Get rid of SSL_CTX_INTERNAL and SSL_INTERNAL.

These are no longer necessary due to SSL_CTX and SSL now being fully
opaque. Merge SSL_CTX_INTERNAL back into SSL_CTX and SSL_INTERNAL back
into SSL.

Prompted by tb@

26 files changed, 1220 insertions, 1237 deletions

diff --git a/src/lib/libssl/bio_ssl.c b/src/lib/libssl/bio_ssl.c
index e86b9d83f2..e78bbc1851 100644
--- a/src/lib/libssl/bio_ssl.c
+++ b/src/lib/libssl/bio_ssl.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: bio_ssl.c,v 1.33 2022/01/14 09:12:53 tb Exp $ */
+/* $OpenBSD: bio_ssl.c,v 1.34 2022/10/02 16:36:41 jsing Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -294,10 +294,10 @@ ssl_ctrl(BIO *b, int cmd, long num, void *ptr)
         case BIO_CTRL_RESET:
                 SSL_shutdown(ssl);
 
-                if (ssl->internal->handshake_func ==
+                if (ssl->handshake_func ==
                     ssl->method->ssl_connect)
                         SSL_set_connect_state(ssl);
-                else if (ssl->internal->handshake_func ==
+                else if (ssl->handshake_func ==
                     ssl->method->ssl_accept)
                         SSL_set_accept_state(ssl);
 
diff --git a/src/lib/libssl/d1_both.c b/src/lib/libssl/d1_both.c
index fd7c07a4d5..4f7f8be6ce 100644
--- a/src/lib/libssl/d1_both.c
+++ b/src/lib/libssl/d1_both.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: d1_both.c,v 1.81 2022/02/05 14:54:10 jsing Exp $ */
+/* $OpenBSD: d1_both.c,v 1.82 2022/10/02 16:36:41 jsing Exp $ */
 /*
  * DTLS implementation written by Nagendra Modadugu
  * (nagendra@cs.stanford.edu) for the OpenSSL project 2005.
@@ -206,7 +206,7 @@ dtls1_hm_fragment_free(hm_fragment *frag)
         free(frag);
 }
 
-/* send s->internal->init_buf in records of type 'type' (SSL3_RT_HANDSHAKE or SSL3_RT_CHANGE_CIPHER_SPEC) */
+/* send s->init_buf in records of type 'type' (SSL3_RT_HANDSHAKE or SSL3_RT_CHANGE_CIPHER_SPEC) */
 int
 dtls1_do_write(SSL *s, int type)
 {
@@ -237,15 +237,15 @@ dtls1_do_write(SSL *s, int type)
         OPENSSL_assert(s->d1->mtu >= dtls1_min_mtu());
         /* should have something reasonable now */
 
-        if (s->internal->init_off == 0  && type == SSL3_RT_HANDSHAKE)
-                OPENSSL_assert(s->internal->init_num ==
+        if (s->init_off == 0  && type == SSL3_RT_HANDSHAKE)
+                OPENSSL_assert(s->init_num ==
                     (int)s->d1->w_msg_hdr.msg_len + DTLS1_HM_HEADER_LENGTH);
 
-        if (!tls12_record_layer_write_overhead(s->internal->rl, &overhead))
+        if (!tls12_record_layer_write_overhead(s->rl, &overhead))
                 return -1;
 
         frag_off = 0;
-        while (s->internal->init_num) {
+        while (s->init_num) {
                 curr_mtu = s->d1->mtu - BIO_wpending(SSL_get_wbio(s)) -
                     DTLS1_RT_HEADER_LENGTH - overhead;
 
@@ -258,22 +258,22 @@ dtls1_do_write(SSL *s, int type)
                             overhead;
                 }
 
-                if (s->internal->init_num > curr_mtu)
+                if (s->init_num > curr_mtu)
                         len = curr_mtu;
                 else
-                        len = s->internal->init_num;
+                        len = s->init_num;
 
                 /* XDTLS: this function is too long.  split out the CCS part */
                 if (type == SSL3_RT_HANDSHAKE) {
-                        if (s->internal->init_off != 0) {
-                                OPENSSL_assert(s->internal->init_off > DTLS1_HM_HEADER_LENGTH);
-                                s->internal->init_off -= DTLS1_HM_HEADER_LENGTH;
-                                s->internal->init_num += DTLS1_HM_HEADER_LENGTH;
+                        if (s->init_off != 0) {
+                                OPENSSL_assert(s->init_off > DTLS1_HM_HEADER_LENGTH);
+                                s->init_off -= DTLS1_HM_HEADER_LENGTH;
+                                s->init_num += DTLS1_HM_HEADER_LENGTH;
 
-                                if (s->internal->init_num > curr_mtu)
+                                if (s->init_num > curr_mtu)
                                         len = curr_mtu;
                                 else
-                                        len = s->internal->init_num;
+                                        len = s->init_num;
                         }
 
                         dtls1_fix_message_header(s, frag_off,
@@ -281,14 +281,14 @@ dtls1_do_write(SSL *s, int type)
 
                         if (!dtls1_write_message_header(&s->d1->w_msg_hdr,
                             s->d1->w_msg_hdr.frag_off, s->d1->w_msg_hdr.frag_len,
-                            (unsigned char *)&s->internal->init_buf->data[s->internal->init_off]))
+                            (unsigned char *)&s->init_buf->data[s->init_off]))
                                 return -1;
 
                         OPENSSL_assert(len >= DTLS1_HM_HEADER_LENGTH);
                 }
 
                 ret = dtls1_write_bytes(s, type,
-                    &s->internal->init_buf->data[s->internal->init_off], len);
+                    &s->init_buf->data[s->init_off], len);
                 if (ret < 0) {
                         /*
                          * Might need to update MTU here, but we don't know
@@ -319,7 +319,7 @@ dtls1_do_write(SSL *s, int type)
                                  * but in that case we'll ignore the result
                                  * anyway
                                  */
-                                unsigned char *p = (unsigned char *)&s->internal->init_buf->data[s->internal->init_off];
+                                unsigned char *p = (unsigned char *)&s->init_buf->data[s->init_off];
                                 const struct hm_header_st *msg_hdr = &s->d1->w_msg_hdr;
                                 int xlen;
 
@@ -340,21 +340,21 @@ dtls1_do_write(SSL *s, int type)
                                 tls1_transcript_record(s, p, xlen);
                         }
 
-                        if (ret == s->internal->init_num) {
-                                if (s->internal->msg_callback)
-                                        s->internal->msg_callback(1, s->version, type,
-                                            s->internal->init_buf->data,
-                                            (size_t)(s->internal->init_off + s->internal->init_num),
-                                            s, s->internal->msg_callback_arg);
+                        if (ret == 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),
+                                            s, s->msg_callback_arg);
 
-                                s->internal->init_off = 0;
+                                s->init_off = 0;
                                 /* done writing this message */
-                                s->internal->init_num = 0;
+                                s->init_num = 0;
 
                                 return (1);
                         }
-                        s->internal->init_off += ret;
-                        s->internal->init_num -= ret;
+                        s->init_off += ret;
+                        s->init_num -= ret;
                         frag_off += (ret -= DTLS1_HM_HEADER_LENGTH);
                 }
         }
@@ -377,7 +377,7 @@ dtls1_get_message(SSL *s, int st1, int stn, int mt, long max)
         int i, al, ok;
 
         /*
-         * s3->internal->tmp is used to store messages that are unexpected, caused
+         * s3->tmp is used to store messages that are unexpected, caused
          * by the absence of an optional handshake message
          */
         if (s->s3->hs.tls12.reuse_message) {
@@ -387,8 +387,8 @@ dtls1_get_message(SSL *s, int st1, int stn, int mt, long max)
                         SSLerror(s, SSL_R_UNEXPECTED_MESSAGE);
                         goto fatal_err;
                 }
-                s->internal->init_msg = s->internal->init_buf->data + DTLS1_HM_HEADER_LENGTH;
-                s->internal->init_num = (int)s->s3->hs.tls12.message_size;
+                s->init_msg = s->init_buf->data + DTLS1_HM_HEADER_LENGTH;
+                s->init_num = (int)s->s3->hs.tls12.message_size;
                 return 1;
         }
 
@@ -403,7 +403,7 @@ dtls1_get_message(SSL *s, int st1, int stn, int mt, long max)
         else if (i <= 0 && !ok)
                 return i;
 
-        p = (unsigned char *)s->internal->init_buf->data;
+        p = (unsigned char *)s->init_buf->data;
         msg_len = msg_hdr->msg_len;
 
         /* reconstruct message header */
@@ -413,9 +413,9 @@ dtls1_get_message(SSL *s, int st1, int stn, int mt, long max)
         msg_len += DTLS1_HM_HEADER_LENGTH;
 
         tls1_transcript_record(s, p, msg_len);
-        if (s->internal->msg_callback)
-                s->internal->msg_callback(0, s->version, SSL3_RT_HANDSHAKE, p, msg_len,
-                    s, s->internal->msg_callback_arg);
+        if (s->msg_callback)
+                s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE, p, msg_len,
+                    s, s->msg_callback_arg);
 
         memset(msg_hdr, 0, sizeof(struct hm_header_st));
 
@@ -423,7 +423,7 @@ dtls1_get_message(SSL *s, int st1, int stn, int mt, long max)
         if (!s->d1->listen)
                 s->d1->handshake_read_seq++;
 
-        s->internal->init_msg = s->internal->init_buf->data + DTLS1_HM_HEADER_LENGTH;
+        s->init_msg = s->init_buf->data + DTLS1_HM_HEADER_LENGTH;
         return 1;
 
  fatal_err:
@@ -457,7 +457,7 @@ dtls1_preprocess_fragment(SSL *s, struct hm_header_st *msg_hdr, int max)
                  * msg_len is limited to 2^24, but is effectively checked
                  * against max above
                  */
-                if (!BUF_MEM_grow_clean(s->internal->init_buf,
+                if (!BUF_MEM_grow_clean(s->init_buf,
                     msg_len + DTLS1_HM_HEADER_LENGTH)) {
                         SSLerror(s, ERR_R_BUF_LIB);
                         return SSL_AD_INTERNAL_ERROR;
@@ -486,8 +486,8 @@ dtls1_retrieve_buffered_fragment(SSL *s, long max, int *ok)
         /*
          * (0) check whether the desired fragment is available
          * if so:
-         * (1) copy over the fragment to s->internal->init_buf->data[]
-         * (2) update s->internal->init_num
+         * (1) copy over the fragment to s->init_buf->data[]
+         * (2) update s->init_num
          */
         pitem *item;
         hm_fragment *frag;
@@ -512,7 +512,7 @@ dtls1_retrieve_buffered_fragment(SSL *s, long max, int *ok)
 
                 if (al == 0) /* no alert */
                 {
-                        unsigned char *p = (unsigned char *)s->internal->init_buf->data + DTLS1_HM_HEADER_LENGTH;
+                        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);
                 }
@@ -526,7 +526,7 @@ dtls1_retrieve_buffered_fragment(SSL *s, long max, int *ok)
                 }
 
                 ssl3_send_alert(s, SSL3_AL_FATAL, al);
-                s->internal->init_num = 0;
+                s->init_num = 0;
                 *ok = 0;
                 return -1;
         } else
@@ -544,8 +544,8 @@ dtls1_max_handshake_message_len(const SSL *s)
         unsigned long max_len;
 
         max_len = DTLS1_HM_HEADER_LENGTH + SSL3_RT_MAX_ENCRYPTED_LENGTH;
-        if (max_len < (unsigned long)s->internal->max_cert_list)
-                return s->internal->max_cert_list;
+        if (max_len < (unsigned long)s->max_cert_list)
+                return s->max_cert_list;
         return max_len;
 }
 
@@ -749,7 +749,7 @@ dtls1_get_message_fragment(SSL *s, int st1, int stn, long max, int *ok)
         /* see if we have the required fragment already */
         if ((frag_len = dtls1_retrieve_buffered_fragment(s, max, ok)) || *ok) {
                 if (*ok)
-                        s->internal->init_num = frag_len;
+                        s->init_num = frag_len;
                 return frag_len;
         }
 
@@ -758,7 +758,7 @@ dtls1_get_message_fragment(SSL *s, int st1, int stn, long max, int *ok)
             DTLS1_HM_HEADER_LENGTH, 0);
         if (i <= 0) {
                 /* nbio, or an error */
-                s->internal->rwstate = SSL_READING;
+                s->rwstate = SSL_READING;
                 *ok = 0;
                 return i;
         }
@@ -797,13 +797,13 @@ dtls1_get_message_fragment(SSL *s, int st1, int stn, long max, int *ok)
                  * 'Finished' MAC.
                  */
                 if (wire[1] == 0 && wire[2] == 0 && wire[3] == 0) {
-                        if (s->internal->msg_callback)
-                                s->internal->msg_callback(0, s->version,
+                        if (s->msg_callback)
+                                s->msg_callback(0, s->version,
                                     SSL3_RT_HANDSHAKE, wire,
                                     DTLS1_HM_HEADER_LENGTH, s,
-                                    s->internal->msg_callback_arg);
+                                    s->msg_callback_arg);
 
-                        s->internal->init_num = 0;
+                        s->init_num = 0;
                         goto again;
                 }
                 else /* Incorrectly formated Hello request */
@@ -821,13 +821,13 @@ dtls1_get_message_fragment(SSL *s, int st1, int stn, long max, int *ok)
         s->s3->hs.state = stn;
 
         if (frag_len > 0) {
-                unsigned char *p = (unsigned char *)s->internal->init_buf->data + DTLS1_HM_HEADER_LENGTH;
+                unsigned char *p = (unsigned char *)s->init_buf->data + DTLS1_HM_HEADER_LENGTH;
 
                 i = s->method->ssl_read_bytes(s, SSL3_RT_HANDSHAKE,
                     &p[frag_off], frag_len, 0);
                 /* XDTLS:  fix this--message fragments cannot span multiple packets */
                 if (i <= 0) {
-                        s->internal->rwstate = SSL_READING;
+                        s->rwstate = SSL_READING;
                         *ok = 0;
                         return i;
                 }
@@ -845,18 +845,18 @@ dtls1_get_message_fragment(SSL *s, int st1, int stn, long max, int *ok)
         }
 
         /*
-         * Note that s->internal->init_num is *not* used as current offset in
-         * s->internal->init_buf->data, but as a counter summing up fragments'
+         * 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.
          */
-        s->internal->init_num = frag_len;
+        s->init_num = frag_len;
         *ok = 1;
         return frag_len;
 
  fatal_err:
         ssl3_send_alert(s, SSL3_AL_FATAL, al);
-        s->internal->init_num = 0;
+        s->init_num = 0;
 
         *ok = 0;
         return (-1);
@@ -948,17 +948,17 @@ dtls1_buffer_message(SSL *s, int is_ccs)
          * This function is called immediately after a message has
          * been serialized
          */
-        OPENSSL_assert(s->internal->init_off == 0);
+        OPENSSL_assert(s->init_off == 0);
 
-        frag = dtls1_hm_fragment_new(s->internal->init_num, 0);
+        frag = dtls1_hm_fragment_new(s->init_num, 0);
         if (frag == NULL)
                 return 0;
 
-        memcpy(frag->fragment, s->internal->init_buf->data, s->internal->init_num);
+        memcpy(frag->fragment, s->init_buf->data, s->init_num);
 
         OPENSSL_assert(s->d1->w_msg_hdr.msg_len +
             (is_ccs ? DTLS1_CCS_HEADER_LENGTH : DTLS1_HM_HEADER_LENGTH) ==
-            (unsigned int)s->internal->init_num);
+            (unsigned int)s->init_num);
 
         frag->msg_header.msg_len = s->d1->w_msg_hdr.msg_len;
         frag->msg_header.seq = s->d1->w_msg_hdr.seq;
@@ -970,7 +970,7 @@ dtls1_buffer_message(SSL *s, int is_ccs)
         /* save current state*/
         frag->msg_header.saved_retransmit_state.session = s->session;
         frag->msg_header.saved_retransmit_state.epoch =
-            tls12_record_layer_write_epoch(s->internal->rl);
+            tls12_record_layer_write_epoch(s->rl);
 
         memset(seq64be, 0, sizeof(seq64be));
         seq64be[6] = (unsigned char)(dtls1_get_queue_priority(
@@ -1001,8 +1001,8 @@ dtls1_retransmit_message(SSL *s, unsigned short seq, unsigned long frag_off,
         struct dtls1_retransmit_state saved_state;
 
         /*
-          OPENSSL_assert(s->internal->init_num == 0);
-          OPENSSL_assert(s->internal->init_off == 0);
+          OPENSSL_assert(s->init_num == 0);
+          OPENSSL_assert(s->init_off == 0);
          */
 
         /* XDTLS:  the requested message ought to be found, otherwise error */
@@ -1027,9 +1027,9 @@ dtls1_retransmit_message(SSL *s, unsigned short seq, unsigned long frag_off,
         else
                 header_length = DTLS1_HM_HEADER_LENGTH;
 
-        memcpy(s->internal->init_buf->data, frag->fragment,
+        memcpy(s->init_buf->data, frag->fragment,
             frag->msg_header.msg_len + header_length);
-        s->internal->init_num = 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,
@@ -1037,13 +1037,13 @@ dtls1_retransmit_message(SSL *s, unsigned short seq, unsigned long frag_off,
 
         /* save current state */
         saved_state.session = s->session;
-        saved_state.epoch = tls12_record_layer_write_epoch(s->internal->rl);
+        saved_state.epoch = tls12_record_layer_write_epoch(s->rl);
 
         s->d1->retransmitting = 1;
 
         /* restore state in which the message was originally sent */
         s->session = frag->msg_header.saved_retransmit_state.session;
-        if (!tls12_record_layer_use_write_epoch(s->internal->rl,
+        if (!tls12_record_layer_use_write_epoch(s->rl,
             frag->msg_header.saved_retransmit_state.epoch))
                 return 0;
 
@@ -1052,7 +1052,7 @@ dtls1_retransmit_message(SSL *s, unsigned short seq, unsigned long frag_off,
 
         /* restore current state */
         s->session = saved_state.session;
-        if (!tls12_record_layer_use_write_epoch(s->internal->rl,
+        if (!tls12_record_layer_use_write_epoch(s->rl,
             saved_state.epoch))
                 return 0;
 
@@ -1073,7 +1073,7 @@ dtls1_clear_record_buffer(SSL *s)
             item = pqueue_pop(s->d1->sent_messages)) {
                 frag = item->data;
                 if (frag->msg_header.is_ccs)
-                        tls12_record_layer_write_epoch_done(s->internal->rl,
+                        tls12_record_layer_write_epoch_done(s->rl,
                             frag->msg_header.saved_retransmit_state.epoch);
                 dtls1_hm_fragment_free(frag);
                 pitem_free(item);
diff --git a/src/lib/libssl/d1_lib.c b/src/lib/libssl/d1_lib.c
index 770734e6ff..cf4c5100d5 100644
--- a/src/lib/libssl/d1_lib.c
+++ b/src/lib/libssl/d1_lib.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: d1_lib.c,v 1.61 2021/10/23 13:36:03 jsing Exp $ */
+/* $OpenBSD: d1_lib.c,v 1.62 2022/10/02 16:36:41 jsing Exp $ */
 /*
  * DTLS implementation written by Nagendra Modadugu
  * (nagendra@cs.stanford.edu) for the OpenSSL project 2005.
@@ -187,7 +187,7 @@ dtls1_clear(SSL *s)
                 memset(s->d1, 0, sizeof(*s->d1));
 
                 s->d1->unprocessed_rcds.epoch =
-                    tls12_record_layer_read_epoch(s->internal->rl) + 1;
+                    tls12_record_layer_read_epoch(s->rl) + 1;
 
                 if (s->server) {
                         s->d1->cookie_len = sizeof(s->d1->cookie);
diff --git a/src/lib/libssl/d1_pkt.c b/src/lib/libssl/d1_pkt.c
index 456f871a43..1431434ba8 100644
--- a/src/lib/libssl/d1_pkt.c
+++ b/src/lib/libssl/d1_pkt.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: d1_pkt.c,v 1.123 2022/03/26 15:05:53 jsing Exp $ */
+/* $OpenBSD: d1_pkt.c,v 1.124 2022/10/02 16:36:41 jsing Exp $ */
 /*
  * DTLS implementation written by Nagendra Modadugu
  * (nagendra@cs.stanford.edu) for the OpenSSL project 2005.
@@ -193,8 +193,8 @@ dtls1_copy_record(SSL *s, DTLS1_RECORD_DATA_INTERNAL *rdata)
 {
         ssl3_release_buffer(&s->s3->rbuf);
 
-        s->internal->packet = rdata->packet;
-        s->internal->packet_length = rdata->packet_length;
+        s->packet = rdata->packet;
+        s->packet_length = rdata->packet_length;
         memcpy(&(s->s3->rbuf), &(rdata->rbuf), sizeof(SSL3_BUFFER_INTERNAL));
         memcpy(&(s->s3->rrec), &(rdata->rrec), sizeof(SSL3_RECORD_INTERNAL));
 
@@ -216,15 +216,15 @@ dtls1_buffer_record(SSL *s, record_pqueue *queue, unsigned char *priority)
         if (rdata == NULL || item == NULL)
                 goto init_err;
 
-        rdata->packet = s->internal->packet;
-        rdata->packet_length = s->internal->packet_length;
+        rdata->packet = s->packet;
+        rdata->packet_length = s->packet_length;
         memcpy(&(rdata->rbuf), &(s->s3->rbuf), sizeof(SSL3_BUFFER_INTERNAL));
         memcpy(&(rdata->rrec), &(s->s3->rrec), sizeof(SSL3_RECORD_INTERNAL));
 
         item->data = rdata;
 
-        s->internal->packet = NULL;
-        s->internal->packet_length = 0;
+        s->packet = NULL;
+        s->packet_length = 0;
         memset(&(s->s3->rbuf), 0, sizeof(SSL3_BUFFER_INTERNAL));
         memset(&(s->s3->rrec), 0, sizeof(SSL3_RECORD_INTERNAL));
 
@@ -271,13 +271,13 @@ dtls1_process_buffered_record(SSL *s)
 {
         /* Check if epoch is current. */
         if (s->d1->unprocessed_rcds.epoch !=
-            tls12_record_layer_read_epoch(s->internal->rl))
+            tls12_record_layer_read_epoch(s->rl))
                 return (0);
 
         /* Update epoch once all unprocessed records have been processed. */
         if (pqueue_peek(s->d1->unprocessed_rcds.q) == NULL) {
                 s->d1->unprocessed_rcds.epoch =
-                    tls12_record_layer_read_epoch(s->internal->rl) + 1;
+                    tls12_record_layer_read_epoch(s->rl) + 1;
                 return (0);
         }
 
@@ -298,11 +298,11 @@ dtls1_process_record(SSL *s)
         uint8_t *out;
         size_t out_len;
 
-        tls12_record_layer_set_version(s->internal->rl, s->version);
+        tls12_record_layer_set_version(s->rl, s->version);
 
-        if (!tls12_record_layer_open_record(s->internal->rl, s->internal->packet,
-            s->internal->packet_length, &out, &out_len)) {
-                tls12_record_layer_alert(s->internal->rl, &alert_desc);
+        if (!tls12_record_layer_open_record(s->rl, s->packet,
+            s->packet_length, &out, &out_len)) {
+                tls12_record_layer_alert(s->rl, &alert_desc);
 
                 if (alert_desc == 0)
                         goto err;
@@ -327,7 +327,7 @@ dtls1_process_record(SSL *s)
         rr->length = out_len;
         rr->off = 0;
 
-        s->internal->packet_length = 0;
+        s->packet_length = 0;
 
         return (1);
 
@@ -341,9 +341,9 @@ dtls1_process_record(SSL *s)
  * 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->internal->rrec.type    - is the type of record
- * ssl->s3->internal->rrec.data,         - data
- * ssl->s3->internal->rrec.length, - number of bytes
+ * ssl->s3->rrec.type    - is the type of record
+ * ssl->s3->rrec.data,   - data
+ * ssl->s3->rrec.length, - number of bytes
  */
 /* used only by dtls1_read_bytes */
 int
@@ -364,12 +364,12 @@ dtls1_get_record(SSL *s)
  again:
                 /* dump this record on all retries */
                 rr->length = 0;
-                s->internal->packet_length = 0;
+                s->packet_length = 0;
         }
 
         /* check if we have the header */
-        if ((s->internal->rstate != SSL_ST_READ_BODY) ||
-            (s->internal->packet_length < DTLS1_RT_HEADER_LENGTH)) {
+        if ((s->rstate != SSL_ST_READ_BODY) ||
+            (s->packet_length < DTLS1_RT_HEADER_LENGTH)) {
                 CBS header, seq_no;
                 uint16_t epoch, len, ssl_version;
                 uint8_t type;
@@ -382,9 +382,9 @@ dtls1_get_record(SSL *s)
                 if (n != DTLS1_RT_HEADER_LENGTH)
                         goto again;
 
-                s->internal->rstate = SSL_ST_READ_BODY;
+                s->rstate = SSL_ST_READ_BODY;
 
-                CBS_init(&header, s->internal->packet, s->internal->packet_length);
+                CBS_init(&header, s->packet, s->packet_length);
 
                 /* Pull apart the header into the DTLS1_RECORD */
                 if (!CBS_get_u8(&header, &type))
@@ -409,7 +409,7 @@ dtls1_get_record(SSL *s)
                 rr->length = len;
 
                 /* unexpected version, silently discard */
-                if (!s->internal->first_packet && ssl_version != s->version)
+                if (!s->first_packet && ssl_version != s->version)
                         goto again;
 
                 /* wrong version, silently discard record */
@@ -420,11 +420,11 @@ dtls1_get_record(SSL *s)
                 if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH)
                         goto again;
 
-                /* now s->internal->rstate == SSL_ST_READ_BODY */
+                /* now s->rstate == SSL_ST_READ_BODY */
                 p = (unsigned char *)CBS_data(&header);
         }
 
-        /* s->internal->rstate == SSL_ST_READ_BODY, get and decode the data */
+        /* s->rstate == SSL_ST_READ_BODY, get and decode the data */
 
         n = ssl3_packet_extend(s, DTLS1_RT_HEADER_LENGTH + rr->length);
         if (n <= 0)
@@ -434,7 +434,7 @@ dtls1_get_record(SSL *s)
         if (n != DTLS1_RT_HEADER_LENGTH + rr->length)
                 goto again;
 
-        s->internal->rstate = SSL_ST_READ_HEADER; /* set state for later operations */
+        s->rstate = SSL_ST_READ_HEADER; /* set state for later operations */
 
         /* match epochs.  NULL means the packet is dropped on the floor */
         bitmap = dtls1_get_bitmap(s, rr, &is_next_epoch);
@@ -463,7 +463,7 @@ dtls1_get_record(SSL *s)
          * anything while listening.
          */
         if (is_next_epoch) {
-                if ((SSL_in_init(s) || s->internal->in_handshake) && !s->d1->listen) {
+                if ((SSL_in_init(s) || s->in_handshake) && !s->d1->listen) {
                         if (dtls1_buffer_record(s, &(s->d1->unprocessed_rcds),
                             rr->seq_num) < 0)
                                 return (-1);
@@ -490,7 +490,7 @@ dtls1_read_handshake_unexpected(SSL *s)
         CBS cbs;
         int ret;
 
-        if (s->internal->in_handshake) {
+        if (s->in_handshake) {
                 SSLerror(s, ERR_R_INTERNAL_ERROR);
                 return -1;
         }
@@ -506,7 +506,7 @@ dtls1_read_handshake_unexpected(SSL *s)
                 return -1; /* XXX - probably should drop/continue. */
 
         /* This may just be a stale retransmit. */
-        if (rr->epoch != tls12_record_layer_read_epoch(s->internal->rl)) {
+        if (rr->epoch != tls12_record_layer_read_epoch(s->rl)) {
                 rr->length = 0;
                 return 1;
         }
@@ -556,7 +556,7 @@ dtls1_read_handshake_unexpected(SSL *s)
                 s->d1->handshake_read_seq++;
 
                 /* XXX - why is this set here but not in ssl3? */
-                s->internal->new_session = 1;
+                s->new_session = 1;
 
                 if (!ssl3_renegotiate(s))
                         return 1;
@@ -589,7 +589,7 @@ dtls1_read_handshake_unexpected(SSL *s)
                         return -1;
                 }
 
-                if ((s->internal->options & SSL_OP_NO_CLIENT_RENEGOTIATION) != 0) {
+                if ((s->options & SSL_OP_NO_CLIENT_RENEGOTIATION) != 0) {
                         ssl3_send_alert(s, SSL3_AL_FATAL,
                             SSL_AD_NO_RENEGOTIATION);
                         return -1;
@@ -609,8 +609,8 @@ dtls1_read_handshake_unexpected(SSL *s)
                 }
 
                 s->s3->hs.state = SSL_ST_ACCEPT;
-                s->internal->renegotiate = 1;
-                s->internal->new_session = 1;
+                s->renegotiate = 1;
+                s->new_session = 1;
 
         } else if (hs_msg_hdr.type == SSL3_MT_FINISHED && s->server) {
                 /*
@@ -634,14 +634,14 @@ dtls1_read_handshake_unexpected(SSL *s)
                 return -1;
         }
 
-        if ((ret = s->internal->handshake_func(s)) < 0)
+        if ((ret = s->handshake_func(s)) < 0)
                 return ret;
         if (ret == 0) {
                 SSLerror(s, SSL_R_SSL_HANDSHAKE_FAILURE);
                 return -1;
         }
 
-        if (!(s->internal->mode & SSL_MODE_AUTO_RETRY)) {
+        if (!(s->mode & SSL_MODE_AUTO_RETRY)) {
                 if (s->s3->rbuf.left == 0) {
                         ssl_force_want_read(s);
                         return -1;
@@ -710,8 +710,8 @@ dtls1_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek)
                 return -1;
         }
 
-        if (SSL_in_init(s) && !s->internal->in_handshake) {
-                if ((ret = s->internal->handshake_func(s)) < 0)
+        if (SSL_in_init(s) && !s->in_handshake) {
+                if ((ret = s->handshake_func(s)) < 0)
                         return ret;
                 if (ret == 0) {
                         SSLerror(s, SSL_R_SSL_HANDSHAKE_FAILURE);
@@ -733,7 +733,7 @@ dtls1_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek)
                 return -1;
         }
 
-        s->internal->rwstate = SSL_NOTHING;
+        s->rwstate = SSL_NOTHING;
 
         rr = &s->s3->rrec;
 
@@ -747,7 +747,7 @@ dtls1_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek)
         if (dtls1_handle_timeout(s) > 0)
                 goto start;
 
-        if (rr->length == 0 || s->internal->rstate == SSL_ST_READ_BODY) {
+        if (rr->length == 0 || s->rstate == SSL_ST_READ_BODY) {
                 if ((ret = dtls1_get_record(s)) <= 0) {
                         /* Anything other than a timeout is an error. */
                         if ((ret = dtls1_read_failed(s, ret)) <= 0)
@@ -783,8 +783,8 @@ dtls1_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek)
          * If the other end has shut down, throw anything we read away (even in
          * 'peek' mode).
          */
-        if (s->internal->shutdown & SSL_RECEIVED_SHUTDOWN) {
-                s->internal->rwstate = SSL_NOTHING;
+        if (s->shutdown & SSL_RECEIVED_SHUTDOWN) {
+                s->rwstate = SSL_NOTHING;
                 rr->length = 0;
                 return 0;
         }
@@ -796,7 +796,7 @@ dtls1_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek)
                  * are doing a handshake for the first time.
                  */
                 if (SSL_in_init(s) && type == SSL3_RT_APPLICATION_DATA &&
-                    !tls12_record_layer_read_protected(s->internal->rl)) {
+                    !tls12_record_layer_read_protected(s->rl)) {
                         SSLerror(s, SSL_R_APP_DATA_IN_HANDSHAKE);
                         ssl3_send_alert(s, SSL3_AL_FATAL,
                             SSL_AD_UNEXPECTED_MESSAGE);
@@ -817,7 +817,7 @@ dtls1_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek)
                         rr->length -= n;
                         rr->off += n;
                         if (rr->length == 0) {
-                                s->internal->rstate = SSL_ST_READ_HEADER;
+                                s->rstate = SSL_ST_READ_HEADER;
                                 rr->off = 0;
                         }
                 }
@@ -836,8 +836,8 @@ dtls1_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek)
                 goto start;
         }
 
-        if (s->internal->shutdown & SSL_SENT_SHUTDOWN) {
-                s->internal->rwstate = SSL_NOTHING;
+        if (s->shutdown & SSL_SENT_SHUTDOWN) {
+                s->rwstate = SSL_NOTHING;
                 rr->length = 0;
                 return (0);
         }
@@ -891,9 +891,9 @@ dtls1_write_app_data_bytes(SSL *s, int type, const void *buf_, int len)
 {
         int i;
 
-        if (SSL_in_init(s) && !s->internal->in_handshake)
+        if (SSL_in_init(s) && !s->in_handshake)
         {
-                i = s->internal->handshake_func(s);
+                i = s->handshake_func(s);
                 if (i < 0)
                         return (i);
                 if (i == 0) {
@@ -920,7 +920,7 @@ dtls1_write_bytes(SSL *s, int type, const void *buf, int len)
         int i;
 
         OPENSSL_assert(len <= SSL3_RT_MAX_PLAIN_LENGTH);
-        s->internal->rwstate = SSL_NOTHING;
+        s->rwstate = SSL_NOTHING;
         i = do_dtls1_write(s, type, buf, len);
         return i;
 }
@@ -959,9 +959,9 @@ do_dtls1_write(SSL *s, int type, const unsigned char *buf, unsigned int len)
         if (!CBB_init_fixed(&cbb, wb->buf, wb->len))
                 goto err;
 
-        tls12_record_layer_set_version(s->internal->rl, s->version);
+        tls12_record_layer_set_version(s->rl, s->version);
 
-        if (!tls12_record_layer_seal_record(s->internal->rl, type, buf, len, &cbb))
+        if (!tls12_record_layer_seal_record(s->rl, type, buf, len, &cbb))
                 goto err;
 
         if (!CBB_finish(&cbb, NULL, &out_len))
@@ -1035,7 +1035,7 @@ dtls1_get_bitmap(SSL *s, SSL3_RECORD_INTERNAL *rr, unsigned int *is_next_epoch)
 
         *is_next_epoch = 0;
 
-        read_epoch = tls12_record_layer_read_epoch(s->internal->rl);
+        read_epoch = tls12_record_layer_read_epoch(s->rl);
         read_epoch_next = read_epoch + 1;
 
         /* In current epoch, accept HM, CCS, DATA, & ALERT */
diff --git a/src/lib/libssl/d1_srtp.c b/src/lib/libssl/d1_srtp.c
index 793fa868d7..1c23409736 100644
--- a/src/lib/libssl/d1_srtp.c
+++ b/src/lib/libssl/d1_srtp.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: d1_srtp.c,v 1.30 2022/01/28 13:11:56 inoguchi Exp $ */
+/* $OpenBSD: d1_srtp.c,v 1.31 2022/10/02 16:36:41 jsing Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -227,13 +227,13 @@ ssl_ctx_make_profiles(const char *profiles_string,
 int
 SSL_CTX_set_tlsext_use_srtp(SSL_CTX *ctx, const char *profiles)
 {
-        return ssl_ctx_make_profiles(profiles, &ctx->internal->srtp_profiles);
+        return ssl_ctx_make_profiles(profiles, &ctx->srtp_profiles);
 }
 
 int
 SSL_set_tlsext_use_srtp(SSL *s, const char *profiles)
 {
-        return ssl_ctx_make_profiles(profiles, &s->internal->srtp_profiles);
+        return ssl_ctx_make_profiles(profiles, &s->srtp_profiles);
 }
 
 
@@ -241,11 +241,11 @@ STACK_OF(SRTP_PROTECTION_PROFILE) *
 SSL_get_srtp_profiles(SSL *s)
 {
         if (s != NULL) {
-                if (s->internal->srtp_profiles != NULL) {
-                        return s->internal->srtp_profiles;
+                if (s->srtp_profiles != NULL) {
+                        return s->srtp_profiles;
                 } else if ((s->ctx != NULL) &&
-                    (s->ctx->internal->srtp_profiles != NULL)) {
-                        return s->ctx->internal->srtp_profiles;
+                    (s->ctx->srtp_profiles != NULL)) {
+                        return s->ctx->srtp_profiles;
                 }
         }
 
@@ -256,7 +256,7 @@ SRTP_PROTECTION_PROFILE *
 SSL_get_selected_srtp_profile(SSL *s)
 {
         /* XXX cast away the const */
-        return (SRTP_PROTECTION_PROFILE *)s->internal->srtp_profile;
+        return (SRTP_PROTECTION_PROFILE *)s->srtp_profile;
 }
 
 #endif
diff --git a/src/lib/libssl/s3_lib.c b/src/lib/libssl/s3_lib.c
index 989165b207..52ad16a697 100644
--- a/src/lib/libssl/s3_lib.c
+++ b/src/lib/libssl/s3_lib.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: s3_lib.c,v 1.238 2022/08/21 19:39:44 jsing Exp $ */
+/* $OpenBSD: s3_lib.c,v 1.239 2022/10/02 16:36:41 jsing Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -1441,7 +1441,7 @@ ssl3_cipher_get_value(const SSL_CIPHER *c)
 int
 ssl3_pending(const SSL *s)
 {
-        if (s->internal->rstate == SSL_ST_READ_BODY)
+        if (s->rstate == SSL_ST_READ_BODY)
                 return 0;
 
         return (s->s3->rrec.type == SSL3_RT_APPLICATION_DATA) ?
@@ -1493,13 +1493,13 @@ ssl3_handshake_msg_finish(SSL *s, CBB *handshake)
         if (outlen > INT_MAX)
                 goto err;
 
-        if (!BUF_MEM_grow_clean(s->internal->init_buf, outlen))
+        if (!BUF_MEM_grow_clean(s->init_buf, outlen))
                 goto err;
 
-        memcpy(s->internal->init_buf->data, data, outlen);
+        memcpy(s->init_buf->data, data, outlen);
 
-        s->internal->init_num = (int)outlen;
-        s->internal->init_off = 0;
+        s->init_num = (int)outlen;
+        s->init_off = 0;
 
         if (SSL_is_dtls(s)) {
                 unsigned long len;
@@ -1572,7 +1572,7 @@ ssl3_free(SSL *s)
         tls_buffer_free(s->s3->hs.tls13.quic_read_buffer);
 
         sk_X509_NAME_pop_free(s->s3->hs.tls12.ca_names, X509_NAME_free);
-        sk_X509_pop_free(s->internal->verified_chain, X509_free);
+        sk_X509_pop_free(s->verified_chain, X509_free);
 
         tls1_transcript_free(s);
         tls1_transcript_hash_free(s);
@@ -1595,8 +1595,8 @@ ssl3_clear(SSL *s)
 
         tls1_cleanup_key_block(s);
         sk_X509_NAME_pop_free(s->s3->hs.tls12.ca_names, X509_NAME_free);
-        sk_X509_pop_free(s->internal->verified_chain, X509_free);
-        s->internal->verified_chain = NULL;
+        sk_X509_pop_free(s->verified_chain, X509_free);
+        s->verified_chain = NULL;
 
         freezero(s->s3->hs.sigalgs, s->s3->hs.sigalgs_len);
         s->s3->hs.sigalgs = NULL;
@@ -1656,7 +1656,7 @@ ssl3_clear(SSL *s)
         s->s3->num_renegotiations = 0;
         s->s3->in_read_app_data = 0;
 
-        s->internal->packet_length = 0;
+        s->packet_length = 0;
         s->version = TLS1_VERSION;
 
         s->s3->hs.state = SSL_ST_BEFORE|((s->server) ? SSL_ST_ACCEPT : SSL_ST_CONNECT);
@@ -1725,7 +1725,7 @@ _SSL_get_peer_tmp_key(SSL *s, EVP_PKEY **key)
 static int
 _SSL_session_reused(SSL *s)
 {
-        return s->internal->hit;
+        return s->hit;
 }
 
 static int
@@ -1834,7 +1834,7 @@ _SSL_set_tlsext_host_name(SSL *s, const char *name)
 static int
 _SSL_set_tlsext_debug_arg(SSL *s, void *arg)
 {
-        s->internal->tlsext_debug_arg = arg;
+        s->tlsext_debug_arg = arg;
         return 1;
 }
 
@@ -1854,7 +1854,7 @@ _SSL_set_tlsext_status_type(SSL *s, int type)
 static int
 _SSL_get_tlsext_status_exts(SSL *s, STACK_OF(X509_EXTENSION) **exts)
 {
-        *exts = s->internal->tlsext_ocsp_exts;
+        *exts = s->tlsext_ocsp_exts;
         return 1;
 }
 
@@ -1862,14 +1862,14 @@ static int
 _SSL_set_tlsext_status_exts(SSL *s, STACK_OF(X509_EXTENSION) *exts)
 {
         /* XXX - leak... */
-        s->internal->tlsext_ocsp_exts = exts;
+        s->tlsext_ocsp_exts = exts;
         return 1;
 }
 
 static int
 _SSL_get_tlsext_status_ids(SSL *s, STACK_OF(OCSP_RESPID) **ids)
 {
-        *ids = s->internal->tlsext_ocsp_ids;
+        *ids = s->tlsext_ocsp_ids;
         return 1;
 }
 
@@ -1877,17 +1877,17 @@ static int
 _SSL_set_tlsext_status_ids(SSL *s, STACK_OF(OCSP_RESPID) *ids)
 {
         /* XXX - leak... */
-        s->internal->tlsext_ocsp_ids = ids;
+        s->tlsext_ocsp_ids = ids;
         return 1;
 }
 
 static int
 _SSL_get_tlsext_status_ocsp_resp(SSL *s, unsigned char **resp)
 {
-        if (s->internal->tlsext_ocsp_resp != NULL &&
-            s->internal->tlsext_ocsp_resp_len < INT_MAX) {
-                *resp = s->internal->tlsext_ocsp_resp;
-                return (int)s->internal->tlsext_ocsp_resp_len;
+        if (s->tlsext_ocsp_resp != NULL &&
+            s->tlsext_ocsp_resp_len < INT_MAX) {
+                *resp = s->tlsext_ocsp_resp;
+                return (int)s->tlsext_ocsp_resp_len;
         }
 
         *resp = NULL;
@@ -1898,15 +1898,15 @@ _SSL_get_tlsext_status_ocsp_resp(SSL *s, unsigned char **resp)
 static int
 _SSL_set_tlsext_status_ocsp_resp(SSL *s, unsigned char *resp, int resp_len)
 {
-        free(s->internal->tlsext_ocsp_resp);
-        s->internal->tlsext_ocsp_resp = NULL;
-        s->internal->tlsext_ocsp_resp_len = 0;
+        free(s->tlsext_ocsp_resp);
+        s->tlsext_ocsp_resp = NULL;
+        s->tlsext_ocsp_resp_len = 0;
 
         if (resp_len < 0)
                 return 0;
 
-        s->internal->tlsext_ocsp_resp = resp;
-        s->internal->tlsext_ocsp_resp_len = (size_t)resp_len;
+        s->tlsext_ocsp_resp = resp;
+        s->tlsext_ocsp_resp_len = (size_t)resp_len;
 
         return 1;
 }
@@ -1955,15 +1955,15 @@ SSL_clear_chain_certs(SSL *ssl)
 int
 SSL_set1_groups(SSL *s, const int *groups, size_t groups_len)
 {
-        return tls1_set_groups(&s->internal->tlsext_supportedgroups,
-            &s->internal->tlsext_supportedgroups_length, groups, groups_len);
+        return tls1_set_groups(&s->tlsext_supportedgroups,
+            &s->tlsext_supportedgroups_length, groups, groups_len);
 }
 
 int
 SSL_set1_groups_list(SSL *s, const char *groups)
 {
-        return tls1_set_group_list(&s->internal->tlsext_supportedgroups,
-            &s->internal->tlsext_supportedgroups_length, groups);
+        return tls1_set_group_list(&s->tlsext_supportedgroups,
+            &s->tlsext_supportedgroups_length, groups);
 }
 
 static int
@@ -2183,7 +2183,7 @@ ssl3_callback_ctrl(SSL *s, int cmd, void (*fp)(void))
                 return 1;
 
         case SSL_CTRL_SET_TLSEXT_DEBUG_CB:
-                s->internal->tlsext_debug_cb = (void (*)(SSL *, int , int,
+                s->tlsext_debug_cb = (void (*)(SSL *, int , int,
                     unsigned char *, int, void *))fp;
                 return 1;
         }
@@ -2211,8 +2211,8 @@ _SSL_CTX_set_tmp_dh(SSL_CTX *ctx, DH *dh)
                 return 0;
         }
 
-        DH_free(ctx->internal->cert->dhe_params);
-        ctx->internal->cert->dhe_params = dhe_params;
+        DH_free(ctx->cert->dhe_params);
+        ctx->cert->dhe_params = dhe_params;
 
         return 1;
 }
@@ -2220,7 +2220,7 @@ _SSL_CTX_set_tmp_dh(SSL_CTX *ctx, DH *dh)
 static int
 _SSL_CTX_set_dh_auto(SSL_CTX *ctx, int state)
 {
-        ctx->internal->cert->dhe_params_auto = state;
+        ctx->cert->dhe_params_auto = state;
         return 1;
 }
 
@@ -2248,7 +2248,7 @@ _SSL_CTX_set_ecdh_auto(SSL_CTX *ctx, int state)
 static int
 _SSL_CTX_set_tlsext_servername_arg(SSL_CTX *ctx, void *arg)
 {
-        ctx->internal->tlsext_servername_arg = arg;
+        ctx->tlsext_servername_arg = arg;
         return 1;
 }
 
@@ -2263,9 +2263,9 @@ _SSL_CTX_get_tlsext_ticket_keys(SSL_CTX *ctx, unsigned char *keys, int keys_len)
                 return 0;
         }
 
-        memcpy(keys, ctx->internal->tlsext_tick_key_name, 16);
-        memcpy(keys + 16, ctx->internal->tlsext_tick_hmac_key, 16);
-        memcpy(keys + 32, ctx->internal->tlsext_tick_aes_key, 16);
+        memcpy(keys, ctx->tlsext_tick_key_name, 16);
+        memcpy(keys + 16, ctx->tlsext_tick_hmac_key, 16);
+        memcpy(keys + 32, ctx->tlsext_tick_aes_key, 16);
 
         return 1;
 }
@@ -2281,9 +2281,9 @@ _SSL_CTX_set_tlsext_ticket_keys(SSL_CTX *ctx, unsigned char *keys, int keys_len)
                 return 0;
         }
 
-        memcpy(ctx->internal->tlsext_tick_key_name, keys, 16);
-        memcpy(ctx->internal->tlsext_tick_hmac_key, keys + 16, 16);
-        memcpy(ctx->internal->tlsext_tick_aes_key, keys + 32, 16);
+        memcpy(ctx->tlsext_tick_key_name, keys, 16);
+        memcpy(ctx->tlsext_tick_hmac_key, keys + 16, 16);
+        memcpy(ctx->tlsext_tick_aes_key, keys + 32, 16);
 
         return 1;
 }
@@ -2291,14 +2291,14 @@ _SSL_CTX_set_tlsext_ticket_keys(SSL_CTX *ctx, unsigned char *keys, int keys_len)
 static int
 _SSL_CTX_get_tlsext_status_arg(SSL_CTX *ctx, void **arg)
 {
-        *arg = ctx->internal->tlsext_status_arg;
+        *arg = ctx->tlsext_status_arg;
         return 1;
 }
 
 static int
 _SSL_CTX_set_tlsext_status_arg(SSL_CTX *ctx, void *arg)
 {
-        ctx->internal->tlsext_status_arg = arg;
+        ctx->tlsext_status_arg = arg;
         return 1;
 }
 
@@ -2331,8 +2331,8 @@ SSL_CTX_get0_chain_certs(const SSL_CTX *ctx, STACK_OF(X509) **out_chain)
 {
         *out_chain = NULL;
 
-        if (ctx->internal->cert->key != NULL)
-                *out_chain = ctx->internal->cert->key->chain;
+        if (ctx->cert->key != NULL)
+                *out_chain = ctx->cert->key->chain;
 
         return 1;
 }
@@ -2361,7 +2361,7 @@ _SSL_CTX_get_extra_chain_certs(SSL_CTX *ctx, STACK_OF(X509) **certs)
 {
         *certs = ctx->extra_certs;
         if (*certs == NULL)
-                *certs = ctx->internal->cert->key->chain;
+                *certs = ctx->cert->key->chain;
 
         return 1;
 }
@@ -2384,15 +2384,15 @@ _SSL_CTX_clear_extra_chain_certs(SSL_CTX *ctx)
 int
 SSL_CTX_set1_groups(SSL_CTX *ctx, const int *groups, size_t groups_len)
 {
-        return tls1_set_groups(&ctx->internal->tlsext_supportedgroups,
-            &ctx->internal->tlsext_supportedgroups_length, groups, groups_len);
+        return tls1_set_groups(&ctx->tlsext_supportedgroups,
+            &ctx->tlsext_supportedgroups_length, groups, groups_len);
 }
 
 int
 SSL_CTX_set1_groups_list(SSL_CTX *ctx, const char *groups)
 {
-        return tls1_set_group_list(&ctx->internal->tlsext_supportedgroups,
-            &ctx->internal->tlsext_supportedgroups_length, groups);
+        return tls1_set_group_list(&ctx->tlsext_supportedgroups,
+            &ctx->tlsext_supportedgroups_length, groups);
 }
 
 long
@@ -2507,7 +2507,7 @@ ssl3_ctx_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp)(void))
                 return 0;
 
         case SSL_CTRL_SET_TMP_DH_CB:
-                ctx->internal->cert->dhe_params_cb =
+                ctx->cert->dhe_params_cb =
                     (DH *(*)(SSL *, int, int))fp;
                 return 1;
 
@@ -2515,20 +2515,20 @@ ssl3_ctx_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp)(void))
                 return 1;
 
         case SSL_CTRL_SET_TLSEXT_SERVERNAME_CB:
-                ctx->internal->tlsext_servername_callback =
+                ctx->tlsext_servername_callback =
                     (int (*)(SSL *, int *, void *))fp;
                 return 1;
 
         case SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB:
-                *(int (**)(SSL *, void *))fp = ctx->internal->tlsext_status_cb;
+                *(int (**)(SSL *, void *))fp = ctx->tlsext_status_cb;
                 return 1;
 
         case SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB:
-                ctx->internal->tlsext_status_cb = (int (*)(SSL *, void *))fp;
+                ctx->tlsext_status_cb = (int (*)(SSL *, void *))fp;
                 return 1;
 
         case SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB:
-                ctx->internal->tlsext_ticket_key_cb = (int (*)(SSL *, unsigned char  *,
+                ctx->tlsext_ticket_key_cb = (int (*)(SSL *, unsigned char  *,
                     unsigned char *, EVP_CIPHER_CTX *, HMAC_CTX *, int))fp;
                 return 1;
         }
@@ -2559,7 +2559,7 @@ ssl3_choose_cipher(SSL *s, STACK_OF(SSL_CIPHER) *clnt,
          * but would have to pay with the price of sk_SSL_CIPHER_dup().
          */
 
-        if (s->internal->options & SSL_OP_CIPHER_SERVER_PREFERENCE) {
+        if (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE) {
                 prio = srvr;
                 allow = clnt;
         } else {
@@ -2670,13 +2670,13 @@ ssl3_shutdown(SSL *s)
          * Don't do anything much if we have not done the handshake or
          * we don't want to send messages :-)
          */
-        if ((s->internal->quiet_shutdown) || (s->s3->hs.state == SSL_ST_BEFORE)) {
-                s->internal->shutdown = (SSL_SENT_SHUTDOWN|SSL_RECEIVED_SHUTDOWN);
+        if ((s->quiet_shutdown) || (s->s3->hs.state == SSL_ST_BEFORE)) {
+                s->shutdown = (SSL_SENT_SHUTDOWN|SSL_RECEIVED_SHUTDOWN);
                 return (1);
         }
 
-        if (!(s->internal->shutdown & SSL_SENT_SHUTDOWN)) {
-                s->internal->shutdown|=SSL_SENT_SHUTDOWN;
+        if (!(s->shutdown & SSL_SENT_SHUTDOWN)) {
+                s->shutdown|=SSL_SENT_SHUTDOWN;
                 ssl3_send_alert(s, SSL3_AL_WARNING, SSL_AD_CLOSE_NOTIFY);
                 /*
                  * Our shutdown alert has been sent now, and if it still needs
@@ -2696,15 +2696,15 @@ ssl3_shutdown(SSL *s)
                          */
                         return (ret);
                 }
-        } else if (!(s->internal->shutdown & SSL_RECEIVED_SHUTDOWN)) {
+        } else if (!(s->shutdown & SSL_RECEIVED_SHUTDOWN)) {
                 /* If we are waiting for a close from our peer, we are closed */
                 s->method->ssl_read_bytes(s, 0, NULL, 0, 0);
-                if (!(s->internal->shutdown & SSL_RECEIVED_SHUTDOWN)) {
+                if (!(s->shutdown & SSL_RECEIVED_SHUTDOWN)) {
                         return (-1);    /* return WANT_READ */
                 }
         }
 
-        if ((s->internal->shutdown == (SSL_SENT_SHUTDOWN|SSL_RECEIVED_SHUTDOWN)) &&
+        if ((s->shutdown == (SSL_SENT_SHUTDOWN|SSL_RECEIVED_SHUTDOWN)) &&
             !s->s3->alert_dispatch)
                 return (1);
         else
@@ -2737,16 +2737,16 @@ ssl3_read_internal(SSL *s, void *buf, int len, int peek)
             peek);
         if ((ret == -1) && (s->s3->in_read_app_data == 2)) {
                 /*
-                 * ssl3_read_bytes decided to call s->internal->handshake_func,
+                 * 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.
                  */
-                s->internal->in_handshake++;
+                s->in_handshake++;
                 ret = s->method->ssl_read_bytes(s, SSL3_RT_APPLICATION_DATA,
                     buf, len, peek);
-                s->internal->in_handshake--;
+                s->in_handshake--;
         } else
                 s->s3->in_read_app_data = 0;
 
@@ -2768,7 +2768,7 @@ ssl3_peek(SSL *s, void *buf, int len)
 int
 ssl3_renegotiate(SSL *s)
 {
-        if (s->internal->handshake_func == NULL)
+        if (s->handshake_func == NULL)
                 return 1;
 
         if (s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS)
diff --git a/src/lib/libssl/ssl_both.c b/src/lib/libssl/ssl_both.c
index 801b5bea29..93f7384762 100644
--- a/src/lib/libssl/ssl_both.c
+++ b/src/lib/libssl/ssl_both.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ssl_both.c,v 1.43 2022/10/01 16:23:15 jsing Exp $ */
+/* $OpenBSD: ssl_both.c,v 1.44 2022/10/02 16:36:41 jsing Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -128,7 +128,7 @@
 #include "ssl_locl.h"
 
 /*
- * Send s->internal->init_buf in records of type 'type' (SSL3_RT_HANDSHAKE or
+ * Send s->init_buf in records of type 'type' (SSL3_RT_HANDSHAKE or
  * SSL3_RT_CHANGE_CIPHER_SPEC).
  */
 int
@@ -136,8 +136,8 @@ ssl3_do_write(SSL *s, int type)
 {
         int ret;
 
-        ret = ssl3_write_bytes(s, type, &s->internal->init_buf->data[s->internal->init_off],
-            s->internal->init_num);
+        ret = ssl3_write_bytes(s, type, &s->init_buf->data[s->init_off],
+            s->init_num);
         if (ret < 0)
                 return (-1);
 
@@ -147,16 +147,16 @@ ssl3_do_write(SSL *s, int type)
                  * we'll ignore the result anyway.
                  */
                 tls1_transcript_record(s,
-                    (unsigned char *)&s->internal->init_buf->data[s->internal->init_off], ret);
+                    (unsigned char *)&s->init_buf->data[s->init_off], ret);
 
-        if (ret == s->internal->init_num) {
-                ssl_msg_callback(s, 1, type, s->internal->init_buf->data,
-                    (size_t)(s->internal->init_off + s->internal->init_num));
+        if (ret == s->init_num) {
+                ssl_msg_callback(s, 1, type, s->init_buf->data,
+                    (size_t)(s->init_off + s->init_num));
                 return (1);
         }
 
-        s->internal->init_off += ret;
-        s->internal->init_num -= ret;
+        s->init_off += ret;
+        s->init_num -= ret;
 
         return (0);
 }
@@ -207,7 +207,7 @@ ssl3_output_cert_chain(SSL *s, CBB *cbb, SSL_CERT_PKEY *cpk)
         if ((chain = cpk->chain) == NULL)
                 chain = s->ctx->extra_certs;
 
-        if (chain != NULL || (s->internal->mode & SSL_MODE_NO_AUTO_CHAIN)) {
+        if (chain != NULL || (s->mode & SSL_MODE_NO_AUTO_CHAIN)) {
                 if (!ssl3_add_cert(&cert_list, cpk->x509))
                         goto err;
         } else {
@@ -269,27 +269,27 @@ ssl3_get_message(SSL *s, int st1, int stn, int mt, long max)
                         SSLerror(s, SSL_R_UNEXPECTED_MESSAGE);
                         goto fatal_err;
                 }
-                s->internal->init_msg = s->internal->init_buf->data +
+                s->init_msg = s->init_buf->data +
                     SSL3_HM_HEADER_LENGTH;
-                s->internal->init_num = (int)s->s3->hs.tls12.message_size;
+                s->init_num = (int)s->s3->hs.tls12.message_size;
                 return 1;
         }
 
-        p = (unsigned char *)s->internal->init_buf->data;
+        p = (unsigned char *)s->init_buf->data;
 
         if (s->s3->hs.state == st1) {
                 int skip_message;
 
                 do {
-                        while (s->internal->init_num < SSL3_HM_HEADER_LENGTH) {
+                        while (s->init_num < SSL3_HM_HEADER_LENGTH) {
                                 i = s->method->ssl_read_bytes(s,
-                                    SSL3_RT_HANDSHAKE, &p[s->internal->init_num],
-                                    SSL3_HM_HEADER_LENGTH - s->internal->init_num, 0);
+                                    SSL3_RT_HANDSHAKE, &p[s->init_num],
+                                    SSL3_HM_HEADER_LENGTH - s->init_num, 0);
                                 if (i <= 0) {
-                                        s->internal->rwstate = SSL_READING;
+                                        s->rwstate = SSL_READING;
                                         return i;
                                 }
-                                s->internal->init_num += i;
+                                s->init_num += i;
                         }
 
                         skip_message = 0;
@@ -301,7 +301,7 @@ ssl3_get_message(SSL *s, int st1, int stn, int mt, long max)
                                  * correct.  Does not count for 'Finished' MAC.
                                  */
                                 if (p[1] == 0 && p[2] == 0 &&p[3] == 0) {
-                                        s->internal->init_num = 0;
+                                        s->init_num = 0;
                                         skip_message = 1;
 
                                         ssl_msg_callback(s, 0,
@@ -330,7 +330,7 @@ ssl3_get_message(SSL *s, int st1, int stn, int mt, long max)
                         SSLerror(s, SSL_R_EXCESSIVE_MESSAGE_SIZE);
                         goto fatal_err;
                 }
-                if (l && !BUF_MEM_grow_clean(s->internal->init_buf,
+                if (l && !BUF_MEM_grow_clean(s->init_buf,
                     l + SSL3_HM_HEADER_LENGTH)) {
                         SSLerror(s, ERR_R_BUF_LIB);
                         goto err;
@@ -338,33 +338,33 @@ ssl3_get_message(SSL *s, int st1, int stn, int mt, long max)
                 s->s3->hs.tls12.message_size = l;
                 s->s3->hs.state = stn;
 
-                s->internal->init_msg = s->internal->init_buf->data +
+                s->init_msg = s->init_buf->data +
                     SSL3_HM_HEADER_LENGTH;
-                s->internal->init_num = 0;
+                s->init_num = 0;
         }
 
         /* next state (stn) */
-        p = s->internal->init_msg;
-        n = s->s3->hs.tls12.message_size - s->internal->init_num;
+        p = s->init_msg;
+        n = s->s3->hs.tls12.message_size - s->init_num;
         while (n > 0) {
                 i = s->method->ssl_read_bytes(s, SSL3_RT_HANDSHAKE,
-                    &p[s->internal->init_num], n, 0);
+                    &p[s->init_num], n, 0);
                 if (i <= 0) {
-                        s->internal->rwstate = SSL_READING;
+                        s->rwstate = SSL_READING;
                         return i;
                 }
-                s->internal->init_num += i;
+                s->init_num += i;
                 n -= i;
         }
 
         /* Feed this message into MAC computation. */
-        if (s->internal->mac_packet) {
-                tls1_transcript_record(s, (unsigned char *)s->internal->init_buf->data,
-                    s->internal->init_num + SSL3_HM_HEADER_LENGTH);
+        if (s->mac_packet) {
+                tls1_transcript_record(s, (unsigned char *)s->init_buf->data,
+                    s->init_num + SSL3_HM_HEADER_LENGTH);
 
                 ssl_msg_callback(s, 0, SSL3_RT_HANDSHAKE,
-                    s->internal->init_buf->data,
-                    (size_t)s->internal->init_num + SSL3_HM_HEADER_LENGTH);
+                    s->init_buf->data,
+                    (size_t)s->init_num + SSL3_HM_HEADER_LENGTH);
         }
 
         return 1;
@@ -459,7 +459,7 @@ ssl3_setup_init_buffer(SSL *s)
 {
         BUF_MEM *buf = NULL;
 
-        if (s->internal->init_buf != NULL)
+        if (s->init_buf != NULL)
                 return (1);
 
         if ((buf = BUF_MEM_new()) == NULL)
@@ -467,7 +467,7 @@ ssl3_setup_init_buffer(SSL *s)
         if (!BUF_MEM_grow(buf, SSL3_RT_MAX_PLAIN_LENGTH))
                 goto err;
 
-        s->internal->init_buf = buf;
+        s->init_buf = buf;
         return (1);
 
  err:
@@ -478,11 +478,11 @@ ssl3_setup_init_buffer(SSL *s)
 void
 ssl3_release_init_buffer(SSL *s)
 {
-        BUF_MEM_free(s->internal->init_buf);
-        s->internal->init_buf = NULL;
-        s->internal->init_msg = NULL;
-        s->internal->init_num = 0;
-        s->internal->init_off = 0;
+        BUF_MEM_free(s->init_buf);
+        s->init_buf = NULL;
+        s->init_msg = NULL;
+        s->init_num = 0;
+        s->init_off = 0;
 }
 
 int
@@ -507,7 +507,7 @@ ssl3_setup_read_buffer(SSL *s)
                 s->s3->rbuf.len = len;
         }
 
-        s->internal->packet = s->s3->rbuf.buf;
+        s->packet = s->s3->rbuf.buf;
         return 1;
 
  err:
@@ -531,7 +531,7 @@ ssl3_setup_write_buffer(SSL *s)
         if (s->s3->wbuf.buf == NULL) {
                 len = s->max_send_fragment +
                     SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD + headerlen + align;
-                if (!(s->internal->options & SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS))
+                if (!(s->options & SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS))
                         len += headerlen + align +
                             SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD;
 
diff --git a/src/lib/libssl/ssl_cert.c b/src/lib/libssl/ssl_cert.c
index 453d75771d..d102e2e29d 100644
--- a/src/lib/libssl/ssl_cert.c
+++ b/src/lib/libssl/ssl_cert.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ssl_cert.c,v 1.103 2022/07/07 13:04:39 tb Exp $ */
+/* $OpenBSD: ssl_cert.c,v 1.104 2022/10/02 16:36:41 jsing Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -304,7 +304,7 @@ ssl_get0_cert(SSL_CTX *ctx, SSL *ssl)
         if (ssl != NULL)
                 return ssl->cert;
 
-        return ctx->internal->cert;
+        return ctx->cert;
 }
 
 int
@@ -430,21 +430,21 @@ ssl_verify_cert_chain(SSL *s, STACK_OF(X509) *certs)
          */
         X509_VERIFY_PARAM_set1(param, s->param);
 
-        if (s->internal->verify_callback)
-                X509_STORE_CTX_set_verify_cb(ctx, s->internal->verify_callback);
+        if (s->verify_callback)
+                X509_STORE_CTX_set_verify_cb(ctx, s->verify_callback);
 
-        if (s->ctx->internal->app_verify_callback != NULL)
-                ret = s->ctx->internal->app_verify_callback(ctx,
-                    s->ctx->internal->app_verify_arg);
+        if (s->ctx->app_verify_callback != NULL)
+                ret = s->ctx->app_verify_callback(ctx,
+                    s->ctx->app_verify_arg);
         else
                 ret = X509_verify_cert(ctx);
 
         s->verify_result = X509_STORE_CTX_get_error(ctx);
-        sk_X509_pop_free(s->internal->verified_chain, X509_free);
-        s->internal->verified_chain = NULL;
+        sk_X509_pop_free(s->verified_chain, X509_free);
+        s->verified_chain = NULL;
         if (X509_STORE_CTX_get0_chain(ctx) != NULL) {
-                s->internal->verified_chain = X509_STORE_CTX_get1_chain(ctx);
-                if (s->internal->verified_chain == NULL) {
+                s->verified_chain = X509_STORE_CTX_get1_chain(ctx);
+                if (s->verified_chain == NULL) {
                         SSLerrorx(ERR_R_MALLOC_FAILURE);
                         ret = 0;
                 }
@@ -491,19 +491,19 @@ SSL_dup_CA_list(const STACK_OF(X509_NAME) *sk)
 void
 SSL_set_client_CA_list(SSL *s, STACK_OF(X509_NAME) *name_list)
 {
-        set_client_CA_list(&(s->internal->client_CA), name_list);
+        set_client_CA_list(&(s->client_CA), name_list);
 }
 
 void
 SSL_CTX_set_client_CA_list(SSL_CTX *ctx, STACK_OF(X509_NAME) *name_list)
 {
-        set_client_CA_list(&(ctx->internal->client_CA), name_list);
+        set_client_CA_list(&(ctx->client_CA), name_list);
 }
 
 STACK_OF(X509_NAME) *
 SSL_CTX_get_client_CA_list(const SSL_CTX *ctx)
 {
-        return (ctx->internal->client_CA);
+        return (ctx->client_CA);
 }
 
 STACK_OF(X509_NAME) *
@@ -516,10 +516,10 @@ SSL_get_client_CA_list(const SSL *s)
                 else
                         return (NULL);
         } else {
-                if (s->internal->client_CA != NULL)
-                        return (s->internal->client_CA);
+                if (s->client_CA != NULL)
+                        return (s->client_CA);
                 else
-                        return (s->ctx->internal->client_CA);
+                        return (s->ctx->client_CA);
         }
 }
 
@@ -546,13 +546,13 @@ add_client_CA(STACK_OF(X509_NAME) **sk, X509 *x)
 int
 SSL_add_client_CA(SSL *ssl, X509 *x)
 {
-        return (add_client_CA(&(ssl->internal->client_CA), x));
+        return (add_client_CA(&(ssl->client_CA), x));
 }
 
 int
 SSL_CTX_add_client_CA(SSL_CTX *ctx, X509 *x)
 {
-        return (add_client_CA(&(ctx->internal->client_CA), x));
+        return (add_client_CA(&(ctx->client_CA), x));
 }
 
 static int
diff --git a/src/lib/libssl/ssl_ciphers.c b/src/lib/libssl/ssl_ciphers.c
index f77f32ab7f..09b4805820 100644
--- a/src/lib/libssl/ssl_ciphers.c
+++ b/src/lib/libssl/ssl_ciphers.c
@@ -1,4 +1,4 @@
-/*      $OpenBSD: ssl_ciphers.c,v 1.15 2022/07/02 16:31:04 tb Exp $ */
+/*      $OpenBSD: ssl_ciphers.c,v 1.16 2022/10/02 16:36:41 jsing Exp $ */
 /*
  * Copyright (c) 2015-2017 Doug Hogan <doug@openbsd.org>
  * Copyright (c) 2015-2018, 2020 Joel Sing <jsing@openbsd.org>
@@ -79,7 +79,7 @@ ssl_cipher_list_to_bytes(SSL *s, STACK_OF(SSL_CIPHER) *ciphers, CBB *cbb)
         }
 
         /* Add SCSV if there are other ciphers and we're not renegotiating. */
-        if (num_ciphers > 0 && !s->internal->renegotiate) {
+        if (num_ciphers > 0 && !s->renegotiate) {
                 if (!CBB_add_u16(cbb, SSL3_CK_SCSV & SSL3_CK_VALUE_MASK))
                         return 0;
         }
@@ -118,7 +118,7 @@ ssl_bytes_to_cipher_list(SSL *s, CBS *cbs)
                          * TLS_EMPTY_RENEGOTIATION_INFO_SCSV is fatal if
                          * renegotiating.
                          */
-                        if (s->internal->renegotiate) {
+                        if (s->renegotiate) {
                                 SSLerror(s, SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING);
                                 ssl3_send_alert(s, SSL3_AL_FATAL,
                                     SSL_AD_HANDSHAKE_FAILURE);
diff --git a/src/lib/libssl/ssl_clnt.c b/src/lib/libssl/ssl_clnt.c
index 8b2f209a79..d5791e3ffc 100644
--- a/src/lib/libssl/ssl_clnt.c
+++ b/src/lib/libssl/ssl_clnt.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ssl_clnt.c,v 1.154 2022/10/01 16:23:15 jsing Exp $ */
+/* $OpenBSD: ssl_clnt.c,v 1.155 2022/10/02 16:36:41 jsing Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -204,7 +204,7 @@ ssl3_connect(SSL *s)
         ERR_clear_error();
         errno = 0;
 
-        s->internal->in_handshake++;
+        s->in_handshake++;
         if (!SSL_in_init(s) || SSL_in_before(s))
                 SSL_clear(s);
 
@@ -213,9 +213,9 @@ ssl3_connect(SSL *s)
 
                 switch (s->s3->hs.state) {
                 case SSL_ST_RENEGOTIATE:
-                        s->internal->renegotiate = 1;
+                        s->renegotiate = 1;
                         s->s3->hs.state = SSL_ST_CONNECT;
-                        s->ctx->internal->stats.sess_connect_renegotiate++;
+                        s->ctx->stats.sess_connect_renegotiate++;
                         /* break */
                 case SSL_ST_BEFORE:
                 case SSL_ST_CONNECT:
@@ -268,21 +268,21 @@ ssl3_connect(SSL *s)
                         }
 
                         s->s3->hs.state = SSL3_ST_CW_CLNT_HELLO_A;
-                        s->ctx->internal->stats.sess_connect++;
-                        s->internal->init_num = 0;
+                        s->ctx->stats.sess_connect++;
+                        s->init_num = 0;
 
                         if (SSL_is_dtls(s)) {
                                 /* mark client_random uninitialized */
                                 memset(s->s3->client_random, 0,
                                     sizeof(s->s3->client_random));
                                 s->d1->send_cookie = 0;
-                                s->internal->hit = 0;
+                                s->hit = 0;
                         }
                         break;
 
                 case SSL3_ST_CW_CLNT_HELLO_A:
                 case SSL3_ST_CW_CLNT_HELLO_B:
-                        s->internal->shutdown = 0;
+                        s->shutdown = 0;
 
                         if (SSL_is_dtls(s)) {
                                 /* every DTLS ClientHello resets Finished MAC */
@@ -301,7 +301,7 @@ ssl3_connect(SSL *s)
                         } else
                                 s->s3->hs.state = SSL3_ST_CR_SRVR_HELLO_A;
 
-                        s->internal->init_num = 0;
+                        s->init_num = 0;
 
                         /* turn on buffering for the next lot of output */
                         if (s->bbio != s->wbio)
@@ -315,10 +315,10 @@ ssl3_connect(SSL *s)
                         if (ret <= 0)
                                 goto end;
 
-                        if (s->internal->hit) {
+                        if (s->hit) {
                                 s->s3->hs.state = SSL3_ST_CR_FINISHED_A;
                                 if (!SSL_is_dtls(s)) {
-                                        if (s->internal->tlsext_ticket_expected) {
+                                        if (s->tlsext_ticket_expected) {
                                                 /* receive renewed session ticket */
                                                 s->s3->hs.state = SSL3_ST_CR_SESSION_TICKET_A;
                                         }
@@ -331,7 +331,7 @@ ssl3_connect(SSL *s)
                         } else {
                                 s->s3->hs.state = SSL3_ST_CR_CERT_A;
                         }
-                        s->internal->init_num = 0;
+                        s->init_num = 0;
                         break;
 
                 case DTLS1_ST_CR_HELLO_VERIFY_REQUEST_A:
@@ -344,7 +344,7 @@ ssl3_connect(SSL *s)
                                 s->s3->hs.state = SSL3_ST_CW_CLNT_HELLO_A;
                         else
                                 s->s3->hs.state = SSL3_ST_CR_CERT_A;
-                        s->internal->init_num = 0;
+                        s->init_num = 0;
                         break;
 
                 case SSL3_ST_CR_CERT_A:
@@ -353,12 +353,12 @@ ssl3_connect(SSL *s)
                         if (ret <= 0)
                                 goto end;
                         if (ret == 2) {
-                                s->internal->hit = 1;
-                                if (s->internal->tlsext_ticket_expected)
+                                s->hit = 1;
+                                if (s->tlsext_ticket_expected)
                                         s->s3->hs.state = SSL3_ST_CR_SESSION_TICKET_A;
                                 else
                                         s->s3->hs.state = SSL3_ST_CR_FINISHED_A;
-                                s->internal->init_num = 0;
+                                s->init_num = 0;
                                 break;
                         }
                         /* Check if it is anon DH/ECDH. */
@@ -367,7 +367,7 @@ ssl3_connect(SSL *s)
                                 ret = ssl3_get_server_certificate(s);
                                 if (ret <= 0)
                                         goto end;
-                                if (s->internal->tlsext_status_expected)
+                                if (s->tlsext_status_expected)
                                         s->s3->hs.state = SSL3_ST_CR_CERT_STATUS_A;
                                 else
                                         s->s3->hs.state = SSL3_ST_CR_KEY_EXCH_A;
@@ -375,7 +375,7 @@ ssl3_connect(SSL *s)
                                 skip = 1;
                                 s->s3->hs.state = SSL3_ST_CR_KEY_EXCH_A;
                         }
-                        s->internal->init_num = 0;
+                        s->init_num = 0;
                         break;
 
                 case SSL3_ST_CR_KEY_EXCH_A:
@@ -384,7 +384,7 @@ ssl3_connect(SSL *s)
                         if (ret <= 0)
                                 goto end;
                         s->s3->hs.state = SSL3_ST_CR_CERT_REQ_A;
-                        s->internal->init_num = 0;
+                        s->init_num = 0;
 
                         /*
                          * At this point we check that we have the
@@ -402,7 +402,7 @@ ssl3_connect(SSL *s)
                         if (ret <= 0)
                                 goto end;
                         s->s3->hs.state = SSL3_ST_CR_SRVR_DONE_A;
-                        s->internal->init_num = 0;
+                        s->init_num = 0;
                         break;
 
                 case SSL3_ST_CR_SRVR_DONE_A:
@@ -416,7 +416,7 @@ ssl3_connect(SSL *s)
                                 s->s3->hs.state = SSL3_ST_CW_CERT_A;
                         else
                                 s->s3->hs.state = SSL3_ST_CW_KEY_EXCH_A;
-                        s->internal->init_num = 0;
+                        s->init_num = 0;
 
                         break;
 
@@ -430,7 +430,7 @@ ssl3_connect(SSL *s)
                         if (ret <= 0)
                                 goto end;
                         s->s3->hs.state = SSL3_ST_CW_KEY_EXCH_A;
-                        s->internal->init_num = 0;
+                        s->init_num = 0;
                         break;
 
                 case SSL3_ST_CW_KEY_EXCH_A:
@@ -469,7 +469,7 @@ ssl3_connect(SSL *s)
                                 }
                         }
 
-                        s->internal->init_num = 0;
+                        s->init_num = 0;
                         break;
 
                 case SSL3_ST_CW_CERT_VRFY_A:
@@ -480,20 +480,20 @@ ssl3_connect(SSL *s)
                         if (ret <= 0)
                                 goto end;
                         s->s3->hs.state = SSL3_ST_CW_CHANGE_A;
-                        s->internal->init_num = 0;
+                        s->init_num = 0;
                         s->s3->change_cipher_spec = 0;
                         break;
 
                 case SSL3_ST_CW_CHANGE_A:
                 case SSL3_ST_CW_CHANGE_B:
-                        if (SSL_is_dtls(s) && !s->internal->hit)
+                        if (SSL_is_dtls(s) && !s->hit)
                                 dtls1_start_timer(s);
                         ret = ssl3_send_client_change_cipher_spec(s);
                         if (ret <= 0)
                                 goto end;
 
                         s->s3->hs.state = SSL3_ST_CW_FINISHED_A;
-                        s->internal->init_num = 0;
+                        s->init_num = 0;
                         s->session->cipher = s->s3->hs.cipher;
 
                         if (!tls1_setup_key_block(s)) {
@@ -508,7 +508,7 @@ ssl3_connect(SSL *s)
 
                 case SSL3_ST_CW_FINISHED_A:
                 case SSL3_ST_CW_FINISHED_B:
-                        if (SSL_is_dtls(s) && !s->internal->hit)
+                        if (SSL_is_dtls(s) && !s->hit)
                                 dtls1_start_timer(s);
                         ret = ssl3_send_client_finished(s);
                         if (ret <= 0)
@@ -518,18 +518,18 @@ ssl3_connect(SSL *s)
                         s->s3->hs.state = SSL3_ST_CW_FLUSH;
 
                         /* clear flags */
-                        if (s->internal->hit) {
+                        if (s->hit) {
                                 s->s3->hs.tls12.next_state = SSL_ST_OK;
                         } else {
                                 /* Allow NewSessionTicket if ticket expected */
-                                if (s->internal->tlsext_ticket_expected)
+                                if (s->tlsext_ticket_expected)
                                         s->s3->hs.tls12.next_state =
                                             SSL3_ST_CR_SESSION_TICKET_A;
                                 else
                                         s->s3->hs.tls12.next_state =
                                             SSL3_ST_CR_FINISHED_A;
                         }
-                        s->internal->init_num = 0;
+                        s->init_num = 0;
                         break;
 
                 case SSL3_ST_CR_SESSION_TICKET_A:
@@ -538,7 +538,7 @@ ssl3_connect(SSL *s)
                         if (ret <= 0)
                                 goto end;
                         s->s3->hs.state = SSL3_ST_CR_FINISHED_A;
-                        s->internal->init_num = 0;
+                        s->init_num = 0;
                         break;
 
                 case SSL3_ST_CR_CERT_STATUS_A:
@@ -547,7 +547,7 @@ ssl3_connect(SSL *s)
                         if (ret <= 0)
                                 goto end;
                         s->s3->hs.state = SSL3_ST_CR_KEY_EXCH_A;
-                        s->internal->init_num = 0;
+                        s->init_num = 0;
                         break;
 
                 case SSL3_ST_CR_FINISHED_A:
@@ -562,27 +562,27 @@ ssl3_connect(SSL *s)
                         if (SSL_is_dtls(s))
                                 dtls1_stop_timer(s);
 
-                        if (s->internal->hit)
+                        if (s->hit)
                                 s->s3->hs.state = SSL3_ST_CW_CHANGE_A;
                         else
                                 s->s3->hs.state = SSL_ST_OK;
-                        s->internal->init_num = 0;
+                        s->init_num = 0;
                         break;
 
                 case SSL3_ST_CW_FLUSH:
-                        s->internal->rwstate = SSL_WRITING;
+                        s->rwstate = SSL_WRITING;
                         if (BIO_flush(s->wbio) <= 0) {
                                 if (SSL_is_dtls(s)) {
                                         /* If the write error was fatal, stop trying */
                                         if (!BIO_should_retry(s->wbio)) {
-                                                s->internal->rwstate = SSL_NOTHING;
+                                                s->rwstate = SSL_NOTHING;
                                                 s->s3->hs.state = s->s3->hs.tls12.next_state;
                                         }
                                 }
                                 ret = -1;
                                 goto end;
                         }
-                        s->internal->rwstate = SSL_NOTHING;
+                        s->rwstate = SSL_NOTHING;
                         s->s3->hs.state = s->s3->hs.tls12.next_state;
                         break;
 
@@ -601,18 +601,18 @@ ssl3_connect(SSL *s)
 
                         ssl_free_wbio_buffer(s);
 
-                        s->internal->init_num = 0;
-                        s->internal->renegotiate = 0;
-                        s->internal->new_session = 0;
+                        s->init_num = 0;
+                        s->renegotiate = 0;
+                        s->new_session = 0;
 
                         ssl_update_cache(s, SSL_SESS_CACHE_CLIENT);
-                        if (s->internal->hit)
-                                s->ctx->internal->stats.sess_hit++;
+                        if (s->hit)
+                                s->ctx->stats.sess_hit++;
 
                         ret = 1;
                         /* s->server=0; */
-                        s->internal->handshake_func = ssl3_connect;
-                        s->ctx->internal->stats.sess_connect_good++;
+                        s->handshake_func = ssl3_connect;
+                        s->ctx->stats.sess_connect_good++;
 
                         ssl_info_callback(s, SSL_CB_HANDSHAKE_DONE, 1);
 
@@ -634,7 +634,7 @@ ssl3_connect(SSL *s)
 
                 /* did we do anything */
                 if (!s->s3->hs.tls12.reuse_message && !skip) {
-                        if (s->internal->debug) {
+                        if (s->debug) {
                                 if ((ret = BIO_flush(s->wbio)) <= 0)
                                         goto end;
                         }
@@ -650,7 +650,7 @@ ssl3_connect(SSL *s)
         }
 
  end:
-        s->internal->in_handshake--;
+        s->in_handshake--;
         ssl_info_callback(s, SSL_CB_CONNECT_EXIT, ret);
 
         return (ret);
@@ -706,7 +706,7 @@ ssl3_send_client_hello(SSL *s)
                 /* Session ID */
                 if (!CBB_add_u8_length_prefixed(&client_hello, &session_id))
                         goto err;
-                if (!s->internal->new_session &&
+                if (!s->new_session &&
                     s->session->session_id_length > 0) {
                         sl = s->session->session_id_length;
                         if (sl > sizeof(s->session->session_id)) {
@@ -777,7 +777,7 @@ ssl3_get_dtls_hello_verify(SSL *s)
         int al, ret;
 
         if ((ret = ssl3_get_message(s, DTLS1_ST_CR_HELLO_VERIFY_REQUEST_A,
-            DTLS1_ST_CR_HELLO_VERIFY_REQUEST_B, -1, s->internal->max_cert_list)) <= 0)
+            DTLS1_ST_CR_HELLO_VERIFY_REQUEST_B, -1, s->max_cert_list)) <= 0)
                 return ret;
 
         if (s->s3->hs.tls12.message_type != DTLS1_MT_HELLO_VERIFY_REQUEST) {
@@ -786,11 +786,11 @@ ssl3_get_dtls_hello_verify(SSL *s)
                 return (1);
         }
 
-        if (s->internal->init_num < 0)
+        if (s->init_num < 0)
                 goto decode_err;
 
-        CBS_init(&hello_verify_request, s->internal->init_msg,
-            s->internal->init_num);
+        CBS_init(&hello_verify_request, s->init_msg,
+            s->init_num);
 
         if (!CBS_get_u16(&hello_verify_request, &ssl_version))
                 goto decode_err;
@@ -840,16 +840,16 @@ ssl3_get_server_hello(SSL *s)
         unsigned long alg_k;
         int al, ret;
 
-        s->internal->first_packet = 1;
+        s->first_packet = 1;
         if ((ret = ssl3_get_message(s, SSL3_ST_CR_SRVR_HELLO_A,
             SSL3_ST_CR_SRVR_HELLO_B, -1, 20000 /* ?? */)) <= 0)
                 return ret;
-        s->internal->first_packet = 0;
+        s->first_packet = 0;
 
-        if (s->internal->init_num < 0)
+        if (s->init_num < 0)
                 goto decode_err;
 
-        CBS_init(&cbs, s->internal->init_msg, s->internal->init_num);
+        CBS_init(&cbs, s->init_msg, s->init_num);
 
         if (SSL_is_dtls(s)) {
                 if (s->s3->hs.tls12.message_type == DTLS1_MT_HELLO_VERIFY_REQUEST) {
@@ -944,13 +944,13 @@ ssl3_get_server_hello(SSL *s)
          * Check if we want to resume the session based on external
          * pre-shared secret.
          */
-        if (s->internal->tls_session_secret_cb != NULL) {
+        if (s->tls_session_secret_cb != NULL) {
                 SSL_CIPHER *pref_cipher = NULL;
                 int master_key_length = sizeof(s->session->master_key);
 
-                if (!s->internal->tls_session_secret_cb(s,
+                if (!s->tls_session_secret_cb(s,
                     s->session->master_key, &master_key_length, NULL,
-                    &pref_cipher, s->internal->tls_session_secret_cb_arg)) {
+                    &pref_cipher, s->tls_session_secret_cb_arg)) {
                         SSLerror(s, ERR_R_INTERNAL_ERROR);
                         goto err;
                 }
@@ -978,13 +978,13 @@ ssl3_get_server_hello(SSL *s)
                         goto fatal_err;
                 }
                 s->s3->flags |= SSL3_FLAGS_CCS_OK;
-                s->internal->hit = 1;
+                s->hit = 1;
         } else {
                 /* a miss or crap from the other end */
 
                 /* If we were trying for session-id reuse, make a new
                  * SSL_SESSION so we don't stuff up other people */
-                s->internal->hit = 0;
+                s->hit = 0;
                 if (s->session->session_id_length > 0) {
                         if (!ssl_get_new_session(s, 0)) {
                                 al = SSL_AD_INTERNAL_ERROR;
@@ -1032,7 +1032,7 @@ ssl3_get_server_hello(SSL *s)
          */
         if (s->session->cipher)
                 s->session->cipher_id = s->session->cipher->id;
-        if (s->internal->hit && (s->session->cipher_id != cipher->id)) {
+        if (s->hit && (s->session->cipher_id != cipher->id)) {
                 al = SSL_AD_ILLEGAL_PARAMETER;
                 SSLerror(s, SSL_R_OLD_SESSION_CIPHER_NOT_RETURNED);
                 goto fatal_err;
@@ -1076,7 +1076,7 @@ ssl3_get_server_hello(SSL *s)
          * absence on initial connect only.
          */
         if (!s->s3->renegotiate_seen &&
-            !(s->internal->options & SSL_OP_LEGACY_SERVER_CONNECT)) {
+            !(s->options & SSL_OP_LEGACY_SERVER_CONNECT)) {
                 al = SSL_AD_HANDSHAKE_FAILURE;
                 SSLerror(s, SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
                 goto fatal_err;
@@ -1109,7 +1109,7 @@ ssl3_get_server_certificate(SSL *s)
         int al, ret;
 
         if ((ret = ssl3_get_message(s, SSL3_ST_CR_CERT_A,
-            SSL3_ST_CR_CERT_B, -1, s->internal->max_cert_list)) <= 0)
+            SSL3_ST_CR_CERT_B, -1, s->max_cert_list)) <= 0)
                 return ret;
 
         ret = -1;
@@ -1130,10 +1130,10 @@ ssl3_get_server_certificate(SSL *s)
                 goto err;
         }
 
-        if (s->internal->init_num < 0)
+        if (s->init_num < 0)
                 goto decode_err;
 
-        CBS_init(&cbs, s->internal->init_msg, s->internal->init_num);
+        CBS_init(&cbs, s->init_msg, s->init_num);
 
         if (!CBS_get_u24_length_prefixed(&cbs, &cert_list))
                 goto decode_err;
@@ -1314,16 +1314,16 @@ ssl3_get_server_key_exchange(SSL *s)
          * as ServerKeyExchange message may be skipped.
          */
         if ((ret = ssl3_get_message(s, SSL3_ST_CR_KEY_EXCH_A,
-            SSL3_ST_CR_KEY_EXCH_B, -1, s->internal->max_cert_list)) <= 0)
+            SSL3_ST_CR_KEY_EXCH_B, -1, s->max_cert_list)) <= 0)
                 return ret;
 
         if ((md_ctx = EVP_MD_CTX_new()) == NULL)
                 goto err;
 
-        if (s->internal->init_num < 0)
+        if (s->init_num < 0)
                 goto err;
 
-        CBS_init(&cbs, s->internal->init_msg, s->internal->init_num);
+        CBS_init(&cbs, s->init_msg, s->init_num);
 
         if (s->s3->hs.tls12.message_type != SSL3_MT_SERVER_KEY_EXCHANGE) {
                 /*
@@ -1454,7 +1454,7 @@ ssl3_get_certificate_request(SSL *s)
         int ret;
 
         if ((ret = ssl3_get_message(s, SSL3_ST_CR_CERT_REQ_A,
-            SSL3_ST_CR_CERT_REQ_B, -1, s->internal->max_cert_list)) <= 0)
+            SSL3_ST_CR_CERT_REQ_B, -1, s->max_cert_list)) <= 0)
                 return ret;
 
         ret = 0;
@@ -1484,9 +1484,9 @@ ssl3_get_certificate_request(SSL *s)
                 goto err;
         }
 
-        if (s->internal->init_num < 0)
+        if (s->init_num < 0)
                 goto decode_err;
-        CBS_init(&cert_request, s->internal->init_msg, s->internal->init_num);
+        CBS_init(&cert_request, s->init_msg, s->init_num);
 
         if ((ca_sk = sk_X509_NAME_new(ca_dn_cmp)) == NULL) {
                 SSLerror(s, ERR_R_MALLOC_FAILURE);
@@ -1610,13 +1610,13 @@ ssl3_get_new_session_ticket(SSL *s)
                 goto fatal_err;
         }
 
-        if (s->internal->init_num < 0) {
+        if (s->init_num < 0) {
                 al = SSL_AD_DECODE_ERROR;
                 SSLerror(s, SSL_R_LENGTH_MISMATCH);
                 goto fatal_err;
         }
 
-        CBS_init(&cbs, s->internal->init_msg, s->internal->init_num);
+        CBS_init(&cbs, s->init_msg, s->init_num);
         if (!CBS_get_u32(&cbs, &lifetime_hint) ||
             !CBS_get_u16_length_prefixed(&cbs, &session_ticket) ||
             CBS_len(&cbs) != 0) {
@@ -1679,13 +1679,13 @@ ssl3_get_cert_status(SSL *s)
                  * Tell the callback the server did not send us an OSCP
                  * response, and has decided to head directly to key exchange.
                  */
-                if (s->ctx->internal->tlsext_status_cb) {
-                        free(s->internal->tlsext_ocsp_resp);
-                        s->internal->tlsext_ocsp_resp = NULL;
-                        s->internal->tlsext_ocsp_resp_len = 0;
+                if (s->ctx->tlsext_status_cb) {
+                        free(s->tlsext_ocsp_resp);
+                        s->tlsext_ocsp_resp = NULL;
+                        s->tlsext_ocsp_resp_len = 0;
 
-                        ret = s->ctx->internal->tlsext_status_cb(s,
-                            s->ctx->internal->tlsext_status_arg);
+                        ret = s->ctx->tlsext_status_cb(s,
+                            s->ctx->tlsext_status_arg);
                         if (ret == 0) {
                                 al = SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE;
                                 SSLerror(s, SSL_R_INVALID_STATUS_RESPONSE);
@@ -1708,14 +1708,14 @@ ssl3_get_cert_status(SSL *s)
                 goto fatal_err;
         }
 
-        if (s->internal->init_num < 0) {
+        if (s->init_num < 0) {
                 /* need at least status type + length */
                 al = SSL_AD_DECODE_ERROR;
                 SSLerror(s, SSL_R_LENGTH_MISMATCH);
                 goto fatal_err;
         }
 
-        CBS_init(&cert_status, s->internal->init_msg, s->internal->init_num);
+        CBS_init(&cert_status, s->init_msg, s->init_num);
         if (!CBS_get_u8(&cert_status, &status_type) ||
             CBS_len(&cert_status) < 3) {
                 /* need at least status type + length */
@@ -1737,16 +1737,16 @@ ssl3_get_cert_status(SSL *s)
                 goto fatal_err;
         }
 
-        if (!CBS_stow(&response, &s->internal->tlsext_ocsp_resp,
-            &s->internal->tlsext_ocsp_resp_len)) {
+        if (!CBS_stow(&response, &s->tlsext_ocsp_resp,
+            &s->tlsext_ocsp_resp_len)) {
                 al = SSL_AD_INTERNAL_ERROR;
                 SSLerror(s, ERR_R_MALLOC_FAILURE);
                 goto fatal_err;
         }
 
-        if (s->ctx->internal->tlsext_status_cb) {
-                ret = s->ctx->internal->tlsext_status_cb(s,
-                    s->ctx->internal->tlsext_status_arg);
+        if (s->ctx->tlsext_status_cb) {
+                ret = s->ctx->tlsext_status_cb(s,
+                    s->ctx->tlsext_status_arg);
                 if (ret == 0) {
                         al = SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE;
                         SSLerror(s, SSL_R_INVALID_STATUS_RESPONSE);
@@ -1774,7 +1774,7 @@ ssl3_get_server_done(SSL *s)
             30 /* should be very small, like 0 :-) */)) <= 0)
                 return ret;
 
-        if (s->internal->init_num != 0) {
+        if (s->init_num != 0) {
                 /* should contain no data */
                 ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_DECODE_ERROR);
                 SSLerror(s, SSL_R_LENGTH_MISMATCH);
@@ -2383,15 +2383,15 @@ ssl3_send_client_certificate(SSL *s)
         if (s->s3->hs.state == SSL3_ST_CW_CERT_B) {
                 /*
                  * If we get an error, we need to
-                 * ssl->internal->rwstate = SSL_X509_LOOKUP; return(-1);
+                 * ssl->rwstate = SSL_X509_LOOKUP; return(-1);
                  * We then get retried later.
                  */
                 i = ssl_do_client_cert_cb(s, &x509, &pkey);
                 if (i < 0) {
-                        s->internal->rwstate = SSL_X509_LOOKUP;
+                        s->rwstate = SSL_X509_LOOKUP;
                         return (-1);
                 }
-                s->internal->rwstate = SSL_NOTHING;
+                s->rwstate = SSL_NOTHING;
                 if ((i == 1) && (pkey != NULL) && (x509 != NULL)) {
                         s->s3->hs.state = SSL3_ST_CW_CERT_B;
                         if (!SSL_use_certificate(s, x509) ||
@@ -2508,7 +2508,7 @@ ssl3_check_finished(SSL *s)
         /* this function is called when we really expect a Certificate
          * message, so permit appropriate message length */
         if ((ret = ssl3_get_message(s, SSL3_ST_CR_CERT_A,
-            SSL3_ST_CR_CERT_B, -1, s->internal->max_cert_list)) <= 0)
+            SSL3_ST_CR_CERT_B, -1, s->max_cert_list)) <= 0)
                 return ret;
 
         s->s3->hs.tls12.reuse_message = 1;
@@ -2525,16 +2525,16 @@ ssl_do_client_cert_cb(SSL *s, X509 **px509, EVP_PKEY **ppkey)
         int     i = 0;
 
 #ifndef OPENSSL_NO_ENGINE
-        if (s->ctx->internal->client_cert_engine) {
+        if (s->ctx->client_cert_engine) {
                 i = ENGINE_load_ssl_client_cert(
-                    s->ctx->internal->client_cert_engine, s,
+                    s->ctx->client_cert_engine, s,
                     SSL_get_client_CA_list(s), px509, ppkey, NULL, NULL, NULL);
                 if (i != 0)
                         return (i);
         }
 #endif
-        if (s->ctx->internal->client_cert_cb)
-                i = s->ctx->internal->client_cert_cb(s, px509, ppkey);
+        if (s->ctx->client_cert_cb)
+                i = s->ctx->client_cert_cb(s, px509, ppkey);
         return (i);
 }
 
@@ -2547,8 +2547,8 @@ ssl3_send_client_change_cipher_spec(SSL *s)
         memset(&cbb, 0, sizeof(cbb));
 
         if (s->s3->hs.state == SSL3_ST_CW_CHANGE_A) {
-                if (!CBB_init_fixed(&cbb, s->internal->init_buf->data,
-                    s->internal->init_buf->length))
+                if (!CBB_init_fixed(&cbb, s->init_buf->data,
+                    s->init_buf->length))
                         goto err;
                 if (!CBB_add_u8(&cbb, SSL3_MT_CCS))
                         goto err;
@@ -2558,8 +2558,8 @@ ssl3_send_client_change_cipher_spec(SSL *s)
                 if (outlen > INT_MAX)
                         goto err;
 
-                s->internal->init_num = (int)outlen;
-                s->internal->init_off = 0;
+                s->init_num = (int)outlen;
+                s->init_off = 0;
 
                 if (SSL_is_dtls(s)) {
                         s->d1->handshake_write_seq =
@@ -2639,13 +2639,13 @@ ssl3_get_server_finished(SSL *s)
 
         md_len = TLS1_FINISH_MAC_LENGTH;
 
-        if (s->internal->init_num < 0) {
+        if (s->init_num < 0) {
                 al = SSL_AD_DECODE_ERROR;
                 SSLerror(s, SSL_R_BAD_DIGEST_LENGTH);
                 goto fatal_err;
         }
 
-        CBS_init(&cbs, s->internal->init_msg, s->internal->init_num);
+        CBS_init(&cbs, s->init_msg, s->init_num);
 
         if (s->s3->hs.peer_finished_len != md_len ||
             CBS_len(&cbs) != md_len) {
diff --git a/src/lib/libssl/ssl_lib.c b/src/lib/libssl/ssl_lib.c
index f5f7bf66c1..4b5f119a88 100644
--- a/src/lib/libssl/ssl_lib.c
+++ b/src/lib/libssl/ssl_lib.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ssl_lib.c,v 1.305 2022/09/10 15:29:33 jsing Exp $ */
+/* $OpenBSD: ssl_lib.c,v 1.306 2022/10/02 16:36:41 jsing Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -180,33 +180,33 @@ SSL_clear(SSL *s)
         }
 
         s->error = 0;
-        s->internal->hit = 0;
-        s->internal->shutdown = 0;
+        s->hit = 0;
+        s->shutdown = 0;
 
-        if (s->internal->renegotiate) {
+        if (s->renegotiate) {
                 SSLerror(s, ERR_R_INTERNAL_ERROR);
                 return (0);
         }
 
         s->version = s->method->version;
         s->client_version = s->version;
-        s->internal->rwstate = SSL_NOTHING;
-        s->internal->rstate = SSL_ST_READ_HEADER;
+        s->rwstate = SSL_NOTHING;
+        s->rstate = SSL_ST_READ_HEADER;
 
-        tls13_ctx_free(s->internal->tls13);
-        s->internal->tls13 = NULL;
+        tls13_ctx_free(s->tls13);
+        s->tls13 = NULL;
 
         ssl3_release_init_buffer(s);
 
         ssl_clear_cipher_state(s);
 
-        s->internal->first_packet = 0;
+        s->first_packet = 0;
 
         /*
          * Check to see if we were changed into a different method, if
          * so, revert back if we are not doing session-id reuse.
          */
-        if (!s->internal->in_handshake && (s->session == NULL) &&
+        if (!s->in_handshake && (s->session == NULL) &&
             (s->method != s->ctx->method)) {
                 s->method->ssl_free(s);
                 s->method = s->ctx->method;
@@ -227,8 +227,8 @@ SSL_CTX_set_ssl_version(SSL_CTX *ctx, const SSL_METHOD *meth)
         ctx->method = meth;
 
         ciphers = ssl_create_cipher_list(ctx->method, &ctx->cipher_list,
-            ctx->internal->cipher_list_tls13, SSL_DEFAULT_CIPHER_LIST,
-            ctx->internal->cert);
+            ctx->cipher_list_tls13, SSL_DEFAULT_CIPHER_LIST,
+            ctx->cert);
         if (ciphers == NULL || sk_SSL_CIPHER_num(ciphers) <= 0) {
                 SSLerrorx(SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS);
                 return (0);
@@ -253,87 +253,85 @@ SSL_new(SSL_CTX *ctx)
 
         if ((s = calloc(1, sizeof(*s))) == NULL)
                 goto err;
-        if ((s->internal = calloc(1, sizeof(*s->internal))) == NULL)
-                goto err;
 
-        if ((s->internal->rl = tls12_record_layer_new()) == NULL)
+        if ((s->rl = tls12_record_layer_new()) == NULL)
                 goto err;
 
-        s->internal->min_tls_version = ctx->internal->min_tls_version;
-        s->internal->max_tls_version = ctx->internal->max_tls_version;
-        s->internal->min_proto_version = ctx->internal->min_proto_version;
-        s->internal->max_proto_version = ctx->internal->max_proto_version;
+        s->min_tls_version = ctx->min_tls_version;
+        s->max_tls_version = ctx->max_tls_version;
+        s->min_proto_version = ctx->min_proto_version;
+        s->max_proto_version = ctx->max_proto_version;
 
-        s->internal->options = ctx->internal->options;
-        s->internal->mode = ctx->internal->mode;
-        s->internal->max_cert_list = ctx->internal->max_cert_list;
-        s->internal->num_tickets = ctx->internal->num_tickets;
+        s->options = ctx->options;
+        s->mode = ctx->mode;
+        s->max_cert_list = ctx->max_cert_list;
+        s->num_tickets = ctx->num_tickets;
 
-        if ((s->cert = ssl_cert_dup(ctx->internal->cert)) == NULL)
+        if ((s->cert = ssl_cert_dup(ctx->cert)) == NULL)
                 goto err;
 
-        s->internal->read_ahead = ctx->internal->read_ahead;
-        s->internal->msg_callback = ctx->internal->msg_callback;
-        s->internal->msg_callback_arg = ctx->internal->msg_callback_arg;
+        s->read_ahead = ctx->read_ahead;
+        s->msg_callback = ctx->msg_callback;
+        s->msg_callback_arg = ctx->msg_callback_arg;
         s->verify_mode = ctx->verify_mode;
         s->sid_ctx_length = ctx->sid_ctx_length;
         OPENSSL_assert(s->sid_ctx_length <= sizeof s->sid_ctx);
         memcpy(&s->sid_ctx, &ctx->sid_ctx, sizeof(s->sid_ctx));
-        s->internal->verify_callback = ctx->internal->default_verify_callback;
-        s->internal->generate_session_id = ctx->internal->generate_session_id;
+        s->verify_callback = ctx->default_verify_callback;
+        s->generate_session_id = ctx->generate_session_id;
 
         s->param = X509_VERIFY_PARAM_new();
         if (!s->param)
                 goto err;
         X509_VERIFY_PARAM_inherit(s->param, ctx->param);
-        s->internal->quiet_shutdown = ctx->internal->quiet_shutdown;
-        s->max_send_fragment = ctx->internal->max_send_fragment;
+        s->quiet_shutdown = ctx->quiet_shutdown;
+        s->max_send_fragment = ctx->max_send_fragment;
 
         CRYPTO_add(&ctx->references, 1, CRYPTO_LOCK_SSL_CTX);
         s->ctx = ctx;
-        s->internal->tlsext_debug_cb = 0;
-        s->internal->tlsext_debug_arg = NULL;
-        s->internal->tlsext_ticket_expected = 0;
+        s->tlsext_debug_cb = 0;
+        s->tlsext_debug_arg = NULL;
+        s->tlsext_ticket_expected = 0;
         s->tlsext_status_type = -1;
-        s->internal->tlsext_status_expected = 0;
-        s->internal->tlsext_ocsp_ids = NULL;
-        s->internal->tlsext_ocsp_exts = NULL;
-        s->internal->tlsext_ocsp_resp = NULL;
-        s->internal->tlsext_ocsp_resp_len = 0;
+        s->tlsext_status_expected = 0;
+        s->tlsext_ocsp_ids = NULL;
+        s->tlsext_ocsp_exts = NULL;
+        s->tlsext_ocsp_resp = NULL;
+        s->tlsext_ocsp_resp_len = 0;
         CRYPTO_add(&ctx->references, 1, CRYPTO_LOCK_SSL_CTX);
         s->initial_ctx = ctx;
 
-        if (ctx->internal->tlsext_ecpointformatlist != NULL) {
-                s->internal->tlsext_ecpointformatlist =
-                    calloc(ctx->internal->tlsext_ecpointformatlist_length,
-                        sizeof(ctx->internal->tlsext_ecpointformatlist[0]));
-                if (s->internal->tlsext_ecpointformatlist == NULL)
+        if (ctx->tlsext_ecpointformatlist != NULL) {
+                s->tlsext_ecpointformatlist =
+                    calloc(ctx->tlsext_ecpointformatlist_length,
+                        sizeof(ctx->tlsext_ecpointformatlist[0]));
+                if (s->tlsext_ecpointformatlist == NULL)
                         goto err;
-                memcpy(s->internal->tlsext_ecpointformatlist,
-                    ctx->internal->tlsext_ecpointformatlist,
-                    ctx->internal->tlsext_ecpointformatlist_length *
-                    sizeof(ctx->internal->tlsext_ecpointformatlist[0]));
-                s->internal->tlsext_ecpointformatlist_length =
-                    ctx->internal->tlsext_ecpointformatlist_length;
-        }
-        if (ctx->internal->tlsext_supportedgroups != NULL) {
-                s->internal->tlsext_supportedgroups =
-                    calloc(ctx->internal->tlsext_supportedgroups_length,
-                        sizeof(ctx->internal->tlsext_supportedgroups[0]));
-                if (s->internal->tlsext_supportedgroups == NULL)
+                memcpy(s->tlsext_ecpointformatlist,
+                    ctx->tlsext_ecpointformatlist,
+                    ctx->tlsext_ecpointformatlist_length *
+                    sizeof(ctx->tlsext_ecpointformatlist[0]));
+                s->tlsext_ecpointformatlist_length =
+                    ctx->tlsext_ecpointformatlist_length;
+        }
+        if (ctx->tlsext_supportedgroups != NULL) {
+                s->tlsext_supportedgroups =
+                    calloc(ctx->tlsext_supportedgroups_length,
+                        sizeof(ctx->tlsext_supportedgroups[0]));
+                if (s->tlsext_supportedgroups == NULL)
                         goto err;
-                memcpy(s->internal->tlsext_supportedgroups,
-                    ctx->internal->tlsext_supportedgroups,
-                    ctx->internal->tlsext_supportedgroups_length *
-                    sizeof(ctx->internal->tlsext_supportedgroups[0]));
-                s->internal->tlsext_supportedgroups_length =
-                    ctx->internal->tlsext_supportedgroups_length;
-        }
-
-        CBS_init(&cbs, ctx->internal->alpn_client_proto_list,
-            ctx->internal->alpn_client_proto_list_len);
-        if (!CBS_stow(&cbs, &s->internal->alpn_client_proto_list,
-            &s->internal->alpn_client_proto_list_len))
+                memcpy(s->tlsext_supportedgroups,
+                    ctx->tlsext_supportedgroups,
+                    ctx->tlsext_supportedgroups_length *
+                    sizeof(ctx->tlsext_supportedgroups[0]));
+                s->tlsext_supportedgroups_length =
+                    ctx->tlsext_supportedgroups_length;
+        }
+
+        CBS_init(&cbs, ctx->alpn_client_proto_list,
+            ctx->alpn_client_proto_list_len);
+        if (!CBS_stow(&cbs, &s->alpn_client_proto_list,
+            &s->alpn_client_proto_list_len))
                 goto err;
 
         s->verify_result = X509_V_OK;
@@ -349,7 +347,7 @@ SSL_new(SSL_CTX *ctx)
 
         SSL_clear(s);
 
-        CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->internal->ex_data);
+        CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data);
 
         return (s);
 
@@ -391,7 +389,7 @@ int
 SSL_CTX_set_generate_session_id(SSL_CTX *ctx, GEN_SESSION_CB cb)
 {
         CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
-        ctx->internal->generate_session_id = cb;
+        ctx->generate_session_id = cb;
         CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
         return (1);
 }
@@ -400,7 +398,7 @@ int
 SSL_set_generate_session_id(SSL *ssl, GEN_SESSION_CB cb)
 {
         CRYPTO_w_lock(CRYPTO_LOCK_SSL);
-        ssl->internal->generate_session_id = cb;
+        ssl->generate_session_id = cb;
         CRYPTO_w_unlock(CRYPTO_LOCK_SSL);
         return (1);
 }
@@ -426,7 +424,7 @@ SSL_has_matching_session_id(const SSL *ssl, const unsigned char *id,
         memcpy(r.session_id, id, id_len);
 
         CRYPTO_r_lock(CRYPTO_LOCK_SSL_CTX);
-        p = lh_SSL_SESSION_retrieve(ssl->ctx->internal->sessions, &r);
+        p = lh_SSL_SESSION_retrieve(ssl->ctx->sessions, &r);
         CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX);
         return (p != NULL);
 }
@@ -519,7 +517,7 @@ SSL_free(SSL *s)
 
         X509_VERIFY_PARAM_free(s->param);
 
-        CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->internal->ex_data);
+        CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data);
 
         if (s->bbio != NULL) {
                 /* If the buffering BIO is in place, pop it off */
@@ -534,12 +532,12 @@ SSL_free(SSL *s)
                 BIO_free_all(s->rbio);
         BIO_free_all(s->wbio);
 
-        tls13_ctx_free(s->internal->tls13);
+        tls13_ctx_free(s->tls13);
 
         ssl3_release_init_buffer(s);
 
         sk_SSL_CIPHER_free(s->cipher_list);
-        sk_SSL_CIPHER_free(s->internal->cipher_list_tls13);
+        sk_SSL_CIPHER_free(s->cipher_list_tls13);
 
         /* Make the next call work :-) */
         if (s->session != NULL) {
@@ -554,32 +552,31 @@ SSL_free(SSL *s)
         free(s->tlsext_hostname);
         SSL_CTX_free(s->initial_ctx);
 
-        free(s->internal->tlsext_ecpointformatlist);
-        free(s->internal->tlsext_supportedgroups);
+        free(s->tlsext_ecpointformatlist);
+        free(s->tlsext_supportedgroups);
 
-        sk_X509_EXTENSION_pop_free(s->internal->tlsext_ocsp_exts,
+        sk_X509_EXTENSION_pop_free(s->tlsext_ocsp_exts,
             X509_EXTENSION_free);
-        sk_OCSP_RESPID_pop_free(s->internal->tlsext_ocsp_ids, OCSP_RESPID_free);
-        free(s->internal->tlsext_ocsp_resp);
+        sk_OCSP_RESPID_pop_free(s->tlsext_ocsp_ids, OCSP_RESPID_free);
+        free(s->tlsext_ocsp_resp);
 
-        sk_X509_NAME_pop_free(s->internal->client_CA, X509_NAME_free);
+        sk_X509_NAME_pop_free(s->client_CA, X509_NAME_free);
 
         if (s->method != NULL)
                 s->method->ssl_free(s);
 
         SSL_CTX_free(s->ctx);
 
-        free(s->internal->alpn_client_proto_list);
+        free(s->alpn_client_proto_list);
 
-        free(s->internal->quic_transport_params);
+        free(s->quic_transport_params);
 
 #ifndef OPENSSL_NO_SRTP
-        sk_SRTP_PROTECTION_PROFILE_free(s->internal->srtp_profiles);
+        sk_SRTP_PROTECTION_PROFILE_free(s->srtp_profiles);
 #endif
 
-        tls12_record_layer_free(s->internal->rl);
+        tls12_record_layer_free(s->rl);
 
-        free(s->internal);
         free(s);
 }
 
@@ -768,25 +765,25 @@ SSL_get_verify_depth(const SSL *s)
 int
 (*SSL_get_verify_callback(const SSL *s))(int, X509_STORE_CTX *)
 {
-        return (s->internal->verify_callback);
+        return (s->verify_callback);
 }
 
 void
 SSL_CTX_set_keylog_callback(SSL_CTX *ctx, SSL_CTX_keylog_cb_func cb)
 {
-        ctx->internal->keylog_callback = cb;
+        ctx->keylog_callback = cb;
 }
 
 SSL_CTX_keylog_cb_func
 SSL_CTX_get_keylog_callback(const SSL_CTX *ctx)
 {
-        return (ctx->internal->keylog_callback);
+        return (ctx->keylog_callback);
 }
 
 int
 SSL_set_num_tickets(SSL *s, size_t num_tickets)
 {
-        s->internal->num_tickets = num_tickets;
+        s->num_tickets = num_tickets;
 
         return 1;
 }
@@ -794,13 +791,13 @@ SSL_set_num_tickets(SSL *s, size_t num_tickets)
 size_t
 SSL_get_num_tickets(const SSL *s)
 {
-        return s->internal->num_tickets;
+        return s->num_tickets;
 }
 
 int
 SSL_CTX_set_num_tickets(SSL_CTX *ctx, size_t num_tickets)
 {
-        ctx->internal->num_tickets = num_tickets;
+        ctx->num_tickets = num_tickets;
 
         return 1;
 }
@@ -808,7 +805,7 @@ SSL_CTX_set_num_tickets(SSL_CTX *ctx, size_t num_tickets)
 size_t
 SSL_CTX_get_num_tickets(const SSL_CTX *ctx)
 {
-        return ctx->internal->num_tickets;
+        return ctx->num_tickets;
 }
 
 int
@@ -826,7 +823,7 @@ SSL_CTX_get_verify_depth(const SSL_CTX *ctx)
 int
 (*SSL_CTX_get_verify_callback(const SSL_CTX *ctx))(int, X509_STORE_CTX *)
 {
-        return (ctx->internal->default_verify_callback);
+        return (ctx->default_verify_callback);
 }
 
 void
@@ -835,7 +832,7 @@ SSL_set_verify(SSL *s, int mode,
 {
         s->verify_mode = mode;
         if (callback != NULL)
-                s->internal->verify_callback = callback;
+                s->verify_callback = callback;
 }
 
 void
@@ -847,13 +844,13 @@ SSL_set_verify_depth(SSL *s, int depth)
 void
 SSL_set_read_ahead(SSL *s, int yes)
 {
-        s->internal->read_ahead = yes;
+        s->read_ahead = yes;
 }
 
 int
 SSL_get_read_ahead(const SSL *s)
 {
-        return (s->internal->read_ahead);
+        return (s->read_ahead);
 }
 
 int
@@ -897,7 +894,7 @@ SSL_get_peer_cert_chain(const SSL *s)
 STACK_OF(X509) *
 SSL_get0_verified_chain(const SSL *s)
 {
-        return s->internal->verified_chain;
+        return s->verified_chain;
 }
 
 /*
@@ -939,17 +936,17 @@ SSL_copy_session_id(SSL *t, const SSL *f)
 int
 SSL_CTX_check_private_key(const SSL_CTX *ctx)
 {
-        if ((ctx == NULL) || (ctx->internal->cert == NULL) ||
-            (ctx->internal->cert->key->x509 == NULL)) {
+        if ((ctx == NULL) || (ctx->cert == NULL) ||
+            (ctx->cert->key->x509 == NULL)) {
                 SSLerrorx(SSL_R_NO_CERTIFICATE_ASSIGNED);
                 return (0);
         }
-        if (ctx->internal->cert->key->privatekey == NULL) {
+        if (ctx->cert->key->privatekey == NULL) {
                 SSLerrorx(SSL_R_NO_PRIVATE_KEY_ASSIGNED);
                 return (0);
         }
-        return (X509_check_private_key(ctx->internal->cert->key->x509,
-            ctx->internal->cert->key->privatekey));
+        return (X509_check_private_key(ctx->cert->key->x509,
+            ctx->cert->key->privatekey));
 }
 
 /* Fix this function so that it takes an optional type parameter */
@@ -979,7 +976,7 @@ SSL_check_private_key(const SSL *ssl)
 int
 SSL_accept(SSL *s)
 {
-        if (s->internal->handshake_func == NULL)
+        if (s->handshake_func == NULL)
                 SSL_set_accept_state(s); /* Not properly initialized yet */
 
         return (s->method->ssl_accept(s));
@@ -988,7 +985,7 @@ SSL_accept(SSL *s)
 int
 SSL_connect(SSL *s)
 {
-        if (s->internal->handshake_func == NULL)
+        if (s->handshake_func == NULL)
                 SSL_set_connect_state(s); /* Not properly initialized yet */
 
         return (s->method->ssl_connect(s));
@@ -1035,13 +1032,13 @@ SSL_read(SSL *s, void *buf, int num)
                 return (-1);
         }
 
-        if (s->internal->handshake_func == NULL) {
+        if (s->handshake_func == NULL) {
                 SSLerror(s, SSL_R_UNINITIALIZED);
                 return (-1);
         }
 
-        if (s->internal->shutdown & SSL_RECEIVED_SHUTDOWN) {
-                s->internal->rwstate = SSL_NOTHING;
+        if (s->shutdown & SSL_RECEIVED_SHUTDOWN) {
+                s->rwstate = SSL_NOTHING;
                 return (0);
         }
         return ssl3_read(s, buf, num);
@@ -1079,12 +1076,12 @@ SSL_peek(SSL *s, void *buf, int num)
                 return (-1);
         }
 
-        if (s->internal->handshake_func == NULL) {
+        if (s->handshake_func == NULL) {
                 SSLerror(s, SSL_R_UNINITIALIZED);
                 return (-1);
         }
 
-        if (s->internal->shutdown & SSL_RECEIVED_SHUTDOWN) {
+        if (s->shutdown & SSL_RECEIVED_SHUTDOWN) {
                 return (0);
         }
         return ssl3_peek(s, buf, num);
@@ -1122,13 +1119,13 @@ SSL_write(SSL *s, const void *buf, int num)
                 return (-1);
         }
 
-        if (s->internal->handshake_func == NULL) {
+        if (s->handshake_func == NULL) {
                 SSLerror(s, SSL_R_UNINITIALIZED);
                 return (-1);
         }
 
-        if (s->internal->shutdown & SSL_SENT_SHUTDOWN) {
-                s->internal->rwstate = SSL_NOTHING;
+        if (s->shutdown & SSL_SENT_SHUTDOWN) {
+                s->rwstate = SSL_NOTHING;
                 SSLerror(s, SSL_R_PROTOCOL_IS_SHUTDOWN);
                 return (-1);
         }
@@ -1221,7 +1218,7 @@ SSL_shutdown(SSL *s)
          * even if blocking I/O is used (see ssl3_shutdown).
          */
 
-        if (s->internal->handshake_func == NULL) {
+        if (s->handshake_func == NULL) {
                 SSLerror(s, SSL_R_UNINITIALIZED);
                 return (-1);
         }
@@ -1235,10 +1232,10 @@ SSL_shutdown(SSL *s)
 int
 SSL_renegotiate(SSL *s)
 {
-        if (s->internal->renegotiate == 0)
-                s->internal->renegotiate = 1;
+        if (s->renegotiate == 0)
+                s->renegotiate = 1;
 
-        s->internal->new_session = 1;
+        s->new_session = 1;
 
         return (s->method->ssl_renegotiate(s));
 }
@@ -1246,10 +1243,10 @@ SSL_renegotiate(SSL *s)
 int
 SSL_renegotiate_abbreviated(SSL *s)
 {
-        if (s->internal->renegotiate == 0)
-                s->internal->renegotiate = 1;
+        if (s->renegotiate == 0)
+                s->renegotiate = 1;
 
-        s->internal->new_session = 0;
+        s->new_session = 0;
 
         return (s->method->ssl_renegotiate(s));
 }
@@ -1261,7 +1258,7 @@ SSL_renegotiate_pending(SSL *s)
          * Becomes true when negotiation is requested;
          * false again once a handshake has finished.
          */
-        return (s->internal->renegotiate != 0);
+        return (s->renegotiate != 0);
 }
 
 long
@@ -1271,29 +1268,29 @@ SSL_ctrl(SSL *s, int cmd, long larg, void *parg)
 
         switch (cmd) {
         case SSL_CTRL_GET_READ_AHEAD:
-                return (s->internal->read_ahead);
+                return (s->read_ahead);
         case SSL_CTRL_SET_READ_AHEAD:
-                l = s->internal->read_ahead;
-                s->internal->read_ahead = larg;
+                l = s->read_ahead;
+                s->read_ahead = larg;
                 return (l);
 
         case SSL_CTRL_SET_MSG_CALLBACK_ARG:
-                s->internal->msg_callback_arg = parg;
+                s->msg_callback_arg = parg;
                 return (1);
 
         case SSL_CTRL_OPTIONS:
-                return (s->internal->options|=larg);
+                return (s->options|=larg);
         case SSL_CTRL_CLEAR_OPTIONS:
-                return (s->internal->options&=~larg);
+                return (s->options&=~larg);
         case SSL_CTRL_MODE:
-                return (s->internal->mode|=larg);
+                return (s->mode|=larg);
         case SSL_CTRL_CLEAR_MODE:
-                return (s->internal->mode &=~larg);
+                return (s->mode &=~larg);
         case SSL_CTRL_GET_MAX_CERT_LIST:
-                return (s->internal->max_cert_list);
+                return (s->max_cert_list);
         case SSL_CTRL_SET_MAX_CERT_LIST:
-                l = s->internal->max_cert_list;
-                s->internal->max_cert_list = larg;
+                l = s->max_cert_list;
+                s->max_cert_list = larg;
                 return (l);
         case SSL_CTRL_SET_MTU:
 #ifndef OPENSSL_NO_DTLS1
@@ -1326,7 +1323,7 @@ SSL_callback_ctrl(SSL *s, int cmd, void (*fp)(void))
 {
         switch (cmd) {
         case SSL_CTRL_SET_MSG_CALLBACK:
-                s->internal->msg_callback = (ssl_msg_callback_fn *)(fp);
+                s->msg_callback = (ssl_msg_callback_fn *)(fp);
                 return (1);
 
         default:
@@ -1337,7 +1334,7 @@ SSL_callback_ctrl(SSL *s, int cmd, void (*fp)(void))
 struct lhash_st_SSL_SESSION *
 SSL_CTX_sessions(SSL_CTX *ctx)
 {
-        return (ctx->internal->sessions);
+        return (ctx->sessions);
 }
 
 long
@@ -1347,72 +1344,72 @@ SSL_CTX_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg)
 
         switch (cmd) {
         case SSL_CTRL_GET_READ_AHEAD:
-                return (ctx->internal->read_ahead);
+                return (ctx->read_ahead);
         case SSL_CTRL_SET_READ_AHEAD:
-                l = ctx->internal->read_ahead;
-                ctx->internal->read_ahead = larg;
+                l = ctx->read_ahead;
+                ctx->read_ahead = larg;
                 return (l);
 
         case SSL_CTRL_SET_MSG_CALLBACK_ARG:
-                ctx->internal->msg_callback_arg = parg;
+                ctx->msg_callback_arg = parg;
                 return (1);
 
         case SSL_CTRL_GET_MAX_CERT_LIST:
-                return (ctx->internal->max_cert_list);
+                return (ctx->max_cert_list);
         case SSL_CTRL_SET_MAX_CERT_LIST:
-                l = ctx->internal->max_cert_list;
-                ctx->internal->max_cert_list = larg;
+                l = ctx->max_cert_list;
+                ctx->max_cert_list = larg;
                 return (l);
 
         case SSL_CTRL_SET_SESS_CACHE_SIZE:
-                l = ctx->internal->session_cache_size;
-                ctx->internal->session_cache_size = larg;
+                l = ctx->session_cache_size;
+                ctx->session_cache_size = larg;
                 return (l);
         case SSL_CTRL_GET_SESS_CACHE_SIZE:
-                return (ctx->internal->session_cache_size);
+                return (ctx->session_cache_size);
         case SSL_CTRL_SET_SESS_CACHE_MODE:
-                l = ctx->internal->session_cache_mode;
-                ctx->internal->session_cache_mode = larg;
+                l = ctx->session_cache_mode;
+                ctx->session_cache_mode = larg;
                 return (l);
         case SSL_CTRL_GET_SESS_CACHE_MODE:
-                return (ctx->internal->session_cache_mode);
+                return (ctx->session_cache_mode);
 
         case SSL_CTRL_SESS_NUMBER:
-                return (lh_SSL_SESSION_num_items(ctx->internal->sessions));
+                return (lh_SSL_SESSION_num_items(ctx->sessions));
         case SSL_CTRL_SESS_CONNECT:
-                return (ctx->internal->stats.sess_connect);
+                return (ctx->stats.sess_connect);
         case SSL_CTRL_SESS_CONNECT_GOOD:
-                return (ctx->internal->stats.sess_connect_good);
+                return (ctx->stats.sess_connect_good);
         case SSL_CTRL_SESS_CONNECT_RENEGOTIATE:
-                return (ctx->internal->stats.sess_connect_renegotiate);
+                return (ctx->stats.sess_connect_renegotiate);
         case SSL_CTRL_SESS_ACCEPT:
-                return (ctx->internal->stats.sess_accept);
+                return (ctx->stats.sess_accept);
         case SSL_CTRL_SESS_ACCEPT_GOOD:
-                return (ctx->internal->stats.sess_accept_good);
+                return (ctx->stats.sess_accept_good);
         case SSL_CTRL_SESS_ACCEPT_RENEGOTIATE:
-                return (ctx->internal->stats.sess_accept_renegotiate);
+                return (ctx->stats.sess_accept_renegotiate);
         case SSL_CTRL_SESS_HIT:
-                return (ctx->internal->stats.sess_hit);
+                return (ctx->stats.sess_hit);
         case SSL_CTRL_SESS_CB_HIT:
-                return (ctx->internal->stats.sess_cb_hit);
+                return (ctx->stats.sess_cb_hit);
         case SSL_CTRL_SESS_MISSES:
-                return (ctx->internal->stats.sess_miss);
+                return (ctx->stats.sess_miss);
         case SSL_CTRL_SESS_TIMEOUTS:
-                return (ctx->internal->stats.sess_timeout);
+                return (ctx->stats.sess_timeout);
         case SSL_CTRL_SESS_CACHE_FULL:
-                return (ctx->internal->stats.sess_cache_full);
+                return (ctx->stats.sess_cache_full);
         case SSL_CTRL_OPTIONS:
-                return (ctx->internal->options|=larg);
+                return (ctx->options|=larg);
         case SSL_CTRL_CLEAR_OPTIONS:
-                return (ctx->internal->options&=~larg);
+                return (ctx->options&=~larg);
         case SSL_CTRL_MODE:
-                return (ctx->internal->mode|=larg);
+                return (ctx->mode|=larg);
         case SSL_CTRL_CLEAR_MODE:
-                return (ctx->internal->mode&=~larg);
+                return (ctx->mode&=~larg);
         case SSL_CTRL_SET_MAX_SEND_FRAGMENT:
                 if (larg < 512 || larg > SSL3_RT_MAX_PLAIN_LENGTH)
                         return (0);
-                ctx->internal->max_send_fragment = larg;
+                ctx->max_send_fragment = larg;
                 return (1);
         default:
                 return (ssl3_ctx_ctrl(ctx, cmd, larg, parg));
@@ -1424,7 +1421,7 @@ SSL_CTX_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp)(void))
 {
         switch (cmd) {
         case SSL_CTRL_SET_MSG_CALLBACK:
-                ctx->internal->msg_callback = (ssl_msg_callback_fn *)fp;
+                ctx->msg_callback = (ssl_msg_callback_fn *)fp;
                 return (1);
 
         default:
@@ -1562,7 +1559,7 @@ SSL_CTX_set_cipher_list(SSL_CTX *ctx, const char *str)
          * ctx->cipher_list has been updated.
          */
         ciphers = ssl_create_cipher_list(ctx->method, &ctx->cipher_list,
-            ctx->internal->cipher_list_tls13, str, ctx->internal->cert);
+            ctx->cipher_list_tls13, str, ctx->cert);
         if (ciphers == NULL) {
                 return (0);
         } else if (sk_SSL_CIPHER_num(ciphers) == 0) {
@@ -1575,12 +1572,12 @@ SSL_CTX_set_cipher_list(SSL_CTX *ctx, const char *str)
 int
 SSL_CTX_set_ciphersuites(SSL_CTX *ctx, const char *str)
 {
-        if (!ssl_parse_ciphersuites(&ctx->internal->cipher_list_tls13, str)) {
+        if (!ssl_parse_ciphersuites(&ctx->cipher_list_tls13, str)) {
                 SSLerrorx(SSL_R_NO_CIPHER_MATCH);
                 return 0;
         }
         if (!ssl_merge_cipherlists(ctx->cipher_list,
-            ctx->internal->cipher_list_tls13, &ctx->cipher_list))
+            ctx->cipher_list_tls13, &ctx->cipher_list))
                 return 0;
 
         return 1;
@@ -1592,8 +1589,8 @@ SSL_set_cipher_list(SSL *s, const char *str)
 {
         STACK_OF(SSL_CIPHER) *ciphers, *ciphers_tls13;
 
-        if ((ciphers_tls13 = s->internal->cipher_list_tls13) == NULL)
-                ciphers_tls13 = s->ctx->internal->cipher_list_tls13;
+        if ((ciphers_tls13 = s->cipher_list_tls13) == NULL)
+                ciphers_tls13 = s->ctx->cipher_list_tls13;
 
         /* See comment in SSL_CTX_set_cipher_list. */
         ciphers = ssl_create_cipher_list(s->ctx->method, &s->cipher_list,
@@ -1615,11 +1612,11 @@ SSL_set_ciphersuites(SSL *s, const char *str)
         if ((ciphers = s->cipher_list) == NULL)
                 ciphers = s->ctx->cipher_list;
 
-        if (!ssl_parse_ciphersuites(&s->internal->cipher_list_tls13, str)) {
+        if (!ssl_parse_ciphersuites(&s->cipher_list_tls13, str)) {
                 SSLerrorx(SSL_R_NO_CIPHER_MATCH);
                 return (0);
         }
-        if (!ssl_merge_cipherlists(ciphers, s->internal->cipher_list_tls13,
+        if (!ssl_merge_cipherlists(ciphers, s->cipher_list_tls13,
             &s->cipher_list))
                 return 0;
 
@@ -1791,8 +1788,8 @@ SSL_CTX_set_alpn_protos(SSL_CTX *ctx, const unsigned char *protos,
                         goto err;
         }
 
-        if (!CBS_stow(&cbs, &ctx->internal->alpn_client_proto_list,
-            &ctx->internal->alpn_client_proto_list_len))
+        if (!CBS_stow(&cbs, &ctx->alpn_client_proto_list,
+            &ctx->alpn_client_proto_list_len))
                 goto err;
 
         failed = 0;
@@ -1824,8 +1821,8 @@ SSL_set_alpn_protos(SSL *ssl, const unsigned char *protos,
                         goto err;
         }
 
-        if (!CBS_stow(&cbs, &ssl->internal->alpn_client_proto_list,
-            &ssl->internal->alpn_client_proto_list_len))
+        if (!CBS_stow(&cbs, &ssl->alpn_client_proto_list,
+            &ssl->alpn_client_proto_list_len))
                 goto err;
 
         failed = 0;
@@ -1845,8 +1842,8 @@ SSL_CTX_set_alpn_select_cb(SSL_CTX* ctx,
     int (*cb) (SSL *ssl, const unsigned char **out, unsigned char *outlen,
     const unsigned char *in, unsigned int inlen, void *arg), void *arg)
 {
-        ctx->internal->alpn_select_cb = cb;
-        ctx->internal->alpn_select_cb_arg = arg;
+        ctx->alpn_select_cb = cb;
+        ctx->alpn_select_cb_arg = arg;
 }
 
 /*
@@ -1874,12 +1871,12 @@ SSL_export_keying_material(SSL *s, unsigned char *out, size_t olen,
     const char *label, size_t llen, const unsigned char *p, size_t plen,
     int use_context)
 {
-        if (s->internal->tls13 != NULL && s->version == TLS1_3_VERSION) {
+        if (s->tls13 != NULL && s->version == TLS1_3_VERSION) {
                 if (!use_context) {
                         p = NULL;
                         plen = 0;
                 }
-                return tls13_exporter(s->internal->tls13, label, llen, p, plen,
+                return tls13_exporter(s->tls13, label, llen, p, plen,
                     out, olen);
         }
 
@@ -1961,11 +1958,6 @@ SSL_CTX_new(const SSL_METHOD *meth)
                 SSLerrorx(ERR_R_MALLOC_FAILURE);
                 return (NULL);
         }
-        if ((ret->internal = calloc(1, sizeof(*ret->internal))) == NULL) {
-                free(ret);
-                SSLerrorx(ERR_R_MALLOC_FAILURE);
-                return (NULL);
-        }
 
         if (SSL_get_ex_data_X509_STORE_CTX_idx() < 0) {
                 SSLerrorx(SSL_R_X509_VERIFICATION_SETUP_PROBLEMS);
@@ -1973,62 +1965,62 @@ SSL_CTX_new(const SSL_METHOD *meth)
         }
 
         ret->method = meth;
-        ret->internal->min_tls_version = meth->min_tls_version;
-        ret->internal->max_tls_version = meth->max_tls_version;
-        ret->internal->min_proto_version = 0;
-        ret->internal->max_proto_version = 0;
-        ret->internal->mode = SSL_MODE_AUTO_RETRY;
+        ret->min_tls_version = meth->min_tls_version;
+        ret->max_tls_version = meth->max_tls_version;
+        ret->min_proto_version = 0;
+        ret->max_proto_version = 0;
+        ret->mode = SSL_MODE_AUTO_RETRY;
 
         ret->cert_store = NULL;
-        ret->internal->session_cache_mode = SSL_SESS_CACHE_SERVER;
-        ret->internal->session_cache_size = SSL_SESSION_CACHE_MAX_SIZE_DEFAULT;
-        ret->internal->session_cache_head = NULL;
-        ret->internal->session_cache_tail = NULL;
+        ret->session_cache_mode = SSL_SESS_CACHE_SERVER;
+        ret->session_cache_size = SSL_SESSION_CACHE_MAX_SIZE_DEFAULT;
+        ret->session_cache_head = NULL;
+        ret->session_cache_tail = NULL;
 
         /* We take the system default */
         ret->session_timeout = ssl_get_default_timeout();
 
-        ret->internal->new_session_cb = 0;
-        ret->internal->remove_session_cb = 0;
-        ret->internal->get_session_cb = 0;
-        ret->internal->generate_session_id = 0;
+        ret->new_session_cb = 0;
+        ret->remove_session_cb = 0;
+        ret->get_session_cb = 0;
+        ret->generate_session_id = 0;
 
-        memset((char *)&ret->internal->stats, 0, sizeof(ret->internal->stats));
+        memset((char *)&ret->stats, 0, sizeof(ret->stats));
 
         ret->references = 1;
-        ret->internal->quiet_shutdown = 0;
+        ret->quiet_shutdown = 0;
 
-        ret->internal->info_callback = NULL;
+        ret->info_callback = NULL;
 
-        ret->internal->app_verify_callback = 0;
-        ret->internal->app_verify_arg = NULL;
+        ret->app_verify_callback = 0;
+        ret->app_verify_arg = NULL;
 
-        ret->internal->max_cert_list = SSL_MAX_CERT_LIST_DEFAULT;
-        ret->internal->read_ahead = 0;
-        ret->internal->msg_callback = 0;
-        ret->internal->msg_callback_arg = NULL;
+        ret->max_cert_list = SSL_MAX_CERT_LIST_DEFAULT;
+        ret->read_ahead = 0;
+        ret->msg_callback = 0;
+        ret->msg_callback_arg = NULL;
         ret->verify_mode = SSL_VERIFY_NONE;
         ret->sid_ctx_length = 0;
-        ret->internal->default_verify_callback = NULL;
+        ret->default_verify_callback = NULL;
 
-        if ((ret->internal->cert = ssl_cert_new()) == NULL)
+        if ((ret->cert = ssl_cert_new()) == NULL)
                 goto err;
 
         ret->default_passwd_callback = 0;
         ret->default_passwd_callback_userdata = NULL;
-        ret->internal->client_cert_cb = 0;
-        ret->internal->app_gen_cookie_cb = 0;
-        ret->internal->app_verify_cookie_cb = 0;
+        ret->client_cert_cb = 0;
+        ret->app_gen_cookie_cb = 0;
+        ret->app_verify_cookie_cb = 0;
 
-        ret->internal->sessions = lh_SSL_SESSION_new();
-        if (ret->internal->sessions == NULL)
+        ret->sessions = lh_SSL_SESSION_new();
+        if (ret->sessions == NULL)
                 goto err;
         ret->cert_store = X509_STORE_new();
         if (ret->cert_store == NULL)
                 goto err;
 
         ssl_create_cipher_list(ret->method, &ret->cipher_list,
-            NULL, SSL_DEFAULT_CIPHER_LIST, ret->internal->cert);
+            NULL, SSL_DEFAULT_CIPHER_LIST, ret->cert);
         if (ret->cipher_list == NULL ||
             sk_SSL_CIPHER_num(ret->cipher_list) <= 0) {
                 SSLerrorx(SSL_R_LIBRARY_HAS_NO_CIPHERS);
@@ -2039,28 +2031,28 @@ SSL_CTX_new(const SSL_METHOD *meth)
         if (!ret->param)
                 goto err;
 
-        if ((ret->internal->client_CA = sk_X509_NAME_new_null()) == NULL)
+        if ((ret->client_CA = sk_X509_NAME_new_null()) == NULL)
                 goto err;
 
-        CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_CTX, ret, &ret->internal->ex_data);
+        CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_CTX, ret, &ret->ex_data);
 
         ret->extra_certs = NULL;
 
-        ret->internal->max_send_fragment = SSL3_RT_MAX_PLAIN_LENGTH;
+        ret->max_send_fragment = SSL3_RT_MAX_PLAIN_LENGTH;
 
-        ret->internal->tlsext_servername_callback = 0;
-        ret->internal->tlsext_servername_arg = NULL;
+        ret->tlsext_servername_callback = 0;
+        ret->tlsext_servername_arg = NULL;
 
         /* Setup RFC4507 ticket keys */
-        arc4random_buf(ret->internal->tlsext_tick_key_name, 16);
-        arc4random_buf(ret->internal->tlsext_tick_hmac_key, 16);
-        arc4random_buf(ret->internal->tlsext_tick_aes_key, 16);
+        arc4random_buf(ret->tlsext_tick_key_name, 16);
+        arc4random_buf(ret->tlsext_tick_hmac_key, 16);
+        arc4random_buf(ret->tlsext_tick_aes_key, 16);
 
-        ret->internal->tlsext_status_cb = 0;
-        ret->internal->tlsext_status_arg = NULL;
+        ret->tlsext_status_cb = 0;
+        ret->tlsext_status_arg = NULL;
 
 #ifndef OPENSSL_NO_ENGINE
-        ret->internal->client_cert_engine = NULL;
+        ret->client_cert_engine = NULL;
 #ifdef OPENSSL_SSL_CLIENT_ENGINE_AUTO
 #define eng_strx(x)     #x
 #define eng_str(x)      eng_strx(x)
@@ -2083,7 +2075,7 @@ SSL_CTX_new(const SSL_METHOD *meth)
          * Default is to connect to non-RI servers. When RI is more widely
          * deployed might change this.
          */
-        ret->internal->options |= SSL_OP_LEGACY_SERVER_CONNECT;
+        ret->options |= SSL_OP_LEGACY_SERVER_CONNECT;
 
         return (ret);
  err:
@@ -2116,35 +2108,34 @@ SSL_CTX_free(SSL_CTX *ctx)
          * free ex_data, then finally free the cache.
          * (See ticket [openssl.org #212].)
          */
-        if (ctx->internal->sessions != NULL)
+        if (ctx->sessions != NULL)
                 SSL_CTX_flush_sessions(ctx, 0);
 
-        CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL_CTX, ctx, &ctx->internal->ex_data);
+        CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL_CTX, ctx, &ctx->ex_data);
 
-        lh_SSL_SESSION_free(ctx->internal->sessions);
+        lh_SSL_SESSION_free(ctx->sessions);
 
         X509_STORE_free(ctx->cert_store);
         sk_SSL_CIPHER_free(ctx->cipher_list);
-        sk_SSL_CIPHER_free(ctx->internal->cipher_list_tls13);
-        ssl_cert_free(ctx->internal->cert);
-        sk_X509_NAME_pop_free(ctx->internal->client_CA, X509_NAME_free);
+        sk_SSL_CIPHER_free(ctx->cipher_list_tls13);
+        ssl_cert_free(ctx->cert);
+        sk_X509_NAME_pop_free(ctx->client_CA, X509_NAME_free);
         sk_X509_pop_free(ctx->extra_certs, X509_free);
 
 #ifndef OPENSSL_NO_SRTP
-        if (ctx->internal->srtp_profiles)
-                sk_SRTP_PROTECTION_PROFILE_free(ctx->internal->srtp_profiles);
+        if (ctx->srtp_profiles)
+                sk_SRTP_PROTECTION_PROFILE_free(ctx->srtp_profiles);
 #endif
 
 #ifndef OPENSSL_NO_ENGINE
-        ENGINE_finish(ctx->internal->client_cert_engine);
+        ENGINE_finish(ctx->client_cert_engine);
 #endif
 
-        free(ctx->internal->tlsext_ecpointformatlist);
-        free(ctx->internal->tlsext_supportedgroups);
+        free(ctx->tlsext_ecpointformatlist);
+        free(ctx->tlsext_supportedgroups);
 
-        free(ctx->internal->alpn_client_proto_list);
+        free(ctx->alpn_client_proto_list);
 
-        free(ctx->internal);
         free(ctx);
 }
 
@@ -2183,15 +2174,15 @@ void
 SSL_CTX_set_cert_verify_callback(SSL_CTX *ctx,
     int (*cb)(X509_STORE_CTX *, void *), void *arg)
 {
-        ctx->internal->app_verify_callback = cb;
-        ctx->internal->app_verify_arg = 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->internal->default_verify_callback = cb;
+        ctx->default_verify_callback = cb;
 }
 
 void
@@ -2363,14 +2354,14 @@ ssl_should_update_external_cache(SSL *s, int mode)
 {
         int cache_mode;
 
-        cache_mode = s->session_ctx->internal->session_cache_mode;
+        cache_mode = s->session_ctx->session_cache_mode;
 
         /* Don't cache if mode says not to */
         if ((cache_mode & mode) == 0)
                 return 0;
 
         /* if it is not already cached, cache it */
-        if (!s->internal->hit)
+        if (!s->hit)
                 return 1;
 
         /* If it's TLS 1.3, do it to match OpenSSL */
@@ -2385,14 +2376,14 @@ ssl_should_update_internal_cache(SSL *s, int mode)
 {
         int cache_mode;
 
-        cache_mode = s->session_ctx->internal->session_cache_mode;
+        cache_mode = s->session_ctx->session_cache_mode;
 
         /* Don't cache if mode says not to */
         if ((cache_mode & mode) == 0)
                 return 0;
 
         /* If it is already cached, don't cache it again */
-        if (s->internal->hit)
+        if (s->hit)
                 return 0;
 
         if ((cache_mode & SSL_SESS_CACHE_NO_INTERNAL_STORE) != 0)
@@ -2415,11 +2406,11 @@ ssl_should_update_internal_cache(SSL *s, int mode)
          * to know about this even if it's a stateless ticket
          * from 1.3 so we can know when it is removed.
          */
-        if (s->session_ctx->internal->remove_session_cb != NULL)
+        if (s->session_ctx->remove_session_cb != NULL)
                 return 1;
 
         /* If we have set OP_NO_TICKET, cache it. */
-        if ((s->internal->options & SSL_OP_NO_TICKET) != 0)
+        if ((s->options & SSL_OP_NO_TICKET) != 0)
                 return 1;
 
         /* Otherwise do not cache */
@@ -2434,7 +2425,7 @@ ssl_update_cache(SSL *s, int mode)
         if (s->session->session_id_length == 0)
                 return;
 
-        cache_mode = s->session_ctx->internal->session_cache_mode;
+        cache_mode = s->session_ctx->session_cache_mode;
         do_callback = ssl_should_update_external_cache(s, mode);
 
         if (ssl_should_update_internal_cache(s, mode)) {
@@ -2455,9 +2446,9 @@ ssl_update_cache(SSL *s, int mode)
          * same glorious experience they expect from OpenSSL which
          * does it this way.
          */
-        if (do_callback && s->session_ctx->internal->new_session_cb != NULL) {
+        if (do_callback && s->session_ctx->new_session_cb != NULL) {
                     CRYPTO_add(&s->session->references, 1, CRYPTO_LOCK_SSL_SESSION);
-                    if (!s->session_ctx->internal->new_session_cb(s, s->session))
+                    if (!s->session_ctx->new_session_cb(s, s->session))
                             SSL_SESSION_free(s->session);
         }
 
@@ -2466,9 +2457,9 @@ ssl_update_cache(SSL *s, int mode)
             (cache_mode & mode) != 0) {
                 int connections;
                 if (mode & SSL_SESS_CACHE_CLIENT)
-                        connections = s->session_ctx->internal->stats.sess_connect_good;
+                        connections = s->session_ctx->stats.sess_connect_good;
                 else
-                        connections = s->session_ctx->internal->stats.sess_accept_good;
+                        connections = s->session_ctx->stats.sess_accept_good;
                 if ((connections & 0xff) == 0xff)
                         SSL_CTX_flush_sessions(s->session_ctx, time(NULL));
         }
@@ -2489,9 +2480,9 @@ SSL_set_ssl_method(SSL *s, const SSL_METHOD *method)
         if (s->method == method)
                 return (ret);
 
-        if (s->internal->handshake_func == s->method->ssl_connect)
+        if (s->handshake_func == s->method->ssl_connect)
                 handshake_func = method->ssl_connect;
-        else if (s->internal->handshake_func == s->method->ssl_accept)
+        else if (s->handshake_func == s->method->ssl_accept)
                 handshake_func = method->ssl_accept;
 
         if (s->method->version == method->version) {
@@ -2501,7 +2492,7 @@ SSL_set_ssl_method(SSL *s, const SSL_METHOD *method)
                 s->method = method;
                 ret = s->method->ssl_new(s);
         }
-        s->internal->handshake_func = handshake_func;
+        s->handshake_func = handshake_func;
 
         return (ret);
 }
@@ -2537,7 +2528,7 @@ SSL_get_error(const SSL *s, int i)
                          * 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->internal->rwstate incorrectly (so that we have
+                         * 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.
@@ -2578,7 +2569,7 @@ SSL_get_error(const SSL *s, int i)
         if (SSL_want_x509_lookup(s))
                 return (SSL_ERROR_WANT_X509_LOOKUP);
 
-        if ((s->internal->shutdown & SSL_RECEIVED_SHUTDOWN) &&
+        if ((s->shutdown & SSL_RECEIVED_SHUTDOWN) &&
             (s->s3->warn_alert == SSL_AD_CLOSE_NOTIFY))
                 return (SSL_ERROR_ZERO_RETURN);
 
@@ -2631,15 +2622,15 @@ SSL_quic_max_handshake_flight_len(const SSL *ssl,
                          * to request client certificates.
                          */
                         if ((SSL_get_verify_mode(ssl) & SSL_VERIFY_PEER) != 0 &&
-                            ssl->internal->max_cert_list > flight_len)
-                                flight_len = ssl->internal->max_cert_list;
+                            ssl->max_cert_list > flight_len)
+                                flight_len = ssl->max_cert_list;
                 } else {
                         /*
                          * Clients may receive both Certificate message and a
                          * CertificateRequest message.
                          */
-                        if (ssl->internal->max_cert_list * 2 > flight_len)
-                                flight_len = ssl->internal->max_cert_list * 2;
+                        if (ssl->max_cert_list * 2 > flight_len)
+                                flight_len = ssl->max_cert_list * 2;
                 }
                 return flight_len;
         case ssl_encryption_application:
@@ -2709,7 +2700,7 @@ SSL_process_quic_post_handshake(SSL *ssl)
 int
 SSL_do_handshake(SSL *s)
 {
-        if (s->internal->handshake_func == NULL) {
+        if (s->handshake_func == NULL) {
                 SSLerror(s, SSL_R_CONNECTION_TYPE_NOT_SET);
                 return (-1);
         }
@@ -2719,7 +2710,7 @@ SSL_do_handshake(SSL *s)
         if (!SSL_in_init(s) && !SSL_in_before(s))
                 return 1;
 
-        return s->internal->handshake_func(s);
+        return s->handshake_func(s);
 }
 
 /*
@@ -2730,9 +2721,9 @@ void
 SSL_set_accept_state(SSL *s)
 {
         s->server = 1;
-        s->internal->shutdown = 0;
+        s->shutdown = 0;
         s->s3->hs.state = SSL_ST_ACCEPT|SSL_ST_BEFORE;
-        s->internal->handshake_func = s->method->ssl_accept;
+        s->handshake_func = s->method->ssl_accept;
         ssl_clear_cipher_state(s);
 }
 
@@ -2740,9 +2731,9 @@ void
 SSL_set_connect_state(SSL *s)
 {
         s->server = 0;
-        s->internal->shutdown = 0;
+        s->shutdown = 0;
         s->s3->hs.state = SSL_ST_CONNECT|SSL_ST_BEFORE;
-        s->internal->handshake_func = s->method->ssl_connect;
+        s->handshake_func = s->method->ssl_connect;
         ssl_clear_cipher_state(s);
 }
 
@@ -2832,24 +2823,24 @@ SSL_dup(SSL *s)
                         goto err;
         }
 
-        ret->internal->options = s->internal->options;
-        ret->internal->mode = s->internal->mode;
+        ret->options = s->options;
+        ret->mode = s->mode;
         SSL_set_max_cert_list(ret, SSL_get_max_cert_list(s));
         SSL_set_read_ahead(ret, SSL_get_read_ahead(s));
-        ret->internal->msg_callback = s->internal->msg_callback;
-        ret->internal->msg_callback_arg = s->internal->msg_callback_arg;
+        ret->msg_callback = s->msg_callback;
+        ret->msg_callback_arg = s->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));
-        ret->internal->generate_session_id = s->internal->generate_session_id;
+        ret->generate_session_id = s->generate_session_id;
 
         SSL_set_info_callback(ret, SSL_get_info_callback(s));
 
-        ret->internal->debug = s->internal->debug;
+        ret->debug = s->debug;
 
         /* copy app data, a little dangerous perhaps */
         if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_SSL,
-            &ret->internal->ex_data, &s->internal->ex_data))
+            &ret->ex_data, &s->ex_data))
                 goto err;
 
         /* setup rbio, and wbio */
@@ -2864,25 +2855,25 @@ SSL_dup(SSL *s)
                 } else
                         ret->wbio = ret->rbio;
         }
-        ret->internal->rwstate = s->internal->rwstate;
-        ret->internal->in_handshake = s->internal->in_handshake;
-        ret->internal->handshake_func = s->internal->handshake_func;
+        ret->rwstate = s->rwstate;
+        ret->in_handshake = s->in_handshake;
+        ret->handshake_func = s->handshake_func;
         ret->server = s->server;
-        ret->internal->renegotiate = s->internal->renegotiate;
-        ret->internal->new_session = s->internal->new_session;
-        ret->internal->quiet_shutdown = s->internal->quiet_shutdown;
-        ret->internal->shutdown = s->internal->shutdown;
+        ret->renegotiate = s->renegotiate;
+        ret->new_session = s->new_session;
+        ret->quiet_shutdown = s->quiet_shutdown;
+        ret->shutdown = s->shutdown;
         /* SSL_dup does not really work at any state, though */
         ret->s3->hs.state = s->s3->hs.state;
-        ret->internal->rstate = s->internal->rstate;
+        ret->rstate = s->rstate;
 
         /*
          * Would have to copy ret->init_buf, ret->init_msg, ret->init_num,
          * ret->init_off
          */
-        ret->internal->init_num = 0;
+        ret->init_num = 0;
 
-        ret->internal->hit = s->internal->hit;
+        ret->hit = s->hit;
 
         X509_VERIFY_PARAM_inherit(ret->param, s->param);
 
@@ -2891,16 +2882,16 @@ SSL_dup(SSL *s)
                     sk_SSL_CIPHER_dup(s->cipher_list)) == NULL)
                         goto err;
         }
-        if (s->internal->cipher_list_tls13 != NULL) {
-                if ((ret->internal->cipher_list_tls13 =
-                    sk_SSL_CIPHER_dup(s->internal->cipher_list_tls13)) == NULL)
+        if (s->cipher_list_tls13 != NULL) {
+                if ((ret->cipher_list_tls13 =
+                    sk_SSL_CIPHER_dup(s->cipher_list_tls13)) == NULL)
                         goto err;
         }
 
         /* Dup the client_CA list */
-        if (s->internal->client_CA != NULL) {
-                if ((sk = sk_X509_NAME_dup(s->internal->client_CA)) == NULL) goto err;
-                        ret->internal->client_CA = sk;
+        if (s->client_CA != NULL) {
+                if ((sk = sk_X509_NAME_dup(s->client_CA)) == NULL) goto err;
+                        ret->client_CA = sk;
                 for (i = 0; i < sk_X509_NAME_num(sk); i++) {
                         xn = sk_X509_NAME_value(sk, i);
                         if (sk_X509_NAME_set(sk, i,
@@ -2920,8 +2911,8 @@ SSL_dup(SSL *s)
 void
 ssl_clear_cipher_state(SSL *s)
 {
-        tls12_record_layer_clear_read_state(s->internal->rl);
-        tls12_record_layer_clear_write_state(s->internal->rl);
+        tls12_record_layer_clear_read_state(s->rl);
+        tls12_record_layer_clear_write_state(s->rl);
 }
 
 void
@@ -2929,8 +2920,8 @@ ssl_info_callback(const SSL *s, int type, int value)
 {
         ssl_info_callback_fn *cb;
 
-        if ((cb = s->internal->info_callback) == NULL)
-                cb = s->ctx->internal->info_callback;
+        if ((cb = s->info_callback) == NULL)
+                cb = s->ctx->info_callback;
         if (cb != NULL)
                 cb(s, type, value);
 }
@@ -2939,11 +2930,11 @@ void
 ssl_msg_callback(SSL *s, int is_write, int content_type,
     const void *msg_buf, size_t msg_len)
 {
-        if (s->internal->msg_callback == NULL)
+        if (s->msg_callback == NULL)
                 return;
 
-        s->internal->msg_callback(is_write, s->version, content_type,
-            msg_buf, msg_len, s, s->internal->msg_callback_arg);
+        s->msg_callback(is_write, s->version, content_type,
+            msg_buf, msg_len, s, s->msg_callback_arg);
 }
 
 void
@@ -3068,37 +3059,37 @@ ssl_free_wbio_buffer(SSL *s)
 void
 SSL_CTX_set_quiet_shutdown(SSL_CTX *ctx, int mode)
 {
-        ctx->internal->quiet_shutdown = mode;
+        ctx->quiet_shutdown = mode;
 }
 
 int
 SSL_CTX_get_quiet_shutdown(const SSL_CTX *ctx)
 {
-        return (ctx->internal->quiet_shutdown);
+        return (ctx->quiet_shutdown);
 }
 
 void
 SSL_set_quiet_shutdown(SSL *s, int mode)
 {
-        s->internal->quiet_shutdown = mode;
+        s->quiet_shutdown = mode;
 }
 
 int
 SSL_get_quiet_shutdown(const SSL *s)
 {
-        return (s->internal->quiet_shutdown);
+        return (s->quiet_shutdown);
 }
 
 void
 SSL_set_shutdown(SSL *s, int mode)
 {
-        s->internal->shutdown = mode;
+        s->shutdown = mode;
 }
 
 int
 SSL_get_shutdown(const SSL *s)
 {
-        return (s->internal->shutdown);
+        return (s->shutdown);
 }
 
 int
@@ -3123,7 +3114,7 @@ SSL_set_SSL_CTX(SSL *ssl, SSL_CTX* ctx)
         if (ssl->ctx == ctx)
                 return (ssl->ctx);
 
-        if ((new_cert = ssl_cert_dup(ctx->internal->cert)) == NULL)
+        if ((new_cert = ssl_cert_dup(ctx->cert)) == NULL)
                 return NULL;
         ssl_cert_free(ssl->cert);
         ssl->cert = new_cert;
@@ -3157,12 +3148,12 @@ SSL_CTX_load_verify_mem(SSL_CTX *ctx, void *buf, int len)
 void
 SSL_set_info_callback(SSL *ssl, void (*cb)(const SSL *ssl, int type, int val))
 {
-        ssl->internal->info_callback = cb;
+        ssl->info_callback = cb;
 }
 
 void (*SSL_get_info_callback(const SSL *ssl))(const SSL *ssl, int type, int val)
 {
-        return (ssl->internal->info_callback);
+        return (ssl->info_callback);
 }
 
 int
@@ -3218,13 +3209,13 @@ SSL_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
 int
 SSL_set_ex_data(SSL *s, int idx, void *arg)
 {
-        return (CRYPTO_set_ex_data(&s->internal->ex_data, idx, 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->internal->ex_data, idx));
+        return (CRYPTO_get_ex_data(&s->ex_data, idx));
 }
 
 int
@@ -3238,13 +3229,13 @@ SSL_CTX_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
 int
 SSL_CTX_set_ex_data(SSL_CTX *s, int idx, void *arg)
 {
-        return (CRYPTO_set_ex_data(&s->internal->ex_data, idx, 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->internal->ex_data, idx));
+        return (CRYPTO_get_ex_data(&s->ex_data, idx));
 }
 
 int
@@ -3269,25 +3260,25 @@ SSL_CTX_set_cert_store(SSL_CTX *ctx, X509_STORE *store)
 X509 *
 SSL_CTX_get0_certificate(const SSL_CTX *ctx)
 {
-        if (ctx->internal->cert == NULL)
+        if (ctx->cert == NULL)
                 return NULL;
 
-        return ctx->internal->cert->key->x509;
+        return ctx->cert->key->x509;
 }
 
 EVP_PKEY *
 SSL_CTX_get0_privatekey(const SSL_CTX *ctx)
 {
-        if (ctx->internal->cert == NULL)
+        if (ctx->cert == NULL)
                 return NULL;
 
-        return ctx->internal->cert->key->privatekey;
+        return ctx->cert->key->privatekey;
 }
 
 int
 SSL_want(const SSL *s)
 {
-        return (s->internal->rwstate);
+        return (s->rwstate);
 }
 
 void
@@ -3352,68 +3343,68 @@ SSL_set_msg_callback(SSL *ssl, void (*cb)(int write_p, int version,
 void
 SSL_set_debug(SSL *s, int debug)
 {
-        s->internal->debug = debug;
+        s->debug = debug;
 }
 
 int
 SSL_cache_hit(SSL *s)
 {
-        return (s->internal->hit);
+        return (s->hit);
 }
 
 int
 SSL_CTX_get_min_proto_version(SSL_CTX *ctx)
 {
-        return ctx->internal->min_proto_version;
+        return ctx->min_proto_version;
 }
 
 int
 SSL_CTX_set_min_proto_version(SSL_CTX *ctx, uint16_t version)
 {
         return ssl_version_set_min(ctx->method, version,
-            ctx->internal->max_tls_version, &ctx->internal->min_tls_version,
-            &ctx->internal->min_proto_version);
+            ctx->max_tls_version, &ctx->min_tls_version,
+            &ctx->min_proto_version);
 }
 
 int
 SSL_CTX_get_max_proto_version(SSL_CTX *ctx)
 {
-        return ctx->internal->max_proto_version;
+        return ctx->max_proto_version;
 }
 
 int
 SSL_CTX_set_max_proto_version(SSL_CTX *ctx, uint16_t version)
 {
         return ssl_version_set_max(ctx->method, version,
-            ctx->internal->min_tls_version, &ctx->internal->max_tls_version,
-            &ctx->internal->max_proto_version);
+            ctx->min_tls_version, &ctx->max_tls_version,
+            &ctx->max_proto_version);
 }
 
 int
 SSL_get_min_proto_version(SSL *ssl)
 {
-        return ssl->internal->min_proto_version;
+        return ssl->min_proto_version;
 }
 
 int
 SSL_set_min_proto_version(SSL *ssl, uint16_t version)
 {
         return ssl_version_set_min(ssl->method, version,
-            ssl->internal->max_tls_version, &ssl->internal->min_tls_version,
-            &ssl->internal->min_proto_version);
+            ssl->max_tls_version, &ssl->min_tls_version,
+            &ssl->min_proto_version);
 }
 int
 SSL_get_max_proto_version(SSL *ssl)
 {
-        return ssl->internal->max_proto_version;
+        return ssl->max_proto_version;
 }
 
 int
 SSL_set_max_proto_version(SSL *ssl, uint16_t version)
 {
         return ssl_version_set_max(ssl->method, version,
-            ssl->internal->min_tls_version, &ssl->internal->max_tls_version,
-            &ssl->internal->max_proto_version);
+            ssl->min_tls_version, &ssl->max_tls_version,
+            &ssl->max_proto_version);
 }
 
 const SSL_METHOD *
@@ -3425,13 +3416,13 @@ SSL_CTX_get_ssl_method(const SSL_CTX *ctx)
 int
 SSL_CTX_get_security_level(const SSL_CTX *ctx)
 {
-        return ctx->internal->cert->security_level;
+        return ctx->cert->security_level;
 }
 
 void
 SSL_CTX_set_security_level(SSL_CTX *ctx, int level)
 {
-        ctx->internal->cert->security_level = level;
+        ctx->cert->security_level = level;
 }
 
 int
@@ -3456,16 +3447,16 @@ int
 SSL_set_quic_transport_params(SSL *ssl, const uint8_t *params,
     size_t params_len)
 {
-        freezero(ssl->internal->quic_transport_params,
-            ssl->internal->quic_transport_params_len);
-        ssl->internal->quic_transport_params = NULL;
-        ssl->internal->quic_transport_params_len = 0;
+        freezero(ssl->quic_transport_params,
+            ssl->quic_transport_params_len);
+        ssl->quic_transport_params = NULL;
+        ssl->quic_transport_params_len = 0;
 
-        if ((ssl->internal->quic_transport_params = malloc(params_len)) == NULL)
+        if ((ssl->quic_transport_params = malloc(params_len)) == NULL)
                 return 0;
 
-        memcpy(ssl->internal->quic_transport_params, params, params_len);
-        ssl->internal->quic_transport_params_len = params_len;
+        memcpy(ssl->quic_transport_params, params, params_len);
+        ssl->quic_transport_params_len = params_len;
 
         return 1;
 }
diff --git a/src/lib/libssl/ssl_locl.h b/src/lib/libssl/ssl_locl.h
index a8d5308e8c..8046ad8c86 100644
--- a/src/lib/libssl/ssl_locl.h
+++ b/src/lib/libssl/ssl_locl.h
@@ -1,4 +1,4 @@
-/* $OpenBSD: ssl_locl.h,v 1.426 2022/10/01 16:23:15 jsing Exp $ */
+/* $OpenBSD: ssl_locl.h,v 1.427 2022/10/02 16:36:41 jsing Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -713,7 +713,42 @@ typedef void (ssl_info_callback_fn)(const SSL *s, int type, int val);
 typedef void (ssl_msg_callback_fn)(int is_write, int version, int content_type,
     const void *buf, size_t len, SSL *ssl, void *arg);
 
-typedef struct ssl_ctx_internal_st {
+struct ssl_ctx_st {
+        const SSL_METHOD *method;
+        const SSL_QUIC_METHOD *quic_method;
+
+        STACK_OF(SSL_CIPHER) *cipher_list;
+
+        struct x509_store_st /* X509_STORE */ *cert_store;
+
+        /* 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 */
+        long session_timeout;
+
+        int references;
+
+        /* Default values to use in SSL structures follow (these are copied by SSL_new) */
+
+        STACK_OF(X509) *extra_certs;
+
+        int verify_mode;
+        size_t sid_ctx_length;
+        unsigned char sid_ctx[SSL_MAX_SID_CTX_LENGTH];
+
+        X509_VERIFY_PARAM *param;
+
+        /*
+         * XXX
+         * default_passwd_cb used by python and openvpn, need to keep it until we
+         * add an accessor
+         */
+        /* Default password callback. */
+        pem_password_cb *default_passwd_callback;
+
+        /* Default password callback user data. */
+        void *default_passwd_callback_userdata;
+
         uint16_t min_tls_version;
         uint16_t max_tls_version;
 
@@ -879,48 +914,72 @@ typedef struct ssl_ctx_internal_st {
         uint16_t *tlsext_supportedgroups; /* our list */
         SSL_CTX_keylog_cb_func keylog_callback; /* Unused. For OpenSSL compatibility. */
         size_t num_tickets; /* Unused, for OpenSSL compatibility */
-} SSL_CTX_INTERNAL;
+};
+
+struct ssl_st {
+        /* protocol version
+         * (one of SSL2_VERSION, SSL3_VERSION, TLS1_VERSION, DTLS1_VERSION)
+         */
+        int version;
 
-struct ssl_ctx_st {
         const SSL_METHOD *method;
         const SSL_QUIC_METHOD *quic_method;
 
-        STACK_OF(SSL_CIPHER) *cipher_list;
+        /* 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 */
 
-        struct x509_store_st /* X509_STORE */ *cert_store;
+        BIO *rbio; /* used by SSL_read */
+        BIO *wbio; /* used by SSL_write */
+        BIO *bbio; /* used during session-id reuse to concatenate
+                    * messages */
+        int server;     /* are we the server side? - mostly used by SSL_clear*/
 
-        /* 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 */
-        long session_timeout;
+        struct ssl3_state_st *s3; /* SSLv3 variables */
+        struct dtls1_state_st *d1; /* DTLSv1 variables */
 
-        int references;
+        X509_VERIFY_PARAM *param;
 
-        /* Default values to use in SSL structures follow (these are copied by SSL_new) */
+        /* crypto */
+        STACK_OF(SSL_CIPHER) *cipher_list;
 
-        STACK_OF(X509) *extra_certs;
+        /* This is used to hold the server certificate used */
+        SSL_CERT *cert;
 
-        int verify_mode;
+        /* 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];
 
-        X509_VERIFY_PARAM *param;
+        /* This can also be in the session once a session is established */
+        SSL_SESSION *session;
 
-        /*
-         * XXX
-         * default_passwd_cb used by python and openvpn, need to keep it until we
-         * add an accessor
-         */
-        /* Default password callback. */
-        pem_password_cb *default_passwd_callback;
+        /* Used in SSL2 and SSL3 */
+        int verify_mode;        /* 0 don't care about verify failure.
+                                 * 1 fail if verify fails */
+        int error;              /* error bytes to be written */
+        int error_code;         /* actual code */
 
-        /* Default password callback user data. */
-        void *default_passwd_callback_userdata;
+        SSL_CTX *ctx;
 
-        struct ssl_ctx_internal_st *internal;
-};
+        long verify_result;
+
+        int references;
+
+        int client_version;     /* what was passed, used for
+                                 * SSLv3/TLS rollback check */
+
+        unsigned int max_send_fragment;
+
+        char *tlsext_hostname;
+
+        /* certificate status request info */
+        /* Status type or -1 if no status type */
+        int tlsext_status_type;
+
+        SSL_CTX * initial_ctx; /* initial ctx, used to store sessions */
+#define session_ctx initial_ctx
 
-typedef struct ssl_internal_st {
         struct tls13_ctx *tls13;
 
         uint16_t min_tls_version;
@@ -1066,73 +1125,6 @@ typedef struct ssl_internal_st {
 
         size_t num_tickets; /* Unused, for OpenSSL compatibility */
         STACK_OF(X509) *verified_chain;
-} SSL_INTERNAL;
-
-struct ssl_st {
-        /* protocol version
-         * (one of SSL2_VERSION, SSL3_VERSION, TLS1_VERSION, DTLS1_VERSION)
-         */
-        int version;
-
-        const SSL_METHOD *method;
-        const SSL_QUIC_METHOD *quic_method;
-
-        /* 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 */
-
-        BIO *rbio; /* used by SSL_read */
-        BIO *wbio; /* used by SSL_write */
-        BIO *bbio; /* used during session-id reuse to concatenate
-                    * messages */
-        int server;     /* are we the server side? - mostly used by SSL_clear*/
-
-        struct ssl3_state_st *s3; /* SSLv3 variables */
-        struct dtls1_state_st *d1; /* DTLSv1 variables */
-
-        X509_VERIFY_PARAM *param;
-
-        /* crypto */
-        STACK_OF(SSL_CIPHER) *cipher_list;
-
-        /* This is used to hold the server certificate used */
-        SSL_CERT *cert;
-
-        /* 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;
-
-        /* Used in SSL2 and SSL3 */
-        int verify_mode;        /* 0 don't care about verify failure.
-                                 * 1 fail if verify fails */
-        int error;              /* error bytes to be written */
-        int error_code;         /* actual code */
-
-        SSL_CTX *ctx;
-
-        long verify_result;
-
-        int references;
-
-        int client_version;     /* what was passed, used for
-                                 * SSLv3/TLS rollback check */
-
-        unsigned int max_send_fragment;
-
-        char *tlsext_hostname;
-
-        /* certificate status request info */
-        /* Status type or -1 if no status type */
-        int tlsext_status_type;
-
-        SSL_CTX * initial_ctx; /* initial ctx, used to store sessions */
-#define session_ctx initial_ctx
-
-        struct ssl_internal_st *internal;
 };
 
 typedef struct ssl3_record_internal_st {
diff --git a/src/lib/libssl/ssl_packet.c b/src/lib/libssl/ssl_packet.c
index 091685b217..b2c3d0f2a0 100644
--- a/src/lib/libssl/ssl_packet.c
+++ b/src/lib/libssl/ssl_packet.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ssl_packet.c,v 1.13 2022/02/05 14:54:10 jsing Exp $ */
+/* $OpenBSD: ssl_packet.c,v 1.14 2022/10/02 16:36:41 jsing Exp $ */
 /*
  * Copyright (c) 2016, 2017 Joel Sing <jsing@openbsd.org>
  *
@@ -84,7 +84,7 @@ ssl_convert_sslv2_client_hello(SSL *s)
 
         memset(&cbb, 0, sizeof(cbb));
 
-        CBS_init(&cbs, s->internal->packet, SSL3_RT_HEADER_LENGTH);
+        CBS_init(&cbs, s->packet, SSL3_RT_HEADER_LENGTH);
 
         if (!CBS_get_u16(&cbs, &record_length) ||
             !CBS_get_u8(&cbs, &message_type) ||
@@ -119,17 +119,17 @@ ssl_convert_sslv2_client_hello(SSL *s)
         if (n != record_length + 2)
                 return n;
 
-        tls1_transcript_record(s, s->internal->packet + 2,
-            s->internal->packet_length - 2);
-        s->internal->mac_packet = 0;
+        tls1_transcript_record(s, s->packet + 2,
+            s->packet_length - 2);
+        s->mac_packet = 0;
 
-        if (s->internal->msg_callback)
-                s->internal->msg_callback(0, SSL2_VERSION, 0,
-                    s->internal->packet + 2, s->internal->packet_length - 2, s,
-                    s->internal->msg_callback_arg);
+        if (s->msg_callback)
+                s->msg_callback(0, SSL2_VERSION, 0,
+                    s->packet + 2, s->packet_length - 2, s,
+                    s->msg_callback_arg);
 
         /* Decode the SSLv2 record containing the client hello. */
-        CBS_init(&cbs, s->internal->packet, s->internal->packet_length);
+        CBS_init(&cbs, s->packet, s->packet_length);
 
         if (!CBS_get_u16(&cbs, &record_length))
                 return -1;
@@ -212,9 +212,9 @@ ssl_convert_sslv2_client_hello(SSL *s)
         if (data_len > s->s3->rbuf.len)
                 goto err;
 
-        s->internal->packet = s->s3->rbuf.buf;
-        s->internal->packet_length = data_len;
-        memcpy(s->internal->packet, data, data_len);
+        s->packet = s->s3->rbuf.buf;
+        s->packet_length = data_len;
+        memcpy(s->packet, data, data_len);
         ret = 1;
 
  err:
@@ -240,7 +240,7 @@ ssl_server_legacy_first_packet(SSL *s)
         if (SSL_is_dtls(s))
                 return 1;
 
-        CBS_init(&header, s->internal->packet, SSL3_RT_HEADER_LENGTH);
+        CBS_init(&header, s->packet, SSL3_RT_HEADER_LENGTH);
 
         if (ssl_is_sslv3_handshake(&header) == 1)
                 return 1;
diff --git a/src/lib/libssl/ssl_pkt.c b/src/lib/libssl/ssl_pkt.c
index d9f5a0d057..8462d03967 100644
--- a/src/lib/libssl/ssl_pkt.c
+++ b/src/lib/libssl/ssl_pkt.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ssl_pkt.c,v 1.60 2022/09/11 13:51:25 jsing Exp $ */
+/* $OpenBSD: ssl_pkt.c,v 1.61 2022/10/02 16:36:41 jsing Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -136,16 +136,16 @@ ssl_force_want_read(SSL *s)
         BIO_clear_retry_flags(bio);
         BIO_set_retry_read(bio);
 
-        s->internal->rwstate = SSL_READING;
+        s->rwstate = SSL_READING;
 }
 
 /*
  * 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 s->s3->rbuf.buf specified
- * by s->internal->packet and s->internal->packet_length.
- * (If s->internal->read_ahead is set, 'max' bytes may be stored in rbuf
- * [plus s->internal->packet_length bytes if extend == 1].)
+ * by s->packet and s->packet_length.
+ * (If s->read_ahead is set, 'max' bytes may be stored in rbuf
+ * [plus s->packet_length bytes if extend == 1].)
  */
 static int
 ssl3_read_n(SSL *s, int n, int max, int extend)
@@ -187,8 +187,8 @@ ssl3_read_n(SSL *s, int n, int max, int extend)
                                 rb->offset = align;
                         }
                 }
-                s->internal->packet = rb->buf + rb->offset;
-                s->internal->packet_length = 0;
+                s->packet = rb->buf + rb->offset;
+                s->packet_length = 0;
                 /* ... now we can act as if 'extend' was set */
         }
 
@@ -202,7 +202,7 @@ ssl3_read_n(SSL *s, int n, int max, int extend)
 
         /* if there is enough in the buffer from a previous read, take some */
         if (left >= n) {
-                s->internal->packet_length += n;
+                s->packet_length += n;
                 rb->left = left - n;
                 rb->offset += n;
                 return (n);
@@ -210,15 +210,15 @@ ssl3_read_n(SSL *s, int n, int max, int extend)
 
         /* else we need to read more data */
 
-        len = s->internal->packet_length;
+        len = s->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 (s->internal->packet != pkt)  {
+        if (s->packet != pkt)  {
                 /* len > 0 */
-                memmove(pkt, s->internal->packet, len + left);
-                s->internal->packet = pkt;
+                memmove(pkt, s->packet, len + left);
+                s->packet = pkt;
                 rb->offset = len + align;
         }
 
@@ -228,7 +228,7 @@ ssl3_read_n(SSL *s, int n, int max, int extend)
                 return -1;
         }
 
-        if (s->internal->read_ahead || SSL_is_dtls(s)) {
+        if (s->read_ahead || SSL_is_dtls(s)) {
                 if (max < n)
                         max = n;
                 if (max > (int)(rb->len - rb->offset))
@@ -245,7 +245,7 @@ ssl3_read_n(SSL *s, int n, int max, int extend)
 
                 errno = 0;
                 if (s->rbio != NULL) {
-                        s->internal->rwstate = SSL_READING;
+                        s->rwstate = SSL_READING;
                         i = BIO_read(s->rbio, pkt + len + left, max - left);
                 } else {
                         SSLerror(s, SSL_R_READ_BIO_NOT_SET);
@@ -254,7 +254,7 @@ ssl3_read_n(SSL *s, int n, int max, int extend)
 
                 if (i <= 0) {
                         rb->left = left;
-                        if (s->internal->mode & SSL_MODE_RELEASE_BUFFERS &&
+                        if (s->mode & SSL_MODE_RELEASE_BUFFERS &&
                             !SSL_is_dtls(s)) {
                                 if (len + left == 0)
                                         ssl3_release_read_buffer(s);
@@ -277,8 +277,8 @@ ssl3_read_n(SSL *s, int n, int max, int extend)
         /* done reading, now the book-keeping */
         rb->offset += n;
         rb->left = left - n;
-        s->internal->packet_length += n;
-        s->internal->rwstate = SSL_NOTHING;
+        s->packet_length += n;
+        s->rwstate = SSL_NOTHING;
 
         return (n);
 }
@@ -291,8 +291,8 @@ ssl3_packet_read(SSL *s, int plen)
         n = ssl3_read_n(s, plen, s->s3->rbuf.len, 0);
         if (n <= 0)
                 return n;
-        if (s->internal->packet_length < plen)
-                return s->internal->packet_length;
+        if (s->packet_length < plen)
+                return s->packet_length;
 
         return plen;
 }
@@ -302,15 +302,15 @@ ssl3_packet_extend(SSL *s, int plen)
 {
         int rlen, n;
 
-        if (s->internal->packet_length >= plen)
+        if (s->packet_length >= plen)
                 return plen;
-        rlen = plen - s->internal->packet_length;
+        rlen = plen - s->packet_length;
 
         n = ssl3_read_n(s, rlen, rlen, 1);
         if (n <= 0)
                 return n;
-        if (s->internal->packet_length < plen)
-                return s->internal->packet_length;
+        if (s->packet_length < plen)
+                return s->packet_length;
 
         return plen;
 }
@@ -319,9 +319,9 @@ ssl3_packet_extend(SSL *s, int plen)
  * 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->internal->rrec.type    - is the type of record
- * ssl->s3->internal->rrec.data,         - data
- * ssl->s3->internal->rrec.length, - number of bytes
+ * ssl->s3->rrec.type    - is the type of record
+ * ssl->s3->rrec.data,   - data
+ * ssl->s3->rrec.length, - number of bytes
  */
 /* used only by ssl3_read_bytes */
 static int
@@ -337,8 +337,8 @@ ssl3_get_record(SSL *s)
 
  again:
         /* check if we have the header */
-        if ((s->internal->rstate != SSL_ST_READ_BODY) ||
-            (s->internal->packet_length < SSL3_RT_HEADER_LENGTH)) {
+        if ((s->rstate != SSL_ST_READ_BODY) ||
+            (s->packet_length < SSL3_RT_HEADER_LENGTH)) {
                 CBS header;
                 uint16_t len, ssl_version;
                 uint8_t type;
@@ -347,16 +347,16 @@ ssl3_get_record(SSL *s)
                 if (n <= 0)
                         return (n);
 
-                s->internal->mac_packet = 1;
-                s->internal->rstate = SSL_ST_READ_BODY;
+                s->mac_packet = 1;
+                s->rstate = SSL_ST_READ_BODY;
 
-                if (s->server && s->internal->first_packet) {
+                if (s->server && s->first_packet) {
                         if ((ret = ssl_server_legacy_first_packet(s)) != 1)
                                 return (ret);
                         ret = -1;
                 }
 
-                CBS_init(&header, s->internal->packet, SSL3_RT_HEADER_LENGTH);
+                CBS_init(&header, s->packet, SSL3_RT_HEADER_LENGTH);
 
                 /* Pull apart the header into the SSL3_RECORD_INTERNAL */
                 if (!CBS_get_u8(&header, &type) ||
@@ -370,9 +370,9 @@ ssl3_get_record(SSL *s)
                 rr->length = len;
 
                 /* Lets check version */
-                if (!s->internal->first_packet && ssl_version != s->version) {
+                if (!s->first_packet && ssl_version != s->version) {
                         if ((s->version & 0xFF00) == (ssl_version & 0xFF00) &&
-                            !tls12_record_layer_write_protected(s->internal->rl)) {
+                            !tls12_record_layer_write_protected(s->rl)) {
                                 /* Send back error using their minor version number :-) */
                                 s->version = ssl_version;
                         }
@@ -399,17 +399,17 @@ ssl3_get_record(SSL *s)
         if (n != SSL3_RT_HEADER_LENGTH + rr->length)
                 return (n);
 
-        s->internal->rstate = SSL_ST_READ_HEADER; /* set state for later operations */
+        s->rstate = SSL_ST_READ_HEADER; /* set state for later operations */
 
         /*
          * A full record has now been read from the wire, which now needs
          * to be processed.
          */
-        tls12_record_layer_set_version(s->internal->rl, s->version);
+        tls12_record_layer_set_version(s->rl, s->version);
 
-        if (!tls12_record_layer_open_record(s->internal->rl, s->internal->packet,
-            s->internal->packet_length, &out, &out_len)) {
-                tls12_record_layer_alert(s->internal->rl, &alert_desc);
+        if (!tls12_record_layer_open_record(s->rl, s->packet,
+            s->packet_length, &out, &out_len)) {
+                tls12_record_layer_alert(s->rl, &alert_desc);
 
                 if (alert_desc == 0)
                         goto err;
@@ -428,7 +428,7 @@ ssl3_get_record(SSL *s)
         rr->off = 0;
 
         /* we have pulled in a full packet so zero things */
-        s->internal->packet_length = 0;
+        s->packet_length = 0;
 
         if (rr->length == 0) {
                 /*
@@ -446,18 +446,18 @@ ssl3_get_record(SSL *s)
                  * insert a single empty record, so we allow ourselves to read
                  * once past a single empty record without forcing want_read.
                  */
-                if (s->internal->empty_record_count++ > SSL_MAX_EMPTY_RECORDS) {
+                if (s->empty_record_count++ > SSL_MAX_EMPTY_RECORDS) {
                         SSLerror(s, SSL_R_PEER_BEHAVING_BADLY);
                         return -1;
                 }
-                if (s->internal->empty_record_count > 1) {
+                if (s->empty_record_count > 1) {
                         ssl_force_want_read(s);
                         return -1;
                 }
                 goto again;
         }
 
-        s->internal->empty_record_count = 0;
+        s->empty_record_count = 0;
 
         return (1);
 
@@ -482,12 +482,12 @@ ssl3_write_bytes(SSL *s, int type, const void *buf_, int len)
                 return -1;
         }
 
-        s->internal->rwstate = SSL_NOTHING;
+        s->rwstate = SSL_NOTHING;
         tot = s->s3->wnum;
         s->s3->wnum = 0;
 
-        if (SSL_in_init(s) && !s->internal->in_handshake) {
-                i = s->internal->handshake_func(s);
+        if (SSL_in_init(s) && !s->in_handshake) {
+                i = s->handshake_func(s);
                 if (i < 0)
                         return (i);
                 if (i == 0) {
@@ -512,7 +512,7 @@ ssl3_write_bytes(SSL *s, int type, const void *buf_, int len)
                 }
 
                 if ((i == (int)n) || (type == SSL3_RT_APPLICATION_DATA &&
-                    (s->internal->mode & SSL_MODE_ENABLE_PARTIAL_WRITE))) {
+                    (s->mode & SSL_MODE_ENABLE_PARTIAL_WRITE))) {
                         /*
                          * Next chunk of data should get another prepended
                          * empty fragment in ciphersuites with known-IV
@@ -573,7 +573,7 @@ do_ssl3_write(SSL *s, int type, const unsigned char *buf, unsigned int len)
          */
         version = s->version;
         if (s->s3->hs.state == SSL3_ST_CW_CLNT_HELLO_B &&
-            !s->internal->renegotiate &&
+            !s->renegotiate &&
             s->s3->hs.our_max_tls_version > TLS1_VERSION)
                 version = TLS1_VERSION;
 
@@ -582,7 +582,7 @@ do_ssl3_write(SSL *s, int type, const unsigned char *buf, unsigned int len)
          * (see http://www.openssl.org/~bodo/tls-cbc.txt). Note that this
          * is unnecessary for AEAD.
          */
-        if (sess != NULL && tls12_record_layer_write_protected(s->internal->rl)) {
+        if (sess != NULL && tls12_record_layer_write_protected(s->rl)) {
                 if (s->s3->need_empty_fragments &&
                     !s->s3->empty_fragment_done &&
                     type == SSL3_RT_APPLICATION_DATA)
@@ -603,16 +603,16 @@ do_ssl3_write(SSL *s, int type, const unsigned char *buf, unsigned int len)
         if (!CBB_init_fixed(&cbb, wb->buf + align, wb->len - align))
                 goto err;
 
-        tls12_record_layer_set_version(s->internal->rl, version);
+        tls12_record_layer_set_version(s->rl, version);
 
         if (need_empty_fragment) {
-                if (!tls12_record_layer_seal_record(s->internal->rl, type,
+                if (!tls12_record_layer_seal_record(s->rl, type,
                     buf, 0, &cbb))
                         goto err;
                 s->s3->empty_fragment_done = 1;
         }
 
-        if (!tls12_record_layer_seal_record(s->internal->rl, type, buf, len, &cbb))
+        if (!tls12_record_layer_seal_record(s->rl, type, buf, len, &cbb))
                 goto err;
 
         if (!CBB_finish(&cbb, NULL, &out_len))
@@ -647,7 +647,7 @@ ssl3_write_pending(SSL *s, int type, const unsigned char *buf, unsigned int len)
 
         /* XXXX */
         if ((s->s3->wpend_tot > (int)len) || ((s->s3->wpend_buf != buf) &&
-            !(s->internal->mode & SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER)) ||
+            !(s->mode & SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER)) ||
             (s->s3->wpend_type != type)) {
                 SSLerror(s, SSL_R_BAD_WRITE_RETRY);
                 return (-1);
@@ -656,7 +656,7 @@ ssl3_write_pending(SSL *s, int type, const unsigned char *buf, unsigned int len)
         for (;;) {
                 errno = 0;
                 if (s->wbio != NULL) {
-                        s->internal->rwstate = SSL_WRITING;
+                        s->rwstate = SSL_WRITING;
                         i = BIO_write(s->wbio, (char *)&(wb->buf[wb->offset]),
                             (unsigned int)wb->left);
                 } else {
@@ -666,10 +666,10 @@ ssl3_write_pending(SSL *s, int type, const unsigned char *buf, unsigned int len)
                 if (i == wb->left) {
                         wb->left = 0;
                         wb->offset += i;
-                        if (s->internal->mode & SSL_MODE_RELEASE_BUFFERS &&
+                        if (s->mode & SSL_MODE_RELEASE_BUFFERS &&
                             !SSL_is_dtls(s))
                                 ssl3_release_write_buffer(s);
-                        s->internal->rwstate = SSL_NOTHING;
+                        s->rwstate = SSL_NOTHING;
                         return (s->s3->wpend_ret);
                 } else if (i <= 0) {
                         /*
@@ -731,7 +731,7 @@ ssl3_read_alert(SSL *s)
         if (alert_level == SSL3_AL_WARNING) {
                 s->s3->warn_alert = alert_descr;
                 if (alert_descr == SSL_AD_CLOSE_NOTIFY) {
-                        s->internal->shutdown |= SSL_RECEIVED_SHUTDOWN;
+                        s->shutdown |= SSL_RECEIVED_SHUTDOWN;
                         return 0;
                 }
                 /* We requested renegotiation and the peer rejected it. */
@@ -742,11 +742,11 @@ ssl3_read_alert(SSL *s)
                         return -1;
                 }
         } else if (alert_level == SSL3_AL_FATAL) {
-                s->internal->rwstate = SSL_NOTHING;
+                s->rwstate = SSL_NOTHING;
                 s->s3->fatal_alert = alert_descr;
                 SSLerror(s, SSL_AD_REASON_OFFSET + alert_descr);
                 ERR_asprintf_error_data("SSL alert number %d", alert_descr);
-                s->internal->shutdown |= SSL_RECEIVED_SHUTDOWN;
+                s->shutdown |= SSL_RECEIVED_SHUTDOWN;
                 SSL_CTX_remove_session(s->ctx, s->session);
                 return 0;
         } else {
@@ -847,7 +847,7 @@ ssl3_read_handshake_unexpected(SSL *s)
         if (s->s3->handshake_fragment_len < sizeof(s->s3->handshake_fragment))
                 return 1;
 
-        if (s->internal->in_handshake) {
+        if (s->in_handshake) {
                 SSLerror(s, ERR_R_INTERNAL_ERROR);
                 return -1;
         }
@@ -937,7 +937,7 @@ ssl3_read_handshake_unexpected(SSL *s)
                         return -1;
                 }
 
-                if ((s->internal->options & SSL_OP_NO_CLIENT_RENEGOTIATION) != 0) {
+                if ((s->options & SSL_OP_NO_CLIENT_RENEGOTIATION) != 0) {
                         ssl3_send_alert(s, SSL3_AL_FATAL,
                             SSL_AD_NO_RENEGOTIATION);
                         return -1;
@@ -957,8 +957,8 @@ ssl3_read_handshake_unexpected(SSL *s)
                 }
 
                 s->s3->hs.state = SSL_ST_ACCEPT;
-                s->internal->renegotiate = 1;
-                s->internal->new_session = 1;
+                s->renegotiate = 1;
+                s->new_session = 1;
 
         } else {
                 SSLerror(s, SSL_R_UNEXPECTED_MESSAGE);
@@ -966,14 +966,14 @@ ssl3_read_handshake_unexpected(SSL *s)
                 return -1;
         }
 
-        if ((ret = s->internal->handshake_func(s)) < 0)
+        if ((ret = s->handshake_func(s)) < 0)
                 return ret;
         if (ret == 0) {
                 SSLerror(s, SSL_R_SSL_HANDSHAKE_FAILURE);
                 return -1;
         }
 
-        if (!(s->internal->mode & SSL_MODE_AUTO_RETRY)) {
+        if (!(s->mode & SSL_MODE_AUTO_RETRY)) {
                 if (s->s3->rbuf.left == 0) {
                         ssl_force_want_read(s);
                         return -1;
@@ -1062,8 +1062,8 @@ ssl3_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek)
                 return n;
         }
 
-        if (SSL_in_init(s) && !s->internal->in_handshake) {
-                if ((ret = s->internal->handshake_func(s)) < 0)
+        if (SSL_in_init(s) && !s->in_handshake) {
+                if ((ret = s->handshake_func(s)) < 0)
                         return ret;
                 if (ret == 0) {
                         SSLerror(s, SSL_R_SSL_HANDSHAKE_FAILURE);
@@ -1085,11 +1085,11 @@ ssl3_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek)
                 return -1;
         }
 
-        s->internal->rwstate = SSL_NOTHING;
+        s->rwstate = SSL_NOTHING;
 
         rr = &s->s3->rrec;
 
-        if (rr->length == 0 || s->internal->rstate == SSL_ST_READ_BODY) {
+        if (rr->length == 0 || s->rstate == SSL_ST_READ_BODY) {
                 if ((ret = ssl3_get_record(s)) <= 0)
                         return ret;
         }
@@ -1106,8 +1106,8 @@ ssl3_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek)
          * If the other end has shut down, throw anything we read away (even in
          * 'peek' mode).
          */
-        if (s->internal->shutdown & SSL_RECEIVED_SHUTDOWN) {
-                s->internal->rwstate = SSL_NOTHING;
+        if (s->shutdown & SSL_RECEIVED_SHUTDOWN) {
+                s->rwstate = SSL_NOTHING;
                 rr->length = 0;
                 return 0;
         }
@@ -1119,7 +1119,7 @@ ssl3_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek)
                  * are doing a handshake for the first time.
                  */
                 if (SSL_in_init(s) && type == SSL3_RT_APPLICATION_DATA &&
-                    !tls12_record_layer_read_protected(s->internal->rl)) {
+                    !tls12_record_layer_read_protected(s->rl)) {
                         SSLerror(s, SSL_R_APP_DATA_IN_HANDSHAKE);
                         ssl3_send_alert(s, SSL3_AL_FATAL,
                             SSL_AD_UNEXPECTED_MESSAGE);
@@ -1140,9 +1140,9 @@ ssl3_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek)
                         rr->length -= n;
                         rr->off += n;
                         if (rr->length == 0) {
-                                s->internal->rstate = SSL_ST_READ_HEADER;
+                                s->rstate = SSL_ST_READ_HEADER;
                                 rr->off = 0;
-                                if (s->internal->mode & SSL_MODE_RELEASE_BUFFERS &&
+                                if (s->mode & SSL_MODE_RELEASE_BUFFERS &&
                                     s->s3->rbuf.left == 0)
                                         ssl3_release_read_buffer(s);
                         }
@@ -1162,8 +1162,8 @@ ssl3_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek)
                 goto start;
         }
 
-        if (s->internal->shutdown & SSL_SENT_SHUTDOWN) {
-                s->internal->rwstate = SSL_NOTHING;
+        if (s->shutdown & SSL_SENT_SHUTDOWN) {
+                s->rwstate = SSL_NOTHING;
                 rr->length = 0;
                 return 0;
         }
diff --git a/src/lib/libssl/ssl_seclevel.c b/src/lib/libssl/ssl_seclevel.c
index b691b9bc4b..7026b330cf 100644
--- a/src/lib/libssl/ssl_seclevel.c
+++ b/src/lib/libssl/ssl_seclevel.c
@@ -1,4 +1,4 @@
-/*      $OpenBSD: ssl_seclevel.c,v 1.25 2022/08/17 18:41:17 tb Exp $ */
+/*      $OpenBSD: ssl_seclevel.c,v 1.26 2022/10/02 16:36:41 jsing Exp $ */
 /*
  * Copyright (c) 2020-2022 Theo Buehler <tb@openbsd.org>
  *
@@ -224,8 +224,8 @@ ssl_security_default_cb(const SSL *ssl, const SSL_CTX *ctx, int secop, int bits,
 static int
 ssl_ctx_security(const SSL_CTX *ctx, int secop, int bits, int nid, void *other)
 {
-        return ctx->internal->cert->security_cb(NULL, ctx, secop, bits, nid,
-            other, ctx->internal->cert->security_ex_data);
+        return ctx->cert->security_cb(NULL, ctx, secop, bits, nid,
+            other, ctx->cert->security_ex_data);
 }
 
 static int
diff --git a/src/lib/libssl/ssl_sess.c b/src/lib/libssl/ssl_sess.c
index 7cf36f8984..45c6ddb682 100644
--- a/src/lib/libssl/ssl_sess.c
+++ b/src/lib/libssl/ssl_sess.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ssl_sess.c,v 1.117 2022/08/17 07:39:19 jsing Exp $ */
+/* $OpenBSD: ssl_sess.c,v 1.118 2022/10/02 16:36:41 jsing Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -354,17 +354,17 @@ ssl_get_new_session(SSL *s, int session)
                 }
 
                 /* If RFC4507 ticket use empty session ID. */
-                if (s->internal->tlsext_ticket_expected) {
+                if (s->tlsext_ticket_expected) {
                         ss->session_id_length = 0;
                         goto sess_id_done;
                 }
 
                 /* Choose which callback will set the session ID. */
                 CRYPTO_r_lock(CRYPTO_LOCK_SSL_CTX);
-                if (s->internal->generate_session_id)
-                        cb = s->internal->generate_session_id;
-                else if (s->session_ctx->internal->generate_session_id)
-                        cb = s->session_ctx->internal->generate_session_id;
+                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_r_unlock(CRYPTO_LOCK_SSL_CTX);
 
                 /* Choose a session ID. */
@@ -430,7 +430,7 @@ ssl_session_from_cache(SSL *s, CBS *session_id)
         SSL_SESSION *sess;
         SSL_SESSION data;
 
-        if ((s->session_ctx->internal->session_cache_mode &
+        if ((s->session_ctx->session_cache_mode &
              SSL_SESS_CACHE_NO_INTERNAL_LOOKUP))
                 return NULL;
 
@@ -443,13 +443,13 @@ ssl_session_from_cache(SSL *s, CBS *session_id)
                 return NULL;
 
         CRYPTO_r_lock(CRYPTO_LOCK_SSL_CTX);
-        sess = lh_SSL_SESSION_retrieve(s->session_ctx->internal->sessions, &data);
+        sess = lh_SSL_SESSION_retrieve(s->session_ctx->sessions, &data);
         if (sess != NULL)
                 CRYPTO_add(&sess->references, 1, CRYPTO_LOCK_SSL_SESSION);
         CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX);
 
         if (sess == NULL)
-                s->session_ctx->internal->stats.sess_miss++;
+                s->session_ctx->stats.sess_miss++;
 
         return sess;
 }
@@ -460,11 +460,11 @@ ssl_session_from_callback(SSL *s, CBS *session_id)
         SSL_SESSION *sess;
         int copy;
 
-        if (s->session_ctx->internal->get_session_cb == NULL)
+        if (s->session_ctx->get_session_cb == NULL)
                 return NULL;
 
         copy = 1;
-        if ((sess = s->session_ctx->internal->get_session_cb(s,
+        if ((sess = s->session_ctx->get_session_cb(s,
             CBS_data(session_id), CBS_len(session_id), &copy)) == NULL)
                 return NULL;
         /*
@@ -476,10 +476,10 @@ ssl_session_from_callback(SSL *s, CBS *session_id)
         if (copy)
                 CRYPTO_add(&sess->references, 1, CRYPTO_LOCK_SSL_SESSION);
 
-        s->session_ctx->internal->stats.sess_cb_hit++;
+        s->session_ctx->stats.sess_cb_hit++;
 
         /* Add the externally cached session to the internal cache as well. */
-        if (!(s->session_ctx->internal->session_cache_mode &
+        if (!(s->session_ctx->session_cache_mode &
             SSL_SESS_CACHE_NO_INTERNAL_STORE)) {
                 /*
                  * The following should not return 1,
@@ -523,7 +523,7 @@ ssl_session_by_id(SSL *s, CBS *session_id)
  *   - 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.
- *   - For both new and resumed sessions, s->internal->tlsext_ticket_expected
+ *   - For both new and resumed sessions, s->tlsext_ticket_expected
  *     indicates whether the server should issue a new session ticket or not.
  */
 int
@@ -538,7 +538,7 @@ ssl_get_prev_session(SSL *s, CBS *session_id, CBS *ext_block, int *alert)
         if (CBS_len(session_id) > SSL_MAX_SSL_SESSION_ID_LENGTH)
                 goto err;
 
-        /* Sets s->internal->tlsext_ticket_expected. */
+        /* Sets s->tlsext_ticket_expected. */
         switch (tls1_process_ticket(s, ext_block, &alert_desc, &sess)) {
         case TLS1_TICKET_FATAL_ERROR:
                 fatal = 1;
@@ -605,7 +605,7 @@ ssl_get_prev_session(SSL *s, CBS *session_id, CBS *ext_block, int *alert)
         }
 
         if (sess->timeout < (time(NULL) - sess->time)) {
-                s->session_ctx->internal->stats.sess_timeout++;
+                s->session_ctx->stats.sess_timeout++;
                 if (!ticket_decrypted) {
                         /* The session was from the cache, so remove it. */
                         SSL_CTX_remove_session(s->session_ctx, sess);
@@ -613,7 +613,7 @@ ssl_get_prev_session(SSL *s, CBS *session_id, CBS *ext_block, int *alert)
                 goto err;
         }
 
-        s->session_ctx->internal->stats.sess_hit++;
+        s->session_ctx->stats.sess_hit++;
 
         SSL_SESSION_free(s->session);
         s->session = sess;
@@ -628,7 +628,7 @@ ssl_get_prev_session(SSL *s, CBS *session_id, CBS *ext_block, int *alert)
                  * The session was from a ticket. Issue a ticket for the new
                  * session.
                  */
-                s->internal->tlsext_ticket_expected = 1;
+                s->tlsext_ticket_expected = 1;
         }
         if (fatal) {
                 *alert = alert_desc;
@@ -655,12 +655,12 @@ SSL_CTX_add_session(SSL_CTX *ctx, SSL_SESSION *c)
          * later.
          */
         CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
-        s = lh_SSL_SESSION_insert(ctx->internal->sessions, c);
+        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->internal->sessions), or we're in trouble.
+         * ctx->sessions), or we're in trouble.
          */
         if (s != NULL && s != c) {
                 /* We *are* in trouble ... */
@@ -700,10 +700,10 @@ SSL_CTX_add_session(SSL_CTX *ctx, SSL_SESSION *c)
                         while (SSL_CTX_sess_number(ctx) >
                             SSL_CTX_sess_get_cache_size(ctx)) {
                                 if (!remove_session_lock(ctx,
-                                    ctx->internal->session_cache_tail, 0))
+                                    ctx->session_cache_tail, 0))
                                         break;
                                 else
-                                        ctx->internal->stats.sess_cache_full++;
+                                        ctx->stats.sess_cache_full++;
                         }
                 }
         }
@@ -728,9 +728,9 @@ remove_session_lock(SSL_CTX *ctx, SSL_SESSION *c, int lck)
 
         if (lck)
                 CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
-        if ((r = lh_SSL_SESSION_retrieve(ctx->internal->sessions, c)) == c) {
+        if ((r = lh_SSL_SESSION_retrieve(ctx->sessions, c)) == c) {
                 ret = 1;
-                r = lh_SSL_SESSION_delete(ctx->internal->sessions, c);
+                r = lh_SSL_SESSION_delete(ctx->sessions, c);
                 SSL_SESSION_list_remove(ctx, c);
         }
         if (lck)
@@ -738,8 +738,8 @@ remove_session_lock(SSL_CTX *ctx, SSL_SESSION *c, int lck)
 
         if (ret) {
                 r->not_resumable = 1;
-                if (ctx->internal->remove_session_cb != NULL)
-                        ctx->internal->remove_session_cb(ctx, r);
+                if (ctx->remove_session_cb != NULL)
+                        ctx->remove_session_cb(ctx, r);
                 SSL_SESSION_free(r);
         }
 
@@ -942,8 +942,8 @@ SSL_set_session_secret_cb(SSL *s, int (*tls_session_secret_cb)(SSL *s,
 {
         if (s == NULL)
                 return (0);
-        s->internal->tls_session_secret_cb = tls_session_secret_cb;
-        s->internal->tls_session_secret_cb_arg = arg;
+        s->tls_session_secret_cb = tls_session_secret_cb;
+        s->tls_session_secret_cb_arg = arg;
         return (1);
 }
 
@@ -953,8 +953,8 @@ SSL_set_session_ticket_ext_cb(SSL *s, tls_session_ticket_ext_cb_fn cb,
 {
         if (s == NULL)
                 return (0);
-        s->internal->tls_session_ticket_ext_cb = cb;
-        s->internal->tls_session_ticket_ext_cb_arg = arg;
+        s->tls_session_ticket_ext_cb = cb;
+        s->tls_session_ticket_ext_cb_arg = arg;
         return (1);
 }
 
@@ -962,23 +962,23 @@ int
 SSL_set_session_ticket_ext(SSL *s, void *ext_data, int ext_len)
 {
         if (s->version >= TLS1_VERSION) {
-                free(s->internal->tlsext_session_ticket);
-                s->internal->tlsext_session_ticket =
+                free(s->tlsext_session_ticket);
+                s->tlsext_session_ticket =
                     malloc(sizeof(TLS_SESSION_TICKET_EXT) + ext_len);
-                if (!s->internal->tlsext_session_ticket) {
+                if (!s->tlsext_session_ticket) {
                         SSLerror(s, ERR_R_MALLOC_FAILURE);
                         return 0;
                 }
 
                 if (ext_data) {
-                        s->internal->tlsext_session_ticket->length = ext_len;
-                        s->internal->tlsext_session_ticket->data =
-                            s->internal->tlsext_session_ticket + 1;
-                        memcpy(s->internal->tlsext_session_ticket->data,
+                        s->tlsext_session_ticket->length = ext_len;
+                        s->tlsext_session_ticket->data =
+                            s->tlsext_session_ticket + 1;
+                        memcpy(s->tlsext_session_ticket->data,
                             ext_data, ext_len);
                 } else {
-                        s->internal->tlsext_session_ticket->length = 0;
-                        s->internal->tlsext_session_ticket->data = NULL;
+                        s->tlsext_session_ticket->length = 0;
+                        s->tlsext_session_ticket->data = NULL;
                 }
 
                 return 1;
@@ -1003,8 +1003,8 @@ timeout_doall_arg(SSL_SESSION *s, TIMEOUT_PARAM *p)
                 (void)lh_SSL_SESSION_delete(p->cache, s);
                 SSL_SESSION_list_remove(p->ctx, s);
                 s->not_resumable = 1;
-                if (p->ctx->internal->remove_session_cb != NULL)
-                        p->ctx->internal->remove_session_cb(p->ctx, s);
+                if (p->ctx->remove_session_cb != NULL)
+                        p->ctx->remove_session_cb(p->ctx, s);
                 SSL_SESSION_free(s);
         }
 }
@@ -1026,7 +1026,7 @@ SSL_CTX_flush_sessions(SSL_CTX *s, long t)
         TIMEOUT_PARAM tp;
 
         tp.ctx = s;
-        tp.cache = s->internal->sessions;
+        tp.cache = s->sessions;
         if (tp.cache == NULL)
                 return;
         tp.time = t;
@@ -1042,7 +1042,7 @@ SSL_CTX_flush_sessions(SSL_CTX *s, long t)
 int
 ssl_clear_bad_session(SSL *s)
 {
-        if ((s->session != NULL) && !(s->internal->shutdown & SSL_SENT_SHUTDOWN) &&
+        if ((s->session != NULL) && !(s->shutdown & SSL_SENT_SHUTDOWN) &&
             !(SSL_in_init(s) || SSL_in_before(s))) {
                 SSL_CTX_remove_session(s->ctx, s->session);
                 return (1);
@@ -1057,23 +1057,23 @@ SSL_SESSION_list_remove(SSL_CTX *ctx, SSL_SESSION *s)
         if (s->next == NULL || s->prev == NULL)
                 return;
 
-        if (s->next == (SSL_SESSION *)&(ctx->internal->session_cache_tail)) {
+        if (s->next == (SSL_SESSION *)&(ctx->session_cache_tail)) {
                 /* last element in list */
-                if (s->prev == (SSL_SESSION *)&(ctx->internal->session_cache_head)) {
+                if (s->prev == (SSL_SESSION *)&(ctx->session_cache_head)) {
                         /* only one element in list */
-                        ctx->internal->session_cache_head = NULL;
-                        ctx->internal->session_cache_tail = NULL;
+                        ctx->session_cache_head = NULL;
+                        ctx->session_cache_tail = NULL;
                 } else {
-                        ctx->internal->session_cache_tail = s->prev;
+                        ctx->session_cache_tail = s->prev;
                         s->prev->next =
-                            (SSL_SESSION *)&(ctx->internal->session_cache_tail);
+                            (SSL_SESSION *)&(ctx->session_cache_tail);
                 }
         } else {
-                if (s->prev == (SSL_SESSION *)&(ctx->internal->session_cache_head)) {
+                if (s->prev == (SSL_SESSION *)&(ctx->session_cache_head)) {
                         /* first element in list */
-                        ctx->internal->session_cache_head = s->next;
+                        ctx->session_cache_head = s->next;
                         s->next->prev =
-                            (SSL_SESSION *)&(ctx->internal->session_cache_head);
+                            (SSL_SESSION *)&(ctx->session_cache_head);
                 } else {
                         /* middle of list */
                         s->next->prev = s->prev;
@@ -1089,83 +1089,83 @@ SSL_SESSION_list_add(SSL_CTX *ctx, SSL_SESSION *s)
         if (s->next != NULL && s->prev != NULL)
                 SSL_SESSION_list_remove(ctx, s);
 
-        if (ctx->internal->session_cache_head == NULL) {
-                ctx->internal->session_cache_head = s;
-                ctx->internal->session_cache_tail = s;
-                s->prev = (SSL_SESSION *)&(ctx->internal->session_cache_head);
-                s->next = (SSL_SESSION *)&(ctx->internal->session_cache_tail);
+        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 {
-                s->next = ctx->internal->session_cache_head;
+                s->next = ctx->session_cache_head;
                 s->next->prev = s;
-                s->prev = (SSL_SESSION *)&(ctx->internal->session_cache_head);
-                ctx->internal->session_cache_head = s;
+                s->prev = (SSL_SESSION *)&(ctx->session_cache_head);
+                ctx->session_cache_head = s;
         }
 }
 
 void
 SSL_CTX_sess_set_new_cb(SSL_CTX *ctx,
     int (*cb)(struct ssl_st *ssl, SSL_SESSION *sess)) {
-        ctx->internal->new_session_cb = cb;
+        ctx->new_session_cb = cb;
 }
 
 int
 (*SSL_CTX_sess_get_new_cb(SSL_CTX *ctx))(SSL *ssl, SSL_SESSION *sess)
 {
-        return ctx->internal->new_session_cb;
+        return ctx->new_session_cb;
 }
 
 void
 SSL_CTX_sess_set_remove_cb(SSL_CTX *ctx,
     void (*cb)(SSL_CTX *ctx, SSL_SESSION *sess))
 {
-        ctx->internal->remove_session_cb = cb;
+        ctx->remove_session_cb = cb;
 }
 
 void
 (*SSL_CTX_sess_get_remove_cb(SSL_CTX *ctx))(SSL_CTX * ctx, SSL_SESSION *sess)
 {
-        return ctx->internal->remove_session_cb;
+        return ctx->remove_session_cb;
 }
 
 void
 SSL_CTX_sess_set_get_cb(SSL_CTX *ctx, SSL_SESSION *(*cb)(struct ssl_st *ssl,
     const unsigned char *data, int len, int *copy))
 {
-        ctx->internal->get_session_cb = cb;
+        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->internal->get_session_cb;
+        return ctx->get_session_cb;
 }
 
 void
 SSL_CTX_set_info_callback(SSL_CTX *ctx,
     void (*cb)(const SSL *ssl, int type, int val))
 {
-        ctx->internal->info_callback = cb;
+        ctx->info_callback = cb;
 }
 
 void
 (*SSL_CTX_get_info_callback(SSL_CTX *ctx))(const SSL *ssl, int type, int val)
 {
-        return ctx->internal->info_callback;
+        return ctx->info_callback;
 }
 
 void
 SSL_CTX_set_client_cert_cb(SSL_CTX *ctx,
     int (*cb)(SSL *ssl, X509 **x509, EVP_PKEY **pkey))
 {
-        ctx->internal->client_cert_cb = cb;
+        ctx->client_cert_cb = cb;
 }
 
 int
 (*SSL_CTX_get_client_cert_cb(SSL_CTX *ctx))(SSL * ssl, X509 ** x509,
     EVP_PKEY **pkey)
 {
-        return ctx->internal->client_cert_cb;
+        return ctx->client_cert_cb;
 }
 
 #ifndef OPENSSL_NO_ENGINE
@@ -1181,7 +1181,7 @@ SSL_CTX_set_client_cert_engine(SSL_CTX *ctx, ENGINE *e)
                 ENGINE_finish(e);
                 return 0;
         }
-        ctx->internal->client_cert_engine = e;
+        ctx->client_cert_engine = e;
         return 1;
 }
 #endif
@@ -1190,14 +1190,14 @@ void
 SSL_CTX_set_cookie_generate_cb(SSL_CTX *ctx,
     int (*cb)(SSL *ssl, unsigned char *cookie, unsigned int *cookie_len))
 {
-        ctx->internal->app_gen_cookie_cb = cb;
+        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->internal->app_verify_cookie_cb = cb;
+        ctx->app_verify_cookie_cb = cb;
 }
 
 int
diff --git a/src/lib/libssl/ssl_srvr.c b/src/lib/libssl/ssl_srvr.c
index 821006af81..098e82e339 100644
--- a/src/lib/libssl/ssl_srvr.c
+++ b/src/lib/libssl/ssl_srvr.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ssl_srvr.c,v 1.150 2022/10/01 16:23:15 jsing Exp $ */
+/* $OpenBSD: ssl_srvr.c,v 1.151 2022/10/02 16:36:41 jsing Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -204,7 +204,7 @@ ssl3_accept(SSL *s)
                 listen = s->d1->listen;
 
         /* init things to blank */
-        s->internal->in_handshake++;
+        s->in_handshake++;
         if (!SSL_in_init(s) || SSL_in_before(s))
                 SSL_clear(s);
 
@@ -216,7 +216,7 @@ ssl3_accept(SSL *s)
 
                 switch (s->s3->hs.state) {
                 case SSL_ST_RENEGOTIATE:
-                        s->internal->renegotiate = 1;
+                        s->renegotiate = 1;
                         /* s->s3->hs.state=SSL_ST_ACCEPT; */
 
                 case SSL_ST_BEFORE:
@@ -257,7 +257,7 @@ ssl3_accept(SSL *s)
                                 goto end;
                         }
 
-                        s->internal->init_num = 0;
+                        s->init_num = 0;
 
                         if (s->s3->hs.state != SSL_ST_RENEGOTIATE) {
                                 /*
@@ -276,7 +276,7 @@ ssl3_accept(SSL *s)
                                 }
 
                                 s->s3->hs.state = SSL3_ST_SR_CLNT_HELLO_A;
-                                s->ctx->internal->stats.sess_accept++;
+                                s->ctx->stats.sess_accept++;
                         } else if (!SSL_is_dtls(s) && !s->s3->send_connection_binding) {
                                 /*
                                  * Server attempting to renegotiate with
@@ -293,14 +293,14 @@ ssl3_accept(SSL *s)
                                  * s->s3->hs.state == SSL_ST_RENEGOTIATE,
                                  * we will just send a HelloRequest.
                                  */
-                                s->ctx->internal->stats.sess_accept_renegotiate++;
+                                s->ctx->stats.sess_accept_renegotiate++;
                                 s->s3->hs.state = SSL3_ST_SW_HELLO_REQ_A;
                         }
                         break;
 
                 case SSL3_ST_SW_HELLO_REQ_A:
                 case SSL3_ST_SW_HELLO_REQ_B:
-                        s->internal->shutdown = 0;
+                        s->shutdown = 0;
                         if (SSL_is_dtls(s)) {
                                 dtls1_clear_record_buffer(s);
                                 dtls1_start_timer(s);
@@ -313,7 +313,7 @@ ssl3_accept(SSL *s)
                         else
                                 s->s3->hs.tls12.next_state = SSL3_ST_SW_HELLO_REQ_C;
                         s->s3->hs.state = SSL3_ST_SW_FLUSH;
-                        s->internal->init_num = 0;
+                        s->init_num = 0;
 
                         if (SSL_is_dtls(s)) {
                                 if (!tls1_transcript_init(s)) {
@@ -330,7 +330,7 @@ ssl3_accept(SSL *s)
                 case SSL3_ST_SR_CLNT_HELLO_A:
                 case SSL3_ST_SR_CLNT_HELLO_B:
                 case SSL3_ST_SR_CLNT_HELLO_C:
-                        s->internal->shutdown = 0;
+                        s->shutdown = 0;
                         if (SSL_is_dtls(s)) {
                                 ret = ssl3_get_client_hello(s);
                                 if (ret <= 0)
@@ -343,7 +343,7 @@ ssl3_accept(SSL *s)
                                 else
                                         s->s3->hs.state = SSL3_ST_SW_SRVR_HELLO_A;
 
-                                s->internal->init_num = 0;
+                                s->init_num = 0;
 
                                 /*
                                  * Reflect ClientHello sequence to remain
@@ -351,7 +351,7 @@ ssl3_accept(SSL *s)
                                  */
                                 if (listen) {
                                         tls12_record_layer_reflect_seq_num(
-                                            s->internal->rl);
+                                            s->rl);
                                 }
 
                                 /* If we're just listening, stop here */
@@ -368,15 +368,15 @@ ssl3_accept(SSL *s)
                                         goto end;
                                 }
                         } else {
-                                if (s->internal->rwstate != SSL_X509_LOOKUP) {
+                                if (s->rwstate != SSL_X509_LOOKUP) {
                                         ret = ssl3_get_client_hello(s);
                                         if (ret <= 0)
                                                 goto end;
                                 }
 
-                                s->internal->renegotiate = 2;
+                                s->renegotiate = 2;
                                 s->s3->hs.state = SSL3_ST_SW_SRVR_HELLO_A;
-                                s->internal->init_num = 0;
+                                s->init_num = 0;
                         }
                         break;
 
@@ -395,21 +395,21 @@ ssl3_accept(SSL *s)
                 case SSL3_ST_SW_SRVR_HELLO_A:
                 case SSL3_ST_SW_SRVR_HELLO_B:
                         if (SSL_is_dtls(s)) {
-                                s->internal->renegotiate = 2;
+                                s->renegotiate = 2;
                                 dtls1_start_timer(s);
                         }
                         ret = ssl3_send_server_hello(s);
                         if (ret <= 0)
                                 goto end;
-                        if (s->internal->hit) {
-                                if (s->internal->tlsext_ticket_expected)
+                        if (s->hit) {
+                                if (s->tlsext_ticket_expected)
                                         s->s3->hs.state = SSL3_ST_SW_SESSION_TICKET_A;
                                 else
                                         s->s3->hs.state = SSL3_ST_SW_CHANGE_A;
                         } else {
                                 s->s3->hs.state = SSL3_ST_SW_CERT_A;
                         }
-                        s->internal->init_num = 0;
+                        s->init_num = 0;
                         break;
 
                 case SSL3_ST_SW_CERT_A:
@@ -422,7 +422,7 @@ ssl3_accept(SSL *s)
                                 ret = ssl3_send_server_certificate(s);
                                 if (ret <= 0)
                                         goto end;
-                                if (s->internal->tlsext_status_expected)
+                                if (s->tlsext_status_expected)
                                         s->s3->hs.state = SSL3_ST_SW_CERT_STATUS_A;
                                 else
                                         s->s3->hs.state = SSL3_ST_SW_KEY_EXCH_A;
@@ -430,7 +430,7 @@ ssl3_accept(SSL *s)
                                 skip = 1;
                                 s->s3->hs.state = SSL3_ST_SW_KEY_EXCH_A;
                         }
-                        s->internal->init_num = 0;
+                        s->init_num = 0;
                         break;
 
                 case SSL3_ST_SW_KEY_EXCH_A:
@@ -455,7 +455,7 @@ ssl3_accept(SSL *s)
                                 skip = 1;
 
                         s->s3->hs.state = SSL3_ST_SW_CERT_REQ_A;
-                        s->internal->init_num = 0;
+                        s->init_num = 0;
                         break;
 
                 case SSL3_ST_SW_CERT_REQ_A:
@@ -498,7 +498,7 @@ ssl3_accept(SSL *s)
                                 if (ret <= 0)
                                         goto end;
                                 s->s3->hs.state = SSL3_ST_SW_SRVR_DONE_A;
-                                s->internal->init_num = 0;
+                                s->init_num = 0;
                         }
                         break;
 
@@ -511,7 +511,7 @@ ssl3_accept(SSL *s)
                                 goto end;
                         s->s3->hs.tls12.next_state = SSL3_ST_SR_CERT_A;
                         s->s3->hs.state = SSL3_ST_SW_FLUSH;
-                        s->internal->init_num = 0;
+                        s->init_num = 0;
                         break;
 
                 case SSL3_ST_SW_FLUSH:
@@ -525,19 +525,19 @@ ssl3_accept(SSL *s)
                          * still exist. So instead we just flush
                          * unconditionally.
                          */
-                        s->internal->rwstate = SSL_WRITING;
+                        s->rwstate = SSL_WRITING;
                         if (BIO_flush(s->wbio) <= 0) {
                                 if (SSL_is_dtls(s)) {
                                         /* If the write error was fatal, stop trying. */
                                         if (!BIO_should_retry(s->wbio)) {
-                                                s->internal->rwstate = SSL_NOTHING;
+                                                s->rwstate = SSL_NOTHING;
                                                 s->s3->hs.state = s->s3->hs.tls12.next_state;
                                         }
                                 }
                                 ret = -1;
                                 goto end;
                         }
-                        s->internal->rwstate = SSL_NOTHING;
+                        s->rwstate = SSL_NOTHING;
                         s->s3->hs.state = s->s3->hs.tls12.next_state;
                         break;
 
@@ -548,7 +548,7 @@ ssl3_accept(SSL *s)
                                 if (ret <= 0)
                                         goto end;
                         }
-                        s->internal->init_num = 0;
+                        s->init_num = 0;
                         s->s3->hs.state = SSL3_ST_SR_KEY_EXCH_A;
                         break;
 
@@ -560,7 +560,7 @@ ssl3_accept(SSL *s)
 
                         if (SSL_is_dtls(s)) {
                                 s->s3->hs.state = SSL3_ST_SR_CERT_VRFY_A;
-                                s->internal->init_num = 0;
+                                s->init_num = 0;
                         }
 
                         alg_k = s->s3->hs.cipher->algorithm_mkey;
@@ -571,10 +571,10 @@ ssl3_accept(SSL *s)
                                  * the CertificateVerify message is not sent.
                                  */
                                 s->s3->hs.state = SSL3_ST_SR_FINISHED_A;
-                                s->internal->init_num = 0;
+                                s->init_num = 0;
                         } else if (SSL_USE_SIGALGS(s) || (alg_k & SSL_kGOST)) {
                                 s->s3->hs.state = SSL3_ST_SR_CERT_VRFY_A;
-                                s->internal->init_num = 0;
+                                s->init_num = 0;
                                 if (!s->session->peer_cert)
                                         break;
                                 /*
@@ -584,7 +584,7 @@ ssl3_accept(SSL *s)
                                 tls1_transcript_freeze(s);
                         } else {
                                 s->s3->hs.state = SSL3_ST_SR_CERT_VRFY_A;
-                                s->internal->init_num = 0;
+                                s->init_num = 0;
 
                                 tls1_transcript_free(s);
 
@@ -614,7 +614,7 @@ ssl3_accept(SSL *s)
                         if (ret <= 0)
                                 goto end;
                         s->s3->hs.state = SSL3_ST_SR_FINISHED_A;
-                        s->internal->init_num = 0;
+                        s->init_num = 0;
                         break;
 
                 case SSL3_ST_SR_FINISHED_A:
@@ -628,13 +628,13 @@ ssl3_accept(SSL *s)
                                 goto end;
                         if (SSL_is_dtls(s))
                                 dtls1_stop_timer(s);
-                        if (s->internal->hit)
+                        if (s->hit)
                                 s->s3->hs.state = SSL_ST_OK;
-                        else if (s->internal->tlsext_ticket_expected)
+                        else if (s->tlsext_ticket_expected)
                                 s->s3->hs.state = SSL3_ST_SW_SESSION_TICKET_A;
                         else
                                 s->s3->hs.state = SSL3_ST_SW_CHANGE_A;
-                        s->internal->init_num = 0;
+                        s->init_num = 0;
                         break;
 
                 case SSL3_ST_SW_SESSION_TICKET_A:
@@ -643,7 +643,7 @@ ssl3_accept(SSL *s)
                         if (ret <= 0)
                                 goto end;
                         s->s3->hs.state = SSL3_ST_SW_CHANGE_A;
-                        s->internal->init_num = 0;
+                        s->init_num = 0;
                         break;
 
                 case SSL3_ST_SW_CERT_STATUS_A:
@@ -652,7 +652,7 @@ ssl3_accept(SSL *s)
                         if (ret <= 0)
                                 goto end;
                         s->s3->hs.state = SSL3_ST_SW_KEY_EXCH_A;
-                        s->internal->init_num = 0;
+                        s->init_num = 0;
                         break;
 
                 case SSL3_ST_SW_CHANGE_A:
@@ -661,7 +661,7 @@ ssl3_accept(SSL *s)
                         if (ret <= 0)
                                 goto end;
                         s->s3->hs.state = SSL3_ST_SW_FINISHED_A;
-                        s->internal->init_num = 0;
+                        s->init_num = 0;
                         s->session->cipher = s->s3->hs.cipher;
 
                         if (!tls1_setup_key_block(s)) {
@@ -680,12 +680,12 @@ ssl3_accept(SSL *s)
                         if (ret <= 0)
                                 goto end;
                         s->s3->hs.state = SSL3_ST_SW_FLUSH;
-                        if (s->internal->hit) {
+                        if (s->hit) {
                                 s->s3->hs.tls12.next_state = SSL3_ST_SR_FINISHED_A;
                                 tls1_transcript_free(s);
                         } else
                                 s->s3->hs.tls12.next_state = SSL_ST_OK;
-                        s->internal->init_num = 0;
+                        s->init_num = 0;
                         break;
 
                 case SSL_ST_OK:
@@ -704,18 +704,18 @@ ssl3_accept(SSL *s)
                         /* remove buffering on output */
                         ssl_free_wbio_buffer(s);
 
-                        s->internal->init_num = 0;
+                        s->init_num = 0;
 
                         /* Skipped if we just sent a HelloRequest. */
-                        if (s->internal->renegotiate == 2) {
-                                s->internal->renegotiate = 0;
-                                s->internal->new_session = 0;
+                        if (s->renegotiate == 2) {
+                                s->renegotiate = 0;
+                                s->new_session = 0;
 
                                 ssl_update_cache(s, SSL_SESS_CACHE_SERVER);
 
-                                s->ctx->internal->stats.sess_accept_good++;
+                                s->ctx->stats.sess_accept_good++;
                                 /* s->server=1; */
-                                s->internal->handshake_func = ssl3_accept;
+                                s->handshake_func = ssl3_accept;
 
                                 ssl_info_callback(s, SSL_CB_HANDSHAKE_DONE, 1);
                         }
@@ -740,7 +740,7 @@ ssl3_accept(SSL *s)
                 }
 
                 if (!s->s3->hs.tls12.reuse_message && !skip) {
-                        if (s->internal->debug) {
+                        if (s->debug) {
                                 if ((ret = BIO_flush(s->wbio)) <= 0)
                                         goto end;
                         }
@@ -757,7 +757,7 @@ ssl3_accept(SSL *s)
         }
  end:
         /* BIO_flush(s->wbio); */
-        s->internal->in_handshake--;
+        s->in_handshake--;
         ssl_info_callback(s, SSL_CB_ACCEPT_EXIT, ret);
 
         return (ret);
@@ -815,19 +815,19 @@ ssl3_get_client_hello(SSL *s)
         if (s->s3->hs.state == SSL3_ST_SR_CLNT_HELLO_A)
                 s->s3->hs.state = SSL3_ST_SR_CLNT_HELLO_B;
 
-        s->internal->first_packet = 1;
+        s->first_packet = 1;
         if ((ret = ssl3_get_message(s, SSL3_ST_SR_CLNT_HELLO_B,
             SSL3_ST_SR_CLNT_HELLO_C, SSL3_MT_CLIENT_HELLO,
             SSL3_RT_MAX_PLAIN_LENGTH)) <= 0)
                 return ret;
-        s->internal->first_packet = 0;
+        s->first_packet = 0;
 
         ret = -1;
 
-        if (s->internal->init_num < 0)
+        if (s->init_num < 0)
                 goto err;
 
-        CBS_init(&cbs, s->internal->init_msg, s->internal->init_num);
+        CBS_init(&cbs, s->init_msg, s->init_num);
 
         /* Parse client hello up until the extensions (if any). */
         if (!CBS_get_u16(&cbs, &client_version))
@@ -856,7 +856,7 @@ ssl3_get_client_hello(SSL *s)
          */
         if (!ssl_max_shared_version(s, client_version, &shared_version)) {
                 if ((client_version >> 8) == SSL3_VERSION_MAJOR &&
-                    !tls12_record_layer_write_protected(s->internal->rl)) {
+                    !tls12_record_layer_write_protected(s->rl)) {
                         /*
                          * Similar to ssl3_get_record, send alert using remote
                          * version number.
@@ -898,7 +898,7 @@ ssl3_get_client_hello(SSL *s)
             sizeof(s->s3->client_random), NULL))
                 goto err;
 
-        s->internal->hit = 0;
+        s->hit = 0;
 
         /*
          * Versions before 0.9.7 always allow clients to resume sessions in
@@ -910,12 +910,12 @@ ssl3_get_client_hello(SSL *s)
          * library versions).
          *
          * 1.0.1 and later also have a function SSL_renegotiate_abbreviated()
-         * to request renegotiation but not a new session (s->internal->new_session
+         * 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 ((s->internal->new_session && (s->internal->options &
+        if ((s->new_session && (s->options &
             SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION))) {
                 if (!ssl_get_new_session(s, 1))
                         goto err;
@@ -926,7 +926,7 @@ ssl3_get_client_hello(SSL *s)
 
                 i = ssl_get_prev_session(s, &session_id, &ext_block, &al);
                 if (i == 1) { /* previous session */
-                        s->internal->hit = 1;
+                        s->hit = 1;
                 } else if (i == -1)
                         goto fatal_err;
                 else {
@@ -958,8 +958,8 @@ ssl3_get_client_hello(SSL *s)
                             sizeof(s->d1->rcvd_cookie), &cookie_len))
                                 goto err;
 
-                        if (s->ctx->internal->app_verify_cookie_cb != NULL) {
-                                if (s->ctx->internal->app_verify_cookie_cb(s,
+                        if (s->ctx->app_verify_cookie_cb != NULL) {
+                                if (s->ctx->app_verify_cookie_cb(s,
                                     s->d1->rcvd_cookie, cookie_len) == 0) {
                                         al = SSL_AD_HANDSHAKE_FAILURE;
                                         SSLerror(s, SSL_R_COOKIE_MISMATCH);
@@ -994,7 +994,7 @@ ssl3_get_client_hello(SSL *s)
 
         /* If it is a hit, check that the cipher is in the list */
         /* XXX - CBS_len(&cipher_suites) will always be zero here... */
-        if (s->internal->hit && CBS_len(&cipher_suites) > 0) {
+        if (s->hit && CBS_len(&cipher_suites) > 0) {
                 j = 0;
                 id = s->session->cipher->id;
 
@@ -1037,7 +1037,7 @@ ssl3_get_client_hello(SSL *s)
         if (CBS_len(&cbs) != 0)
                 goto decode_err;
 
-        if (!s->s3->renegotiate_seen && s->internal->renegotiate) {
+        if (!s->s3->renegotiate_seen && s->renegotiate) {
                 al = SSL_AD_HANDSHAKE_FAILURE;
                 SSLerror(s, SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
                 goto fatal_err;
@@ -1077,13 +1077,13 @@ ssl3_get_client_hello(SSL *s)
                 }
         }
 
-        if (!s->internal->hit && s->internal->tls_session_secret_cb != NULL) {
+        if (!s->hit && s->tls_session_secret_cb != NULL) {
                 SSL_CIPHER *pref_cipher = NULL;
                 int master_key_length = sizeof(s->session->master_key);
 
-                if (!s->internal->tls_session_secret_cb(s,
+                if (!s->tls_session_secret_cb(s,
                     s->session->master_key, &master_key_length, ciphers,
-                    &pref_cipher, s->internal->tls_session_secret_cb_arg)) {
+                    &pref_cipher, s->tls_session_secret_cb_arg)) {
                         SSLerror(s, ERR_R_INTERNAL_ERROR);
                         goto err;
                 }
@@ -1093,7 +1093,7 @@ ssl3_get_client_hello(SSL *s)
                 }
                 s->session->master_key_length = master_key_length;
 
-                s->internal->hit = 1;
+                s->hit = 1;
                 s->session->verify_result = X509_V_OK;
 
                 sk_SSL_CIPHER_free(s->session->ciphers);
@@ -1120,7 +1120,7 @@ ssl3_get_client_hello(SSL *s)
          * pick a cipher
          */
 
-        if (!s->internal->hit) {
+        if (!s->hit) {
                 if (ciphers == NULL) {
                         al = SSL_AD_ILLEGAL_PARAMETER;
                         SSLerror(s, SSL_R_NO_CIPHERS_PASSED);
@@ -1157,7 +1157,7 @@ ssl3_get_client_hello(SSL *s)
          * compression          - basically ignored right now
          * ssl version is set   - sslv3
          * s->session           - The ssl session has been setup.
-         * s->internal->hit             - session reuse flag
+         * s->hit               - session reuse flag
          * s->hs.cipher - the new cipher to use.
          */
 
@@ -1190,8 +1190,8 @@ ssl3_send_dtls_hello_verify_request(SSL *s)
         memset(&cbb, 0, sizeof(cbb));
 
         if (s->s3->hs.state == DTLS1_ST_SW_HELLO_VERIFY_REQUEST_A) {
-                if (s->ctx->internal->app_gen_cookie_cb == NULL ||
-                    s->ctx->internal->app_gen_cookie_cb(s, s->d1->cookie,
+                if (s->ctx->app_gen_cookie_cb == NULL ||
+                    s->ctx->app_gen_cookie_cb(s, s->d1->cookie,
                         &(s->d1->cookie_len)) == 0) {
                         SSLerror(s, ERR_R_INTERNAL_ERROR);
                         return 0;
@@ -1259,12 +1259,12 @@ ssl3_send_server_hello(SSL *s)
                  * - However, if we want the new session to be single-use,
                  *   we send back a 0-length session ID.
                  *
-                 * s->internal->hit is non-zero in either case of session reuse,
+                 * 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->ctx->internal->session_cache_mode & SSL_SESS_CACHE_SERVER)
-                    && !s->internal->hit)
+                if (!(s->ctx->session_cache_mode & SSL_SESS_CACHE_SERVER)
+                    && !s->hit)
                         s->session->session_id_length = 0;
 
                 sl = s->session->session_id_length;
@@ -1895,10 +1895,10 @@ ssl3_get_client_key_exchange(SSL *s)
             SSL3_ST_SR_KEY_EXCH_B, SSL3_MT_CLIENT_KEY_EXCHANGE, 2048)) <= 0)
                 return ret;
 
-        if (s->internal->init_num < 0)
+        if (s->init_num < 0)
                 goto err;
 
-        CBS_init(&cbs, s->internal->init_msg, s->internal->init_num);
+        CBS_init(&cbs, s->init_msg, s->init_num);
 
         alg_k = s->s3->hs.cipher->algorithm_mkey;
 
@@ -1955,13 +1955,13 @@ ssl3_get_cert_verify(SSL *s)
 
         ret = 0;
 
-        if (s->internal->init_num < 0)
+        if (s->init_num < 0)
                 goto err;
 
         if ((mctx = EVP_MD_CTX_new()) == NULL)
                 goto err;
 
-        CBS_init(&cbs, s->internal->init_msg, s->internal->init_num);
+        CBS_init(&cbs, s->init_msg, s->init_num);
 
         peer_cert = s->session->peer_cert;
         pkey = X509_get0_pubkey(peer_cert);
@@ -2178,7 +2178,7 @@ ssl3_get_client_certificate(SSL *s)
         int al, ret;
 
         if ((ret = ssl3_get_message(s, SSL3_ST_SR_CERT_A, SSL3_ST_SR_CERT_B,
-            -1, s->internal->max_cert_list)) <= 0)
+            -1, s->max_cert_list)) <= 0)
                 return ret;
 
         ret = -1;
@@ -2210,10 +2210,10 @@ ssl3_get_client_certificate(SSL *s)
                 goto fatal_err;
         }
 
-        if (s->internal->init_num < 0)
+        if (s->init_num < 0)
                 goto decode_err;
 
-        CBS_init(&cbs, s->internal->init_msg, s->internal->init_num);
+        CBS_init(&cbs, s->init_msg, s->init_num);
 
         if (!CBS_get_u24_length_prefixed(&cbs, &cert_list))
                 goto decode_err;
@@ -2367,17 +2367,17 @@ ssl3_send_newsession_ticket(SSL *s)
                  * it does all the work, otherwise use generated values from
                  * parent context.
                  */
-                if (tctx->internal->tlsext_ticket_key_cb != NULL) {
-                        if (tctx->internal->tlsext_ticket_key_cb(s,
+                if (tctx->tlsext_ticket_key_cb != NULL) {
+                        if (tctx->tlsext_ticket_key_cb(s,
                             key_name, iv, ctx, hctx, 1) < 0)
                                 goto err;
                 } else {
                         arc4random_buf(iv, 16);
                         EVP_EncryptInit_ex(ctx, EVP_aes_128_cbc(), NULL,
-                            tctx->internal->tlsext_tick_aes_key, iv);
-                        HMAC_Init_ex(hctx, tctx->internal->tlsext_tick_hmac_key,
+                            tctx->tlsext_tick_aes_key, iv);
+                        HMAC_Init_ex(hctx, tctx->tlsext_tick_hmac_key,
                             16, EVP_sha256(), NULL);
-                        memcpy(key_name, tctx->internal->tlsext_tick_key_name, 16);
+                        memcpy(key_name, tctx->tlsext_tick_key_name, 16);
                 }
 
                 /* Encrypt the session state. */
@@ -2415,7 +2415,7 @@ ssl3_send_newsession_ticket(SSL *s)
                  * sessions will live as long as their sessions.
                  */
                 if (!CBB_add_u32(&session_ticket,
-                    s->internal->hit ? 0 : s->session->timeout))
+                    s->hit ? 0 : s->session->timeout))
                         goto err;
 
                 if (!CBB_add_u16_length_prefixed(&session_ticket, &ticket))
@@ -2473,8 +2473,8 @@ ssl3_send_cert_status(SSL *s)
                         goto err;
                 if (!CBB_add_u24_length_prefixed(&certstatus, &ocspresp))
                         goto err;
-                if (!CBB_add_bytes(&ocspresp, s->internal->tlsext_ocsp_resp,
-                    s->internal->tlsext_ocsp_resp_len))
+                if (!CBB_add_bytes(&ocspresp, s->tlsext_ocsp_resp,
+                    s->tlsext_ocsp_resp_len))
                         goto err;
                 if (!ssl3_handshake_msg_finish(s, &cbb))
                         goto err;
@@ -2500,8 +2500,8 @@ ssl3_send_server_change_cipher_spec(SSL *s)
         memset(&cbb, 0, sizeof(cbb));
 
         if (s->s3->hs.state == SSL3_ST_SW_CHANGE_A) {
-                if (!CBB_init_fixed(&cbb, s->internal->init_buf->data,
-                    s->internal->init_buf->length))
+                if (!CBB_init_fixed(&cbb, s->init_buf->data,
+                    s->init_buf->length))
                         goto err;
                 if (!CBB_add_u8(&cbb, SSL3_MT_CCS))
                         goto err;
@@ -2511,8 +2511,8 @@ ssl3_send_server_change_cipher_spec(SSL *s)
                 if (outlen > INT_MAX)
                         goto err;
 
-                s->internal->init_num = (int)outlen;
-                s->internal->init_off = 0;
+                s->init_num = (int)outlen;
+                s->init_off = 0;
 
                 if (SSL_is_dtls(s)) {
                         s->d1->handshake_write_seq =
@@ -2555,13 +2555,13 @@ ssl3_get_client_finished(SSL *s)
 
         md_len = TLS1_FINISH_MAC_LENGTH;
 
-        if (s->internal->init_num < 0) {
+        if (s->init_num < 0) {
                 al = SSL_AD_DECODE_ERROR;
                 SSLerror(s, SSL_R_BAD_DIGEST_LENGTH);
                 goto fatal_err;
         }
 
-        CBS_init(&cbs, s->internal->init_msg, s->internal->init_num);
+        CBS_init(&cbs, s->init_msg, s->init_num);
 
         if (s->s3->hs.peer_finished_len != md_len ||
             CBS_len(&cbs) != md_len) {
diff --git a/src/lib/libssl/ssl_stat.c b/src/lib/libssl/ssl_stat.c
index 5d35528acd..e4303e171a 100644
--- a/src/lib/libssl/ssl_stat.c
+++ b/src/lib/libssl/ssl_stat.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ssl_stat.c,v 1.18 2022/02/05 14:54:10 jsing Exp $ */
+/* $OpenBSD: ssl_stat.c,v 1.19 2022/10/02 16:36:41 jsing Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -325,7 +325,7 @@ SSL_rstate_string_long(const SSL *s)
 {
         const char *str;
 
-        switch (s->internal->rstate) {
+        switch (s->rstate) {
         case SSL_ST_READ_HEADER:
                 str = "read header";
                 break;
@@ -771,7 +771,7 @@ SSL_rstate_string(const SSL *s)
 {
         const char *str;
 
-        switch (s->internal->rstate) {
+        switch (s->rstate) {
         case SSL_ST_READ_HEADER:
                 str = "RH";
                 break;
diff --git a/src/lib/libssl/ssl_tlsext.c b/src/lib/libssl/ssl_tlsext.c
index a42856264b..647a95e485 100644
--- a/src/lib/libssl/ssl_tlsext.c
+++ b/src/lib/libssl/ssl_tlsext.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ssl_tlsext.c,v 1.129 2022/08/15 10:46:53 tb Exp $ */
+/* $OpenBSD: ssl_tlsext.c,v 1.130 2022/10/02 16:36:41 jsing Exp $ */
 /*
  * Copyright (c) 2016, 2017, 2019 Joel Sing <jsing@openbsd.org>
  * Copyright (c) 2017 Doug Hogan <doug@openbsd.org>
@@ -40,7 +40,7 @@ static int
 tlsext_alpn_client_needs(SSL *s, uint16_t msg_type)
 {
         /* ALPN protos have been specified and this is the initial handshake */
-        return s->internal->alpn_client_proto_list != NULL &&
+        return s->alpn_client_proto_list != NULL &&
             s->s3->hs.finished_len == 0;
 }
 
@@ -52,8 +52,8 @@ tlsext_alpn_client_build(SSL *s, uint16_t msg_type, CBB *cbb)
         if (!CBB_add_u16_length_prefixed(cbb, &protolist))
                 return 0;
 
-        if (!CBB_add_bytes(&protolist, s->internal->alpn_client_proto_list,
-            s->internal->alpn_client_proto_list_len))
+        if (!CBB_add_bytes(&protolist, s->alpn_client_proto_list,
+            s->alpn_client_proto_list_len))
                 return 0;
 
         if (!CBB_flush(cbb))
@@ -97,7 +97,7 @@ tlsext_alpn_server_parse(SSL *s, uint16_t msg_types, CBS *cbs, int *alert)
         if (!tlsext_alpn_check_format(&alpn))
                 return 0;
 
-        if (s->ctx->internal->alpn_select_cb == NULL)
+        if (s->ctx->alpn_select_cb == NULL)
                 return 1;
 
         /*
@@ -106,9 +106,9 @@ tlsext_alpn_server_parse(SSL *s, uint16_t msg_types, CBS *cbs, int *alert)
          * 2. Should the callback be called even if no ALPN extension was sent?
          * 3. TLSv1.2 and earlier: ensure that SNI has already been processed.
          */
-        r = s->ctx->internal->alpn_select_cb(s, &selected, &selected_len,
+        r = s->ctx->alpn_select_cb(s, &selected, &selected_len,
             CBS_data(&alpn), CBS_len(&alpn),
-            s->ctx->internal->alpn_select_cb_arg);
+            s->ctx->alpn_select_cb_arg);
 
         if (r == SSL_TLSEXT_ERR_OK) {
                 CBS_init(&selected_cbs, selected, selected_len);
@@ -164,7 +164,7 @@ tlsext_alpn_client_parse(SSL *s, uint16_t msg_type, CBS *cbs, int *alert)
 {
         CBS list, proto;
 
-        if (s->internal->alpn_client_proto_list == NULL) {
+        if (s->alpn_client_proto_list == NULL) {
                 *alert = SSL_AD_UNSUPPORTED_EXTENSION;
                 return 0;
         }
@@ -243,7 +243,7 @@ tlsext_supportedgroups_server_parse(SSL *s, uint16_t msg_type, CBS *cbs,
                 return 0;
         groups_len /= 2;
 
-        if (s->internal->hit)
+        if (s->hit)
                 return 1;
 
         if (s->s3->hs.tls13.hrr) {
@@ -365,7 +365,7 @@ tlsext_ecpf_parse(SSL *s, uint16_t msg_type, CBS *cbs, int *alert)
                 return 0;
         }
 
-        if (!s->internal->hit) {
+        if (!s->hit) {
                 if (!CBS_stow(&ecpf, &(s->session->tlsext_ecpointformatlist),
                     &(s->session->tlsext_ecpointformatlist_length))) {
                         *alert = SSL_AD_INTERNAL_ERROR;
@@ -418,7 +418,7 @@ tlsext_ecpf_client_parse(SSL *s, uint16_t msg_type, CBS *cbs, int *alert)
 static int
 tlsext_ri_client_needs(SSL *s, uint16_t msg_type)
 {
-        return (s->internal->renegotiate);
+        return (s->renegotiate);
 }
 
 static int
@@ -779,7 +779,7 @@ tlsext_sni_server_parse(SSL *s, uint16_t msg_type, CBS *cbs, int *alert)
                 goto err;
         }
 
-        if (s->internal->hit || s->s3->hs.tls13.hrr) {
+        if (s->hit || s->s3->hs.tls13.hrr) {
                 if (s->session->tlsext_hostname == NULL) {
                         *alert = SSL_AD_UNRECOGNIZED_NAME;
                         goto err;
@@ -817,7 +817,7 @@ tlsext_sni_server_parse(SSL *s, uint16_t msg_type, CBS *cbs, int *alert)
 static int
 tlsext_sni_server_needs(SSL *s, uint16_t msg_type)
 {
-        if (s->internal->hit)
+        if (s->hit)
                 return 0;
 
         return (s->session->tlsext_hostname != NULL);
@@ -837,7 +837,7 @@ tlsext_sni_client_parse(SSL *s, uint16_t msg_type, CBS *cbs, int *alert)
                 return 0;
         }
 
-        if (s->internal->hit) {
+        if (s->hit) {
                 if (s->session->tlsext_hostname == NULL) {
                         *alert = SSL_AD_UNRECOGNIZED_NAME;
                         return 0;
@@ -885,12 +885,12 @@ tlsext_ocsp_client_build(SSL *s, uint16_t msg_type, CBB *cbb)
                 return 0;
         if (!CBB_add_u16_length_prefixed(cbb, &respid_list))
                 return 0;
-        for (i = 0; i < sk_OCSP_RESPID_num(s->internal->tlsext_ocsp_ids); i++) {
+        for (i = 0; i < sk_OCSP_RESPID_num(s->tlsext_ocsp_ids); i++) {
                 unsigned char *respid_data;
                 OCSP_RESPID *id;
                 size_t id_len;
 
-                if ((id = sk_OCSP_RESPID_value(s->internal->tlsext_ocsp_ids,
+                if ((id = sk_OCSP_RESPID_value(s->tlsext_ocsp_ids,
                     i)) ==  NULL)
                         return 0;
                 if ((id_len = i2d_OCSP_RESPID(id, NULL)) == -1)
@@ -904,12 +904,12 @@ tlsext_ocsp_client_build(SSL *s, uint16_t msg_type, CBB *cbb)
         }
         if (!CBB_add_u16_length_prefixed(cbb, &exts))
                 return 0;
-        if ((ext_len = i2d_X509_EXTENSIONS(s->internal->tlsext_ocsp_exts,
+        if ((ext_len = i2d_X509_EXTENSIONS(s->tlsext_ocsp_exts,
             NULL)) == -1)
                 return 0;
         if (!CBB_add_space(&exts, &ext_data, ext_len))
                 return 0;
-        if ((i2d_X509_EXTENSIONS(s->internal->tlsext_ocsp_exts, &ext_data) !=
+        if ((i2d_X509_EXTENSIONS(s->tlsext_ocsp_exts, &ext_data) !=
             ext_len))
                 return 0;
         if (!CBB_flush(cbb))
@@ -946,11 +946,11 @@ tlsext_ocsp_server_parse(SSL *s, uint16_t msg_type, CBS *cbs, int *alert)
                 goto err;
 
         /* XXX */
-        sk_OCSP_RESPID_pop_free(s->internal->tlsext_ocsp_ids, OCSP_RESPID_free);
-        s->internal->tlsext_ocsp_ids = NULL;
+        sk_OCSP_RESPID_pop_free(s->tlsext_ocsp_ids, OCSP_RESPID_free);
+        s->tlsext_ocsp_ids = NULL;
         if (CBS_len(&respid_list) > 0) {
-                s->internal->tlsext_ocsp_ids = sk_OCSP_RESPID_new_null();
-                if (s->internal->tlsext_ocsp_ids == NULL) {
+                s->tlsext_ocsp_ids = sk_OCSP_RESPID_new_null();
+                if (s->tlsext_ocsp_ids == NULL) {
                         alert_desc = SSL_AD_INTERNAL_ERROR;
                         goto err;
                 }
@@ -964,7 +964,7 @@ tlsext_ocsp_server_parse(SSL *s, uint16_t msg_type, CBS *cbs, int *alert)
                 p = CBS_data(&respid);
                 if ((id = d2i_OCSP_RESPID(NULL, &p, CBS_len(&respid))) == NULL)
                         goto err;
-                if (!sk_OCSP_RESPID_push(s->internal->tlsext_ocsp_ids, id)) {
+                if (!sk_OCSP_RESPID_push(s->tlsext_ocsp_ids, id)) {
                         alert_desc = SSL_AD_INTERNAL_ERROR;
                         OCSP_RESPID_free(id);
                         goto err;
@@ -975,10 +975,10 @@ tlsext_ocsp_server_parse(SSL *s, uint16_t msg_type, CBS *cbs, int *alert)
         if (!CBS_get_u16_length_prefixed(cbs, &exts))
                 goto err;
         if (CBS_len(&exts) > 0) {
-                sk_X509_EXTENSION_pop_free(s->internal->tlsext_ocsp_exts,
+                sk_X509_EXTENSION_pop_free(s->tlsext_ocsp_exts,
                     X509_EXTENSION_free);
                 p = CBS_data(&exts);
-                if ((s->internal->tlsext_ocsp_exts = d2i_X509_EXTENSIONS(NULL,
+                if ((s->tlsext_ocsp_exts = d2i_X509_EXTENSIONS(NULL,
                     &p, CBS_len(&exts))) == NULL)
                         goto err;
         }
@@ -995,14 +995,14 @@ tlsext_ocsp_server_needs(SSL *s, uint16_t msg_type)
 {
         if (s->s3->hs.negotiated_tls_version >= TLS1_3_VERSION &&
             s->tlsext_status_type == TLSEXT_STATUSTYPE_ocsp &&
-            s->ctx->internal->tlsext_status_cb != NULL) {
-                s->internal->tlsext_status_expected = 0;
-                if (s->ctx->internal->tlsext_status_cb(s,
-                    s->ctx->internal->tlsext_status_arg) == SSL_TLSEXT_ERR_OK &&
-                    s->internal->tlsext_ocsp_resp_len > 0)
-                        s->internal->tlsext_status_expected = 1;
+            s->ctx->tlsext_status_cb != NULL) {
+                s->tlsext_status_expected = 0;
+                if (s->ctx->tlsext_status_cb(s,
+                    s->ctx->tlsext_status_arg) == SSL_TLSEXT_ERR_OK &&
+                    s->tlsext_ocsp_resp_len > 0)
+                        s->tlsext_status_expected = 1;
         }
-        return s->internal->tlsext_status_expected;
+        return s->tlsext_status_expected;
 }
 
 static int
@@ -1016,8 +1016,8 @@ tlsext_ocsp_server_build(SSL *s, uint16_t msg_type, CBB *cbb)
                 if (!CBB_add_u24_length_prefixed(cbb, &ocsp_response))
                         return 0;
                 if (!CBB_add_bytes(&ocsp_response,
-                    s->internal->tlsext_ocsp_resp,
-                    s->internal->tlsext_ocsp_resp_len))
+                    s->tlsext_ocsp_resp,
+                    s->tlsext_ocsp_resp_len))
                         return 0;
                 if (!CBB_flush(cbb))
                         return 0;
@@ -1059,8 +1059,8 @@ tlsext_ocsp_client_parse(SSL *s, uint16_t msg_type, CBS *cbs, int *alert)
                         SSLerror(s, SSL_R_DATA_LENGTH_TOO_LONG);
                         return 0;
                 }
-                if (!CBS_stow(&response, &s->internal->tlsext_ocsp_resp,
-                    &s->internal->tlsext_ocsp_resp_len)) {
+                if (!CBS_stow(&response, &s->tlsext_ocsp_resp,
+                    &s->tlsext_ocsp_resp_len)) {
                         *alert = SSL_AD_INTERNAL_ERROR;
                         return 0;
                 }
@@ -1070,7 +1070,7 @@ tlsext_ocsp_client_parse(SSL *s, uint16_t msg_type, CBS *cbs, int *alert)
                         return 0;
                 }
                 /* Set flag to expect CertificateStatus message */
-                s->internal->tlsext_status_expected = 1;
+                s->tlsext_status_expected = 1;
         }
         return 1;
 }
@@ -1092,11 +1092,11 @@ tlsext_sessionticket_client_needs(SSL *s, uint16_t msg_type)
         if (!ssl_security_tickets(s))
                 return 0;
 
-        if (s->internal->new_session)
+        if (s->new_session)
                 return 1;
 
-        if (s->internal->tlsext_session_ticket != NULL &&
-            s->internal->tlsext_session_ticket->data == NULL)
+        if (s->tlsext_session_ticket != NULL &&
+            s->tlsext_session_ticket->data == NULL)
                 return 0;
 
         return 1;
@@ -1109,7 +1109,7 @@ tlsext_sessionticket_client_build(SSL *s, uint16_t msg_type, CBB *cbb)
          * Signal that we support session tickets by sending an empty
          * extension when renegotiating or no session found.
          */
-        if (s->internal->new_session || s->session == NULL)
+        if (s->new_session || s->session == NULL)
                 return 1;
 
         if (s->session->tlsext_tick != NULL) {
@@ -1118,18 +1118,18 @@ tlsext_sessionticket_client_build(SSL *s, uint16_t msg_type, CBB *cbb)
                     s->session->tlsext_ticklen))
                         return 0;
 
-        } else if (s->internal->tlsext_session_ticket != NULL) {
+        } else if (s->tlsext_session_ticket != NULL) {
                 /*
                  * Attempt to resume with a custom provided session ticket set
                  * by SSL_set_session_ticket_ext().
                  */
-                if (s->internal->tlsext_session_ticket->length > 0) {
-                        size_t ticklen = s->internal->tlsext_session_ticket->length;
+                if (s->tlsext_session_ticket->length > 0) {
+                        size_t ticklen = s->tlsext_session_ticket->length;
 
                         if ((s->session->tlsext_tick = malloc(ticklen)) == NULL)
                                 return 0;
                         memcpy(s->session->tlsext_tick,
-                            s->internal->tlsext_session_ticket->data,
+                            s->tlsext_session_ticket->data,
                             ticklen);
                         s->session->tlsext_ticklen = ticklen;
 
@@ -1149,10 +1149,10 @@ static int
 tlsext_sessionticket_server_parse(SSL *s, uint16_t msg_type, CBS *cbs,
     int *alert)
 {
-        if (s->internal->tls_session_ticket_ext_cb) {
-                if (!s->internal->tls_session_ticket_ext_cb(s, CBS_data(cbs),
+        if (s->tls_session_ticket_ext_cb) {
+                if (!s->tls_session_ticket_ext_cb(s, CBS_data(cbs),
                     (int)CBS_len(cbs),
-                    s->internal->tls_session_ticket_ext_cb_arg)) {
+                    s->tls_session_ticket_ext_cb_arg)) {
                         *alert = SSL_AD_INTERNAL_ERROR;
                         return 0;
                 }
@@ -1170,7 +1170,7 @@ tlsext_sessionticket_server_parse(SSL *s, uint16_t msg_type, CBS *cbs,
 static int
 tlsext_sessionticket_server_needs(SSL *s, uint16_t msg_type)
 {
-        return (s->internal->tlsext_ticket_expected &&
+        return (s->tlsext_ticket_expected &&
             !(SSL_get_options(s) & SSL_OP_NO_TICKET) &&
             ssl_security_tickets(s));
 }
@@ -1186,10 +1186,10 @@ static int
 tlsext_sessionticket_client_parse(SSL *s, uint16_t msg_type, CBS *cbs,
     int *alert)
 {
-        if (s->internal->tls_session_ticket_ext_cb) {
-                if (!s->internal->tls_session_ticket_ext_cb(s, CBS_data(cbs),
+        if (s->tls_session_ticket_ext_cb) {
+                if (!s->tls_session_ticket_ext_cb(s, CBS_data(cbs),
                     (int)CBS_len(cbs),
-                    s->internal->tls_session_ticket_ext_cb_arg)) {
+                    s->tls_session_ticket_ext_cb_arg)) {
                         *alert = SSL_AD_INTERNAL_ERROR;
                         return 0;
                 }
@@ -1200,7 +1200,7 @@ tlsext_sessionticket_client_parse(SSL *s, uint16_t msg_type, CBS *cbs,
                 return 0;
         }
 
-        s->internal->tlsext_ticket_expected = 1;
+        s->tlsext_ticket_expected = 1;
 
         return 1;
 }
@@ -1310,7 +1310,7 @@ tlsext_srtp_server_parse(SSL *s, uint16_t msg_type, CBS *cbs, int *alert)
                                 goto err;
 
                         if (cprof->id == sprof->id) {
-                                s->internal->srtp_profile = sprof;
+                                s->srtp_profile = sprof;
                                 ret = 1;
                                 goto done;
                         }
@@ -1397,7 +1397,7 @@ tlsext_srtp_client_parse(SSL *s, uint16_t msg_type, CBS *cbs, int *alert)
                 }
 
                 if (prof->id == id) {
-                        s->internal->srtp_profile = prof;
+                        s->srtp_profile = prof;
                         return 1;
                 }
         }
@@ -1899,15 +1899,15 @@ tlsext_psk_server_parse(SSL *s, uint16_t msg_type, CBS *cbs, int *alert)
 static int
 tlsext_quic_transport_parameters_client_needs(SSL *s, uint16_t msg_type)
 {
-        return SSL_is_quic(s) && s->internal->quic_transport_params_len > 0;
+        return SSL_is_quic(s) && s->quic_transport_params_len > 0;
 }
 
 static int
 tlsext_quic_transport_parameters_client_build(SSL *s, uint16_t msg_type,
     CBB *cbb)
 {
-        if (!CBB_add_bytes(cbb, s->internal->quic_transport_params,
-            s->internal->quic_transport_params_len))
+        if (!CBB_add_bytes(cbb, s->quic_transport_params,
+            s->quic_transport_params_len))
                 return 0;
 
         return 1;
@@ -1934,15 +1934,15 @@ tlsext_quic_transport_parameters_client_parse(SSL *s, uint16_t msg_type,
 static int
 tlsext_quic_transport_parameters_server_needs(SSL *s, uint16_t msg_type)
 {
-        return SSL_is_quic(s) && s->internal->quic_transport_params_len > 0;
+        return SSL_is_quic(s) && s->quic_transport_params_len > 0;
 }
 
 static int
 tlsext_quic_transport_parameters_server_build(SSL *s, uint16_t msg_type,
     CBB *cbb)
 {
-        if (!CBB_add_bytes(cbb, s->internal->quic_transport_params,
-            s->internal->quic_transport_params_len))
+        if (!CBB_add_bytes(cbb, s->quic_transport_params,
+            s->quic_transport_params_len))
                 return 0;
 
         return 1;
@@ -2294,7 +2294,7 @@ tlsext_clienthello_hash_extension(SSL *s, uint16_t type, CBS *cbs)
          * RFC 8446 4.1.2. For subsequent CH, early data will be removed,
          * cookie may be added, padding may be removed.
          */
-        struct tls13_ctx *ctx = s->internal->tls13;
+        struct tls13_ctx *ctx = s->tls13;
 
         if (type == TLSEXT_TYPE_early_data || type == TLSEXT_TYPE_cookie ||
             type == TLSEXT_TYPE_padding)
@@ -2344,11 +2344,11 @@ tlsext_parse(SSL *s, int is_server, uint16_t msg_type, CBS *cbs, int *alert)
                 if (!CBS_get_u16_length_prefixed(&extensions, &extension_data))
                         goto err;
 
-                if (s->internal->tlsext_debug_cb != NULL)
-                        s->internal->tlsext_debug_cb(s, !is_server, type,
+                if (s->tlsext_debug_cb != NULL)
+                        s->tlsext_debug_cb(s, !is_server, type,
                             (unsigned char *)CBS_data(&extension_data),
                             CBS_len(&extension_data),
-                            s->internal->tlsext_debug_arg);
+                            s->tlsext_debug_arg);
 
                 /* Unknown extensions are ignored. */
                 if ((tlsext = tls_extension_find(type, &idx)) == NULL)
@@ -2397,7 +2397,7 @@ tlsext_server_reset_state(SSL *s)
         free(s->s3->alpn_selected);
         s->s3->alpn_selected = NULL;
         s->s3->alpn_selected_len = 0;
-        s->internal->srtp_profile = NULL;
+        s->srtp_profile = NULL;
 }
 
 int
diff --git a/src/lib/libssl/ssl_versions.c b/src/lib/libssl/ssl_versions.c
index 4a58f14ccd..3cd6db01ca 100644
--- a/src/lib/libssl/ssl_versions.c
+++ b/src/lib/libssl/ssl_versions.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ssl_versions.c,v 1.24 2022/09/11 18:13:30 jsing Exp $ */
+/* $OpenBSD: ssl_versions.c,v 1.25 2022/10/02 16:36:41 jsing Exp $ */
 /*
  * Copyright (c) 2016, 2017 Joel Sing <jsing@openbsd.org>
  *
@@ -140,13 +140,13 @@ ssl_enabled_tls_version_range(SSL *s, uint16_t *min_ver, uint16_t *max_ver)
 
         min_version = 0;
         max_version = TLS1_3_VERSION;
-        options = s->internal->options;
+        options = s->options;
 
         if (SSL_is_dtls(s)) {
                 options = 0;
-                if (s->internal->options & SSL_OP_NO_DTLSv1)
+                if (s->options & SSL_OP_NO_DTLSv1)
                         options |= SSL_OP_NO_TLSv1 | SSL_OP_NO_TLSv1_1;
-                if (s->internal->options & SSL_OP_NO_DTLSv1_2)
+                if (s->options & SSL_OP_NO_DTLSv1_2)
                         options |= SSL_OP_NO_TLSv1 | SSL_OP_NO_TLSv1_2;
         }
 
@@ -174,7 +174,7 @@ ssl_enabled_tls_version_range(SSL *s, uint16_t *min_ver, uint16_t *max_ver)
 
         /* Limit to configured version range. */
         if (!ssl_clamp_tls_version_range(&min_version, &max_version,
-            s->internal->min_tls_version, s->internal->max_tls_version))
+            s->min_tls_version, s->max_tls_version))
                 return 0;
 
         /* QUIC requires a minimum of TLSv1.3. */
diff --git a/src/lib/libssl/t1_enc.c b/src/lib/libssl/t1_enc.c
index c996159a47..66a7aea2f5 100644
--- a/src/lib/libssl/t1_enc.c
+++ b/src/lib/libssl/t1_enc.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: t1_enc.c,v 1.154 2022/02/05 14:54:10 jsing Exp $ */
+/* $OpenBSD: t1_enc.c,v 1.155 2022/10/02 16:36:41 jsing Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -311,13 +311,13 @@ tls1_change_cipher_state(SSL *s, int is_write)
         }
 
         if (!is_write) {
-                if (!tls12_record_layer_change_read_cipher_state(s->internal->rl,
+                if (!tls12_record_layer_change_read_cipher_state(s->rl,
                     &mac_key, &key, &iv))
                         goto err;
                 if (SSL_is_dtls(s))
                         dtls1_reset_read_seq_numbers(s);
         } else {
-                if (!tls12_record_layer_change_write_cipher_state(s->internal->rl,
+                if (!tls12_record_layer_change_write_cipher_state(s->rl,
                     &mac_key, &key, &iv))
                         goto err;
         }
@@ -375,8 +375,8 @@ tls1_setup_key_block(SSL *s)
         if (!ssl_get_handshake_evp_md(s, &handshake_hash))
                 return (0);
 
-        tls12_record_layer_set_aead(s->internal->rl, aead);
-        tls12_record_layer_set_cipher_hash(s->internal->rl, cipher,
+        tls12_record_layer_set_aead(s->rl, aead);
+        tls12_record_layer_set_cipher_hash(s->rl, cipher,
             handshake_hash, mac_hash);
 
         if ((key_block = tls12_key_block_new()) == NULL)
@@ -387,7 +387,7 @@ tls1_setup_key_block(SSL *s)
         s->s3->hs.tls12.key_block = key_block;
         key_block = NULL;
 
-        if (!(s->internal->options & SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS) &&
+        if (!(s->options & SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS) &&
             s->method->version <= TLS1_VERSION) {
                 /*
                  * Enable vulnerability countermeasure for CBC ciphers with
diff --git a/src/lib/libssl/t1_lib.c b/src/lib/libssl/t1_lib.c
index 355c9827ef..c326575231 100644
--- a/src/lib/libssl/t1_lib.c
+++ b/src/lib/libssl/t1_lib.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: t1_lib.c,v 1.195 2022/08/17 18:45:25 tb Exp $ */
+/* $OpenBSD: t1_lib.c,v 1.196 2022/10/02 16:36:42 jsing Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -139,7 +139,7 @@ tls1_free(SSL *s)
         if (s == NULL)
                 return;
 
-        free(s->internal->tlsext_session_ticket);
+        free(s->tlsext_session_ticket);
         ssl3_free(s);
 }
 
@@ -404,8 +404,8 @@ tls1_get_formatlist(const SSL *s, int client_formats, const uint8_t **pformats,
                 return;
         }
 
-        *pformats = s->internal->tlsext_ecpointformatlist;
-        *pformatslen = s->internal->tlsext_ecpointformatlist_length;
+        *pformats = s->tlsext_ecpointformatlist;
+        *pformatslen = s->tlsext_ecpointformatlist_length;
         if (*pformats == NULL) {
                 *pformats = ecformats_default;
                 *pformatslen = sizeof(ecformats_default);
@@ -427,8 +427,8 @@ tls1_get_group_list(const SSL *s, int client_groups, const uint16_t **pgroups,
                 return;
         }
 
-        *pgroups = s->internal->tlsext_supportedgroups;
-        *pgroupslen = s->internal->tlsext_supportedgroups_length;
+        *pgroups = s->tlsext_supportedgroups;
+        *pgroupslen = s->tlsext_supportedgroups_length;
         if (*pgroups != NULL)
                 return;
 
@@ -451,7 +451,7 @@ tls1_get_group_lists(const SSL *ssl, const uint16_t **pref, size_t *preflen,
         if (!ssl->server)
                 return 0;
 
-        server_pref = (ssl->internal->options & SSL_OP_CIPHER_SERVER_PREFERENCE);
+        server_pref = (ssl->options & SSL_OP_CIPHER_SERVER_PREFERENCE);
         tls1_get_group_list(ssl, (server_pref == 0), pref, preflen);
         tls1_get_group_list(ssl, (server_pref != 0), supp, supplen);
 
@@ -738,12 +738,12 @@ ssl_check_clienthello_tlsext_early(SSL *s)
          * ssl3_choose_cipher in s3_lib.c.
          */
 
-        if (s->ctx != NULL && s->ctx->internal->tlsext_servername_callback != 0)
-                ret = s->ctx->internal->tlsext_servername_callback(s, &al,
-                    s->ctx->internal->tlsext_servername_arg);
-        else if (s->initial_ctx != NULL && s->initial_ctx->internal->tlsext_servername_callback != 0)
-                ret = s->initial_ctx->internal->tlsext_servername_callback(s, &al,
-                    s->initial_ctx->internal->tlsext_servername_arg);
+        if (s->ctx != NULL && s->ctx->tlsext_servername_callback != 0)
+                ret = s->ctx->tlsext_servername_callback(s, &al,
+                    s->ctx->tlsext_servername_arg);
+        else if (s->initial_ctx != NULL && s->initial_ctx->tlsext_servername_callback != 0)
+                ret = s->initial_ctx->tlsext_servername_callback(s, &al,
+                    s->initial_ctx->tlsext_servername_arg);
 
         switch (ret) {
         case SSL_TLSEXT_ERR_ALERT_FATAL:
@@ -770,32 +770,32 @@ ssl_check_clienthello_tlsext_late(SSL *s)
          * has been chosen because this may influence which certificate is sent
          */
         if ((s->tlsext_status_type != -1) &&
-            s->ctx && s->ctx->internal->tlsext_status_cb) {
+            s->ctx && s->ctx->tlsext_status_cb) {
                 int r;
                 SSL_CERT_PKEY *certpkey;
                 certpkey = ssl_get_server_send_pkey(s);
                 /* If no certificate can't return certificate status */
                 if (certpkey == NULL) {
-                        s->internal->tlsext_status_expected = 0;
+                        s->tlsext_status_expected = 0;
                         return 1;
                 }
                 /* Set current certificate to one we will use so
                  * SSL_get_certificate et al can pick it up.
                  */
                 s->cert->key = certpkey;
-                r = s->ctx->internal->tlsext_status_cb(s,
-                    s->ctx->internal->tlsext_status_arg);
+                r = s->ctx->tlsext_status_cb(s,
+                    s->ctx->tlsext_status_arg);
                 switch (r) {
                         /* We don't want to send a status request response */
                 case SSL_TLSEXT_ERR_NOACK:
-                        s->internal->tlsext_status_expected = 0;
+                        s->tlsext_status_expected = 0;
                         break;
                         /* status request response should be sent */
                 case SSL_TLSEXT_ERR_OK:
-                        if (s->internal->tlsext_ocsp_resp)
-                                s->internal->tlsext_status_expected = 1;
+                        if (s->tlsext_ocsp_resp)
+                                s->tlsext_status_expected = 1;
                         else
-                                s->internal->tlsext_status_expected = 0;
+                                s->tlsext_status_expected = 0;
                         break;
                         /* something bad happened */
                 case SSL_TLSEXT_ERR_ALERT_FATAL:
@@ -804,7 +804,7 @@ ssl_check_clienthello_tlsext_late(SSL *s)
                         goto err;
                 }
         } else
-                s->internal->tlsext_status_expected = 0;
+                s->tlsext_status_expected = 0;
 
  err:
         switch (ret) {
@@ -827,26 +827,26 @@ ssl_check_serverhello_tlsext(SSL *s)
 
         ret = SSL_TLSEXT_ERR_OK;
 
-        if (s->ctx != NULL && s->ctx->internal->tlsext_servername_callback != 0)
-                ret = s->ctx->internal->tlsext_servername_callback(s, &al,
-                    s->ctx->internal->tlsext_servername_arg);
-        else if (s->initial_ctx != NULL && s->initial_ctx->internal->tlsext_servername_callback != 0)
-                ret = s->initial_ctx->internal->tlsext_servername_callback(s, &al,
-                    s->initial_ctx->internal->tlsext_servername_arg);
+        if (s->ctx != NULL && s->ctx->tlsext_servername_callback != 0)
+                ret = s->ctx->tlsext_servername_callback(s, &al,
+                    s->ctx->tlsext_servername_arg);
+        else if (s->initial_ctx != NULL && s->initial_ctx->tlsext_servername_callback != 0)
+                ret = s->initial_ctx->tlsext_servername_callback(s, &al,
+                    s->initial_ctx->tlsext_servername_arg);
 
         /* If we've requested certificate status and we wont get one
          * tell the callback
          */
-        if ((s->tlsext_status_type != -1) && !(s->internal->tlsext_status_expected) &&
-            s->ctx && s->ctx->internal->tlsext_status_cb) {
+        if ((s->tlsext_status_type != -1) && !(s->tlsext_status_expected) &&
+            s->ctx && s->ctx->tlsext_status_cb) {
                 int r;
 
-                free(s->internal->tlsext_ocsp_resp);
-                s->internal->tlsext_ocsp_resp = NULL;
-                s->internal->tlsext_ocsp_resp_len = 0;
+                free(s->tlsext_ocsp_resp);
+                s->tlsext_ocsp_resp = NULL;
+                s->tlsext_ocsp_resp_len = 0;
 
-                r = s->ctx->internal->tlsext_status_cb(s,
-                    s->ctx->internal->tlsext_status_arg);
+                r = s->ctx->tlsext_status_cb(s,
+                    s->ctx->tlsext_status_arg);
                 if (r == 0) {
                         al = SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE;
                         ret = SSL_TLSEXT_ERR_ALERT_FATAL;
@@ -878,27 +878,27 @@ ssl_check_serverhello_tlsext(SSL *s)
  *   ret: (output) on return, if a ticket was decrypted, then this is set to
  *       point to the resulting session.
  *
- * If s->internal->tls_session_secret_cb is set then we are expecting a pre-shared key
+ * If s->tls_session_secret_cb is set 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->internal->tlsext_ticket_expected be set to 1.
+ * never be decrypted, nor will s->tlsext_ticket_expected be set to 1.
  *
  * Returns:
  *    TLS1_TICKET_FATAL_ERROR: error from parsing or decrypting the ticket.
  *    TLS1_TICKET_NONE: no ticket was found (or was ignored, based on settings).
  *    TLS1_TICKET_EMPTY: a zero length extension was found, indicating that the
  *       client supports session tickets but doesn't currently have one to offer.
- *    TLS1_TICKET_NOT_DECRYPTED: either s->internal->tls_session_secret_cb was
+ *    TLS1_TICKET_NOT_DECRYPTED: either s->tls_session_secret_cb was
  *       set, or a ticket was offered but couldn't be decrypted because of a
  *       non-fatal error.
  *    TLS1_TICKET_DECRYPTED: a ticket was successfully decrypted and *ret was set.
  *
  * Side effects:
- *   Sets s->internal->tlsext_ticket_expected to 1 if the server will have to issue
+ *   Sets s->tlsext_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->internal->tls_session_secret_cb is NULL) but the client either doesn't have
+ *   (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->tlsext_ticket_key_cb asked to renew the client's ticket.
- *   Otherwise, s->internal->tlsext_ticket_expected is set to 0.
+ *   Otherwise, s->tlsext_ticket_expected is set to 0.
  */
 int
 tls1_process_ticket(SSL *s, CBS *ext_block, int *alert, SSL_SESSION **ret)
@@ -906,7 +906,7 @@ tls1_process_ticket(SSL *s, CBS *ext_block, int *alert, SSL_SESSION **ret)
         CBS extensions, ext_data;
         uint16_t ext_type = 0;
 
-        s->internal->tlsext_ticket_expected = 0;
+        s->tlsext_ticket_expected = 0;
         *ret = NULL;
 
         /*
@@ -947,11 +947,11 @@ tls1_process_ticket(SSL *s, CBS *ext_block, int *alert, SSL_SESSION **ret)
                  * The client will accept a ticket but does not currently
                  * have one.
                  */
-                s->internal->tlsext_ticket_expected = 1;
+                s->tlsext_ticket_expected = 1;
                 return TLS1_TICKET_EMPTY;
         }
 
-        if (s->internal->tls_session_secret_cb != NULL) {
+        if (s->tls_session_secret_cb != NULL) {
                 /*
                  * Indicate that the ticket could not be decrypted rather than
                  * generating the session from ticket now, trigger abbreviated
@@ -1004,7 +1004,7 @@ tls_decrypt_ticket(SSL *s, CBS *ticket, int *alert, SSL_SESSION **psess)
         if ((hctx = HMAC_CTX_new()) == NULL)
                 goto err;
 
-        if (tctx->internal->tlsext_ticket_key_cb != NULL) {
+        if (tctx->tlsext_ticket_key_cb != NULL) {
                 int rv;
 
                 /*
@@ -1016,7 +1016,7 @@ tls_decrypt_ticket(SSL *s, CBS *ticket, int *alert, SSL_SESSION **psess)
                 if (CBS_len(ticket) < EVP_MAX_IV_LENGTH)
                         goto derr;
 
-                if ((rv = tctx->internal->tlsext_ticket_key_cb(s,
+                if ((rv = tctx->tlsext_ticket_key_cb(s,
                     (unsigned char *)CBS_data(&ticket_name),
                     (unsigned char *)CBS_data(ticket), cctx, hctx, 0)) < 0)
                         goto err;
@@ -1024,7 +1024,7 @@ tls_decrypt_ticket(SSL *s, CBS *ticket, int *alert, SSL_SESSION **psess)
                         goto derr;
                 if (rv == 2) {
                         /* Renew ticket. */
-                        s->internal->tlsext_ticket_expected = 1;
+                        s->tlsext_ticket_expected = 1;
                 }
 
                 /*
@@ -1037,17 +1037,17 @@ tls_decrypt_ticket(SSL *s, CBS *ticket, int *alert, SSL_SESSION **psess)
         } else {
                 /* Check that the key name matches. */
                 if (!CBS_mem_equal(&ticket_name,
-                    tctx->internal->tlsext_tick_key_name,
-                    sizeof(tctx->internal->tlsext_tick_key_name)))
+                    tctx->tlsext_tick_key_name,
+                    sizeof(tctx->tlsext_tick_key_name)))
                         goto derr;
                 if (!CBS_get_bytes(ticket, &ticket_iv,
                     EVP_CIPHER_iv_length(EVP_aes_128_cbc())))
                         goto derr;
                 if (!EVP_DecryptInit_ex(cctx, EVP_aes_128_cbc(), NULL,
-                    tctx->internal->tlsext_tick_aes_key, CBS_data(&ticket_iv)))
+                    tctx->tlsext_tick_aes_key, CBS_data(&ticket_iv)))
                         goto err;
-                if (!HMAC_Init_ex(hctx, tctx->internal->tlsext_tick_hmac_key,
-                    sizeof(tctx->internal->tlsext_tick_hmac_key), EVP_sha256(),
+                if (!HMAC_Init_ex(hctx, tctx->tlsext_tick_hmac_key,
+                    sizeof(tctx->tlsext_tick_hmac_key), EVP_sha256(),
                     NULL))
                         goto err;
         }
@@ -1113,7 +1113,7 @@ tls_decrypt_ticket(SSL *s, CBS *ticket, int *alert, SSL_SESSION **psess)
 
  derr:
         ERR_clear_error();
-        s->internal->tlsext_ticket_expected = 1;
+        s->tlsext_ticket_expected = 1;
         ret = TLS1_TICKET_NOT_DECRYPTED;
         goto done;
 
diff --git a/src/lib/libssl/tls13_client.c b/src/lib/libssl/tls13_client.c
index 33ef55d2ec..746447cc13 100644
--- a/src/lib/libssl/tls13_client.c
+++ b/src/lib/libssl/tls13_client.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: tls13_client.c,v 1.99 2022/09/11 14:33:07 jsing Exp $ */
+/* $OpenBSD: tls13_client.c,v 1.100 2022/10/02 16:36:42 jsing Exp $ */
 /*
  * Copyright (c) 2018, 2019 Joel Sing <jsing@openbsd.org>
  *
@@ -39,7 +39,7 @@ tls13_client_init(struct tls13_ctx *ctx)
         s->version = ctx->hs->our_max_tls_version;
 
         tls13_record_layer_set_retry_after_phh(ctx->rl,
-            (s->internal->mode & SSL_MODE_AUTO_RETRY) != 0);
+            (s->mode & SSL_MODE_AUTO_RETRY) != 0);
 
         if (!ssl_get_new_session(s, 0)) /* XXX */
                 return 0;
diff --git a/src/lib/libssl/tls13_legacy.c b/src/lib/libssl/tls13_legacy.c
index 545f2cd978..57fb84cefb 100644
--- a/src/lib/libssl/tls13_legacy.c
+++ b/src/lib/libssl/tls13_legacy.c
@@ -1,4 +1,4 @@
-/*      $OpenBSD: tls13_legacy.c,v 1.38 2022/07/17 15:49:20 jsing Exp $ */
+/*      $OpenBSD: tls13_legacy.c,v 1.39 2022/10/02 16:36:42 jsing Exp $ */
 /*
  * Copyright (c) 2018, 2019 Joel Sing <jsing@openbsd.org>
  *
@@ -30,7 +30,7 @@ tls13_legacy_wire_read(SSL *ssl, uint8_t *buf, size_t len)
                 return TLS13_IO_FAILURE;
         }
 
-        ssl->internal->rwstate = SSL_READING;
+        ssl->rwstate = SSL_READING;
         errno = 0;
 
         if ((n = BIO_read(ssl->rbio, buf, len)) <= 0) {
@@ -46,7 +46,7 @@ tls13_legacy_wire_read(SSL *ssl, uint8_t *buf, size_t len)
         }
 
         if (n == len)
-                ssl->internal->rwstate = SSL_NOTHING;
+                ssl->rwstate = SSL_NOTHING;
 
         return n;
 }
@@ -69,7 +69,7 @@ tls13_legacy_wire_write(SSL *ssl, const uint8_t *buf, size_t len)
                 return TLS13_IO_FAILURE;
         }
 
-        ssl->internal->rwstate = SSL_WRITING;
+        ssl->rwstate = SSL_WRITING;
         errno = 0;
 
         if ((n = BIO_write(ssl->wbio, buf, len)) <= 0) {
@@ -83,7 +83,7 @@ tls13_legacy_wire_write(SSL *ssl, const uint8_t *buf, size_t len)
         }
 
         if (n == len)
-                ssl->internal->rwstate = SSL_NOTHING;
+                ssl->rwstate = SSL_NOTHING;
 
         return n;
 }
@@ -123,7 +123,7 @@ tls13_legacy_wire_flush_cb(void *arg)
 static void
 tls13_legacy_error(SSL *ssl)
 {
-        struct tls13_ctx *ctx = ssl->internal->tls13;
+        struct tls13_ctx *ctx = ssl->tls13;
         int reason = SSL_R_UNKNOWN;
 
         /* If we received a fatal alert we already put an error on the stack. */
@@ -171,7 +171,7 @@ tls13_legacy_return_code(SSL *ssl, ssize_t ret)
         if (ret > 0)
                 return ret;
 
-        ssl->internal->rwstate = SSL_NOTHING;
+        ssl->rwstate = SSL_NOTHING;
 
         switch (ret) {
         case TLS13_IO_EOF:
@@ -187,12 +187,12 @@ tls13_legacy_return_code(SSL *ssl, ssize_t ret)
 
         case TLS13_IO_WANT_POLLIN:
                 BIO_set_retry_read(ssl->rbio);
-                ssl->internal->rwstate = SSL_READING;
+                ssl->rwstate = SSL_READING;
                 return -1;
 
         case TLS13_IO_WANT_POLLOUT:
                 BIO_set_retry_write(ssl->wbio);
-                ssl->internal->rwstate = SSL_WRITING;
+                ssl->rwstate = SSL_WRITING;
                 return -1;
 
         case TLS13_IO_WANT_RETRY:
@@ -207,7 +207,7 @@ tls13_legacy_return_code(SSL *ssl, ssize_t ret)
 int
 tls13_legacy_pending(const SSL *ssl)
 {
-        struct tls13_ctx *ctx = ssl->internal->tls13;
+        struct tls13_ctx *ctx = ssl->tls13;
         ssize_t ret;
 
         if (ctx == NULL)
@@ -223,11 +223,11 @@ tls13_legacy_pending(const SSL *ssl)
 int
 tls13_legacy_read_bytes(SSL *ssl, int type, unsigned char *buf, int len, int peek)
 {
-        struct tls13_ctx *ctx = ssl->internal->tls13;
+        struct tls13_ctx *ctx = ssl->tls13;
         ssize_t ret;
 
         if (ctx == NULL || !ctx->handshake_completed) {
-                if ((ret = ssl->internal->handshake_func(ssl)) <= 0)
+                if ((ret = ssl->handshake_func(ssl)) <= 0)
                         return ret;
                 if (len == 0)
                         return 0;
@@ -235,7 +235,7 @@ tls13_legacy_read_bytes(SSL *ssl, int type, unsigned char *buf, int len, int pee
         }
 
         tls13_record_layer_set_retry_after_phh(ctx->rl,
-            (ctx->ssl->internal->mode & SSL_MODE_AUTO_RETRY) != 0);
+            (ctx->ssl->mode & SSL_MODE_AUTO_RETRY) != 0);
 
         if (type != SSL3_RT_APPLICATION_DATA) {
                 SSLerror(ssl, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
@@ -257,13 +257,13 @@ tls13_legacy_read_bytes(SSL *ssl, int type, unsigned char *buf, int len, int pee
 int
 tls13_legacy_write_bytes(SSL *ssl, int type, const void *vbuf, int len)
 {
-        struct tls13_ctx *ctx = ssl->internal->tls13;
+        struct tls13_ctx *ctx = ssl->tls13;
         const uint8_t *buf = vbuf;
         size_t n, sent;
         ssize_t ret;
 
         if (ctx == NULL || !ctx->handshake_completed) {
-                if ((ret = ssl->internal->handshake_func(ssl)) <= 0)
+                if ((ret = ssl->handshake_func(ssl)) <= 0)
                         return ret;
                 if (len == 0)
                         return 0;
@@ -283,7 +283,7 @@ tls13_legacy_write_bytes(SSL *ssl, int type, const void *vbuf, int len)
          * The TLSv1.3 record layer write behaviour is the same as
          * SSL_MODE_ENABLE_PARTIAL_WRITE.
          */
-        if (ssl->internal->mode & SSL_MODE_ENABLE_PARTIAL_WRITE) {
+        if (ssl->mode & SSL_MODE_ENABLE_PARTIAL_WRITE) {
                 ret = tls13_write_application_data(ctx->rl, buf, len);
                 return tls13_legacy_return_code(ssl, ret);
         }
@@ -352,18 +352,18 @@ tls13_use_legacy_stack(struct tls13_ctx *ctx)
                 s->s3->rbuf.left = CBS_len(&cbs);
                 s->s3->rrec.type = SSL3_RT_HANDSHAKE;
                 s->s3->rrec.length = CBS_len(&cbs);
-                s->internal->rstate = SSL_ST_READ_BODY;
-                s->internal->packet = s->s3->rbuf.buf;
-                s->internal->packet_length = SSL3_RT_HEADER_LENGTH;
-                s->internal->mac_packet = 1;
+                s->rstate = SSL_ST_READ_BODY;
+                s->packet = s->s3->rbuf.buf;
+                s->packet_length = SSL3_RT_HEADER_LENGTH;
+                s->mac_packet = 1;
         }
 
         /* Stash the current handshake message. */
         tls13_handshake_msg_data(ctx->hs_msg, &cbs);
-        if (!BUF_MEM_grow_clean(s->internal->init_buf, CBS_len(&cbs)))
+        if (!BUF_MEM_grow_clean(s->init_buf, CBS_len(&cbs)))
                 goto err;
-        if (!CBS_write_bytes(&cbs, s->internal->init_buf->data,
-            s->internal->init_buf->length, NULL))
+        if (!CBS_write_bytes(&cbs, s->init_buf->data,
+            s->init_buf->length, NULL))
                 goto err;
 
         s->s3->hs.tls12.reuse_message = 1;
@@ -386,7 +386,7 @@ tls13_use_legacy_client(struct tls13_ctx *ctx)
         if (!tls13_use_legacy_stack(ctx))
                 return 0;
 
-        s->internal->handshake_func = s->method->ssl_connect;
+        s->handshake_func = s->method->ssl_connect;
         s->version = s->method->max_tls_version;
 
         return 1;
@@ -400,7 +400,7 @@ tls13_use_legacy_server(struct tls13_ctx *ctx)
         if (!tls13_use_legacy_stack(ctx))
                 return 0;
 
-        s->internal->handshake_func = s->method->ssl_accept;
+        s->handshake_func = s->method->ssl_accept;
         s->version = s->method->max_tls_version;
         s->server = 1;
 
@@ -410,7 +410,7 @@ tls13_use_legacy_server(struct tls13_ctx *ctx)
 int
 tls13_legacy_accept(SSL *ssl)
 {
-        struct tls13_ctx *ctx = ssl->internal->tls13;
+        struct tls13_ctx *ctx = ssl->tls13;
         int ret;
 
         if (ctx == NULL) {
@@ -442,7 +442,7 @@ tls13_legacy_accept(SSL *ssl)
 int
 tls13_legacy_connect(SSL *ssl)
 {
-        struct tls13_ctx *ctx = ssl->internal->tls13;
+        struct tls13_ctx *ctx = ssl->tls13;
         int ret;
 
         if (ctx == NULL) {
@@ -474,7 +474,7 @@ tls13_legacy_connect(SSL *ssl)
 int
 tls13_legacy_shutdown(SSL *ssl)
 {
-        struct tls13_ctx *ctx = ssl->internal->tls13;
+        struct tls13_ctx *ctx = ssl->tls13;
         uint8_t buf[512]; /* XXX */
         ssize_t ret;
 
@@ -484,15 +484,15 @@ tls13_legacy_shutdown(SSL *ssl)
          * alerts. All other cases, including EOF, return -1 and set internal
          * state appropriately.
          */
-        if (ctx == NULL || ssl->internal->quiet_shutdown) {
-                ssl->internal->shutdown = SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN;
+        if (ctx == NULL || ssl->quiet_shutdown) {
+                ssl->shutdown = SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN;
                 return 1;
         }
 
         if (!ctx->close_notify_sent) {
                 /* Enqueue and send close notify. */
-                if (!(ssl->internal->shutdown & SSL_SENT_SHUTDOWN)) {
-                        ssl->internal->shutdown |= SSL_SENT_SHUTDOWN;
+                if (!(ssl->shutdown & SSL_SENT_SHUTDOWN)) {
+                        ssl->shutdown |= SSL_SENT_SHUTDOWN;
                         if ((ret = tls13_send_alert(ctx->rl,
                             TLS13_ALERT_CLOSE_NOTIFY)) < 0)
                                 return tls13_legacy_return_code(ssl, ret);
@@ -533,13 +533,13 @@ tls13_legacy_servername_process(struct tls13_ctx *ctx, uint8_t *alert)
         SSL_CTX *ssl_ctx = ctx->ssl->ctx;
         SSL *s = ctx->ssl;
 
-        if (ssl_ctx->internal->tlsext_servername_callback == NULL)
+        if (ssl_ctx->tlsext_servername_callback == NULL)
                 ssl_ctx = s->initial_ctx;
-        if (ssl_ctx->internal->tlsext_servername_callback == NULL)
+        if (ssl_ctx->tlsext_servername_callback == NULL)
                 return 1;
 
-        ret = ssl_ctx->internal->tlsext_servername_callback(s, &legacy_alert,
-            ssl_ctx->internal->tlsext_servername_arg);
+        ret = ssl_ctx->tlsext_servername_callback(s, &legacy_alert,
+            ssl_ctx->tlsext_servername_arg);
 
         /*
          * Ignore SSL_TLSEXT_ERR_ALERT_WARNING returns to match OpenSSL's
diff --git a/src/lib/libssl/tls13_lib.c b/src/lib/libssl/tls13_lib.c
index 651c34ca29..017cc887b8 100644
--- a/src/lib/libssl/tls13_lib.c
+++ b/src/lib/libssl/tls13_lib.c
@@ -1,4 +1,4 @@
-/*      $OpenBSD: tls13_lib.c,v 1.71 2022/09/10 15:29:33 jsing Exp $ */
+/*      $OpenBSD: tls13_lib.c,v 1.72 2022/10/02 16:36:42 jsing Exp $ */
 /*
  * Copyright (c) 2018, 2019 Joel Sing <jsing@openbsd.org>
  * Copyright (c) 2019 Bob Beck <beck@openbsd.org>
@@ -110,7 +110,7 @@ tls13_alert_received_cb(uint8_t alert_desc, void *arg)
 
         if (alert_desc == TLS13_ALERT_CLOSE_NOTIFY) {
                 ctx->close_notify_recv = 1;
-                ctx->ssl->internal->shutdown |= SSL_RECEIVED_SHUTDOWN;
+                ctx->ssl->shutdown |= SSL_RECEIVED_SHUTDOWN;
                 ctx->ssl->s3->warn_alert = alert_desc;
                 return;
         }
@@ -158,7 +158,7 @@ tls13_legacy_handshake_message_recv_cb(void *arg)
         SSL *s = ctx->ssl;
         CBS cbs;
 
-        if (s->internal->msg_callback == NULL)
+        if (s->msg_callback == NULL)
                 return;
 
         tls13_handshake_msg_data(ctx->hs_msg, &cbs);
@@ -172,7 +172,7 @@ tls13_legacy_handshake_message_sent_cb(void *arg)
         SSL *s = ctx->ssl;
         CBS cbs;
 
-        if (s->internal->msg_callback == NULL)
+        if (s->msg_callback == NULL)
                 return;
 
         tls13_handshake_msg_data(ctx->hs_msg, &cbs);
@@ -195,11 +195,11 @@ tls13_legacy_ocsp_status_recv_cb(void *arg)
         SSL *s = ctx->ssl;
         int ret;
 
-        if (s->ctx->internal->tlsext_status_cb == NULL)
+        if (s->ctx->tlsext_status_cb == NULL)
                 return 1;
 
-        ret = s->ctx->internal->tlsext_status_cb(s,
-            s->ctx->internal->tlsext_status_arg);
+        ret = s->ctx->tlsext_status_cb(s,
+            s->ctx->tlsext_status_arg);
         if (ret < 0) {
                 ctx->alert = TLS13_ALERT_INTERNAL_ERROR;
                 SSLerror(s, ERR_R_MALLOC_FAILURE);
@@ -413,7 +413,7 @@ tls13_ctx_new(int mode, SSL *ssl)
 
         ctx->middlebox_compat = 1;
 
-        ssl->internal->tls13 = ctx;
+        ssl->tls13 = ctx;
 
         if (SSL_is_quic(ssl)) {
                 if (!tls13_quic_init(ctx))
diff --git a/src/lib/libssl/tls13_server.c b/src/lib/libssl/tls13_server.c
index 82350702dc..7bbc541c82 100644
--- a/src/lib/libssl/tls13_server.c
+++ b/src/lib/libssl/tls13_server.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: tls13_server.c,v 1.103 2022/09/17 17:14:06 jsing Exp $ */
+/* $OpenBSD: tls13_server.c,v 1.104 2022/10/02 16:36:42 jsing Exp $ */
 /*
  * Copyright (c) 2019, 2020 Joel Sing <jsing@openbsd.org>
  * Copyright (c) 2020 Bob Beck <beck@openbsd.org>
@@ -37,7 +37,7 @@ tls13_server_init(struct tls13_ctx *ctx)
         s->version = ctx->hs->our_max_tls_version;
 
         tls13_record_layer_set_retry_after_phh(ctx->rl,
-            (s->internal->mode & SSL_MODE_AUTO_RETRY) != 0);
+            (s->mode & SSL_MODE_AUTO_RETRY) != 0);
 
         if (!ssl_get_new_session(s, 0)) /* XXX */
                 return 0;
@@ -656,7 +656,7 @@ tls13_server_certificate_send(struct tls13_ctx *ctx, CBB *cbb)
         if ((chain = cpk->chain) == NULL)
                 chain = s->ctx->extra_certs;
 
-        if (chain == NULL && !(s->internal->mode & SSL_MODE_NO_AUTO_CHAIN)) {
+        if (chain == NULL && !(s->mode & SSL_MODE_NO_AUTO_CHAIN)) {
                 if ((xsc = X509_STORE_CTX_new()) == NULL)
                         goto err;
                 if (!X509_STORE_CTX_init(xsc, s->ctx->cert_store, cpk->x509, NULL))