BIO *dbio, *bio;
long ret = 1;
BIO *next;
+ SSL_CONNECTION *sc = NULL;
bs = BIO_get_data(b);
next = BIO_next(b);
ssl = bs->ssl;
- if ((ssl == NULL) && (cmd != BIO_C_SET_SSL))
+ if ((ssl == NULL
+ || (sc = SSL_CONNECTION_FROM_SSL(ssl)) == NULL)
+ && cmd != BIO_C_SET_SSL)
return 0;
+ /* TODO(QUIC): The rbio/wbio might be from QUIC_CONNECTION instead */
switch (cmd) {
case BIO_CTRL_RESET:
SSL_shutdown(ssl);
- if (ssl->handshake_func == ssl->method->ssl_connect)
+ if (sc->handshake_func == ssl->method->ssl_connect)
SSL_set_connect_state(ssl);
- else if (ssl->handshake_func == ssl->method->ssl_accept)
+ else if (sc->handshake_func == ssl->method->ssl_accept)
SSL_set_accept_state(ssl);
if (!SSL_clear(ssl)) {
if (next != NULL)
ret = BIO_ctrl(next, cmd, num, ptr);
- else if (ssl->rbio != NULL)
- ret = BIO_ctrl(ssl->rbio, cmd, num, ptr);
+ else if (sc->rbio != NULL)
+ ret = BIO_ctrl(sc->rbio, cmd, num, ptr);
else
ret = 1;
break;
BIO_set_shutdown(b, (int)num);
break;
case BIO_CTRL_WPENDING:
- ret = BIO_ctrl(ssl->wbio, cmd, num, ptr);
+ ret = BIO_ctrl(sc->wbio, cmd, num, ptr);
break;
case BIO_CTRL_PENDING:
ret = SSL_pending(ssl);
if (ret == 0)
- ret = BIO_pending(ssl->rbio);
+ ret = BIO_pending(sc->rbio);
break;
case BIO_CTRL_FLUSH:
BIO_clear_retry_flags(b);
- ret = BIO_ctrl(ssl->wbio, cmd, num, ptr);
+ ret = BIO_ctrl(sc->wbio, cmd, num, ptr);
BIO_copy_next_retry(b);
break;
case BIO_CTRL_PUSH:
- if ((next != NULL) && (next != ssl->rbio)) {
+ if ((next != NULL) && (next != sc->rbio)) {
/*
* We are going to pass ownership of next to the SSL object...but
* we don't own a reference to pass yet - so up ref
ret = (dbs->ssl != NULL);
break;
case BIO_C_GET_FD:
- ret = BIO_ctrl(ssl->rbio, cmd, num, ptr);
+ ret = BIO_ctrl(sc->rbio, cmd, num, ptr);
break;
case BIO_CTRL_SET_CALLBACK:
ret = 0; /* use callback ctrl */
break;
default:
- ret = BIO_ctrl(ssl->rbio, cmd, num, ptr);
+ ret = BIO_ctrl(sc->rbio, cmd, num, ptr);
break;
}
return ret;
ssl = bs->ssl;
switch (cmd) {
case BIO_CTRL_SET_CALLBACK:
- ret = BIO_callback_ctrl(ssl->rbio, cmd, fp);
+ ret = BIO_callback_ctrl(SSL_get_rbio(ssl), cmd, fp);
break;
default:
ret = 0;
#include "internal/time.h"
static void get_current_time(struct timeval *t);
-static int dtls1_handshake_write(SSL *s);
+static int dtls1_handshake_write(SSL_CONNECTION *s);
static size_t dtls1_link_min_mtu(void);
/* XDTLS: figure out the right values */
return (60 * 60 * 2);
}
-int dtls1_new(SSL *s)
+int dtls1_new(SSL *ssl)
{
DTLS1_STATE *d1;
+ SSL_CONNECTION *s = SSL_CONNECTION_FROM_SSL_ONLY(ssl);
+
+ if (s == NULL)
+ return 0;
if (!DTLS_RECORD_LAYER_new(&s->rlayer)) {
return 0;
}
- if (!ssl3_new(s))
+ if (!ssl3_new(ssl))
return 0;
if ((d1 = OPENSSL_zalloc(sizeof(*d1))) == NULL) {
- ssl3_free(s);
+ ssl3_free(ssl);
return 0;
}
pqueue_free(d1->buffered_messages);
pqueue_free(d1->sent_messages);
OPENSSL_free(d1);
- ssl3_free(s);
+ ssl3_free(ssl);
return 0;
}
s->d1 = d1;
- if (!s->method->ssl_clear(s))
+ if (!ssl->method->ssl_clear(ssl))
return 0;
return 1;
}
-static void dtls1_clear_queues(SSL *s)
+static void dtls1_clear_queues(SSL_CONNECTION *s)
{
dtls1_clear_received_buffer(s);
dtls1_clear_sent_buffer(s);
}
-void dtls1_clear_received_buffer(SSL *s)
+void dtls1_clear_received_buffer(SSL_CONNECTION *s)
{
pitem *item = NULL;
hm_fragment *frag = NULL;
}
}
-void dtls1_clear_sent_buffer(SSL *s)
+void dtls1_clear_sent_buffer(SSL_CONNECTION *s)
{
pitem *item = NULL;
hm_fragment *frag = NULL;
}
-void dtls1_free(SSL *s)
+void dtls1_free(SSL *ssl)
{
+ SSL_CONNECTION *s = SSL_CONNECTION_FROM_SSL_ONLY(ssl);
+
+ if (s == NULL)
+ return;
+
DTLS_RECORD_LAYER_free(&s->rlayer);
- ssl3_free(s);
+ ssl3_free(ssl);
if (s->d1 != NULL) {
dtls1_clear_queues(s);
s->d1 = NULL;
}
-int dtls1_clear(SSL *s)
+int dtls1_clear(SSL *ssl)
{
pqueue *buffered_messages;
pqueue *sent_messages;
size_t mtu;
size_t link_mtu;
+ SSL_CONNECTION *s = SSL_CONNECTION_FROM_SSL_ONLY(ssl);
+
+ if (s == NULL)
+ return 0;
+
DTLS_RECORD_LAYER_clear(&s->rlayer);
if (s->d1) {
s->d1->cookie_len = sizeof(s->d1->cookie);
}
- if (SSL_get_options(s) & SSL_OP_NO_QUERY_MTU) {
+ if (SSL_get_options(ssl) & SSL_OP_NO_QUERY_MTU) {
s->d1->mtu = mtu;
s->d1->link_mtu = link_mtu;
}
s->d1->sent_messages = sent_messages;
}
- if (!ssl3_clear(s))
+ if (!ssl3_clear(ssl))
return 0;
- if (s->method->version == DTLS_ANY_VERSION)
+ if (ssl->method->version == DTLS_ANY_VERSION)
s->version = DTLS_MAX_VERSION_INTERNAL;
#ifndef OPENSSL_NO_DTLS1_METHOD
else if (s->options & SSL_OP_CISCO_ANYCONNECT)
s->client_version = s->version = DTLS1_BAD_VER;
#endif
else
- s->version = s->method->version;
+ s->version = ssl->method->version;
return 1;
}
-long dtls1_ctrl(SSL *s, int cmd, long larg, void *parg)
+long dtls1_ctrl(SSL *ssl, int cmd, long larg, void *parg)
{
int ret = 0;
+ SSL_CONNECTION *s = SSL_CONNECTION_FROM_SSL_ONLY(ssl);
+
+ if (s == NULL)
+ return 0;
switch (cmd) {
case DTLS_CTRL_GET_TIMEOUT:
s->d1->mtu = larg;
return larg;
default:
- ret = ssl3_ctrl(s, cmd, larg, parg);
+ ret = ssl3_ctrl(ssl, cmd, larg, parg);
break;
}
return ret;
}
-void dtls1_start_timer(SSL *s)
+void dtls1_start_timer(SSL_CONNECTION *s)
{
unsigned int sec, usec;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
#ifndef OPENSSL_NO_SCTP
/* Disable timer for SCTP */
- if (BIO_dgram_is_sctp(SSL_get_wbio(s))) {
+ if (BIO_dgram_is_sctp(SSL_get_wbio(ssl))) {
memset(&s->d1->next_timeout, 0, sizeof(s->d1->next_timeout));
return;
}
if (s->d1->next_timeout.tv_sec == 0 && s->d1->next_timeout.tv_usec == 0) {
if (s->d1->timer_cb != NULL)
- s->d1->timeout_duration_us = s->d1->timer_cb(s, 0);
+ s->d1->timeout_duration_us = s->d1->timer_cb(ssl, 0);
else
s->d1->timeout_duration_us = 1000000;
}
s->d1->next_timeout.tv_usec -= 1000000;
}
- BIO_ctrl(SSL_get_rbio(s), BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT, 0,
+ BIO_ctrl(SSL_get_rbio(ssl), BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT, 0,
&(s->d1->next_timeout));
}
-struct timeval *dtls1_get_timeout(SSL *s, struct timeval *timeleft)
+struct timeval *dtls1_get_timeout(SSL_CONNECTION *s, struct timeval *timeleft)
{
struct timeval timenow;
return timeleft;
}
-int dtls1_is_timer_expired(SSL *s)
+int dtls1_is_timer_expired(SSL_CONNECTION *s)
{
struct timeval timeleft;
return 1;
}
-static void dtls1_double_timeout(SSL *s)
+static void dtls1_double_timeout(SSL_CONNECTION *s)
{
s->d1->timeout_duration_us *= 2;
if (s->d1->timeout_duration_us > 60000000)
s->d1->timeout_duration_us = 60000000;
}
-void dtls1_stop_timer(SSL *s)
+void dtls1_stop_timer(SSL_CONNECTION *s)
{
/* Reset everything */
s->d1->timeout_num_alerts = 0;
memset(&s->d1->next_timeout, 0, sizeof(s->d1->next_timeout));
s->d1->timeout_duration_us = 1000000;
- BIO_ctrl(SSL_get_rbio(s), BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT, 0,
+ BIO_ctrl(s->rbio, BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT, 0,
&(s->d1->next_timeout));
/* Clear retransmission buffer */
dtls1_clear_sent_buffer(s);
}
-int dtls1_check_timeout_num(SSL *s)
+int dtls1_check_timeout_num(SSL_CONNECTION *s)
{
size_t mtu;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
s->d1->timeout_num_alerts++;
/* Reduce MTU after 2 unsuccessful retransmissions */
if (s->d1->timeout_num_alerts > 2
- && !(SSL_get_options(s) & SSL_OP_NO_QUERY_MTU)) {
+ && !(SSL_get_options(ssl) & SSL_OP_NO_QUERY_MTU)) {
mtu =
- BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_GET_FALLBACK_MTU, 0, NULL);
+ BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_GET_FALLBACK_MTU, 0, NULL);
if (mtu < s->d1->mtu)
s->d1->mtu = mtu;
}
return 0;
}
-int dtls1_handle_timeout(SSL *s)
+int dtls1_handle_timeout(SSL_CONNECTION *s)
{
/* if no timer is expired, don't do anything */
if (!dtls1_is_timer_expired(s)) {
}
if (s->d1->timer_cb != NULL)
- s->d1->timeout_duration_us = s->d1->timer_cb(s, s->d1->timeout_duration_us);
+ s->d1->timeout_duration_us = s->d1->timer_cb(SSL_CONNECTION_GET_SSL(s),
+ s->d1->timeout_duration_us);
else
dtls1_double_timeout(s);
#define LISTEN_SEND_VERIFY_REQUEST 1
#ifndef OPENSSL_NO_SOCK
-int DTLSv1_listen(SSL *s, BIO_ADDR *client)
+int DTLSv1_listen(SSL *ssl, BIO_ADDR *client)
{
int next, n, ret = 0;
unsigned char cookie[DTLS1_COOKIE_LENGTH];
BIO *rbio, *wbio;
BIO_ADDR *tmpclient = NULL;
PACKET pkt, msgpkt, msgpayload, session, cookiepkt;
+ SSL_CONNECTION *s = SSL_CONNECTION_FROM_SSL_ONLY(ssl);
+
+ if (s == NULL)
+ return -1;
if (s->handshake_func == NULL) {
/* Not properly initialized yet */
- SSL_set_accept_state(s);
+ SSL_set_accept_state(ssl);
}
/* Ensure there is no state left over from a previous invocation */
- if (!SSL_clear(s))
+ if (!SSL_clear(ssl))
return -1;
ERR_clear_error();
- rbio = SSL_get_rbio(s);
- wbio = SSL_get_wbio(s);
+ rbio = SSL_get_rbio(ssl);
+ wbio = SSL_get_wbio(ssl);
if (!rbio || !wbio) {
ERR_raise(ERR_LIB_SSL, SSL_R_BIO_NOT_SET);
if (s->msg_callback)
s->msg_callback(0, 0, SSL3_RT_HEADER, buf,
- DTLS1_RT_HEADER_LENGTH, s, s->msg_callback_arg);
+ DTLS1_RT_HEADER_LENGTH, ssl, s->msg_callback_arg);
/* Get the record header */
if (!PACKET_get_1(&pkt, &rectype)
if (s->msg_callback)
s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE, data,
- fraglen + DTLS1_HM_HEADER_LENGTH, s,
+ fraglen + DTLS1_HM_HEADER_LENGTH, ssl,
s->msg_callback_arg);
if (!PACKET_get_net_2(&msgpayload, &clientvers)) {
/*
* Verify client version is supported
*/
- if (DTLS_VERSION_LT(clientvers, (unsigned int)s->method->version) &&
- s->method->version != DTLS_ANY_VERSION) {
+ if (DTLS_VERSION_LT(clientvers, (unsigned int)ssl->method->version) &&
+ ssl->method->version != DTLS_ANY_VERSION) {
ERR_raise(ERR_LIB_SSL, SSL_R_WRONG_VERSION_NUMBER);
goto end;
}
/*
* We have a cookie, so lets check it.
*/
- if (s->ctx->app_verify_cookie_cb == NULL) {
+ if (ssl->ctx->app_verify_cookie_cb == NULL) {
ERR_raise(ERR_LIB_SSL, SSL_R_NO_VERIFY_COOKIE_CALLBACK);
/* This is fatal */
return -1;
}
- if (s->ctx->app_verify_cookie_cb(s, PACKET_data(&cookiepkt),
+ if (ssl->ctx->app_verify_cookie_cb(ssl, PACKET_data(&cookiepkt),
(unsigned int)PACKET_remaining(&cookiepkt)) == 0) {
/*
* We treat invalid cookies in the same was as no cookie as
*/
/* Generate the cookie */
- if (s->ctx->app_gen_cookie_cb == NULL ||
- s->ctx->app_gen_cookie_cb(s, cookie, &cookielen) == 0 ||
+ if (ssl->ctx->app_gen_cookie_cb == NULL ||
+ ssl->ctx->app_gen_cookie_cb(ssl, cookie, &cookielen) == 0 ||
cookielen > 255) {
ERR_raise(ERR_LIB_SSL, SSL_R_COOKIE_GEN_CALLBACK_FAILURE);
/* This is fatal */
* haven't decided which version to use yet send back using version
* 1.0 header: otherwise some clients will ignore it.
*/
- version = (s->method->version == DTLS_ANY_VERSION) ? DTLS1_VERSION
- : s->version;
+ version = (ssl->method->version == DTLS_ANY_VERSION) ? DTLS1_VERSION
+ : s->version;
/* Construct the record and message headers */
if (!WPACKET_init_static_len(&wpkt,
if (s->msg_callback)
s->msg_callback(1, 0, SSL3_RT_HEADER, buf,
- DTLS1_RT_HEADER_LENGTH, s, s->msg_callback_arg);
+ DTLS1_RT_HEADER_LENGTH, ssl,
+ s->msg_callback_arg);
if ((tmpclient = BIO_ADDR_new()) == NULL) {
ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
* We are doing cookie exchange, so make sure we set that option in the
* SSL object
*/
- SSL_set_options(s, SSL_OP_COOKIE_EXCHANGE);
+ SSL_set_options(ssl, SSL_OP_COOKIE_EXCHANGE);
/*
* Tell the state machine that we've done the initial hello verify
}
#endif
-static int dtls1_handshake_write(SSL *s)
+static int dtls1_handshake_write(SSL_CONNECTION *s)
{
return dtls1_do_write(s, SSL3_RT_HANDSHAKE);
}
int ret;
#ifndef OPENSSL_NO_SCTP
BIO *wbio;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
+
+ if (s == NULL)
+ return -1;
wbio = SSL_get_wbio(s);
if (wbio != NULL && BIO_dgram_is_sctp(wbio) &&
- !(s->shutdown & SSL_SENT_SHUTDOWN)) {
+ !(sc->shutdown & SSL_SENT_SHUTDOWN)) {
ret = BIO_dgram_sctp_wait_for_dry(wbio);
if (ret < 0)
return -1;
return ret;
}
-int dtls1_query_mtu(SSL *s)
+int dtls1_query_mtu(SSL_CONNECTION *s)
{
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
+
if (s->d1->link_mtu) {
s->d1->mtu =
- s->d1->link_mtu - BIO_dgram_get_mtu_overhead(SSL_get_wbio(s));
+ s->d1->link_mtu - BIO_dgram_get_mtu_overhead(SSL_get_wbio(ssl));
s->d1->link_mtu = 0;
}
/* AHA! Figure out the MTU, and stick to the right size */
if (s->d1->mtu < dtls1_min_mtu(s)) {
- if (!(SSL_get_options(s) & SSL_OP_NO_QUERY_MTU)) {
+ if (!(SSL_get_options(ssl) & SSL_OP_NO_QUERY_MTU)) {
s->d1->mtu =
- BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_QUERY_MTU, 0, NULL);
+ BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_QUERY_MTU, 0, NULL);
/*
* I've seen the kernel return bogus numbers when it doesn't know
if (s->d1->mtu < dtls1_min_mtu(s)) {
/* Set to min mtu */
s->d1->mtu = dtls1_min_mtu(s);
- BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SET_MTU,
+ BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SET_MTU,
(long)s->d1->mtu, NULL);
}
} else
sizeof(g_probable_mtu[0])) - 1]);
}
-size_t dtls1_min_mtu(SSL *s)
+size_t dtls1_min_mtu(SSL_CONNECTION *s)
{
- return dtls1_link_min_mtu() - BIO_dgram_get_mtu_overhead(SSL_get_wbio(s));
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
+
+ return dtls1_link_min_mtu() - BIO_dgram_get_mtu_overhead(SSL_get_wbio(ssl));
}
-size_t DTLS_get_data_mtu(const SSL *s)
+size_t DTLS_get_data_mtu(const SSL *ssl)
{
size_t mac_overhead, int_overhead, blocksize, ext_overhead;
- const SSL_CIPHER *ciph = SSL_get_current_cipher(s);
- size_t mtu = s->d1->mtu;
+ const SSL_CIPHER *ciph = SSL_get_current_cipher(ssl);
+ size_t mtu;
+ const SSL_CONNECTION *s = SSL_CONNECTION_FROM_CONST_SSL_ONLY(ssl);
+
+ if (s == NULL)
+ return 0;
+
+ mtu = s->d1->mtu;
if (ciph == NULL)
return 0;
return mtu;
}
-void DTLS_set_timer_cb(SSL *s, DTLS_timer_cb cb)
+void DTLS_set_timer_cb(SSL *ssl, DTLS_timer_cb cb)
{
+ SSL_CONNECTION *s = SSL_CONNECTION_FROM_SSL_ONLY(ssl);
+
+ if (s == NULL)
+ return;
+
s->d1->timer_cb = cb;
}
size_t *written)
{
int i;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
- if (SSL_in_init(s) && !ossl_statem_get_in_handshake(s)) {
- i = s->handshake_func(s);
+ if (sc == NULL)
+ return -1;
+
+ if (SSL_in_init(s) && !ossl_statem_get_in_handshake(sc)) {
+ i = sc->handshake_func(s);
if (i < 0)
return i;
if (i == 0) {
return -1;
}
- return dtls1_write_bytes(s, type, buf_, len, written);
+ return dtls1_write_bytes(sc, type, buf_, len, written);
}
-int dtls1_dispatch_alert(SSL *s)
+int dtls1_dispatch_alert(SSL *ssl)
{
int i, j;
void (*cb) (const SSL *ssl, int type, int val) = NULL;
unsigned char buf[DTLS1_AL_HEADER_LENGTH];
unsigned char *ptr = &buf[0];
size_t written;
+ SSL_CONNECTION *s = SSL_CONNECTION_FROM_SSL_ONLY(ssl);
+
+ if (s == NULL)
+ return 0;
s->s3.alert_dispatch = 0;
if (s->msg_callback)
s->msg_callback(1, s->version, SSL3_RT_ALERT, s->s3.send_alert,
- 2, s, s->msg_callback_arg);
+ 2, ssl, s->msg_callback_arg);
if (s->info_callback != NULL)
cb = s->info_callback;
- else if (s->ctx->info_callback != NULL)
- cb = s->ctx->info_callback;
+ else if (ssl->ctx->info_callback != NULL)
+ cb = ssl->ctx->info_callback;
if (cb != NULL) {
j = (s->s3.send_alert[0] << 8) | s->s3.send_alert[1];
- cb(s, SSL_CB_WRITE_ALERT, j);
+ cb(ssl, SSL_CB_WRITE_ALERT, j);
}
}
return i;
int SSL_set_tlsext_use_srtp(SSL *s, const char *profiles)
{
- return ssl_ctx_make_profiles(profiles, &s->srtp_profiles);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
+
+ if (sc == NULL)
+ return 0;
+
+ return ssl_ctx_make_profiles(profiles, &sc->srtp_profiles);
}
STACK_OF(SRTP_PROTECTION_PROFILE) *SSL_get_srtp_profiles(SSL *s)
{
- if (s != NULL) {
- if (s->srtp_profiles != NULL) {
- return s->srtp_profiles;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
+
+ if (sc != NULL) {
+ if (sc->srtp_profiles != NULL) {
+ return sc->srtp_profiles;
} else if ((s->ctx != NULL) && (s->ctx->srtp_profiles != NULL)) {
return s->ctx->srtp_profiles;
}
SRTP_PROTECTION_PROFILE *SSL_get_selected_srtp_profile(SSL *s)
{
- return s->srtp_profile;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
+
+ if (sc == NULL)
+ return 0;
+
+ return sc->srtp_profile;
}
#endif
* record layer. If read_ahead is enabled, then this might be false and this
* function will fail.
*/
-static int count_unprocessed_records(SSL *s)
+static int count_unprocessed_records(SSL_CONNECTION *s)
{
SSL3_BUFFER *rbuf = RECORD_LAYER_get_rbuf(&s->rlayer);
PACKET pkt, subpkt;
* partial record, fail and return 0. Otherwise, update the sequence
* number at *rec_seq for the count of unprocessed records and return 1.
*/
-static int check_rx_read_ahead(SSL *s, unsigned char *rec_seq)
+static int check_rx_read_ahead(SSL_CONNECTION *s, unsigned char *rec_seq)
{
int bit, count_unprocessed;
* provider is found, but this checks if the socket option
* supports the cipher suite used at all.
*/
-int ktls_check_supported_cipher(const SSL *s, const EVP_CIPHER *c,
+int ktls_check_supported_cipher(const SSL_CONNECTION *s, const EVP_CIPHER *c,
const EVP_CIPHER_CTX *dd)
{
}
/* Function to configure kernel TLS structure */
-int ktls_configure_crypto(SSL *s, const EVP_CIPHER *c, EVP_CIPHER_CTX *dd,
+int ktls_configure_crypto(SSL_CONNECTION *s, const EVP_CIPHER *c,
+ EVP_CIPHER_CTX *dd,
void *rl_sequence, ktls_crypto_info_t *crypto_info,
int is_tx, unsigned char *iv,
unsigned char *key, unsigned char *mac_key,
#if defined(OPENSSL_SYS_LINUX)
/* Function to check supported ciphers in Linux */
-int ktls_check_supported_cipher(const SSL *s, const EVP_CIPHER *c,
+int ktls_check_supported_cipher(const SSL_CONNECTION *s, const EVP_CIPHER *c,
const EVP_CIPHER_CTX *dd)
{
switch (s->version) {
}
/* Function to configure kernel TLS structure */
-int ktls_configure_crypto(SSL *s, const EVP_CIPHER *c, EVP_CIPHER_CTX *dd,
+int ktls_configure_crypto(SSL_CONNECTION *s, const EVP_CIPHER *c,
+ EVP_CIPHER_CTX *dd,
void *rl_sequence, ktls_crypto_info_t *crypto_info,
int is_tx, unsigned char *iv,
unsigned char *key, unsigned char *mac_key,
OPENSSL_free(pq->heap);
OPENSSL_free(pq->elements);
OPENSSL_free(pq);
- }
+ }
}
void ossl_pqueue_pop_free(OSSL_PQUEUE *pq, void (*freefunc)(void *))
#include <openssl/objects.h>
#include "quic_local.h"
-int ossl_quic_new(SSL *s)
+SSL *ossl_quic_new(SSL_CTX *ctx)
+{
+ QUIC_CONNECTION *qc;
+ SSL *ssl = NULL;
+ SSL_CONNECTION *sc;
+
+ qc = OPENSSL_zalloc(sizeof(*qc));
+ if (qc == NULL)
+ goto err;
+
+ ssl = &qc->ssl;
+ if (!ossl_ssl_init(ssl, ctx, SSL_TYPE_QUIC_CONNECTION)) {
+ OPENSSL_free(qc);
+ ssl = NULL;
+ goto err;
+ }
+ qc->tls = ossl_ssl_connection_new(ctx);
+ if (qc->tls == NULL || (sc = SSL_CONNECTION_FROM_SSL(qc->tls)) == NULL)
+ goto err;
+ /* override the user_ssl of the inner connection */
+ sc->user_ssl = ssl;
+
+ /* We'll need to set proper TLS method on qc->tls here */
+ return ssl;
+err:
+ ossl_quic_free(ssl);
+ return NULL;
+}
+
+int ossl_quic_init(SSL *s)
{
return s->method->ssl_clear(s);
}
+void ossl_quic_deinit(SSL *s)
+{
+ return;
+}
+
void ossl_quic_free(SSL *s)
{
+ QUIC_CONNECTION *qc = QUIC_CONNECTION_FROM_SSL(s);
+
+ if (qc == NULL) {
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
+
+ if (sc != NULL)
+ ossl_ssl_connection_free(s);
+ return;
+ }
+
+ SSL_free(qc->tls);
return;
}
+int ossl_quic_reset(SSL *s)
+{
+ QUIC_CONNECTION *qc = QUIC_CONNECTION_FROM_SSL(s);
+
+ if (qc == NULL) {
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
+
+ return sc != NULL ? ossl_ssl_connection_reset(s) : 0;
+ }
+
+ return ossl_ssl_connection_reset(qc->tls);
+}
+
int ossl_quic_clear(SSL *s)
{
return 1;
int ossl_quic_accept(SSL *s)
{
- s->statem.in_init = 0;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_QUIC_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ sc->statem.in_init = 0;
return 1;
}
int ossl_quic_connect(SSL *s)
{
- s->statem.in_init = 0;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_QUIC_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ sc->statem.in_init = 0;
return 1;
}
{
int ret;
BIO *rbio = SSL_get_rbio(s);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_QUIC_SSL(s);
- if (rbio == NULL)
+ if (sc == NULL || rbio == NULL)
return 0;
- s->rwstate = SSL_READING;
+ sc->rwstate = SSL_READING;
ret = BIO_read_ex(rbio, buf, len, readbytes);
if (ret > 0 || !BIO_should_retry(rbio))
- s->rwstate = SSL_NOTHING;
+ sc->rwstate = SSL_NOTHING;
return ret <= 0 ? -1 : ret;
}
{
BIO *wbio = SSL_get_wbio(s);
int ret;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_QUIC_SSL(s);
- if (wbio == NULL)
+ if (sc == NULL || wbio == NULL)
return 0;
- s->rwstate = SSL_WRITING;
+ sc->rwstate = SSL_WRITING;
ret = BIO_write_ex(wbio, buf, len, written);
if (ret > 0 || !BIO_should_retry(wbio))
- s->rwstate = SSL_NOTHING;
+ sc->rwstate = SSL_NOTHING;
return ret;
}
long ossl_quic_ctrl(SSL *s, int cmd, long larg, void *parg)
{
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_QUIC_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
switch(cmd) {
case SSL_CTRL_CHAIN:
if (larg)
- return ssl_cert_set1_chain(s, NULL, (STACK_OF(X509) *)parg);
+ return ssl_cert_set1_chain(sc, NULL, (STACK_OF(X509) *)parg);
else
- return ssl_cert_set0_chain(s, NULL, (STACK_OF(X509) *)parg);
+ return ssl_cert_set0_chain(sc, NULL, (STACK_OF(X509) *)parg);
}
return 0;
}
# include <openssl/ssl.h>
# include "../ssl_local.h"
+typedef struct quic_conn_st {
+ /* type identifier and common data */
+ struct ssl_st ssl;
+ /* the associated tls-1.3 connection data */
+ SSL *tls;
+ /* just an example member */
+ uint64_t conn_id;
+} QUIC_CONNECTION;
+
+# define QUIC_CONNECTION_FROM_SSL_int(ssl, c) \
+ ((ssl) == NULL ? NULL \
+ : ((ssl)->type == SSL_TYPE_QUIC_CONNECTION \
+ ? (c QUIC_CONNECTION *)(ssl) \
+ : NULL))
+
+# define SSL_CONNECTION_FROM_QUIC_SSL_int(ssl, c) \
+ ((ssl) == NULL ? NULL \
+ : ((ssl)->type == SSL_TYPE_QUIC_CONNECTION \
+ ? (c SSL_CONNECTION *)((c QUIC_CONNECTION *)(ssl))->tls \
+ : NULL))
+
+# define QUIC_CONNECTION_FROM_SSL(ssl) \
+ QUIC_CONNECTION_FROM_SSL_int(ssl, SSL_CONNECTION_NO_CONST)
+# define QUIC_CONNECTION_FROM_CONST_SSL(ssl) \
+ QUIC_CONNECTION_FROM_SSL_int(ssl, const)
+# define SSL_CONNECTION_FROM_QUIC_SSL(ssl) \
+ SSL_CONNECTION_FROM_QUIC_SSL_int(ssl, SSL_CONNECTION_NO_CONST)
+# define SSL_CONNECTION_FROM_CONST_QUIC_SSL(ssl) \
+ SSL_CONNECTION_FROM_CONST_QUIC_SSL_int(ssl, const)
+
# define OSSL_QUIC_ANY_VERSION 0xFFFFF
# define IMPLEMENT_quic_meth_func(version, func_name, q_accept, \
0, \
0, \
ossl_quic_new, \
- ossl_quic_clear, \
ossl_quic_free, \
+ ossl_quic_reset, \
+ ossl_quic_init, \
+ ossl_quic_clear, \
+ ossl_quic_deinit, \
q_accept, \
q_connect, \
ossl_quic_read, \
return &func_name##_data; \
}
-__owur int ossl_quic_new(SSL *s);
+__owur SSL *ossl_quic_new(SSL_CTX *ctx);
+__owur int ossl_quic_init(SSL *s);
+void ossl_quic_deinit(SSL *s);
void ossl_quic_free(SSL *s);
+int ossl_quic_reset(SSL *s);
int ossl_quic_clear(SSL *s);
__owur int ossl_quic_accept(SSL *s);
__owur int ossl_quic_connect(SSL *s);
__owur int ossl_quic_write(SSL *s, const void *buf, size_t len, size_t *written);
__owur int ossl_quic_shutdown(SSL *s);
__owur long ossl_quic_ctrl(SSL *s, int cmd, long larg, void *parg);
-__owur long ossl_quic_ctx_ctrl(SSL_CTX *s, int cmd, long larg, void *parg);
+__owur long ossl_quic_ctx_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg);
__owur long ossl_quic_callback_ctrl(SSL *s, int cmd, void (*fp) (void));
-__owur long ossl_quic_ctx_callback_ctrl(SSL_CTX *s, int cmd, void (*fp) (void));
+__owur long ossl_quic_ctx_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp) (void));
__owur size_t ossl_quic_pending(const SSL *s);
__owur long ossl_quic_default_timeout(void);
__owur int ossl_quic_num_ciphers(void);
return (int)ret;
}
-int dtls1_record_replay_check(SSL *s, DTLS1_BITMAP *bitmap)
+int dtls1_record_replay_check(SSL_CONNECTION *s, DTLS1_BITMAP *bitmap)
{
int cmp;
unsigned int shift;
return 1;
}
-void dtls1_record_bitmap_update(SSL *s, DTLS1_BITMAP *bitmap)
+void dtls1_record_bitmap_update(SSL_CONNECTION *s, DTLS1_BITMAP *bitmap)
{
int cmp;
unsigned int shift;
}
/* copy buffered record into SSL structure */
-static int dtls1_copy_record(SSL *s, pitem *item)
+static int dtls1_copy_record(SSL_CONNECTION *s, pitem *item)
{
DTLS1_RECORD_DATA *rdata;
return 1;
}
-int dtls1_buffer_record(SSL *s, record_pqueue *queue, unsigned char *priority)
+int dtls1_buffer_record(SSL_CONNECTION *s, record_pqueue *queue,
+ unsigned char *priority)
{
DTLS1_RECORD_DATA *rdata;
pitem *item;
+#ifndef OPENSSL_NO_SCTP
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
+#endif
/* Limit the size of the queue to prevent DOS attacks */
if (pqueue_size(queue->q) >= 100)
#ifndef OPENSSL_NO_SCTP
/* Store bio_dgram_sctp_rcvinfo struct */
- if (BIO_dgram_is_sctp(SSL_get_rbio(s)) &&
- (SSL_get_state(s) == TLS_ST_SR_FINISHED
- || SSL_get_state(s) == TLS_ST_CR_FINISHED)) {
- BIO_ctrl(SSL_get_rbio(s), BIO_CTRL_DGRAM_SCTP_GET_RCVINFO,
+ if (BIO_dgram_is_sctp(SSL_get_rbio(ssl)) &&
+ (SSL_get_state(ssl) == TLS_ST_SR_FINISHED
+ || SSL_get_state(ssl) == TLS_ST_CR_FINISHED)) {
+ BIO_ctrl(SSL_get_rbio(ssl), BIO_CTRL_DGRAM_SCTP_GET_RCVINFO,
sizeof(rdata->recordinfo), &rdata->recordinfo);
}
#endif
return 1;
}
-int dtls1_retrieve_buffered_record(SSL *s, record_pqueue *queue)
+int dtls1_retrieve_buffered_record(SSL_CONNECTION *s, record_pqueue *queue)
{
pitem *item;
dtls1_retrieve_buffered_record((s), \
&((s)->rlayer.d->unprocessed_rcds))
-int dtls1_process_buffered_records(SSL *s)
+int dtls1_process_buffered_records(SSL_CONNECTION *s)
{
pitem *item;
SSL3_BUFFER *rb;
}
#ifndef OPENSSL_NO_SCTP
/* Only do replay check if no SCTP bio */
- if (!BIO_dgram_is_sctp(SSL_get_rbio(s)))
+ if (!BIO_dgram_is_sctp(SSL_get_rbio(SSL_CONNECTION_GET_SSL(s))))
#endif
{
/*
size_t n;
SSL3_RECORD *rr;
void (*cb) (const SSL *ssl, int type2, int val) = NULL;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return -1;
- if (!SSL3_BUFFER_is_initialised(&s->rlayer.rbuf)) {
+ if (!SSL3_BUFFER_is_initialised(&sc->rlayer.rbuf)) {
/* Not initialized yet */
- if (!ssl3_setup_buffers(s)) {
+ if (!ssl3_setup_buffers(sc)) {
/* SSLfatal() already called */
return -1;
}
if ((type && (type != SSL3_RT_APPLICATION_DATA) &&
(type != SSL3_RT_HANDSHAKE)) ||
(peek && (type != SSL3_RT_APPLICATION_DATA))) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
+ SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return -1;
}
- if (!ossl_statem_get_in_handshake(s) && SSL_in_init(s)) {
+ if (!ossl_statem_get_in_handshake(sc) && SSL_in_init(s)) {
/* type == SSL3_RT_APPLICATION_DATA */
- i = s->handshake_func(s);
+ i = sc->handshake_func(s);
/* SSLfatal() already called if appropriate */
if (i < 0)
return i;
}
start:
- s->rwstate = SSL_NOTHING;
+ sc->rwstate = SSL_NOTHING;
/*-
* s->s3.rrec.type - is the type of record
* s->s3.rrec.off, - offset into 'data' for next read
* s->s3.rrec.length, - number of bytes.
*/
- rr = s->rlayer.rrec;
+ rr = sc->rlayer.rrec;
/*
* We are not handshaking and have no data yet, so process data buffered
*/
if (SSL_is_init_finished(s) && SSL3_RECORD_get_length(rr) == 0) {
pitem *item;
- item = pqueue_pop(s->rlayer.d->buffered_app_data.q);
+ item = pqueue_pop(sc->rlayer.d->buffered_app_data.q);
if (item) {
#ifndef OPENSSL_NO_SCTP
/* Restore bio_dgram_sctp_rcvinfo struct */
}
#endif
- dtls1_copy_record(s, item);
+ dtls1_copy_record(sc, item);
OPENSSL_free(item->data);
pitem_free(item);
}
/* Check for timeout */
- if (dtls1_handle_timeout(s) > 0) {
+ if (dtls1_handle_timeout(sc) > 0) {
goto start;
- } else if (ossl_statem_in_error(s)) {
+ } else if (ossl_statem_in_error(sc)) {
/* dtls1_handle_timeout() has failed with a fatal error */
return -1;
}
/* get new packet if necessary */
if ((SSL3_RECORD_get_length(rr) == 0)
- || (s->rlayer.rstate == SSL_ST_READ_BODY)) {
- RECORD_LAYER_set_numrpipes(&s->rlayer, 0);
- iret = dtls1_get_record(s);
+ || (sc->rlayer.rstate == SSL_ST_READ_BODY)) {
+ RECORD_LAYER_set_numrpipes(&sc->rlayer, 0);
+ iret = dtls1_get_record(sc);
if (iret <= 0) {
- iret = dtls1_read_failed(s, iret);
+ iret = dtls1_read_failed(sc, iret);
/*
* Anything other than a timeout is an error. SSLfatal() already
* called if appropriate.
else
goto start;
}
- RECORD_LAYER_set_numrpipes(&s->rlayer, 1);
+ RECORD_LAYER_set_numrpipes(&sc->rlayer, 1);
}
/*
*/
if (SSL3_RECORD_get_type(rr) != SSL3_RT_ALERT
&& SSL3_RECORD_get_length(rr) != 0)
- s->rlayer.alert_count = 0;
+ sc->rlayer.alert_count = 0;
/* we now have a packet which can be read and processed */
- if (s->s3.change_cipher_spec /* set when we receive ChangeCipherSpec,
+ if (sc->s3.change_cipher_spec /* set when we receive ChangeCipherSpec,
* reset by ssl3_get_finished */
&& (SSL3_RECORD_get_type(rr) != SSL3_RT_HANDSHAKE)) {
/*
* the packets were reordered on their way, so buffer the application
* data for later processing rather than dropping the connection.
*/
- if (dtls1_buffer_record(s, &(s->rlayer.d->buffered_app_data),
+ if (dtls1_buffer_record(sc, &(sc->rlayer.d->buffered_app_data),
SSL3_RECORD_get_seq_num(rr)) < 0) {
/* SSLfatal() already called */
return -1;
* If the other end has shut down, throw anything we read away (even in
* 'peek' mode)
*/
- if (s->shutdown & SSL_RECEIVED_SHUTDOWN) {
+ if (sc->shutdown & SSL_RECEIVED_SHUTDOWN) {
SSL3_RECORD_set_length(rr, 0);
SSL3_RECORD_set_read(rr);
- s->rwstate = SSL_NOTHING;
+ sc->rwstate = SSL_NOTHING;
return 0;
}
* doing a handshake for the first time
*/
if (SSL_in_init(s) && (type == SSL3_RT_APPLICATION_DATA) &&
- (s->enc_read_ctx == NULL)) {
- SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE,
+ (sc->enc_read_ctx == NULL)) {
+ SSLfatal(sc, SSL_AD_UNEXPECTED_MESSAGE,
SSL_R_APP_DATA_IN_HANDSHAKE);
return -1;
}
if (SSL3_RECORD_get_length(rr) == 0)
SSL3_RECORD_set_read(rr);
} else {
- if (s->options & SSL_OP_CLEANSE_PLAINTEXT)
+ if (sc->options & SSL_OP_CLEANSE_PLAINTEXT)
OPENSSL_cleanse(&(SSL3_RECORD_get_data(rr)[SSL3_RECORD_get_off(rr)]), n);
SSL3_RECORD_sub_length(rr, n);
SSL3_RECORD_add_off(rr, n);
if (SSL3_RECORD_get_length(rr) == 0) {
- s->rlayer.rstate = SSL_ST_READ_HEADER;
+ sc->rlayer.rstate = SSL_ST_READ_HEADER;
SSL3_RECORD_set_off(rr, 0);
SSL3_RECORD_set_read(rr);
}
* anymore, finally set shutdown.
*/
if (BIO_dgram_is_sctp(SSL_get_rbio(s)) &&
- s->d1->shutdown_received
+ sc->d1->shutdown_received
&& BIO_dgram_sctp_msg_waiting(SSL_get_rbio(s)) <= 0) {
- s->shutdown |= SSL_RECEIVED_SHUTDOWN;
+ sc->shutdown |= SSL_RECEIVED_SHUTDOWN;
return 0;
}
#endif
|| !PACKET_get_1(&alert, &alert_level)
|| !PACKET_get_1(&alert, &alert_descr)
|| PACKET_remaining(&alert) != 0) {
- SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_INVALID_ALERT);
+ SSLfatal(sc, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_INVALID_ALERT);
return -1;
}
- if (s->msg_callback)
- s->msg_callback(0, s->version, SSL3_RT_ALERT, alert_bytes, 2, s,
- s->msg_callback_arg);
+ if (sc->msg_callback)
+ sc->msg_callback(0, sc->version, SSL3_RT_ALERT, alert_bytes, 2, s,
+ sc->msg_callback_arg);
- if (s->info_callback != NULL)
- cb = s->info_callback;
+ if (sc->info_callback != NULL)
+ cb = sc->info_callback;
else if (s->ctx->info_callback != NULL)
cb = s->ctx->info_callback;
}
if (alert_level == SSL3_AL_WARNING) {
- s->s3.warn_alert = alert_descr;
+ sc->s3.warn_alert = alert_descr;
SSL3_RECORD_set_read(rr);
- s->rlayer.alert_count++;
- if (s->rlayer.alert_count == MAX_WARN_ALERT_COUNT) {
- SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE,
+ sc->rlayer.alert_count++;
+ if (sc->rlayer.alert_count == MAX_WARN_ALERT_COUNT) {
+ SSLfatal(sc, SSL_AD_UNEXPECTED_MESSAGE,
SSL_R_TOO_MANY_WARN_ALERTS);
return -1;
}
*/
if (BIO_dgram_is_sctp(SSL_get_rbio(s)) &&
BIO_dgram_sctp_msg_waiting(SSL_get_rbio(s)) > 0) {
- s->d1->shutdown_received = 1;
- s->rwstate = SSL_READING;
+ sc->d1->shutdown_received = 1;
+ sc->rwstate = SSL_READING;
BIO_clear_retry_flags(SSL_get_rbio(s));
BIO_set_retry_read(SSL_get_rbio(s));
return -1;
}
#endif
- s->shutdown |= SSL_RECEIVED_SHUTDOWN;
+ sc->shutdown |= SSL_RECEIVED_SHUTDOWN;
return 0;
}
} else if (alert_level == SSL3_AL_FATAL) {
- s->rwstate = SSL_NOTHING;
- s->s3.fatal_alert = alert_descr;
- SSLfatal_data(s, SSL_AD_NO_ALERT,
+ sc->rwstate = SSL_NOTHING;
+ sc->s3.fatal_alert = alert_descr;
+ SSLfatal_data(sc, SSL_AD_NO_ALERT,
SSL_AD_REASON_OFFSET + alert_descr,
"SSL alert number %d", alert_descr);
- s->shutdown |= SSL_RECEIVED_SHUTDOWN;
+ sc->shutdown |= SSL_RECEIVED_SHUTDOWN;
SSL3_RECORD_set_read(rr);
- SSL_CTX_remove_session(s->session_ctx, s->session);
+ SSL_CTX_remove_session(sc->session_ctx, sc->session);
return 0;
} else {
- SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_UNKNOWN_ALERT_TYPE);
+ SSLfatal(sc, SSL_AD_ILLEGAL_PARAMETER, SSL_R_UNKNOWN_ALERT_TYPE);
return -1;
}
goto start;
}
- if (s->shutdown & SSL_SENT_SHUTDOWN) { /* but we have not received a
+ if (sc->shutdown & SSL_SENT_SHUTDOWN) { /* but we have not received a
* shutdown */
- s->rwstate = SSL_NOTHING;
+ sc->rwstate = SSL_NOTHING;
SSL3_RECORD_set_length(rr, 0);
SSL3_RECORD_set_read(rr);
return 0;
* Unexpected handshake message (Client Hello, or protocol violation)
*/
if ((SSL3_RECORD_get_type(rr) == SSL3_RT_HANDSHAKE) &&
- !ossl_statem_get_in_handshake(s)) {
+ !ossl_statem_get_in_handshake(sc)) {
struct hm_header_st msg_hdr;
/*
* This may just be a stale retransmit. Also sanity check that we have
* at least enough record bytes for a message header
*/
- if (SSL3_RECORD_get_epoch(rr) != s->rlayer.d->r_epoch
+ if (SSL3_RECORD_get_epoch(rr) != sc->rlayer.d->r_epoch
|| SSL3_RECORD_get_length(rr) < DTLS1_HM_HEADER_LENGTH) {
SSL3_RECORD_set_length(rr, 0);
SSL3_RECORD_set_read(rr);
* here, then retransmit our CCS and FINISHED.
*/
if (msg_hdr.type == SSL3_MT_FINISHED) {
- if (dtls1_check_timeout_num(s) < 0) {
+ if (dtls1_check_timeout_num(sc) < 0) {
/* SSLfatal) already called */
return -1;
}
- if (dtls1_retransmit_buffered_messages(s) <= 0) {
+ if (dtls1_retransmit_buffered_messages(sc) <= 0) {
/* Fail if we encountered a fatal error */
- if (ossl_statem_in_error(s))
+ if (ossl_statem_in_error(sc))
return -1;
}
SSL3_RECORD_set_length(rr, 0);
SSL3_RECORD_set_read(rr);
- if (!(s->mode & SSL_MODE_AUTO_RETRY)) {
- if (SSL3_BUFFER_get_left(&s->rlayer.rbuf) == 0) {
+ if (!(sc->mode & SSL_MODE_AUTO_RETRY)) {
+ if (SSL3_BUFFER_get_left(&sc->rlayer.rbuf) == 0) {
/* no read-ahead left? */
BIO *bio;
- s->rwstate = SSL_READING;
+ sc->rwstate = SSL_READING;
bio = SSL_get_rbio(s);
BIO_clear_retry_flags(bio);
BIO_set_retry_read(bio);
* finished
*/
if (!ossl_assert(SSL_is_init_finished(s))) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
+ SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return -1;
}
/* We found handshake data, so we're going back into init */
- ossl_statem_set_in_init(s, 1);
+ ossl_statem_set_in_init(sc, 1);
- i = s->handshake_func(s);
+ i = sc->handshake_func(s);
/* SSLfatal() called if appropriate */
if (i < 0)
return i;
if (i == 0)
return -1;
- if (!(s->mode & SSL_MODE_AUTO_RETRY)) {
- if (SSL3_BUFFER_get_left(&s->rlayer.rbuf) == 0) {
+ if (!(sc->mode & SSL_MODE_AUTO_RETRY)) {
+ if (SSL3_BUFFER_get_left(&sc->rlayer.rbuf) == 0) {
/* no read-ahead left? */
BIO *bio;
/*
* option set. Otherwise renegotiation may cause nasty
* problems in the blocking world
*/
- s->rwstate = SSL_READING;
+ sc->rwstate = SSL_READING;
bio = SSL_get_rbio(s);
BIO_clear_retry_flags(bio);
BIO_set_retry_read(bio);
switch (SSL3_RECORD_get_type(rr)) {
default:
- SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_RECORD);
+ SSLfatal(sc, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_RECORD);
return -1;
case SSL3_RT_CHANGE_CIPHER_SPEC:
case SSL3_RT_ALERT:
* SSL3_RT_HANDSHAKE when ossl_statem_get_in_handshake(s) is true, but
* that should not happen when type != rr->type
*/
- SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, ERR_R_INTERNAL_ERROR);
+ SSLfatal(sc, SSL_AD_UNEXPECTED_MESSAGE, ERR_R_INTERNAL_ERROR);
return -1;
case SSL3_RT_APPLICATION_DATA:
/*
* application data at this point (session renegotiation not yet
* started), we will indulge it.
*/
- if (s->s3.in_read_app_data &&
- (s->s3.total_renegotiations != 0) &&
- ossl_statem_app_data_allowed(s)) {
- s->s3.in_read_app_data = 2;
+ if (sc->s3.in_read_app_data &&
+ (sc->s3.total_renegotiations != 0) &&
+ ossl_statem_app_data_allowed(sc)) {
+ sc->s3.in_read_app_data = 2;
return -1;
} else {
- SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_RECORD);
+ SSLfatal(sc, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_RECORD);
return -1;
}
}
* Call this to write data in records of type 'type' It will return <= 0 if
* not all data has been sent or non-blocking IO.
*/
-int dtls1_write_bytes(SSL *s, int type, const void *buf, size_t len,
- size_t *written)
+int dtls1_write_bytes(SSL_CONNECTION *s, int type, const void *buf,
+ size_t len, size_t *written)
{
int i;
return i;
}
-int do_dtls1_write(SSL *s, int type, const unsigned char *buf,
+int do_dtls1_write(SSL_CONNECTION *sc, int type, const unsigned char *buf,
size_t len, int create_empty_fragment, size_t *written)
{
unsigned char *p, *pseq;
SSL3_RECORD wr;
SSL3_BUFFER *wb;
SSL_SESSION *sess;
+ SSL *s = SSL_CONNECTION_GET_SSL(sc);
- wb = &s->rlayer.wbuf[0];
+ wb = &sc->rlayer.wbuf[0];
/*
* DTLS writes whole datagrams, so there can't be anything left in
* the buffer.
*/
if (!ossl_assert(SSL3_BUFFER_get_left(wb) == 0)) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
+ SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return 0;
}
/* If we have an alert to send, lets send it */
- if (s->s3.alert_dispatch) {
+ if (sc->s3.alert_dispatch) {
i = s->method->ssl_dispatch_alert(s);
if (i <= 0)
return i;
if (len == 0 && !create_empty_fragment)
return 0;
- if (len > ssl_get_max_send_fragment(s)) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_EXCEEDS_MAX_FRAGMENT_SIZE);
+ if (len > ssl_get_max_send_fragment(sc)) {
+ SSLfatal(sc, SSL_AD_INTERNAL_ERROR, SSL_R_EXCEEDS_MAX_FRAGMENT_SIZE);
return 0;
}
- sess = s->session;
+ sess = sc->session;
if ((sess == NULL)
- || (s->enc_write_ctx == NULL)
- || (EVP_MD_CTX_get0_md(s->write_hash) == NULL))
+ || (sc->enc_write_ctx == NULL)
+ || (EVP_MD_CTX_get0_md(sc->write_hash) == NULL))
clear = 1;
if (clear)
mac_size = 0;
else {
- mac_size = EVP_MD_CTX_get_size(s->write_hash);
+ mac_size = EVP_MD_CTX_get_size(sc->write_hash);
if (mac_size < 0) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR,
+ SSLfatal(sc, SSL_AD_INTERNAL_ERROR,
SSL_R_EXCEEDS_MAX_FRAGMENT_SIZE);
return -1;
}
* header: otherwise some clients will ignore it.
*/
if (s->method->version == DTLS_ANY_VERSION &&
- s->max_proto_version != DTLS1_BAD_VER) {
+ sc->max_proto_version != DTLS1_BAD_VER) {
*(p++) = DTLS1_VERSION >> 8;
*(p++) = DTLS1_VERSION & 0xff;
} else {
- *(p++) = s->version >> 8;
- *(p++) = s->version & 0xff;
+ *(p++) = sc->version >> 8;
+ *(p++) = sc->version & 0xff;
}
/* field where we are to write out packet epoch, seq num and len */
p += 10;
/* Explicit IV length, block ciphers appropriate version flag */
- if (s->enc_write_ctx) {
- int mode = EVP_CIPHER_CTX_get_mode(s->enc_write_ctx);
+ if (sc->enc_write_ctx) {
+ int mode = EVP_CIPHER_CTX_get_mode(sc->enc_write_ctx);
if (mode == EVP_CIPH_CBC_MODE) {
- eivlen = EVP_CIPHER_CTX_get_iv_length(s->enc_write_ctx);
+ eivlen = EVP_CIPHER_CTX_get_iv_length(sc->enc_write_ctx);
if (eivlen <= 1)
eivlen = 0;
}
*/
/* first we compress */
- if (s->compress != NULL) {
- if (!ssl3_do_compress(s, &wr)) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_COMPRESSION_FAILURE);
+ if (sc->compress != NULL) {
+ if (!ssl3_do_compress(sc, &wr)) {
+ SSLfatal(sc, SSL_AD_INTERNAL_ERROR, SSL_R_COMPRESSION_FAILURE);
return -1;
}
} else {
* wb->buf
*/
- if (!SSL_WRITE_ETM(s) && mac_size != 0) {
- if (!s->method->ssl3_enc->mac(s, &wr,
+ if (!SSL_WRITE_ETM(sc) && mac_size != 0) {
+ if (!s->method->ssl3_enc->mac(sc, &wr,
&(p[SSL3_RECORD_get_length(&wr) + eivlen]),
1)) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
+ SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return -1;
}
SSL3_RECORD_add_length(&wr, mac_size);
if (eivlen)
SSL3_RECORD_add_length(&wr, eivlen);
- if (s->method->ssl3_enc->enc(s, &wr, 1, 1, NULL, mac_size) < 1) {
- if (!ossl_statem_in_error(s)) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
+ if (s->method->ssl3_enc->enc(sc, &wr, 1, 1, NULL, mac_size) < 1) {
+ if (!ossl_statem_in_error(sc)) {
+ SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
}
return -1;
}
- if (SSL_WRITE_ETM(s) && mac_size != 0) {
- if (!s->method->ssl3_enc->mac(s, &wr,
+ if (SSL_WRITE_ETM(sc) && mac_size != 0) {
+ if (!s->method->ssl3_enc->mac(sc, &wr,
&(p[SSL3_RECORD_get_length(&wr)]), 1)) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
+ SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return -1;
}
SSL3_RECORD_add_length(&wr, mac_size);
/* there's only one epoch between handshake and app data */
- s2n(s->rlayer.d->w_epoch, pseq);
+ s2n(sc->rlayer.d->w_epoch, pseq);
- memcpy(pseq, &(s->rlayer.write_sequence[2]), 6);
+ memcpy(pseq, &(sc->rlayer.write_sequence[2]), 6);
pseq += 6;
s2n(SSL3_RECORD_get_length(&wr), pseq);
- if (s->msg_callback)
- s->msg_callback(1, 0, SSL3_RT_HEADER, pseq - DTLS1_RT_HEADER_LENGTH,
- DTLS1_RT_HEADER_LENGTH, s, s->msg_callback_arg);
+ if (sc->msg_callback)
+ sc->msg_callback(1, 0, SSL3_RT_HEADER, pseq - DTLS1_RT_HEADER_LENGTH,
+ DTLS1_RT_HEADER_LENGTH, s, sc->msg_callback_arg);
/*
* we should now have wr.data pointing to the encrypted data, which is
SSL3_RECORD_set_type(&wr, type); /* not needed but helps for debugging */
SSL3_RECORD_add_length(&wr, DTLS1_RT_HEADER_LENGTH);
- ssl3_record_sequence_update(&(s->rlayer.write_sequence[0]));
+ ssl3_record_sequence_update(&(sc->rlayer.write_sequence[0]));
if (create_empty_fragment) {
/*
* memorize arguments so that ssl3_write_pending can detect bad write
* retries later
*/
- s->rlayer.wpend_tot = len;
- s->rlayer.wpend_buf = buf;
- s->rlayer.wpend_type = type;
- s->rlayer.wpend_ret = len;
+ sc->rlayer.wpend_tot = len;
+ sc->rlayer.wpend_buf = buf;
+ sc->rlayer.wpend_type = type;
+ sc->rlayer.wpend_ret = len;
/* we now just need to write the buffer. Calls SSLfatal() as required. */
- return ssl3_write_pending(s, type, buf, len, written);
+ return ssl3_write_pending(sc, type, buf, len, written);
}
-DTLS1_BITMAP *dtls1_get_bitmap(SSL *s, SSL3_RECORD *rr,
+DTLS1_BITMAP *dtls1_get_bitmap(SSL_CONNECTION *s, SSL3_RECORD *rr,
unsigned int *is_next_epoch)
{
return NULL;
}
-void dtls1_reset_seq_numbers(SSL *s, int rw)
+void dtls1_reset_seq_numbers(SSL_CONNECTION *s, int rw)
{
unsigned char *seq;
unsigned int seq_bytes = sizeof(s->rlayer.read_sequence);
# define EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK 0
#endif
-void RECORD_LAYER_init(RECORD_LAYER *rl, SSL *s)
+void RECORD_LAYER_init(RECORD_LAYER *rl, SSL_CONNECTION *s)
{
rl->s = s;
RECORD_LAYER_set_first_record(&s->rlayer);
size_t ssl3_pending(const SSL *s)
{
size_t i, num = 0;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
- if (s->rlayer.rstate == SSL_ST_READ_BODY)
+ if (sc == NULL)
return 0;
- for (i = 0; i < RECORD_LAYER_get_numrpipes(&s->rlayer); i++) {
- if (SSL3_RECORD_get_type(&s->rlayer.rrec[i])
+ if (sc->rlayer.rstate == SSL_ST_READ_BODY)
+ return 0;
+
+ for (i = 0; i < RECORD_LAYER_get_numrpipes(&sc->rlayer); i++) {
+ if (SSL3_RECORD_get_type(&sc->rlayer.rrec[i])
!= SSL3_RT_APPLICATION_DATA)
return 0;
- num += SSL3_RECORD_get_length(&s->rlayer.rrec[i]);
+ num += SSL3_RECORD_get_length(&sc->rlayer.rrec[i]);
}
return num;
void SSL_set_default_read_buffer_len(SSL *s, size_t len)
{
- SSL3_BUFFER_set_default_len(RECORD_LAYER_get_rbuf(&s->rlayer), len);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return;
+
+ SSL3_BUFFER_set_default_len(RECORD_LAYER_get_rbuf(&sc->rlayer), len);
}
const char *SSL_rstate_string_long(const SSL *s)
{
- switch (s->rlayer.rstate) {
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return NULL;
+
+ switch (sc->rlayer.rstate) {
case SSL_ST_READ_HEADER:
return "read header";
case SSL_ST_READ_BODY:
const char *SSL_rstate_string(const SSL *s)
{
- switch (s->rlayer.rstate) {
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return NULL;
+
+ switch (sc->rlayer.rstate) {
case SSL_ST_READ_HEADER:
return "RH";
case SSL_ST_READ_BODY:
/*
* Return values are as per SSL_read()
*/
-int ssl3_read_n(SSL *s, size_t n, size_t max, int extend, int clearold,
- size_t *readbytes)
+int ssl3_read_n(SSL_CONNECTION *s, size_t n, size_t max, int extend,
+ int clearold, size_t *readbytes)
{
/*
* If extend == 0, obtain new n-byte packet; if extend == 1, increase
* operation returns the whole packet at once (as long as it fits into
* the buffer).
*/
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
if (left == 0 && extend)
return 0;
if (left > 0 && n > left)
* Also, we always act like read_ahead is set for DTLS.
*/
if (!BIO_get_ktls_recv(s->rbio) && !s->rlayer.read_ahead
- && !SSL_IS_DTLS(s)) {
+ && !SSL_CONNECTION_IS_DTLS(s)) {
/* ignore max parameter */
max = n;
} else {
&& !BIO_should_retry(s->rbio)
&& BIO_eof(s->rbio)) {
if (s->options & SSL_OP_IGNORE_UNEXPECTED_EOF) {
- SSL_set_shutdown(s, SSL_RECEIVED_SHUTDOWN);
+ SSL_set_shutdown(SSL_CONNECTION_GET_SSL(s),
+ SSL_RECEIVED_SHUTDOWN);
s->s3.warn_alert = SSL_AD_CLOSE_NOTIFY;
} else {
SSLfatal(s, SSL_AD_DECODE_ERROR,
if (ret <= 0) {
rb->left = left;
- if (s->mode & SSL_MODE_RELEASE_BUFFERS && !SSL_IS_DTLS(s))
+ if ((s->mode & SSL_MODE_RELEASE_BUFFERS) != 0
+ && !SSL_CONNECTION_IS_DTLS(s))
if (len + left == 0)
ssl3_release_read_buffer(s);
return ret;
* underlying transport protocol is message oriented as opposed to
* byte oriented as in the TLS case.
*/
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
if (n > left)
n = left; /* makes the while condition false */
}
* Call this to write data in records of type 'type' It will return <= 0 if
* not all data has been sent or non-blocking IO.
*/
-int ssl3_write_bytes(SSL *s, int type, const void *buf_, size_t len,
+int ssl3_write_bytes(SSL *ssl, int type, const void *buf_, size_t len,
size_t *written)
{
const unsigned char *buf = buf_;
#if !defined(OPENSSL_NO_MULTIBLOCK) && EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
size_t nw;
#endif
- SSL3_BUFFER *wb = &s->rlayer.wbuf[0];
+ SSL3_BUFFER *wb;
int i;
size_t tmpwrit;
+ SSL_CONNECTION *s = SSL_CONNECTION_FROM_SSL_ONLY(ssl);
+ if (s == NULL)
+ return -1;
+
+ wb = &s->rlayer.wbuf[0];
s->rwstate = SSL_NOTHING;
tot = s->rlayer.wnum;
/*
}
if (s->early_data_state == SSL_EARLY_DATA_WRITING
- && !early_data_count_ok(s, len, 0, 1)) {
+ && !ossl_early_data_count_ok(s, len, 0, 1)) {
/* SSLfatal() already called */
return -1;
}
* between receiving the EoED and the CF - but we don't want to handle those
* messages yet.
*/
- if (SSL_in_init(s) && !ossl_statem_get_in_handshake(s)
+ if (SSL_in_init(ssl) && !ossl_statem_get_in_handshake(s)
&& s->early_data_state != SSL_EARLY_DATA_UNAUTH_WRITING) {
- i = s->handshake_func(s);
+ i = s->handshake_func(ssl);
/* SSLfatal() already called */
if (i < 0)
return i;
}
if (s->s3.alert_dispatch) {
- i = s->method->ssl_dispatch_alert(s);
+ i = ssl->method->ssl_dispatch_alert(ssl);
if (i <= 0) {
/* SSLfatal() already called if appropriate */
s->rlayer.wnum = tot;
} else
#endif /* !defined(OPENSSL_NO_MULTIBLOCK) && EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK */
if (tot == len) { /* done? */
- if (s->mode & SSL_MODE_RELEASE_BUFFERS && !SSL_IS_DTLS(s))
+ if (s->mode & SSL_MODE_RELEASE_BUFFERS && !SSL_CONNECTION_IS_DTLS(s))
ssl3_release_write_buffer(s);
*written = tot;
if (tmpwrit == n
&& (s->mode & SSL_MODE_RELEASE_BUFFERS) != 0
- && !SSL_IS_DTLS(s))
+ && !SSL_CONNECTION_IS_DTLS(s))
ssl3_release_write_buffer(s);
*written = tot + tmpwrit;
}
}
-int do_ssl3_write(SSL *s, int type, const unsigned char *buf,
+int do_ssl3_write(SSL_CONNECTION *s, int type, const unsigned char *buf,
size_t *pipelens, size_t numpipes,
int create_empty_fragment, size_t *written)
{
size_t totlen = 0, len, wpinited = 0;
size_t j;
int using_ktls;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
for (j = 0; j < numpipes; j++)
totlen += pipelens[j];
/* If we have an alert to send, lets send it */
if (s->s3.alert_dispatch) {
- i = s->method->ssl_dispatch_alert(s);
+ i = ssl->method->ssl_dispatch_alert(ssl);
if (i <= 0) {
/* SSLfatal() already called if appropriate */
return i;
}
/* Explicit IV length, block ciphers appropriate version flag */
- if (s->enc_write_ctx && SSL_USE_EXPLICIT_IV(s) && !SSL_TREAT_AS_TLS13(s)) {
+ if (s->enc_write_ctx && SSL_USE_EXPLICIT_IV(s)
+ && !SSL_CONNECTION_TREAT_AS_TLS13(s)) {
int mode = EVP_CIPHER_CTX_get_mode(s->enc_write_ctx);
if (mode == EVP_CIPH_CBC_MODE) {
eivlen = EVP_CIPHER_CTX_get_iv_length(s->enc_write_ctx);
* In TLSv1.3, once encrypting, we always use application data for the
* record type
*/
- if (SSL_TREAT_AS_TLS13(s)
+ if (SSL_CONNECTION_TREAT_AS_TLS13(s)
&& s->enc_write_ctx != NULL
&& (s->statem.enc_write_state != ENC_WRITE_STATE_WRITE_PLAIN_ALERTS
|| type != SSL3_RT_ALERT))
* Some servers hang if initial client hello is larger than 256 bytes
* and record version number > TLS 1.0
*/
- if (SSL_get_state(s) == TLS_ST_CW_CLNT_HELLO
+ if (SSL_get_state(ssl) == TLS_ST_CW_CLNT_HELLO
&& !s->renegotiate
- && TLS1_get_version(s) > TLS1_VERSION
+ && TLS1_get_version(ssl) > TLS1_VERSION
&& s->hello_retry_request == SSL_HRR_NONE)
version = TLS1_VERSION;
SSL3_RECORD_set_rec_version(thiswr, version);
}
}
- if (SSL_TREAT_AS_TLS13(s)
+ if (SSL_CONNECTION_TREAT_AS_TLS13(s)
&& !using_ktls
&& s->enc_write_ctx != NULL
&& (s->statem.enc_write_state != ENC_WRITE_STATE_WRITE_PLAIN_ALERTS
size_t padding = 0;
size_t max_padding = max_send_fragment - rlen;
if (s->record_padding_cb != NULL) {
- padding = s->record_padding_cb(s, type, rlen, s->record_padding_arg);
+ padding = s->record_padding_cb(ssl, type, rlen, s->record_padding_arg);
} else if (s->block_padding > 0) {
size_t mask = s->block_padding - 1;
size_t remainder;
unsigned char *mac;
if (!WPACKET_allocate_bytes(thispkt, mac_size, &mac)
- || !s->method->ssl3_enc->mac(s, thiswr, mac, 1)) {
+ || !ssl->method->ssl3_enc->mac(s, thiswr, mac, 1)) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
goto err;
}
}
} else {
if (!using_ktls) {
- if (s->method->ssl3_enc->enc(s, wr, numpipes, 1, NULL,
+ if (ssl->method->ssl3_enc->enc(s, wr, numpipes, 1, NULL,
mac_size) < 1) {
if (!ossl_statem_in_error(s)) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
unsigned char *mac;
if (!WPACKET_allocate_bytes(thispkt, mac_size, &mac)
- || !s->method->ssl3_enc->mac(s, thiswr, mac, 1)) {
+ || !ssl->method->ssl3_enc->mac(s, thiswr, mac, 1)) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
goto err;
}
recordstart = WPACKET_get_curr(thispkt) - len
- SSL3_RT_HEADER_LENGTH;
s->msg_callback(1, thiswr->rec_version, SSL3_RT_HEADER, recordstart,
- SSL3_RT_HEADER_LENGTH, s,
+ SSL3_RT_HEADER_LENGTH, ssl,
s->msg_callback_arg);
- if (SSL_TREAT_AS_TLS13(s) && s->enc_write_ctx != NULL) {
+ if (SSL_CONNECTION_TREAT_AS_TLS13(s) && s->enc_write_ctx != NULL) {
unsigned char ctype = type;
s->msg_callback(1, thiswr->rec_version, SSL3_RT_INNER_CONTENT_TYPE,
- &ctype, 1, s, s->msg_callback_arg);
+ &ctype, 1, ssl, s->msg_callback_arg);
}
}
*
* Return values are as per SSL_write()
*/
-int ssl3_write_pending(SSL *s, int type, const unsigned char *buf, size_t len,
- size_t *written)
+int ssl3_write_pending(SSL_CONNECTION *s, int type, const unsigned char *buf,
+ size_t len, size_t *written)
{
int i;
SSL3_BUFFER *wb = s->rlayer.wbuf;
*written = s->rlayer.wpend_ret;
return 1;
} else if (i <= 0) {
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
/*
* For DTLS, just drop it. That's kind of the whole point in
* using a datagram service
* Application data protocol
* none of our business
*/
-int ssl3_read_bytes(SSL *s, int type, int *recvd_type, unsigned char *buf,
+int ssl3_read_bytes(SSL *ssl, int type, int *recvd_type, unsigned char *buf,
size_t len, int peek, size_t *readbytes)
{
int i, j, ret;
SSL3_RECORD *rr;
SSL3_BUFFER *rbuf;
void (*cb) (const SSL *ssl, int type2, int val) = NULL;
- int is_tls13 = SSL_IS_TLS13(s);
+ int is_tls13;
+ SSL_CONNECTION *s = SSL_CONNECTION_FROM_SSL_ONLY(ssl);
+
+ is_tls13 = SSL_CONNECTION_IS_TLS13(s);
rbuf = &s->rlayer.rbuf;
* Now s->rlayer.handshake_fragment_len == 0 if type == SSL3_RT_HANDSHAKE.
*/
- if (!ossl_statem_get_in_handshake(s) && SSL_in_init(s)) {
+ if (!ossl_statem_get_in_handshake(s) && SSL_in_init(ssl)) {
/* type == SSL3_RT_APPLICATION_DATA */
- i = s->handshake_func(s);
+ i = s->handshake_func(ssl);
/* SSLfatal() already called */
if (i < 0)
return i;
if (s->rlayer.handshake_fragment_len > 0
&& SSL3_RECORD_get_type(rr) != SSL3_RT_HANDSHAKE
- && SSL_IS_TLS13(s)) {
+ && SSL_CONNECTION_IS_TLS13(s)) {
SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE,
SSL_R_MIXED_HANDSHAKE_AND_NON_HANDSHAKE_DATA);
return -1;
* make sure that we are not getting application data when we are
* doing a handshake for the first time
*/
- if (SSL_in_init(s) && (type == SSL3_RT_APPLICATION_DATA) &&
- (s->enc_read_ctx == NULL)) {
+ if (SSL_in_init(ssl) && type == SSL3_RT_APPLICATION_DATA
+ && s->enc_read_ctx == NULL) {
SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_APP_DATA_IN_HANDSHAKE);
return -1;
}
return -1;
}
- if (s->method->version == TLS_ANY_VERSION
+ if (ssl->method->version == TLS_ANY_VERSION
&& (s->server || rr->type != SSL3_RT_ALERT)) {
/*
* If we've got this far and still haven't decided on what version
}
if (s->msg_callback)
- s->msg_callback(0, s->version, SSL3_RT_ALERT, alert_bytes, 2, s,
+ s->msg_callback(0, s->version, SSL3_RT_ALERT, alert_bytes, 2, ssl,
s->msg_callback_arg);
if (s->info_callback != NULL)
cb = s->info_callback;
- else if (s->ctx->info_callback != NULL)
- cb = s->ctx->info_callback;
+ else if (ssl->ctx->info_callback != NULL)
+ cb = ssl->ctx->info_callback;
if (cb != NULL) {
j = (alert_level << 8) | alert_descr;
- cb(s, SSL_CB_READ_ALERT, j);
+ cb(ssl, SSL_CB_READ_ALERT, j);
}
if (alert_level == SSL3_AL_WARNING
* because we are unable to write any response due to having already
* sent close_notify.
*/
- if (!SSL_IS_TLS13(s)) {
+ if (!SSL_CONNECTION_IS_TLS13(s)) {
SSL3_RECORD_set_length(rr, 0);
SSL3_RECORD_set_read(rr);
goto start;
s->rwstate = SSL_READING;
- rbio = SSL_get_rbio(s);
+ rbio = SSL_get_rbio(ssl);
BIO_clear_retry_flags(rbio);
BIO_set_retry_read(rbio);
return -1;
/* We found handshake data, so we're going back into init */
ossl_statem_set_in_init(s, 1);
- i = s->handshake_func(s);
+ i = s->handshake_func(ssl);
/* SSLfatal() already called if appropriate */
if (i < 0)
return i;
* problems in the blocking world
*/
s->rwstate = SSL_READING;
- bio = SSL_get_rbio(s);
+ bio = SSL_get_rbio(ssl);
BIO_clear_retry_flags(bio);
BIO_set_retry_read(bio);
return -1;
* decryption was applied. We just skip it and move on to the next
* record.
*/
- if (!early_data_count_ok(s, rr->length,
- EARLY_DATA_CIPHERTEXT_OVERHEAD, 0)) {
+ if (!ossl_early_data_count_ok(s, rr->length,
+ EARLY_DATA_CIPHERTEXT_OVERHEAD, 0)) {
/* SSLfatal() already called */
return -1;
}
* https://www.openssl.org/source/license.html
*/
+typedef struct ssl_connection_st SSL_CONNECTION;
+
/*****************************************************************************
* *
* These structures should be considered PRIVATE to the record layer. No *
*****************************************************************************/
typedef struct record_layer_st {
- /* The parent SSL structure */
- SSL *s;
+ /* The parent SSL_CONNECTION structure */
+ SSL_CONNECTION *s;
/*
* Read as many input bytes as possible (for
* non-blocking reads)
#define RECORD_LAYER_get_rbuf(rl) (&(rl)->rbuf)
#define RECORD_LAYER_get_wbuf(rl) ((rl)->wbuf)
-void RECORD_LAYER_init(RECORD_LAYER *rl, SSL *s);
+void RECORD_LAYER_init(RECORD_LAYER *rl, SSL_CONNECTION *s);
void RECORD_LAYER_clear(RECORD_LAYER *rl);
void RECORD_LAYER_release(RECORD_LAYER *rl);
int RECORD_LAYER_read_pending(const RECORD_LAYER *rl);
__owur size_t ssl3_pending(const SSL *s);
__owur int ssl3_write_bytes(SSL *s, int type, const void *buf, size_t len,
size_t *written);
-int do_ssl3_write(SSL *s, int type, const unsigned char *buf,
+int do_ssl3_write(SSL_CONNECTION *s, int type, const unsigned char *buf,
size_t *pipelens, size_t numpipes,
int create_empty_fragment, size_t *written);
__owur int ssl3_read_bytes(SSL *s, int type, int *recvd_type,
unsigned char *buf, size_t len, int peek,
size_t *readbytes);
-__owur int ssl3_setup_buffers(SSL *s);
-__owur int ssl3_enc(SSL *s, SSL3_RECORD *inrecs, size_t n_recs, int send,
- SSL_MAC_BUF *mac, size_t macsize);
-__owur int n_ssl3_mac(SSL *ssl, SSL3_RECORD *rec, unsigned char *md, int send);
-__owur int ssl3_write_pending(SSL *s, int type, const unsigned char *buf, size_t len,
+__owur int ssl3_setup_buffers(SSL_CONNECTION *s);
+__owur int ssl3_enc(SSL_CONNECTION *s, SSL3_RECORD *inrecs, size_t n_recs,
+ int send, SSL_MAC_BUF *mac, size_t macsize);
+__owur int n_ssl3_mac(SSL_CONNECTION *s, SSL3_RECORD *rec, unsigned char *md,
+ int send);
+__owur int ssl3_write_pending(SSL_CONNECTION *s, int type,
+ const unsigned char *buf, size_t len,
size_t *written);
-__owur int tls1_enc(SSL *s, SSL3_RECORD *recs, size_t n_recs, int sending,
- SSL_MAC_BUF *mac, size_t macsize);
-__owur int tls1_mac(SSL *ssl, SSL3_RECORD *rec, unsigned char *md, int send);
-__owur int tls13_enc(SSL *s, SSL3_RECORD *recs, size_t n_recs, int send,
- SSL_MAC_BUF *mac, size_t macsize);
+__owur int tls1_enc(SSL_CONNECTION *s, SSL3_RECORD *recs, size_t n_recs,
+ int sending, SSL_MAC_BUF *mac, size_t macsize);
+__owur int tls1_mac(SSL_CONNECTION *s, SSL3_RECORD *rec, unsigned char *md,
+ int send);
+__owur int tls13_enc(SSL_CONNECTION *s, SSL3_RECORD *recs, size_t n_recs,
+ int send, SSL_MAC_BUF *mac, size_t macsize);
int DTLS_RECORD_LAYER_new(RECORD_LAYER *rl);
void DTLS_RECORD_LAYER_free(RECORD_LAYER *rl);
void DTLS_RECORD_LAYER_clear(RECORD_LAYER *rl);
__owur int dtls1_read_bytes(SSL *s, int type, int *recvd_type,
unsigned char *buf, size_t len, int peek,
size_t *readbytes);
-__owur int dtls1_write_bytes(SSL *s, int type, const void *buf, size_t len,
- size_t *written);
-int do_dtls1_write(SSL *s, int type, const unsigned char *buf,
+__owur int dtls1_write_bytes(SSL_CONNECTION *s, int type, const void *buf,
+ size_t len, size_t *written);
+int do_dtls1_write(SSL_CONNECTION *s, int type, const unsigned char *buf,
size_t len, int create_empty_fragment, size_t *written);
-void dtls1_reset_seq_numbers(SSL *s, int rw);
-int dtls_buffer_listen_record(SSL *s, size_t len, unsigned char *seq,
+void dtls1_reset_seq_numbers(SSL_CONNECTION *s, int rw);
+int dtls_buffer_listen_record(SSL_CONNECTION *s, size_t len, unsigned char *seq,
size_t off);
#define RECORD_LAYER_clear_first_record(rl) ((rl)->is_first_record = 0)
#define DTLS_RECORD_LAYER_get_r_epoch(rl) ((rl)->d->r_epoch)
-__owur int ssl3_read_n(SSL *s, size_t n, size_t max, int extend, int clearold,
- size_t *readbytes);
+__owur int ssl3_read_n(SSL_CONNECTION *s, size_t n, size_t max, int extend,
+ int clearold, size_t *readbytes);
-DTLS1_BITMAP *dtls1_get_bitmap(SSL *s, SSL3_RECORD *rr,
+DTLS1_BITMAP *dtls1_get_bitmap(SSL_CONNECTION *s, SSL3_RECORD *rr,
unsigned int *is_next_epoch);
-int dtls1_process_buffered_records(SSL *s);
-int dtls1_retrieve_buffered_record(SSL *s, record_pqueue *queue);
-int dtls1_buffer_record(SSL *s, record_pqueue *q, unsigned char *priority);
+int dtls1_process_buffered_records(SSL_CONNECTION *s);
+int dtls1_retrieve_buffered_record(SSL_CONNECTION *s, record_pqueue *queue);
+int dtls1_buffer_record(SSL_CONNECTION *s, record_pqueue *q,
+ unsigned char *priority);
void ssl3_record_sequence_update(unsigned char *seq);
/* Functions provided by the DTLS1_BITMAP component */
-int dtls1_record_replay_check(SSL *s, DTLS1_BITMAP *bitmap);
-void dtls1_record_bitmap_update(SSL *s, DTLS1_BITMAP *bitmap);
+int dtls1_record_replay_check(SSL_CONNECTION *s, DTLS1_BITMAP *bitmap);
+void dtls1_record_bitmap_update(SSL_CONNECTION *s, DTLS1_BITMAP *bitmap);
/* Macros/functions provided by the SSL3_BUFFER component */
void SSL3_BUFFER_clear(SSL3_BUFFER *b);
void SSL3_BUFFER_set_data(SSL3_BUFFER *b, const unsigned char *d, size_t n);
void SSL3_BUFFER_release(SSL3_BUFFER *b);
-__owur int ssl3_setup_read_buffer(SSL *s);
-__owur int ssl3_setup_write_buffer(SSL *s, size_t numwpipes, size_t len);
-int ssl3_release_read_buffer(SSL *s);
-int ssl3_release_write_buffer(SSL *s);
+__owur int ssl3_setup_read_buffer(SSL_CONNECTION *s);
+__owur int ssl3_setup_write_buffer(SSL_CONNECTION *s, size_t numwpipes,
+ size_t len);
+int ssl3_release_read_buffer(SSL_CONNECTION *s);
+int ssl3_release_write_buffer(SSL_CONNECTION *s);
/* Macros/functions provided by the SSL3_RECORD component */
void SSL3_RECORD_clear(SSL3_RECORD *r, size_t);
void SSL3_RECORD_release(SSL3_RECORD *r, size_t num_recs);
void SSL3_RECORD_set_seq_num(SSL3_RECORD *r, const unsigned char *seq_num);
-int ssl3_get_record(SSL *s);
-__owur int ssl3_do_compress(SSL *ssl, SSL3_RECORD *wr);
-__owur int ssl3_do_uncompress(SSL *ssl, SSL3_RECORD *rr);
+int ssl3_get_record(SSL_CONNECTION *s);
+__owur int ssl3_do_compress(SSL_CONNECTION *ssl, SSL3_RECORD *wr);
+__owur int ssl3_do_uncompress(SSL_CONNECTION *ssl, SSL3_RECORD *rr);
__owur int ssl3_cbc_remove_padding_and_mac(size_t *reclen,
size_t origreclen,
unsigned char *recdata,
size_t block_size, size_t mac_size,
int aead,
OSSL_LIB_CTX *libctx);
-int dtls1_process_record(SSL *s, DTLS1_BITMAP *bitmap);
-__owur int dtls1_get_record(SSL *s);
-int early_data_count_ok(SSL *s, size_t length, size_t overhead, int send);
+int dtls1_process_record(SSL_CONNECTION *s, DTLS1_BITMAP *bitmap);
+__owur int dtls1_get_record(SSL_CONNECTION *s);
+int ossl_early_data_count_ok(SSL_CONNECTION *s, size_t length,
+ size_t overhead, int send);
b->buf = NULL;
}
-int ssl3_setup_read_buffer(SSL *s)
+int ssl3_setup_read_buffer(SSL_CONNECTION *s)
{
unsigned char *p;
size_t len, align = 0, headerlen;
b = RECORD_LAYER_get_rbuf(&s->rlayer);
- if (SSL_IS_DTLS(s))
+ if (SSL_CONNECTION_IS_DTLS(s))
headerlen = DTLS1_RT_HEADER_LENGTH;
else
headerlen = SSL3_RT_HEADER_LENGTH;
return 1;
}
-int ssl3_setup_write_buffer(SSL *s, size_t numwpipes, size_t len)
+int ssl3_setup_write_buffer(SSL_CONNECTION *s, size_t numwpipes,
+ size_t len)
{
unsigned char *p;
size_t align = 0, headerlen;
s->rlayer.numwpipes = numwpipes;
if (len == 0) {
- if (SSL_IS_DTLS(s))
+ if (SSL_CONNECTION_IS_DTLS(s))
headerlen = DTLS1_RT_HEADER_LENGTH + 1;
else
headerlen = SSL3_RT_HEADER_LENGTH;
return 1;
}
-int ssl3_setup_buffers(SSL *s)
+int ssl3_setup_buffers(SSL_CONNECTION *s)
{
if (!ssl3_setup_read_buffer(s)) {
/* SSLfatal() already called */
return 1;
}
-int ssl3_release_write_buffer(SSL *s)
+int ssl3_release_write_buffer(SSL_CONNECTION *s)
{
SSL3_BUFFER *wb;
size_t pipes;
return 1;
}
-int ssl3_release_read_buffer(SSL *s)
+int ssl3_release_read_buffer(SSL_CONNECTION *s)
{
SSL3_BUFFER *b;
* Peeks ahead into "read_ahead" data to see if we have a whole record waiting
* for us in the buffer.
*/
-static int ssl3_record_app_data_waiting(SSL *s)
+static int ssl3_record_app_data_waiting(SSL_CONNECTION *s)
{
SSL3_BUFFER *rbuf;
size_t left, len;
return 1;
}
-int early_data_count_ok(SSL *s, size_t length, size_t overhead, int send)
+int ossl_early_data_count_ok(SSL_CONNECTION *s, size_t length,
+ size_t overhead, int send)
{
uint32_t max_early_data;
SSL_SESSION *sess = s->session;
* |max_pipelines|
*/
/* used only by ssl3_read_bytes */
-int ssl3_get_record(SSL *s)
+int ssl3_get_record(SSL_CONNECTION *s)
{
int enc_err, rret;
int i;
int using_ktls;
SSL_MAC_BUF *macbufs = NULL;
int ret = -1;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
rr = RECORD_LAYER_get_rrec(&s->rlayer);
rbuf = RECORD_LAYER_get_rbuf(&s->rlayer);
|| !PACKET_get_net_2(&pkt, &version)
|| !PACKET_get_net_2_len(&pkt, &thisrr->length)) {
if (s->msg_callback)
- s->msg_callback(0, 0, SSL3_RT_HEADER, p, 5, s,
+ s->msg_callback(0, 0, SSL3_RT_HEADER, p, 5, ssl,
s->msg_callback_arg);
SSLfatal(s, SSL_AD_DECODE_ERROR, ERR_R_INTERNAL_ERROR);
return -1;
thisrr->rec_version = version;
if (s->msg_callback)
- s->msg_callback(0, version, SSL3_RT_HEADER, p, 5, s,
+ s->msg_callback(0, version, SSL3_RT_HEADER, p, 5, ssl,
s->msg_callback_arg);
/*
* yet, but we still treat it as TLSv1.3, so we must check for
* that explicitly
*/
- if (!s->first_packet && !SSL_IS_TLS13(s)
+ if (!s->first_packet && !SSL_CONNECTION_IS_TLS13(s)
&& s->hello_retry_request != SSL_HRR_PENDING
&& version != (unsigned int)s->version) {
if ((s->version & 0xFF00) == (version & 0xFF00)
}
}
- if (SSL_IS_TLS13(s)
+ if (SSL_CONNECTION_IS_TLS13(s)
&& s->enc_read_ctx != NULL
&& !using_ktls) {
if (thisrr->type != SSL3_RT_APPLICATION_DATA
/* now s->rlayer.rstate == SSL_ST_READ_BODY */
}
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
size_t len = SSL3_RT_MAX_TLS13_ENCRYPTED_LENGTH;
/* KTLS strips the inner record type. */
if (num_recs == 1
&& thisrr->type == SSL3_RT_CHANGE_CIPHER_SPEC
- && (SSL_IS_TLS13(s) || s->hello_retry_request != SSL_HRR_NONE)
+ && (SSL_CONNECTION_IS_TLS13(s)
+ || s->hello_retry_request != SSL_HRR_NONE)
&& SSL_IS_FIRST_HANDSHAKE(s)) {
/*
* CCS messages must be exactly 1 byte long, containing the value 0x01
}
thisrr->length -= mac_size;
mac = thisrr->data + thisrr->length;
- i = s->method->ssl3_enc->mac(s, thisrr, md, 0 /* not send */ );
+ i = ssl->method->ssl3_enc->mac(s, thisrr, md, 0 /* not send */ );
if (i == 0 || CRYPTO_memcmp(md, mac, mac_size) != 0) {
SSLfatal(s, SSL_AD_BAD_RECORD_MAC,
SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC);
}
}
- enc_err = s->method->ssl3_enc->enc(s, rr, num_recs, 0, macbufs, mac_size);
+ enc_err = ssl->method->ssl3_enc->enc(s, rr, num_recs, 0, macbufs, mac_size);
/*-
* enc_err is:
thisrr = &rr[0];
- if (!early_data_count_ok(s, thisrr->length,
- EARLY_DATA_CIPHERTEXT_OVERHEAD, 0)) {
+ if (!ossl_early_data_count_ok(s, thisrr->length,
+ EARLY_DATA_CIPHERTEXT_OVERHEAD, 0)) {
/* SSLfatal() already called */
goto end;
}
SSL_MAC_BUF *thismb = &macbufs[j];
thisrr = &rr[j];
- i = s->method->ssl3_enc->mac(s, thisrr, md, 0 /* not send */ );
+ i = ssl->method->ssl3_enc->mac(s, thisrr, md, 0 /* not send */ );
if (i == 0 || thismb == NULL || thismb->mac == NULL
|| CRYPTO_memcmp(md, thismb->mac, (size_t)mac_size) != 0)
enc_err = 0;
}
}
- if (SSL_IS_TLS13(s)
+ if (SSL_CONNECTION_IS_TLS13(s)
&& s->enc_read_ctx != NULL
&& thisrr->type != SSL3_RT_ALERT) {
/*
}
if (s->msg_callback)
s->msg_callback(0, s->version, SSL3_RT_INNER_CONTENT_TYPE,
- &thisrr->type, 1, s, s->msg_callback_arg);
+ &thisrr->type, 1, ssl, s->msg_callback_arg);
}
/*
* TLSv1.3 alert and handshake records are required to be non-zero in
* length.
*/
- if (SSL_IS_TLS13(s)
+ if (SSL_CONNECTION_IS_TLS13(s)
&& (thisrr->type == SSL3_RT_HANDSHAKE
|| thisrr->type == SSL3_RT_ALERT)
&& thisrr->length == 0) {
if (s->early_data_state == SSL_EARLY_DATA_READING) {
thisrr = &rr[0];
if (thisrr->type == SSL3_RT_APPLICATION_DATA
- && !early_data_count_ok(s, thisrr->length, 0, 0)) {
+ && !ossl_early_data_count_ok(s, thisrr->length, 0, 0)) {
/* SSLfatal already called */
goto end;
}
return ret;
}
-int ssl3_do_uncompress(SSL *ssl, SSL3_RECORD *rr)
+int ssl3_do_uncompress(SSL_CONNECTION *sc, SSL3_RECORD *rr)
{
#ifndef OPENSSL_NO_COMP
int i;
if (rr->comp == NULL)
return 0;
- i = COMP_expand_block(ssl->expand, rr->comp,
+ i = COMP_expand_block(sc->expand, rr->comp,
SSL3_RT_MAX_PLAIN_LENGTH, rr->data, (int)rr->length);
if (i < 0)
return 0;
return 1;
}
-int ssl3_do_compress(SSL *ssl, SSL3_RECORD *wr)
+int ssl3_do_compress(SSL_CONNECTION *sc, SSL3_RECORD *wr)
{
#ifndef OPENSSL_NO_COMP
int i;
- i = COMP_compress_block(ssl->compress, wr->data,
+ i = COMP_compress_block(sc->compress, wr->data,
(int)(wr->length + SSL3_RT_MAX_COMPRESSED_OVERHEAD),
wr->input, (int)wr->length);
if (i < 0)
* 0: if the record is publicly invalid, or an internal error
* 1: Success or Mac-then-encrypt decryption failed (MAC will be randomised)
*/
-int ssl3_enc(SSL *s, SSL3_RECORD *inrecs, size_t n_recs, int sending,
+int ssl3_enc(SSL_CONNECTION *s, SSL3_RECORD *inrecs, size_t n_recs, int sending,
SSL_MAC_BUF *mac, size_t macsize)
{
SSL3_RECORD *rec;
(mac != NULL) ? &mac->alloced : NULL,
bs,
macsize,
- s->ctx->libctx);
+ SSL_CONNECTION_GET_CTX(s)->libctx);
}
}
return 1;
* decryption failed, or Encrypt-then-mac decryption failed.
* 1: Success or Mac-then-encrypt decryption failed (MAC will be randomised)
*/
-int tls1_enc(SSL *s, SSL3_RECORD *recs, size_t n_recs, int sending,
+int tls1_enc(SSL_CONNECTION *s, SSL3_RECORD *recs, size_t n_recs, int sending,
SSL_MAC_BUF *macs, size_t macsize)
{
EVP_CIPHER_CTX *ds;
*/
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return 0;
- } else if (RAND_bytes_ex(s->ctx->libctx, recs[ctr].input,
+ } else if (RAND_bytes_ex(SSL_CONNECTION_GET_CTX(s)->libctx,
+ recs[ctr].input,
ivlen, 0) <= 0) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return 0;
seq = sending ? RECORD_LAYER_get_write_sequence(&s->rlayer)
: RECORD_LAYER_get_read_sequence(&s->rlayer);
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
/* DTLS does not support pipelining */
unsigned char dtlsseq[8], *p = dtlsseq;
}
}
- if (!SSL_IS_DTLS(s) && tlstree_enc) {
+ if (!SSL_CONNECTION_IS_DTLS(s) && tlstree_enc) {
unsigned char *seq;
int decrement_seq = 0;
pad ? (size_t)pad : macsize,
(EVP_CIPHER_get_flags(enc)
& EVP_CIPH_FLAG_AEAD_CIPHER) != 0,
- s->ctx->libctx))
+ SSL_CONNECTION_GET_CTX(s)->libctx))
return 0;
}
}
}
}
-int n_ssl3_mac(SSL *ssl, SSL3_RECORD *rec, unsigned char *md, int sending)
+int n_ssl3_mac(SSL_CONNECTION *sc, SSL3_RECORD *rec, unsigned char *md,
+ int sending)
{
unsigned char *mac_sec, *seq;
const EVP_MD_CTX *hash;
int t;
if (sending) {
- mac_sec = &(ssl->s3.write_mac_secret[0]);
- seq = RECORD_LAYER_get_write_sequence(&ssl->rlayer);
- hash = ssl->write_hash;
+ mac_sec = &(sc->s3.write_mac_secret[0]);
+ seq = RECORD_LAYER_get_write_sequence(&sc->rlayer);
+ hash = sc->write_hash;
} else {
- mac_sec = &(ssl->s3.read_mac_secret[0]);
- seq = RECORD_LAYER_get_read_sequence(&ssl->rlayer);
- hash = ssl->read_hash;
+ mac_sec = &(sc->s3.read_mac_secret[0]);
+ seq = RECORD_LAYER_get_read_sequence(&sc->rlayer);
+ hash = sc->read_hash;
}
t = EVP_MD_CTX_get_size(hash);
npad = (48 / md_size) * md_size;
if (!sending
- && EVP_CIPHER_CTX_get_mode(ssl->enc_read_ctx) == EVP_CIPH_CBC_MODE
+ && EVP_CIPHER_CTX_get_mode(sc->enc_read_ctx) == EVP_CIPH_CBC_MODE
&& ssl3_cbc_record_digest_supported(hash)) {
#ifdef OPENSSL_NO_DEPRECATED_3_0
return 0;
return 1;
}
-int tls1_mac(SSL *ssl, SSL3_RECORD *rec, unsigned char *md, int sending)
+int tls1_mac(SSL_CONNECTION *sc, SSL3_RECORD *rec, unsigned char *md,
+ int sending)
{
unsigned char *seq;
EVP_MD_CTX *hash;
int i;
EVP_MD_CTX *hmac = NULL, *mac_ctx;
unsigned char header[13];
- int stream_mac = sending ? (ssl->mac_flags & SSL_MAC_FLAG_WRITE_MAC_STREAM)
- : (ssl->mac_flags & SSL_MAC_FLAG_READ_MAC_STREAM);
- int tlstree_mac = sending ? (ssl->mac_flags & SSL_MAC_FLAG_WRITE_MAC_TLSTREE)
- : (ssl->mac_flags & SSL_MAC_FLAG_READ_MAC_TLSTREE);
+ int stream_mac = sending ? (sc->mac_flags & SSL_MAC_FLAG_WRITE_MAC_STREAM)
+ : (sc->mac_flags & SSL_MAC_FLAG_READ_MAC_STREAM);
+ int tlstree_mac = sending ? (sc->mac_flags & SSL_MAC_FLAG_WRITE_MAC_TLSTREE)
+ : (sc->mac_flags & SSL_MAC_FLAG_READ_MAC_TLSTREE);
int t;
int ret = 0;
if (sending) {
- seq = RECORD_LAYER_get_write_sequence(&ssl->rlayer);
- hash = ssl->write_hash;
+ seq = RECORD_LAYER_get_write_sequence(&sc->rlayer);
+ hash = sc->write_hash;
} else {
- seq = RECORD_LAYER_get_read_sequence(&ssl->rlayer);
- hash = ssl->read_hash;
+ seq = RECORD_LAYER_get_read_sequence(&sc->rlayer);
+ hash = sc->read_hash;
}
t = EVP_MD_CTX_get_size(hash);
mac_ctx = hmac;
}
- if (!SSL_IS_DTLS(ssl) && tlstree_mac && EVP_MD_CTX_ctrl(mac_ctx, EVP_MD_CTRL_TLSTREE, 0, seq) <= 0) {
+ if (!SSL_CONNECTION_IS_DTLS(sc) && tlstree_mac
+ && EVP_MD_CTX_ctrl(mac_ctx, EVP_MD_CTRL_TLSTREE, 0, seq) <= 0) {
goto end;
}
- if (SSL_IS_DTLS(ssl)) {
+ if (SSL_CONNECTION_IS_DTLS(sc)) {
unsigned char dtlsseq[8], *p = dtlsseq;
- s2n(sending ? DTLS_RECORD_LAYER_get_w_epoch(&ssl->rlayer) :
- DTLS_RECORD_LAYER_get_r_epoch(&ssl->rlayer), p);
+ s2n(sending ? DTLS_RECORD_LAYER_get_w_epoch(&sc->rlayer) :
+ DTLS_RECORD_LAYER_get_r_epoch(&sc->rlayer), p);
memcpy(p, &seq[2], 6);
memcpy(header, dtlsseq, 8);
memcpy(header, seq, 8);
header[8] = rec->type;
- header[9] = (unsigned char)(ssl->version >> 8);
- header[10] = (unsigned char)(ssl->version);
+ header[9] = (unsigned char)(sc->version >> 8);
+ header[10] = (unsigned char)(sc->version);
header[11] = (unsigned char)(rec->length >> 8);
header[12] = (unsigned char)(rec->length & 0xff);
- if (!sending && !SSL_READ_ETM(ssl)
- && EVP_CIPHER_CTX_get_mode(ssl->enc_read_ctx) == EVP_CIPH_CBC_MODE
+ if (!sending && !SSL_READ_ETM(sc)
+ && EVP_CIPHER_CTX_get_mode(sc->enc_read_ctx) == EVP_CIPH_CBC_MODE
&& ssl3_cbc_record_digest_supported(mac_ctx)) {
OSSL_PARAM tls_hmac_params[2], *p = tls_hmac_params;
BIO_dump_indent(trc_out, rec->data, rec->length, 4);
} OSSL_TRACE_END(TLS);
- if (!SSL_IS_DTLS(ssl)) {
+ if (!SSL_CONNECTION_IS_DTLS(sc)) {
for (i = 7; i >= 0; i--) {
++seq[i];
if (seq[i] != 0)
return ret;
}
-int dtls1_process_record(SSL *s, DTLS1_BITMAP *bitmap)
+int dtls1_process_record(SSL_CONNECTION *s, DTLS1_BITMAP *bitmap)
{
int i;
int enc_err;
size_t max_plain_length = SSL3_RT_MAX_PLAIN_LENGTH;
SSL_MAC_BUF macbuf = { NULL, 0 };
int ret = 0;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
rr = RECORD_LAYER_get_rrec(&s->rlayer);
sess = s->session;
}
rr->length -= mac_size;
mac = rr->data + rr->length;
- i = s->method->ssl3_enc->mac(s, rr, md, 0 /* not send */ );
+ i = ssl->method->ssl3_enc->mac(s, rr, md, 0 /* not send */ );
if (i == 0 || CRYPTO_memcmp(md, mac, (size_t)mac_size) != 0) {
SSLfatal(s, SSL_AD_BAD_RECORD_MAC,
SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC);
* errors in the queue from processing bogus junk that we ignored.
*/
ERR_set_mark();
- enc_err = s->method->ssl3_enc->enc(s, rr, 1, 0, &macbuf, mac_size);
+ enc_err = ssl->method->ssl3_enc->enc(s, rr, 1, 0, &macbuf, mac_size);
/*-
* enc_err is:
&& (EVP_MD_CTX_get0_md(s->read_hash) != NULL)) {
/* s->read_hash != NULL => mac_size != -1 */
- i = s->method->ssl3_enc->mac(s, rr, md, 0 /* not send */ );
+ i = ssl->method->ssl3_enc->mac(s, rr, md, 0 /* not send */ );
if (i == 0 || macbuf.mac == NULL
|| CRYPTO_memcmp(md, macbuf.mac, mac_size) != 0)
enc_err = 0;
* ssl->s3.rrec.length - number of bytes
*/
/* used only by dtls1_read_bytes */
-int dtls1_get_record(SSL *s)
+int dtls1_get_record(SSL_CONNECTION *s)
{
int ssl_major, ssl_minor;
int rret;
unsigned short version;
DTLS1_BITMAP *bitmap;
unsigned int is_next_epoch;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
rr = RECORD_LAYER_get_rrec(&s->rlayer);
if (s->msg_callback)
s->msg_callback(0, 0, SSL3_RT_HEADER, p, DTLS1_RT_HEADER_LENGTH,
- s, s->msg_callback_arg);
+ ssl, s->msg_callback_arg);
/* Pull apart the header into the DTLS1_RECORD */
rr->type = *(p++);
}
#ifndef OPENSSL_NO_SCTP
/* Only do replay check if no SCTP bio */
- if (!BIO_dgram_is_sctp(SSL_get_rbio(s))) {
+ if (!BIO_dgram_is_sctp(SSL_get_rbio(ssl))) {
#endif
/* Check whether this is a repeat, or aged record. */
if (!dtls1_record_replay_check(s, bitmap)) {
* processed at this time.
*/
if (is_next_epoch) {
- if ((SSL_in_init(s) || ossl_statem_get_in_handshake(s))) {
+ if ((SSL_in_init(ssl) || ossl_statem_get_in_handshake(s))) {
if (dtls1_buffer_record (s,
&(DTLS_RECORD_LAYER_get_unprocessed_rcds(&s->rlayer)),
rr->seq_num) < 0) {
}
-int dtls_buffer_listen_record(SSL *s, size_t len, unsigned char *seq, size_t off)
+int dtls_buffer_listen_record(SSL_CONNECTION *s, size_t len, unsigned char *seq,
+ size_t off)
{
SSL3_RECORD *rr;
* 0: On failure
* 1: if the record encryption/decryption was successful.
*/
-int tls13_enc(SSL *s, SSL3_RECORD *recs, size_t n_recs, int sending,
+int tls13_enc(SSL_CONNECTION *s, SSL3_RECORD *recs, size_t n_recs, int sending,
ossl_unused SSL_MAC_BUF *mac, ossl_unused size_t macsize)
{
EVP_CIPHER_CTX *ctx;
if (EVP_CipherInit_ex(ctx, NULL, NULL, NULL, iv, sending) <= 0
|| (!sending && EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG,
- taglen,
- rec->data + rec->length) <= 0)) {
+ taglen,
+ rec->data + rec->length) <= 0)) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return 0;
}
#include <openssl/core_names.h>
#include "internal/cryptlib.h"
-static int ssl3_generate_key_block(SSL *s, unsigned char *km, int num)
+static int ssl3_generate_key_block(SSL_CONNECTION *s, unsigned char *km, int num)
{
const EVP_MD *md5 = NULL, *sha1 = NULL;
EVP_MD_CTX *m5;
unsigned char c = 'A';
unsigned int i, k;
int ret = 0;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
#ifdef CHARSET_EBCDIC
c = os_toascii[c]; /* 'A' in ASCII */
#endif
k = 0;
- md5 = ssl_evp_md_fetch(s->ctx->libctx, NID_md5, s->ctx->propq);
- sha1 = ssl_evp_md_fetch(s->ctx->libctx, NID_sha1, s->ctx->propq);
+ md5 = ssl_evp_md_fetch(sctx->libctx, NID_md5, sctx->propq);
+ sha1 = ssl_evp_md_fetch(sctx->libctx, NID_sha1, sctx->propq);
m5 = EVP_MD_CTX_new();
s1 = EVP_MD_CTX_new();
if (md5 == NULL || sha1 == NULL || m5 == NULL || s1 == NULL) {
return ret;
}
-int ssl3_change_cipher_state(SSL *s, int which)
+int ssl3_change_cipher_state(SSL_CONNECTION *s, int which)
{
unsigned char *p, *mac_secret;
unsigned char *ms, *key, *iv;
return 0;
}
-int ssl3_setup_key_block(SSL *s)
+int ssl3_setup_key_block(SSL_CONNECTION *s)
{
unsigned char *p;
const EVP_CIPHER *c;
if (s->s3.tmp.key_block_length != 0)
return 1;
- if (!ssl_cipher_get_evp(s->ctx, s->session, &c, &hash, NULL, NULL, &comp,
- 0)) {
+ if (!ssl_cipher_get_evp(SSL_CONNECTION_GET_CTX(s), s->session, &c, &hash,
+ NULL, NULL, &comp, 0)) {
/* Error is already recorded */
SSLfatal_alert(s, SSL_AD_INTERNAL_ERROR);
return 0;
return ret;
}
-void ssl3_cleanup_key_block(SSL *s)
+void ssl3_cleanup_key_block(SSL_CONNECTION *s)
{
OPENSSL_clear_free(s->s3.tmp.key_block, s->s3.tmp.key_block_length);
s->s3.tmp.key_block = NULL;
s->s3.tmp.key_block_length = 0;
}
-int ssl3_init_finished_mac(SSL *s)
+int ssl3_init_finished_mac(SSL_CONNECTION *s)
{
BIO *buf = BIO_new(BIO_s_mem());
* together.
*/
-void ssl3_free_digest_list(SSL *s)
+void ssl3_free_digest_list(SSL_CONNECTION *s)
{
BIO_free(s->s3.handshake_buffer);
s->s3.handshake_buffer = NULL;
s->s3.handshake_dgst = NULL;
}
-int ssl3_finish_mac(SSL *s, const unsigned char *buf, size_t len)
+int ssl3_finish_mac(SSL_CONNECTION *s, const unsigned char *buf, size_t len)
{
int ret;
return 1;
}
-int ssl3_digest_cached_records(SSL *s, int keep)
+int ssl3_digest_cached_records(SSL_CONNECTION *s, int keep)
{
const EVP_MD *md;
long hdatalen;
params[n++] = OSSL_PARAM_construct_end();
}
-size_t ssl3_final_finish_mac(SSL *s, const char *sender, size_t len,
+size_t ssl3_final_finish_mac(SSL_CONNECTION *s, const char *sender, size_t len,
unsigned char *p)
{
int ret;
return ret;
}
-int ssl3_generate_master_secret(SSL *s, unsigned char *out, unsigned char *p,
+int ssl3_generate_master_secret(SSL_CONNECTION *s, unsigned char *out,
+ unsigned char *p,
size_t len, size_t *secret_size)
{
static const unsigned char *salt[3] = {
return 0;
}
for (i = 0; i < 3; i++) {
- if (EVP_DigestInit_ex(ctx, s->ctx->sha1, NULL) <= 0
+ if (EVP_DigestInit_ex(ctx, SSL_CONNECTION_GET_CTX(s)->sha1, NULL) <= 0
|| EVP_DigestUpdate(ctx, salt[i],
strlen((const char *)salt[i])) <= 0
|| EVP_DigestUpdate(ctx, p, len) <= 0
|| EVP_DigestUpdate(ctx, &(s->s3.server_random[0]),
SSL3_RANDOM_SIZE) <= 0
|| EVP_DigestFinal_ex(ctx, buf, &n) <= 0
- || EVP_DigestInit_ex(ctx, s->ctx->md5, NULL) <= 0
+ || EVP_DigestInit_ex(ctx, SSL_CONNECTION_GET_CTX(s)->md5, NULL) <= 0
|| EVP_DigestUpdate(ctx, p, len) <= 0
|| EVP_DigestUpdate(ctx, buf, n) <= 0
|| EVP_DigestFinal_ex(ctx, out, &n) <= 0) {
qsort(ssl3_scsvs, SSL3_NUM_SCSVS, sizeof(ssl3_scsvs[0]), cipher_compare);
}
-static int ssl_undefined_function_1(SSL *ssl, unsigned char *r, size_t s,
- const char * t, size_t u,
- const unsigned char * v, size_t w, int x)
+static int sslcon_undefined_function_1(SSL_CONNECTION *sc, unsigned char *r,
+ size_t s, const char *t, size_t u,
+ const unsigned char *v, size_t w, int x)
{
(void)r;
(void)s;
(void)v;
(void)w;
(void)x;
- return ssl_undefined_function(ssl);
+ return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc));
}
const SSL3_ENC_METHOD SSLv3_enc_data = {
SSL3_MD_CLIENT_FINISHED_CONST, 4,
SSL3_MD_SERVER_FINISHED_CONST, 4,
ssl3_alert_code,
- ssl_undefined_function_1,
+ sslcon_undefined_function_1,
0,
ssl3_set_handshake_header,
tls_close_construct_packet,
return NULL;
}
-int ssl3_set_handshake_header(SSL *s, WPACKET *pkt, int htype)
+int ssl3_set_handshake_header(SSL_CONNECTION *s, WPACKET *pkt, int htype)
{
/* No header in the event of a CCS */
if (htype == SSL3_MT_CHANGE_CIPHER_SPEC)
return 1;
}
-int ssl3_handshake_write(SSL *s)
+int ssl3_handshake_write(SSL_CONNECTION *s)
{
return ssl3_do_write(s, SSL3_RT_HANDSHAKE);
}
int ssl3_new(SSL *s)
{
#ifndef OPENSSL_NO_SRP
- if (!ssl_srp_ctx_init_intern(s))
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ if (!ssl_srp_ctx_init_intern(sc))
return 0;
#endif
void ssl3_free(SSL *s)
{
- if (s == NULL)
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
return;
- ssl3_cleanup_key_block(s);
+ ssl3_cleanup_key_block(sc);
- EVP_PKEY_free(s->s3.peer_tmp);
- s->s3.peer_tmp = NULL;
- EVP_PKEY_free(s->s3.tmp.pkey);
- s->s3.tmp.pkey = NULL;
+ EVP_PKEY_free(sc->s3.peer_tmp);
+ sc->s3.peer_tmp = NULL;
+ EVP_PKEY_free(sc->s3.tmp.pkey);
+ sc->s3.tmp.pkey = NULL;
- ssl_evp_cipher_free(s->s3.tmp.new_sym_enc);
- ssl_evp_md_free(s->s3.tmp.new_hash);
+ ssl_evp_cipher_free(sc->s3.tmp.new_sym_enc);
+ ssl_evp_md_free(sc->s3.tmp.new_hash);
- OPENSSL_free(s->s3.tmp.ctype);
- sk_X509_NAME_pop_free(s->s3.tmp.peer_ca_names, X509_NAME_free);
- OPENSSL_free(s->s3.tmp.ciphers_raw);
- OPENSSL_clear_free(s->s3.tmp.pms, s->s3.tmp.pmslen);
- OPENSSL_free(s->s3.tmp.peer_sigalgs);
- OPENSSL_free(s->s3.tmp.peer_cert_sigalgs);
- ssl3_free_digest_list(s);
- OPENSSL_free(s->s3.alpn_selected);
- OPENSSL_free(s->s3.alpn_proposed);
+ OPENSSL_free(sc->s3.tmp.ctype);
+ sk_X509_NAME_pop_free(sc->s3.tmp.peer_ca_names, X509_NAME_free);
+ OPENSSL_free(sc->s3.tmp.ciphers_raw);
+ OPENSSL_clear_free(sc->s3.tmp.pms, sc->s3.tmp.pmslen);
+ OPENSSL_free(sc->s3.tmp.peer_sigalgs);
+ OPENSSL_free(sc->s3.tmp.peer_cert_sigalgs);
+ ssl3_free_digest_list(sc);
+ OPENSSL_free(sc->s3.alpn_selected);
+ OPENSSL_free(sc->s3.alpn_proposed);
#ifndef OPENSSL_NO_SRP
- ssl_srp_ctx_free_intern(s);
+ ssl_srp_ctx_free_intern(sc);
#endif
- memset(&s->s3, 0, sizeof(s->s3));
+ memset(&sc->s3, 0, sizeof(sc->s3));
}
int ssl3_clear(SSL *s)
{
- ssl3_cleanup_key_block(s);
- OPENSSL_free(s->s3.tmp.ctype);
- sk_X509_NAME_pop_free(s->s3.tmp.peer_ca_names, X509_NAME_free);
- OPENSSL_free(s->s3.tmp.ciphers_raw);
- OPENSSL_clear_free(s->s3.tmp.pms, s->s3.tmp.pmslen);
- OPENSSL_free(s->s3.tmp.peer_sigalgs);
- OPENSSL_free(s->s3.tmp.peer_cert_sigalgs);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ ssl3_cleanup_key_block(sc);
+ OPENSSL_free(sc->s3.tmp.ctype);
+ sk_X509_NAME_pop_free(sc->s3.tmp.peer_ca_names, X509_NAME_free);
+ OPENSSL_free(sc->s3.tmp.ciphers_raw);
+ OPENSSL_clear_free(sc->s3.tmp.pms, sc->s3.tmp.pmslen);
+ OPENSSL_free(sc->s3.tmp.peer_sigalgs);
+ OPENSSL_free(sc->s3.tmp.peer_cert_sigalgs);
- EVP_PKEY_free(s->s3.tmp.pkey);
- EVP_PKEY_free(s->s3.peer_tmp);
+ EVP_PKEY_free(sc->s3.tmp.pkey);
+ EVP_PKEY_free(sc->s3.peer_tmp);
- ssl3_free_digest_list(s);
+ ssl3_free_digest_list(sc);
- OPENSSL_free(s->s3.alpn_selected);
- OPENSSL_free(s->s3.alpn_proposed);
+ OPENSSL_free(sc->s3.alpn_selected);
+ OPENSSL_free(sc->s3.alpn_proposed);
/* NULL/zero-out everything in the s3 struct */
- memset(&s->s3, 0, sizeof(s->s3));
+ memset(&sc->s3, 0, sizeof(sc->s3));
- if (!ssl_free_wbio_buffer(s))
+ if (!ssl_free_wbio_buffer(sc))
return 0;
- s->version = SSL3_VERSION;
+ sc->version = SSL3_VERSION;
#if !defined(OPENSSL_NO_NEXTPROTONEG)
- OPENSSL_free(s->ext.npn);
- s->ext.npn = NULL;
- s->ext.npn_len = 0;
+ OPENSSL_free(sc->ext.npn);
+ sc->ext.npn = NULL;
+ sc->ext.npn_len = 0;
#endif
return 1;
#ifndef OPENSSL_NO_SRP
static char *srp_password_from_info_cb(SSL *s, void *arg)
{
- return OPENSSL_strdup(s->srp_ctx.info);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return NULL;
+
+ return OPENSSL_strdup(sc->srp_ctx.info);
}
#endif
long ssl3_ctrl(SSL *s, int cmd, long larg, void *parg)
{
int ret = 0;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return ret;
switch (cmd) {
case SSL_CTRL_GET_CLIENT_CERT_REQUEST:
break;
case SSL_CTRL_GET_NUM_RENEGOTIATIONS:
- ret = s->s3.num_renegotiations;
+ ret = sc->s3.num_renegotiations;
break;
case SSL_CTRL_CLEAR_NUM_RENEGOTIATIONS:
- ret = s->s3.num_renegotiations;
- s->s3.num_renegotiations = 0;
+ ret = sc->s3.num_renegotiations;
+ sc->s3.num_renegotiations = 0;
break;
case SSL_CTRL_GET_TOTAL_RENEGOTIATIONS:
- ret = s->s3.total_renegotiations;
+ ret = sc->s3.total_renegotiations;
break;
case SSL_CTRL_GET_FLAGS:
- ret = (int)(s->s3.flags);
+ ret = (int)(sc->s3.flags);
break;
#if !defined(OPENSSL_NO_DEPRECATED_3_0)
case SSL_CTRL_SET_TMP_DH:
}
#endif
case SSL_CTRL_SET_DH_AUTO:
- s->cert->dh_tmp_auto = larg;
+ sc->cert->dh_tmp_auto = larg;
return 1;
#if !defined(OPENSSL_NO_DEPRECATED_3_0)
case SSL_CTRL_SET_TMP_ECDH:
ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
- return ssl_set_tmp_ecdh_groups(&s->ext.supportedgroups,
- &s->ext.supportedgroups_len,
+ return ssl_set_tmp_ecdh_groups(&sc->ext.supportedgroups,
+ &sc->ext.supportedgroups_len,
parg);
}
#endif /* !OPENSSL_NO_DEPRECATED_3_0 */
if (larg == TLSEXT_NAMETYPE_host_name) {
size_t len;
- OPENSSL_free(s->ext.hostname);
- s->ext.hostname = NULL;
+ OPENSSL_free(sc->ext.hostname);
+ sc->ext.hostname = NULL;
ret = 1;
if (parg == NULL)
ERR_raise(ERR_LIB_SSL, SSL_R_SSL3_EXT_INVALID_SERVERNAME);
return 0;
}
- if ((s->ext.hostname = OPENSSL_strdup((char *)parg)) == NULL) {
+ if ((sc->ext.hostname = OPENSSL_strdup((char *)parg)) == NULL) {
ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
return 0;
}
}
break;
case SSL_CTRL_SET_TLSEXT_DEBUG_ARG:
- s->ext.debug_arg = parg;
+ sc->ext.debug_arg = parg;
ret = 1;
break;
case SSL_CTRL_GET_TLSEXT_STATUS_REQ_TYPE:
- ret = s->ext.status_type;
+ ret = sc->ext.status_type;
break;
case SSL_CTRL_SET_TLSEXT_STATUS_REQ_TYPE:
- s->ext.status_type = larg;
+ sc->ext.status_type = larg;
ret = 1;
break;
case SSL_CTRL_GET_TLSEXT_STATUS_REQ_EXTS:
- *(STACK_OF(X509_EXTENSION) **)parg = s->ext.ocsp.exts;
+ *(STACK_OF(X509_EXTENSION) **)parg = sc->ext.ocsp.exts;
ret = 1;
break;
case SSL_CTRL_SET_TLSEXT_STATUS_REQ_EXTS:
- s->ext.ocsp.exts = parg;
+ sc->ext.ocsp.exts = parg;
ret = 1;
break;
case SSL_CTRL_GET_TLSEXT_STATUS_REQ_IDS:
- *(STACK_OF(OCSP_RESPID) **)parg = s->ext.ocsp.ids;
+ *(STACK_OF(OCSP_RESPID) **)parg = sc->ext.ocsp.ids;
ret = 1;
break;
case SSL_CTRL_SET_TLSEXT_STATUS_REQ_IDS:
- s->ext.ocsp.ids = parg;
+ sc->ext.ocsp.ids = parg;
ret = 1;
break;
case SSL_CTRL_GET_TLSEXT_STATUS_REQ_OCSP_RESP:
- *(unsigned char **)parg = s->ext.ocsp.resp;
- if (s->ext.ocsp.resp_len == 0
- || s->ext.ocsp.resp_len > LONG_MAX)
+ *(unsigned char **)parg = sc->ext.ocsp.resp;
+ if (sc->ext.ocsp.resp_len == 0
+ || sc->ext.ocsp.resp_len > LONG_MAX)
return -1;
- return (long)s->ext.ocsp.resp_len;
+ return (long)sc->ext.ocsp.resp_len;
case SSL_CTRL_SET_TLSEXT_STATUS_REQ_OCSP_RESP:
- OPENSSL_free(s->ext.ocsp.resp);
- s->ext.ocsp.resp = parg;
- s->ext.ocsp.resp_len = larg;
+ OPENSSL_free(sc->ext.ocsp.resp);
+ sc->ext.ocsp.resp = parg;
+ sc->ext.ocsp.resp_len = larg;
ret = 1;
break;
case SSL_CTRL_CHAIN:
if (larg)
- return ssl_cert_set1_chain(s, NULL, (STACK_OF(X509) *)parg);
+ return ssl_cert_set1_chain(sc, NULL, (STACK_OF(X509) *)parg);
else
- return ssl_cert_set0_chain(s, NULL, (STACK_OF(X509) *)parg);
+ return ssl_cert_set0_chain(sc, NULL, (STACK_OF(X509) *)parg);
case SSL_CTRL_CHAIN_CERT:
if (larg)
- return ssl_cert_add1_chain_cert(s, NULL, (X509 *)parg);
+ return ssl_cert_add1_chain_cert(sc, NULL, (X509 *)parg);
else
- return ssl_cert_add0_chain_cert(s, NULL, (X509 *)parg);
+ return ssl_cert_add0_chain_cert(sc, NULL, (X509 *)parg);
case SSL_CTRL_GET_CHAIN_CERTS:
- *(STACK_OF(X509) **)parg = s->cert->key->chain;
+ *(STACK_OF(X509) **)parg = sc->cert->key->chain;
ret = 1;
break;
case SSL_CTRL_SELECT_CURRENT_CERT:
- return ssl_cert_select_current(s->cert, (X509 *)parg);
+ return ssl_cert_select_current(sc->cert, (X509 *)parg);
case SSL_CTRL_SET_CURRENT_CERT:
if (larg == SSL_CERT_SET_SERVER) {
const SSL_CIPHER *cipher;
- if (!s->server)
+ if (!sc->server)
return 0;
- cipher = s->s3.tmp.new_cipher;
+ cipher = sc->s3.tmp.new_cipher;
if (cipher == NULL)
return 0;
/*
*/
if (cipher->algorithm_auth & (SSL_aNULL | SSL_aSRP))
return 2;
- if (s->s3.tmp.cert == NULL)
+ if (sc->s3.tmp.cert == NULL)
return 0;
- s->cert->key = s->s3.tmp.cert;
+ sc->cert->key = sc->s3.tmp.cert;
return 1;
}
- return ssl_cert_set_current(s->cert, larg);
+ return ssl_cert_set_current(sc->cert, larg);
case SSL_CTRL_GET_GROUPS:
{
uint16_t *clist;
size_t clistlen;
- if (!s->session)
+ if (!sc->session)
return 0;
- clist = s->ext.peer_supportedgroups;
- clistlen = s->ext.peer_supportedgroups_len;
+ clist = sc->ext.peer_supportedgroups;
+ clistlen = sc->ext.peer_supportedgroups_len;
if (parg) {
size_t i;
int *cptr = parg;
for (i = 0; i < clistlen; i++) {
- uint16_t cid = SSL_IS_TLS13(s)
+ uint16_t cid = SSL_CONNECTION_IS_TLS13(sc)
? ssl_group_id_tls13_to_internal(clist[i])
: clist[i];
const TLS_GROUP_INFO *cinf
}
case SSL_CTRL_SET_GROUPS:
- return tls1_set_groups(&s->ext.supportedgroups,
- &s->ext.supportedgroups_len, parg, larg);
+ return tls1_set_groups(&sc->ext.supportedgroups,
+ &sc->ext.supportedgroups_len, parg, larg);
case SSL_CTRL_SET_GROUPS_LIST:
- return tls1_set_groups_list(s->ctx, &s->ext.supportedgroups,
- &s->ext.supportedgroups_len, parg);
+ return tls1_set_groups_list(s->ctx, &sc->ext.supportedgroups,
+ &sc->ext.supportedgroups_len, parg);
case SSL_CTRL_GET_SHARED_GROUP:
{
- uint16_t id = tls1_shared_group(s, larg);
+ uint16_t id = tls1_shared_group(sc, larg);
if (larg != -1)
return tls1_group_id2nid(id, 1);
{
unsigned int id;
- if (SSL_IS_TLS13(s) && s->s3.did_kex)
- id = s->s3.group_id;
+ if (SSL_CONNECTION_IS_TLS13(sc) && sc->s3.did_kex)
+ id = sc->s3.group_id;
else
- id = s->session->kex_group;
+ id = sc->session->kex_group;
ret = tls1_group_id2nid(id, 1);
break;
}
case SSL_CTRL_SET_SIGALGS:
- return tls1_set_sigalgs(s->cert, parg, larg, 0);
+ return tls1_set_sigalgs(sc->cert, parg, larg, 0);
case SSL_CTRL_SET_SIGALGS_LIST:
- return tls1_set_sigalgs_list(s->cert, parg, 0);
+ return tls1_set_sigalgs_list(sc->cert, parg, 0);
case SSL_CTRL_SET_CLIENT_SIGALGS:
- return tls1_set_sigalgs(s->cert, parg, larg, 1);
+ return tls1_set_sigalgs(sc->cert, parg, larg, 1);
case SSL_CTRL_SET_CLIENT_SIGALGS_LIST:
- return tls1_set_sigalgs_list(s->cert, parg, 1);
+ return tls1_set_sigalgs_list(sc->cert, parg, 1);
case SSL_CTRL_GET_CLIENT_CERT_TYPES:
{
const unsigned char **pctype = parg;
- if (s->server || !s->s3.tmp.cert_req)
+ if (sc->server || !sc->s3.tmp.cert_req)
return 0;
if (pctype)
- *pctype = s->s3.tmp.ctype;
- return s->s3.tmp.ctype_len;
+ *pctype = sc->s3.tmp.ctype;
+ return sc->s3.tmp.ctype_len;
}
case SSL_CTRL_SET_CLIENT_CERT_TYPES:
- if (!s->server)
+ if (!sc->server)
return 0;
- return ssl3_set_req_cert_type(s->cert, parg, larg);
+ return ssl3_set_req_cert_type(sc->cert, parg, larg);
case SSL_CTRL_BUILD_CERT_CHAIN:
- return ssl_build_cert_chain(s, NULL, larg);
+ return ssl_build_cert_chain(sc, NULL, larg);
case SSL_CTRL_SET_VERIFY_CERT_STORE:
- return ssl_cert_set_cert_store(s->cert, parg, 0, larg);
+ return ssl_cert_set_cert_store(sc->cert, parg, 0, larg);
case SSL_CTRL_SET_CHAIN_CERT_STORE:
- return ssl_cert_set_cert_store(s->cert, parg, 1, larg);
+ return ssl_cert_set_cert_store(sc->cert, parg, 1, larg);
case SSL_CTRL_GET_VERIFY_CERT_STORE:
- return ssl_cert_get_cert_store(s->cert, parg, 0);
+ return ssl_cert_get_cert_store(sc->cert, parg, 0);
case SSL_CTRL_GET_CHAIN_CERT_STORE:
- return ssl_cert_get_cert_store(s->cert, parg, 1);
+ return ssl_cert_get_cert_store(sc->cert, parg, 1);
case SSL_CTRL_GET_PEER_SIGNATURE_NID:
- if (s->s3.tmp.peer_sigalg == NULL)
+ if (sc->s3.tmp.peer_sigalg == NULL)
return 0;
- *(int *)parg = s->s3.tmp.peer_sigalg->hash;
+ *(int *)parg = sc->s3.tmp.peer_sigalg->hash;
return 1;
case SSL_CTRL_GET_SIGNATURE_NID:
- if (s->s3.tmp.sigalg == NULL)
+ if (sc->s3.tmp.sigalg == NULL)
return 0;
- *(int *)parg = s->s3.tmp.sigalg->hash;
+ *(int *)parg = sc->s3.tmp.sigalg->hash;
return 1;
case SSL_CTRL_GET_PEER_TMP_KEY:
- if (s->session == NULL || s->s3.peer_tmp == NULL) {
+ if (sc->session == NULL || sc->s3.peer_tmp == NULL) {
return 0;
} else {
- EVP_PKEY_up_ref(s->s3.peer_tmp);
- *(EVP_PKEY **)parg = s->s3.peer_tmp;
+ EVP_PKEY_up_ref(sc->s3.peer_tmp);
+ *(EVP_PKEY **)parg = sc->s3.peer_tmp;
return 1;
}
case SSL_CTRL_GET_TMP_KEY:
- if (s->session == NULL || s->s3.tmp.pkey == NULL) {
+ if (sc->session == NULL || sc->s3.tmp.pkey == NULL) {
return 0;
} else {
- EVP_PKEY_up_ref(s->s3.tmp.pkey);
- *(EVP_PKEY **)parg = s->s3.tmp.pkey;
+ EVP_PKEY_up_ref(sc->s3.tmp.pkey);
+ *(EVP_PKEY **)parg = sc->s3.tmp.pkey;
return 1;
}
{
const unsigned char **pformat = parg;
- if (s->ext.peer_ecpointformats == NULL)
+ if (sc->ext.peer_ecpointformats == NULL)
return 0;
- *pformat = s->ext.peer_ecpointformats;
- return (int)s->ext.peer_ecpointformats_len;
+ *pformat = sc->ext.peer_ecpointformats;
+ return (int)sc->ext.peer_ecpointformats_len;
}
case SSL_CTRL_GET_IANA_GROUPS:
{
if (parg != NULL) {
- *(uint16_t **)parg = (uint16_t *)s->ext.peer_supportedgroups;
+ *(uint16_t **)parg = (uint16_t *)sc->ext.peer_supportedgroups;
}
- return (int)s->ext.peer_supportedgroups_len;
+ return (int)sc->ext.peer_supportedgroups_len;
}
default:
long ssl3_callback_ctrl(SSL *s, int cmd, void (*fp) (void))
{
int ret = 0;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return ret;
switch (cmd) {
#if !defined(OPENSSL_NO_DEPRECATED_3_0)
case SSL_CTRL_SET_TMP_DH_CB:
- s->cert->dh_tmp_cb = (DH *(*)(SSL *, int, int))fp;
+ sc->cert->dh_tmp_cb = (DH *(*)(SSL *, int, int))fp;
ret = 1;
break;
#endif
case SSL_CTRL_SET_TLSEXT_DEBUG_CB:
- s->ext.debug_cb = (void (*)(SSL *, int, int,
- const unsigned char *, int, void *))fp;
+ sc->ext.debug_cb = (void (*)(SSL *, int, int,
+ const unsigned char *, int, void *))fp;
ret = 1;
break;
case SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB:
- s->not_resumable_session_cb = (int (*)(SSL *, int))fp;
+ sc->not_resumable_session_cb = (int (*)(SSL *, int))fp;
ret = 1;
break;
default:
# ifndef OPENSSL_NO_DEPRECATED_3_0
case SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB:
ctx->ext.ticket_key_cb = (int (*)(SSL *, unsigned char *,
- unsigned char *,
- EVP_CIPHER_CTX *,
- HMAC_CTX *, int))fp;
+ unsigned char *,
+ EVP_CIPHER_CTX *,
+ HMAC_CTX *, int))fp;
break;
#endif
*
* Returns the selected cipher or NULL when no common ciphers.
*/
-const SSL_CIPHER *ssl3_choose_cipher(SSL *s, STACK_OF(SSL_CIPHER) *clnt,
+const SSL_CIPHER *ssl3_choose_cipher(SSL_CONNECTION *s, STACK_OF(SSL_CIPHER) *clnt,
STACK_OF(SSL_CIPHER) *srvr)
{
const SSL_CIPHER *c, *ret = NULL;
allow = srvr;
}
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
#ifndef OPENSSL_NO_PSK
int j;
c = sk_SSL_CIPHER_value(prio, i);
/* Skip ciphers not supported by the protocol version */
- if (!SSL_IS_DTLS(s) &&
+ if (!SSL_CONNECTION_IS_DTLS(s) &&
((s->version < c->min_tls) || (s->version > c->max_tls)))
continue;
- if (SSL_IS_DTLS(s) &&
+ if (SSL_CONNECTION_IS_DTLS(s) &&
(DTLS_VERSION_LT(s->version, c->min_dtls) ||
DTLS_VERSION_GT(s->version, c->max_dtls)))
continue;
* Since TLS 1.3 ciphersuites can be used with any auth or
* key exchange scheme skip tests.
*/
- if (!SSL_IS_TLS13(s)) {
+ if (!SSL_CONNECTION_IS_TLS13(s)) {
mask_k = s->s3.tmp.mask_k;
mask_a = s->s3.tmp.mask_a;
#ifndef OPENSSL_NO_SRP
if (prefer_sha256) {
const SSL_CIPHER *tmp = sk_SSL_CIPHER_value(allow, ii);
- const EVP_MD *md = ssl_md(s->ctx, tmp->algorithm2);
+ const EVP_MD *md = ssl_md(SSL_CONNECTION_GET_CTX(s),
+ tmp->algorithm2);
if (md != NULL
&& EVP_MD_is_a(md, OSSL_DIGEST_NAME_SHA2_256)) {
return ret;
}
-int ssl3_get_req_cert_type(SSL *s, WPACKET *pkt)
+int ssl3_get_req_cert_type(SSL_CONNECTION *s, WPACKET *pkt)
{
uint32_t alg_k, alg_a = 0;
int ssl3_shutdown(SSL *s)
{
int ret;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
+
+ if (sc == NULL)
+ return 0;
/*
* Don't do anything much if we have not done the handshake or we don't
* want to send messages :-)
*/
- if (s->quiet_shutdown || SSL_in_before(s)) {
- s->shutdown = (SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
+ if (sc->quiet_shutdown || SSL_in_before(s)) {
+ sc->shutdown = (SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
return 1;
}
- if (!(s->shutdown & SSL_SENT_SHUTDOWN)) {
- s->shutdown |= SSL_SENT_SHUTDOWN;
- ssl3_send_alert(s, SSL3_AL_WARNING, SSL_AD_CLOSE_NOTIFY);
+ if (!(sc->shutdown & SSL_SENT_SHUTDOWN)) {
+ sc->shutdown |= SSL_SENT_SHUTDOWN;
+ ssl3_send_alert(sc, SSL3_AL_WARNING, SSL_AD_CLOSE_NOTIFY);
/*
* our shutdown alert has been sent now, and if it still needs to be
* written, s->s3.alert_dispatch will be true
*/
- if (s->s3.alert_dispatch)
+ if (sc->s3.alert_dispatch)
return -1; /* return WANT_WRITE */
- } else if (s->s3.alert_dispatch) {
+ } else if (sc->s3.alert_dispatch) {
/* resend it if not sent */
ret = s->method->ssl_dispatch_alert(s);
if (ret == -1) {
*/
return ret;
}
- } else if (!(s->shutdown & SSL_RECEIVED_SHUTDOWN)) {
+ } else if (!(sc->shutdown & SSL_RECEIVED_SHUTDOWN)) {
size_t readbytes;
/*
* If we are waiting for a close from our peer, we are closed
*/
s->method->ssl_read_bytes(s, 0, NULL, NULL, 0, 0, &readbytes);
- if (!(s->shutdown & SSL_RECEIVED_SHUTDOWN)) {
+ if (!(sc->shutdown & SSL_RECEIVED_SHUTDOWN)) {
return -1; /* return WANT_READ */
}
}
- if ((s->shutdown == (SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN)) &&
- !s->s3.alert_dispatch)
+ if ((sc->shutdown == (SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN)) &&
+ !sc->s3.alert_dispatch)
return 1;
else
return 0;
int ssl3_write(SSL *s, const void *buf, size_t len, size_t *written)
{
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
+
+ if (sc == NULL)
+ return 0;
+
clear_sys_error();
- if (s->s3.renegotiate)
+ if (sc->s3.renegotiate)
ssl3_renegotiate_check(s, 0);
return s->method->ssl_write_bytes(s, SSL3_RT_APPLICATION_DATA, buf, len,
size_t *readbytes)
{
int ret;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
+
+ if (sc == NULL)
+ return 0;
clear_sys_error();
- if (s->s3.renegotiate)
+ if (sc->s3.renegotiate)
ssl3_renegotiate_check(s, 0);
- s->s3.in_read_app_data = 1;
+ sc->s3.in_read_app_data = 1;
ret =
s->method->ssl_read_bytes(s, SSL3_RT_APPLICATION_DATA, NULL, buf, len,
peek, readbytes);
- if ((ret == -1) && (s->s3.in_read_app_data == 2)) {
+ if ((ret == -1) && (sc->s3.in_read_app_data == 2)) {
/*
* ssl3_read_bytes decided to call s->handshake_func, which called
* ssl3_read_bytes to read handshake data. However, ssl3_read_bytes
* makes sense here; so disable handshake processing and try to read
* application data again.
*/
- ossl_statem_set_in_handshake(s, 1);
+ ossl_statem_set_in_handshake(sc, 1);
ret =
s->method->ssl_read_bytes(s, SSL3_RT_APPLICATION_DATA, NULL, buf,
len, peek, readbytes);
- ossl_statem_set_in_handshake(s, 0);
+ ossl_statem_set_in_handshake(sc, 0);
} else
- s->s3.in_read_app_data = 0;
+ sc->s3.in_read_app_data = 0;
return ret;
}
int ssl3_renegotiate(SSL *s)
{
- if (s->handshake_func == NULL)
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
+
+ if (sc == NULL)
+ return 0;
+
+ if (sc->handshake_func == NULL)
return 1;
- s->s3.renegotiate = 1;
+ sc->s3.renegotiate = 1;
return 1;
}
int ssl3_renegotiate_check(SSL *s, int initok)
{
int ret = 0;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
- if (s->s3.renegotiate) {
- if (!RECORD_LAYER_read_pending(&s->rlayer)
- && !RECORD_LAYER_write_pending(&s->rlayer)
+ if (sc == NULL)
+ return 0;
+
+ if (sc->s3.renegotiate) {
+ if (!RECORD_LAYER_read_pending(&sc->rlayer)
+ && !RECORD_LAYER_write_pending(&sc->rlayer)
&& (initok || !SSL_in_init(s))) {
/*
* if we are the server, and we have sent a 'RENEGOTIATE'
* message, we need to set the state machine into the renegotiate
* state.
*/
- ossl_statem_set_renegotiate(s);
- s->s3.renegotiate = 0;
- s->s3.num_renegotiations++;
- s->s3.total_renegotiations++;
+ ossl_statem_set_renegotiate(sc);
+ sc->s3.renegotiate = 0;
+ sc->s3.num_renegotiations++;
+ sc->s3.total_renegotiations++;
ret = 1;
}
}
*
* If PSK and using SHA384 for TLS < 1.2 switch to default.
*/
-long ssl_get_algorithm2(SSL *s)
+long ssl_get_algorithm2(SSL_CONNECTION *s)
{
long alg2;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
+
if (s->s3.tmp.new_cipher == NULL)
return -1;
alg2 = s->s3.tmp.new_cipher->algorithm2;
- if (s->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_SHA256_PRF) {
+ if (ssl->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_SHA256_PRF) {
if (alg2 == (SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF))
return SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256;
} else if (s->s3.tmp.new_cipher->algorithm_mkey & SSL_PSK) {
* Fill a ClientRandom or ServerRandom field of length len. Returns <= 0 on
* failure, 1 on success.
*/
-int ssl_fill_hello_random(SSL *s, int server, unsigned char *result, size_t len,
+int ssl_fill_hello_random(SSL_CONNECTION *s, int server,
+ unsigned char *result, size_t len,
DOWNGRADE dgrd)
{
int send_time = 0, ret;
unsigned char *p = result;
l2n(Time, p);
- ret = RAND_bytes_ex(s->ctx->libctx, p, len - 4, 0);
+ ret = RAND_bytes_ex(SSL_CONNECTION_GET_CTX(s)->libctx, p, len - 4, 0);
} else {
- ret = RAND_bytes_ex(s->ctx->libctx, result, len, 0);
+ ret = RAND_bytes_ex(SSL_CONNECTION_GET_CTX(s)->libctx, result, len, 0);
}
if (ret > 0) {
return ret;
}
-int ssl_generate_master_secret(SSL *s, unsigned char *pms, size_t pmslen,
- int free_pms)
+int ssl_generate_master_secret(SSL_CONNECTION *s, unsigned char *pms,
+ size_t pmslen, int free_pms)
{
unsigned long alg_k = s->s3.tmp.new_cipher->algorithm_mkey;
int ret = 0;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
if (alg_k & SSL_PSK) {
#ifndef OPENSSL_NO_PSK
OPENSSL_clear_free(s->s3.tmp.psk, psklen);
s->s3.tmp.psk = NULL;
s->s3.tmp.psklen = 0;
- if (!s->method->ssl3_enc->generate_master_secret(s,
+ if (!ssl->method->ssl3_enc->generate_master_secret(s,
s->session->master_key, pskpms, pskpmslen,
&s->session->master_key_length)) {
OPENSSL_clear_free(pskpms, pskpmslen);
goto err;
#endif
} else {
- if (!s->method->ssl3_enc->generate_master_secret(s,
+ if (!ssl->method->ssl3_enc->generate_master_secret(s,
s->session->master_key, pms, pmslen,
&s->session->master_key_length)) {
/* SSLfatal() already called */
}
/* Generate a private key from parameters */
-EVP_PKEY *ssl_generate_pkey(SSL *s, EVP_PKEY *pm)
+EVP_PKEY *ssl_generate_pkey(SSL_CONNECTION *s, EVP_PKEY *pm)
{
EVP_PKEY_CTX *pctx = NULL;
EVP_PKEY *pkey = NULL;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
if (pm == NULL)
return NULL;
- pctx = EVP_PKEY_CTX_new_from_pkey(s->ctx->libctx, pm, s->ctx->propq);
+ pctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, pm, sctx->propq);
if (pctx == NULL)
goto err;
if (EVP_PKEY_keygen_init(pctx) <= 0)
}
/* Generate a private key from a group ID */
-EVP_PKEY *ssl_generate_pkey_group(SSL *s, uint16_t id)
+EVP_PKEY *ssl_generate_pkey_group(SSL_CONNECTION *s, uint16_t id)
{
- const TLS_GROUP_INFO *ginf = tls1_group_id_lookup(s->ctx, id);
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
+ const TLS_GROUP_INFO *ginf = tls1_group_id_lookup(sctx, id);
EVP_PKEY_CTX *pctx = NULL;
EVP_PKEY *pkey = NULL;
goto err;
}
- pctx = EVP_PKEY_CTX_new_from_name(s->ctx->libctx, ginf->algorithm,
- s->ctx->propq);
+ pctx = EVP_PKEY_CTX_new_from_name(sctx->libctx, ginf->algorithm,
+ sctx->propq);
if (pctx == NULL) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
/*
* Generate parameters from a group ID
*/
-EVP_PKEY *ssl_generate_param_group(SSL *s, uint16_t id)
+EVP_PKEY *ssl_generate_param_group(SSL_CONNECTION *s, uint16_t id)
{
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
EVP_PKEY_CTX *pctx = NULL;
EVP_PKEY *pkey = NULL;
- const TLS_GROUP_INFO *ginf = tls1_group_id_lookup(s->ctx, id);
+ const TLS_GROUP_INFO *ginf = tls1_group_id_lookup(sctx, id);
if (ginf == NULL)
goto err;
- pctx = EVP_PKEY_CTX_new_from_name(s->ctx->libctx, ginf->algorithm,
- s->ctx->propq);
+ pctx = EVP_PKEY_CTX_new_from_name(sctx->libctx, ginf->algorithm,
+ sctx->propq);
if (pctx == NULL)
goto err;
}
/* Generate secrets from pms */
-int ssl_gensecret(SSL *s, unsigned char *pms, size_t pmslen)
+int ssl_gensecret(SSL_CONNECTION *s, unsigned char *pms, size_t pmslen)
{
int rv = 0;
/* SSLfatal() called as appropriate in the below functions */
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
/*
* If we are resuming then we already generated the early secret
* when we created the ClientHello, so don't recreate it.
}
/* Derive secrets for ECDH/DH */
-int ssl_derive(SSL *s, EVP_PKEY *privkey, EVP_PKEY *pubkey, int gensecret)
+int ssl_derive(SSL_CONNECTION *s, EVP_PKEY *privkey, EVP_PKEY *pubkey, int gensecret)
{
int rv = 0;
unsigned char *pms = NULL;
size_t pmslen = 0;
EVP_PKEY_CTX *pctx;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
if (privkey == NULL || pubkey == NULL) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return 0;
}
- pctx = EVP_PKEY_CTX_new_from_pkey(s->ctx->libctx, privkey, s->ctx->propq);
+ pctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, privkey, sctx->propq);
if (EVP_PKEY_derive_init(pctx) <= 0
|| EVP_PKEY_derive_set_peer(pctx, pubkey) <= 0
goto err;
}
- if (SSL_IS_TLS13(s) && EVP_PKEY_is_a(privkey, "DH"))
+ if (SSL_CONNECTION_IS_TLS13(s) && EVP_PKEY_is_a(privkey, "DH"))
EVP_PKEY_CTX_set_dh_pad(pctx, 1);
pms = OPENSSL_malloc(pmslen);
}
/* Decapsulate secrets for KEM */
-int ssl_decapsulate(SSL *s, EVP_PKEY *privkey,
+int ssl_decapsulate(SSL_CONNECTION *s, EVP_PKEY *privkey,
const unsigned char *ct, size_t ctlen,
int gensecret)
{
unsigned char *pms = NULL;
size_t pmslen = 0;
EVP_PKEY_CTX *pctx;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
if (privkey == NULL) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return 0;
}
- pctx = EVP_PKEY_CTX_new_from_pkey(s->ctx->libctx, privkey, s->ctx->propq);
+ pctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, privkey, sctx->propq);
if (EVP_PKEY_decapsulate_init(pctx, NULL) <= 0
|| EVP_PKEY_decapsulate(pctx, NULL, &pmslen, ct, ctlen) <= 0) {
return rv;
}
-int ssl_encapsulate(SSL *s, EVP_PKEY *pubkey,
+int ssl_encapsulate(SSL_CONNECTION *s, EVP_PKEY *pubkey,
unsigned char **ctp, size_t *ctlenp,
int gensecret)
{
unsigned char *pms = NULL, *ct = NULL;
size_t pmslen = 0, ctlen = 0;
EVP_PKEY_CTX *pctx;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
if (pubkey == NULL) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return 0;
}
- pctx = EVP_PKEY_CTX_new_from_pkey(s->ctx->libctx, pubkey, s->ctx->propq);
+ pctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, pubkey, sctx->propq);
if (EVP_PKEY_encapsulate_init(pctx, NULL) <= 0
|| EVP_PKEY_encapsulate(pctx, NULL, &ctlen, NULL, &pmslen) <= 0
#include "ssl_local.h"
-int ssl3_do_change_cipher_spec(SSL *s)
+int ssl3_do_change_cipher_spec(SSL_CONNECTION *s)
{
int i;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
if (s->server)
i = SSL3_CHANGE_CIPHER_SERVER_READ;
}
s->session->cipher = s->s3.tmp.new_cipher;
- if (!s->method->ssl3_enc->setup_key_block(s)) {
+ if (!ssl->method->ssl3_enc->setup_key_block(s)) {
/* SSLfatal() already called */
return 0;
}
}
- if (!s->method->ssl3_enc->change_cipher_state(s, i)) {
+ if (!ssl->method->ssl3_enc->change_cipher_state(s, i)) {
/* SSLfatal() already called */
return 0;
}
return 1;
}
-int ssl3_send_alert(SSL *s, int level, int desc)
+int ssl3_send_alert(SSL_CONNECTION *s, int level, int desc)
{
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
+
/* Map tls/ssl alert value to correct one */
- if (SSL_TREAT_AS_TLS13(s))
+ if (SSL_CONNECTION_TREAT_AS_TLS13(s))
desc = tls13_alert_code(desc);
else
- desc = s->method->ssl3_enc->alert_value(desc);
+ desc = ssl->method->ssl3_enc->alert_value(desc);
if (s->version == SSL3_VERSION && desc == SSL_AD_PROTOCOL_VERSION)
desc = SSL_AD_HANDSHAKE_FAILURE; /* SSL 3.0 does not have
* protocol_version alerts */
s->s3.send_alert[1] = desc;
if (!RECORD_LAYER_write_pending(&s->rlayer)) {
/* data still being written out? */
- return s->method->ssl_dispatch_alert(s);
+ return ssl->method->ssl_dispatch_alert(ssl);
}
/*
* else data is still being written out, we will get written some time in
size_t alertlen;
void (*cb) (const SSL *ssl, int type, int val) = NULL;
size_t written;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return -1;
- s->s3.alert_dispatch = 0;
+ sc->s3.alert_dispatch = 0;
alertlen = 2;
- i = do_ssl3_write(s, SSL3_RT_ALERT, &s->s3.send_alert[0], &alertlen, 1, 0,
+ i = do_ssl3_write(sc, SSL3_RT_ALERT, &sc->s3.send_alert[0], &alertlen, 1, 0,
&written);
if (i <= 0) {
- s->s3.alert_dispatch = 1;
+ sc->s3.alert_dispatch = 1;
} else {
/*
* Alert sent to BIO - now flush. If the message does not get sent due
* to non-blocking IO, we will not worry too much.
*/
- (void)BIO_flush(s->wbio);
+ (void)BIO_flush(sc->wbio);
- if (s->msg_callback)
- s->msg_callback(1, s->version, SSL3_RT_ALERT, s->s3.send_alert,
- 2, s, s->msg_callback_arg);
+ if (sc->msg_callback)
+ sc->msg_callback(1, sc->version, SSL3_RT_ALERT, sc->s3.send_alert,
+ 2, s, sc->msg_callback_arg);
- if (s->info_callback != NULL)
- cb = s->info_callback;
+ if (sc->info_callback != NULL)
+ cb = sc->info_callback;
else if (s->ctx->info_callback != NULL)
cb = s->ctx->info_callback;
if (cb != NULL) {
- j = (s->s3.send_alert[0] << 8) | s->s3.send_alert[1];
+ j = (sc->s3.send_alert[0] << 8) | sc->s3.send_alert[1];
cb(s, SSL_CB_WRITE_ALERT, j);
}
}
OPENSSL_free(c);
}
-int ssl_cert_set0_chain(SSL *s, SSL_CTX *ctx, STACK_OF(X509) *chain)
+int ssl_cert_set0_chain(SSL_CONNECTION *s, SSL_CTX *ctx, STACK_OF(X509) *chain)
{
int i, r;
CERT_PKEY *cpk = s != NULL ? s->cert->key : ctx->cert->key;
return 1;
}
-int ssl_cert_set1_chain(SSL *s, SSL_CTX *ctx, STACK_OF(X509) *chain)
+int ssl_cert_set1_chain(SSL_CONNECTION *s, SSL_CTX *ctx, STACK_OF(X509) *chain)
{
STACK_OF(X509) *dchain;
if (!chain)
return 1;
}
-int ssl_cert_add0_chain_cert(SSL *s, SSL_CTX *ctx, X509 *x)
+int ssl_cert_add0_chain_cert(SSL_CONNECTION *s, SSL_CTX *ctx, X509 *x)
{
int r;
CERT_PKEY *cpk = s ? s->cert->key : ctx->cert->key;
return 1;
}
-int ssl_cert_add1_chain_cert(SSL *s, SSL_CTX *ctx, X509 *x)
+int ssl_cert_add1_chain_cert(SSL_CONNECTION *s, SSL_CTX *ctx, X509 *x)
{
if (!ssl_cert_add0_chain_cert(s, ctx, x))
return 0;
* 0: Verify failure or error
* -1: Retry required
*/
-int ssl_verify_cert_chain(SSL *s, STACK_OF(X509) *sk)
+int ssl_verify_cert_chain(SSL_CONNECTION *s, STACK_OF(X509) *sk)
{
X509 *x;
int i = 0;
X509_STORE *verify_store;
X509_STORE_CTX *ctx = NULL;
X509_VERIFY_PARAM *param;
+ SSL_CTX *sctx;
if ((sk == NULL) || (sk_X509_num(sk) == 0))
return 0;
+ sctx = SSL_CONNECTION_GET_CTX(s);
if (s->cert->verify_store)
verify_store = s->cert->verify_store;
else
- verify_store = s->ctx->cert_store;
+ verify_store = sctx->cert_store;
- ctx = X509_STORE_CTX_new_ex(s->ctx->libctx, s->ctx->propq);
+ ctx = X509_STORE_CTX_new_ex(sctx->libctx, sctx->propq);
if (ctx == NULL) {
ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
return 0;
* point, for now a single @SECLEVEL sets the same policy for TLS crypto
* and PKI authentication.
*/
- X509_VERIFY_PARAM_set_auth_level(param, SSL_get_security_level(s));
+ X509_VERIFY_PARAM_set_auth_level(param,
+ SSL_get_security_level(SSL_CONNECTION_GET_SSL(s)));
/* Set suite B flags if needed */
X509_STORE_CTX_set_flags(ctx, tls1_suiteb(s));
- if (!X509_STORE_CTX_set_ex_data
- (ctx, SSL_get_ex_data_X509_STORE_CTX_idx(), s)) {
+ if (!X509_STORE_CTX_set_ex_data(ctx,
+ SSL_get_ex_data_X509_STORE_CTX_idx(), s)) {
goto end;
}
if (s->verify_callback)
X509_STORE_CTX_set_verify_cb(ctx, s->verify_callback);
- if (s->ctx->app_verify_callback != NULL) {
- i = s->ctx->app_verify_callback(ctx, s->ctx->app_verify_arg);
+ if (sctx->app_verify_callback != NULL) {
+ i = sctx->app_verify_callback(ctx, sctx->app_verify_arg);
} else {
i = X509_verify_cert(ctx);
/* We treat an error in the same way as a failure to verify */
void SSL_set0_CA_list(SSL *s, STACK_OF(X509_NAME) *name_list)
{
- set0_CA_list(&s->ca_names, name_list);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return;
+
+ set0_CA_list(&sc->ca_names, name_list);
}
void SSL_CTX_set0_CA_list(SSL_CTX *ctx, STACK_OF(X509_NAME) *name_list)
const STACK_OF(X509_NAME) *SSL_get0_CA_list(const SSL *s)
{
- return s->ca_names != NULL ? s->ca_names : s->ctx->ca_names;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return NULL;
+
+ return sc->ca_names != NULL ? sc->ca_names : s->ctx->ca_names;
}
void SSL_CTX_set_client_CA_list(SSL_CTX *ctx, STACK_OF(X509_NAME) *name_list)
void SSL_set_client_CA_list(SSL *s, STACK_OF(X509_NAME) *name_list)
{
- set0_CA_list(&s->client_ca_names, name_list);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return;
+
+ set0_CA_list(&sc->client_ca_names, name_list);
}
const STACK_OF(X509_NAME) *SSL_get0_peer_CA_list(const SSL *s)
{
- return s->s3.tmp.peer_ca_names;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return NULL;
+
+ return sc->s3.tmp.peer_ca_names;
}
STACK_OF(X509_NAME) *SSL_get_client_CA_list(const SSL *s)
{
- if (!s->server)
- return s->s3.tmp.peer_ca_names;
- return s->client_ca_names != NULL ? s->client_ca_names
- : s->ctx->client_ca_names;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return NULL;
+
+ if (!sc->server)
+ return sc->s3.tmp.peer_ca_names;
+ return sc->client_ca_names != NULL ? sc->client_ca_names
+ : s->ctx->client_ca_names;
}
static int add_ca_name(STACK_OF(X509_NAME) **sk, const X509 *x)
int SSL_add1_to_CA_list(SSL *ssl, const X509 *x)
{
- return add_ca_name(&ssl->ca_names, x);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
+
+ if (sc == NULL)
+ return 0;
+
+ return add_ca_name(&sc->ca_names, x);
}
int SSL_CTX_add1_to_CA_list(SSL_CTX *ctx, const X509 *x)
*/
int SSL_add_client_CA(SSL *ssl, X509 *x)
{
- return add_ca_name(&ssl->client_ca_names, x);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
+
+ if (sc == NULL)
+ return 0;
+
+ return add_ca_name(&sc->client_ca_names, x);
}
int SSL_CTX_add_client_CA(SSL_CTX *ctx, X509 *x)
}
/* Build a certificate chain for current certificate */
-int ssl_build_cert_chain(SSL *s, SSL_CTX *ctx, int flags)
+int ssl_build_cert_chain(SSL_CONNECTION *s, SSL_CTX *ctx, int flags)
{
- CERT *c = s ? s->cert : ctx->cert;
+ CERT *c = s != NULL ? s->cert : ctx->cert;
CERT_PKEY *cpk = c->key;
X509_STORE *chain_store = NULL;
X509_STORE_CTX *xs_ctx = NULL;
STACK_OF(X509) *chain = NULL, *untrusted = NULL;
X509 *x;
- SSL_CTX *real_ctx = (s == NULL) ? ctx : s->ctx;
+ SSL_CTX *real_ctx = (s == NULL) ? ctx : SSL_CONNECTION_GET_CTX(s);
int i, rv = 0;
- if (!cpk->x509) {
+ if (cpk->x509 == NULL) {
ERR_raise(ERR_LIB_SSL, SSL_R_NO_CERTIFICATE_SET);
goto err;
}
if (!X509_STORE_add_cert(chain_store, cpk->x509))
goto err;
} else {
- if (c->chain_store)
+ if (c->chain_store != NULL)
chain_store = c->chain_store;
- else if (s)
- chain_store = s->ctx->cert_store;
else
- chain_store = ctx->cert_store;
+ chain_store = real_ctx->cert_store;
if (flags & SSL_BUILD_CHAIN_FLAG_UNTRUSTED)
untrusted = cpk->chain;
void *ex)
{
int level, minbits, pfs_mask;
+ const SSL_CONNECTION *sc;
minbits = ssl_get_security_level_bits(s, ctx, &level);
break;
}
case SSL_SECOP_VERSION:
- if (!SSL_IS_DTLS(s)) {
+ if ((sc = SSL_CONNECTION_FROM_CONST_SSL(s)) == NULL)
+ return 0;
+ if (!SSL_CONNECTION_IS_DTLS(sc)) {
/* SSLv3, TLS v1.0 and TLS v1.1 only allowed at level 0 */
if (nid <= TLS1_1_VERSION && level > 0)
return 0;
return 1;
}
-int ssl_security(const SSL *s, int op, int bits, int nid, void *other)
+int ssl_security(const SSL_CONNECTION *s, int op, int bits, int nid, void *other)
{
- return s->cert->sec_cb(s, NULL, op, bits, nid, other, s->cert->sec_ex);
+ return s->cert->sec_cb(SSL_CONNECTION_GET_SSL(s), NULL, op, bits, nid,
+ other, s->cert->sec_ex);
}
int ssl_ctx_security(const SSL_CTX *ctx, int op, int bits, int nid, void *other)
return ctx->ssl_digest_methods[idx];
}
-const EVP_MD *ssl_handshake_md(SSL *s)
+const EVP_MD *ssl_handshake_md(SSL_CONNECTION *s)
{
- return ssl_md(s->ctx, ssl_get_algorithm2(s));
+ return ssl_md(SSL_CONNECTION_GET_CTX(s), ssl_get_algorithm2(s));
}
-const EVP_MD *ssl_prf_md(SSL *s)
+const EVP_MD *ssl_prf_md(SSL_CONNECTION *s)
{
- return ssl_md(s->ctx, ssl_get_algorithm2(s) >> TLS1_PRF_DGST_SHIFT);
+ return ssl_md(SSL_CONNECTION_GET_CTX(s),
+ ssl_get_algorithm2(s) >> TLS1_PRF_DGST_SHIFT);
}
#define ITEM_SEP(a) \
int SSL_set_ciphersuites(SSL *s, const char *str)
{
STACK_OF(SSL_CIPHER) *cipher_list;
- int ret = set_ciphersuites(&(s->tls13_ciphersuites), str);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+ int ret;
- if (s->cipher_list == NULL) {
+ if (sc == NULL)
+ return 0;
+
+ ret = set_ciphersuites(&(sc->tls13_ciphersuites), str);
+
+ if (sc->cipher_list == NULL) {
if ((cipher_list = SSL_get_ciphers(s)) != NULL)
- s->cipher_list = sk_SSL_CIPHER_dup(cipher_list);
+ sc->cipher_list = sk_SSL_CIPHER_dup(cipher_list);
}
- if (ret && s->cipher_list != NULL)
- return update_cipher_list(s->ctx, &s->cipher_list, &s->cipher_list_by_id,
- s->tls13_ciphersuites);
+ if (ret && sc->cipher_list != NULL)
+ return update_cipher_list(s->ctx, &sc->cipher_list,
+ &sc->cipher_list_by_id,
+ sc->tls13_ciphersuites);
return ret;
}
#endif
}
-const SSL_CIPHER *ssl_get_cipher_by_char(SSL *ssl, const unsigned char *ptr,
+const SSL_CIPHER *ssl_get_cipher_by_char(SSL_CONNECTION *s,
+ const unsigned char *ptr,
int all)
{
- const SSL_CIPHER *c = ssl->method->get_cipher_by_char(ptr);
+ const SSL_CIPHER *c = SSL_CONNECTION_GET_SSL(s)->method->get_cipher_by_char(ptr);
if (c == NULL || (!all && c->valid == 0))
return NULL;
{
int rv = 1;
CERT *c = NULL;
- if (cctx->ctx) {
+ if (cctx->ctx != NULL) {
rv = SSL_CTX_use_certificate_chain_file(cctx->ctx, value);
c = cctx->ctx->cert;
}
- if (cctx->ssl) {
- rv = SSL_use_certificate_chain_file(cctx->ssl, value);
- c = cctx->ssl->cert;
+ if (cctx->ssl != NULL) {
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(cctx->ssl);
+
+ if (sc != NULL) {
+ rv = SSL_use_certificate_chain_file(cctx->ssl, value);
+ c = sc->cert;
+ } else {
+ rv = 0;
+ }
}
- if (rv > 0 && c && cctx->flags & SSL_CONF_FLAG_REQUIRE_PRIVATE) {
+ if (rv > 0 && c != NULL && cctx->flags & SSL_CONF_FLAG_REQUIRE_PRIVATE) {
char **pfilename = &cctx->cert_filename[c->key - c->pkeys];
+
OPENSSL_free(*pfilename);
*pfilename = OPENSSL_strdup(value);
if (*pfilename == NULL)
cert = cctx->ctx->cert;
ctx = cctx->ctx;
} else if (cctx->ssl != NULL) {
- cert = cctx->ssl->cert;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(cctx->ssl);
+
+ if (sc == NULL)
+ return 0;
+
+ cert = sc->cert;
ctx = cctx->ssl->ctx;
} else {
return 1;
/* See if any certificates are missing private keys */
size_t i;
CERT *c = NULL;
- if (cctx->ctx)
+
+ if (cctx->ctx != NULL) {
c = cctx->ctx->cert;
- else if (cctx->ssl)
- c = cctx->ssl->cert;
- if (c && cctx->flags & SSL_CONF_FLAG_REQUIRE_PRIVATE) {
+ } else if (cctx->ssl != NULL) {
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(cctx->ssl);
+
+ if (sc != NULL)
+ c = sc->cert;
+ }
+ if (c != NULL && cctx->flags & SSL_CONF_FLAG_REQUIRE_PRIVATE) {
for (i = 0; i < SSL_PKEY_NUM; i++) {
const char *p = cctx->cert_filename[i];
/*
{
cctx->ssl = ssl;
cctx->ctx = NULL;
- if (ssl) {
- cctx->poptions = &ssl->options;
- cctx->min_version = &ssl->min_proto_version;
- cctx->max_version = &ssl->max_proto_version;
- cctx->pcert_flags = &ssl->cert->cert_flags;
- cctx->pvfy_flags = &ssl->verify_mode;
+ if (ssl != NULL) {
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
+
+ if (sc == NULL)
+ return;
+ cctx->poptions = &sc->options;
+ cctx->min_version = &sc->min_proto_version;
+ cctx->max_version = &sc->max_proto_version;
+ cctx->pcert_flags = &sc->cert->cert_flags;
+ cctx->pvfy_flags = &sc->verify_mode;
} else {
cctx->poptions = NULL;
cctx->min_version = NULL;
#include "internal/refcount.h"
#include "internal/ktls.h"
-static int ssl_undefined_function_1(SSL *ssl, SSL3_RECORD *r, size_t s, int t,
- SSL_MAC_BUF *mac, size_t macsize)
+static int ssl_undefined_function_1(SSL_CONNECTION *sc, SSL3_RECORD *r, size_t s,
+ int t, SSL_MAC_BUF *mac, size_t macsize)
{
- return ssl_undefined_function(ssl);
+ return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc));
}
-static int ssl_undefined_function_2(SSL *ssl, SSL3_RECORD *r, unsigned char *s,
- int t)
+static int ssl_undefined_function_2(SSL_CONNECTION *sc, SSL3_RECORD *r,
+ unsigned char *s, int t)
{
- return ssl_undefined_function(ssl);
+ return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc));
}
-static int ssl_undefined_function_3(SSL *ssl, unsigned char *r,
+static int ssl_undefined_function_3(SSL_CONNECTION *sc, unsigned char *r,
unsigned char *s, size_t t, size_t *u)
{
- return ssl_undefined_function(ssl);
+ return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc));
}
-static int ssl_undefined_function_4(SSL *ssl, int r)
+static int ssl_undefined_function_4(SSL_CONNECTION *sc, int r)
{
- return ssl_undefined_function(ssl);
+ return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc));
}
-static size_t ssl_undefined_function_5(SSL *ssl, const char *r, size_t s,
- unsigned char *t)
+static size_t ssl_undefined_function_5(SSL_CONNECTION *sc, const char *r,
+ size_t s, unsigned char *t)
{
- return ssl_undefined_function(ssl);
+ return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc));
}
static int ssl_undefined_function_6(int r)
return ssl_undefined_function(NULL);
}
-static int ssl_undefined_function_7(SSL *ssl, unsigned char *r, size_t s,
- const char *t, size_t u,
+static int ssl_undefined_function_7(SSL_CONNECTION *sc, unsigned char *r,
+ size_t s, const char *t, size_t u,
const unsigned char *v, size_t w, int x)
{
- return ssl_undefined_function(ssl);
+ return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc));
+}
+
+static int ssl_undefined_function_8(SSL_CONNECTION *sc)
+{
+ return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc));
}
SSL3_ENC_METHOD ssl3_undef_enc_method = {
ssl_undefined_function_1,
ssl_undefined_function_2,
- ssl_undefined_function,
+ ssl_undefined_function_8,
ssl_undefined_function_3,
ssl_undefined_function_4,
ssl_undefined_function_5,
/*
* dane_copy - Copy dane configuration, sans verification state.
*/
-static int ssl_dane_dup(SSL *to, SSL *from)
+static int ssl_dane_dup(SSL_CONNECTION *to, SSL_CONNECTION *from)
{
int num;
int i;
num = sk_danetls_record_num(from->dane.trecs);
dane_final(&to->dane);
to->dane.flags = from->dane.flags;
- to->dane.dctx = &to->ctx->dane;
+ to->dane.dctx = &SSL_CONNECTION_GET_CTX(to)->dane;
to->dane.trecs = sk_danetls_record_new_reserve(NULL, num);
if (to->dane.trecs == NULL) {
for (i = 0; i < num; ++i) {
danetls_record *t = sk_danetls_record_value(from->dane.trecs, i);
- if (SSL_dane_tlsa_add(to, t->usage, t->selector, t->mtype,
- t->data, t->dlen) <= 0)
+ if (SSL_dane_tlsa_add(SSL_CONNECTION_GET_SSL(to), t->usage,
+ t->selector, t->mtype, t->data, t->dlen) <= 0)
return 0;
}
return 1;
#endif
-static void clear_ciphers(SSL *s)
+static void clear_ciphers(SSL_CONNECTION *s)
{
/* clear the current cipher */
ssl_clear_cipher_ctx(s);
return 0;
}
- if (ssl_clear_bad_session(s)) {
- SSL_SESSION_free(s->session);
- s->session = NULL;
+ return s->method->ssl_reset(s);
+}
+
+int ossl_ssl_connection_reset(SSL *s)
+{
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ if (ssl_clear_bad_session(sc)) {
+ SSL_SESSION_free(sc->session);
+ sc->session = NULL;
}
- SSL_SESSION_free(s->psksession);
- s->psksession = NULL;
- OPENSSL_free(s->psksession_id);
- s->psksession_id = NULL;
- s->psksession_id_len = 0;
- s->hello_retry_request = 0;
- s->sent_tickets = 0;
+ SSL_SESSION_free(sc->psksession);
+ sc->psksession = NULL;
+ OPENSSL_free(sc->psksession_id);
+ sc->psksession_id = NULL;
+ sc->psksession_id_len = 0;
+ sc->hello_retry_request = 0;
+ sc->sent_tickets = 0;
- s->error = 0;
- s->hit = 0;
- s->shutdown = 0;
+ sc->error = 0;
+ sc->hit = 0;
+ sc->shutdown = 0;
- if (s->renegotiate) {
+ if (sc->renegotiate) {
ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
return 0;
}
- ossl_statem_clear(s);
+ ossl_statem_clear(sc);
- s->version = s->method->version;
- s->client_version = s->version;
- s->rwstate = SSL_NOTHING;
+ /* TODO(QUIC): Version handling not yet clear */
+ sc->version = s->method->version;
+ sc->client_version = sc->version;
+ sc->rwstate = SSL_NOTHING;
- BUF_MEM_free(s->init_buf);
- s->init_buf = NULL;
- clear_ciphers(s);
- s->first_packet = 0;
+ BUF_MEM_free(sc->init_buf);
+ sc->init_buf = NULL;
+ clear_ciphers(sc);
+ sc->first_packet = 0;
- s->key_update = SSL_KEY_UPDATE_NONE;
+ sc->key_update = SSL_KEY_UPDATE_NONE;
- EVP_MD_CTX_free(s->pha_dgst);
- s->pha_dgst = NULL;
+ EVP_MD_CTX_free(sc->pha_dgst);
+ sc->pha_dgst = NULL;
/* Reset DANE verification result state */
- s->dane.mdpth = -1;
- s->dane.pdpth = -1;
- X509_free(s->dane.mcert);
- s->dane.mcert = NULL;
- s->dane.mtlsa = NULL;
+ sc->dane.mdpth = -1;
+ sc->dane.pdpth = -1;
+ X509_free(sc->dane.mcert);
+ sc->dane.mcert = NULL;
+ sc->dane.mtlsa = NULL;
/* Clear the verification result peername */
- X509_VERIFY_PARAM_move_peername(s->param, NULL);
+ X509_VERIFY_PARAM_move_peername(sc->param, NULL);
/* Clear any shared connection state */
- OPENSSL_free(s->shared_sigalgs);
- s->shared_sigalgs = NULL;
- s->shared_sigalgslen = 0;
+ OPENSSL_free(sc->shared_sigalgs);
+ sc->shared_sigalgs = NULL;
+ sc->shared_sigalgslen = 0;
/*
* Check to see if we were changed into a different method, if so, revert
* back.
*/
- if (s->method != s->ctx->method) {
- s->method->ssl_free(s);
- s->method = s->ctx->method;
- if (!s->method->ssl_new(s))
+ if (s->method != SSL_CONNECTION_GET_CTX(sc)->method) {
+ s->method->ssl_deinit(s);
+ s->method = SSL_CONNECTION_GET_CTX(sc)->method;
+ if (!s->method->ssl_init(s))
return 0;
} else {
if (!s->method->ssl_clear(s))
return 0;
}
- RECORD_LAYER_clear(&s->rlayer);
+ RECORD_LAYER_clear(&sc->rlayer);
return 1;
}
SSL *SSL_new(SSL_CTX *ctx)
{
- SSL *s;
-
if (ctx == NULL) {
ERR_raise(ERR_LIB_SSL, SSL_R_NULL_SSL_CTX);
return NULL;
ERR_raise(ERR_LIB_SSL, SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION);
return NULL;
}
+ return ctx->method->ssl_new(ctx);
+}
+
+int ossl_ssl_init(SSL *ssl, SSL_CTX *ctx, int type)
+{
+ ssl->type = type;
+
+ ssl->references = 1;
+ ssl->lock = CRYPTO_THREAD_lock_new();
+ if (ssl->lock == NULL)
+ return 0;
+
+ SSL_CTX_up_ref(ctx);
+ ssl->ctx = ctx;
+
+ ssl->method = ctx->method;
+
+ if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL, ssl, &ssl->ex_data))
+ return 0;
+
+ return 1;
+}
+
+SSL *ossl_ssl_connection_new(SSL_CTX *ctx)
+{
+ SSL_CONNECTION *s;
+ SSL *ssl;
s = OPENSSL_zalloc(sizeof(*s));
if (s == NULL)
- goto err;
+ return NULL;
- s->references = 1;
- s->lock = CRYPTO_THREAD_lock_new();
- if (s->lock == NULL) {
+ ssl = &s->ssl;
+ if (!ossl_ssl_init(ssl, ctx, SSL_TYPE_SSL_CONNECTION)) {
OPENSSL_free(s);
s = NULL;
goto err;
}
+#ifndef OPENSSL_NO_QUIC
+ /* set the parent (user visible) ssl to self */
+ s->user_ssl = ssl;
+#endif
+
RECORD_LAYER_init(&s->rlayer, s);
s->options = ctx->options;
if (s->max_pipelines > 1)
RECORD_LAYER_set_read_ahead(&s->rlayer, 1);
if (ctx->default_read_buf_len > 0)
- SSL_set_default_read_buffer_len(s, ctx->default_read_buf_len);
+ SSL_set_default_read_buffer_len(ssl, ctx->default_read_buf_len);
- SSL_CTX_up_ref(ctx);
- s->ctx = ctx;
s->ext.debug_cb = 0;
s->ext.debug_arg = NULL;
s->ext.ticket_expected = 0;
s->ext.npn = NULL;
#endif
- if (s->ctx->ext.alpn) {
- s->ext.alpn = OPENSSL_malloc(s->ctx->ext.alpn_len);
+ if (ctx->ext.alpn != NULL) {
+ s->ext.alpn = OPENSSL_malloc(ctx->ext.alpn_len);
if (s->ext.alpn == NULL) {
s->ext.alpn_len = 0;
goto err;
}
- memcpy(s->ext.alpn, s->ctx->ext.alpn, s->ctx->ext.alpn_len);
- s->ext.alpn_len = s->ctx->ext.alpn_len;
+ memcpy(s->ext.alpn, ctx->ext.alpn, ctx->ext.alpn_len);
+ s->ext.alpn_len = ctx->ext.alpn_len;
}
s->verified_chain = NULL;
s->default_passwd_callback = ctx->default_passwd_callback;
s->default_passwd_callback_userdata = ctx->default_passwd_callback_userdata;
- s->method = ctx->method;
-
s->key_update = SSL_KEY_UPDATE_NONE;
s->allow_early_data_cb = ctx->allow_early_data_cb;
s->allow_early_data_cb_data = ctx->allow_early_data_cb_data;
- if (!s->method->ssl_new(s))
+ if (!ssl->method->ssl_init(ssl))
goto err;
s->server = (ctx->method->ssl_accept == ssl_undefined_function) ? 0 : 1;
- if (!SSL_clear(s))
- goto err;
-
- if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data))
+ if (!SSL_clear(ssl))
goto err;
#ifndef OPENSSL_NO_PSK
s->job = NULL;
#ifndef OPENSSL_NO_CT
- if (!SSL_set_ct_validation_callback(s, ctx->ct_validation_callback,
+ if (!SSL_set_ct_validation_callback(ssl, ctx->ct_validation_callback,
ctx->ct_validation_callback_arg))
goto err;
#endif
- return s;
+ return ssl;
err:
- SSL_free(s);
+ SSL_free(ssl);
ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
return NULL;
}
int SSL_is_dtls(const SSL *s)
{
- return SSL_IS_DTLS(s) ? 1 : 0;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ return SSL_CONNECTION_IS_DTLS(sc) ? 1 : 0;
}
int SSL_up_ref(SSL *s)
int SSL_set_session_id_context(SSL *ssl, const unsigned char *sid_ctx,
unsigned int sid_ctx_len)
{
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
+
+ if (sc == NULL)
+ return 0;
+
if (sid_ctx_len > SSL_MAX_SID_CTX_LENGTH) {
ERR_raise(ERR_LIB_SSL, SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);
return 0;
}
- ssl->sid_ctx_length = sid_ctx_len;
- memcpy(ssl->sid_ctx, sid_ctx, sid_ctx_len);
+ sc->sid_ctx_length = sid_ctx_len;
+ memcpy(sc->sid_ctx, sid_ctx, sid_ctx_len);
return 1;
}
int SSL_set_generate_session_id(SSL *ssl, GEN_SESSION_CB cb)
{
- if (!CRYPTO_THREAD_write_lock(ssl->lock))
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
+
+ if (sc == NULL || !CRYPTO_THREAD_write_lock(ssl->lock))
return 0;
- ssl->generate_session_id = cb;
+ sc->generate_session_id = cb;
CRYPTO_THREAD_unlock(ssl->lock);
return 1;
}
* by this SSL.
*/
SSL_SESSION r, *p;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(ssl);
- if (id_len > sizeof(r.session_id))
+ if (sc == NULL || id_len > sizeof(r.session_id))
return 0;
- r.ssl_version = ssl->version;
+ r.ssl_version = sc->version;
r.session_id_length = id_len;
memcpy(r.session_id, id, id_len);
- if (!CRYPTO_THREAD_read_lock(ssl->session_ctx->lock))
+ if (!CRYPTO_THREAD_read_lock(sc->session_ctx->lock))
return 0;
- p = lh_SSL_SESSION_retrieve(ssl->session_ctx->sessions, &r);
- CRYPTO_THREAD_unlock(ssl->session_ctx->lock);
+ p = lh_SSL_SESSION_retrieve(sc->session_ctx->sessions, &r);
+ CRYPTO_THREAD_unlock(sc->session_ctx->lock);
return (p != NULL);
}
int SSL_set_purpose(SSL *s, int purpose)
{
- return X509_VERIFY_PARAM_set_purpose(s->param, purpose);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ return X509_VERIFY_PARAM_set_purpose(sc->param, purpose);
}
int SSL_CTX_set_trust(SSL_CTX *s, int trust)
int SSL_set_trust(SSL *s, int trust)
{
- return X509_VERIFY_PARAM_set_trust(s->param, trust);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ return X509_VERIFY_PARAM_set_trust(sc->param, trust);
}
int SSL_set1_host(SSL *s, const char *hostname)
{
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
/* If a hostname is provided and parses as an IP address,
* treat it as such. */
- if (hostname && X509_VERIFY_PARAM_set1_ip_asc(s->param, hostname) == 1)
+ if (hostname != NULL
+ && X509_VERIFY_PARAM_set1_ip_asc(sc->param, hostname) == 1)
return 1;
- return X509_VERIFY_PARAM_set1_host(s->param, hostname, 0);
+ return X509_VERIFY_PARAM_set1_host(sc->param, hostname, 0);
}
int SSL_add1_host(SSL *s, const char *hostname)
{
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
/* If a hostname is provided and parses as an IP address,
* treat it as such. */
if (hostname)
/* We didn't want it; only to check if it *is* an IP address */
ASN1_OCTET_STRING_free(ip);
- old_ip = X509_VERIFY_PARAM_get1_ip_asc(s->param);
+ old_ip = X509_VERIFY_PARAM_get1_ip_asc(sc->param);
if (old_ip)
{
OPENSSL_free(old_ip);
return 0;
}
- return X509_VERIFY_PARAM_set1_ip_asc(s->param, hostname);
+ return X509_VERIFY_PARAM_set1_ip_asc(sc->param, hostname);
}
}
- return X509_VERIFY_PARAM_add1_host(s->param, hostname, 0);
+ return X509_VERIFY_PARAM_add1_host(sc->param, hostname, 0);
}
void SSL_set_hostflags(SSL *s, unsigned int flags)
{
- X509_VERIFY_PARAM_set_hostflags(s->param, flags);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return;
+
+ X509_VERIFY_PARAM_set_hostflags(sc->param, flags);
}
const char *SSL_get0_peername(SSL *s)
{
- return X509_VERIFY_PARAM_get0_peername(s->param);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return NULL;
+
+ return X509_VERIFY_PARAM_get0_peername(sc->param);
}
int SSL_CTX_dane_enable(SSL_CTX *ctx)
int SSL_dane_enable(SSL *s, const char *basedomain)
{
- SSL_DANE *dane = &s->dane;
+ SSL_DANE *dane;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+ if (sc == NULL)
+ return 0;
+
+ dane = &sc->dane;
if (s->ctx->dane.mdmax == 0) {
ERR_raise(ERR_LIB_SSL, SSL_R_CONTEXT_NOT_DANE_ENABLED);
return 0;
* accepts them and disables host name checks. To avoid side-effects with
* invalid input, set the SNI name first.
*/
- if (s->ext.hostname == NULL) {
+ if (sc->ext.hostname == NULL) {
if (!SSL_set_tlsext_host_name(s, basedomain)) {
ERR_raise(ERR_LIB_SSL, SSL_R_ERROR_SETTING_TLSA_BASE_DOMAIN);
return -1;
}
/* Primary RFC6125 reference identifier */
- if (!X509_VERIFY_PARAM_set1_host(s->param, basedomain, 0)) {
+ if (!X509_VERIFY_PARAM_set1_host(sc->param, basedomain, 0)) {
ERR_raise(ERR_LIB_SSL, SSL_R_ERROR_SETTING_TLSA_BASE_DOMAIN);
return -1;
}
unsigned long SSL_dane_set_flags(SSL *ssl, unsigned long flags)
{
- unsigned long orig = ssl->dane.flags;
+ unsigned long orig;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
+
+ if (sc == NULL)
+ return 0;
+
+ orig = sc->dane.flags;
- ssl->dane.flags |= flags;
+ sc->dane.flags |= flags;
return orig;
}
unsigned long SSL_dane_clear_flags(SSL *ssl, unsigned long flags)
{
- unsigned long orig = ssl->dane.flags;
+ unsigned long orig;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
- ssl->dane.flags &= ~flags;
+ if (sc == NULL)
+ return 0;
+
+ orig = sc->dane.flags;
+
+ sc->dane.flags &= ~flags;
return orig;
}
int SSL_get0_dane_authority(SSL *s, X509 **mcert, EVP_PKEY **mspki)
{
- SSL_DANE *dane = &s->dane;
+ SSL_DANE *dane;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
- if (!DANETLS_ENABLED(dane) || s->verify_result != X509_V_OK)
+ if (sc == NULL)
+ return -1;
+
+ dane = &sc->dane;
+
+ if (!DANETLS_ENABLED(dane) || sc->verify_result != X509_V_OK)
return -1;
if (dane->mtlsa) {
if (mcert)
int SSL_get0_dane_tlsa(SSL *s, uint8_t *usage, uint8_t *selector,
uint8_t *mtype, const unsigned char **data, size_t *dlen)
{
- SSL_DANE *dane = &s->dane;
+ SSL_DANE *dane;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
- if (!DANETLS_ENABLED(dane) || s->verify_result != X509_V_OK)
+ if (sc == NULL)
+ return -1;
+
+ dane = &sc->dane;
+
+ if (!DANETLS_ENABLED(dane) || sc->verify_result != X509_V_OK)
return -1;
if (dane->mtlsa) {
if (usage)
SSL_DANE *SSL_get0_dane(SSL *s)
{
- return &s->dane;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return NULL;
+
+ return &sc->dane;
}
int SSL_dane_tlsa_add(SSL *s, uint8_t usage, uint8_t selector,
uint8_t mtype, const unsigned char *data, size_t dlen)
{
- return dane_tlsa_add(&s->dane, usage, selector, mtype, data, dlen);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ return dane_tlsa_add(&sc->dane, usage, selector, mtype, data, dlen);
}
int SSL_CTX_dane_mtype_set(SSL_CTX *ctx, const EVP_MD *md, uint8_t mtype,
int SSL_set1_param(SSL *ssl, X509_VERIFY_PARAM *vpm)
{
- return X509_VERIFY_PARAM_set1(ssl->param, vpm);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
+
+ if (sc == NULL)
+ return 0;
+
+ return X509_VERIFY_PARAM_set1(sc->param, vpm);
}
X509_VERIFY_PARAM *SSL_CTX_get0_param(SSL_CTX *ctx)
X509_VERIFY_PARAM *SSL_get0_param(SSL *ssl)
{
- return ssl->param;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
+
+ if (sc == NULL)
+ return NULL;
+
+ return sc->param;
}
void SSL_certs_clear(SSL *s)
{
- ssl_cert_clear_certs(s->cert);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return;
+
+ ssl_cert_clear_certs(sc->cert);
}
void SSL_free(SSL *s)
return;
REF_ASSERT_ISNT(i < 0);
+ CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data);
+
+ if (s->method != NULL)
+ s->method->ssl_free(s);
+
+ SSL_CTX_free(s->ctx);
+ CRYPTO_THREAD_lock_free(s->lock);
+
+ OPENSSL_free(s);
+}
+
+void ossl_ssl_connection_free(SSL *ssl)
+{
+ SSL_CONNECTION *s;
+
+ s = SSL_CONNECTION_FROM_SSL_ONLY(ssl);
+ if (s == NULL)
+ return;
+
X509_VERIFY_PARAM_free(s->param);
dane_final(&s->dane);
- CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data);
RECORD_LAYER_release(&s->rlayer);
OSSL_STACK_OF_X509_free(s->verified_chain);
- if (s->method != NULL)
- s->method->ssl_free(s);
-
- SSL_CTX_free(s->ctx);
+ if (ssl->method != NULL)
+ ssl->method->ssl_deinit(ssl);
ASYNC_WAIT_CTX_free(s->waitctx);
#ifndef OPENSSL_NO_SRTP
sk_SRTP_PROTECTION_PROFILE_free(s->srtp_profiles);
#endif
-
- CRYPTO_THREAD_lock_free(s->lock);
-
- OPENSSL_free(s);
}
void SSL_set0_rbio(SSL *s, BIO *rbio)
{
- BIO_free_all(s->rbio);
- s->rbio = rbio;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return;
+
+ BIO_free_all(sc->rbio);
+ sc->rbio = rbio;
}
void SSL_set0_wbio(SSL *s, BIO *wbio)
{
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return;
+
/*
* If the output buffering BIO is still in place, remove it
*/
- if (s->bbio != NULL)
- s->wbio = BIO_pop(s->wbio);
+ if (sc->bbio != NULL)
+ sc->wbio = BIO_pop(sc->wbio);
- BIO_free_all(s->wbio);
- s->wbio = wbio;
+ BIO_free_all(sc->wbio);
+ sc->wbio = wbio;
/* Re-attach |bbio| to the new |wbio|. */
- if (s->bbio != NULL)
- s->wbio = BIO_push(s->bbio, s->wbio);
+ if (sc->bbio != NULL)
+ sc->wbio = BIO_push(sc->bbio, sc->wbio);
}
void SSL_set_bio(SSL *s, BIO *rbio, BIO *wbio)
BIO *SSL_get_rbio(const SSL *s)
{
- return s->rbio;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return NULL;
+
+ return sc->rbio;
}
BIO *SSL_get_wbio(const SSL *s)
{
- if (s->bbio != NULL) {
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return NULL;
+
+ if (sc->bbio != NULL) {
/*
* If |bbio| is active, the true caller-configured BIO is its
* |next_bio|.
*/
- return BIO_next(s->bbio);
+ return BIO_next(sc->bbio);
}
- return s->wbio;
+ return sc->wbio;
}
int SSL_get_fd(const SSL *s)
size_t SSL_get_finished(const SSL *s, void *buf, size_t count)
{
size_t ret = 0;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return 0;
- ret = s->s3.tmp.finish_md_len;
+ ret = sc->s3.tmp.finish_md_len;
if (count > ret)
count = ret;
- memcpy(buf, s->s3.tmp.finish_md, count);
+ memcpy(buf, sc->s3.tmp.finish_md, count);
return ret;
}
size_t SSL_get_peer_finished(const SSL *s, void *buf, size_t count)
{
size_t ret = 0;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
- ret = s->s3.tmp.peer_finish_md_len;
+ if (sc == NULL)
+ return 0;
+
+ ret = sc->s3.tmp.peer_finish_md_len;
if (count > ret)
count = ret;
- memcpy(buf, s->s3.tmp.peer_finish_md, count);
+ memcpy(buf, sc->s3.tmp.peer_finish_md, count);
return ret;
}
int SSL_get_verify_mode(const SSL *s)
{
- return s->verify_mode;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ return sc->verify_mode;
}
int SSL_get_verify_depth(const SSL *s)
{
- return X509_VERIFY_PARAM_get_depth(s->param);
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ return X509_VERIFY_PARAM_get_depth(sc->param);
}
int (*SSL_get_verify_callback(const SSL *s)) (int, X509_STORE_CTX *) {
- return s->verify_callback;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return NULL;
+
+ return sc->verify_callback;
}
int SSL_CTX_get_verify_mode(const SSL_CTX *ctx)
void SSL_set_verify(SSL *s, int mode,
int (*callback) (int ok, X509_STORE_CTX *ctx))
{
- s->verify_mode = mode;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return;
+
+ sc->verify_mode = mode;
if (callback != NULL)
- s->verify_callback = callback;
+ sc->verify_callback = callback;
}
void SSL_set_verify_depth(SSL *s, int depth)
{
- X509_VERIFY_PARAM_set_depth(s->param, depth);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return;
+
+ X509_VERIFY_PARAM_set_depth(sc->param, depth);
}
void SSL_set_read_ahead(SSL *s, int yes)
{
- RECORD_LAYER_set_read_ahead(&s->rlayer, yes);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return;
+
+ RECORD_LAYER_set_read_ahead(&sc->rlayer, yes);
}
int SSL_get_read_ahead(const SSL *s)
{
- return RECORD_LAYER_get_read_ahead(&s->rlayer);
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ return RECORD_LAYER_get_read_ahead(&sc->rlayer);
}
int SSL_pending(const SSL *s)
* data. That data may not result in any application data, or we may fail
* to parse the records for some reason.
*/
- if (RECORD_LAYER_processed_read_pending(&s->rlayer))
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ if (RECORD_LAYER_processed_read_pending(&sc->rlayer))
return 1;
- return RECORD_LAYER_read_pending(&s->rlayer);
+ return RECORD_LAYER_read_pending(&sc->rlayer);
}
X509 *SSL_get1_peer_certificate(const SSL *s)
X509 *SSL_get0_peer_certificate(const SSL *s)
{
- if ((s == NULL) || (s->session == NULL))
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return NULL;
+
+ if (sc->session == NULL)
return NULL;
else
- return s->session->peer;
+ return sc->session->peer;
}
STACK_OF(X509) *SSL_get_peer_cert_chain(const SSL *s)
{
STACK_OF(X509) *r;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
- if ((s == NULL) || (s->session == NULL))
+ if (sc == NULL)
+ return NULL;
+
+ if (sc->session == NULL)
r = NULL;
else
- r = s->session->peer_chain;
+ r = sc->session->peer_chain;
/*
* If we are a client, cert_chain includes the peer's own certificate; if
int SSL_copy_session_id(SSL *t, const SSL *f)
{
int i;
+ /* TODO(QUIC): Do we want to support this for QUIC connections? */
+ SSL_CONNECTION *tsc = SSL_CONNECTION_FROM_SSL_ONLY(t);
+ const SSL_CONNECTION *fsc = SSL_CONNECTION_FROM_CONST_SSL_ONLY(f);
+
+ if (tsc == NULL || fsc == NULL)
+ return 0;
+
/* Do we need to do SSL locking? */
if (!SSL_set_session(t, SSL_get_session(f))) {
return 0;
* what if we are setup for one protocol version but want to talk another
*/
if (t->method != f->method) {
- t->method->ssl_free(t);
+ t->method->ssl_deinit(t);
t->method = f->method;
- if (t->method->ssl_new(t) == 0)
+ if (t->method->ssl_init(t) == 0)
return 0;
}
- CRYPTO_UP_REF(&f->cert->references, &i, f->cert->lock);
- ssl_cert_free(t->cert);
- t->cert = f->cert;
- if (!SSL_set_session_id_context(t, f->sid_ctx, (int)f->sid_ctx_length)) {
+ CRYPTO_UP_REF(&fsc->cert->references, &i, fsc->cert->lock);
+ ssl_cert_free(tsc->cert);
+ tsc->cert = fsc->cert;
+ if (!SSL_set_session_id_context(t, fsc->sid_ctx, (int)fsc->sid_ctx_length)) {
return 0;
}
/* Fix this function so that it takes an optional type parameter */
int SSL_check_private_key(const SSL *ssl)
{
- if (ssl == NULL) {
+ const SSL_CONNECTION *sc;
+
+ if ((sc = SSL_CONNECTION_FROM_CONST_SSL(ssl)) == NULL) {
ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
- if (ssl->cert->key->x509 == NULL) {
+ if (sc->cert->key->x509 == NULL) {
ERR_raise(ERR_LIB_SSL, SSL_R_NO_CERTIFICATE_ASSIGNED);
return 0;
}
- if (ssl->cert->key->privatekey == NULL) {
+ if (sc->cert->key->privatekey == NULL) {
ERR_raise(ERR_LIB_SSL, SSL_R_NO_PRIVATE_KEY_ASSIGNED);
return 0;
}
- return X509_check_private_key(ssl->cert->key->x509,
- ssl->cert->key->privatekey);
+ return X509_check_private_key(sc->cert->key->x509,
+ sc->cert->key->privatekey);
}
int SSL_waiting_for_async(SSL *s)
{
- if (s->job)
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ if (sc->job)
return 1;
return 0;
int SSL_get_all_async_fds(SSL *s, OSSL_ASYNC_FD *fds, size_t *numfds)
{
- ASYNC_WAIT_CTX *ctx = s->waitctx;
+ ASYNC_WAIT_CTX *ctx;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
- if (ctx == NULL)
+ if (sc == NULL)
+ return 0;
+
+ if ((ctx = sc->waitctx) == NULL)
return 0;
return ASYNC_WAIT_CTX_get_all_fds(ctx, fds, numfds);
}
int SSL_get_changed_async_fds(SSL *s, OSSL_ASYNC_FD *addfd, size_t *numaddfds,
OSSL_ASYNC_FD *delfd, size_t *numdelfds)
{
- ASYNC_WAIT_CTX *ctx = s->waitctx;
+ ASYNC_WAIT_CTX *ctx;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
- if (ctx == NULL)
+ if (sc == NULL)
+ return 0;
+
+ if ((ctx = sc->waitctx) == NULL)
return 0;
return ASYNC_WAIT_CTX_get_changed_fds(ctx, addfd, numaddfds, delfd,
numdelfds);
int SSL_set_async_callback(SSL *s, SSL_async_callback_fn callback)
{
- s->async_cb = callback;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ sc->async_cb = callback;
return 1;
}
int SSL_set_async_callback_arg(SSL *s, void *arg)
{
- s->async_cb_arg = arg;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ sc->async_cb_arg = arg;
return 1;
}
int SSL_get_async_status(SSL *s, int *status)
{
- ASYNC_WAIT_CTX *ctx = s->waitctx;
+ ASYNC_WAIT_CTX *ctx;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
- if (ctx == NULL)
+ if (sc == NULL)
+ return 0;
+
+ if ((ctx = sc->waitctx) == NULL)
return 0;
*status = ASYNC_WAIT_CTX_get_status(ctx);
return 1;
int SSL_accept(SSL *s)
{
- if (s->handshake_func == NULL) {
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ if (sc->handshake_func == NULL) {
/* Not properly initialized yet */
SSL_set_accept_state(s);
}
int SSL_connect(SSL *s)
{
- if (s->handshake_func == NULL) {
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ if (sc->handshake_func == NULL) {
/* Not properly initialized yet */
SSL_set_connect_state(s);
}
static int ssl_async_wait_ctx_cb(void *arg)
{
SSL *s = (SSL *)arg;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
- return s->async_cb(s, s->async_cb_arg);
+ if (sc == NULL)
+ return 0;
+
+ return sc->async_cb(s, sc->async_cb_arg);
}
static int ssl_start_async_job(SSL *s, struct ssl_async_args *args,
int (*func) (void *))
{
int ret;
- if (s->waitctx == NULL) {
- s->waitctx = ASYNC_WAIT_CTX_new();
- if (s->waitctx == NULL)
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ if (sc->waitctx == NULL) {
+ sc->waitctx = ASYNC_WAIT_CTX_new();
+ if (sc->waitctx == NULL)
return -1;
- if (s->async_cb != NULL
+ if (sc->async_cb != NULL
&& !ASYNC_WAIT_CTX_set_callback
- (s->waitctx, ssl_async_wait_ctx_cb, s))
+ (sc->waitctx, ssl_async_wait_ctx_cb, s))
return -1;
}
- s->rwstate = SSL_NOTHING;
- switch (ASYNC_start_job(&s->job, s->waitctx, &ret, func, args,
+ sc->rwstate = SSL_NOTHING;
+ switch (ASYNC_start_job(&sc->job, sc->waitctx, &ret, func, args,
sizeof(struct ssl_async_args))) {
case ASYNC_ERR:
- s->rwstate = SSL_NOTHING;
+ sc->rwstate = SSL_NOTHING;
ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_INIT_ASYNC);
return -1;
case ASYNC_PAUSE:
- s->rwstate = SSL_ASYNC_PAUSED;
+ sc->rwstate = SSL_ASYNC_PAUSED;
return -1;
case ASYNC_NO_JOBS:
- s->rwstate = SSL_ASYNC_NO_JOBS;
+ sc->rwstate = SSL_ASYNC_NO_JOBS;
return -1;
case ASYNC_FINISH:
- s->job = NULL;
+ sc->job = NULL;
return ret;
default:
- s->rwstate = SSL_NOTHING;
+ sc->rwstate = SSL_NOTHING;
ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
/* Shouldn't happen */
return -1;
SSL *s;
void *buf;
size_t num;
+ SSL_CONNECTION *sc;
args = (struct ssl_async_args *)vargs;
s = args->s;
buf = args->buf;
num = args->num;
+ if ((sc = SSL_CONNECTION_FROM_SSL(s)) == NULL)
+ return -1;
+
switch (args->type) {
case READFUNC:
- return args->f.func_read(s, buf, num, &s->asyncrw);
+ return args->f.func_read(s, buf, num, &sc->asyncrw);
case WRITEFUNC:
- return args->f.func_write(s, buf, num, &s->asyncrw);
+ return args->f.func_write(s, buf, num, &sc->asyncrw);
case OTHERFUNC:
return args->f.func_other(s);
}
int ssl_read_internal(SSL *s, void *buf, size_t num, size_t *readbytes)
{
- if (s->handshake_func == NULL) {
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return -1;
+
+ if (sc->handshake_func == NULL) {
ERR_raise(ERR_LIB_SSL, SSL_R_UNINITIALIZED);
return -1;
}
- if (s->shutdown & SSL_RECEIVED_SHUTDOWN) {
- s->rwstate = SSL_NOTHING;
+ if (sc->shutdown & SSL_RECEIVED_SHUTDOWN) {
+ sc->rwstate = SSL_NOTHING;
return 0;
}
- if (s->early_data_state == SSL_EARLY_DATA_CONNECT_RETRY
- || s->early_data_state == SSL_EARLY_DATA_ACCEPT_RETRY) {
+ if (sc->early_data_state == SSL_EARLY_DATA_CONNECT_RETRY
+ || sc->early_data_state == SSL_EARLY_DATA_ACCEPT_RETRY) {
ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
return 0;
}
* If we are a client and haven't received the ServerHello etc then we
* better do that
*/
- ossl_statem_check_finish_init(s, 0);
+ ossl_statem_check_finish_init(sc, 0);
- if ((s->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
+ if ((sc->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
struct ssl_async_args args;
int ret;
args.f.func_read = s->method->ssl_read;
ret = ssl_start_async_job(s, &args, ssl_io_intern);
- *readbytes = s->asyncrw;
+ *readbytes = sc->asyncrw;
return ret;
} else {
return s->method->ssl_read(s, buf, num, readbytes);
int SSL_read_early_data(SSL *s, void *buf, size_t num, size_t *readbytes)
{
int ret;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
+
+ /* TODO(QUIC): This will need special handling for QUIC */
+ if (sc == NULL)
+ return 0;
- if (!s->server) {
+ if (!sc->server) {
ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
return SSL_READ_EARLY_DATA_ERROR;
}
- switch (s->early_data_state) {
+ switch (sc->early_data_state) {
case SSL_EARLY_DATA_NONE:
if (!SSL_in_before(s)) {
ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
/* fall through */
case SSL_EARLY_DATA_ACCEPT_RETRY:
- s->early_data_state = SSL_EARLY_DATA_ACCEPTING;
+ sc->early_data_state = SSL_EARLY_DATA_ACCEPTING;
ret = SSL_accept(s);
if (ret <= 0) {
/* NBIO or error */
- s->early_data_state = SSL_EARLY_DATA_ACCEPT_RETRY;
+ sc->early_data_state = SSL_EARLY_DATA_ACCEPT_RETRY;
return SSL_READ_EARLY_DATA_ERROR;
}
/* fall through */
case SSL_EARLY_DATA_READ_RETRY:
- if (s->ext.early_data == SSL_EARLY_DATA_ACCEPTED) {
- s->early_data_state = SSL_EARLY_DATA_READING;
+ if (sc->ext.early_data == SSL_EARLY_DATA_ACCEPTED) {
+ sc->early_data_state = SSL_EARLY_DATA_READING;
ret = SSL_read_ex(s, buf, num, readbytes);
/*
* State machine will update early_data_state to
* SSL_EARLY_DATA_FINISHED_READING if we get an EndOfEarlyData
* message
*/
- if (ret > 0 || (ret <= 0 && s->early_data_state
+ if (ret > 0 || (ret <= 0 && sc->early_data_state
!= SSL_EARLY_DATA_FINISHED_READING)) {
- s->early_data_state = SSL_EARLY_DATA_READ_RETRY;
+ sc->early_data_state = SSL_EARLY_DATA_READ_RETRY;
return ret > 0 ? SSL_READ_EARLY_DATA_SUCCESS
: SSL_READ_EARLY_DATA_ERROR;
}
} else {
- s->early_data_state = SSL_EARLY_DATA_FINISHED_READING;
+ sc->early_data_state = SSL_EARLY_DATA_FINISHED_READING;
}
*readbytes = 0;
return SSL_READ_EARLY_DATA_FINISH;
int SSL_get_early_data_status(const SSL *s)
{
- return s->ext.early_data;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL_ONLY(s);
+
+ /* TODO(QUIC): This will need special handling for QUIC */
+ if (sc == NULL)
+ return 0;
+
+ return sc->ext.early_data;
}
static int ssl_peek_internal(SSL *s, void *buf, size_t num, size_t *readbytes)
{
- if (s->handshake_func == NULL) {
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ if (sc->handshake_func == NULL) {
ERR_raise(ERR_LIB_SSL, SSL_R_UNINITIALIZED);
return -1;
}
- if (s->shutdown & SSL_RECEIVED_SHUTDOWN) {
+ if (sc->shutdown & SSL_RECEIVED_SHUTDOWN) {
return 0;
}
- if ((s->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
+ if ((sc->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
struct ssl_async_args args;
int ret;
args.f.func_read = s->method->ssl_peek;
ret = ssl_start_async_job(s, &args, ssl_io_intern);
- *readbytes = s->asyncrw;
+ *readbytes = sc->asyncrw;
return ret;
} else {
return s->method->ssl_peek(s, buf, num, readbytes);
int ssl_write_internal(SSL *s, const void *buf, size_t num, size_t *written)
{
- if (s->handshake_func == NULL) {
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ if (sc->handshake_func == NULL) {
ERR_raise(ERR_LIB_SSL, SSL_R_UNINITIALIZED);
return -1;
}
- if (s->shutdown & SSL_SENT_SHUTDOWN) {
- s->rwstate = SSL_NOTHING;
+ if (sc->shutdown & SSL_SENT_SHUTDOWN) {
+ sc->rwstate = SSL_NOTHING;
ERR_raise(ERR_LIB_SSL, SSL_R_PROTOCOL_IS_SHUTDOWN);
return -1;
}
- if (s->early_data_state == SSL_EARLY_DATA_CONNECT_RETRY
- || s->early_data_state == SSL_EARLY_DATA_ACCEPT_RETRY
- || s->early_data_state == SSL_EARLY_DATA_READ_RETRY) {
+ if (sc->early_data_state == SSL_EARLY_DATA_CONNECT_RETRY
+ || sc->early_data_state == SSL_EARLY_DATA_ACCEPT_RETRY
+ || sc->early_data_state == SSL_EARLY_DATA_READ_RETRY) {
ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
return 0;
}
/* If we are a client and haven't sent the Finished we better do that */
- ossl_statem_check_finish_init(s, 1);
+ ossl_statem_check_finish_init(sc, 1);
- if ((s->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
+ if ((sc->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
int ret;
struct ssl_async_args args;
args.f.func_write = s->method->ssl_write;
ret = ssl_start_async_job(s, &args, ssl_io_intern);
- *written = s->asyncrw;
+ *written = sc->asyncrw;
return ret;
} else {
return s->method->ssl_write(s, buf, num, written);
ossl_ssize_t SSL_sendfile(SSL *s, int fd, off_t offset, size_t size, int flags)
{
ossl_ssize_t ret;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
- if (s->handshake_func == NULL) {
+ if (sc == NULL)
+ return 0;
+
+ if (sc->handshake_func == NULL) {
ERR_raise(ERR_LIB_SSL, SSL_R_UNINITIALIZED);
return -1;
}
- if (s->shutdown & SSL_SENT_SHUTDOWN) {
- s->rwstate = SSL_NOTHING;
+ if (sc->shutdown & SSL_SENT_SHUTDOWN) {
+ sc->rwstate = SSL_NOTHING;
ERR_raise(ERR_LIB_SSL, SSL_R_PROTOCOL_IS_SHUTDOWN);
return -1;
}
- if (!BIO_get_ktls_send(s->wbio)) {
+ if (!BIO_get_ktls_send(sc->wbio)) {
ERR_raise(ERR_LIB_SSL, SSL_R_UNINITIALIZED);
return -1;
}
/* If we have an alert to send, lets send it */
- if (s->s3.alert_dispatch) {
+ if (sc->s3.alert_dispatch) {
ret = (ossl_ssize_t)s->method->ssl_dispatch_alert(s);
if (ret <= 0) {
/* SSLfatal() already called if appropriate */
/* if it went, fall through and send more stuff */
}
- s->rwstate = SSL_WRITING;
- if (BIO_flush(s->wbio) <= 0) {
- if (!BIO_should_retry(s->wbio)) {
- s->rwstate = SSL_NOTHING;
+ sc->rwstate = SSL_WRITING;
+ if (BIO_flush(sc->wbio) <= 0) {
+ if (!BIO_should_retry(sc->wbio)) {
+ sc->rwstate = SSL_NOTHING;
} else {
#ifdef EAGAIN
set_sys_error(EAGAIN);
if ((get_last_sys_error() == EAGAIN) ||
(get_last_sys_error() == EINTR) ||
(get_last_sys_error() == EBUSY))
- BIO_set_retry_write(s->wbio);
+ BIO_set_retry_write(sc->wbio);
else
#endif
ERR_raise(ERR_LIB_SSL, SSL_R_UNINITIALIZED);
return ret;
}
- s->rwstate = SSL_NOTHING;
+ sc->rwstate = SSL_NOTHING;
return ret;
#endif
}
int ret, early_data_state;
size_t writtmp;
uint32_t partialwrite;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
+
+ /* TODO(QUIC): This will need special handling for QUIC */
+ if (sc == NULL)
+ return 0;
- switch (s->early_data_state) {
+ switch (sc->early_data_state) {
case SSL_EARLY_DATA_NONE:
- if (s->server
+ if (sc->server
|| !SSL_in_before(s)
- || ((s->session == NULL || s->session->ext.max_early_data == 0)
- && (s->psk_use_session_cb == NULL))) {
+ || ((sc->session == NULL || sc->session->ext.max_early_data == 0)
+ && (sc->psk_use_session_cb == NULL))) {
ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
return 0;
}
/* fall through */
case SSL_EARLY_DATA_CONNECT_RETRY:
- s->early_data_state = SSL_EARLY_DATA_CONNECTING;
+ sc->early_data_state = SSL_EARLY_DATA_CONNECTING;
ret = SSL_connect(s);
if (ret <= 0) {
/* NBIO or error */
- s->early_data_state = SSL_EARLY_DATA_CONNECT_RETRY;
+ sc->early_data_state = SSL_EARLY_DATA_CONNECT_RETRY;
return 0;
}
/* fall through */
case SSL_EARLY_DATA_WRITE_RETRY:
- s->early_data_state = SSL_EARLY_DATA_WRITING;
+ sc->early_data_state = SSL_EARLY_DATA_WRITING;
/*
* We disable partial write for early data because we don't keep track
* of how many bytes we've written between the SSL_write_ex() call and
* the flush if the flush needs to be retried)
*/
- partialwrite = s->mode & SSL_MODE_ENABLE_PARTIAL_WRITE;
- s->mode &= ~SSL_MODE_ENABLE_PARTIAL_WRITE;
+ partialwrite = sc->mode & SSL_MODE_ENABLE_PARTIAL_WRITE;
+ sc->mode &= ~SSL_MODE_ENABLE_PARTIAL_WRITE;
ret = SSL_write_ex(s, buf, num, &writtmp);
- s->mode |= partialwrite;
+ sc->mode |= partialwrite;
if (!ret) {
- s->early_data_state = SSL_EARLY_DATA_WRITE_RETRY;
+ sc->early_data_state = SSL_EARLY_DATA_WRITE_RETRY;
return ret;
}
- s->early_data_state = SSL_EARLY_DATA_WRITE_FLUSH;
+ sc->early_data_state = SSL_EARLY_DATA_WRITE_FLUSH;
/* fall through */
case SSL_EARLY_DATA_WRITE_FLUSH:
/* The buffering BIO is still in place so we need to flush it */
- if (statem_flush(s) != 1)
+ if (statem_flush(sc) != 1)
return 0;
*written = num;
- s->early_data_state = SSL_EARLY_DATA_WRITE_RETRY;
+ sc->early_data_state = SSL_EARLY_DATA_WRITE_RETRY;
return 1;
case SSL_EARLY_DATA_FINISHED_READING:
case SSL_EARLY_DATA_READ_RETRY:
- early_data_state = s->early_data_state;
+ early_data_state = sc->early_data_state;
/* We are a server writing to an unauthenticated client */
- s->early_data_state = SSL_EARLY_DATA_UNAUTH_WRITING;
+ sc->early_data_state = SSL_EARLY_DATA_UNAUTH_WRITING;
ret = SSL_write_ex(s, buf, num, written);
/* The buffering BIO is still in place */
if (ret)
- (void)BIO_flush(s->wbio);
- s->early_data_state = early_data_state;
+ (void)BIO_flush(sc->wbio);
+ sc->early_data_state = early_data_state;
return ret;
default:
* calling it once is usually not enough, even if blocking I/O is used
* (see ssl3_shutdown).
*/
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
- if (s->handshake_func == NULL) {
+ if (sc == NULL)
+ return -1;
+
+ if (sc->handshake_func == NULL) {
ERR_raise(ERR_LIB_SSL, SSL_R_UNINITIALIZED);
return -1;
}
if (!SSL_in_init(s)) {
- if ((s->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
+ if ((sc->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
struct ssl_async_args args;
memset(&args, 0, sizeof(args));
int SSL_key_update(SSL *s, int updatetype)
{
- if (!SSL_IS_TLS13(s)) {
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ if (!SSL_CONNECTION_IS_TLS13(sc)) {
ERR_raise(ERR_LIB_SSL, SSL_R_WRONG_SSL_VERSION);
return 0;
}
return 0;
}
- if (RECORD_LAYER_write_pending(&s->rlayer)) {
+ if (RECORD_LAYER_write_pending(&sc->rlayer)) {
ERR_raise(ERR_LIB_SSL, SSL_R_BAD_WRITE_RETRY);
return 0;
}
- ossl_statem_set_in_init(s, 1);
- s->key_update = updatetype;
+ ossl_statem_set_in_init(sc, 1);
+ sc->key_update = updatetype;
return 1;
}
int SSL_get_key_update_type(const SSL *s)
{
- return s->key_update;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ return sc->key_update;
}
/*
* Can we accept a renegotiation request? If yes, set the flag and
* return 1 if yes. If not, raise error and return 0.
*/
-static int can_renegotiate(const SSL *s)
+static int can_renegotiate(const SSL_CONNECTION *sc)
{
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(sc)) {
ERR_raise(ERR_LIB_SSL, SSL_R_WRONG_SSL_VERSION);
return 0;
}
- if ((s->options & SSL_OP_NO_RENEGOTIATION) != 0) {
+ if ((sc->options & SSL_OP_NO_RENEGOTIATION) != 0) {
ERR_raise(ERR_LIB_SSL, SSL_R_NO_RENEGOTIATION);
return 0;
}
int SSL_renegotiate(SSL *s)
{
- if (!can_renegotiate(s))
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
+
+ if (sc == NULL)
return 0;
- s->renegotiate = 1;
- s->new_session = 1;
+ if (!can_renegotiate(sc))
+ return 0;
+
+ sc->renegotiate = 1;
+ sc->new_session = 1;
return s->method->ssl_renegotiate(s);
}
int SSL_renegotiate_abbreviated(SSL *s)
{
- if (!can_renegotiate(s))
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
+
+ if (sc == NULL)
+ return 0;
+
+ if (!can_renegotiate(sc))
return 0;
- s->renegotiate = 1;
- s->new_session = 0;
+ sc->renegotiate = 1;
+ sc->new_session = 0;
return s->method->ssl_renegotiate(s);
}
int SSL_renegotiate_pending(const SSL *s)
{
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
+
+ if (sc == NULL)
+ return 0;
+
/*
* becomes true when negotiation is requested; false again once a
* handshake has finished
*/
- return (s->renegotiate != 0);
+ return (sc->renegotiate != 0);
}
int SSL_new_session_ticket(SSL *s)
{
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
/* If we are in init because we're sending tickets, okay to send more. */
- if ((SSL_in_init(s) && s->ext.extra_tickets_expected == 0)
- || SSL_IS_FIRST_HANDSHAKE(s) || !s->server
- || !SSL_IS_TLS13(s))
+ if ((SSL_in_init(s) && sc->ext.extra_tickets_expected == 0)
+ || SSL_IS_FIRST_HANDSHAKE(sc) || !sc->server
+ || !SSL_CONNECTION_IS_TLS13(sc))
return 0;
- s->ext.extra_tickets_expected++;
- if (!RECORD_LAYER_write_pending(&s->rlayer) && !SSL_in_init(s))
- ossl_statem_set_in_init(s, 1);
+ sc->ext.extra_tickets_expected++;
+ if (!RECORD_LAYER_write_pending(&sc->rlayer) && !SSL_in_init(s))
+ ossl_statem_set_in_init(sc, 1);
return 1;
}
long SSL_ctrl(SSL *s, int cmd, long larg, void *parg)
{
long l;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ /* TODO(QUIC): Special handling for some ctrls will be needed */
+ if (sc == NULL)
+ return 0;
switch (cmd) {
case SSL_CTRL_GET_READ_AHEAD:
- return RECORD_LAYER_get_read_ahead(&s->rlayer);
+ return RECORD_LAYER_get_read_ahead(&sc->rlayer);
case SSL_CTRL_SET_READ_AHEAD:
- l = RECORD_LAYER_get_read_ahead(&s->rlayer);
- RECORD_LAYER_set_read_ahead(&s->rlayer, larg);
+ l = RECORD_LAYER_get_read_ahead(&sc->rlayer);
+ RECORD_LAYER_set_read_ahead(&sc->rlayer, larg);
return l;
case SSL_CTRL_SET_MSG_CALLBACK_ARG:
- s->msg_callback_arg = parg;
+ sc->msg_callback_arg = parg;
return 1;
case SSL_CTRL_MODE:
- return (s->mode |= larg);
+ return (sc->mode |= larg);
case SSL_CTRL_CLEAR_MODE:
- return (s->mode &= ~larg);
+ return (sc->mode &= ~larg);
case SSL_CTRL_GET_MAX_CERT_LIST:
- return (long)s->max_cert_list;
+ return (long)sc->max_cert_list;
case SSL_CTRL_SET_MAX_CERT_LIST:
if (larg < 0)
return 0;
- l = (long)s->max_cert_list;
- s->max_cert_list = (size_t)larg;
+ l = (long)sc->max_cert_list;
+ sc->max_cert_list = (size_t)larg;
return l;
case SSL_CTRL_SET_MAX_SEND_FRAGMENT:
if (larg < 512 || larg > SSL3_RT_MAX_PLAIN_LENGTH)
return 0;
#ifndef OPENSSL_NO_KTLS
- if (s->wbio != NULL && BIO_get_ktls_send(s->wbio))
+ if (sc->wbio != NULL && BIO_get_ktls_send(sc->wbio))
return 0;
#endif /* OPENSSL_NO_KTLS */
- s->max_send_fragment = larg;
- if (s->max_send_fragment < s->split_send_fragment)
- s->split_send_fragment = s->max_send_fragment;
+ sc->max_send_fragment = larg;
+ if (sc->max_send_fragment < sc->split_send_fragment)
+ sc->split_send_fragment = sc->max_send_fragment;
return 1;
case SSL_CTRL_SET_SPLIT_SEND_FRAGMENT:
- if ((size_t)larg > s->max_send_fragment || larg == 0)
+ if ((size_t)larg > sc->max_send_fragment || larg == 0)
return 0;
- s->split_send_fragment = larg;
+ sc->split_send_fragment = larg;
return 1;
case SSL_CTRL_SET_MAX_PIPELINES:
if (larg < 1 || larg > SSL_MAX_PIPELINES)
return 0;
- s->max_pipelines = larg;
+ sc->max_pipelines = larg;
if (larg > 1)
- RECORD_LAYER_set_read_ahead(&s->rlayer, 1);
+ RECORD_LAYER_set_read_ahead(&sc->rlayer, 1);
return 1;
case SSL_CTRL_GET_RI_SUPPORT:
- return s->s3.send_connection_binding;
+ return sc->s3.send_connection_binding;
case SSL_CTRL_SET_RETRY_VERIFY:
- s->rwstate = SSL_RETRY_VERIFY;
+ sc->rwstate = SSL_RETRY_VERIFY;
return 1;
case SSL_CTRL_CERT_FLAGS:
- return (s->cert->cert_flags |= larg);
+ return (sc->cert->cert_flags |= larg);
case SSL_CTRL_CLEAR_CERT_FLAGS:
- return (s->cert->cert_flags &= ~larg);
+ return (sc->cert->cert_flags &= ~larg);
case SSL_CTRL_GET_RAW_CIPHERLIST:
if (parg) {
- if (s->s3.tmp.ciphers_raw == NULL)
+ if (sc->s3.tmp.ciphers_raw == NULL)
return 0;
- *(unsigned char **)parg = s->s3.tmp.ciphers_raw;
- return (int)s->s3.tmp.ciphers_rawlen;
+ *(unsigned char **)parg = sc->s3.tmp.ciphers_raw;
+ return (int)sc->s3.tmp.ciphers_rawlen;
} else {
return TLS_CIPHER_LEN;
}
case SSL_CTRL_GET_EXTMS_SUPPORT:
- if (!s->session || SSL_in_init(s) || ossl_statem_get_in_handshake(s))
+ if (!sc->session || SSL_in_init(s) || ossl_statem_get_in_handshake(sc))
return -1;
- if (s->session->flags & SSL_SESS_FLAG_EXTMS)
+ if (sc->session->flags & SSL_SESS_FLAG_EXTMS)
return 1;
else
return 0;
case SSL_CTRL_SET_MIN_PROTO_VERSION:
- return ssl_check_allowed_versions(larg, s->max_proto_version)
+ return ssl_check_allowed_versions(larg, sc->max_proto_version)
&& ssl_set_version_bound(s->ctx->method->version, (int)larg,
- &s->min_proto_version);
+ &sc->min_proto_version);
case SSL_CTRL_GET_MIN_PROTO_VERSION:
- return s->min_proto_version;
+ return sc->min_proto_version;
case SSL_CTRL_SET_MAX_PROTO_VERSION:
- return ssl_check_allowed_versions(s->min_proto_version, larg)
+ return ssl_check_allowed_versions(sc->min_proto_version, larg)
&& ssl_set_version_bound(s->ctx->method->version, (int)larg,
- &s->max_proto_version);
+ &sc->max_proto_version);
case SSL_CTRL_GET_MAX_PROTO_VERSION:
- return s->max_proto_version;
+ return sc->max_proto_version;
default:
return s->method->ssl_ctrl(s, cmd, larg, parg);
}
long SSL_callback_ctrl(SSL *s, int cmd, void (*fp) (void))
{
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
switch (cmd) {
case SSL_CTRL_SET_MSG_CALLBACK:
- s->msg_callback = (void (*)
- (int write_p, int version, int content_type,
- const void *buf, size_t len, SSL *ssl,
- void *arg))(fp);
+ sc->msg_callback = (void (*)
+ (int write_p, int version, int content_type,
+ const void *buf, size_t len, SSL *ssl,
+ void *arg))(fp);
return 1;
default:
return 0;
}
-/** return a STACK of the ciphers available for the SSL and in order of
- * preference */
+/*
+ * return a STACK of the ciphers available for the SSL and in order of
+ * preference
+ */
STACK_OF(SSL_CIPHER) *SSL_get_ciphers(const SSL *s)
{
- if (s != NULL) {
- if (s->cipher_list != NULL) {
- return s->cipher_list;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc != NULL) {
+ if (sc->cipher_list != NULL) {
+ return sc->cipher_list;
} else if ((s->ctx != NULL) && (s->ctx->cipher_list != NULL)) {
return s->ctx->cipher_list;
}
STACK_OF(SSL_CIPHER) *SSL_get_client_ciphers(const SSL *s)
{
- if ((s == NULL) || !s->server)
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL || !sc->server)
return NULL;
- return s->peer_ciphers;
+ return sc->peer_ciphers;
}
STACK_OF(SSL_CIPHER) *SSL_get1_supported_ciphers(SSL *s)
{
STACK_OF(SSL_CIPHER) *sk = NULL, *ciphers;
int i;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return NULL;
ciphers = SSL_get_ciphers(s);
if (!ciphers)
return NULL;
- if (!ssl_set_client_disabled(s))
+ if (!ssl_set_client_disabled(sc))
return NULL;
for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) {
const SSL_CIPHER *c = sk_SSL_CIPHER_value(ciphers, i);
- if (!ssl_cipher_disabled(s, c, SSL_SECOP_CIPHER_SUPPORTED, 0)) {
+ if (!ssl_cipher_disabled(sc, c, SSL_SECOP_CIPHER_SUPPORTED, 0)) {
if (!sk)
sk = sk_SSL_CIPHER_new_null();
if (!sk)
/** return a STACK of the ciphers available for the SSL and in order of
* algorithm id */
-STACK_OF(SSL_CIPHER) *ssl_get_ciphers_by_id(SSL *s)
+STACK_OF(SSL_CIPHER) *ssl_get_ciphers_by_id(SSL_CONNECTION *s)
{
if (s != NULL) {
- if (s->cipher_list_by_id != NULL) {
+ if (s->cipher_list_by_id != NULL)
return s->cipher_list_by_id;
- } else if ((s->ctx != NULL) && (s->ctx->cipher_list_by_id != NULL)) {
- return s->ctx->cipher_list_by_id;
- }
+ else if (s->ssl.ctx != NULL
+ && s->ssl.ctx->cipher_list_by_id != NULL)
+ return s->ssl.ctx->cipher_list_by_id;
}
return NULL;
}
int SSL_set_cipher_list(SSL *s, const char *str)
{
STACK_OF(SSL_CIPHER) *sk;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
- sk = ssl_create_cipher_list(s->ctx, s->tls13_ciphersuites,
- &s->cipher_list, &s->cipher_list_by_id, str,
- s->cert);
+ if (sc == NULL)
+ return 0;
+
+ sk = ssl_create_cipher_list(s->ctx, sc->tls13_ciphersuites,
+ &sc->cipher_list, &sc->cipher_list_by_id, str,
+ sc->cert);
/* see comment in SSL_CTX_set_cipher_list */
if (sk == NULL)
return 0;
STACK_OF(SSL_CIPHER) *clntsk, *srvrsk;
const SSL_CIPHER *c;
int i;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return NULL;
- if (!s->server
- || s->peer_ciphers == NULL
+ if (!sc->server
+ || sc->peer_ciphers == NULL
|| size < 2)
return NULL;
p = buf;
- clntsk = s->peer_ciphers;
+ clntsk = sc->peer_ciphers;
srvrsk = SSL_get_ciphers(s);
if (clntsk == NULL || srvrsk == NULL)
return NULL;
* - if we are before or during/after the handshake,
* - if a resumption or normal handshake is being attempted/has occurred
* - whether we have negotiated TLSv1.2 (or below) or TLSv1.3
- *
+ *
* Note that only the host_name type is defined (RFC 3546).
*/
const char *SSL_get_servername(const SSL *s, const int type)
{
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+ int server;
+
+ if (sc == NULL)
+ return NULL;
+
/*
* If we don't know if we are the client or the server yet then we assume
* client.
*/
- int server = s->handshake_func == NULL ? 0 : s->server;
+ server = sc->handshake_func == NULL ? 0 : sc->server;
+
if (type != TLSEXT_NAMETYPE_host_name)
return NULL;
* - The function will return the servername requested by the client in
* this handshake or NULL if none was requested.
*/
- if (s->hit && !SSL_IS_TLS13(s))
- return s->session->ext.hostname;
+ if (sc->hit && !SSL_CONNECTION_IS_TLS13(sc))
+ return sc->session->ext.hostname;
} else {
/**
* Client side
* (or NULL if it was not called).
*/
if (SSL_in_before(s)) {
- if (s->ext.hostname == NULL
- && s->session != NULL
- && s->session->ssl_version != TLS1_3_VERSION)
- return s->session->ext.hostname;
+ if (sc->ext.hostname == NULL
+ && sc->session != NULL
+ && sc->session->ssl_version != TLS1_3_VERSION)
+ return sc->session->ext.hostname;
} else {
- if (!SSL_IS_TLS13(s) && s->hit && s->session->ext.hostname != NULL)
- return s->session->ext.hostname;
+ if (!SSL_CONNECTION_IS_TLS13(sc) && sc->hit
+ && sc->session->ext.hostname != NULL)
+ return sc->session->ext.hostname;
}
}
- return s->ext.hostname;
+ return sc->ext.hostname;
}
int SSL_get_servername_type(const SSL *s)
void SSL_get0_next_proto_negotiated(const SSL *s, const unsigned char **data,
unsigned *len)
{
- *data = s->ext.npn;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL) {
+ /* We have no other way to indicate error */
+ *data = NULL;
+ *len = 0;
+ return;
+ }
+
+ *data = sc->ext.npn;
if (*data == NULL) {
*len = 0;
} else {
- *len = (unsigned int)s->ext.npn_len;
+ *len = (unsigned int)sc->ext.npn_len;
}
}
unsigned int protos_len)
{
unsigned char *alpn;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
+
+ if (sc == NULL)
+ return 1;
if (protos_len == 0 || protos == NULL) {
- OPENSSL_free(ssl->ext.alpn);
- ssl->ext.alpn = NULL;
- ssl->ext.alpn_len = 0;
+ OPENSSL_free(sc->ext.alpn);
+ sc->ext.alpn = NULL;
+ sc->ext.alpn_len = 0;
return 0;
}
/* Not valid per RFC */
ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
return 1;
}
- OPENSSL_free(ssl->ext.alpn);
- ssl->ext.alpn = alpn;
- ssl->ext.alpn_len = protos_len;
+ OPENSSL_free(sc->ext.alpn);
+ sc->ext.alpn = alpn;
+ sc->ext.alpn_len = protos_len;
return 0;
}
void SSL_get0_alpn_selected(const SSL *ssl, const unsigned char **data,
unsigned int *len)
{
- *data = ssl->s3.alpn_selected;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(ssl);
+
+ if (sc == NULL) {
+ /* We have no other way to indicate error */
+ *data = NULL;
+ *len = 0;
+ return;
+ }
+
+ *data = sc->s3.alpn_selected;
if (*data == NULL)
*len = 0;
else
- *len = (unsigned int)ssl->s3.alpn_selected_len;
+ *len = (unsigned int)sc->s3.alpn_selected_len;
}
int SSL_export_keying_material(SSL *s, unsigned char *out, size_t olen,
const unsigned char *context, size_t contextlen,
int use_context)
{
- if (s->session == NULL
- || (s->version < TLS1_VERSION && s->version != DTLS1_BAD_VER))
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return -1;
+
+ if (sc->session == NULL
+ || (sc->version < TLS1_VERSION && sc->version != DTLS1_BAD_VER))
return -1;
- return s->method->ssl3_enc->export_keying_material(s, out, olen, label,
+ return s->method->ssl3_enc->export_keying_material(sc, out, olen, label,
llen, context,
contextlen, use_context);
}
const unsigned char *context,
size_t contextlen)
{
- if (s->version != TLS1_3_VERSION)
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return -1;
+
+ if (sc->version != TLS1_3_VERSION)
return 0;
- return tls13_export_keying_material_early(s, out, olen, label, llen,
+ return tls13_export_keying_material_early(sc, out, olen, label, llen,
context, contextlen);
}
void SSL_set_default_passwd_cb(SSL *s, pem_password_cb *cb)
{
- s->default_passwd_callback = cb;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return;
+
+ sc->default_passwd_callback = cb;
}
void SSL_set_default_passwd_cb_userdata(SSL *s, void *u)
{
- s->default_passwd_callback_userdata = u;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return;
+
+ sc->default_passwd_callback_userdata = u;
}
pem_password_cb *SSL_get_default_passwd_cb(SSL *s)
{
- return s->default_passwd_callback;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return NULL;
+
+ return sc->default_passwd_callback;
}
void *SSL_get_default_passwd_cb_userdata(SSL *s)
{
- return s->default_passwd_callback_userdata;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return NULL;
+
+ return sc->default_passwd_callback_userdata;
}
void SSL_CTX_set_cert_verify_callback(SSL_CTX *ctx,
void SSL_set_cert_cb(SSL *s, int (*cb) (SSL *ssl, void *arg), void *arg)
{
- ssl_cert_set_cert_cb(s->cert, cb, arg);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return;
+
+ ssl_cert_set_cert_cb(sc->cert, cb, arg);
}
-void ssl_set_masks(SSL *s)
+void ssl_set_masks(SSL_CONNECTION *s)
{
CERT *c = s->cert;
uint32_t *pvalid = s->s3.tmp.valid_flags;
if (rsa_enc || rsa_sign || (ssl_has_cert(s, SSL_PKEY_RSA_PSS_SIGN)
&& pvalid[SSL_PKEY_RSA_PSS_SIGN] & CERT_PKEY_EXPLICIT_SIGN
- && TLS1_get_version(s) == TLS1_2_VERSION))
+ && TLS1_get_version(&s->ssl) == TLS1_2_VERSION))
mask_a |= SSL_aRSA;
if (dsa_sign) {
/* Allow Ed25519 for TLS 1.2 if peer supports it */
if (!(mask_a & SSL_aECDSA) && ssl_has_cert(s, SSL_PKEY_ED25519)
&& pvalid[SSL_PKEY_ED25519] & CERT_PKEY_EXPLICIT_SIGN
- && TLS1_get_version(s) == TLS1_2_VERSION)
+ && TLS1_get_version(&s->ssl) == TLS1_2_VERSION)
mask_a |= SSL_aECDSA;
/* Allow Ed448 for TLS 1.2 if peer supports it */
if (!(mask_a & SSL_aECDSA) && ssl_has_cert(s, SSL_PKEY_ED448)
&& pvalid[SSL_PKEY_ED448] & CERT_PKEY_EXPLICIT_SIGN
- && TLS1_get_version(s) == TLS1_2_VERSION)
+ && TLS1_get_version(&s->ssl) == TLS1_2_VERSION)
mask_a |= SSL_aECDSA;
mask_k |= SSL_kECDHE;
s->s3.tmp.mask_a = mask_a;
}
-int ssl_check_srvr_ecc_cert_and_alg(X509 *x, SSL *s)
+int ssl_check_srvr_ecc_cert_and_alg(X509 *x, SSL_CONNECTION *s)
{
if (s->s3.tmp.new_cipher->algorithm_auth & SSL_aECDSA) {
/* key usage, if present, must allow signing */
return 1; /* all checks are ok */
}
-int ssl_get_server_cert_serverinfo(SSL *s, const unsigned char **serverinfo,
+int ssl_get_server_cert_serverinfo(SSL_CONNECTION *s,
+ const unsigned char **serverinfo,
size_t *serverinfo_length)
{
CERT_PKEY *cpk = s->s3.tmp.cert;
return 1;
}
-void ssl_update_cache(SSL *s, int mode)
+void ssl_update_cache(SSL_CONNECTION *s, int mode)
{
int i;
i = s->session_ctx->session_cache_mode;
if ((i & mode) != 0
- && (!s->hit || SSL_IS_TLS13(s))) {
+ && (!s->hit || SSL_CONNECTION_IS_TLS13(s))) {
/*
* Add the session to the internal cache. In server side TLSv1.3 we
* normally don't do this because by default it's a full stateless ticket
* - SSL_OP_NO_TICKET is set in which case it is a stateful ticket
*/
if ((i & SSL_SESS_CACHE_NO_INTERNAL_STORE) == 0
- && (!SSL_IS_TLS13(s)
+ && (!SSL_CONNECTION_IS_TLS13(s)
|| !s->server
|| (s->max_early_data > 0
&& (s->options & SSL_OP_NO_ANTI_REPLAY) == 0)
*/
if (s->session_ctx->new_session_cb != NULL) {
SSL_SESSION_up_ref(s->session);
- if (!s->session_ctx->new_session_cb(s, s->session))
+ if (!s->session_ctx->new_session_cb(SSL_CONNECTION_GET_SSL(s),
+ s->session))
SSL_SESSION_free(s->session);
}
}
int SSL_set_ssl_method(SSL *s, const SSL_METHOD *meth)
{
int ret = 1;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ /* TODO(QUIC): Do we want this for QUIC? */
+ if (sc == NULL
+ || (s->type != SSL_TYPE_SSL_CONNECTION && s->method != meth))
+ return 0;
if (s->method != meth) {
const SSL_METHOD *sm = s->method;
- int (*hf) (SSL *) = s->handshake_func;
+ int (*hf) (SSL *) = sc->handshake_func;
if (sm->version == meth->version)
s->method = meth;
else {
- sm->ssl_free(s);
+ sm->ssl_deinit(s);
s->method = meth;
- ret = s->method->ssl_new(s);
+ ret = s->method->ssl_init(s);
}
if (hf == sm->ssl_connect)
- s->handshake_func = meth->ssl_connect;
+ sc->handshake_func = meth->ssl_connect;
else if (hf == sm->ssl_accept)
- s->handshake_func = meth->ssl_accept;
+ sc->handshake_func = meth->ssl_accept;
}
return ret;
}
int reason;
unsigned long l;
BIO *bio;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
if (i > 0)
return SSL_ERROR_NONE;
+ /* TODO(QUIC): This will need more handling for QUIC_CONNECTIONs */
+ if (sc == NULL)
+ return SSL_ERROR_SSL;
+
/*
* Make things return SSL_ERROR_SYSCALL when doing SSL_do_handshake etc,
* where we do encode the error
if (SSL_want_write(s)) {
/* Access wbio directly - in order to use the buffered bio if present */
- bio = s->wbio;
+ bio = sc->wbio;
if (BIO_should_write(bio))
return SSL_ERROR_WANT_WRITE;
else if (BIO_should_read(bio))
if (SSL_want_client_hello_cb(s))
return SSL_ERROR_WANT_CLIENT_HELLO_CB;
- if ((s->shutdown & SSL_RECEIVED_SHUTDOWN) &&
- (s->s3.warn_alert == SSL_AD_CLOSE_NOTIFY))
+ if ((sc->shutdown & SSL_RECEIVED_SHUTDOWN) &&
+ (sc->s3.warn_alert == SSL_AD_CLOSE_NOTIFY))
return SSL_ERROR_ZERO_RETURN;
return SSL_ERROR_SYSCALL;
static int ssl_do_handshake_intern(void *vargs)
{
- struct ssl_async_args *args;
- SSL *s;
+ struct ssl_async_args *args = (struct ssl_async_args *)vargs;
+ SSL *s = args->s;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
- args = (struct ssl_async_args *)vargs;
- s = args->s;
+ if (sc == NULL)
+ return -1;
- return s->handshake_func(s);
+ return sc->handshake_func(s);
}
int SSL_do_handshake(SSL *s)
{
int ret = 1;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ /* TODO(QUIC): Special handling for QUIC will be needed */
+ if (sc == NULL)
+ return -1;
- if (s->handshake_func == NULL) {
+ if (sc->handshake_func == NULL) {
ERR_raise(ERR_LIB_SSL, SSL_R_CONNECTION_TYPE_NOT_SET);
return -1;
}
- ossl_statem_check_finish_init(s, -1);
+ ossl_statem_check_finish_init(sc, -1);
s->method->ssl_renegotiate_check(s, 0);
if (SSL_in_init(s) || SSL_in_before(s)) {
- if ((s->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
+ if ((sc->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
struct ssl_async_args args;
memset(&args, 0, sizeof(args));
ret = ssl_start_async_job(s, &args, ssl_do_handshake_intern);
} else {
- ret = s->handshake_func(s);
+ ret = sc->handshake_func(s);
}
}
return ret;
void SSL_set_accept_state(SSL *s)
{
- s->server = 1;
- s->shutdown = 0;
- ossl_statem_clear(s);
- s->handshake_func = s->method->ssl_accept;
- clear_ciphers(s);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ /* TODO(QUIC): Special handling for QUIC will be needed */
+ if (sc == NULL)
+ return;
+
+ sc->server = 1;
+ sc->shutdown = 0;
+ ossl_statem_clear(sc);
+ sc->handshake_func = s->method->ssl_accept;
+ clear_ciphers(sc);
}
void SSL_set_connect_state(SSL *s)
{
- s->server = 0;
- s->shutdown = 0;
- ossl_statem_clear(s);
- s->handshake_func = s->method->ssl_connect;
- clear_ciphers(s);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ /* TODO(QUIC): Special handling for QUIC will be needed */
+ if (sc == NULL)
+ return;
+
+ sc->server = 0;
+ sc->shutdown = 0;
+ ossl_statem_clear(sc);
+ sc->handshake_func = s->method->ssl_connect;
+ clear_ciphers(sc);
}
int ssl_undefined_function(SSL *s)
const char *SSL_get_version(const SSL *s)
{
- return ssl_protocol_to_string(s->version);
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ /* TODO(QUIC): Should QUIC return QUIC or TLSv1.3? */
+ if (sc == NULL)
+ return NULL;
+
+ return ssl_protocol_to_string(sc->version);
}
static int dup_ca_names(STACK_OF(X509_NAME) **dst, STACK_OF(X509_NAME) *src)
{
SSL *ret;
int i;
+ /* TODO(QUIC): Add a SSL_METHOD function for duplication */
+ SSL_CONNECTION *retsc;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
+
+ if (sc == NULL)
+ return NULL;
/* If we're not quiescent, just up_ref! */
if (!SSL_in_init(s) || !SSL_in_before(s)) {
*/
if ((ret = SSL_new(SSL_get_SSL_CTX(s))) == NULL)
return NULL;
+ if ((retsc = SSL_CONNECTION_FROM_SSL_ONLY(ret)) == NULL)
+ goto err;
- if (s->session != NULL) {
+ if (sc->session != NULL) {
/*
* Arranges to share the same session via up_ref. This "copies"
* session-id, SSL_METHOD, sid_ctx, and 'cert'
if (!SSL_set_ssl_method(ret, s->method))
goto err;
- if (s->cert != NULL) {
- ssl_cert_free(ret->cert);
- ret->cert = ssl_cert_dup(s->cert);
- if (ret->cert == NULL)
+ if (sc->cert != NULL) {
+ ssl_cert_free(retsc->cert);
+ retsc->cert = ssl_cert_dup(sc->cert);
+ if (retsc->cert == NULL)
goto err;
}
- if (!SSL_set_session_id_context(ret, s->sid_ctx,
- (int)s->sid_ctx_length))
+ if (!SSL_set_session_id_context(ret, sc->sid_ctx,
+ (int)sc->sid_ctx_length))
goto err;
}
- if (!ssl_dane_dup(ret, s))
+ if (!ssl_dane_dup(retsc, sc))
goto err;
- ret->version = s->version;
- ret->options = s->options;
- ret->min_proto_version = s->min_proto_version;
- ret->max_proto_version = s->max_proto_version;
- ret->mode = s->mode;
+ retsc->version = sc->version;
+ retsc->options = sc->options;
+ retsc->min_proto_version = sc->min_proto_version;
+ retsc->max_proto_version = sc->max_proto_version;
+ retsc->mode = sc->mode;
SSL_set_max_cert_list(ret, SSL_get_max_cert_list(s));
SSL_set_read_ahead(ret, SSL_get_read_ahead(s));
- ret->msg_callback = s->msg_callback;
- ret->msg_callback_arg = s->msg_callback_arg;
+ retsc->msg_callback = sc->msg_callback;
+ retsc->msg_callback_arg = sc->msg_callback_arg;
SSL_set_verify(ret, SSL_get_verify_mode(s), SSL_get_verify_callback(s));
SSL_set_verify_depth(ret, SSL_get_verify_depth(s));
- ret->generate_session_id = s->generate_session_id;
+ retsc->generate_session_id = sc->generate_session_id;
SSL_set_info_callback(ret, SSL_get_info_callback(s));
if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_SSL, &ret->ex_data, &s->ex_data))
goto err;
- ret->server = s->server;
- if (s->handshake_func) {
- if (s->server)
+ retsc->server = sc->server;
+ if (sc->handshake_func) {
+ if (sc->server)
SSL_set_accept_state(ret);
else
SSL_set_connect_state(ret);
}
- ret->shutdown = s->shutdown;
- ret->hit = s->hit;
+ retsc->shutdown = sc->shutdown;
+ retsc->hit = sc->hit;
- ret->default_passwd_callback = s->default_passwd_callback;
- ret->default_passwd_callback_userdata = s->default_passwd_callback_userdata;
+ retsc->default_passwd_callback = sc->default_passwd_callback;
+ retsc->default_passwd_callback_userdata = sc->default_passwd_callback_userdata;
- X509_VERIFY_PARAM_inherit(ret->param, s->param);
+ X509_VERIFY_PARAM_inherit(retsc->param, sc->param);
/* dup the cipher_list and cipher_list_by_id stacks */
- if (s->cipher_list != NULL) {
- if ((ret->cipher_list = sk_SSL_CIPHER_dup(s->cipher_list)) == NULL)
+ if (sc->cipher_list != NULL) {
+ if ((retsc->cipher_list = sk_SSL_CIPHER_dup(sc->cipher_list)) == NULL)
goto err;
}
- if (s->cipher_list_by_id != NULL)
- if ((ret->cipher_list_by_id = sk_SSL_CIPHER_dup(s->cipher_list_by_id))
+ if (sc->cipher_list_by_id != NULL)
+ if ((retsc->cipher_list_by_id = sk_SSL_CIPHER_dup(sc->cipher_list_by_id))
== NULL)
goto err;
/* Dup the client_CA list */
- if (!dup_ca_names(&ret->ca_names, s->ca_names)
- || !dup_ca_names(&ret->client_ca_names, s->client_ca_names))
+ if (!dup_ca_names(&retsc->ca_names, sc->ca_names)
+ || !dup_ca_names(&retsc->client_ca_names, sc->client_ca_names))
goto err;
return ret;
return NULL;
}
-void ssl_clear_cipher_ctx(SSL *s)
+void ssl_clear_cipher_ctx(SSL_CONNECTION *s)
{
if (s->enc_read_ctx != NULL) {
EVP_CIPHER_CTX_free(s->enc_read_ctx);
X509 *SSL_get_certificate(const SSL *s)
{
- if (s->cert != NULL)
- return s->cert->key->x509;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return NULL;
+
+ if (sc->cert != NULL)
+ return sc->cert->key->x509;
else
return NULL;
}
EVP_PKEY *SSL_get_privatekey(const SSL *s)
{
- if (s->cert != NULL)
- return s->cert->key->privatekey;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return NULL;
+
+ if (sc->cert != NULL)
+ return sc->cert->key->privatekey;
else
return NULL;
}
const SSL_CIPHER *SSL_get_current_cipher(const SSL *s)
{
- if ((s->session != NULL) && (s->session->cipher != NULL))
- return s->session->cipher;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return NULL;
+
+ if ((sc->session != NULL) && (sc->session->cipher != NULL))
+ return sc->session->cipher;
return NULL;
}
const SSL_CIPHER *SSL_get_pending_cipher(const SSL *s)
{
- return s->s3.tmp.new_cipher;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return NULL;
+
+ return sc->s3.tmp.new_cipher;
}
const COMP_METHOD *SSL_get_current_compression(const SSL *s)
{
#ifndef OPENSSL_NO_COMP
- return s->compress ? COMP_CTX_get_method(s->compress) : NULL;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL_ONLY(s);
+
+ if (sc == NULL)
+ return NULL;
+
+ return sc->compress ? COMP_CTX_get_method(sc->compress) : NULL;
#else
return NULL;
#endif
const COMP_METHOD *SSL_get_current_expansion(const SSL *s)
{
#ifndef OPENSSL_NO_COMP
- return s->expand ? COMP_CTX_get_method(s->expand) : NULL;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL_ONLY(s);
+
+ if (sc == NULL)
+ return NULL;
+
+ return sc->expand ? COMP_CTX_get_method(sc->expand) : NULL;
#else
return NULL;
#endif
}
-int ssl_init_wbio_buffer(SSL *s)
+int ssl_init_wbio_buffer(SSL_CONNECTION *s)
{
BIO *bbio;
return 1;
}
-int ssl_free_wbio_buffer(SSL *s)
+int ssl_free_wbio_buffer(SSL_CONNECTION *s)
{
/* callers ensure s is never null */
if (s->bbio == NULL)
void SSL_set_quiet_shutdown(SSL *s, int mode)
{
- s->quiet_shutdown = mode;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
+
+ /* TODO(QUIC): Do we want this for QUIC? */
+ if (sc == NULL)
+ return;
+
+ sc->quiet_shutdown = mode;
}
int SSL_get_quiet_shutdown(const SSL *s)
{
- return s->quiet_shutdown;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL_ONLY(s);
+
+ /* TODO(QUIC): Do we want this for QUIC? */
+ if (sc == NULL)
+ return 0;
+
+ return sc->quiet_shutdown;
}
void SSL_set_shutdown(SSL *s, int mode)
{
- s->shutdown = mode;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
+
+ /* TODO(QUIC): Do we want this for QUIC? */
+ if (sc == NULL)
+ return;
+
+ sc->shutdown = mode;
}
int SSL_get_shutdown(const SSL *s)
{
- return s->shutdown;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL_ONLY(s);
+
+ /* TODO(QUIC): Do we want this for QUIC? */
+ if (sc == NULL)
+ return 0;
+
+ return sc->shutdown;
}
int SSL_version(const SSL *s)
{
- return s->version;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ /* TODO(QUIC): Do we want to report QUIC version this way instead? */
+ if (sc == NULL)
+ return 0;
+
+ return sc->version;
}
int SSL_client_version(const SSL *s)
{
- return s->client_version;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ /* TODO(QUIC): Do we want to report QUIC version this way instead? */
+ if (sc == NULL)
+ return 0;
+
+ return sc->client_version;
}
SSL_CTX *SSL_get_SSL_CTX(const SSL *ssl)
SSL_CTX *SSL_set_SSL_CTX(SSL *ssl, SSL_CTX *ctx)
{
CERT *new_cert;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(ssl);
+
+ /* TODO(QUIC): Do we need this for QUIC support? */
+ if (sc == NULL)
+ return NULL;
+
if (ssl->ctx == ctx)
return ssl->ctx;
if (ctx == NULL)
- ctx = ssl->session_ctx;
+ ctx = sc->session_ctx;
new_cert = ssl_cert_dup(ctx->cert);
if (new_cert == NULL) {
return NULL;
}
- if (!custom_exts_copy_flags(&new_cert->custext, &ssl->cert->custext)) {
+ if (!custom_exts_copy_flags(&new_cert->custext, &sc->cert->custext)) {
ssl_cert_free(new_cert);
return NULL;
}
- ssl_cert_free(ssl->cert);
- ssl->cert = new_cert;
+ ssl_cert_free(sc->cert);
+ sc->cert = new_cert;
/*
* Program invariant: |sid_ctx| has fixed size (SSL_MAX_SID_CTX_LENGTH),
* so setter APIs must prevent invalid lengths from entering the system.
*/
- if (!ossl_assert(ssl->sid_ctx_length <= sizeof(ssl->sid_ctx)))
+ if (!ossl_assert(sc->sid_ctx_length <= sizeof(sc->sid_ctx)))
return NULL;
/*
* leave it unchanged.
*/
if ((ssl->ctx != NULL) &&
- (ssl->sid_ctx_length == ssl->ctx->sid_ctx_length) &&
- (memcmp(ssl->sid_ctx, ssl->ctx->sid_ctx, ssl->sid_ctx_length) == 0)) {
- ssl->sid_ctx_length = ctx->sid_ctx_length;
- memcpy(&ssl->sid_ctx, &ctx->sid_ctx, sizeof(ssl->sid_ctx));
+ (sc->sid_ctx_length == ssl->ctx->sid_ctx_length) &&
+ (memcmp(sc->sid_ctx, ssl->ctx->sid_ctx, sc->sid_ctx_length) == 0)) {
+ sc->sid_ctx_length = ctx->sid_ctx_length;
+ memcpy(&sc->sid_ctx, &ctx->sid_ctx, sizeof(sc->sid_ctx));
}
SSL_CTX_up_ref(ctx);
void SSL_set_info_callback(SSL *ssl,
void (*cb) (const SSL *ssl, int type, int val))
{
- ssl->info_callback = cb;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
+
+ if (sc == NULL)
+ return;
+
+ sc->info_callback = cb;
}
/*
void (*SSL_get_info_callback(const SSL *ssl)) (const SSL * /* ssl */ ,
int /* type */ ,
int /* val */ ) {
- return ssl->info_callback;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(ssl);
+
+ if (sc == NULL)
+ return NULL;
+
+ return sc->info_callback;
}
void SSL_set_verify_result(SSL *ssl, long arg)
{
- ssl->verify_result = arg;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
+
+ if (sc == NULL)
+ return;
+
+ sc->verify_result = arg;
}
long SSL_get_verify_result(const SSL *ssl)
{
- return ssl->verify_result;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(ssl);
+
+ if (sc == NULL)
+ return 0;
+
+ return sc->verify_result;
}
size_t SSL_get_client_random(const SSL *ssl, unsigned char *out, size_t outlen)
{
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(ssl);
+
+ if (sc == NULL)
+ return 0;
+
if (outlen == 0)
- return sizeof(ssl->s3.client_random);
- if (outlen > sizeof(ssl->s3.client_random))
- outlen = sizeof(ssl->s3.client_random);
- memcpy(out, ssl->s3.client_random, outlen);
+ return sizeof(sc->s3.client_random);
+ if (outlen > sizeof(sc->s3.client_random))
+ outlen = sizeof(sc->s3.client_random);
+ memcpy(out, sc->s3.client_random, outlen);
return outlen;
}
size_t SSL_get_server_random(const SSL *ssl, unsigned char *out, size_t outlen)
{
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(ssl);
+
+ if (sc == NULL)
+ return 0;
+
if (outlen == 0)
- return sizeof(ssl->s3.server_random);
- if (outlen > sizeof(ssl->s3.server_random))
- outlen = sizeof(ssl->s3.server_random);
- memcpy(out, ssl->s3.server_random, outlen);
+ return sizeof(sc->s3.server_random);
+ if (outlen > sizeof(sc->s3.server_random))
+ outlen = sizeof(sc->s3.server_random);
+ memcpy(out, sc->s3.server_random, outlen);
return outlen;
}
int SSL_want(const SSL *s)
{
- return s->rwstate;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return SSL_NOTHING;
+
+ return sc->rwstate;
}
#ifndef OPENSSL_NO_PSK
int SSL_use_psk_identity_hint(SSL *s, const char *identity_hint)
{
- if (s == NULL)
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
return 0;
if (identity_hint != NULL && strlen(identity_hint) > PSK_MAX_IDENTITY_LEN) {
ERR_raise(ERR_LIB_SSL, SSL_R_DATA_LENGTH_TOO_LONG);
return 0;
}
- OPENSSL_free(s->cert->psk_identity_hint);
+ OPENSSL_free(sc->cert->psk_identity_hint);
if (identity_hint != NULL) {
- s->cert->psk_identity_hint = OPENSSL_strdup(identity_hint);
- if (s->cert->psk_identity_hint == NULL)
+ sc->cert->psk_identity_hint = OPENSSL_strdup(identity_hint);
+ if (sc->cert->psk_identity_hint == NULL)
return 0;
} else
- s->cert->psk_identity_hint = NULL;
+ sc->cert->psk_identity_hint = NULL;
return 1;
}
const char *SSL_get_psk_identity_hint(const SSL *s)
{
- if (s == NULL || s->session == NULL)
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL || sc->session == NULL)
return NULL;
- return s->session->psk_identity_hint;
+
+ return sc->session->psk_identity_hint;
}
const char *SSL_get_psk_identity(const SSL *s)
{
- if (s == NULL || s->session == NULL)
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL || sc->session == NULL)
return NULL;
- return s->session->psk_identity;
+
+ return sc->session->psk_identity;
}
void SSL_set_psk_client_callback(SSL *s, SSL_psk_client_cb_func cb)
{
- s->psk_client_callback = cb;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return;
+
+ sc->psk_client_callback = cb;
}
void SSL_CTX_set_psk_client_callback(SSL_CTX *ctx, SSL_psk_client_cb_func cb)
void SSL_set_psk_server_callback(SSL *s, SSL_psk_server_cb_func cb)
{
- s->psk_server_callback = cb;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return;
+
+ sc->psk_server_callback = cb;
}
void SSL_CTX_set_psk_server_callback(SSL_CTX *ctx, SSL_psk_server_cb_func cb)
void SSL_set_psk_find_session_callback(SSL *s, SSL_psk_find_session_cb_func cb)
{
- s->psk_find_session_cb = cb;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return;
+
+ sc->psk_find_session_cb = cb;
}
void SSL_CTX_set_psk_find_session_callback(SSL_CTX *ctx,
void SSL_set_psk_use_session_callback(SSL *s, SSL_psk_use_session_cb_func cb)
{
- s->psk_use_session_cb = cb;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return;
+
+ sc->psk_use_session_cb = cb;
}
void SSL_CTX_set_psk_use_session_callback(SSL_CTX *ctx,
size_t len, void *arg))
{
BIO *b;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
+
+ if (sc == NULL)
+ return 0;
b = SSL_get_wbio(ssl);
if (b == NULL || !BIO_get_ktls_send(b)) {
- ssl->record_padding_cb = cb;
+ sc->record_padding_cb = cb;
return 1;
}
return 0;
void SSL_set_record_padding_callback_arg(SSL *ssl, void *arg)
{
- ssl->record_padding_arg = arg;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
+
+ if (sc == NULL)
+ return;
+
+ sc->record_padding_arg = arg;
}
void *SSL_get_record_padding_callback_arg(const SSL *ssl)
{
- return ssl->record_padding_arg;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(ssl);
+
+ if (sc == NULL)
+ return NULL;
+
+ return sc->record_padding_arg;
}
int SSL_set_block_padding(SSL *ssl, size_t block_size)
{
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
+
+ if (sc == NULL)
+ return 0;
+
/* block size of 0 or 1 is basically no padding */
if (block_size == 1)
- ssl->block_padding = 0;
+ sc->block_padding = 0;
else if (block_size <= SSL3_RT_MAX_PLAIN_LENGTH)
- ssl->block_padding = block_size;
+ sc->block_padding = block_size;
else
return 0;
return 1;
int SSL_set_num_tickets(SSL *s, size_t num_tickets)
{
- s->num_tickets = num_tickets;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ sc->num_tickets = num_tickets;
return 1;
}
size_t SSL_get_num_tickets(const SSL *s)
{
- return s->num_tickets;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ return sc->num_tickets;
}
int SSL_CTX_set_num_tickets(SSL_CTX *ctx, size_t num_tickets)
}
/* Retrieve handshake hashes */
-int ssl_handshake_hash(SSL *s, unsigned char *out, size_t outlen,
+int ssl_handshake_hash(SSL_CONNECTION *s,
+ unsigned char *out, size_t outlen,
size_t *hashlen)
{
EVP_MD_CTX *ctx = NULL;
int SSL_session_reused(const SSL *s)
{
- return s->hit;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ return sc->hit;
}
int SSL_is_server(const SSL *s)
{
- return s->server;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ return sc->server;
}
#ifndef OPENSSL_NO_DEPRECATED_1_1_0
void SSL_set_security_level(SSL *s, int level)
{
- s->cert->sec_level = level;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return;
+
+ sc->cert->sec_level = level;
}
int SSL_get_security_level(const SSL *s)
{
- return s->cert->sec_level;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ return sc->cert->sec_level;
}
void SSL_set_security_callback(SSL *s,
int op, int bits, int nid,
void *other, void *ex))
{
- s->cert->sec_cb = cb;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return;
+
+ sc->cert->sec_cb = cb;
}
int (*SSL_get_security_callback(const SSL *s)) (const SSL *s,
const SSL_CTX *ctx, int op,
int bits, int nid, void *other,
void *ex) {
- return s->cert->sec_cb;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return NULL;
+
+ return sc->cert->sec_cb;
}
void SSL_set0_security_ex_data(SSL *s, void *ex)
{
- s->cert->sec_ex = ex;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return;
+
+ sc->cert->sec_ex = ex;
}
void *SSL_get0_security_ex_data(const SSL *s)
{
- return s->cert->sec_ex;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return NULL;
+
+ return sc->cert->sec_ex;
}
void SSL_CTX_set_security_level(SSL_CTX *ctx, int level)
uint64_t SSL_get_options(const SSL *s)
{
- return s->options;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ return sc->options;
}
uint64_t SSL_CTX_set_options(SSL_CTX *ctx, uint64_t op)
uint64_t SSL_set_options(SSL *s, uint64_t op)
{
- return s->options |= op;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ return sc->options |= op;
}
uint64_t SSL_CTX_clear_options(SSL_CTX *ctx, uint64_t op)
uint64_t SSL_clear_options(SSL *s, uint64_t op)
{
- return s->options &= ~op;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ return sc->options &= ~op;
}
STACK_OF(X509) *SSL_get0_verified_chain(const SSL *s)
{
- return s->verified_chain;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return NULL;
+
+ return sc->verified_chain;
}
IMPLEMENT_OBJ_BSEARCH_GLOBAL_CMP_FN(SSL_CIPHER, SSL_CIPHER, ssl_cipher_id);
* Look for data collected during ServerHello and parse if found.
* Returns the number of SCTs extracted.
*/
-static int ct_extract_tls_extension_scts(SSL *s)
+static int ct_extract_tls_extension_scts(SSL_CONNECTION *s)
{
int scts_extracted = 0;
* - 0 if no OCSP response exists or it contains no SCTs.
* - A negative integer if an error occurs.
*/
-static int ct_extract_ocsp_response_scts(SSL *s)
+static int ct_extract_ocsp_response_scts(SSL_CONNECTION *s)
{
# ifndef OPENSSL_NO_OCSP
int scts_extracted = 0;
* Return the number of SCTs extracted, or a negative integer if an error
* occurs.
*/
-static int ct_extract_x509v3_extension_scts(SSL *s)
+static int ct_extract_x509v3_extension_scts(SSL_CONNECTION *s)
{
int scts_extracted = 0;
X509 *cert = s->session != NULL ? s->session->peer : NULL;
*/
const STACK_OF(SCT) *SSL_get0_peer_scts(SSL *s)
{
- if (!s->scts_parsed) {
- if (ct_extract_tls_extension_scts(s) < 0 ||
- ct_extract_ocsp_response_scts(s) < 0 ||
- ct_extract_x509v3_extension_scts(s) < 0)
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return NULL;
+
+ if (!sc->scts_parsed) {
+ if (ct_extract_tls_extension_scts(sc) < 0 ||
+ ct_extract_ocsp_response_scts(sc) < 0 ||
+ ct_extract_x509v3_extension_scts(sc) < 0)
goto err;
- s->scts_parsed = 1;
+ sc->scts_parsed = 1;
}
- return s->scts;
+ return sc->scts;
err:
return NULL;
}
int SSL_set_ct_validation_callback(SSL *s, ssl_ct_validation_cb callback,
void *arg)
{
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
/*
* Since code exists that uses the custom extension handler for CT, look
* for this and throw an error if they have already registered to use CT.
return 0;
}
- s->ct_validation_callback = callback;
- s->ct_validation_callback_arg = arg;
+ sc->ct_validation_callback = callback;
+ sc->ct_validation_callback_arg = arg;
return 1;
}
int SSL_ct_is_enabled(const SSL *s)
{
- return s->ct_validation_callback != NULL;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ return sc->ct_validation_callback != NULL;
}
int SSL_CTX_ct_is_enabled(const SSL_CTX *ctx)
return ctx->ct_validation_callback != NULL;
}
-int ssl_validate_ct(SSL *s)
+int ssl_validate_ct(SSL_CONNECTION *s)
{
int ret = 0;
X509 *cert = s->session != NULL ? s->session->peer : NULL;
}
}
- ctx = CT_POLICY_EVAL_CTX_new_ex(s->ctx->libctx, s->ctx->propq);
+ ctx = CT_POLICY_EVAL_CTX_new_ex(SSL_CONNECTION_GET_CTX(s)->libctx,
+ SSL_CONNECTION_GET_CTX(s)->propq);
if (ctx == NULL) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
goto end;
issuer = sk_X509_value(s->verified_chain, 1);
CT_POLICY_EVAL_CTX_set1_cert(ctx, cert);
CT_POLICY_EVAL_CTX_set1_issuer(ctx, issuer);
- CT_POLICY_EVAL_CTX_set_shared_CTLOG_STORE(ctx, s->ctx->ctlog_store);
+ CT_POLICY_EVAL_CTX_set_shared_CTLOG_STORE(ctx,
+ SSL_CONNECTION_GET_CTX(s)->ctlog_store);
CT_POLICY_EVAL_CTX_set_time(
- ctx, (uint64_t)SSL_SESSION_get_time(SSL_get0_session(s)) * 1000);
+ ctx, (uint64_t)SSL_SESSION_get_time(s->session) * 1000);
- scts = SSL_get0_peer_scts(s);
+ scts = SSL_get0_peer_scts(SSL_CONNECTION_GET_SSL(s));
/*
* This function returns success (> 0) only when all the SCTs are valid, 0
int SSL_client_hello_isv2(SSL *s)
{
- if (s->clienthello == NULL)
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ if (sc->clienthello == NULL)
return 0;
- return s->clienthello->isv2;
+ return sc->clienthello->isv2;
}
unsigned int SSL_client_hello_get0_legacy_version(SSL *s)
{
- if (s->clienthello == NULL)
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ if (sc->clienthello == NULL)
return 0;
- return s->clienthello->legacy_version;
+ return sc->clienthello->legacy_version;
}
size_t SSL_client_hello_get0_random(SSL *s, const unsigned char **out)
{
- if (s->clienthello == NULL)
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ if (sc->clienthello == NULL)
return 0;
if (out != NULL)
- *out = s->clienthello->random;
+ *out = sc->clienthello->random;
return SSL3_RANDOM_SIZE;
}
size_t SSL_client_hello_get0_session_id(SSL *s, const unsigned char **out)
{
- if (s->clienthello == NULL)
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ if (sc->clienthello == NULL)
return 0;
if (out != NULL)
- *out = s->clienthello->session_id;
- return s->clienthello->session_id_len;
+ *out = sc->clienthello->session_id;
+ return sc->clienthello->session_id_len;
}
size_t SSL_client_hello_get0_ciphers(SSL *s, const unsigned char **out)
{
- if (s->clienthello == NULL)
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ if (sc->clienthello == NULL)
return 0;
if (out != NULL)
- *out = PACKET_data(&s->clienthello->ciphersuites);
- return PACKET_remaining(&s->clienthello->ciphersuites);
+ *out = PACKET_data(&sc->clienthello->ciphersuites);
+ return PACKET_remaining(&sc->clienthello->ciphersuites);
}
size_t SSL_client_hello_get0_compression_methods(SSL *s, const unsigned char **out)
{
- if (s->clienthello == NULL)
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ if (sc->clienthello == NULL)
return 0;
if (out != NULL)
- *out = s->clienthello->compressions;
- return s->clienthello->compressions_len;
+ *out = sc->clienthello->compressions;
+ return sc->clienthello->compressions_len;
}
int SSL_client_hello_get1_extensions_present(SSL *s, int **out, size_t *outlen)
RAW_EXTENSION *ext;
int *present;
size_t num = 0, i;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
- if (s->clienthello == NULL || out == NULL || outlen == NULL)
+ if (sc == NULL)
return 0;
- for (i = 0; i < s->clienthello->pre_proc_exts_len; i++) {
- ext = s->clienthello->pre_proc_exts + i;
+
+ if (sc->clienthello == NULL || out == NULL || outlen == NULL)
+ return 0;
+ for (i = 0; i < sc->clienthello->pre_proc_exts_len; i++) {
+ ext = sc->clienthello->pre_proc_exts + i;
if (ext->present)
num++;
}
ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
return 0;
}
- for (i = 0; i < s->clienthello->pre_proc_exts_len; i++) {
- ext = s->clienthello->pre_proc_exts + i;
+ for (i = 0; i < sc->clienthello->pre_proc_exts_len; i++) {
+ ext = sc->clienthello->pre_proc_exts + i;
if (ext->present) {
if (ext->received_order >= num)
goto err;
{
RAW_EXTENSION *ext;
size_t num = 0, i;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
- if (s->clienthello == NULL || num_exts == NULL)
+ if (sc->clienthello == NULL || num_exts == NULL)
return 0;
- for (i = 0; i < s->clienthello->pre_proc_exts_len; i++) {
- ext = s->clienthello->pre_proc_exts + i;
+ for (i = 0; i < sc->clienthello->pre_proc_exts_len; i++) {
+ ext = sc->clienthello->pre_proc_exts + i;
if (ext->present)
num++;
}
}
if (*num_exts < num)
return 0;
- for (i = 0; i < s->clienthello->pre_proc_exts_len; i++) {
- ext = s->clienthello->pre_proc_exts + i;
+ for (i = 0; i < sc->clienthello->pre_proc_exts_len; i++) {
+ ext = sc->clienthello->pre_proc_exts + i;
if (ext->present) {
if (ext->received_order >= num)
return 0;
{
size_t i;
RAW_EXTENSION *r;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
- if (s->clienthello == NULL)
+ if (sc == NULL)
return 0;
- for (i = 0; i < s->clienthello->pre_proc_exts_len; ++i) {
- r = s->clienthello->pre_proc_exts + i;
+
+ if (sc->clienthello == NULL)
+ return 0;
+ for (i = 0; i < sc->clienthello->pre_proc_exts_len; ++i) {
+ r = sc->clienthello->pre_proc_exts + i;
if (r->present && r->type == type) {
if (out != NULL)
*out = PACKET_data(&r->data);
int SSL_free_buffers(SSL *ssl)
{
- RECORD_LAYER *rl = &ssl->rlayer;
+ RECORD_LAYER *rl;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
+
+ if (sc == NULL)
+ return 0;
+
+ rl = &sc->rlayer;
if (RECORD_LAYER_read_pending(rl) || RECORD_LAYER_write_pending(rl))
return 0;
int SSL_alloc_buffers(SSL *ssl)
{
- return ssl3_setup_buffers(ssl);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
+
+ if (sc == NULL)
+ return 0;
+
+ return ssl3_setup_buffers(sc);
}
void SSL_CTX_set_keylog_callback(SSL_CTX *ctx, SSL_CTX_keylog_cb_func cb)
}
static int nss_keylog_int(const char *prefix,
- SSL *ssl,
+ SSL_CONNECTION *sc,
const uint8_t *parameter_1,
size_t parameter_1_len,
const uint8_t *parameter_2,
size_t out_len = 0;
size_t i;
size_t prefix_len;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(sc);
- if (ssl->ctx->keylog_callback == NULL)
+ if (sctx->keylog_callback == NULL)
return 1;
/*
prefix_len = strlen(prefix);
out_len = prefix_len + (2 * parameter_1_len) + (2 * parameter_2_len) + 3;
if ((out = cursor = OPENSSL_malloc(out_len)) == NULL) {
- SSLfatal(ssl, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
return 0;
}
}
*cursor = '\0';
- ssl->ctx->keylog_callback(ssl, (const char *)out);
+ sctx->keylog_callback(SSL_CONNECTION_GET_SSL(sc), (const char *)out);
OPENSSL_clear_free(out, out_len);
return 1;
}
-int ssl_log_rsa_client_key_exchange(SSL *ssl,
+int ssl_log_rsa_client_key_exchange(SSL_CONNECTION *sc,
const uint8_t *encrypted_premaster,
size_t encrypted_premaster_len,
const uint8_t *premaster,
size_t premaster_len)
{
if (encrypted_premaster_len < 8) {
- SSLfatal(ssl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
+ SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return 0;
}
/* We only want the first 8 bytes of the encrypted premaster as a tag. */
return nss_keylog_int("RSA",
- ssl,
+ sc,
encrypted_premaster,
8,
premaster,
premaster_len);
}
-int ssl_log_secret(SSL *ssl,
+int ssl_log_secret(SSL_CONNECTION *sc,
const char *label,
const uint8_t *secret,
size_t secret_len)
{
return nss_keylog_int(label,
- ssl,
- ssl->s3.client_random,
+ sc,
+ sc->s3.client_random,
SSL3_RANDOM_SIZE,
secret,
secret_len);
#define SSLV2_CIPHER_LEN 3
-int ssl_cache_cipherlist(SSL *s, PACKET *cipher_suites, int sslv2format)
+int ssl_cache_cipherlist(SSL_CONNECTION *s, PACKET *cipher_suites, int sslv2format)
{
int n;
STACK_OF(SSL_CIPHER) **scsvs)
{
PACKET pkt;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
if (!PACKET_buf_init(&pkt, bytes, len))
return 0;
- return bytes_to_cipher_list(s, &pkt, sk, scsvs, isv2format, 0);
+ return ossl_bytes_to_cipher_list(sc, &pkt, sk, scsvs, isv2format, 0);
}
-int bytes_to_cipher_list(SSL *s, PACKET *cipher_suites,
- STACK_OF(SSL_CIPHER) **skp,
- STACK_OF(SSL_CIPHER) **scsvs_out,
- int sslv2format, int fatal)
+int ossl_bytes_to_cipher_list(SSL_CONNECTION *s, PACKET *cipher_suites,
+ STACK_OF(SSL_CIPHER) **skp,
+ STACK_OF(SSL_CIPHER) **scsvs_out,
+ int sslv2format, int fatal)
{
const SSL_CIPHER *c;
STACK_OF(SSL_CIPHER) *sk = NULL;
int SSL_set_max_early_data(SSL *s, uint32_t max_early_data)
{
- s->max_early_data = max_early_data;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ sc->max_early_data = max_early_data;
return 1;
}
uint32_t SSL_get_max_early_data(const SSL *s)
{
- return s->max_early_data;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ return sc->max_early_data;
}
int SSL_CTX_set_recv_max_early_data(SSL_CTX *ctx, uint32_t recv_max_early_data)
int SSL_set_recv_max_early_data(SSL *s, uint32_t recv_max_early_data)
{
- s->recv_max_early_data = recv_max_early_data;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ sc->recv_max_early_data = recv_max_early_data;
return 1;
}
uint32_t SSL_get_recv_max_early_data(const SSL *s)
{
- return s->recv_max_early_data;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ return sc->recv_max_early_data;
}
-__owur unsigned int ssl_get_max_send_fragment(const SSL *ssl)
+__owur unsigned int ssl_get_max_send_fragment(const SSL_CONNECTION *sc)
{
/* Return any active Max Fragment Len extension */
- if (ssl->session != NULL && USE_MAX_FRAGMENT_LENGTH_EXT(ssl->session))
- return GET_MAX_FRAGMENT_LENGTH(ssl->session);
+ if (sc->session != NULL && USE_MAX_FRAGMENT_LENGTH_EXT(sc->session))
+ return GET_MAX_FRAGMENT_LENGTH(sc->session);
/* return current SSL connection setting */
- return ssl->max_send_fragment;
+ return sc->max_send_fragment;
}
-__owur unsigned int ssl_get_split_send_fragment(const SSL *ssl)
+__owur unsigned int ssl_get_split_send_fragment(const SSL_CONNECTION *sc)
{
/* Return a value regarding an active Max Fragment Len extension */
- if (ssl->session != NULL && USE_MAX_FRAGMENT_LENGTH_EXT(ssl->session)
- && ssl->split_send_fragment > GET_MAX_FRAGMENT_LENGTH(ssl->session))
- return GET_MAX_FRAGMENT_LENGTH(ssl->session);
+ if (sc->session != NULL && USE_MAX_FRAGMENT_LENGTH_EXT(sc->session)
+ && sc->split_send_fragment > GET_MAX_FRAGMENT_LENGTH(sc->session))
+ return GET_MAX_FRAGMENT_LENGTH(sc->session);
/* else limit |split_send_fragment| to current |max_send_fragment| */
- if (ssl->split_send_fragment > ssl->max_send_fragment)
- return ssl->max_send_fragment;
+ if (sc->split_send_fragment > sc->max_send_fragment)
+ return sc->max_send_fragment;
/* return current SSL connection setting */
- return ssl->split_send_fragment;
+ return sc->split_send_fragment;
}
int SSL_stateless(SSL *s)
{
int ret;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ /* TODO(QUIC): This will need further work. */
+ if (sc == NULL)
+ return 0;
/* Ensure there is no state left over from a previous invocation */
if (!SSL_clear(s))
ERR_clear_error();
- s->s3.flags |= TLS1_FLAGS_STATELESS;
+ sc->s3.flags |= TLS1_FLAGS_STATELESS;
ret = SSL_accept(s);
- s->s3.flags &= ~TLS1_FLAGS_STATELESS;
+ sc->s3.flags &= ~TLS1_FLAGS_STATELESS;
- if (ret > 0 && s->ext.cookieok)
+ if (ret > 0 && sc->ext.cookieok)
return 1;
- if (s->hello_retry_request == SSL_HRR_PENDING && !ossl_statem_in_error(s))
+ if (sc->hello_retry_request == SSL_HRR_PENDING && !ossl_statem_in_error(sc))
return 0;
return -1;
void SSL_set_post_handshake_auth(SSL *ssl, int val)
{
- ssl->pha_enabled = val;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
+
+ if (sc == NULL)
+ return;
+
+ sc->pha_enabled = val;
}
int SSL_verify_client_post_handshake(SSL *ssl)
{
- if (!SSL_IS_TLS13(ssl)) {
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
+
+ if (sc == NULL)
+ return 0;
+
+ if (!SSL_CONNECTION_IS_TLS13(sc)) {
ERR_raise(ERR_LIB_SSL, SSL_R_WRONG_SSL_VERSION);
return 0;
}
- if (!ssl->server) {
+ if (!sc->server) {
ERR_raise(ERR_LIB_SSL, SSL_R_NOT_SERVER);
return 0;
}
return 0;
}
- switch (ssl->post_handshake_auth) {
+ switch (sc->post_handshake_auth) {
case SSL_PHA_NONE:
ERR_raise(ERR_LIB_SSL, SSL_R_EXTENSION_NOT_RECEIVED);
return 0;
return 0;
}
- ssl->post_handshake_auth = SSL_PHA_REQUEST_PENDING;
+ sc->post_handshake_auth = SSL_PHA_REQUEST_PENDING;
/* checks verify_mode and algorithm_auth */
- if (!send_certificate_request(ssl)) {
- ssl->post_handshake_auth = SSL_PHA_EXT_RECEIVED; /* restore on error */
+ if (!send_certificate_request(sc)) {
+ sc->post_handshake_auth = SSL_PHA_EXT_RECEIVED; /* restore on error */
ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_CONFIG);
return 0;
}
- ossl_statem_set_in_init(ssl, 1);
+ ossl_statem_set_in_init(sc, 1);
return 1;
}
SSL_allow_early_data_cb_fn cb,
void *arg)
{
- s->allow_early_data_cb = cb;
- s->allow_early_data_cb_data = arg;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return;
+
+ sc->allow_early_data_cb = cb;
+ sc->allow_early_data_cb_data = arg;
}
const EVP_CIPHER *ssl_evp_cipher_fetch(OSSL_LIB_CTX *libctx,
int SSL_set0_tmp_dh_pkey(SSL *s, EVP_PKEY *dhpkey)
{
- if (!ssl_security(s, SSL_SECOP_TMP_DH,
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ if (!ssl_security(sc, SSL_SECOP_TMP_DH,
EVP_PKEY_get_security_bits(dhpkey), 0, dhpkey)) {
ERR_raise(ERR_LIB_SSL, SSL_R_DH_KEY_TOO_SMALL);
return 0;
}
- EVP_PKEY_free(s->cert->dh_tmp);
- s->cert->dh_tmp = dhpkey;
+ EVP_PKEY_free(sc->cert->dh_tmp);
+ sc->cert->dh_tmp = dhpkey;
return 1;
}
# define SSL3_CK_CIPHERSUITE_FLAG 0x03000000
/* Check if an SSL structure is using DTLS */
-# define SSL_IS_DTLS(s) (s->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS)
+# define SSL_CONNECTION_IS_DTLS(s) \
+ (SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS)
/* Check if we are using TLSv1.3 */
-# define SSL_IS_TLS13(s) (!SSL_IS_DTLS(s) \
- && (s)->method->version >= TLS1_3_VERSION \
- && (s)->method->version != TLS_ANY_VERSION)
+# define SSL_CONNECTION_IS_TLS13(s) (!SSL_CONNECTION_IS_DTLS(s) \
+ && SSL_CONNECTION_GET_SSL(s)->method->version >= TLS1_3_VERSION \
+ && SSL_CONNECTION_GET_SSL(s)->method->version != TLS_ANY_VERSION)
-# define SSL_TREAT_AS_TLS13(s) \
- (SSL_IS_TLS13(s) || (s)->early_data_state == SSL_EARLY_DATA_CONNECTING \
+# define SSL_CONNECTION_TREAT_AS_TLS13(s) \
+ (SSL_CONNECTION_IS_TLS13(s) \
+ || (s)->early_data_state == SSL_EARLY_DATA_CONNECTING \
|| (s)->early_data_state == SSL_EARLY_DATA_CONNECT_RETRY \
|| (s)->early_data_state == SSL_EARLY_DATA_WRITING \
|| (s)->early_data_state == SSL_EARLY_DATA_WRITE_RETRY \
|| (s)->hello_retry_request == SSL_HRR_PENDING)
-# define SSL_IS_FIRST_HANDSHAKE(S) ((s)->s3.tmp.finish_md_len == 0 \
+# define SSL_IS_FIRST_HANDSHAKE(s) ((s)->s3.tmp.finish_md_len == 0 \
|| (s)->s3.tmp.peer_finish_md_len == 0)
/* See if we need explicit IV */
# define SSL_USE_EXPLICIT_IV(s) \
- (s->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_EXPLICIT_IV)
+ (SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_EXPLICIT_IV)
/*
* See if we use signature algorithms extension and signature algorithm
* before signatures.
*/
# define SSL_USE_SIGALGS(s) \
- (s->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_SIGALGS)
+ (SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_SIGALGS)
/*
* Allow TLS 1.2 ciphersuites: applies to DTLS 1.2 as well as TLS 1.2: may
* apply to others in future.
*/
# define SSL_USE_TLS1_2_CIPHERS(s) \
- (s->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_TLS1_2_CIPHERS)
+ (SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_TLS1_2_CIPHERS)
/*
* Determine if a client can use TLS 1.2 ciphersuites: can't rely on method
* flags because it may not be set to correct version yet.
*/
# define SSL_CLIENT_USE_TLS1_2_CIPHERS(s) \
- ((!SSL_IS_DTLS(s) && s->client_version >= TLS1_2_VERSION) || \
- (SSL_IS_DTLS(s) && DTLS_VERSION_GE(s->client_version, DTLS1_2_VERSION)))
+ ((!SSL_CONNECTION_IS_DTLS(s) && s->client_version >= TLS1_2_VERSION) || \
+ (SSL_CONNECTION_IS_DTLS(s) && DTLS_VERSION_GE(s->client_version, DTLS1_2_VERSION)))
/*
* Determine if a client should send signature algorithms extension:
* as with TLS1.2 cipher we can't rely on method flags.
int version;
unsigned flags;
unsigned long mask;
- int (*ssl_new) (SSL *s);
- int (*ssl_clear) (SSL *s);
+ SSL *(*ssl_new) (SSL_CTX *ctx);
void (*ssl_free) (SSL *s);
+ int (*ssl_reset) (SSL *s);
+ int (*ssl_init) (SSL *s);
+ int (*ssl_clear) (SSL *s);
+ void (*ssl_deinit) (SSL *s);
int (*ssl_accept) (SSL *s);
int (*ssl_connect) (SSL *s);
int (*ssl_read) (SSL *s, void *buf, size_t len, size_t *readbytes);
typedef struct cert_pkey_st CERT_PKEY;
+#define SSL_TYPE_SSL_CONNECTION 0
+#define SSL_TYPE_QUIC_CONNECTION 1
+#define SSL_TYPE_QUIC_STREAM 2
+
struct ssl_st {
+ int type;
+ SSL_CTX *ctx;
+ const SSL_METHOD *method;
+ CRYPTO_REF_COUNT references;
+ CRYPTO_RWLOCK *lock;
+ /* extra application data */
+ CRYPTO_EX_DATA ex_data;
+};
+
+struct ssl_connection_st {
+ /* type identifier and common data */
+ struct ssl_st ssl;
+#ifndef OPENSSL_NO_QUIC
+ /* pointer to parent SSL of QUIC_CONNECTION or self */
+ struct ssl_st *user_ssl;
+#endif
/*
* protocol version (one of SSL2_VERSION, SSL3_VERSION, TLS1_VERSION,
* DTLS1_VERSION)
*/
int version;
- /* SSLv3 */
- const SSL_METHOD *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
SSL_psk_find_session_cb_func psk_find_session_cb;
SSL_psk_use_session_cb_func psk_use_session_cb;
- SSL_CTX *ctx;
/* Verified chain of peer */
STACK_OF(X509) *verified_chain;
long verify_result;
- /* extra application data */
- CRYPTO_EX_DATA ex_data;
/*
* What we put in certificate_authorities extension for TLS 1.3
* (ClientHello and CertificateRequest) or just client cert requests for
*/
STACK_OF(X509_NAME) *ca_names;
STACK_OF(X509_NAME) *client_ca_names;
- CRYPTO_REF_COUNT references;
/* protocol behaviour */
uint64_t options;
/* API behaviour */
void *record_padding_arg;
size_t block_padding;
- CRYPTO_RWLOCK *lock;
-
/* The number of TLS1.3 tickets to automatically send */
size_t num_tickets;
/* The number of TLS1.3 tickets actually sent so far */
size_t shared_sigalgslen;
};
+# define SSL_CONNECTION_FROM_SSL_ONLY_int(ssl, c) \
+ ((ssl) == NULL ? NULL \
+ : ((ssl)->type == SSL_TYPE_SSL_CONNECTION \
+ ? (c SSL_CONNECTION *)(ssl) \
+ : NULL))
+# define SSL_CONNECTION_NO_CONST
+# define SSL_CONNECTION_FROM_SSL_ONLY(ssl) \
+ SSL_CONNECTION_FROM_SSL_ONLY_int(ssl, SSL_CONNECTION_NO_CONST)
+# define SSL_CONNECTION_FROM_CONST_SSL_ONLY(ssl) \
+ SSL_CONNECTION_FROM_SSL_ONLY_int(ssl, const)
+# define SSL_CONNECTION_GET_CTX(sc) ((sc)->ssl.ctx)
+# ifndef OPENSSL_NO_QUIC
+# include "quic/quic_local.h"
+# define SSL_CONNECTION_FROM_SSL_int(ssl, c) \
+ ((ssl) == NULL ? NULL \
+ : ((ssl)->type == SSL_TYPE_SSL_CONNECTION \
+ ? (c SSL_CONNECTION *)(ssl) \
+ : ((ssl)->type == SSL_TYPE_QUIC_CONNECTION \
+ ? (c SSL_CONNECTION *)((c QUIC_CONNECTION *)(ssl))->tls \
+ : NULL)))
+# define SSL_CONNECTION_FROM_SSL(ssl) \
+ SSL_CONNECTION_FROM_SSL_int(ssl, SSL_CONNECTION_NO_CONST)
+# define SSL_CONNECTION_FROM_CONST_SSL(ssl) \
+ SSL_CONNECTION_FROM_SSL_int(ssl, const)
+# define SSL_CONNECTION_GET_SSL(sc) ((sc)->user_ssl)
+# else
+# define SSL_CONNECTION_FROM_SSL(ssl) \
+ SSL_CONNECTION_FROM_SSL_ONLY_int(ssl, SSL_CONNECTION_NO_CONST)
+# define SSL_CONNECTION_FROM_CONST_SSL(ssl) \
+ SSL_CONNECTION_FROM_SSL_ONLY_int(ssl, const)
+# define SSL_CONNECTION_GET_SSL(sc) (&(sc)->ssl)
+# endif
+
/*
* Structure containing table entry of values associated with the signature
* algorithms (signature scheme) extension
* of a mess of functions, but hell, think of it as an opaque structure :-)
*/
typedef struct ssl3_enc_method {
- int (*enc) (SSL *, SSL3_RECORD *, size_t, int, SSL_MAC_BUF *, size_t);
- int (*mac) (SSL *, SSL3_RECORD *, unsigned char *, int);
- int (*setup_key_block) (SSL *);
- int (*generate_master_secret) (SSL *, unsigned char *, unsigned char *,
- size_t, size_t *);
- int (*change_cipher_state) (SSL *, int);
- size_t (*final_finish_mac) (SSL *, const char *, size_t, unsigned char *);
+ int (*enc) (SSL_CONNECTION *, SSL3_RECORD *, size_t, int,
+ SSL_MAC_BUF *, size_t);
+ int (*mac) (SSL_CONNECTION *, SSL3_RECORD *, unsigned char *, int);
+ int (*setup_key_block) (SSL_CONNECTION *);
+ int (*generate_master_secret) (SSL_CONNECTION *, unsigned char *,
+ unsigned char *, size_t, size_t *);
+ int (*change_cipher_state) (SSL_CONNECTION *, int);
+ size_t (*final_finish_mac) (SSL_CONNECTION *, const char *, size_t,
+ unsigned char *);
const char *client_finished_label;
size_t client_finished_label_len;
const char *server_finished_label;
size_t server_finished_label_len;
int (*alert_value) (int);
- int (*export_keying_material) (SSL *, unsigned char *, size_t,
+ int (*export_keying_material) (SSL_CONNECTION *, unsigned char *, size_t,
const char *, size_t,
const unsigned char *, size_t,
int use_context);
/* Various flags indicating protocol version requirements */
uint32_t enc_flags;
/* Set the handshake header */
- int (*set_handshake_header) (SSL *s, WPACKET *pkt, int type);
+ int (*set_handshake_header) (SSL_CONNECTION *s, WPACKET *pkt, int type);
/* Close construction of the handshake message */
- int (*close_construct_packet) (SSL *s, WPACKET *pkt, int htype);
+ int (*close_construct_packet) (SSL_CONNECTION *s, WPACKET *pkt, int htype);
/* Write out handshake message */
- int (*do_write) (SSL *s);
+ int (*do_write) (SSL_CONNECTION *s);
} SSL3_ENC_METHOD;
# define ssl_set_handshake_header(s, pkt, htype) \
- s->method->ssl3_enc->set_handshake_header((s), (pkt), (htype))
+ SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->set_handshake_header((s), (pkt), (htype))
# define ssl_close_construct_packet(s, pkt, htype) \
- s->method->ssl3_enc->close_construct_packet((s), (pkt), (htype))
-# define ssl_do_write(s) s->method->ssl3_enc->do_write(s)
+ SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->close_construct_packet((s), (pkt), (htype))
+# define ssl_do_write(s) SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->do_write(s)
/* Values for enc_flags */
version, \
flags, \
mask, \
+ ossl_ssl_connection_new, \
+ ossl_ssl_connection_free, \
+ ossl_ssl_connection_reset, \
tls1_new, \
tls1_clear, \
tls1_free, \
SSL3_VERSION, \
SSL_METHOD_NO_FIPS | SSL_METHOD_NO_SUITEB, \
SSL_OP_NO_SSLv3, \
+ ossl_ssl_connection_new, \
+ ossl_ssl_connection_free, \
+ ossl_ssl_connection_reset, \
ssl3_new, \
ssl3_clear, \
ssl3_free, \
version, \
flags, \
mask, \
+ ossl_ssl_connection_new, \
+ ossl_ssl_connection_free, \
+ ossl_ssl_connection_reset, \
dtls1_new, \
dtls1_clear, \
dtls1_free, \
}
struct openssl_ssl_test_functions {
- int (*p_ssl_init_wbio_buffer) (SSL *s);
- int (*p_ssl3_setup_buffers) (SSL *s);
+ int (*p_ssl_init_wbio_buffer) (SSL_CONNECTION *s);
+ int (*p_ssl3_setup_buffers) (SSL_CONNECTION *s);
};
const char *ssl_protocol_to_string(int version);
/* Returns true if certificate and private key for 'idx' are present */
-static ossl_inline int ssl_has_cert(const SSL *s, int idx)
+static ossl_inline int ssl_has_cert(const SSL_CONNECTION *s, int idx)
{
if (idx < 0 || idx >= SSL_PKEY_NUM)
return 0;
&& s->cert->pkeys[idx].privatekey != NULL;
}
-static ossl_inline void tls1_get_peer_groups(SSL *s, const uint16_t **pgroups,
+static ossl_inline void tls1_get_peer_groups(SSL_CONNECTION *s,
+ const uint16_t **pgroups,
size_t *pgroupslen)
{
*pgroups = s->ext.peer_supportedgroups;
# ifndef OPENSSL_UNIT_TEST
+__owur int ossl_ssl_init(SSL *ssl, SSL_CTX *ctx, int type);
+__owur SSL *ossl_ssl_connection_new(SSL_CTX *ctx);
+void ossl_ssl_connection_free(SSL *ssl);
+__owur int ossl_ssl_connection_reset(SSL *ssl);
+
__owur int ssl_read_internal(SSL *s, void *buf, size_t num, size_t *readbytes);
__owur int ssl_write_internal(SSL *s, const void *buf, size_t num, size_t *written);
-void ssl_clear_cipher_ctx(SSL *s);
-int ssl_clear_bad_session(SSL *s);
+void ssl_clear_cipher_ctx(SSL_CONNECTION *s);
+int ssl_clear_bad_session(SSL_CONNECTION *s);
__owur CERT *ssl_cert_new(void);
__owur CERT *ssl_cert_dup(CERT *cert);
void ssl_cert_clear_certs(CERT *c);
void ssl_cert_free(CERT *c);
-__owur int ssl_generate_session_id(SSL *s, SSL_SESSION *ss);
-__owur int ssl_get_new_session(SSL *s, int session);
-__owur SSL_SESSION *lookup_sess_in_cache(SSL *s, const unsigned char *sess_id,
+__owur int ssl_generate_session_id(SSL_CONNECTION *s, SSL_SESSION *ss);
+__owur int ssl_get_new_session(SSL_CONNECTION *s, int session);
+__owur SSL_SESSION *lookup_sess_in_cache(SSL_CONNECTION *s,
+ const unsigned char *sess_id,
size_t sess_id_len);
-__owur int ssl_get_prev_session(SSL *s, CLIENTHELLO_MSG *hello);
+__owur int ssl_get_prev_session(SSL_CONNECTION *s, CLIENTHELLO_MSG *hello);
__owur SSL_SESSION *ssl_session_dup(const SSL_SESSION *src, int ticket);
__owur int ssl_cipher_id_cmp(const SSL_CIPHER *a, const SSL_CIPHER *b);
DECLARE_OBJ_BSEARCH_GLOBAL_CMP_FN(SSL_CIPHER, SSL_CIPHER, ssl_cipher_id);
STACK_OF(SSL_CIPHER) **cipher_list_by_id,
const char *rule_str,
CERT *c);
-__owur int ssl_cache_cipherlist(SSL *s, PACKET *cipher_suites, int sslv2format);
-__owur int bytes_to_cipher_list(SSL *s, PACKET *cipher_suites,
- STACK_OF(SSL_CIPHER) **skp,
- STACK_OF(SSL_CIPHER) **scsvs, int sslv2format,
- int fatal);
-void ssl_update_cache(SSL *s, int mode);
+__owur int ssl_cache_cipherlist(SSL_CONNECTION *s, PACKET *cipher_suites,
+ int sslv2format);
+__owur int ossl_bytes_to_cipher_list(SSL_CONNECTION *s, PACKET *cipher_suites,
+ STACK_OF(SSL_CIPHER) **skp,
+ STACK_OF(SSL_CIPHER) **scsvs, int sslv2format,
+ int fatal);
+void ssl_update_cache(SSL_CONNECTION *s, int mode);
__owur int ssl_cipher_get_evp_cipher(SSL_CTX *ctx, const SSL_CIPHER *sslc,
const EVP_CIPHER **enc);
__owur int ssl_cipher_get_evp(SSL_CTX *ctxc, const SSL_SESSION *s,
size_t *int_overhead, size_t *blocksize,
size_t *ext_overhead);
__owur int ssl_cert_is_disabled(SSL_CTX *ctx, size_t idx);
-__owur const SSL_CIPHER *ssl_get_cipher_by_char(SSL *ssl,
+__owur const SSL_CIPHER *ssl_get_cipher_by_char(SSL_CONNECTION *ssl,
const unsigned char *ptr,
int all);
-__owur int ssl_cert_set0_chain(SSL *s, SSL_CTX *ctx, STACK_OF(X509) *chain);
-__owur int ssl_cert_set1_chain(SSL *s, SSL_CTX *ctx, STACK_OF(X509) *chain);
-__owur int ssl_cert_add0_chain_cert(SSL *s, SSL_CTX *ctx, X509 *x);
-__owur int ssl_cert_add1_chain_cert(SSL *s, SSL_CTX *ctx, X509 *x);
+__owur int ssl_cert_set0_chain(SSL_CONNECTION *s, SSL_CTX *ctx,
+ STACK_OF(X509) *chain);
+__owur int ssl_cert_set1_chain(SSL_CONNECTION *s, SSL_CTX *ctx,
+ STACK_OF(X509) *chain);
+__owur int ssl_cert_add0_chain_cert(SSL_CONNECTION *s, SSL_CTX *ctx, X509 *x);
+__owur int ssl_cert_add1_chain_cert(SSL_CONNECTION *s, SSL_CTX *ctx, X509 *x);
__owur int ssl_cert_select_current(CERT *c, X509 *x);
__owur int ssl_cert_set_current(CERT *c, long arg);
void ssl_cert_set_cert_cb(CERT *c, int (*cb) (SSL *ssl, void *arg), void *arg);
-__owur int ssl_verify_cert_chain(SSL *s, STACK_OF(X509) *sk);
-__owur int ssl_build_cert_chain(SSL *s, SSL_CTX *ctx, int flags);
+__owur int ssl_verify_cert_chain(SSL_CONNECTION *s, STACK_OF(X509) *sk);
+__owur int ssl_build_cert_chain(SSL_CONNECTION *s, SSL_CTX *ctx, int flags);
__owur int ssl_cert_set_cert_store(CERT *c, X509_STORE *store, int chain,
int ref);
__owur int ssl_cert_get_cert_store(CERT *c, X509_STORE **pstore, int chain);
-__owur int ssl_security(const SSL *s, int op, int bits, int nid, void *other);
+__owur int ssl_security(const SSL_CONNECTION *s, int op, int bits, int nid,
+ void *other);
__owur int ssl_ctx_security(const SSL_CTX *ctx, int op, int bits, int nid,
void *other);
int ssl_get_security_level_bits(const SSL *s, const SSL_CTX *ctx, int *levelp);
int ssl_undefined_function(SSL *s);
__owur int ssl_undefined_void_function(void);
__owur int ssl_undefined_const_function(const SSL *s);
-__owur int ssl_get_server_cert_serverinfo(SSL *s,
+__owur int ssl_get_server_cert_serverinfo(SSL_CONNECTION *s,
const unsigned char **serverinfo,
size_t *serverinfo_length);
-void ssl_set_masks(SSL *s);
-__owur STACK_OF(SSL_CIPHER) *ssl_get_ciphers_by_id(SSL *s);
+void ssl_set_masks(SSL_CONNECTION *s);
+__owur STACK_OF(SSL_CIPHER) *ssl_get_ciphers_by_id(SSL_CONNECTION *sc);
__owur int ssl_x509err2alert(int type);
void ssl_sort_cipher_list(void);
int ssl_load_ciphers(SSL_CTX *ctx);
__owur int ssl_setup_sig_algs(SSL_CTX *ctx);
int ssl_load_groups(SSL_CTX *ctx);
-__owur int ssl_fill_hello_random(SSL *s, int server, unsigned char *field,
- size_t len, DOWNGRADE dgrd);
-__owur int ssl_generate_master_secret(SSL *s, unsigned char *pms, size_t pmslen,
- int free_pms);
-__owur EVP_PKEY *ssl_generate_pkey(SSL *s, EVP_PKEY *pm);
-__owur int ssl_gensecret(SSL *s, unsigned char *pms, size_t pmslen);
-__owur int ssl_derive(SSL *s, EVP_PKEY *privkey, EVP_PKEY *pubkey,
+__owur int ssl_fill_hello_random(SSL_CONNECTION *s, int server,
+ unsigned char *field, size_t len,
+ DOWNGRADE dgrd);
+__owur int ssl_generate_master_secret(SSL_CONNECTION *s, unsigned char *pms,
+ size_t pmslen, int free_pms);
+__owur EVP_PKEY *ssl_generate_pkey(SSL_CONNECTION *s, EVP_PKEY *pm);
+__owur int ssl_gensecret(SSL_CONNECTION *s, unsigned char *pms, size_t pmslen);
+__owur int ssl_derive(SSL_CONNECTION *s, EVP_PKEY *privkey, EVP_PKEY *pubkey,
int genmaster);
-__owur int ssl_decapsulate(SSL *s, EVP_PKEY *privkey,
+__owur int ssl_decapsulate(SSL_CONNECTION *s, EVP_PKEY *privkey,
const unsigned char *ct, size_t ctlen,
int gensecret);
-__owur int ssl_encapsulate(SSL *s, EVP_PKEY *pubkey,
+__owur int ssl_encapsulate(SSL_CONNECTION *s, EVP_PKEY *pubkey,
unsigned char **ctp, size_t *ctlenp,
int gensecret);
__owur EVP_PKEY *ssl_dh_to_pkey(DH *dh);
__owur int ssl_set_tmp_ecdh_groups(uint16_t **pext, size_t *pextlen,
void *key);
-__owur unsigned int ssl_get_max_send_fragment(const SSL *ssl);
-__owur unsigned int ssl_get_split_send_fragment(const SSL *ssl);
+__owur unsigned int ssl_get_max_send_fragment(const SSL_CONNECTION *sc);
+__owur unsigned int ssl_get_split_send_fragment(const SSL_CONNECTION *sc);
__owur const SSL_CIPHER *ssl3_get_cipher_by_id(uint32_t id);
__owur const SSL_CIPHER *ssl3_get_cipher_by_std_name(const char *stdname);
__owur const SSL_CIPHER *ssl3_get_cipher_by_char(const unsigned char *p);
__owur int ssl3_put_cipher_by_char(const SSL_CIPHER *c, WPACKET *pkt,
size_t *len);
-int ssl3_init_finished_mac(SSL *s);
-__owur int ssl3_setup_key_block(SSL *s);
-__owur int ssl3_change_cipher_state(SSL *s, int which);
-void ssl3_cleanup_key_block(SSL *s);
-__owur int ssl3_do_write(SSL *s, int type);
-int ssl3_send_alert(SSL *s, int level, int desc);
-__owur int ssl3_generate_master_secret(SSL *s, unsigned char *out,
+int ssl3_init_finished_mac(SSL_CONNECTION *s);
+__owur int ssl3_setup_key_block(SSL_CONNECTION *s);
+__owur int ssl3_change_cipher_state(SSL_CONNECTION *s, int which);
+void ssl3_cleanup_key_block(SSL_CONNECTION *s);
+__owur int ssl3_do_write(SSL_CONNECTION *s, int type);
+int ssl3_send_alert(SSL_CONNECTION *s, int level, int desc);
+__owur int ssl3_generate_master_secret(SSL_CONNECTION *s, unsigned char *out,
unsigned char *p, size_t len,
size_t *secret_size);
-__owur int ssl3_get_req_cert_type(SSL *s, WPACKET *pkt);
+__owur int ssl3_get_req_cert_type(SSL_CONNECTION *s, WPACKET *pkt);
__owur int ssl3_num_ciphers(void);
__owur const SSL_CIPHER *ssl3_get_cipher(unsigned int u);
int ssl3_renegotiate(SSL *ssl);
void ssl3_digest_master_key_set_params(const SSL_SESSION *session,
OSSL_PARAM params[]);
__owur int ssl3_dispatch_alert(SSL *s);
-__owur size_t ssl3_final_finish_mac(SSL *s, const char *sender, size_t slen,
- unsigned char *p);
-__owur int ssl3_finish_mac(SSL *s, const unsigned char *buf, size_t len);
-void ssl3_free_digest_list(SSL *s);
-__owur unsigned long ssl3_output_cert_chain(SSL *s, WPACKET *pkt,
+__owur size_t ssl3_final_finish_mac(SSL_CONNECTION *s, const char *sender,
+ size_t slen, unsigned char *p);
+__owur int ssl3_finish_mac(SSL_CONNECTION *s, const unsigned char *buf,
+ size_t len);
+void ssl3_free_digest_list(SSL_CONNECTION *s);
+__owur unsigned long ssl3_output_cert_chain(SSL_CONNECTION *s, WPACKET *pkt,
CERT_PKEY *cpk);
-__owur const SSL_CIPHER *ssl3_choose_cipher(SSL *ssl,
+__owur const SSL_CIPHER *ssl3_choose_cipher(SSL_CONNECTION *s,
STACK_OF(SSL_CIPHER) *clnt,
STACK_OF(SSL_CIPHER) *srvr);
-__owur int ssl3_digest_cached_records(SSL *s, int keep);
+__owur int ssl3_digest_cached_records(SSL_CONNECTION *s, int keep);
__owur int ssl3_new(SSL *s);
void ssl3_free(SSL *s);
__owur int ssl3_read(SSL *s, void *buf, size_t len, size_t *readbytes);
__owur long ssl3_callback_ctrl(SSL *s, int cmd, void (*fp) (void));
__owur long ssl3_ctx_callback_ctrl(SSL_CTX *s, int cmd, void (*fp) (void));
-__owur int ssl3_do_change_cipher_spec(SSL *ssl);
+__owur int ssl3_do_change_cipher_spec(SSL_CONNECTION *s);
__owur long ssl3_default_timeout(void);
-__owur int ssl3_set_handshake_header(SSL *s, WPACKET *pkt, int htype);
-__owur int tls_close_construct_packet(SSL *s, WPACKET *pkt, int htype);
-__owur int tls_setup_handshake(SSL *s);
-__owur int dtls1_set_handshake_header(SSL *s, WPACKET *pkt, int htype);
-__owur int dtls1_close_construct_packet(SSL *s, WPACKET *pkt, int htype);
-__owur int ssl3_handshake_write(SSL *s);
+__owur int ssl3_set_handshake_header(SSL_CONNECTION *s, WPACKET *pkt,
+ int htype);
+__owur int tls_close_construct_packet(SSL_CONNECTION *s, WPACKET *pkt, int htype);
+__owur int tls_setup_handshake(SSL_CONNECTION *s);
+__owur int dtls1_set_handshake_header(SSL_CONNECTION *s, WPACKET *pkt, int htype);
+__owur int dtls1_close_construct_packet(SSL_CONNECTION *s, WPACKET *pkt, int htype);
+__owur int ssl3_handshake_write(SSL_CONNECTION *s);
-__owur int ssl_allow_compression(SSL *s);
+__owur int ssl_allow_compression(SSL_CONNECTION *s);
-__owur int ssl_version_supported(const SSL *s, int version,
+__owur int ssl_version_supported(const SSL_CONNECTION *s, int version,
const SSL_METHOD **meth);
-__owur int ssl_set_client_hello_version(SSL *s);
-__owur int ssl_check_version_downgrade(SSL *s);
+__owur int ssl_set_client_hello_version(SSL_CONNECTION *s);
+__owur int ssl_check_version_downgrade(SSL_CONNECTION *s);
__owur int ssl_set_version_bound(int method_version, int version, int *bound);
-__owur int ssl_choose_server_version(SSL *s, CLIENTHELLO_MSG *hello,
+__owur int ssl_choose_server_version(SSL_CONNECTION *s, CLIENTHELLO_MSG *hello,
DOWNGRADE *dgrd);
-__owur int ssl_choose_client_version(SSL *s, int version,
+__owur int ssl_choose_client_version(SSL_CONNECTION *s, int version,
RAW_EXTENSION *extensions);
-__owur int ssl_get_min_max_version(const SSL *s, int *min_version,
+__owur int ssl_get_min_max_version(const SSL_CONNECTION *s, int *min_version,
int *max_version, int *real_max);
__owur long tls1_default_timeout(void);
-__owur int dtls1_do_write(SSL *s, int type);
-void dtls1_set_message_header(SSL *s,
+__owur int dtls1_do_write(SSL_CONNECTION *s, int type);
+void dtls1_set_message_header(SSL_CONNECTION *s,
unsigned char mt,
size_t len,
size_t frag_off, size_t frag_len);
int dtls1_write_app_data_bytes(SSL *s, int type, const void *buf_, size_t len,
size_t *written);
-__owur int dtls1_read_failed(SSL *s, int code);
-__owur int dtls1_buffer_message(SSL *s, int ccs);
-__owur int dtls1_retransmit_message(SSL *s, unsigned short seq, int *found);
+__owur int dtls1_read_failed(SSL_CONNECTION *s, int code);
+__owur int dtls1_buffer_message(SSL_CONNECTION *s, int ccs);
+__owur int dtls1_retransmit_message(SSL_CONNECTION *s, unsigned short seq,
+ int *found);
__owur int dtls1_get_queue_priority(unsigned short seq, int is_ccs);
-int dtls1_retransmit_buffered_messages(SSL *s);
-void dtls1_clear_received_buffer(SSL *s);
-void dtls1_clear_sent_buffer(SSL *s);
+int dtls1_retransmit_buffered_messages(SSL_CONNECTION *s);
+void dtls1_clear_received_buffer(SSL_CONNECTION *s);
+void dtls1_clear_sent_buffer(SSL_CONNECTION *s);
void dtls1_get_message_header(unsigned char *data,
struct hm_header_st *msg_hdr);
__owur long dtls1_default_timeout(void);
-__owur struct timeval *dtls1_get_timeout(SSL *s, struct timeval *timeleft);
-__owur int dtls1_check_timeout_num(SSL *s);
-__owur int dtls1_handle_timeout(SSL *s);
-void dtls1_start_timer(SSL *s);
-void dtls1_stop_timer(SSL *s);
-__owur int dtls1_is_timer_expired(SSL *s);
+__owur struct timeval *dtls1_get_timeout(SSL_CONNECTION *s,
+ struct timeval *timeleft);
+__owur int dtls1_check_timeout_num(SSL_CONNECTION *s);
+__owur int dtls1_handle_timeout(SSL_CONNECTION *s);
+void dtls1_start_timer(SSL_CONNECTION *s);
+void dtls1_stop_timer(SSL_CONNECTION *s);
+__owur int dtls1_is_timer_expired(SSL_CONNECTION *s);
__owur int dtls_raw_hello_verify_request(WPACKET *pkt, unsigned char *cookie,
size_t cookie_len);
-__owur size_t dtls1_min_mtu(SSL *s);
+__owur size_t dtls1_min_mtu(SSL_CONNECTION *s);
void dtls1_hm_fragment_free(hm_fragment *frag);
-__owur int dtls1_query_mtu(SSL *s);
+__owur int dtls1_query_mtu(SSL_CONNECTION *s);
__owur int tls1_new(SSL *s);
void tls1_free(SSL *s);
__owur int dtls1_dispatch_alert(SSL *s);
-__owur int ssl_init_wbio_buffer(SSL *s);
-int ssl_free_wbio_buffer(SSL *s);
+__owur int ssl_init_wbio_buffer(SSL_CONNECTION *s);
+int ssl_free_wbio_buffer(SSL_CONNECTION *s);
-__owur int tls1_change_cipher_state(SSL *s, int which);
-__owur int tls1_setup_key_block(SSL *s);
-__owur size_t tls1_final_finish_mac(SSL *s, const char *str, size_t slen,
- unsigned char *p);
-__owur int tls1_generate_master_secret(SSL *s, unsigned char *out,
+__owur int tls1_change_cipher_state(SSL_CONNECTION *s, int which);
+__owur int tls1_setup_key_block(SSL_CONNECTION *s);
+__owur size_t tls1_final_finish_mac(SSL_CONNECTION *s, const char *str,
+ size_t slen, unsigned char *p);
+__owur int tls1_generate_master_secret(SSL_CONNECTION *s, unsigned char *out,
unsigned char *p, size_t len,
size_t *secret_size);
-__owur int tls13_setup_key_block(SSL *s);
-__owur size_t tls13_final_finish_mac(SSL *s, const char *str, size_t slen,
+__owur int tls13_setup_key_block(SSL_CONNECTION *s);
+__owur size_t tls13_final_finish_mac(SSL_CONNECTION *s, const char *str, size_t slen,
unsigned char *p);
-__owur int tls13_change_cipher_state(SSL *s, int which);
-__owur int tls13_update_key(SSL *s, int send);
-__owur int tls13_hkdf_expand(SSL *s, const EVP_MD *md,
+__owur int tls13_change_cipher_state(SSL_CONNECTION *s, int which);
+__owur int tls13_update_key(SSL_CONNECTION *s, int send);
+__owur int tls13_hkdf_expand(SSL_CONNECTION *s, const EVP_MD *md,
const unsigned char *secret,
const unsigned char *label, size_t labellen,
const unsigned char *data, size_t datalen,
unsigned char *out, size_t outlen, int fatal);
-__owur int tls13_derive_key(SSL *s, const EVP_MD *md,
+__owur int tls13_derive_key(SSL_CONNECTION *s, const EVP_MD *md,
const unsigned char *secret, unsigned char *key,
size_t keylen);
-__owur int tls13_derive_iv(SSL *s, const EVP_MD *md,
+__owur int tls13_derive_iv(SSL_CONNECTION *s, const EVP_MD *md,
const unsigned char *secret, unsigned char *iv,
size_t ivlen);
-__owur int tls13_derive_finishedkey(SSL *s, const EVP_MD *md,
+__owur int tls13_derive_finishedkey(SSL_CONNECTION *s, const EVP_MD *md,
const unsigned char *secret,
unsigned char *fin, size_t finlen);
-int tls13_generate_secret(SSL *s, const EVP_MD *md,
+int tls13_generate_secret(SSL_CONNECTION *s, const EVP_MD *md,
const unsigned char *prevsecret,
const unsigned char *insecret,
size_t insecretlen,
unsigned char *outsecret);
-__owur int tls13_generate_handshake_secret(SSL *s,
+__owur int tls13_generate_handshake_secret(SSL_CONNECTION *s,
const unsigned char *insecret,
size_t insecretlen);
-__owur int tls13_generate_master_secret(SSL *s, unsigned char *out,
+__owur int tls13_generate_master_secret(SSL_CONNECTION *s, unsigned char *out,
unsigned char *prev, size_t prevlen,
size_t *secret_size);
-__owur int tls1_export_keying_material(SSL *s, unsigned char *out, size_t olen,
+__owur int tls1_export_keying_material(SSL_CONNECTION *s,
+ unsigned char *out, size_t olen,
const char *label, size_t llen,
const unsigned char *p, size_t plen,
int use_context);
-__owur int tls13_export_keying_material(SSL *s, unsigned char *out, size_t olen,
+__owur int tls13_export_keying_material(SSL_CONNECTION *s,
+ unsigned char *out, size_t olen,
const char *label, size_t llen,
const unsigned char *context,
size_t contextlen, int use_context);
-__owur int tls13_export_keying_material_early(SSL *s, unsigned char *out,
- size_t olen, const char *label,
- size_t llen,
+__owur int tls13_export_keying_material_early(SSL_CONNECTION *s,
+ unsigned char *out, size_t olen,
+ const char *label, size_t llen,
const unsigned char *context,
size_t contextlen);
__owur int tls1_alert_code(int code);
__owur int tls13_alert_code(int code);
__owur int ssl3_alert_code(int code);
-__owur int ssl_check_srvr_ecc_cert_and_alg(X509 *x, SSL *s);
+__owur int ssl_check_srvr_ecc_cert_and_alg(X509 *x, SSL_CONNECTION *s);
SSL_COMP *ssl3_comp_find(STACK_OF(SSL_COMP) *sk, int n);
__owur const TLS_GROUP_INFO *tls1_group_id_lookup(SSL_CTX *ctx, uint16_t curve_id);
__owur int tls1_group_id2nid(uint16_t group_id, int include_unknown);
__owur uint16_t tls1_nid2group_id(int nid);
-__owur int tls1_check_group_id(SSL *s, uint16_t group_id, int check_own_curves);
-__owur uint16_t tls1_shared_group(SSL *s, int nmatch);
+__owur int tls1_check_group_id(SSL_CONNECTION *s, uint16_t group_id,
+ int check_own_curves);
+__owur uint16_t tls1_shared_group(SSL_CONNECTION *s, int nmatch);
__owur int tls1_set_groups(uint16_t **pext, size_t *pextlen,
int *curves, size_t ncurves);
__owur int tls1_set_groups_list(SSL_CTX *ctx, uint16_t **pext, size_t *pextlen,
const char *str);
-__owur EVP_PKEY *ssl_generate_pkey_group(SSL *s, uint16_t id);
-__owur int tls_valid_group(SSL *s, uint16_t group_id, int minversion,
+__owur EVP_PKEY *ssl_generate_pkey_group(SSL_CONNECTION *s, uint16_t id);
+__owur int tls_valid_group(SSL_CONNECTION *s, uint16_t group_id, int minversion,
int maxversion, int isec, int *okfortls13);
-__owur EVP_PKEY *ssl_generate_param_group(SSL *s, uint16_t id);
-void tls1_get_formatlist(SSL *s, const unsigned char **pformats,
+__owur EVP_PKEY *ssl_generate_param_group(SSL_CONNECTION *s, uint16_t id);
+void tls1_get_formatlist(SSL_CONNECTION *s, const unsigned char **pformats,
size_t *num_formats);
-__owur int tls1_check_ec_tmp_key(SSL *s, unsigned long id);
+__owur int tls1_check_ec_tmp_key(SSL_CONNECTION *s, unsigned long id);
-__owur int tls_group_allowed(SSL *s, uint16_t curve, int op);
-void tls1_get_supported_groups(SSL *s, const uint16_t **pgroups,
+__owur int tls_group_allowed(SSL_CONNECTION *s, uint16_t curve, int op);
+void tls1_get_supported_groups(SSL_CONNECTION *s, const uint16_t **pgroups,
size_t *pgroupslen);
-__owur int tls1_set_server_sigalgs(SSL *s);
+__owur int tls1_set_server_sigalgs(SSL_CONNECTION *s);
-__owur SSL_TICKET_STATUS tls_get_ticket_from_client(SSL *s, CLIENTHELLO_MSG *hello,
+__owur SSL_TICKET_STATUS tls_get_ticket_from_client(SSL_CONNECTION *s,
+ CLIENTHELLO_MSG *hello,
SSL_SESSION **ret);
-__owur SSL_TICKET_STATUS tls_decrypt_ticket(SSL *s, const unsigned char *etick,
+__owur SSL_TICKET_STATUS tls_decrypt_ticket(SSL_CONNECTION *s,
+ const unsigned char *etick,
size_t eticklen,
const unsigned char *sess_id,
size_t sesslen, SSL_SESSION **psess);
-__owur int tls_use_ticket(SSL *s);
+__owur int tls_use_ticket(SSL_CONNECTION *s);
-void ssl_set_sig_mask(uint32_t *pmask_a, SSL *s, int op);
+void ssl_set_sig_mask(uint32_t *pmask_a, SSL_CONNECTION *s, int op);
__owur int tls1_set_sigalgs_list(CERT *c, const char *str, int client);
__owur int tls1_set_raw_sigalgs(CERT *c, const uint16_t *psigs, size_t salglen,
int client);
__owur int tls1_set_sigalgs(CERT *c, const int *salg, size_t salglen,
int client);
-int tls1_check_chain(SSL *s, X509 *x, EVP_PKEY *pk, STACK_OF(X509) *chain,
- int idx);
-void tls1_set_cert_validity(SSL *s);
+int tls1_check_chain(SSL_CONNECTION *s, X509 *x, EVP_PKEY *pk,
+ STACK_OF(X509) *chain, int idx);
+void tls1_set_cert_validity(SSL_CONNECTION *s);
# ifndef OPENSSL_NO_CT
-__owur int ssl_validate_ct(SSL *s);
+__owur int ssl_validate_ct(SSL_CONNECTION *s);
# endif
-__owur EVP_PKEY *ssl_get_auto_dh(SSL *s);
+__owur EVP_PKEY *ssl_get_auto_dh(SSL_CONNECTION *s);
-__owur int ssl_security_cert(SSL *s, SSL_CTX *ctx, X509 *x, int vfy, int is_ee);
-__owur int ssl_security_cert_chain(SSL *s, STACK_OF(X509) *sk, X509 *ex,
- int vfy);
+__owur int ssl_security_cert(SSL_CONNECTION *s, SSL_CTX *ctx, X509 *x, int vfy,
+ int is_ee);
+__owur int ssl_security_cert_chain(SSL_CONNECTION *s, STACK_OF(X509) *sk,
+ X509 *ex, int vfy);
-int tls_choose_sigalg(SSL *s, int fatalerrs);
+int tls_choose_sigalg(SSL_CONNECTION *s, int fatalerrs);
__owur EVP_MD_CTX *ssl_replace_hash(EVP_MD_CTX **hash, const EVP_MD *md);
void ssl_clear_hash_ctx(EVP_MD_CTX **hash);
-__owur long ssl_get_algorithm2(SSL *s);
-__owur int tls12_copy_sigalgs(SSL *s, WPACKET *pkt,
+__owur long ssl_get_algorithm2(SSL_CONNECTION *s);
+__owur int tls12_copy_sigalgs(SSL_CONNECTION *s, WPACKET *pkt,
const uint16_t *psig, size_t psiglen);
__owur int tls1_save_u16(PACKET *pkt, uint16_t **pdest, size_t *pdestlen);
-__owur int tls1_save_sigalgs(SSL *s, PACKET *pkt, int cert);
-__owur int tls1_process_sigalgs(SSL *s);
-__owur int tls1_set_peer_legacy_sigalg(SSL *s, const EVP_PKEY *pkey);
+__owur int tls1_save_sigalgs(SSL_CONNECTION *s, PACKET *pkt, int cert);
+__owur int tls1_process_sigalgs(SSL_CONNECTION *s);
+__owur int tls1_set_peer_legacy_sigalg(SSL_CONNECTION *s, const EVP_PKEY *pkey);
__owur int tls1_lookup_md(SSL_CTX *ctx, const SIGALG_LOOKUP *lu,
const EVP_MD **pmd);
-__owur size_t tls12_get_psigalgs(SSL *s, int sent, const uint16_t **psigs);
-__owur int tls_check_sigalg_curve(const SSL *s, int curve);
-__owur int tls12_check_peer_sigalg(SSL *s, uint16_t, EVP_PKEY *pkey);
-__owur int ssl_set_client_disabled(SSL *s);
-__owur int ssl_cipher_disabled(const SSL *s, const SSL_CIPHER *c, int op, int echde);
-
-__owur int ssl_handshake_hash(SSL *s, unsigned char *out, size_t outlen,
- size_t *hashlen);
+__owur size_t tls12_get_psigalgs(SSL_CONNECTION *s, int sent,
+ const uint16_t **psigs);
+__owur int tls_check_sigalg_curve(const SSL_CONNECTION *s, int curve);
+__owur int tls12_check_peer_sigalg(SSL_CONNECTION *s, uint16_t, EVP_PKEY *pkey);
+__owur int ssl_set_client_disabled(SSL_CONNECTION *s);
+__owur int ssl_cipher_disabled(const SSL_CONNECTION *s, const SSL_CIPHER *c,
+ int op, int echde);
+
+__owur int ssl_handshake_hash(SSL_CONNECTION *s,
+ unsigned char *out, size_t outlen,
+ size_t *hashlen);
__owur const EVP_MD *ssl_md(SSL_CTX *ctx, int idx);
-__owur const EVP_MD *ssl_handshake_md(SSL *s);
-__owur const EVP_MD *ssl_prf_md(SSL *s);
+__owur const EVP_MD *ssl_handshake_md(SSL_CONNECTION *s);
+__owur const EVP_MD *ssl_prf_md(SSL_CONNECTION *s);
/*
* ssl_log_rsa_client_key_exchange logs |premaster| to the SSL_CTX associated
* failure. The entry is identified by the first 8 bytes of
* |encrypted_premaster|.
*/
-__owur int ssl_log_rsa_client_key_exchange(SSL *ssl,
+__owur int ssl_log_rsa_client_key_exchange(SSL_CONNECTION *s,
const uint8_t *encrypted_premaster,
size_t encrypted_premaster_len,
const uint8_t *premaster,
* logging is available. It returns one on success and zero on failure. It tags
* the entry with |label|.
*/
-__owur int ssl_log_secret(SSL *ssl, const char *label,
+__owur int ssl_log_secret(SSL_CONNECTION *s, const char *label,
const uint8_t *secret, size_t secret_len);
#define MASTER_SECRET_LABEL "CLIENT_RANDOM"
# ifndef OPENSSL_NO_KTLS
/* ktls.c */
-int ktls_check_supported_cipher(const SSL *s, const EVP_CIPHER *c,
+int ktls_check_supported_cipher(const SSL_CONNECTION *s, const EVP_CIPHER *c,
const EVP_CIPHER_CTX *dd);
-int ktls_configure_crypto(SSL *s, const EVP_CIPHER *c, EVP_CIPHER_CTX *dd,
+int ktls_configure_crypto(SSL_CONNECTION *s, const EVP_CIPHER *c,
+ EVP_CIPHER_CTX *dd,
void *rl_sequence, ktls_crypto_info_t *crypto_info,
int is_tx, unsigned char *iv,
unsigned char *key, unsigned char *mac_key,
const unsigned char *mac_secret,
size_t mac_secret_length, char is_sslv3);
-__owur int srp_generate_server_master_secret(SSL *s);
-__owur int srp_generate_client_master_secret(SSL *s);
-__owur int srp_verify_server_param(SSL *s);
+__owur int srp_generate_server_master_secret(SSL_CONNECTION *s);
+__owur int srp_generate_client_master_secret(SSL_CONNECTION *s);
+__owur int srp_verify_server_param(SSL_CONNECTION *s);
/* statem/statem_srvr.c */
-__owur int send_certificate_request(SSL *s);
+__owur int send_certificate_request(SSL_CONNECTION *s);
/* statem/extensions_cust.c */
void custom_ext_init(custom_ext_methods *meths);
-__owur int custom_ext_parse(SSL *s, unsigned int context, unsigned int ext_type,
+__owur int custom_ext_parse(SSL_CONNECTION *s, unsigned int context,
+ unsigned int ext_type,
const unsigned char *ext_data, size_t ext_size,
X509 *x, size_t chainidx);
-__owur int custom_ext_add(SSL *s, int context, WPACKET *pkt, X509 *x,
+__owur int custom_ext_add(SSL_CONNECTION *s, int context, WPACKET *pkt, X509 *x,
size_t chainidx, int maxversion);
__owur int custom_exts_copy(custom_ext_methods *dst,
int ssl_evp_md_up_ref(const EVP_MD *md);
void ssl_evp_md_free(const EVP_MD *md);
-int tls_provider_set_tls_params(SSL *s, EVP_CIPHER_CTX *ctx,
+int tls_provider_set_tls_params(SSL_CONNECTION *s, EVP_CIPHER_CTX *ctx,
const EVP_CIPHER *ciph,
const EVP_MD *md);
void tls_engine_finish(ENGINE *e);
const EVP_CIPHER *tls_get_cipher_from_engine(int nid);
const EVP_MD *tls_get_digest_from_engine(int nid);
-int tls_engine_load_ssl_client_cert(SSL *s, X509 **px509, EVP_PKEY **ppkey);
+int tls_engine_load_ssl_client_cert(SSL_CONNECTION *s, X509 **px509,
+ EVP_PKEY **ppkey);
int ssl_hmac_old_new(SSL_HMAC *ret);
void ssl_hmac_old_free(SSL_HMAC *ctx);
int ssl_hmac_old_init(SSL_HMAC *ctx, void *key, size_t len, char *md);
int ssl_ctx_srp_ctx_free_intern(SSL_CTX *ctx);
int ssl_ctx_srp_ctx_init_intern(SSL_CTX *ctx);
-int ssl_srp_ctx_free_intern(SSL *s);
-int ssl_srp_ctx_init_intern(SSL *s);
+int ssl_srp_ctx_free_intern(SSL_CONNECTION *s);
+int ssl_srp_ctx_init_intern(SSL_CONNECTION *s);
-int ssl_srp_calc_a_param_intern(SSL *s);
-int ssl_srp_server_param_with_username_intern(SSL *s, int *ad);
+int ssl_srp_calc_a_param_intern(SSL_CONNECTION *s);
+int ssl_srp_server_param_with_username_intern(SSL_CONNECTION *s, int *ad);
-void ssl_session_calculate_timeout(SSL_SESSION* ss);
+void ssl_session_calculate_timeout(SSL_SESSION *ss);
# else /* OPENSSL_UNIT_TEST */
int SSL_use_certificate(SSL *ssl, X509 *x)
{
int rv;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
+
+ if (sc == NULL)
+ return 0;
+
if (x == NULL) {
ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
- rv = ssl_security_cert(ssl, NULL, x, 0, 1);
+ rv = ssl_security_cert(sc, NULL, x, 0, 1);
if (rv != 1) {
ERR_raise(ERR_LIB_SSL, rv);
return 0;
}
- return ssl_set_cert(ssl->cert, x);
+ return ssl_set_cert(sc->cert, x);
}
int SSL_use_certificate_file(SSL *ssl, const char *file, int type)
j = ERR_R_ASN1_LIB;
cert = d2i_X509_bio(in, &x);
} else if (type == SSL_FILETYPE_PEM) {
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
+
+ if (sc == NULL)
+ goto end;
+
j = ERR_R_PEM_LIB;
- cert = PEM_read_bio_X509(in, &x, ssl->default_passwd_callback,
- ssl->default_passwd_callback_userdata);
+ cert = PEM_read_bio_X509(in, &x, sc->default_passwd_callback,
+ sc->default_passwd_callback_userdata);
} else {
ERR_raise(ERR_LIB_SSL, SSL_R_BAD_SSL_FILETYPE);
goto end;
int SSL_use_PrivateKey(SSL *ssl, EVP_PKEY *pkey)
{
int ret;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
+
+ if (sc == NULL)
+ return 0;
if (pkey == NULL) {
ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
- ret = ssl_set_pkey(ssl->cert, pkey);
+ ret = ssl_set_pkey(sc->cert, pkey);
return ret;
}
goto end;
}
if (type == SSL_FILETYPE_PEM) {
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
+
+ if (sc == NULL)
+ goto end;
+
j = ERR_R_PEM_LIB;
pkey = PEM_read_bio_PrivateKey_ex(in, NULL,
- ssl->default_passwd_callback,
- ssl->default_passwd_callback_userdata,
+ sc->default_passwd_callback,
+ sc->default_passwd_callback_userdata,
ssl->ctx->libctx,
ssl->ctx->propq);
} else if (type == SSL_FILETYPE_ASN1) {
passwd_callback = ctx->default_passwd_callback;
passwd_callback_userdata = ctx->default_passwd_callback_userdata;
} else {
- passwd_callback = ssl->default_passwd_callback;
- passwd_callback_userdata = ssl->default_passwd_callback_userdata;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
+
+ if (sc == NULL)
+ return 0;
+
+ passwd_callback = sc->default_passwd_callback;
+ passwd_callback_userdata = sc->default_passwd_callback_userdata;
}
in = BIO_new(BIO_s_file());
{
const unsigned char *serverinfo = NULL;
size_t serverinfo_length = 0;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL) {
+ *al = SSL_AD_INTERNAL_ERROR;
+ return -1;
+ }
/* We only support extensions for the first Certificate */
if ((context & SSL_EXT_TLS1_3_CERTIFICATE) != 0 && chainidx > 0)
return 0;
/* Is there serverinfo data for the chosen server cert? */
- if ((ssl_get_server_cert_serverinfo(s, &serverinfo,
+ if ((ssl_get_server_cert_serverinfo(sc, &serverinfo,
&serverinfo_length)) != 0) {
/* Find the relevant extension from the serverinfo */
int retval = serverinfo_find_extension(serverinfo, serverinfo_length,
size_t i;
int j;
int rv;
- CERT *c = ssl != NULL ? ssl->cert : ctx->cert;
+ CERT *c;
STACK_OF(X509) *dup_chain = NULL;
EVP_PKEY *pubkey = NULL;
+ SSL_CONNECTION *sc = NULL;
+
+ if (ctx == NULL &&
+ (sc = SSL_CONNECTION_FROM_SSL(ssl)) == NULL)
+ return 0;
+ c = sc != NULL ? sc->cert : ctx->cert;
/* Do all security checks before anything else */
- rv = ssl_security_cert(ssl, ctx, x509, 0, 1);
+ rv = ssl_security_cert(sc, ctx, x509, 0, 1);
if (rv != 1) {
ERR_raise(ERR_LIB_SSL, rv);
goto out;
}
for (j = 0; j < sk_X509_num(chain); j++) {
- rv = ssl_security_cert(ssl, ctx, sk_X509_value(chain, j), 0, 0);
+ rv = ssl_security_cert(sc, ctx, sk_X509_value(chain, j), 0, 0);
if (rv != 1) {
ERR_raise(ERR_LIB_SSL, rv);
goto out;
SSL_SESSION *SSL_get_session(const SSL *ssl)
/* aka SSL_get0_session; gets 0 objects, just returns a copy of the pointer */
{
- return ssl->session;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
+
+ if (sc == NULL)
+ return NULL;
+
+ return sc->session;
}
SSL_SESSION *SSL_get1_session(SSL *ssl)
/* variant of SSL_get_session: caller really gets something */
{
SSL_SESSION *sess;
+
/*
* Need to lock this all up rather than just use CRYPTO_add so that
* somebody doesn't free ssl->session between when we check it's non-null
*/
if (!CRYPTO_THREAD_read_lock(ssl->lock))
return NULL;
- sess = ssl->session;
- if (sess)
+ sess = SSL_get_session(ssl);
+ if (sess != NULL)
SSL_SESSION_up_ref(sess);
CRYPTO_THREAD_unlock(ssl->lock);
return sess;
return 0;
}
-int ssl_generate_session_id(SSL *s, SSL_SESSION *ss)
+int ssl_generate_session_id(SSL_CONNECTION *s, SSL_SESSION *ss)
{
unsigned int tmp;
GEN_SESSION_CB cb = def_generate_session_id;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
switch (s->version) {
case SSL3_VERSION:
}
/* Choose which callback will set the session ID */
- if (!CRYPTO_THREAD_read_lock(s->lock))
+ if (!CRYPTO_THREAD_read_lock(SSL_CONNECTION_GET_SSL(s)->lock))
return 0;
if (!CRYPTO_THREAD_read_lock(s->session_ctx->lock)) {
- CRYPTO_THREAD_unlock(s->lock);
+ CRYPTO_THREAD_unlock(ssl->lock);
SSLfatal(s, SSL_AD_INTERNAL_ERROR,
SSL_R_SESSION_ID_CONTEXT_UNINITIALIZED);
return 0;
else if (s->session_ctx->generate_session_id)
cb = s->session_ctx->generate_session_id;
CRYPTO_THREAD_unlock(s->session_ctx->lock);
- CRYPTO_THREAD_unlock(s->lock);
+ CRYPTO_THREAD_unlock(ssl->lock);
/* Choose a session ID */
memset(ss->session_id, 0, ss->session_id_length);
tmp = (int)ss->session_id_length;
- if (!cb(s, ss->session_id, &tmp)) {
+ if (!cb(ssl, ss->session_id, &tmp)) {
/* The callback failed */
SSLfatal(s, SSL_AD_INTERNAL_ERROR,
SSL_R_SSL_SESSION_ID_CALLBACK_FAILED);
}
ss->session_id_length = tmp;
/* Finally, check for a conflict */
- if (SSL_has_matching_session_id(s, ss->session_id,
+ if (SSL_has_matching_session_id(ssl, ss->session_id,
(unsigned int)ss->session_id_length)) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_SSL_SESSION_ID_CONFLICT);
return 0;
return 1;
}
-int ssl_get_new_session(SSL *s, int session)
+int ssl_get_new_session(SSL_CONNECTION *s, int session)
{
/* This gets used by clients and servers. */
/* If the context has a default timeout, use it */
if (s->session_ctx->session_timeout == 0)
- ss->timeout = SSL_get_default_timeout(s);
+ ss->timeout = SSL_get_default_timeout(SSL_CONNECTION_GET_SSL(s));
else
ss->timeout = s->session_ctx->session_timeout;
ssl_session_calculate_timeout(ss);
s->session = NULL;
if (session) {
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
/*
* We generate the session id while constructing the
* NewSessionTicket in TLSv1.3.
return 1;
}
-SSL_SESSION *lookup_sess_in_cache(SSL *s, const unsigned char *sess_id,
+SSL_SESSION *lookup_sess_in_cache(SSL_CONNECTION *s,
+ const unsigned char *sess_id,
size_t sess_id_len)
{
SSL_SESSION *ret = NULL;
if (ret == NULL && s->session_ctx->get_session_cb != NULL) {
int copy = 1;
- ret = s->session_ctx->get_session_cb(s, sess_id, sess_id_len, ©);
+ ret = s->session_ctx->get_session_cb(SSL_CONNECTION_GET_SSL(s),
+ sess_id, sess_id_len, ©);
if (ret != NULL) {
ssl_tsan_counter(s->session_ctx,
* - Both for new and resumed sessions, s->ext.ticket_expected is set to 1
* if the server should issue a new session ticket (to 0 otherwise).
*/
-int ssl_get_prev_session(SSL *s, CLIENTHELLO_MSG *hello)
+int ssl_get_prev_session(SSL_CONNECTION *s, CLIENTHELLO_MSG *hello)
{
/* This is used only by servers. */
int try_session_cache = 0;
SSL_TICKET_STATUS r;
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
/*
* By default we will send a new ticket. This can be overridden in the
* ticket processing.
goto err;
}
- if (!SSL_IS_TLS13(s)) {
+ if (!SSL_CONNECTION_IS_TLS13(s)) {
/* We already did this for TLS1.3 */
SSL_SESSION_free(s->session);
s->session = ret;
if (ret != NULL) {
SSL_SESSION_free(ret);
/* In TLSv1.3 s->session was already set to ret, so we NULL it out */
- if (SSL_IS_TLS13(s))
+ if (SSL_CONNECTION_IS_TLS13(s))
s->session = NULL;
if (!try_session_cache) {
int SSL_set_session(SSL *s, SSL_SESSION *session)
{
- ssl_clear_bad_session(s);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ ssl_clear_bad_session(sc);
if (s->ctx->method != s->method) {
if (!SSL_set_ssl_method(s, s->ctx->method))
return 0;
if (session != NULL) {
SSL_SESSION_up_ref(session);
- s->verify_result = session->verify_result;
+ sc->verify_result = session->verify_result;
}
- SSL_SESSION_free(s->session);
- s->session = session;
+ SSL_SESSION_free(sc->session);
+ sc->session = session;
return 1;
}
tls_session_secret_cb_fn tls_session_secret_cb,
void *arg)
{
- if (s == NULL)
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
return 0;
- s->ext.session_secret_cb = tls_session_secret_cb;
- s->ext.session_secret_cb_arg = arg;
+
+ sc->ext.session_secret_cb = tls_session_secret_cb;
+ sc->ext.session_secret_cb_arg = arg;
return 1;
}
int SSL_set_session_ticket_ext_cb(SSL *s, tls_session_ticket_ext_cb_fn cb,
void *arg)
{
- if (s == NULL)
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
return 0;
- s->ext.session_ticket_cb = cb;
- s->ext.session_ticket_cb_arg = arg;
+
+ sc->ext.session_ticket_cb = cb;
+ sc->ext.session_ticket_cb_arg = arg;
return 1;
}
int SSL_set_session_ticket_ext(SSL *s, void *ext_data, int ext_len)
{
- if (s->version >= TLS1_VERSION) {
- OPENSSL_free(s->ext.session_ticket);
- s->ext.session_ticket = NULL;
- s->ext.session_ticket =
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ if (sc->version >= TLS1_VERSION) {
+ OPENSSL_free(sc->ext.session_ticket);
+ sc->ext.session_ticket = NULL;
+ sc->ext.session_ticket =
OPENSSL_malloc(sizeof(TLS_SESSION_TICKET_EXT) + ext_len);
- if (s->ext.session_ticket == NULL) {
+ if (sc->ext.session_ticket == NULL) {
ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
return 0;
}
if (ext_data != NULL) {
- s->ext.session_ticket->length = ext_len;
- s->ext.session_ticket->data = s->ext.session_ticket + 1;
- memcpy(s->ext.session_ticket->data, ext_data, ext_len);
+ sc->ext.session_ticket->length = ext_len;
+ sc->ext.session_ticket->data = sc->ext.session_ticket + 1;
+ memcpy(sc->ext.session_ticket->data, ext_data, ext_len);
} else {
- s->ext.session_ticket->length = 0;
- s->ext.session_ticket->data = NULL;
+ sc->ext.session_ticket->length = 0;
+ sc->ext.session_ticket->data = NULL;
}
return 1;
sk_SSL_SESSION_pop_free(sk, SSL_SESSION_free);
}
-int ssl_clear_bad_session(SSL *s)
+int ssl_clear_bad_session(SSL_CONNECTION *s)
{
if ((s->session != NULL) &&
!(s->shutdown & SSL_SENT_SHUTDOWN) &&
- !(SSL_in_init(s) || SSL_in_before(s))) {
+ !(SSL_in_init(SSL_CONNECTION_GET_SSL(s))
+ || SSL_in_before(SSL_CONNECTION_GET_SSL(s)))) {
SSL_CTX_remove_session(s->session_ctx, s->session);
return 1;
} else
}
void SSL_CTX_sess_set_get_cb(SSL_CTX *ctx,
- SSL_SESSION *(*cb) (struct ssl_st *ssl,
+ SSL_SESSION *(*cb) (SSL *ssl,
const unsigned char *data,
int len, int *copy))
{
const char *SSL_state_string_long(const SSL *s)
{
- if (ossl_statem_in_error(s))
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL || ossl_statem_in_error(sc))
return "error";
switch (SSL_get_state(s)) {
const char *SSL_state_string(const SSL *s)
{
- if (ossl_statem_in_error(s))
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL || ossl_statem_in_error(sc))
return "SSLERR";
switch (SSL_get_state(s)) {
#include "../ssl_local.h"
#include "statem_local.h"
-static int final_renegotiate(SSL *s, unsigned int context, int sent);
-static int init_server_name(SSL *s, unsigned int context);
-static int final_server_name(SSL *s, unsigned int context, int sent);
-static int final_ec_pt_formats(SSL *s, unsigned int context, int sent);
-static int init_session_ticket(SSL *s, unsigned int context);
+static int final_renegotiate(SSL_CONNECTION *s, unsigned int context, int sent);
+static int init_server_name(SSL_CONNECTION *s, unsigned int context);
+static int final_server_name(SSL_CONNECTION *s, unsigned int context, int sent);
+static int final_ec_pt_formats(SSL_CONNECTION *s, unsigned int context,
+ int sent);
+static int init_session_ticket(SSL_CONNECTION *s, unsigned int context);
#ifndef OPENSSL_NO_OCSP
-static int init_status_request(SSL *s, unsigned int context);
+static int init_status_request(SSL_CONNECTION *s, unsigned int context);
#endif
#ifndef OPENSSL_NO_NEXTPROTONEG
-static int init_npn(SSL *s, unsigned int context);
+static int init_npn(SSL_CONNECTION *s, unsigned int context);
#endif
-static int init_alpn(SSL *s, unsigned int context);
-static int final_alpn(SSL *s, unsigned int context, int sent);
-static int init_sig_algs_cert(SSL *s, unsigned int context);
-static int init_sig_algs(SSL *s, unsigned int context);
-static int init_certificate_authorities(SSL *s, unsigned int context);
-static EXT_RETURN tls_construct_certificate_authorities(SSL *s, WPACKET *pkt,
+static int init_alpn(SSL_CONNECTION *s, unsigned int context);
+static int final_alpn(SSL_CONNECTION *s, unsigned int context, int sent);
+static int init_sig_algs_cert(SSL_CONNECTION *s, unsigned int context);
+static int init_sig_algs(SSL_CONNECTION *s, unsigned int context);
+static int init_certificate_authorities(SSL_CONNECTION *s,
+ unsigned int context);
+static EXT_RETURN tls_construct_certificate_authorities(SSL_CONNECTION *s,
+ WPACKET *pkt,
unsigned int context,
X509 *x,
size_t chainidx);
-static int tls_parse_certificate_authorities(SSL *s, PACKET *pkt,
+static int tls_parse_certificate_authorities(SSL_CONNECTION *s, PACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx);
#ifndef OPENSSL_NO_SRP
-static int init_srp(SSL *s, unsigned int context);
+static int init_srp(SSL_CONNECTION *s, unsigned int context);
#endif
-static int init_ec_point_formats(SSL *s, unsigned int context);
-static int init_etm(SSL *s, unsigned int context);
-static int init_ems(SSL *s, unsigned int context);
-static int final_ems(SSL *s, unsigned int context, int sent);
-static int init_psk_kex_modes(SSL *s, unsigned int context);
-static int final_key_share(SSL *s, unsigned int context, int sent);
+static int init_ec_point_formats(SSL_CONNECTION *s, unsigned int context);
+static int init_etm(SSL_CONNECTION *s, unsigned int context);
+static int init_ems(SSL_CONNECTION *s, unsigned int context);
+static int final_ems(SSL_CONNECTION *s, unsigned int context, int sent);
+static int init_psk_kex_modes(SSL_CONNECTION *s, unsigned int context);
+static int final_key_share(SSL_CONNECTION *s, unsigned int context, int sent);
#ifndef OPENSSL_NO_SRTP
-static int init_srtp(SSL *s, unsigned int context);
+static int init_srtp(SSL_CONNECTION *s, unsigned int context);
#endif
-static int final_sig_algs(SSL *s, unsigned int context, int sent);
-static int final_early_data(SSL *s, unsigned int context, int sent);
-static int final_maxfragmentlen(SSL *s, unsigned int context, int sent);
-static int init_post_handshake_auth(SSL *s, unsigned int context);
-static int final_psk(SSL *s, unsigned int context, int sent);
+static int final_sig_algs(SSL_CONNECTION *s, unsigned int context, int sent);
+static int final_early_data(SSL_CONNECTION *s, unsigned int context, int sent);
+static int final_maxfragmentlen(SSL_CONNECTION *s, unsigned int context,
+ int sent);
+static int init_post_handshake_auth(SSL_CONNECTION *s, unsigned int context);
+static int final_psk(SSL_CONNECTION *s, unsigned int context, int sent);
/* Structure to define a built-in extension */
typedef struct extensions_definition_st {
* Initialise extension before parsing. Always called for relevant contexts
* even if extension not present
*/
- int (*init)(SSL *s, unsigned int context);
+ int (*init)(SSL_CONNECTION *s, unsigned int context);
/* Parse extension sent from client to server */
- int (*parse_ctos)(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx);
+ int (*parse_ctos)(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
+ X509 *x, size_t chainidx);
/* Parse extension send from server to client */
- int (*parse_stoc)(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx);
+ int (*parse_stoc)(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
+ X509 *x, size_t chainidx);
/* Construct extension sent from server to client */
- EXT_RETURN (*construct_stoc)(SSL *s, WPACKET *pkt, unsigned int context,
+ EXT_RETURN (*construct_stoc)(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
/* Construct extension sent from client to server */
- EXT_RETURN (*construct_ctos)(SSL *s, WPACKET *pkt, unsigned int context,
+ EXT_RETURN (*construct_ctos)(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
/*
* Finalise extension after parsing. Always called where an extensions was
* initialised even if the extension was not present. |sent| is set to 1 if
* the extension was seen, or 0 otherwise.
*/
- int (*final)(SSL *s, unsigned int context, int sent);
+ int (*final)(SSL_CONNECTION *s, unsigned int context, int sent);
} EXTENSION_DEFINITION;
/*
};
/* Check whether an extension's context matches the current context */
-static int validate_context(SSL *s, unsigned int extctx, unsigned int thisctx)
+static int validate_context(SSL_CONNECTION *s, unsigned int extctx,
+ unsigned int thisctx)
{
/* Check we're allowed to use this extension in this context */
if ((thisctx & extctx) == 0)
return 0;
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
if ((extctx & SSL_EXT_TLS_ONLY) != 0)
return 0;
} else if ((extctx & SSL_EXT_DTLS_ONLY) != 0) {
return 1;
}
-int tls_validate_all_contexts(SSL *s, unsigned int thisctx, RAW_EXTENSION *exts)
+int tls_validate_all_contexts(SSL_CONNECTION *s, unsigned int thisctx,
+ RAW_EXTENSION *exts)
{
size_t i, num_exts, builtin_num = OSSL_NELEM(ext_defs), offset;
RAW_EXTENSION *thisext;
* indicate the extension is not allowed. If returning 1 then |*found| is set to
* the definition for the extension we found.
*/
-static int verify_extension(SSL *s, unsigned int context, unsigned int type,
- custom_ext_methods *meths, RAW_EXTENSION *rawexlist,
- RAW_EXTENSION **found)
+static int verify_extension(SSL_CONNECTION *s, unsigned int context,
+ unsigned int type, custom_ext_methods *meths,
+ RAW_EXTENSION *rawexlist, RAW_EXTENSION **found)
{
size_t i;
size_t builtin_num = OSSL_NELEM(ext_defs);
* the extension is relevant for the current context |thisctx| or not. Returns
* 1 if the extension is relevant for this context, and 0 otherwise
*/
-int extension_is_relevant(SSL *s, unsigned int extctx, unsigned int thisctx)
+int extension_is_relevant(SSL_CONNECTION *s, unsigned int extctx,
+ unsigned int thisctx)
{
int is_tls13;
if ((thisctx & SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST) != 0)
is_tls13 = 1;
else
- is_tls13 = SSL_IS_TLS13(s);
+ is_tls13 = SSL_CONNECTION_IS_TLS13(s);
- if ((SSL_IS_DTLS(s)
+ if ((SSL_CONNECTION_IS_DTLS(s)
&& (extctx & SSL_EXT_TLS_IMPLEMENTATION_ONLY) != 0)
|| (s->version == SSL3_VERSION
&& (extctx & SSL_EXT_SSL3_ALLOWED) == 0)
* found, or an internal error occurred. We only check duplicates for
* extensions that we know about. We ignore others.
*/
-int tls_collect_extensions(SSL *s, PACKET *packet, unsigned int context,
+int tls_collect_extensions(SSL_CONNECTION *s, PACKET *packet,
+ unsigned int context,
RAW_EXTENSION **res, size_t *len, int init)
{
PACKET extensions = *packet;
thisex->type = type;
thisex->received_order = i++;
if (s->ext.debug_cb)
- s->ext.debug_cb(s, !s->server, thisex->type,
- PACKET_data(&thisex->data),
+ s->ext.debug_cb(SSL_CONNECTION_GET_SSL(s), !s->server,
+ thisex->type, PACKET_data(&thisex->data),
PACKET_remaining(&thisex->data),
s->ext.debug_arg);
}
* Certificate. Returns 1 on success or 0 on failure. If an extension is not
* present this counted as success.
*/
-int tls_parse_extension(SSL *s, TLSEXT_INDEX idx, int context,
+int tls_parse_extension(SSL_CONNECTION *s, TLSEXT_INDEX idx, int context,
RAW_EXTENSION *exts, X509 *x, size_t chainidx)
{
RAW_EXTENSION *currext = &exts[idx];
- int (*parser)(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
+ int (*parser)(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x,
size_t chainidx) = NULL;
/* Skip if the extension is not present */
* working on a Certificate message then we also pass the Certificate |x| and
* its position in the |chainidx|, with 0 being the first certificate.
*/
-int tls_parse_all_extensions(SSL *s, int context, RAW_EXTENSION *exts, X509 *x,
+int tls_parse_all_extensions(SSL_CONNECTION *s, int context,
+ RAW_EXTENSION *exts, X509 *x,
size_t chainidx, int fin)
{
size_t i, numexts = OSSL_NELEM(ext_defs);
return 1;
}
-int should_add_extension(SSL *s, unsigned int extctx, unsigned int thisctx,
- int max_version)
+int should_add_extension(SSL_CONNECTION *s, unsigned int extctx,
+ unsigned int thisctx, int max_version)
{
/* Skip if not relevant for our context */
if ((extctx & thisctx) == 0)
if (!extension_is_relevant(s, extctx, thisctx)
|| ((extctx & SSL_EXT_TLS1_3_ONLY) != 0
&& (thisctx & SSL_EXT_CLIENT_HELLO) != 0
- && (SSL_IS_DTLS(s) || max_version < TLS1_3_VERSION)))
+ && (SSL_CONNECTION_IS_DTLS(s) || max_version < TLS1_3_VERSION)))
return 0;
return 1;
* 0 being the first in the chain). Returns 1 on success or 0 on failure. On a
* failure construction stops at the first extension to fail to construct.
*/
-int tls_construct_extensions(SSL *s, WPACKET *pkt, unsigned int context,
+int tls_construct_extensions(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx)
{
size_t i;
}
for (i = 0, thisexd = ext_defs; i < OSSL_NELEM(ext_defs); i++, thisexd++) {
- EXT_RETURN (*construct)(SSL *s, WPACKET *pkt, unsigned int context,
+ EXT_RETURN (*construct)(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
EXT_RETURN ret;
* otherwise. These functions return 1 on success or 0 on failure.
*/
-static int final_renegotiate(SSL *s, unsigned int context, int sent)
+static int final_renegotiate(SSL_CONNECTION *s, unsigned int context, int sent)
{
if (!s->server) {
/*
}
}
-static int init_server_name(SSL *s, unsigned int context)
+static int init_server_name(SSL_CONNECTION *s, unsigned int context)
{
if (s->server) {
s->servername_done = 0;
return 1;
}
-static int final_server_name(SSL *s, unsigned int context, int sent)
+static int final_server_name(SSL_CONNECTION *s, unsigned int context, int sent)
{
int ret = SSL_TLSEXT_ERR_NOACK;
int altmp = SSL_AD_UNRECOGNIZED_NAME;
- int was_ticket = (SSL_get_options(s) & SSL_OP_NO_TICKET) == 0;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
+ int was_ticket = (SSL_get_options(ssl) & SSL_OP_NO_TICKET) == 0;
- if (!ossl_assert(s->ctx != NULL) || !ossl_assert(s->session_ctx != NULL)) {
+ if (!ossl_assert(sctx != NULL) || !ossl_assert(s->session_ctx != NULL)) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return 0;
}
- if (s->ctx->ext.servername_cb != NULL)
- ret = s->ctx->ext.servername_cb(s, &altmp,
- s->ctx->ext.servername_arg);
+ if (sctx->ext.servername_cb != NULL)
+ ret = sctx->ext.servername_cb(ssl, &altmp,
+ sctx->ext.servername_arg);
else if (s->session_ctx->ext.servername_cb != NULL)
- ret = s->session_ctx->ext.servername_cb(s, &altmp,
+ ret = s->session_ctx->ext.servername_cb(ssl, &altmp,
s->session_ctx->ext.servername_arg);
/*
* context, to avoid the confusing situation of having sess_accept_good
* exceed sess_accept (zero) for the new context.
*/
- if (SSL_IS_FIRST_HANDSHAKE(s) && s->ctx != s->session_ctx
+ if (SSL_IS_FIRST_HANDSHAKE(s) && sctx != s->session_ctx
&& s->hello_retry_request == SSL_HRR_NONE) {
- ssl_tsan_counter(s->ctx, &s->ctx->stats.sess_accept);
+ ssl_tsan_counter(sctx, &sctx->stats.sess_accept);
ssl_tsan_decr(s->session_ctx, &s->session_ctx->stats.sess_accept);
}
* Also, if this is not a resumption, create a new session ID
*/
if (ret == SSL_TLSEXT_ERR_OK && s->ext.ticket_expected
- && was_ticket && (SSL_get_options(s) & SSL_OP_NO_TICKET) != 0) {
+ && was_ticket && (SSL_get_options(ssl) & SSL_OP_NO_TICKET) != 0) {
s->ext.ticket_expected = 0;
if (!s->hit) {
- SSL_SESSION* ss = SSL_get_session(s);
+ SSL_SESSION* ss = SSL_get_session(ssl);
if (ss != NULL) {
OPENSSL_free(ss->ext.tick);
case SSL_TLSEXT_ERR_ALERT_WARNING:
/* TLSv1.3 doesn't have warning alerts so we suppress this */
- if (!SSL_IS_TLS13(s))
+ if (!SSL_CONNECTION_IS_TLS13(s))
ssl3_send_alert(s, SSL3_AL_WARNING, altmp);
s->servername_done = 0;
return 1;
}
}
-static int final_ec_pt_formats(SSL *s, unsigned int context, int sent)
+static int final_ec_pt_formats(SSL_CONNECTION *s, unsigned int context,
+ int sent)
{
unsigned long alg_k, alg_a;
return 1;
}
-static int init_session_ticket(SSL *s, unsigned int context)
+static int init_session_ticket(SSL_CONNECTION *s, unsigned int context)
{
if (!s->server)
s->ext.ticket_expected = 0;
}
#ifndef OPENSSL_NO_OCSP
-static int init_status_request(SSL *s, unsigned int context)
+static int init_status_request(SSL_CONNECTION *s, unsigned int context)
{
if (s->server) {
s->ext.status_type = TLSEXT_STATUSTYPE_nothing;
#endif
#ifndef OPENSSL_NO_NEXTPROTONEG
-static int init_npn(SSL *s, unsigned int context)
+static int init_npn(SSL_CONNECTION *s, unsigned int context)
{
s->s3.npn_seen = 0;
}
#endif
-static int init_alpn(SSL *s, unsigned int context)
+static int init_alpn(SSL_CONNECTION *s, unsigned int context)
{
OPENSSL_free(s->s3.alpn_selected);
s->s3.alpn_selected = NULL;
return 1;
}
-static int final_alpn(SSL *s, unsigned int context, int sent)
+static int final_alpn(SSL_CONNECTION *s, unsigned int context, int sent)
{
if (!s->server && !sent && s->session->ext.alpn_selected != NULL)
s->ext.early_data_ok = 0;
- if (!s->server || !SSL_IS_TLS13(s))
+ if (!s->server || !SSL_CONNECTION_IS_TLS13(s))
return 1;
/*
return tls_handle_alpn(s);
}
-static int init_sig_algs(SSL *s, unsigned int context)
+static int init_sig_algs(SSL_CONNECTION *s, unsigned int context)
{
/* Clear any signature algorithms extension received */
OPENSSL_free(s->s3.tmp.peer_sigalgs);
return 1;
}
-static int init_sig_algs_cert(SSL *s, ossl_unused unsigned int context)
+static int init_sig_algs_cert(SSL_CONNECTION *s,
+ ossl_unused unsigned int context)
{
/* Clear any signature algorithms extension received */
OPENSSL_free(s->s3.tmp.peer_cert_sigalgs);
}
#ifndef OPENSSL_NO_SRP
-static int init_srp(SSL *s, unsigned int context)
+static int init_srp(SSL_CONNECTION *s, unsigned int context)
{
OPENSSL_free(s->srp_ctx.login);
s->srp_ctx.login = NULL;
}
#endif
-static int init_ec_point_formats(SSL *s, unsigned int context)
+static int init_ec_point_formats(SSL_CONNECTION *s, unsigned int context)
{
OPENSSL_free(s->ext.peer_ecpointformats);
s->ext.peer_ecpointformats = NULL;
return 1;
}
-static int init_etm(SSL *s, unsigned int context)
+static int init_etm(SSL_CONNECTION *s, unsigned int context)
{
s->ext.use_etm = 0;
return 1;
}
-static int init_ems(SSL *s, unsigned int context)
+static int init_ems(SSL_CONNECTION *s, unsigned int context)
{
if (s->s3.flags & TLS1_FLAGS_RECEIVED_EXTMS) {
s->s3.flags &= ~TLS1_FLAGS_RECEIVED_EXTMS;
return 1;
}
-static int final_ems(SSL *s, unsigned int context, int sent)
+static int final_ems(SSL_CONNECTION *s, unsigned int context, int sent)
{
/*
* Check extended master secret extension is not dropped on
return 1;
}
-static int init_certificate_authorities(SSL *s, unsigned int context)
+static int init_certificate_authorities(SSL_CONNECTION *s, unsigned int context)
{
sk_X509_NAME_pop_free(s->s3.tmp.peer_ca_names, X509_NAME_free);
s->s3.tmp.peer_ca_names = NULL;
return 1;
}
-static EXT_RETURN tls_construct_certificate_authorities(SSL *s, WPACKET *pkt,
+static EXT_RETURN tls_construct_certificate_authorities(SSL_CONNECTION *s,
+ WPACKET *pkt,
unsigned int context,
X509 *x,
size_t chainidx)
return EXT_RETURN_SENT;
}
-static int tls_parse_certificate_authorities(SSL *s, PACKET *pkt,
+static int tls_parse_certificate_authorities(SSL_CONNECTION *s, PACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx)
{
}
#ifndef OPENSSL_NO_SRTP
-static int init_srtp(SSL *s, unsigned int context)
+static int init_srtp(SSL_CONNECTION *s, unsigned int context)
{
if (s->server)
s->srtp_profile = NULL;
}
#endif
-static int final_sig_algs(SSL *s, unsigned int context, int sent)
+static int final_sig_algs(SSL_CONNECTION *s, unsigned int context, int sent)
{
- if (!sent && SSL_IS_TLS13(s) && !s->hit) {
+ if (!sent && SSL_CONNECTION_IS_TLS13(s) && !s->hit) {
SSLfatal(s, TLS13_AD_MISSING_EXTENSION,
SSL_R_MISSING_SIGALGS_EXTENSION);
return 0;
return 1;
}
-static int final_key_share(SSL *s, unsigned int context, int sent)
+static int final_key_share(SSL_CONNECTION *s, unsigned int context, int sent)
{
#if !defined(OPENSSL_NO_TLS1_3)
- if (!SSL_IS_TLS13(s))
+ if (!SSL_CONNECTION_IS_TLS13(s))
return 1;
/* Nothing to do for key_share in an HRR */
return 1;
}
-static int init_psk_kex_modes(SSL *s, unsigned int context)
+static int init_psk_kex_modes(SSL_CONNECTION *s, unsigned int context)
{
s->ext.psk_kex_mode = TLSEXT_KEX_MODE_FLAG_NONE;
return 1;
}
-int tls_psk_do_binder(SSL *s, const EVP_MD *md, const unsigned char *msgstart,
+int tls_psk_do_binder(SSL_CONNECTION *s, const EVP_MD *md,
+ const unsigned char *msgstart,
size_t binderoffset, const unsigned char *binderin,
unsigned char *binderout, SSL_SESSION *sess, int sign,
int external)
int hashsizei = EVP_MD_get_size(md);
int ret = -1;
int usepskfored = 0;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
/* Ensure cast to size_t is safe */
if (!ossl_assert(hashsizei >= 0)) {
goto err;
}
- mackey = EVP_PKEY_new_raw_private_key_ex(s->ctx->libctx, "HMAC",
- s->ctx->propq, finishedkey,
+ mackey = EVP_PKEY_new_raw_private_key_ex(sctx->libctx, "HMAC",
+ sctx->propq, finishedkey,
hashsize);
if (mackey == NULL) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
binderout = tmpbinder;
bindersize = hashsize;
- if (EVP_DigestSignInit_ex(mctx, NULL, EVP_MD_get0_name(md), s->ctx->libctx,
- s->ctx->propq, mackey, NULL) <= 0
+ if (EVP_DigestSignInit_ex(mctx, NULL, EVP_MD_get0_name(md), sctx->libctx,
+ sctx->propq, mackey, NULL) <= 0
|| EVP_DigestSignUpdate(mctx, hash, hashsize) <= 0
|| EVP_DigestSignFinal(mctx, binderout, &bindersize) <= 0
|| bindersize != hashsize) {
return ret;
}
-static int final_early_data(SSL *s, unsigned int context, int sent)
+static int final_early_data(SSL_CONNECTION *s, unsigned int context, int sent)
{
if (!sent)
return 1;
|| !s->ext.early_data_ok
|| s->hello_retry_request != SSL_HRR_NONE
|| (s->allow_early_data_cb != NULL
- && !s->allow_early_data_cb(s,
+ && !s->allow_early_data_cb(SSL_CONNECTION_GET_SSL(s),
s->allow_early_data_cb_data))) {
s->ext.early_data = SSL_EARLY_DATA_REJECTED;
} else {
return 1;
}
-static int final_maxfragmentlen(SSL *s, unsigned int context, int sent)
+static int final_maxfragmentlen(SSL_CONNECTION *s, unsigned int context,
+ int sent)
{
/*
* Session resumption on server-side with MFL extension active
return 1;
}
-static int init_post_handshake_auth(SSL *s, ossl_unused unsigned int context)
+static int init_post_handshake_auth(SSL_CONNECTION *s,
+ ossl_unused unsigned int context)
{
s->post_handshake_auth = SSL_PHA_NONE;
* If clients offer "pre_shared_key" without a "psk_key_exchange_modes"
* extension, servers MUST abort the handshake.
*/
-static int final_psk(SSL *s, unsigned int context, int sent)
+static int final_psk(SSL_CONNECTION *s, unsigned int context, int sent)
{
if (s->server && sent && s->clienthello != NULL
&& !s->clienthello->pre_proc_exts[TLSEXT_IDX_psk_kex_modes].present) {
#include "internal/cryptlib.h"
#include "statem_local.h"
-EXT_RETURN tls_construct_ctos_renegotiate(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_ctos_renegotiate(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx)
{
return EXT_RETURN_SENT;
}
-EXT_RETURN tls_construct_ctos_server_name(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_ctos_server_name(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx)
{
}
/* Push a Max Fragment Len extension into ClientHello */
-EXT_RETURN tls_construct_ctos_maxfragmentlen(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_ctos_maxfragmentlen(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx)
{
}
#ifndef OPENSSL_NO_SRP
-EXT_RETURN tls_construct_ctos_srp(SSL *s, WPACKET *pkt, unsigned int context,
+EXT_RETURN tls_construct_ctos_srp(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx)
{
/* Add SRP username if there is one */
}
#endif
-static int use_ecc(SSL *s, int min_version, int max_version)
+static int use_ecc(SSL_CONNECTION *s, int min_version, int max_version)
{
int i, end, ret = 0;
unsigned long alg_k, alg_a;
STACK_OF(SSL_CIPHER) *cipher_stack = NULL;
const uint16_t *pgroups = NULL;
size_t num_groups, j;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
/* See if we support any ECC ciphersuites */
if (s->version == SSL3_VERSION)
return 0;
- cipher_stack = SSL_get1_supported_ciphers(s);
+ cipher_stack = SSL_get1_supported_ciphers(ssl);
end = sk_SSL_CIPHER_num(cipher_stack);
for (i = 0; i < end; i++) {
const SSL_CIPHER *c = sk_SSL_CIPHER_value(cipher_stack, i);
return 0;
}
-EXT_RETURN tls_construct_ctos_ec_pt_formats(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_ctos_ec_pt_formats(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx)
{
return EXT_RETURN_SENT;
}
-EXT_RETURN tls_construct_ctos_supported_groups(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_ctos_supported_groups(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx)
{
* if we don't have EC support then we don't send this extension.
*/
if (!use_ecc(s, min_version, max_version)
- && (SSL_IS_DTLS(s) || max_version < TLS1_3_VERSION))
+ && (SSL_CONNECTION_IS_DTLS(s) || max_version < TLS1_3_VERSION))
return EXT_RETURN_NOT_SENT;
/*
return EXT_RETURN_SENT;
}
-EXT_RETURN tls_construct_ctos_session_ticket(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_ctos_session_ticket(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx)
{
return EXT_RETURN_SENT;
}
-EXT_RETURN tls_construct_ctos_sig_algs(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_ctos_sig_algs(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx)
{
}
#ifndef OPENSSL_NO_OCSP
-EXT_RETURN tls_construct_ctos_status_request(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_ctos_status_request(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx)
{
#endif
#ifndef OPENSSL_NO_NEXTPROTONEG
-EXT_RETURN tls_construct_ctos_npn(SSL *s, WPACKET *pkt, unsigned int context,
+EXT_RETURN tls_construct_ctos_npn(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx)
{
- if (s->ctx->ext.npn_select_cb == NULL || !SSL_IS_FIRST_HANDSHAKE(s))
+ if (SSL_CONNECTION_GET_CTX(s)->ext.npn_select_cb == NULL
+ || !SSL_IS_FIRST_HANDSHAKE(s))
return EXT_RETURN_NOT_SENT;
/*
}
#endif
-EXT_RETURN tls_construct_ctos_alpn(SSL *s, WPACKET *pkt, unsigned int context,
+EXT_RETURN tls_construct_ctos_alpn(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx)
{
s->s3.alpn_sent = 0;
#ifndef OPENSSL_NO_SRTP
-EXT_RETURN tls_construct_ctos_use_srtp(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_ctos_use_srtp(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx)
{
- STACK_OF(SRTP_PROTECTION_PROFILE) *clnt = SSL_get_srtp_profiles(s);
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
+ STACK_OF(SRTP_PROTECTION_PROFILE) *clnt = SSL_get_srtp_profiles(ssl);
int i, end;
if (clnt == NULL)
}
#endif
-EXT_RETURN tls_construct_ctos_etm(SSL *s, WPACKET *pkt, unsigned int context,
+EXT_RETURN tls_construct_ctos_etm(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx)
{
if (s->options & SSL_OP_NO_ENCRYPT_THEN_MAC)
}
#ifndef OPENSSL_NO_CT
-EXT_RETURN tls_construct_ctos_sct(SSL *s, WPACKET *pkt, unsigned int context,
+EXT_RETURN tls_construct_ctos_sct(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx)
{
if (s->ct_validation_callback == NULL)
}
#endif
-EXT_RETURN tls_construct_ctos_ems(SSL *s, WPACKET *pkt, unsigned int context,
+EXT_RETURN tls_construct_ctos_ems(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx)
{
if (s->options & SSL_OP_NO_EXTENDED_MASTER_SECRET)
return EXT_RETURN_SENT;
}
-EXT_RETURN tls_construct_ctos_supported_versions(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_ctos_supported_versions(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx)
{
/*
* Construct a psk_kex_modes extension.
*/
-EXT_RETURN tls_construct_ctos_psk_kex_modes(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_ctos_psk_kex_modes(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx)
{
}
#ifndef OPENSSL_NO_TLS1_3
-static int add_key_share(SSL *s, WPACKET *pkt, unsigned int curve_id)
+static int add_key_share(SSL_CONNECTION *s, WPACKET *pkt, unsigned int curve_id)
{
unsigned char *encoded_point = NULL;
EVP_PKEY *key_share_key = NULL;
}
#endif
-EXT_RETURN tls_construct_ctos_key_share(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_ctos_key_share(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx)
{
#endif
}
-EXT_RETURN tls_construct_ctos_cookie(SSL *s, WPACKET *pkt, unsigned int context,
+EXT_RETURN tls_construct_ctos_cookie(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx)
{
EXT_RETURN ret = EXT_RETURN_FAIL;
return ret;
}
-EXT_RETURN tls_construct_ctos_early_data(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_ctos_early_data(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx)
{
SSL_SESSION *psksess = NULL;
SSL_SESSION *edsess = NULL;
const EVP_MD *handmd = NULL;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
if (s->hello_retry_request == SSL_HRR_PENDING)
handmd = ssl_handshake_md(s);
if (s->psk_use_session_cb != NULL
- && (!s->psk_use_session_cb(s, handmd, &id, &idlen, &psksess)
+ && (!s->psk_use_session_cb(ssl, handmd, &id, &idlen, &psksess)
|| (psksess != NULL
&& psksess->ssl_version != TLS1_3_VERSION))) {
SSL_SESSION_free(psksess);
size_t psklen = 0;
memset(identity, 0, sizeof(identity));
- psklen = s->psk_client_callback(s, NULL, identity, sizeof(identity) - 1,
+ psklen = s->psk_client_callback(ssl, NULL,
+ identity, sizeof(identity) - 1,
psk, sizeof(psk));
if (psklen > PSK_MAX_PSK_LEN) {
* We found a PSK using an old style callback. We don't know
* the digest so we default to SHA256 as per the TLSv1.3 spec
*/
- cipher = SSL_CIPHER_find(s, tls13_aes128gcmsha256_id);
+ cipher = SSL_CIPHER_find(ssl, tls13_aes128gcmsha256_id);
if (cipher == NULL) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return EXT_RETURN_FAIL;
*/
#define PSK_PRE_BINDER_OVERHEAD (2 + 2 + 2 + 2 + 4 + 2 + 1)
-EXT_RETURN tls_construct_ctos_padding(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_ctos_padding(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx)
{
if (s->session->ssl_version == TLS1_3_VERSION
&& s->session->ext.ticklen != 0
&& s->session->cipher != NULL) {
- const EVP_MD *md = ssl_md(s->ctx, s->session->cipher->algorithm2);
+ const EVP_MD *md = ssl_md(SSL_CONNECTION_GET_CTX(s),
+ s->session->cipher->algorithm2);
if (md != NULL) {
/*
/*
* Construct the pre_shared_key extension
*/
-EXT_RETURN tls_construct_ctos_psk(SSL *s, WPACKET *pkt, unsigned int context,
+EXT_RETURN tls_construct_ctos_psk(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx)
{
#ifndef OPENSSL_NO_TLS1_3
unsigned char *resbinder = NULL, *pskbinder = NULL, *msgstart = NULL;
const EVP_MD *handmd = NULL, *mdres = NULL, *mdpsk = NULL;
int dores = 0;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
s->ext.tick_identity = 0;
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return EXT_RETURN_FAIL;
}
- mdres = ssl_md(s->ctx, s->session->cipher->algorithm2);
+ mdres = ssl_md(sctx, s->session->cipher->algorithm2);
if (mdres == NULL) {
/*
* Don't recognize this cipher so we can't use the session.
return EXT_RETURN_NOT_SENT;
if (s->psksession != NULL) {
- mdpsk = ssl_md(s->ctx, s->psksession->cipher->algorithm2);
+ mdpsk = ssl_md(sctx, s->psksession->cipher->algorithm2);
if (mdpsk == NULL) {
/*
* Don't recognize this cipher so we can't use the session.
#endif
}
-EXT_RETURN tls_construct_ctos_post_handshake_auth(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_ctos_post_handshake_auth(SSL_CONNECTION *s, WPACKET *pkt,
ossl_unused unsigned int context,
ossl_unused X509 *x,
ossl_unused size_t chainidx)
/*
* Parse the server's renegotiation binding and abort if it's not right
*/
-int tls_parse_stoc_renegotiate(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_stoc_renegotiate(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx)
{
size_t expected_len = s->s3.previous_client_finished_len
}
/* Parse the server's max fragment len extension packet */
-int tls_parse_stoc_maxfragmentlen(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_stoc_maxfragmentlen(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx)
{
unsigned int value;
return 1;
}
-int tls_parse_stoc_server_name(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_stoc_server_name(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx)
{
if (s->ext.hostname == NULL) {
return 1;
}
-int tls_parse_stoc_ec_pt_formats(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_stoc_ec_pt_formats(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx)
{
size_t ecpointformats_len;
return 1;
}
-int tls_parse_stoc_session_ticket(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_stoc_session_ticket(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx)
{
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
+
if (s->ext.session_ticket_cb != NULL &&
- !s->ext.session_ticket_cb(s, PACKET_data(pkt),
- PACKET_remaining(pkt),
- s->ext.session_ticket_cb_arg)) {
+ !s->ext.session_ticket_cb(ssl, PACKET_data(pkt),
+ PACKET_remaining(pkt),
+ s->ext.session_ticket_cb_arg)) {
SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_BAD_EXTENSION);
return 0;
}
}
#ifndef OPENSSL_NO_OCSP
-int tls_parse_stoc_status_request(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_stoc_status_request(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx)
{
if (context == SSL_EXT_TLS1_3_CERTIFICATE_REQUEST) {
SSLfatal(s, SSL_AD_UNSUPPORTED_EXTENSION, SSL_R_BAD_EXTENSION);
return 0;
}
- if (!SSL_IS_TLS13(s) && PACKET_remaining(pkt) > 0) {
+ if (!SSL_CONNECTION_IS_TLS13(s) && PACKET_remaining(pkt) > 0) {
SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION);
return 0;
}
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
/* We only know how to handle this if it's for the first Certificate in
* the chain. We ignore any other responses.
*/
#ifndef OPENSSL_NO_CT
-int tls_parse_stoc_sct(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx)
+int tls_parse_stoc_sct(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
+ X509 *x, size_t chainidx)
{
if (context == SSL_EXT_TLS1_3_CERTIFICATE_REQUEST) {
/* We ignore this if the server sends it in a CertificateRequest */
* elements of zero length are allowed and the set of elements must exactly
* fill the length of the block. Returns 1 on success or 0 on failure.
*/
-static int ssl_next_proto_validate(SSL *s, PACKET *pkt)
+static int ssl_next_proto_validate(SSL_CONNECTION *s, PACKET *pkt)
{
PACKET tmp_protocol;
return 1;
}
-int tls_parse_stoc_npn(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx)
+int tls_parse_stoc_npn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
+ X509 *x, size_t chainidx)
{
unsigned char *selected;
unsigned char selected_len;
PACKET tmppkt;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
/* Check if we are in a renegotiation. If so ignore this extension */
if (!SSL_IS_FIRST_HANDSHAKE(s))
return 1;
/* We must have requested it. */
- if (s->ctx->ext.npn_select_cb == NULL) {
+ if (sctx->ext.npn_select_cb == NULL) {
SSLfatal(s, SSL_AD_UNSUPPORTED_EXTENSION, SSL_R_BAD_EXTENSION);
return 0;
}
/* SSLfatal() already called */
return 0;
}
- if (s->ctx->ext.npn_select_cb(s, &selected, &selected_len,
- PACKET_data(pkt),
- PACKET_remaining(pkt),
- s->ctx->ext.npn_select_cb_arg) !=
+ if (sctx->ext.npn_select_cb(SSL_CONNECTION_GET_SSL(s),
+ &selected, &selected_len,
+ PACKET_data(pkt), PACKET_remaining(pkt),
+ sctx->ext.npn_select_cb_arg) !=
SSL_TLSEXT_ERR_OK) {
SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_BAD_EXTENSION);
return 0;
}
#endif
-int tls_parse_stoc_alpn(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx)
+int tls_parse_stoc_alpn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
+ X509 *x, size_t chainidx)
{
size_t len;
}
#ifndef OPENSSL_NO_SRTP
-int tls_parse_stoc_use_srtp(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx)
+int tls_parse_stoc_use_srtp(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context, X509 *x, size_t chainidx)
{
unsigned int id, ct, mki;
int i;
}
/* Throw an error if the server gave us an unsolicited extension */
- clnt = SSL_get_srtp_profiles(s);
+ clnt = SSL_get_srtp_profiles(SSL_CONNECTION_GET_SSL(s));
if (clnt == NULL) {
SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_NO_SRTP_PROFILES);
return 0;
}
#endif
-int tls_parse_stoc_etm(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx)
+int tls_parse_stoc_etm(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
+ X509 *x, size_t chainidx)
{
/* Ignore if inappropriate ciphersuite */
if (!(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC)
return 1;
}
-int tls_parse_stoc_ems(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx)
+int tls_parse_stoc_ems(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
+ X509 *x, size_t chainidx)
{
if (s->options & SSL_OP_NO_EXTENDED_MASTER_SECRET)
return 1;
return 1;
}
-int tls_parse_stoc_supported_versions(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_stoc_supported_versions(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx)
{
unsigned int version;
return 1;
}
-int tls_parse_stoc_key_share(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
+int tls_parse_stoc_key_share(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context, X509 *x,
size_t chainidx)
{
#ifndef OPENSSL_NO_TLS1_3
s->session->kex_group = group_id;
}
- if ((ginf = tls1_group_id_lookup(s->ctx, group_id)) == NULL) {
+ if ((ginf = tls1_group_id_lookup(SSL_CONNECTION_GET_CTX(s),
+ group_id)) == NULL) {
SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_KEY_SHARE);
return 0;
}
return 1;
}
-int tls_parse_stoc_cookie(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx)
+int tls_parse_stoc_cookie(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
+ X509 *x, size_t chainidx)
{
PACKET cookie;
return 1;
}
-int tls_parse_stoc_early_data(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_stoc_early_data(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx)
{
if (context == SSL_EXT_TLS1_3_NEW_SESSION_TICKET) {
return 1;
}
-int tls_parse_stoc_psk(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
+int tls_parse_stoc_psk(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context, X509 *x,
size_t chainidx)
{
#ifndef OPENSSL_NO_TLS1_3
}
/* Pass received custom extension data to the application for parsing. */
-int custom_ext_parse(SSL *s, unsigned int context, unsigned int ext_type,
+int custom_ext_parse(SSL_CONNECTION *s, unsigned int context,
+ unsigned int ext_type,
const unsigned char *ext_data, size_t ext_size, X509 *x,
size_t chainidx)
{
meth->ext_flags |= SSL_EXT_FLAG_RECEIVED;
/* If no parse function set return success */
- if (!meth->parse_cb)
+ if (meth->parse_cb == NULL)
return 1;
- if (meth->parse_cb(s, ext_type, context, ext_data, ext_size, x, chainidx,
- &al, meth->parse_arg) <= 0) {
+ if (meth->parse_cb(SSL_CONNECTION_GET_SSL(s), ext_type, context, ext_data,
+ ext_size, x, chainidx, &al, meth->parse_arg) <= 0) {
SSLfatal(s, al, SSL_R_BAD_EXTENSION);
return 0;
}
* Request custom extension data from the application and add to the return
* buffer.
*/
-int custom_ext_add(SSL *s, int context, WPACKET *pkt, X509 *x, size_t chainidx,
- int maxversion)
+int custom_ext_add(SSL_CONNECTION *s, int context, WPACKET *pkt, X509 *x,
+ size_t chainidx, int maxversion)
{
custom_ext_methods *exts = &s->cert->custext;
custom_ext_method *meth;
continue;
if (meth->add_cb != NULL) {
- int cb_retval = meth->add_cb(s, meth->ext_type, context, &out,
+ int cb_retval = meth->add_cb(SSL_CONNECTION_GET_SSL(s),
+ meth->ext_type, context, &out,
&outlen, x, chainidx, &al,
meth->add_arg);
meth->ext_flags |= SSL_EXT_FLAG_SENT;
}
if (meth->free_cb != NULL)
- meth->free_cb(s, meth->ext_type, context, out, meth->add_arg);
+ meth->free_cb(SSL_CONNECTION_GET_SSL(s), meth->ext_type, context,
+ out, meth->add_arg);
}
return 1;
}
/*
* Parse the client's renegotiation binding and abort if it's not right
*/
-int tls_parse_ctos_renegotiate(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_ctos_renegotiate(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx)
{
unsigned int ilen;
* extension.
* - On session reconnect, the servername extension may be absent.
*/
-int tls_parse_ctos_server_name(SSL *s, PACKET *pkt, unsigned int context,
- X509 *x, size_t chainidx)
+int tls_parse_ctos_server_name(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context, X509 *x, size_t chainidx)
{
unsigned int servname_type;
PACKET sni, hostname;
* In TLSv1.2 and below the SNI is associated with the session. In TLSv1.3
* we always use the SNI value from the handshake.
*/
- if (!s->hit || SSL_IS_TLS13(s)) {
+ if (!s->hit || SSL_CONNECTION_IS_TLS13(s)) {
if (PACKET_remaining(&hostname) > TLSEXT_MAXLEN_host_name) {
SSLfatal(s, SSL_AD_UNRECOGNIZED_NAME, SSL_R_BAD_EXTENSION);
return 0;
return 1;
}
-int tls_parse_ctos_maxfragmentlen(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_ctos_maxfragmentlen(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx)
{
unsigned int value;
}
#ifndef OPENSSL_NO_SRP
-int tls_parse_ctos_srp(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx)
+int tls_parse_ctos_srp(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
+ X509 *x, size_t chainidx)
{
PACKET srp_I;
}
#endif
-int tls_parse_ctos_ec_pt_formats(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_ctos_ec_pt_formats(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx)
{
PACKET ec_point_format_list;
return 1;
}
-int tls_parse_ctos_session_ticket(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_ctos_session_ticket(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx)
{
if (s->ext.session_ticket_cb &&
- !s->ext.session_ticket_cb(s, PACKET_data(pkt),
- PACKET_remaining(pkt),
- s->ext.session_ticket_cb_arg)) {
+ !s->ext.session_ticket_cb(SSL_CONNECTION_GET_SSL(s),
+ PACKET_data(pkt), PACKET_remaining(pkt),
+ s->ext.session_ticket_cb_arg)) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return 0;
}
return 1;
}
-int tls_parse_ctos_sig_algs_cert(SSL *s, PACKET *pkt,
+int tls_parse_ctos_sig_algs_cert(SSL_CONNECTION *s, PACKET *pkt,
ossl_unused unsigned int context,
ossl_unused X509 *x,
ossl_unused size_t chainidx)
return 1;
}
-int tls_parse_ctos_sig_algs(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx)
+int tls_parse_ctos_sig_algs(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context, X509 *x, size_t chainidx)
{
PACKET supported_sig_algs;
}
#ifndef OPENSSL_NO_OCSP
-int tls_parse_ctos_status_request(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_ctos_status_request(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx)
{
PACKET responder_id_list, exts;
#endif
#ifndef OPENSSL_NO_NEXTPROTONEG
-int tls_parse_ctos_npn(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx)
+int tls_parse_ctos_npn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
+ X509 *x, size_t chainidx)
{
/*
* We shouldn't accept this extension on a
* Save the ALPN extension in a ClientHello.|pkt| holds the contents of the ALPN
* extension, not including type and length. Returns: 1 on success, 0 on error.
*/
-int tls_parse_ctos_alpn(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx)
+int tls_parse_ctos_alpn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
+ X509 *x, size_t chainidx)
{
PACKET protocol_list, save_protocol_list, protocol;
}
#ifndef OPENSSL_NO_SRTP
-int tls_parse_ctos_use_srtp(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx)
+int tls_parse_ctos_use_srtp(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context, X509 *x, size_t chainidx)
{
STACK_OF(SRTP_PROTECTION_PROFILE) *srvr;
unsigned int ct, mki_len, id;
int i, srtp_pref;
PACKET subpkt;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
/* Ignore this if we have no SRTP profiles */
- if (SSL_get_srtp_profiles(s) == NULL)
+ if (SSL_get_srtp_profiles(ssl) == NULL)
return 1;
/* Pull off the length of the cipher suite list and check it is even */
return 0;
}
- srvr = SSL_get_srtp_profiles(s);
+ srvr = SSL_get_srtp_profiles(ssl);
s->srtp_profile = NULL;
/* Search all profiles for a match initially */
srtp_pref = sk_SRTP_PROTECTION_PROFILE_num(srvr);
}
#endif
-int tls_parse_ctos_etm(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx)
+int tls_parse_ctos_etm(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
+ X509 *x, size_t chainidx)
{
if (!(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC))
s->ext.use_etm = 1;
* Process a psk_kex_modes extension received in the ClientHello. |pkt| contains
* the raw PACKET data for the extension. Returns 1 on success or 0 on failure.
*/
-int tls_parse_ctos_psk_kex_modes(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_ctos_psk_kex_modes(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx)
{
#ifndef OPENSSL_NO_TLS1_3
* Process a key_share extension received in the ClientHello. |pkt| contains
* the raw PACKET data for the extension. Returns 1 on success or 0 on failure.
*/
-int tls_parse_ctos_key_share(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx)
+int tls_parse_ctos_key_share(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context, X509 *x, size_t chainidx)
{
#ifndef OPENSSL_NO_TLS1_3
unsigned int group_id;
return 1;
}
-int tls_parse_ctos_cookie(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx)
+int tls_parse_ctos_cookie(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
+ X509 *x, size_t chainidx)
{
#ifndef OPENSSL_NO_TLS1_3
unsigned int format, version, key_share, group_id;
unsigned char hrr[MAX_HRR_SIZE];
size_t rawlen, hmaclen, hrrlen, ciphlen;
unsigned long tm, now;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
/* Ignore any cookie if we're not set up to verify it */
- if (s->ctx->verify_stateless_cookie_cb == NULL
+ if (sctx->verify_stateless_cookie_cb == NULL
|| (s->s3.flags & TLS1_FLAGS_STATELESS) == 0)
return 1;
/* Verify the HMAC of the cookie */
hctx = EVP_MD_CTX_create();
- pkey = EVP_PKEY_new_raw_private_key_ex(s->ctx->libctx, "HMAC",
- s->ctx->propq,
+ pkey = EVP_PKEY_new_raw_private_key_ex(sctx->libctx, "HMAC",
+ sctx->propq,
s->session_ctx->ext.cookie_hmac_key,
sizeof(s->session_ctx->ext.cookie_hmac_key));
if (hctx == NULL || pkey == NULL) {
}
hmaclen = SHA256_DIGEST_LENGTH;
- if (EVP_DigestSignInit_ex(hctx, NULL, "SHA2-256", s->ctx->libctx,
- s->ctx->propq, pkey, NULL) <= 0
+ if (EVP_DigestSignInit_ex(hctx, NULL, "SHA2-256", sctx->libctx,
+ sctx->propq, pkey, NULL) <= 0
|| EVP_DigestSign(hctx, hmac, &hmaclen, data,
rawlen - SHA256_DIGEST_LENGTH) <= 0
|| hmaclen != SHA256_DIGEST_LENGTH) {
}
/* Verify the app cookie */
- if (s->ctx->verify_stateless_cookie_cb(s, PACKET_data(&appcookie),
- PACKET_remaining(&appcookie)) == 0) {
+ if (sctx->verify_stateless_cookie_cb(ssl,
+ PACKET_data(&appcookie),
+ PACKET_remaining(&appcookie)) == 0) {
SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_COOKIE_MISMATCH);
return 0;
}
|| !WPACKET_memcpy(&hrrpkt, hrrrandom, SSL3_RANDOM_SIZE)
|| !WPACKET_sub_memcpy_u8(&hrrpkt, s->tmp_session_id,
s->tmp_session_id_len)
- || !s->method->put_cipher_by_char(s->s3.tmp.new_cipher, &hrrpkt,
- &ciphlen)
+ || !ssl->method->put_cipher_by_char(s->s3.tmp.new_cipher, &hrrpkt,
+ &ciphlen)
|| !WPACKET_put_bytes_u8(&hrrpkt, 0)
|| !WPACKET_start_sub_packet_u16(&hrrpkt)) {
WPACKET_cleanup(&hrrpkt);
return 1;
}
-int tls_parse_ctos_supported_groups(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_ctos_supported_groups(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx)
{
PACKET supported_groups_list;
return 0;
}
- if (!s->hit || SSL_IS_TLS13(s)) {
+ if (!s->hit || SSL_CONNECTION_IS_TLS13(s)) {
OPENSSL_free(s->ext.peer_supportedgroups);
s->ext.peer_supportedgroups = NULL;
s->ext.peer_supportedgroups_len = 0;
return 1;
}
-int tls_parse_ctos_ems(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx)
+int tls_parse_ctos_ems(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
+ X509 *x, size_t chainidx)
{
/* The extension must always be empty */
if (PACKET_remaining(pkt) != 0) {
}
-int tls_parse_ctos_early_data(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_ctos_early_data(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
X509 *x, size_t chainidx)
{
if (PACKET_remaining(pkt) != 0) {
return 1;
}
-static SSL_TICKET_STATUS tls_get_stateful_ticket(SSL *s, PACKET *tick,
+static SSL_TICKET_STATUS tls_get_stateful_ticket(SSL_CONNECTION *s, PACKET *tick,
SSL_SESSION **sess)
{
SSL_SESSION *tmpsess = NULL;
return SSL_TICKET_SUCCESS;
}
-int tls_parse_ctos_psk(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx)
+int tls_parse_ctos_psk(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
+ X509 *x, size_t chainidx)
{
PACKET identities, binders, binder;
size_t binderoffset, hashsize;
SSL_SESSION *sess = NULL;
unsigned int id, i, ext = 0;
const EVP_MD *md = NULL;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
/*
* If we have no PSK kex mode that we recognise then we can't resume so
idlen = PACKET_remaining(&identity);
if (s->psk_find_session_cb != NULL
- && !s->psk_find_session_cb(s, PACKET_data(&identity), idlen,
+ && !s->psk_find_session_cb(ssl, PACKET_data(&identity), idlen,
&sess)) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_EXTENSION);
return 0;
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return 0;
}
- pskdatalen = s->psk_server_callback(s, pskid, pskdata,
+ pskdatalen = s->psk_server_callback(ssl, pskid, pskdata,
sizeof(pskdata));
OPENSSL_free(pskid);
if (pskdatalen > PSK_MAX_PSK_LEN) {
* We found a PSK using an old style callback. We don't know
* the digest so we default to SHA256 as per the TLSv1.3 spec
*/
- cipher = SSL_CIPHER_find(s, tls13_aes128gcmsha256_id);
+ cipher = SSL_CIPHER_find(ssl, tls13_aes128gcmsha256_id);
if (cipher == NULL) {
OPENSSL_cleanse(pskdata, pskdatalen);
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
}
}
- md = ssl_md(s->ctx, sess->cipher->algorithm2);
+ md = ssl_md(sctx, sess->cipher->algorithm2);
if (md == NULL) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
goto err;
}
if (!EVP_MD_is_a(md,
- EVP_MD_get0_name(ssl_md(s->ctx,
+ EVP_MD_get0_name(ssl_md(sctx,
s->s3.tmp.new_cipher->algorithm2)))) {
/* The ciphersuite is not compatible with this session. */
SSL_SESSION_free(sess);
return 0;
}
-int tls_parse_ctos_post_handshake_auth(SSL *s, PACKET *pkt,
+int tls_parse_ctos_post_handshake_auth(SSL_CONNECTION *s, PACKET *pkt,
ossl_unused unsigned int context,
ossl_unused X509 *x,
ossl_unused size_t chainidx)
/*
* Add the server's renegotiation binding
*/
-EXT_RETURN tls_construct_stoc_renegotiate(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_stoc_renegotiate(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx)
{
return EXT_RETURN_SENT;
}
-EXT_RETURN tls_construct_stoc_server_name(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_stoc_server_name(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx)
{
* Prior to TLSv1.3 we ignore any SNI in the current handshake if resuming.
* We just use the servername from the initial handshake.
*/
- if (s->hit && !SSL_IS_TLS13(s))
+ if (s->hit && !SSL_CONNECTION_IS_TLS13(s))
return EXT_RETURN_NOT_SENT;
if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_name)
}
/* Add/include the server's max fragment len extension into ServerHello */
-EXT_RETURN tls_construct_stoc_maxfragmentlen(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_stoc_maxfragmentlen(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx)
{
return EXT_RETURN_SENT;
}
-EXT_RETURN tls_construct_stoc_ec_pt_formats(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_stoc_ec_pt_formats(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx)
{
return EXT_RETURN_SENT;
}
-EXT_RETURN tls_construct_stoc_supported_groups(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_stoc_supported_groups(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx)
{
}
/* Copy group ID if supported */
- version = SSL_version(s);
+ version = SSL_version(SSL_CONNECTION_GET_SSL(s));
for (i = 0; i < numgroups; i++) {
uint16_t group = groups[i];
return EXT_RETURN_SENT;
}
-EXT_RETURN tls_construct_stoc_session_ticket(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_stoc_session_ticket(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx)
{
}
#ifndef OPENSSL_NO_OCSP
-EXT_RETURN tls_construct_stoc_status_request(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_stoc_status_request(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx)
{
if (!s->ext.status_expected)
return EXT_RETURN_NOT_SENT;
- if (SSL_IS_TLS13(s) && chainidx != 0)
+ if (SSL_CONNECTION_IS_TLS13(s) && chainidx != 0)
return EXT_RETURN_NOT_SENT;
if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_status_request)
* send back an empty extension, with the certificate status appearing as a
* separate message
*/
- if (SSL_IS_TLS13(s) && !tls_construct_cert_status_body(s, pkt)) {
+ if (SSL_CONNECTION_IS_TLS13(s) && !tls_construct_cert_status_body(s, pkt)) {
/* SSLfatal() already called */
return EXT_RETURN_FAIL;
}
#endif
#ifndef OPENSSL_NO_NEXTPROTONEG
-EXT_RETURN tls_construct_stoc_next_proto_neg(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_stoc_next_proto_neg(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx)
{
unsigned int npalen;
int ret;
int npn_seen = s->s3.npn_seen;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
s->s3.npn_seen = 0;
- if (!npn_seen || s->ctx->ext.npn_advertised_cb == NULL)
+ if (!npn_seen || sctx->ext.npn_advertised_cb == NULL)
return EXT_RETURN_NOT_SENT;
- ret = s->ctx->ext.npn_advertised_cb(s, &npa, &npalen,
- s->ctx->ext.npn_advertised_cb_arg);
+ ret = sctx->ext.npn_advertised_cb(SSL_CONNECTION_GET_SSL(s), &npa, &npalen,
+ sctx->ext.npn_advertised_cb_arg);
if (ret == SSL_TLSEXT_ERR_OK) {
if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_next_proto_neg)
|| !WPACKET_sub_memcpy_u16(pkt, npa, npalen)) {
}
#endif
-EXT_RETURN tls_construct_stoc_alpn(SSL *s, WPACKET *pkt, unsigned int context,
+EXT_RETURN tls_construct_stoc_alpn(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context,
X509 *x, size_t chainidx)
{
if (s->s3.alpn_selected == NULL)
}
#ifndef OPENSSL_NO_SRTP
-EXT_RETURN tls_construct_stoc_use_srtp(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_stoc_use_srtp(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx)
{
}
#endif
-EXT_RETURN tls_construct_stoc_etm(SSL *s, WPACKET *pkt, unsigned int context,
+EXT_RETURN tls_construct_stoc_etm(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx)
{
if (!s->ext.use_etm)
return EXT_RETURN_SENT;
}
-EXT_RETURN tls_construct_stoc_ems(SSL *s, WPACKET *pkt, unsigned int context,
+EXT_RETURN tls_construct_stoc_ems(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx)
{
if ((s->s3.flags & TLS1_FLAGS_RECEIVED_EXTMS) == 0)
return EXT_RETURN_SENT;
}
-EXT_RETURN tls_construct_stoc_supported_versions(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_stoc_supported_versions(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx)
{
- if (!ossl_assert(SSL_IS_TLS13(s))) {
+ if (!ossl_assert(SSL_CONNECTION_IS_TLS13(s))) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return EXT_RETURN_FAIL;
}
return EXT_RETURN_SENT;
}
-EXT_RETURN tls_construct_stoc_key_share(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_stoc_key_share(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx)
{
return EXT_RETURN_FAIL;
}
- if ((ginf = tls1_group_id_lookup(s->ctx, s->s3.group_id)) == NULL) {
+ if ((ginf = tls1_group_id_lookup(SSL_CONNECTION_GET_CTX(s),
+ s->s3.group_id)) == NULL) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return EXT_RETURN_FAIL;
}
#endif
}
-EXT_RETURN tls_construct_stoc_cookie(SSL *s, WPACKET *pkt, unsigned int context,
+EXT_RETURN tls_construct_stoc_cookie(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx)
{
#ifndef OPENSSL_NO_TLS1_3
EVP_MD_CTX *hctx;
EVP_PKEY *pkey;
int ret = EXT_RETURN_FAIL;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
if ((s->s3.flags & TLS1_FLAGS_STATELESS) == 0)
return EXT_RETURN_NOT_SENT;
- if (s->ctx->gen_stateless_cookie_cb == NULL) {
+ if (sctx->gen_stateless_cookie_cb == NULL) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_COOKIE_CALLBACK_SET);
return EXT_RETURN_FAIL;
}
|| !WPACKET_put_bytes_u16(pkt, COOKIE_STATE_FORMAT_VERSION)
|| !WPACKET_put_bytes_u16(pkt, TLS1_3_VERSION)
|| !WPACKET_put_bytes_u16(pkt, s->s3.group_id)
- || !s->method->put_cipher_by_char(s->s3.tmp.new_cipher, pkt,
- &ciphlen)
+ || !ssl->method->put_cipher_by_char(s->s3.tmp.new_cipher, pkt,
+ &ciphlen)
/* Is there a key_share extension present in this HRR? */
|| !WPACKET_put_bytes_u8(pkt, s->s3.peer_tmp == NULL)
|| !WPACKET_put_bytes_u32(pkt, (unsigned int)time(NULL))
}
/* Generate the application cookie */
- if (s->ctx->gen_stateless_cookie_cb(s, appcookie1, &appcookielen) == 0) {
+ if (sctx->gen_stateless_cookie_cb(ssl, appcookie1,
+ &appcookielen) == 0) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_COOKIE_GEN_CALLBACK_FAILURE);
return EXT_RETURN_FAIL;
}
/* HMAC the cookie */
hctx = EVP_MD_CTX_create();
- pkey = EVP_PKEY_new_raw_private_key_ex(s->ctx->libctx, "HMAC",
- s->ctx->propq,
+ pkey = EVP_PKEY_new_raw_private_key_ex(sctx->libctx, "HMAC",
+ sctx->propq,
s->session_ctx->ext.cookie_hmac_key,
sizeof(s->session_ctx->ext.cookie_hmac_key));
if (hctx == NULL || pkey == NULL) {
goto err;
}
- if (EVP_DigestSignInit_ex(hctx, NULL, "SHA2-256", s->ctx->libctx,
- s->ctx->propq, pkey, NULL) <= 0
+ if (EVP_DigestSignInit_ex(hctx, NULL, "SHA2-256", sctx->libctx,
+ sctx->propq, pkey, NULL) <= 0
|| EVP_DigestSign(hctx, hmac, &hmaclen, cookie,
totcookielen) <= 0) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
#endif
}
-EXT_RETURN tls_construct_stoc_cryptopro_bug(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_stoc_cryptopro_bug(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx)
{
if (((s->s3.tmp.new_cipher->id & 0xFFFF) != 0x80
&& (s->s3.tmp.new_cipher->id & 0xFFFF) != 0x81)
- || (SSL_get_options(s) & SSL_OP_CRYPTOPRO_TLSEXT_BUG) == 0)
+ || (SSL_get_options(SSL_CONNECTION_GET_SSL(s))
+ & SSL_OP_CRYPTOPRO_TLSEXT_BUG) == 0)
return EXT_RETURN_NOT_SENT;
if (!WPACKET_memcpy(pkt, cryptopro_ext, sizeof(cryptopro_ext))) {
return EXT_RETURN_SENT;
}
-EXT_RETURN tls_construct_stoc_early_data(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_stoc_early_data(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx)
{
return EXT_RETURN_SENT;
}
-EXT_RETURN tls_construct_stoc_psk(SSL *s, WPACKET *pkt, unsigned int context,
+EXT_RETURN tls_construct_stoc_psk(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx)
{
if (!s->hit)
SUB_STATE_END_HANDSHAKE
} SUB_STATE_RETURN;
-static int state_machine(SSL *s, int server);
-static void init_read_state_machine(SSL *s);
-static SUB_STATE_RETURN read_state_machine(SSL *s);
-static void init_write_state_machine(SSL *s);
-static SUB_STATE_RETURN write_state_machine(SSL *s);
+static int state_machine(SSL_CONNECTION *s, int server);
+static void init_read_state_machine(SSL_CONNECTION *s);
+static SUB_STATE_RETURN read_state_machine(SSL_CONNECTION *s);
+static void init_write_state_machine(SSL_CONNECTION *s);
+static SUB_STATE_RETURN write_state_machine(SSL_CONNECTION *s);
OSSL_HANDSHAKE_STATE SSL_get_state(const SSL *ssl)
{
- return ssl->statem.hand_state;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(ssl);
+
+ if (sc == NULL)
+ return TLS_ST_BEFORE;
+
+ return sc->statem.hand_state;
}
int SSL_in_init(const SSL *s)
{
- return s->statem.in_init;
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ return sc->statem.in_init;
}
int SSL_is_init_finished(const SSL *s)
{
- return !(s->statem.in_init) && (s->statem.hand_state == TLS_ST_OK);
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ return !(sc->statem.in_init) && (sc->statem.hand_state == TLS_ST_OK);
}
int SSL_in_before(const SSL *s)
{
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
/*
* Historically being "in before" meant before anything had happened. In the
* current code though we remain in the "before" state for a while after we
* first message to arrive). There "in before" is taken to mean "in before"
* and not started any handshake process yet.
*/
- return (s->statem.hand_state == TLS_ST_BEFORE)
- && (s->statem.state == MSG_FLOW_UNINITED);
+ return (sc->statem.hand_state == TLS_ST_BEFORE)
+ && (sc->statem.state == MSG_FLOW_UNINITED);
}
/*
* Clear the state machine state and reset back to MSG_FLOW_UNINITED
*/
-void ossl_statem_clear(SSL *s)
+void ossl_statem_clear(SSL_CONNECTION *s)
{
s->statem.state = MSG_FLOW_UNINITED;
s->statem.hand_state = TLS_ST_BEFORE;
/*
* Set the state machine up ready for a renegotiation handshake
*/
-void ossl_statem_set_renegotiate(SSL *s)
+void ossl_statem_set_renegotiate(SSL_CONNECTION *s)
{
s->statem.in_init = 1;
s->statem.request_state = TLS_ST_SW_HELLO_REQ;
}
-void ossl_statem_send_fatal(SSL *s, int al)
+void ossl_statem_send_fatal(SSL_CONNECTION *s, int al)
{
/* We shouldn't call SSLfatal() twice. Once is enough */
if (s->statem.in_init && s->statem.state == MSG_FLOW_ERROR)
* into an error state and sends an alert if appropriate.
* This is a permanent error for the current connection.
*/
-void ossl_statem_fatal(SSL *s, int al, int reason, const char *fmt, ...)
+void ossl_statem_fatal(SSL_CONNECTION *s, int al, int reason,
+ const char *fmt, ...)
{
va_list args;
* 1: Yes
* 0: No
*/
-int ossl_statem_in_error(const SSL *s)
+int ossl_statem_in_error(const SSL_CONNECTION *s)
{
if (s->statem.state == MSG_FLOW_ERROR)
return 1;
return 0;
}
-void ossl_statem_set_in_init(SSL *s, int init)
+void ossl_statem_set_in_init(SSL_CONNECTION *s, int init)
{
s->statem.in_init = init;
}
-int ossl_statem_get_in_handshake(SSL *s)
+int ossl_statem_get_in_handshake(SSL_CONNECTION *s)
{
return s->statem.in_handshake;
}
-void ossl_statem_set_in_handshake(SSL *s, int inhand)
+void ossl_statem_set_in_handshake(SSL_CONNECTION *s, int inhand)
{
if (inhand)
s->statem.in_handshake++;
}
/* Are we in a sensible state to skip over unreadable early data? */
-int ossl_statem_skip_early_data(SSL *s)
+int ossl_statem_skip_early_data(SSL_CONNECTION *s)
{
if (s->ext.early_data != SSL_EARLY_DATA_REJECTED)
return 0;
* attempting to read data (SSL_read*()), or -1 if we are in SSL_do_handshake()
* or similar.
*/
-void ossl_statem_check_finish_init(SSL *s, int sending)
+void ossl_statem_check_finish_init(SSL_CONNECTION *s, int sending)
{
if (sending == -1) {
if (s->statem.hand_state == TLS_ST_PENDING_EARLY_DATA_END
}
}
-void ossl_statem_set_hello_verify_done(SSL *s)
+void ossl_statem_set_hello_verify_done(SSL_CONNECTION *s)
{
s->statem.state = MSG_FLOW_UNINITED;
s->statem.in_init = 1;
int ossl_statem_connect(SSL *s)
{
- return state_machine(s, 0);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return -1;
+
+ return state_machine(sc, 0);
}
int ossl_statem_accept(SSL *s)
{
- return state_machine(s, 1);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return -1;
+
+ return state_machine(sc, 1);
}
typedef void (*info_cb) (const SSL *, int, int);
-static info_cb get_callback(SSL *s)
+static info_cb get_callback(SSL_CONNECTION *s)
{
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
+
if (s->info_callback != NULL)
return s->info_callback;
- else if (s->ctx->info_callback != NULL)
- return s->ctx->info_callback;
+ else if (sctx->info_callback != NULL)
+ return sctx->info_callback;
return NULL;
}
* 1: Success
* <=0: NBIO or error
*/
-static int state_machine(SSL *s, int server)
+static int state_machine(SSL_CONNECTION *s, int server)
{
BUF_MEM *buf = NULL;
void (*cb) (const SSL *ssl, int type, int val) = NULL;
OSSL_STATEM *st = &s->statem;
int ret = -1;
int ssret;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
if (st->state == MSG_FLOW_ERROR) {
/* Shouldn't have been called if we're already in the error state */
cb = get_callback(s);
st->in_handshake++;
- if (!SSL_in_init(s) || SSL_in_before(s)) {
+ if (!SSL_in_init(ssl) || SSL_in_before(ssl)) {
/*
* If we are stateless then we already called SSL_clear() - don't do
* it again and clear the STATELESS flag itself.
*/
- if ((s->s3.flags & TLS1_FLAGS_STATELESS) == 0 && !SSL_clear(s))
+ if ((s->s3.flags & TLS1_FLAGS_STATELESS) == 0 && !SSL_clear(ssl))
return -1;
}
#ifndef OPENSSL_NO_SCTP
- if (SSL_IS_DTLS(s) && BIO_dgram_is_sctp(SSL_get_wbio(s))) {
+ if (SSL_CONNECTION_IS_DTLS(s) && BIO_dgram_is_sctp(SSL_get_wbio(ssl))) {
/*
* Notify SCTP BIO socket to enter handshake mode and prevent stream
* identifier other than 0.
*/
- BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_SET_IN_HANDSHAKE,
+ BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_SET_IN_HANDSHAKE,
st->in_handshake, NULL);
}
#endif
s->server = server;
if (cb != NULL) {
- if (SSL_IS_FIRST_HANDSHAKE(s) || !SSL_IS_TLS13(s))
- cb(s, SSL_CB_HANDSHAKE_START, 1);
+ if (SSL_IS_FIRST_HANDSHAKE(s) || !SSL_CONNECTION_IS_TLS13(s))
+ cb(ssl, SSL_CB_HANDSHAKE_START, 1);
}
/*
* doomed to failure.
*/
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
if ((s->version & 0xff00) != (DTLS1_VERSION & 0xff00) &&
(server || (s->version & 0xff00) != (DTLS1_BAD_VER & 0xff00))) {
SSLfatal(s, SSL_AD_NO_ALERT, ERR_R_INTERNAL_ERROR);
* SCTP
*/
#ifndef OPENSSL_NO_SCTP
- if (!SSL_IS_DTLS(s) || !BIO_dgram_is_sctp(SSL_get_wbio(s)))
+ if (!SSL_CONNECTION_IS_DTLS(s) || !BIO_dgram_is_sctp(SSL_get_wbio(ssl)))
#endif
if (!ssl_init_wbio_buffer(s)) {
SSLfatal(s, SSL_AD_NO_ALERT, ERR_R_INTERNAL_ERROR);
goto end;
}
- if ((SSL_in_before(s))
+ if ((SSL_in_before(ssl))
|| s->renegotiate) {
if (!tls_setup_handshake(s)) {
/* SSLfatal() already called */
st->in_handshake--;
#ifndef OPENSSL_NO_SCTP
- if (SSL_IS_DTLS(s) && BIO_dgram_is_sctp(SSL_get_wbio(s))) {
+ if (SSL_CONNECTION_IS_DTLS(s) && BIO_dgram_is_sctp(SSL_get_wbio(ssl))) {
/*
* Notify SCTP BIO socket to leave handshake mode and allow stream
* identifier other than 0.
*/
- BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_SET_IN_HANDSHAKE,
+ BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_SET_IN_HANDSHAKE,
st->in_handshake, NULL);
}
#endif
BUF_MEM_free(buf);
if (cb != NULL) {
if (server)
- cb(s, SSL_CB_ACCEPT_EXIT, ret);
+ cb(ssl, SSL_CB_ACCEPT_EXIT, ret);
else
- cb(s, SSL_CB_CONNECT_EXIT, ret);
+ cb(ssl, SSL_CB_CONNECT_EXIT, ret);
}
return ret;
}
/*
* Initialise the MSG_FLOW_READING sub-state machine
*/
-static void init_read_state_machine(SSL *s)
+static void init_read_state_machine(SSL_CONNECTION *s)
{
OSSL_STATEM *st = &s->statem;
st->read_state = READ_STATE_HEADER;
}
-static int grow_init_buf(SSL *s, size_t size) {
+static int grow_init_buf(SSL_CONNECTION *s, size_t size) {
size_t msg_offset = (char *)s->init_msg - s->init_buf->data;
* control returns to the calling application. When this function is recalled we
* will resume in the same state where we left off.
*/
-static SUB_STATE_RETURN read_state_machine(SSL *s)
+static SUB_STATE_RETURN read_state_machine(SSL_CONNECTION *s)
{
OSSL_STATEM *st = &s->statem;
int ret, mt;
size_t len = 0;
- int (*transition) (SSL *s, int mt);
+ int (*transition) (SSL_CONNECTION *s, int mt);
PACKET pkt;
- MSG_PROCESS_RETURN(*process_message) (SSL *s, PACKET *pkt);
- WORK_STATE(*post_process_message) (SSL *s, WORK_STATE wst);
- size_t (*max_message_size) (SSL *s);
+ MSG_PROCESS_RETURN(*process_message) (SSL_CONNECTION *s, PACKET *pkt);
+ WORK_STATE(*post_process_message) (SSL_CONNECTION *s, WORK_STATE wst);
+ size_t (*max_message_size) (SSL_CONNECTION *s);
void (*cb) (const SSL *ssl, int type, int val) = NULL;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
cb = get_callback(s);
switch (st->read_state) {
case READ_STATE_HEADER:
/* Get the state the peer wants to move to */
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
/*
* In DTLS we get the whole message in one go - header and body
*/
if (cb != NULL) {
/* Notify callback of an impending state change */
if (s->server)
- cb(s, SSL_CB_ACCEPT_LOOP, 1);
+ cb(ssl, SSL_CB_ACCEPT_LOOP, 1);
else
- cb(s, SSL_CB_CONNECT_LOOP, 1);
+ cb(ssl, SSL_CB_CONNECT_LOOP, 1);
}
/*
* Validate that we are allowed to move to the new state and move
}
/* dtls_get_message already did this */
- if (!SSL_IS_DTLS(s)
+ if (!SSL_CONNECTION_IS_DTLS(s)
&& s->s3.tmp.message_size > 0
&& !grow_init_buf(s, s->s3.tmp.message_size
+ SSL3_HM_HEADER_LENGTH)) {
/* Fall through */
case READ_STATE_BODY:
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
/*
* Actually we already have the body, but we give DTLS the
* opportunity to do any further processing.
return SUB_STATE_ERROR;
case MSG_PROCESS_FINISHED_READING:
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
dtls1_stop_timer(s);
}
return SUB_STATE_FINISHED;
break;
case WORK_FINISHED_STOP:
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
dtls1_stop_timer(s);
}
return SUB_STATE_FINISHED;
/*
* Send a previously constructed message to the peer.
*/
-static int statem_do_write(SSL *s)
+static int statem_do_write(SSL_CONNECTION *s)
{
OSSL_STATEM *st = &s->statem;
if (st->hand_state == TLS_ST_CW_CHANGE
|| st->hand_state == TLS_ST_SW_CHANGE) {
- if (SSL_IS_DTLS(s))
+ if (SSL_CONNECTION_IS_DTLS(s))
return dtls1_do_write(s, SSL3_RT_CHANGE_CIPHER_SPEC);
else
return ssl3_do_write(s, SSL3_RT_CHANGE_CIPHER_SPEC);
/*
* Initialise the MSG_FLOW_WRITING sub-state machine
*/
-static void init_write_state_machine(SSL *s)
+static void init_write_state_machine(SSL_CONNECTION *s)
{
OSSL_STATEM *st = &s->statem;
* message has been completed. As for WRITE_STATE_PRE_WORK this could also
* result in an NBIO event.
*/
-static SUB_STATE_RETURN write_state_machine(SSL *s)
+static SUB_STATE_RETURN write_state_machine(SSL_CONNECTION *s)
{
OSSL_STATEM *st = &s->statem;
int ret;
- WRITE_TRAN(*transition) (SSL *s);
- WORK_STATE(*pre_work) (SSL *s, WORK_STATE wst);
- WORK_STATE(*post_work) (SSL *s, WORK_STATE wst);
- int (*get_construct_message_f) (SSL *s,
- int (**confunc) (SSL *s, WPACKET *pkt),
+ WRITE_TRAN(*transition) (SSL_CONNECTION *s);
+ WORK_STATE(*pre_work) (SSL_CONNECTION *s, WORK_STATE wst);
+ WORK_STATE(*post_work) (SSL_CONNECTION *s, WORK_STATE wst);
+ int (*get_construct_message_f) (SSL_CONNECTION *s,
+ int (**confunc) (SSL_CONNECTION *s,
+ WPACKET *pkt),
int *mt);
void (*cb) (const SSL *ssl, int type, int val) = NULL;
- int (*confunc) (SSL *s, WPACKET *pkt);
+ int (*confunc) (SSL_CONNECTION *s, WPACKET *pkt);
int mt;
WPACKET pkt;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
cb = get_callback(s);
if (cb != NULL) {
/* Notify callback of an impending state change */
if (s->server)
- cb(s, SSL_CB_ACCEPT_LOOP, 1);
+ cb(ssl, SSL_CB_ACCEPT_LOOP, 1);
else
- cb(s, SSL_CB_CONNECT_LOOP, 1);
+ cb(ssl, SSL_CB_CONNECT_LOOP, 1);
}
switch (transition(s)) {
case WRITE_TRAN_CONTINUE:
/* Fall through */
case WRITE_STATE_SEND:
- if (SSL_IS_DTLS(s) && st->use_timer) {
+ if (SSL_CONNECTION_IS_DTLS(s) && st->use_timer) {
dtls1_start_timer(s);
}
ret = statem_do_write(s);
/*
* Flush the write BIO
*/
-int statem_flush(SSL *s)
+int statem_flush(SSL_CONNECTION *s)
{
s->rwstate = SSL_WRITING;
if (BIO_flush(s->wbio) <= 0) {
* 1: Yes (application data allowed)
* 0: No (application data not allowed)
*/
-int ossl_statem_app_data_allowed(SSL *s)
+int ossl_statem_app_data_allowed(SSL_CONNECTION *s)
{
OSSL_STATEM *st = &s->statem;
* This function returns 1 if TLS exporter is ready to export keying
* material, or 0 if otherwise.
*/
-int ossl_statem_export_allowed(SSL *s)
+int ossl_statem_export_allowed(SSL_CONNECTION *s)
{
return s->s3.previous_server_finished_len != 0
&& s->statem.hand_state != TLS_ST_SW_FINISHED;
* Return 1 if early TLS exporter is ready to export keying material,
* or 0 if otherwise.
*/
-int ossl_statem_export_early_allowed(SSL *s)
+int ossl_statem_export_early_allowed(SSL_CONNECTION *s)
{
/*
* The early exporter secret is only present on the server if we
__owur int ossl_statem_accept(SSL *s);
__owur int ossl_statem_connect(SSL *s);
-void ossl_statem_clear(SSL *s);
-void ossl_statem_set_renegotiate(SSL *s);
-void ossl_statem_send_fatal(SSL *s, int al);
-void ossl_statem_fatal(SSL *s, int al, int reason, const char *fmt, ...);
+void ossl_statem_clear(SSL_CONNECTION *s);
+void ossl_statem_set_renegotiate(SSL_CONNECTION *s);
+void ossl_statem_send_fatal(SSL_CONNECTION *s, int al);
+void ossl_statem_fatal(SSL_CONNECTION *s, int al, int reason,
+ const char *fmt, ...);
# define SSL_AD_NO_ALERT -1
# define SSLfatal_alert(s, al) ossl_statem_send_fatal((s), (al))
# define SSLfatal(s, al, r) SSLfatal_data((s), (al), (r), NULL)
ERR_set_debug(OPENSSL_FILE, OPENSSL_LINE, OPENSSL_FUNC), \
ossl_statem_fatal)
-int ossl_statem_in_error(const SSL *s);
-void ossl_statem_set_in_init(SSL *s, int init);
-int ossl_statem_get_in_handshake(SSL *s);
-void ossl_statem_set_in_handshake(SSL *s, int inhand);
-__owur int ossl_statem_skip_early_data(SSL *s);
-void ossl_statem_check_finish_init(SSL *s, int send);
-void ossl_statem_set_hello_verify_done(SSL *s);
-__owur int ossl_statem_app_data_allowed(SSL *s);
-__owur int ossl_statem_export_allowed(SSL *s);
-__owur int ossl_statem_export_early_allowed(SSL *s);
+int ossl_statem_in_error(const SSL_CONNECTION *s);
+void ossl_statem_set_in_init(SSL_CONNECTION *s, int init);
+int ossl_statem_get_in_handshake(SSL_CONNECTION *s);
+void ossl_statem_set_in_handshake(SSL_CONNECTION *s, int inhand);
+__owur int ossl_statem_skip_early_data(SSL_CONNECTION *s);
+void ossl_statem_check_finish_init(SSL_CONNECTION *s, int send);
+void ossl_statem_set_hello_verify_done(SSL_CONNECTION *s);
+__owur int ossl_statem_app_data_allowed(SSL_CONNECTION *s);
+__owur int ossl_statem_export_allowed(SSL_CONNECTION *s);
+__owur int ossl_statem_export_early_allowed(SSL_CONNECTION *s);
/* Flush the write BIO */
-int statem_flush(SSL *s);
+int statem_flush(SSL_CONNECTION *s);
#include <openssl/param_build.h>
#include "internal/cryptlib.h"
-static MSG_PROCESS_RETURN tls_process_as_hello_retry_request(SSL *s, PACKET *pkt);
-static MSG_PROCESS_RETURN tls_process_encrypted_extensions(SSL *s, PACKET *pkt);
-
-static ossl_inline int cert_req_allowed(SSL *s);
-static int key_exchange_expected(SSL *s);
-static int ssl_cipher_list_to_bytes(SSL *s, STACK_OF(SSL_CIPHER) *sk,
+static MSG_PROCESS_RETURN tls_process_as_hello_retry_request(SSL_CONNECTION *s,
+ PACKET *pkt);
+static MSG_PROCESS_RETURN tls_process_encrypted_extensions(SSL_CONNECTION *s,
+ PACKET *pkt);
+
+static ossl_inline int cert_req_allowed(SSL_CONNECTION *s);
+static int key_exchange_expected(SSL_CONNECTION *s);
+static int ssl_cipher_list_to_bytes(SSL_CONNECTION *s, STACK_OF(SSL_CIPHER) *sk,
WPACKET *pkt);
/*
* 1: Yes
* 0: No
*/
-static ossl_inline int cert_req_allowed(SSL *s)
+static ossl_inline int cert_req_allowed(SSL_CONNECTION *s)
{
/* TLS does not like anon-DH with client cert */
if ((s->version > SSL3_VERSION
* 1: Yes
* 0: No
*/
-static int key_exchange_expected(SSL *s)
+static int key_exchange_expected(SSL_CONNECTION *s)
{
long alg_k = s->s3.tmp.new_cipher->algorithm_mkey;
* Return values are 1 for success (transition allowed) and 0 on error
* (transition not allowed)
*/
-static int ossl_statem_client13_read_transition(SSL *s, int mt)
+static int ossl_statem_client13_read_transition(SSL_CONNECTION *s, int mt)
{
OSSL_STATEM *st = &s->statem;
/* Restore digest for PHA before adding message.*/
# error Internal DTLS version error
#endif
- if (!SSL_IS_DTLS(s) && s->post_handshake_auth == SSL_PHA_EXT_SENT) {
+ if (!SSL_CONNECTION_IS_DTLS(s)
+ && s->post_handshake_auth == SSL_PHA_EXT_SENT) {
s->post_handshake_auth = SSL_PHA_REQUESTED;
/*
* In TLS, this is called before the message is added to the
* Return values are 1 for success (transition allowed) and 0 on error
* (transition not allowed)
*/
-int ossl_statem_client_read_transition(SSL *s, int mt)
+int ossl_statem_client_read_transition(SSL_CONNECTION *s, int mt)
{
OSSL_STATEM *st = &s->statem;
int ske_expected;
* Note that after writing the first ClientHello we don't know what version
* we are going to negotiate yet, so we don't take this branch until later.
*/
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
if (!ossl_statem_client13_read_transition(s, mt))
goto err;
return 1;
return 1;
}
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
if (mt == DTLS1_MT_HELLO_VERIFY_REQUEST) {
st->hand_state = DTLS_ST_CR_HELLO_VERIFY_REQUEST;
return 1;
return 1;
}
} else {
- if (SSL_IS_DTLS(s) && mt == DTLS1_MT_HELLO_VERIFY_REQUEST) {
+ if (SSL_CONNECTION_IS_DTLS(s)
+ && mt == DTLS1_MT_HELLO_VERIFY_REQUEST) {
st->hand_state = DTLS_ST_CR_HELLO_VERIFY_REQUEST;
return 1;
} else if (s->version >= TLS1_VERSION
err:
/* No valid transition found */
- if (SSL_IS_DTLS(s) && mt == SSL3_MT_CHANGE_CIPHER_SPEC) {
+ if (SSL_CONNECTION_IS_DTLS(s) && mt == SSL3_MT_CHANGE_CIPHER_SPEC) {
BIO *rbio;
/*
*/
s->init_num = 0;
s->rwstate = SSL_READING;
- rbio = SSL_get_rbio(s);
+ rbio = SSL_get_rbio(SSL_CONNECTION_GET_SSL(s));
BIO_clear_retry_flags(rbio);
BIO_set_retry_read(rbio);
return 0;
* move to next when the TLSv1.3 client is writing messages to be sent to the
* server.
*/
-static WRITE_TRAN ossl_statem_client13_write_transition(SSL *s)
+static WRITE_TRAN ossl_statem_client13_write_transition(SSL_CONNECTION *s)
{
OSSL_STATEM *st = &s->statem;
* ossl_statem_client_write_transition() works out what handshake state to
* move to next when the client is writing messages to be sent to the server.
*/
-WRITE_TRAN ossl_statem_client_write_transition(SSL *s)
+WRITE_TRAN ossl_statem_client_write_transition(SSL_CONNECTION *s)
{
OSSL_STATEM *st = &s->statem;
* version we are going to negotiate yet, so we don't take this branch until
* later
*/
- if (SSL_IS_TLS13(s))
+ if (SSL_CONNECTION_IS_TLS13(s))
return ossl_statem_client13_write_transition(s);
switch (st->hand_state) {
#if defined(OPENSSL_NO_NEXTPROTONEG)
st->hand_state = TLS_ST_CW_FINISHED;
#else
- if (!SSL_IS_DTLS(s) && s->s3.npn_seen)
+ if (!SSL_CONNECTION_IS_DTLS(s) && s->s3.npn_seen)
st->hand_state = TLS_ST_CW_NEXT_PROTO;
else
st->hand_state = TLS_ST_CW_FINISHED;
* If we can renegotiate now then do so, otherwise wait for a more
* convenient time.
*/
- if (ssl3_renegotiate_check(s, 1)) {
+ if (ssl3_renegotiate_check(SSL_CONNECTION_GET_SSL(s), 1)) {
if (!tls_setup_handshake(s)) {
/* SSLfatal() already called */
return WRITE_TRAN_ERROR;
* Perform any pre work that needs to be done prior to sending a message from
* the client to the server.
*/
-WORK_STATE ossl_statem_client_pre_work(SSL *s, WORK_STATE wst)
+WORK_STATE ossl_statem_client_pre_work(SSL_CONNECTION *s, WORK_STATE wst)
{
OSSL_STATEM *st = &s->statem;
case TLS_ST_CW_CLNT_HELLO:
s->shutdown = 0;
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
/* every DTLS ClientHello resets Finished MAC */
if (!ssl3_init_finished_mac(s)) {
/* SSLfatal() already called */
break;
case TLS_ST_CW_CHANGE:
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
if (s->hit) {
/*
* We're into the last flight so we don't retransmit these
st->use_timer = 0;
}
#ifndef OPENSSL_NO_SCTP
- if (BIO_dgram_is_sctp(SSL_get_wbio(s))) {
+ if (BIO_dgram_is_sctp(SSL_get_wbio(SSL_CONNECTION_GET_SSL(s)))) {
/* Calls SSLfatal() as required */
return dtls_wait_for_dry(s);
}
* Perform any work that needs to be done after sending a message from the
* client to the server.
*/
-WORK_STATE ossl_statem_client_post_work(SSL *s, WORK_STATE wst)
+WORK_STATE ossl_statem_client_post_work(SSL_CONNECTION *s, WORK_STATE wst)
{
OSSL_STATEM *st = &s->statem;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
s->init_num = 0;
return WORK_MORE_A;
}
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
/* Treat the next message as the first packet */
s->first_packet = 1;
}
break;
case TLS_ST_CW_CHANGE:
- if (SSL_IS_TLS13(s) || s->hello_retry_request == SSL_HRR_PENDING)
+ if (SSL_CONNECTION_IS_TLS13(s)
+ || s->hello_retry_request == SSL_HRR_PENDING)
break;
if (s->early_data_state == SSL_EARLY_DATA_CONNECTING
&& s->max_early_data > 0) {
else
s->session->compress_meth = s->s3.tmp.new_compression->id;
#endif
- if (!s->method->ssl3_enc->setup_key_block(s)) {
+ if (!ssl->method->ssl3_enc->setup_key_block(s)) {
/* SSLfatal() already called */
return WORK_ERROR;
}
- if (!s->method->ssl3_enc->change_cipher_state(s,
+ if (!ssl->method->ssl3_enc->change_cipher_state(s,
SSL3_CHANGE_CIPHER_CLIENT_WRITE)) {
/* SSLfatal() already called */
return WORK_ERROR;
}
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
#ifndef OPENSSL_NO_SCTP
if (s->hit) {
/*
* Change to new shared key of SCTP-Auth, will be ignored if
* no SCTP used.
*/
- BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY,
+ BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY,
0, NULL);
}
#endif
case TLS_ST_CW_FINISHED:
#ifndef OPENSSL_NO_SCTP
- if (wst == WORK_MORE_A && SSL_IS_DTLS(s) && s->hit == 0) {
+ if (wst == WORK_MORE_A && SSL_CONNECTION_IS_DTLS(s) && s->hit == 0) {
/*
* Change to new shared key of SCTP-Auth, will be ignored if
* no SCTP used.
*/
- BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY,
+ BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY,
0, NULL);
}
#endif
if (statem_flush(s) != 1)
return WORK_MORE_B;
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
if (!tls13_save_handshake_digest_for_pha(s)) {
/* SSLfatal() already called */
return WORK_ERROR;
}
if (s->post_handshake_auth != SSL_PHA_REQUESTED) {
- if (!s->method->ssl3_enc->change_cipher_state(s,
+ if (!ssl->method->ssl3_enc->change_cipher_state(s,
SSL3_CC_APPLICATION | SSL3_CHANGE_CIPHER_CLIENT_WRITE)) {
/* SSLfatal() already called */
return WORK_ERROR;
* 1: Success
* 0: Error
*/
-int ossl_statem_client_construct_message(SSL *s,
+int ossl_statem_client_construct_message(SSL_CONNECTION *s,
confunc_f *confunc, int *mt)
{
OSSL_STATEM *st = &s->statem;
return 0;
case TLS_ST_CW_CHANGE:
- if (SSL_IS_DTLS(s))
+ if (SSL_CONNECTION_IS_DTLS(s))
*confunc = dtls_construct_change_cipher_spec;
else
*confunc = tls_construct_change_cipher_spec;
* Returns the maximum allowed length for the current message that we are
* reading. Excludes the message header.
*/
-size_t ossl_statem_client_max_message_size(SSL *s)
+size_t ossl_statem_client_max_message_size(SSL_CONNECTION *s)
{
OSSL_STATEM *st = &s->statem;
return CCS_MAX_LENGTH;
case TLS_ST_CR_SESSION_TICKET:
- return (SSL_IS_TLS13(s)) ? SESSION_TICKET_MAX_LENGTH_TLS13
- : SESSION_TICKET_MAX_LENGTH_TLS12;
+ return (SSL_CONNECTION_IS_TLS13(s)) ? SESSION_TICKET_MAX_LENGTH_TLS13
+ : SESSION_TICKET_MAX_LENGTH_TLS12;
case TLS_ST_CR_FINISHED:
return FINISHED_MAX_LENGTH;
/*
* Process a message that the client has received from the server.
*/
-MSG_PROCESS_RETURN ossl_statem_client_process_message(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN ossl_statem_client_process_message(SSL_CONNECTION *s,
+ PACKET *pkt)
{
OSSL_STATEM *st = &s->statem;
* Perform any further processing required following the receipt of a message
* from the server
*/
-WORK_STATE ossl_statem_client_post_process_message(SSL *s, WORK_STATE wst)
+WORK_STATE ossl_statem_client_post_process_message(SSL_CONNECTION *s,
+ WORK_STATE wst)
{
OSSL_STATEM *st = &s->statem;
}
}
-int tls_construct_client_hello(SSL *s, WPACKET *pkt)
+int tls_construct_client_hello(SSL_CONNECTION *s, WPACKET *pkt)
{
unsigned char *p;
size_t sess_id_len;
#endif
SSL_SESSION *sess = s->session;
unsigned char *session_id;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
/* Work out what SSL/TLS/DTLS version to use */
protverr = ssl_set_client_hello_version(s);
* for DTLS if client_random is initialized, reuse it, we are
* required to use same upon reply to HelloVerify
*/
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
size_t idx;
i = 1;
for (idx = 0; idx < sizeof(s->s3.client_random); idx++) {
s->tmp_session_id_len = sess_id_len;
session_id = s->tmp_session_id;
if (s->hello_retry_request == SSL_HRR_NONE
- && RAND_bytes_ex(s->ctx->libctx, s->tmp_session_id,
+ && RAND_bytes_ex(sctx->libctx, s->tmp_session_id,
sess_id_len, 0) <= 0) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return 0;
}
/* cookie stuff for DTLS */
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
if (s->d1->cookie_len > sizeof(s->d1->cookie)
|| !WPACKET_sub_memcpy_u8(pkt, s->d1->cookie,
s->d1->cookie_len)) {
return 0;
}
- if (!ssl_cipher_list_to_bytes(s, SSL_get_ciphers(s), pkt)) {
+ if (!ssl_cipher_list_to_bytes(s, SSL_get_ciphers(SSL_CONNECTION_GET_SSL(s)),
+ pkt)) {
/* SSLfatal() already called */
return 0;
}
}
#ifndef OPENSSL_NO_COMP
if (ssl_allow_compression(s)
- && s->ctx->comp_methods
- && (SSL_IS_DTLS(s) || s->s3.tmp.max_ver < TLS1_3_VERSION)) {
- int compnum = sk_SSL_COMP_num(s->ctx->comp_methods);
+ && sctx->comp_methods
+ && (SSL_CONNECTION_IS_DTLS(s)
+ || s->s3.tmp.max_ver < TLS1_3_VERSION)) {
+ int compnum = sk_SSL_COMP_num(sctx->comp_methods);
for (i = 0; i < compnum; i++) {
- comp = sk_SSL_COMP_value(s->ctx->comp_methods, i);
+ comp = sk_SSL_COMP_value(sctx->comp_methods, i);
if (!WPACKET_put_bytes_u8(pkt, comp->id)) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return 0;
return 1;
}
-MSG_PROCESS_RETURN dtls_process_hello_verify(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN dtls_process_hello_verify(SSL_CONNECTION *s, PACKET *pkt)
{
size_t cookie_len;
PACKET cookiepkt;
return MSG_PROCESS_FINISHED_READING;
}
-static int set_client_ciphersuite(SSL *s, const unsigned char *cipherchars)
+static int set_client_ciphersuite(SSL_CONNECTION *s,
+ const unsigned char *cipherchars)
{
STACK_OF(SSL_CIPHER) *sk;
const SSL_CIPHER *c;
int i;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
c = ssl_get_cipher_by_char(s, cipherchars, 0);
if (c == NULL) {
return 0;
}
- if (SSL_IS_TLS13(s) && s->s3.tmp.new_cipher != NULL
+ if (SSL_CONNECTION_IS_TLS13(s) && s->s3.tmp.new_cipher != NULL
&& s->s3.tmp.new_cipher->id != c->id) {
/* ServerHello selected a different ciphersuite to that in the HRR */
SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_CIPHER_RETURNED);
if (s->session->cipher != NULL)
s->session->cipher_id = s->session->cipher->id;
if (s->hit && (s->session->cipher_id != c->id)) {
- if (SSL_IS_TLS13(s)) {
- const EVP_MD *md = ssl_md(s->ctx, c->algorithm2);
+ if (SSL_CONNECTION_IS_TLS13(s)) {
+ const EVP_MD *md = ssl_md(sctx, c->algorithm2);
/*
* In TLSv1.3 it is valid for the server to select a different
* ciphersuite as long as the hash is the same.
*/
if (md == NULL
- || md != ssl_md(s->ctx, s->session->cipher->algorithm2)) {
+ || md != ssl_md(sctx, s->session->cipher->algorithm2)) {
SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
SSL_R_CIPHERSUITE_DIGEST_HAS_CHANGED);
return 0;
return 1;
}
-MSG_PROCESS_RETURN tls_process_server_hello(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_server_hello(SSL_CONNECTION *s, PACKET *pkt)
{
PACKET session_id, extpkt;
size_t session_id_len;
unsigned int sversion;
unsigned int context;
RAW_EXTENSION *extensions = NULL;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
#ifndef OPENSSL_NO_COMP
SSL_COMP *comp;
#endif
}
}
- if (SSL_IS_TLS13(s) || hrr) {
+ if (SSL_CONNECTION_IS_TLS13(s) || hrr) {
if (compression != 0) {
SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
SSL_R_INVALID_COMPRESSION_ALGORITHM);
* Now we have chosen the version we need to check again that the extensions
* are appropriate for this version.
*/
- context = SSL_IS_TLS13(s) ? SSL_EXT_TLS1_3_SERVER_HELLO
- : SSL_EXT_TLS1_2_SERVER_HELLO;
+ context = SSL_CONNECTION_IS_TLS13(s) ? SSL_EXT_TLS1_3_SERVER_HELLO
+ : SSL_EXT_TLS1_2_SERVER_HELLO;
if (!tls_validate_all_contexts(s, context, extensions)) {
SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_EXTENSION);
goto err;
s->hit = 0;
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
/*
* In TLSv1.3 a ServerHello message signals a key change so the end of
* the message must be on a record boundary.
* backwards compat reasons
*/
int master_key_length;
+
master_key_length = sizeof(s->session->master_key);
- if (s->ext.session_secret_cb(s, s->session->master_key,
+ if (s->ext.session_secret_cb(ssl, s->session->master_key,
&master_key_length,
NULL, &pref_cipher,
s->ext.session_secret_cb_arg)
* echo of what we originally sent in the ClientHello and should not be
* used for resumption.
*/
- if (!SSL_IS_TLS13(s)) {
+ if (!SSL_CONNECTION_IS_TLS13(s)) {
s->session->session_id_length = session_id_len;
/* session_id_len could be 0 */
if (session_id_len > 0)
SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_COMPRESSION_DISABLED);
goto err;
} else {
- comp = ssl3_comp_find(s->ctx->comp_methods, compression);
+ comp = ssl3_comp_find(SSL_CONNECTION_GET_CTX(s)->comp_methods,
+ compression);
}
if (compression != 0 && comp == NULL) {
}
#ifndef OPENSSL_NO_SCTP
- if (SSL_IS_DTLS(s) && s->hit) {
+ if (SSL_CONNECTION_IS_DTLS(s) && s->hit) {
unsigned char sctpauthkey[64];
char labelbuffer[sizeof(DTLS1_SCTP_AUTH_LABEL)];
size_t labellen;
if (s->mode & SSL_MODE_DTLS_SCTP_LABEL_LENGTH_BUG)
labellen += 1;
- if (SSL_export_keying_material(s, sctpauthkey,
+ if (SSL_export_keying_material(ssl, sctpauthkey,
sizeof(sctpauthkey),
labelbuffer,
labellen, NULL, 0, 0) <= 0) {
goto err;
}
- BIO_ctrl(SSL_get_wbio(s),
+ BIO_ctrl(SSL_get_wbio(ssl),
BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY,
sizeof(sctpauthkey), sctpauthkey);
}
* In TLSv1.3 we have some post-processing to change cipher state, otherwise
* we're done with this message
*/
- if (SSL_IS_TLS13(s)
- && (!s->method->ssl3_enc->setup_key_block(s)
- || !s->method->ssl3_enc->change_cipher_state(s,
+ if (SSL_CONNECTION_IS_TLS13(s)
+ && (!ssl->method->ssl3_enc->setup_key_block(s)
+ || !ssl->method->ssl3_enc->change_cipher_state(s,
SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_CLIENT_READ))) {
/* SSLfatal() already called */
goto err;
return MSG_PROCESS_ERROR;
}
-static MSG_PROCESS_RETURN tls_process_as_hello_retry_request(SSL *s,
+static MSG_PROCESS_RETURN tls_process_as_hello_retry_request(SSL_CONNECTION *s,
PACKET *extpkt)
{
RAW_EXTENSION *extensions = NULL;
}
/* prepare server cert verification by setting s->session->peer_chain from pkt */
-MSG_PROCESS_RETURN tls_process_server_certificate(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_server_certificate(SSL_CONNECTION *s,
+ PACKET *pkt)
{
unsigned long cert_list_len, cert_len;
X509 *x = NULL;
const unsigned char *certstart, *certbytes;
size_t chainidx;
unsigned int context = 0;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
if ((s->session->peer_chain = sk_X509_new_null()) == NULL) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
goto err;
}
- if ((SSL_IS_TLS13(s) && !PACKET_get_1(pkt, &context))
+ if ((SSL_CONNECTION_IS_TLS13(s) && !PACKET_get_1(pkt, &context))
|| context != 0
|| !PACKET_get_net_3(pkt, &cert_list_len)
|| PACKET_remaining(pkt) != cert_list_len
}
certstart = certbytes;
- x = X509_new_ex(s->ctx->libctx, s->ctx->propq);
+ x = X509_new_ex(sctx->libctx, sctx->propq);
if (x == NULL) {
SSLfatal(s, SSL_AD_DECODE_ERROR, ERR_R_MALLOC_FAILURE);
ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
goto err;
}
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
RAW_EXTENSION *rawexts = NULL;
PACKET extensions;
* On success set s->session->peer and s->session->verify_result.
* Else the peer certificate verification callback may request retry.
*/
-WORK_STATE tls_post_process_server_certificate(SSL *s, WORK_STATE wst)
+WORK_STATE tls_post_process_server_certificate(SSL_CONNECTION *s,
+ WORK_STATE wst)
{
X509 *x;
EVP_PKEY *pkey = NULL;
* skip check since TLS 1.3 ciphersuites can be used with any certificate
* type.
*/
- if (!SSL_IS_TLS13(s)) {
+ if (!SSL_CONNECTION_IS_TLS13(s)) {
if ((clu->amask & s->s3.tmp.new_cipher->algorithm_auth) == 0) {
SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_CERTIFICATE_TYPE);
return WORK_ERROR;
s->session->verify_result = s->verify_result;
/* Save the current hash state for when we receive the CertificateVerify */
- if (SSL_IS_TLS13(s)
+ if (SSL_CONNECTION_IS_TLS13(s)
&& !ssl_handshake_hash(s, s->cert_verify_hash,
sizeof(s->cert_verify_hash),
&s->cert_verify_hash_len)) {
return WORK_FINISHED_CONTINUE;
}
-static int tls_process_ske_psk_preamble(SSL *s, PACKET *pkt)
+static int tls_process_ske_psk_preamble(SSL_CONNECTION *s, PACKET *pkt)
{
#ifndef OPENSSL_NO_PSK
PACKET psk_identity_hint;
#endif
}
-static int tls_process_ske_srp(SSL *s, PACKET *pkt, EVP_PKEY **pkey)
+static int tls_process_ske_srp(SSL_CONNECTION *s, PACKET *pkt, EVP_PKEY **pkey)
{
#ifndef OPENSSL_NO_SRP
PACKET prime, generator, salt, server_pub;
#endif
}
-static int tls_process_ske_dhe(SSL *s, PACKET *pkt, EVP_PKEY **pkey)
+static int tls_process_ske_dhe(SSL_CONNECTION *s, PACKET *pkt, EVP_PKEY **pkey)
{
PACKET prime, generator, pub_key;
EVP_PKEY *peer_tmp = NULL;
EVP_PKEY_CTX *pctx = NULL;
OSSL_PARAM *params = NULL;
OSSL_PARAM_BLD *tmpl = NULL;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
int ret = 0;
if (!PACKET_get_length_prefixed_2(pkt, &prime)
goto err;
}
- pctx = EVP_PKEY_CTX_new_from_name(s->ctx->libctx, "DH", s->ctx->propq);
+ pctx = EVP_PKEY_CTX_new_from_name(sctx->libctx, "DH", sctx->propq);
if (pctx == NULL) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
goto err;
}
EVP_PKEY_CTX_free(pctx);
- pctx = EVP_PKEY_CTX_new_from_pkey(s->ctx->libctx, peer_tmp, s->ctx->propq);
+ pctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, peer_tmp, sctx->propq);
if (pctx == NULL
/*
* EVP_PKEY_param_check() will verify that the DH params are using
return ret;
}
-static int tls_process_ske_ecdhe(SSL *s, PACKET *pkt, EVP_PKEY **pkey)
+static int tls_process_ske_ecdhe(SSL_CONNECTION *s, PACKET *pkt, EVP_PKEY **pkey)
{
PACKET encoded_pt;
unsigned int curve_type, curve_id;
return 1;
}
-MSG_PROCESS_RETURN tls_process_key_exchange(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_key_exchange(SSL_CONNECTION *s, PACKET *pkt)
{
long alg_k;
EVP_PKEY *pkey = NULL;
EVP_MD_CTX *md_ctx = NULL;
EVP_PKEY_CTX *pctx = NULL;
PACKET save_param_start, signature;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
alg_k = s->s3.tmp.new_cipher->algorithm_mkey;
goto err;
}
- if (!tls1_lookup_md(s->ctx, s->s3.tmp.peer_sigalg, &md)) {
+ if (!tls1_lookup_md(sctx, s->s3.tmp.peer_sigalg, &md)) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR,
SSL_R_NO_SUITABLE_DIGEST_ALGORITHM);
goto err;
if (EVP_DigestVerifyInit_ex(md_ctx, &pctx,
md == NULL ? NULL : EVP_MD_get0_name(md),
- s->ctx->libctx, s->ctx->propq, pkey,
+ sctx->libctx, sctx->propq, pkey,
NULL) <= 0) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
goto err;
return MSG_PROCESS_ERROR;
}
-MSG_PROCESS_RETURN tls_process_certificate_request(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_certificate_request(SSL_CONNECTION *s,
+ PACKET *pkt)
{
size_t i;
for (i = 0; i < SSL_PKEY_NUM; i++)
s->s3.tmp.valid_flags[i] = 0;
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
PACKET reqctx, extensions;
RAW_EXTENSION *rawexts = NULL;
* SSL_get1_peer_certificate() returns something sensible in
* client_cert_cb.
*/
- if (SSL_IS_TLS13(s) && s->post_handshake_auth != SSL_PHA_REQUESTED)
+ if (SSL_CONNECTION_IS_TLS13(s)
+ && s->post_handshake_auth != SSL_PHA_REQUESTED)
return MSG_PROCESS_CONTINUE_READING;
return MSG_PROCESS_CONTINUE_PROCESSING;
}
-MSG_PROCESS_RETURN tls_process_new_session_ticket(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_new_session_ticket(SSL_CONNECTION *s,
+ PACKET *pkt)
{
unsigned int ticklen;
unsigned long ticket_lifetime_hint, age_add = 0;
RAW_EXTENSION *exts = NULL;
PACKET nonce;
EVP_MD *sha256 = NULL;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
PACKET_null_init(&nonce);
if (!PACKET_get_net_4(pkt, &ticket_lifetime_hint)
- || (SSL_IS_TLS13(s)
+ || (SSL_CONNECTION_IS_TLS13(s)
&& (!PACKET_get_net_4(pkt, &age_add)
|| !PACKET_get_length_prefixed_1(pkt, &nonce)))
|| !PACKET_get_net_2(pkt, &ticklen)
- || (SSL_IS_TLS13(s) ? (ticklen == 0 || PACKET_remaining(pkt) < ticklen)
- : PACKET_remaining(pkt) != ticklen)) {
+ || (SSL_CONNECTION_IS_TLS13(s) ? (ticklen == 0
+ || PACKET_remaining(pkt) < ticklen)
+ : PACKET_remaining(pkt) != ticklen)) {
SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
goto err;
}
* post-handshake and the session may have already gone into the session
* cache.
*/
- if (SSL_IS_TLS13(s) || s->session->session_id_length > 0) {
+ if (SSL_CONNECTION_IS_TLS13(s) || s->session->session_id_length > 0) {
SSL_SESSION *new_sess;
/*
}
if ((s->session_ctx->session_cache_mode & SSL_SESS_CACHE_CLIENT) != 0
- && !SSL_IS_TLS13(s)) {
+ && !SSL_CONNECTION_IS_TLS13(s)) {
/*
* In TLSv1.2 and below the arrival of a new tickets signals that
* any old ticket we were using is now out of date, so we remove the
s->session->ext.tick_age_add = age_add;
s->session->ext.ticklen = ticklen;
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
PACKET extpkt;
if (!PACKET_as_length_prefixed_2(pkt, &extpkt)
* elsewhere in OpenSSL. The session ID is set to the SHA256 hash of the
* ticket.
*/
- sha256 = EVP_MD_fetch(s->ctx->libctx, "SHA2-256", s->ctx->propq);
+ sha256 = EVP_MD_fetch(sctx->libctx, "SHA2-256", sctx->propq);
if (sha256 == NULL) {
/* Error is already recorded */
SSLfatal_alert(s, SSL_AD_INTERNAL_ERROR);
s->session->not_resumable = 0;
/* This is a standalone message in TLSv1.3, so there is no more to read */
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
const EVP_MD *md = ssl_handshake_md(s);
int hashleni = EVP_MD_get_size(md);
size_t hashlen;
* In TLSv1.3 this is called from the extensions code, otherwise it is used to
* parse a separate message. Returns 1 on success or 0 on failure
*/
-int tls_process_cert_status_body(SSL *s, PACKET *pkt)
+int tls_process_cert_status_body(SSL_CONNECTION *s, PACKET *pkt)
{
size_t resplen;
unsigned int type;
}
-MSG_PROCESS_RETURN tls_process_cert_status(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_cert_status(SSL_CONNECTION *s, PACKET *pkt)
{
if (!tls_process_cert_status_body(s, pkt)) {
/* SSLfatal() already called */
* In <=TLS1.2 this is after the ServerDone message. Returns 1 on success or 0
* on failure.
*/
-int tls_process_initial_server_flight(SSL *s)
+int tls_process_initial_server_flight(SSL_CONNECTION *s)
{
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
+
/*
* at this point we check that we have the required stuff from
* the server
* message, or NULL and -1 otherwise
*/
if (s->ext.status_type != TLSEXT_STATUSTYPE_nothing
- && s->ctx->ext.status_cb != NULL) {
- int ret = s->ctx->ext.status_cb(s, s->ctx->ext.status_arg);
+ && sctx->ext.status_cb != NULL) {
+ int ret = sctx->ext.status_cb(SSL_CONNECTION_GET_SSL(s),
+ sctx->ext.status_arg);
if (ret == 0) {
SSLfatal(s, SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE,
return 1;
}
-MSG_PROCESS_RETURN tls_process_server_done(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_server_done(SSL_CONNECTION *s, PACKET *pkt)
{
if (PACKET_remaining(pkt) > 0) {
/* should contain no data */
return MSG_PROCESS_FINISHED_READING;
}
-static int tls_construct_cke_psk_preamble(SSL *s, WPACKET *pkt)
+static int tls_construct_cke_psk_preamble(SSL_CONNECTION *s, WPACKET *pkt)
{
#ifndef OPENSSL_NO_PSK
int ret = 0;
memset(identity, 0, sizeof(identity));
- psklen = s->psk_client_callback(s, s->session->psk_identity_hint,
+ psklen = s->psk_client_callback(SSL_CONNECTION_GET_SSL(s),
+ s->session->psk_identity_hint,
identity, sizeof(identity) - 1,
psk, sizeof(psk));
#endif
}
-static int tls_construct_cke_rsa(SSL *s, WPACKET *pkt)
+static int tls_construct_cke_rsa(SSL_CONNECTION *s, WPACKET *pkt)
{
unsigned char *encdata = NULL;
EVP_PKEY *pkey = NULL;
size_t enclen;
unsigned char *pms = NULL;
size_t pmslen = 0;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
if (s->session->peer == NULL) {
/*
pms[0] = s->client_version >> 8;
pms[1] = s->client_version & 0xff;
- if (RAND_bytes_ex(s->ctx->libctx, pms + 2, pmslen - 2, 0) <= 0) {
+ if (RAND_bytes_ex(sctx->libctx, pms + 2, pmslen - 2, 0) <= 0) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
goto err;
}
goto err;
}
- pctx = EVP_PKEY_CTX_new_from_pkey(s->ctx->libctx, pkey, s->ctx->propq);
+ pctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, pkey, sctx->propq);
if (pctx == NULL || EVP_PKEY_encrypt_init(pctx) <= 0
|| EVP_PKEY_encrypt(pctx, NULL, &enclen, pms, pmslen) <= 0) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
return 0;
}
-static int tls_construct_cke_dhe(SSL *s, WPACKET *pkt)
+static int tls_construct_cke_dhe(SSL_CONNECTION *s, WPACKET *pkt)
{
EVP_PKEY *ckey = NULL, *skey = NULL;
unsigned char *keybytes = NULL;
return ret;
}
-static int tls_construct_cke_ecdhe(SSL *s, WPACKET *pkt)
+static int tls_construct_cke_ecdhe(SSL_CONNECTION *s, WPACKET *pkt)
{
unsigned char *encodedPoint = NULL;
size_t encoded_pt_len = 0;
return ret;
}
-static int tls_construct_cke_gost(SSL *s, WPACKET *pkt)
+static int tls_construct_cke_gost(SSL_CONNECTION *s, WPACKET *pkt)
{
#ifndef OPENSSL_NO_GOST
/* GOST key exchange message creation */
int dgst_nid = NID_id_GostR3411_94;
unsigned char *pms = NULL;
size_t pmslen = 0;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
if ((s->s3.tmp.new_cipher->algorithm_auth & SSL_aGOST12) != 0)
dgst_nid = NID_id_GostR3411_2012_256;
return 0;
}
- pkey_ctx = EVP_PKEY_CTX_new_from_pkey(s->ctx->libctx,
+ pkey_ctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx,
X509_get0_pubkey(peer_cert),
- s->ctx->propq);
+ sctx->propq);
if (pkey_ctx == NULL) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
return 0;
if (EVP_PKEY_encrypt_init(pkey_ctx) <= 0
/* Generate session key
*/
- || RAND_bytes_ex(s->ctx->libctx, pms, pmslen, 0) <= 0) {
+ || RAND_bytes_ex(sctx->libctx, pms, pmslen, 0) <= 0) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
goto err;
};
}
#ifndef OPENSSL_NO_GOST
-int ossl_gost18_cke_cipher_nid(const SSL *s)
+int ossl_gost18_cke_cipher_nid(const SSL_CONNECTION *s)
{
if ((s->s3.tmp.new_cipher->algorithm_enc & SSL_MAGMA) != 0)
return NID_magma_ctr;
return NID_undef;
}
-int ossl_gost_ukm(const SSL *s, unsigned char *dgst_buf)
+int ossl_gost_ukm(const SSL_CONNECTION *s, unsigned char *dgst_buf)
{
EVP_MD_CTX * hash = NULL;
unsigned int md_len;
- const EVP_MD *md = ssl_evp_md_fetch(s->ctx->libctx, NID_id_GostR3411_2012_256, s->ctx->propq);
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
+ const EVP_MD *md = ssl_evp_md_fetch(sctx->libctx, NID_id_GostR3411_2012_256,
+ sctx->propq);
if (md == NULL)
return 0;
}
#endif
-static int tls_construct_cke_gost18(SSL *s, WPACKET *pkt)
+static int tls_construct_cke_gost18(SSL_CONNECTION *s, WPACKET *pkt)
{
#ifndef OPENSSL_NO_GOST
/* GOST 2018 key exchange message creation */
size_t pmslen = 0;
size_t msglen;
int cipher_nid = ossl_gost18_cke_cipher_nid(s);
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
if (cipher_nid == NID_undef) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
goto err;
}
- if (RAND_bytes_ex(s->ctx->libctx, pms, pmslen, 0) <= 0) {
+ if (RAND_bytes_ex(sctx->libctx, pms, pmslen, 0) <= 0) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
goto err;
}
goto err;
}
- pkey_ctx = EVP_PKEY_CTX_new_from_pkey(s->ctx->libctx,
+ pkey_ctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx,
X509_get0_pubkey(peer_cert),
- s->ctx->propq);
+ sctx->propq);
if (pkey_ctx == NULL) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
goto err;
#endif
}
-static int tls_construct_cke_srp(SSL *s, WPACKET *pkt)
+static int tls_construct_cke_srp(SSL_CONNECTION *s, WPACKET *pkt)
{
#ifndef OPENSSL_NO_SRP
unsigned char *abytes = NULL;
#endif
}
-int tls_construct_client_key_exchange(SSL *s, WPACKET *pkt)
+int tls_construct_client_key_exchange(SSL_CONNECTION *s, WPACKET *pkt)
{
unsigned long alg_k;
return 0;
}
-int tls_client_key_exchange_post_work(SSL *s)
+int tls_client_key_exchange_post_work(SSL_CONNECTION *s)
{
unsigned char *pms = NULL;
size_t pmslen = 0;
pmslen = 0;
#ifndef OPENSSL_NO_SCTP
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
unsigned char sctpauthkey[64];
char labelbuffer[sizeof(DTLS1_SCTP_AUTH_LABEL)];
size_t labellen;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
/*
* Add new shared key for SCTP-Auth, will be ignored if no SCTP
if (s->mode & SSL_MODE_DTLS_SCTP_LABEL_LENGTH_BUG)
labellen += 1;
- if (SSL_export_keying_material(s, sctpauthkey,
+ if (SSL_export_keying_material(ssl, sctpauthkey,
sizeof(sctpauthkey), labelbuffer,
labellen, NULL, 0, 0) <= 0) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
goto err;
}
- BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY,
+ BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY,
sizeof(sctpauthkey), sctpauthkey);
}
#endif
* cert exists, if we have a suitable digest for TLS 1.2 if static DH client
* certificates can be used and optionally checks suitability for Suite B.
*/
-static int ssl3_check_client_certificate(SSL *s)
+static int ssl3_check_client_certificate(SSL_CONNECTION *s)
{
/* If no suitable signature algorithm can't use certificate */
if (!tls_choose_sigalg(s, 0) || s->s3.tmp.sigalg == NULL)
return 1;
}
-WORK_STATE tls_prepare_client_certificate(SSL *s, WORK_STATE wst)
+WORK_STATE tls_prepare_client_certificate(SSL_CONNECTION *s, WORK_STATE wst)
{
X509 *x509 = NULL;
EVP_PKEY *pkey = NULL;
int i;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
if (wst == WORK_MORE_A) {
/* Let cert callback update client certificates if required */
if (s->cert->cert_cb) {
- i = s->cert->cert_cb(s, s->cert->cert_cb_arg);
+ i = s->cert->cert_cb(ssl, s->cert->cert_cb_arg);
if (i < 0) {
s->rwstate = SSL_X509_LOOKUP;
return WORK_MORE_A;
}
s->rwstate = SSL_NOTHING;
if ((i == 1) && (pkey != NULL) && (x509 != NULL)) {
- if (!SSL_use_certificate(s, x509) || !SSL_use_PrivateKey(s, pkey))
+ if (!SSL_use_certificate(ssl, x509)
+ || !SSL_use_PrivateKey(ssl, pkey))
i = 0;
} else if (i == 1) {
i = 0;
return WORK_ERROR;
}
-int tls_construct_client_certificate(SSL *s, WPACKET *pkt)
+int tls_construct_client_certificate(SSL_CONNECTION *s, WPACKET *pkt)
{
- if (SSL_IS_TLS13(s)) {
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
+
+ if (SSL_CONNECTION_IS_TLS13(s)) {
if (s->pha_context == NULL) {
/* no context available, add 0-length context */
if (!WPACKET_put_bytes_u8(pkt, 0)) {
return 0;
}
- if (SSL_IS_TLS13(s)
+ if (SSL_CONNECTION_IS_TLS13(s)
&& SSL_IS_FIRST_HANDSHAKE(s)
- && (!s->method->ssl3_enc->change_cipher_state(s,
+ && (!ssl->method->ssl3_enc->change_cipher_state(s,
SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_CLIENT_WRITE))) {
/*
* This is a fatal error, which leaves enc_write_ctx in an inconsistent
return 1;
}
-int ssl3_check_cert_and_algorithm(SSL *s)
+int ssl3_check_cert_and_algorithm(SSL_CONNECTION *s)
{
const SSL_CERT_LOOKUP *clu;
size_t idx;
}
#ifndef OPENSSL_NO_NEXTPROTONEG
-int tls_construct_next_proto(SSL *s, WPACKET *pkt)
+int tls_construct_next_proto(SSL_CONNECTION *s, WPACKET *pkt)
{
size_t len, padding_len;
unsigned char *padding = NULL;
}
#endif
-MSG_PROCESS_RETURN tls_process_hello_req(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_hello_req(SSL_CONNECTION *s, PACKET *pkt)
{
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
+
if (PACKET_remaining(pkt) > 0) {
/* should contain no data */
SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
* HelloRequest it will do a full handshake. Either behaviour is reasonable
* but doing one for TLS and another for DTLS is odd.
*/
- if (SSL_IS_DTLS(s))
- SSL_renegotiate(s);
+ if (SSL_CONNECTION_IS_DTLS(s))
+ SSL_renegotiate(ssl);
else
- SSL_renegotiate_abbreviated(s);
+ SSL_renegotiate_abbreviated(ssl);
return MSG_PROCESS_FINISHED_READING;
}
-static MSG_PROCESS_RETURN tls_process_encrypted_extensions(SSL *s, PACKET *pkt)
+static MSG_PROCESS_RETURN tls_process_encrypted_extensions(SSL_CONNECTION *s,
+ PACKET *pkt)
{
PACKET extensions;
RAW_EXTENSION *rawexts = NULL;
return MSG_PROCESS_ERROR;
}
-int ssl_do_client_cert_cb(SSL *s, X509 **px509, EVP_PKEY **ppkey)
+int ssl_do_client_cert_cb(SSL_CONNECTION *s, X509 **px509, EVP_PKEY **ppkey)
{
int i = 0;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
+
#ifndef OPENSSL_NO_ENGINE
- if (s->ctx->client_cert_engine) {
+ if (sctx->client_cert_engine) {
i = tls_engine_load_ssl_client_cert(s, px509, ppkey);
if (i != 0)
return i;
}
#endif
- if (s->ctx->client_cert_cb)
- i = s->ctx->client_cert_cb(s, px509, ppkey);
+ if (sctx->client_cert_cb)
+ i = sctx->client_cert_cb(SSL_CONNECTION_GET_SSL(s), px509, ppkey);
return i;
}
-int ssl_cipher_list_to_bytes(SSL *s, STACK_OF(SSL_CIPHER) *sk, WPACKET *pkt)
+int ssl_cipher_list_to_bytes(SSL_CONNECTION *s, STACK_OF(SSL_CIPHER) *sk,
+ WPACKET *pkt)
{
int i;
size_t totlen = 0, len, maxlen, maxverok = 0;
int empty_reneg_info_scsv = !s->renegotiate;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
/* Set disabled masks for this session */
if (!ssl_set_client_disabled(s)) {
* chop number of supported ciphers to keep it well below this if we
* use TLS v1.2
*/
- if (TLS1_get_version(s) >= TLS1_2_VERSION)
+ if (TLS1_get_version(ssl) >= TLS1_2_VERSION)
maxlen = OPENSSL_MAX_TLS1_2_CIPHER_LENGTH & ~1;
else
#endif
if (ssl_cipher_disabled(s, c, SSL_SECOP_CIPHER_SUPPORTED, 0))
continue;
- if (!s->method->put_cipher_by_char(c, pkt, &len)) {
+ if (!ssl->method->put_cipher_by_char(c, pkt, &len)) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return 0;
}
/* Sanity check that the maximum version we offer has ciphers enabled */
if (!maxverok) {
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
if (DTLS_VERSION_GE(c->max_dtls, s->s3.tmp.max_ver)
&& DTLS_VERSION_LE(c->min_dtls, s->s3.tmp.max_ver))
maxverok = 1;
static SSL_CIPHER scsv = {
0, NULL, NULL, SSL3_CK_SCSV, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
- if (!s->method->put_cipher_by_char(&scsv, pkt, &len)) {
+ if (!ssl->method->put_cipher_by_char(&scsv, pkt, &len)) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return 0;
}
static SSL_CIPHER scsv = {
0, NULL, NULL, SSL3_CK_FALLBACK_SCSV, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
- if (!s->method->put_cipher_by_char(&scsv, pkt, &len)) {
+ if (!ssl->method->put_cipher_by_char(&scsv, pkt, &len)) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return 0;
}
return 1;
}
-int tls_construct_end_of_early_data(SSL *s, WPACKET *pkt)
+int tls_construct_end_of_early_data(SSL_CONNECTION *s, WPACKET *pkt)
{
if (s->early_data_state != SSL_EARLY_DATA_WRITE_RETRY
&& s->early_data_state != SSL_EARLY_DATA_FINISHED_WRITING) {
static unsigned char bitmask_end_values[] =
{ 0xff, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f };
-static void dtls1_fix_message_header(SSL *s, size_t frag_off,
+static void dtls1_fix_message_header(SSL_CONNECTION *s, size_t frag_off,
size_t frag_len);
-static unsigned char *dtls1_write_message_header(SSL *s, unsigned char *p);
-static void dtls1_set_message_header_int(SSL *s, unsigned char mt,
+static unsigned char *dtls1_write_message_header(SSL_CONNECTION *s,
+ unsigned char *p);
+static void dtls1_set_message_header_int(SSL_CONNECTION *s, unsigned char mt,
size_t len,
unsigned short seq_num,
size_t frag_off,
size_t frag_len);
-static int dtls_get_reassembled_message(SSL *s, int *errtype, size_t *len);
+static int dtls_get_reassembled_message(SSL_CONNECTION *s, int *errtype,
+ size_t *len);
static hm_fragment *dtls1_hm_fragment_new(size_t frag_len, int reassembly)
{
* 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)
+int dtls1_do_write(SSL_CONNECTION *s, int type)
{
int ret;
size_t written;
size_t curr_mtu;
int retry = 1;
size_t len, frag_off, mac_size, blocksize, used_len;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
if (!dtls1_query_mtu(s))
return -1;
* retransmit anything. continue as if everything is fine and
* wait for an alert to handle the retransmit
*/
- if (retry && BIO_ctrl(SSL_get_wbio(s),
+ if (retry && BIO_ctrl(SSL_get_wbio(ssl),
BIO_CTRL_DGRAM_MTU_EXCEEDED, 0, NULL) > 0) {
- if (!(SSL_get_options(s) & SSL_OP_NO_QUERY_MTU)) {
+ if (!(SSL_get_options(ssl) & SSL_OP_NO_QUERY_MTU)) {
if (!dtls1_query_mtu(s))
return -1;
/* Have one more go */
if (written == s->init_num) {
if (s->msg_callback)
s->msg_callback(1, s->version, type, s->init_buf->data,
- (size_t)(s->init_off + s->init_num), s,
+ (size_t)(s->init_off + s->init_num), ssl,
s->msg_callback_arg);
s->init_off = 0; /* done writing this message */
return 0;
}
-int dtls_get_message(SSL *s, int *mt)
+int dtls_get_message(SSL_CONNECTION *s, int *mt)
{
struct hm_header_st *msg_hdr;
unsigned char *p;
if (*mt == SSL3_MT_CHANGE_CIPHER_SPEC) {
if (s->msg_callback) {
s->msg_callback(0, s->version, SSL3_RT_CHANGE_CIPHER_SPEC,
- p, 1, s, s->msg_callback_arg);
+ p, 1, SSL_CONNECTION_GET_SSL(s),
+ s->msg_callback_arg);
}
/*
* This isn't a real handshake message so skip the processing below.
* DTLS to do any further processing it wants at the same point that TLS would
* be asked for the message body.
*/
-int dtls_get_message_body(SSL *s, size_t *len)
+int dtls_get_message_body(SSL_CONNECTION *s, size_t *len)
{
unsigned char *msg = (unsigned char *)s->init_buf->data;
size_t msg_len = s->init_num + DTLS1_HM_HEADER_LENGTH;
if (s->msg_callback)
s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE,
s->init_buf->data, s->init_num + DTLS1_HM_HEADER_LENGTH,
- s, s->msg_callback_arg);
+ SSL_CONNECTION_GET_SSL(s), s->msg_callback_arg);
end:
*len = s->init_num;
* permitted in a DTLS handshake message for |s|. The minimum is 16KB, but
* may be greater if the maximum certificate list size requires it.
*/
-static size_t dtls1_max_handshake_message_len(const SSL *s)
+static size_t dtls1_max_handshake_message_len(const SSL_CONNECTION *s)
{
size_t max_len = DTLS1_HM_HEADER_LENGTH + SSL3_RT_MAX_ENCRYPTED_LENGTH;
if (max_len < s->max_cert_list)
return max_len;
}
-static int dtls1_preprocess_fragment(SSL *s, struct hm_header_st *msg_hdr)
+static int dtls1_preprocess_fragment(SSL_CONNECTION *s,
+ struct hm_header_st *msg_hdr)
{
size_t frag_off, frag_len, msg_len;
* Returns 1 if there is a buffered fragment available, 0 if not, or -1 on a
* fatal error.
*/
-static int dtls1_retrieve_buffered_fragment(SSL *s, size_t *len)
+static int dtls1_retrieve_buffered_fragment(SSL_CONNECTION *s, size_t *len)
{
/*-
* (0) check whether the desired fragment is available
}
}
-static int
-dtls1_reassemble_fragment(SSL *s, const struct hm_header_st *msg_hdr)
+static int dtls1_reassemble_fragment(SSL_CONNECTION *s,
+ const struct hm_header_st *msg_hdr)
{
hm_fragment *frag = NULL;
pitem *item = NULL;
unsigned char seq64be[8];
size_t frag_len = msg_hdr->frag_len;
size_t readbytes;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
if ((msg_hdr->frag_off + frag_len) > msg_hdr->msg_len ||
msg_hdr->msg_len > dtls1_max_handshake_message_len(s))
unsigned char devnull[256];
while (frag_len) {
- i = s->method->ssl_read_bytes(s, SSL3_RT_HANDSHAKE, NULL,
- devnull,
- frag_len >
- sizeof(devnull) ? sizeof(devnull) :
- frag_len, 0, &readbytes);
+ i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, NULL,
+ devnull,
+ frag_len >
+ sizeof(devnull) ? sizeof(devnull) :
+ frag_len, 0, &readbytes);
if (i <= 0)
goto err;
frag_len -= readbytes;
}
/* read the body of the fragment (header has already been read */
- i = s->method->ssl_read_bytes(s, SSL3_RT_HANDSHAKE, NULL,
- frag->fragment + msg_hdr->frag_off,
- frag_len, 0, &readbytes);
+ i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, NULL,
+ frag->fragment + msg_hdr->frag_off,
+ frag_len, 0, &readbytes);
if (i <= 0 || readbytes != frag_len)
i = -1;
if (i <= 0)
return -1;
}
-static int
-dtls1_process_out_of_seq_message(SSL *s, const struct hm_header_st *msg_hdr)
+static int dtls1_process_out_of_seq_message(SSL_CONNECTION *s,
+ const struct hm_header_st *msg_hdr)
{
int i = -1;
hm_fragment *frag = NULL;
unsigned char seq64be[8];
size_t frag_len = msg_hdr->frag_len;
size_t readbytes;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
if ((msg_hdr->frag_off + frag_len) > msg_hdr->msg_len)
goto err;
unsigned char devnull[256];
while (frag_len) {
- i = s->method->ssl_read_bytes(s, SSL3_RT_HANDSHAKE, NULL,
- devnull,
- frag_len >
- sizeof(devnull) ? sizeof(devnull) :
- frag_len, 0, &readbytes);
+ i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, NULL,
+ devnull,
+ frag_len >
+ sizeof(devnull) ? sizeof(devnull) :
+ frag_len, 0, &readbytes);
if (i <= 0)
goto err;
frag_len -= readbytes;
/*
* read the body of the fragment (header has already been read
*/
- i = s->method->ssl_read_bytes(s, SSL3_RT_HANDSHAKE, NULL,
- frag->fragment, frag_len, 0,
- &readbytes);
+ i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, NULL,
+ frag->fragment, frag_len, 0,
+ &readbytes);
if (i<=0 || readbytes != frag_len)
i = -1;
if (i <= 0)
return 0;
}
-static int dtls_get_reassembled_message(SSL *s, int *errtype, size_t *len)
+static int dtls_get_reassembled_message(SSL_CONNECTION *s, int *errtype,
+ size_t *len)
{
unsigned char wire[DTLS1_HM_HEADER_LENGTH];
size_t mlen, frag_off, frag_len;
int i, ret, recvd_type;
struct hm_header_st msg_hdr;
size_t readbytes;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
*errtype = 0;
}
/* read handshake message header */
- i = s->method->ssl_read_bytes(s, SSL3_RT_HANDSHAKE, &recvd_type, wire,
- DTLS1_HM_HEADER_LENGTH, 0, &readbytes);
+ i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, &recvd_type, wire,
+ DTLS1_HM_HEADER_LENGTH, 0, &readbytes);
if (i <= 0) { /* nbio, or an error */
s->rwstate = SSL_READING;
*len = 0;
if (wire[1] == 0 && wire[2] == 0 && wire[3] == 0) {
if (s->msg_callback)
s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE,
- wire, DTLS1_HM_HEADER_LENGTH, s,
+ wire, DTLS1_HM_HEADER_LENGTH, ssl,
s->msg_callback_arg);
s->init_num = 0;
unsigned char *p =
(unsigned char *)s->init_buf->data + DTLS1_HM_HEADER_LENGTH;
- i = s->method->ssl_read_bytes(s, SSL3_RT_HANDSHAKE, NULL,
- &p[frag_off], frag_len, 0, &readbytes);
+ i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, NULL,
+ &p[frag_off], frag_len, 0, &readbytes);
/*
* This shouldn't ever fail due to NBIO because we already checked
* ssl->session->read_compression assign
* ssl->session->read_hash assign
*/
-int dtls_construct_change_cipher_spec(SSL *s, WPACKET *pkt)
+int dtls_construct_change_cipher_spec(SSL_CONNECTION *s, WPACKET *pkt)
{
if (s->version == DTLS1_BAD_VER) {
s->d1->next_handshake_write_seq++;
* Wait for a dry event. Should only be called at a point in the handshake
* where we are not expecting any data from the peer except an alert.
*/
-WORK_STATE dtls_wait_for_dry(SSL *s)
+WORK_STATE dtls_wait_for_dry(SSL_CONNECTION *s)
{
int ret, errtype;
size_t len;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
/* read app data until dry event */
- ret = BIO_dgram_sctp_wait_for_dry(SSL_get_wbio(s));
+ ret = BIO_dgram_sctp_wait_for_dry(SSL_get_wbio(ssl));
if (ret < 0) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return WORK_ERROR;
s->s3.in_read_app_data = 2;
s->rwstate = SSL_READING;
- BIO_clear_retry_flags(SSL_get_rbio(s));
- BIO_set_retry_read(SSL_get_rbio(s));
+ BIO_clear_retry_flags(SSL_get_rbio(ssl));
+ BIO_set_retry_read(SSL_get_rbio(ssl));
return WORK_MORE_A;
}
return WORK_FINISHED_CONTINUE;
}
#endif
-int dtls1_read_failed(SSL *s, int code)
+int dtls1_read_failed(SSL_CONNECTION *s, int code)
{
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
+
if (code > 0) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return 0;
return code;
}
/* done, no need to send a retransmit */
- if (!SSL_in_init(s))
+ if (!SSL_in_init(ssl))
{
- BIO_set_flags(SSL_get_rbio(s), BIO_FLAGS_READ);
+ BIO_set_flags(SSL_get_rbio(ssl), BIO_FLAGS_READ);
return code;
}
return seq * 2 - is_ccs;
}
-int dtls1_retransmit_buffered_messages(SSL *s)
+int dtls1_retransmit_buffered_messages(SSL_CONNECTION *s)
{
pqueue *sent = s->d1->sent_messages;
piterator iter;
return 1;
}
-int dtls1_buffer_message(SSL *s, int is_ccs)
+int dtls1_buffer_message(SSL_CONNECTION *s, int is_ccs)
{
pitem *item;
hm_fragment *frag;
return 1;
}
-int dtls1_retransmit_message(SSL *s, unsigned short seq, int *found)
+int dtls1_retransmit_message(SSL_CONNECTION *s, unsigned short seq, int *found)
{
int ret;
/* XDTLS: for now assuming that read/writes are blocking */
return ret;
}
-void dtls1_set_message_header(SSL *s,
+void dtls1_set_message_header(SSL_CONNECTION *s,
unsigned char mt, size_t len,
size_t frag_off, size_t frag_len)
{
/* don't actually do the writing, wait till the MTU has been retrieved */
static void
-dtls1_set_message_header_int(SSL *s, unsigned char mt,
+dtls1_set_message_header_int(SSL_CONNECTION *s, unsigned char mt,
size_t len, unsigned short seq_num,
size_t frag_off, size_t frag_len)
{
}
static void
-dtls1_fix_message_header(SSL *s, size_t frag_off, size_t frag_len)
+dtls1_fix_message_header(SSL_CONNECTION *s, size_t frag_off, size_t frag_len)
{
struct hm_header_st *msg_hdr = &s->d1->w_msg_hdr;
msg_hdr->frag_len = frag_len;
}
-static unsigned char *dtls1_write_message_header(SSL *s, unsigned char *p)
+static unsigned char *dtls1_write_message_header(SSL_CONNECTION *s,
+ unsigned char *p)
{
struct hm_header_st *msg_hdr = &s->d1->w_msg_hdr;
n2l3(data, msg_hdr->frag_len);
}
-int dtls1_set_handshake_header(SSL *s, WPACKET *pkt, int htype)
+int dtls1_set_handshake_header(SSL_CONNECTION *s, WPACKET *pkt, int htype)
{
unsigned char *header;
return 1;
}
-int dtls1_close_construct_packet(SSL *s, WPACKET *pkt, int htype)
+int dtls1_close_construct_packet(SSL_CONNECTION *s, WPACKET *pkt, int htype)
{
size_t msglen;
* send s->init_buf in records of type 'type' (SSL3_RT_HANDSHAKE or
* SSL3_RT_CHANGE_CIPHER_SPEC)
*/
-int ssl3_do_write(SSL *s, int type)
+int ssl3_do_write(SSL_CONNECTION *s, int type)
{
int ret;
size_t written = 0;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
- ret = ssl3_write_bytes(s, type, &s->init_buf->data[s->init_off],
+ ret = ssl3_write_bytes(ssl, type, &s->init_buf->data[s->init_off],
s->init_num, &written);
if (ret < 0)
return -1;
* ignore the result anyway
* TLS1.3 KeyUpdate and NewSessionTicket do not need to be added
*/
- if (!SSL_IS_TLS13(s) || (s->statem.hand_state != TLS_ST_SW_SESSION_TICKET
+ if (!SSL_CONNECTION_IS_TLS13(s)
+ || (s->statem.hand_state != TLS_ST_SW_SESSION_TICKET
&& s->statem.hand_state != TLS_ST_CW_KEY_UPDATE
&& s->statem.hand_state != TLS_ST_SW_KEY_UPDATE))
if (!ssl3_finish_mac(s,
if (written == s->init_num) {
if (s->msg_callback)
s->msg_callback(1, s->version, type, s->init_buf->data,
- (size_t)(s->init_off + s->init_num), s,
+ (size_t)(s->init_off + s->init_num), ssl,
s->msg_callback_arg);
return 1;
}
return 0;
}
-int tls_close_construct_packet(SSL *s, WPACKET *pkt, int htype)
+int tls_close_construct_packet(SSL_CONNECTION *s, WPACKET *pkt, int htype)
{
size_t msglen;
return 1;
}
-int tls_setup_handshake(SSL *s)
+int tls_setup_handshake(SSL_CONNECTION *s)
{
int ver_min, ver_max, ok;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
if (!ssl3_init_finished_mac(s)) {
/* SSLfatal() already called */
}
/* Sanity check that we have MD5-SHA1 if we need it */
- if (s->ctx->ssl_digest_methods[SSL_MD_MD5_SHA1_IDX] == NULL) {
+ if (sctx->ssl_digest_methods[SSL_MD_MD5_SHA1_IDX] == NULL) {
int md5sha1_needed = 0;
/* We don't have MD5-SHA1 - do we need it? */
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
if (DTLS_VERSION_LE(ver_max, DTLS1_VERSION))
md5sha1_needed = 1;
} else {
ok = 1;
/* Don't allow TLSv1.1 or below to be negotiated */
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
if (DTLS_VERSION_LT(ver_min, DTLS1_2_VERSION))
- ok = SSL_set_min_proto_version(s, DTLS1_2_VERSION);
+ ok = SSL_set_min_proto_version(ssl, DTLS1_2_VERSION);
} else {
if (ver_min < TLS1_2_VERSION)
- ok = SSL_set_min_proto_version(s, TLS1_2_VERSION);
+ ok = SSL_set_min_proto_version(ssl, TLS1_2_VERSION);
}
if (!ok) {
/* Shouldn't happen */
ok = 0;
if (s->server) {
- STACK_OF(SSL_CIPHER) *ciphers = SSL_get_ciphers(s);
+ STACK_OF(SSL_CIPHER) *ciphers = SSL_get_ciphers(ssl);
int i;
/*
for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) {
const SSL_CIPHER *c = sk_SSL_CIPHER_value(ciphers, i);
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
if (DTLS_VERSION_GE(ver_max, c->min_dtls) &&
DTLS_VERSION_LE(ver_max, c->max_dtls))
ok = 1;
ssl_tsan_counter(s->session_ctx, &s->session_ctx->stats.sess_accept);
} else {
/* N.B. s->ctx may not equal s->session_ctx */
- ssl_tsan_counter(s->ctx, &s->ctx->stats.sess_accept_renegotiate);
+ ssl_tsan_counter(sctx, &sctx->stats.sess_accept_renegotiate);
s->s3.tmp.cert_request = 0;
}
s->s3.tmp.cert_req = 0;
- if (SSL_IS_DTLS(s))
+ if (SSL_CONNECTION_IS_DTLS(s))
s->statem.use_timer = 1;
}
#define TLS13_TBS_START_SIZE 64
#define TLS13_TBS_PREAMBLE_SIZE (TLS13_TBS_START_SIZE + 33 + 1)
-static int get_cert_verify_tbs_data(SSL *s, unsigned char *tls13tbs,
+static int get_cert_verify_tbs_data(SSL_CONNECTION *s, unsigned char *tls13tbs,
void **hdata, size_t *hdatalen)
{
#ifdef CHARSET_EBCDIC
static const char servercontext[] = "TLS 1.3, server CertificateVerify";
static const char clientcontext[] = "TLS 1.3, client CertificateVerify";
#endif
- if (SSL_IS_TLS13(s)) {
+
+ if (SSL_CONNECTION_IS_TLS13(s)) {
size_t hashlen;
/* Set the first 64 bytes of to-be-signed data to octet 32 */
return 1;
}
-int tls_construct_cert_verify(SSL *s, WPACKET *pkt)
+int tls_construct_cert_verify(SSL_CONNECTION *s, WPACKET *pkt)
{
EVP_PKEY *pkey = NULL;
const EVP_MD *md = NULL;
unsigned char *sig = NULL;
unsigned char tls13tbs[TLS13_TBS_PREAMBLE_SIZE + EVP_MAX_MD_SIZE];
const SIGALG_LOOKUP *lu = s->s3.tmp.sigalg;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
if (lu == NULL || s->s3.tmp.cert == NULL) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
}
pkey = s->s3.tmp.cert->privatekey;
- if (pkey == NULL || !tls1_lookup_md(s->ctx, lu, &md)) {
+ if (pkey == NULL || !tls1_lookup_md(sctx, lu, &md)) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
goto err;
}
if (EVP_DigestSignInit_ex(mctx, &pctx,
md == NULL ? NULL : EVP_MD_get0_name(md),
- s->ctx->libctx, s->ctx->propq, pkey,
+ sctx->libctx, sctx->propq, pkey,
NULL) <= 0) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
goto err;
return 0;
}
-MSG_PROCESS_RETURN tls_process_cert_verify(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_cert_verify(SSL_CONNECTION *s, PACKET *pkt)
{
EVP_PKEY *pkey = NULL;
const unsigned char *data;
unsigned char tls13tbs[TLS13_TBS_PREAMBLE_SIZE + EVP_MAX_MD_SIZE];
EVP_MD_CTX *mctx = EVP_MD_CTX_new();
EVP_PKEY_CTX *pctx = NULL;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
if (mctx == NULL) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
goto err;
}
- if (!tls1_lookup_md(s->ctx, s->s3.tmp.peer_sigalg, &md)) {
+ if (!tls1_lookup_md(sctx, s->s3.tmp.peer_sigalg, &md)) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
goto err;
}
if (EVP_DigestVerifyInit_ex(mctx, &pctx,
md == NULL ? NULL : EVP_MD_get0_name(md),
- s->ctx->libctx, s->ctx->propq, pkey,
+ sctx->libctx, sctx->propq, pkey,
NULL) <= 0) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
goto err;
* want to make sure that SSL_get1_peer_certificate() will return the actual
* server certificate from the client_cert_cb callback.
*/
- if (!s->server && SSL_IS_TLS13(s) && s->s3.tmp.cert_req == 1)
+ if (!s->server && SSL_CONNECTION_IS_TLS13(s) && s->s3.tmp.cert_req == 1)
ret = MSG_PROCESS_CONTINUE_PROCESSING;
else
ret = MSG_PROCESS_CONTINUE_READING;
return ret;
}
-int tls_construct_finished(SSL *s, WPACKET *pkt)
+int tls_construct_finished(SSL_CONNECTION *s, WPACKET *pkt)
{
size_t finish_md_len;
const char *sender;
size_t slen;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
/* This is a real handshake so make sure we clean it up at the end */
if (!s->server && s->post_handshake_auth != SSL_PHA_REQUESTED)
* We only change the keys if we didn't already do this when we sent the
* client certificate
*/
- if (SSL_IS_TLS13(s)
+ if (SSL_CONNECTION_IS_TLS13(s)
&& !s->server
&& s->s3.tmp.cert_req == 0
- && (!s->method->ssl3_enc->change_cipher_state(s,
+ && (!ssl->method->ssl3_enc->change_cipher_state(s,
SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_CLIENT_WRITE))) {;
/* SSLfatal() already called */
return 0;
}
if (s->server) {
- sender = s->method->ssl3_enc->server_finished_label;
- slen = s->method->ssl3_enc->server_finished_label_len;
+ sender = ssl->method->ssl3_enc->server_finished_label;
+ slen = ssl->method->ssl3_enc->server_finished_label_len;
} else {
- sender = s->method->ssl3_enc->client_finished_label;
- slen = s->method->ssl3_enc->client_finished_label_len;
+ sender = ssl->method->ssl3_enc->client_finished_label;
+ slen = ssl->method->ssl3_enc->client_finished_label_len;
}
- finish_md_len = s->method->ssl3_enc->final_finish_mac(s,
- sender, slen,
- s->s3.tmp.finish_md);
+ finish_md_len = ssl->method->ssl3_enc->final_finish_mac(s,
+ sender, slen,
+ s->s3.tmp.finish_md);
if (finish_md_len == 0) {
/* SSLfatal() already called */
return 0;
* Log the master secret, if logging is enabled. We don't log it for
* TLSv1.3: there's a different key schedule for that.
*/
- if (!SSL_IS_TLS13(s) && !ssl_log_secret(s, MASTER_SECRET_LABEL,
- s->session->master_key,
- s->session->master_key_length)) {
+ if (!SSL_CONNECTION_IS_TLS13(s)
+ && !ssl_log_secret(s, MASTER_SECRET_LABEL, s->session->master_key,
+ s->session->master_key_length)) {
/* SSLfatal() already called */
return 0;
}
return 1;
}
-int tls_construct_key_update(SSL *s, WPACKET *pkt)
+int tls_construct_key_update(SSL_CONNECTION *s, WPACKET *pkt)
{
if (!WPACKET_put_bytes_u8(pkt, s->key_update)) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return 1;
}
-MSG_PROCESS_RETURN tls_process_key_update(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_key_update(SSL_CONNECTION *s, PACKET *pkt)
{
unsigned int updatetype;
* ssl3_take_mac calculates the Finished MAC for the handshakes messages seen
* to far.
*/
-int ssl3_take_mac(SSL *s)
+int ssl3_take_mac(SSL_CONNECTION *s)
{
const char *sender;
size_t slen;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
if (!s->server) {
- sender = s->method->ssl3_enc->server_finished_label;
- slen = s->method->ssl3_enc->server_finished_label_len;
+ sender = ssl->method->ssl3_enc->server_finished_label;
+ slen = ssl->method->ssl3_enc->server_finished_label_len;
} else {
- sender = s->method->ssl3_enc->client_finished_label;
- slen = s->method->ssl3_enc->client_finished_label_len;
+ sender = ssl->method->ssl3_enc->client_finished_label;
+ slen = ssl->method->ssl3_enc->client_finished_label_len;
}
s->s3.tmp.peer_finish_md_len =
- s->method->ssl3_enc->final_finish_mac(s, sender, slen,
- s->s3.tmp.peer_finish_md);
+ ssl->method->ssl3_enc->final_finish_mac(s, sender, slen,
+ s->s3.tmp.peer_finish_md);
if (s->s3.tmp.peer_finish_md_len == 0) {
/* SSLfatal() already called */
return 1;
}
-MSG_PROCESS_RETURN tls_process_change_cipher_spec(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_change_cipher_spec(SSL_CONNECTION *s,
+ PACKET *pkt)
{
size_t remain;
* been consumed by ssl_get_message() so there should be no bytes left,
* unless we're using DTLS1_BAD_VER, which has an extra 2 bytes
*/
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
if ((s->version == DTLS1_BAD_VER
&& remain != DTLS1_CCS_HEADER_LENGTH + 1)
|| (s->version != DTLS1_BAD_VER
return MSG_PROCESS_ERROR;
}
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
dtls1_reset_seq_numbers(s, SSL3_CC_READ);
if (s->version == DTLS1_BAD_VER)
* SCTP-Auth can be deleted when a CCS is sent. Will be ignored if no
* SCTP is used
*/
- BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_AUTH_CCS_RCVD, 1, NULL);
+ BIO_ctrl(SSL_get_wbio(SSL_CONNECTION_GET_SSL(s)),
+ BIO_CTRL_DGRAM_SCTP_AUTH_CCS_RCVD, 1, NULL);
#endif
}
return MSG_PROCESS_CONTINUE_READING;
}
-MSG_PROCESS_RETURN tls_process_finished(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_finished(SSL_CONNECTION *s, PACKET *pkt)
{
size_t md_len;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
/* This is a real handshake so make sure we clean it up at the end */
s->statem.enc_read_state = ENC_READ_STATE_VALID;
if (s->post_handshake_auth != SSL_PHA_REQUESTED)
s->statem.cleanuphand = 1;
- if (SSL_IS_TLS13(s) && !tls13_save_handshake_digest_for_pha(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)
+ && !tls13_save_handshake_digest_for_pha(s)) {
/* SSLfatal() already called */
return MSG_PROCESS_ERROR;
}
* In TLSv1.3 a Finished message signals a key change so the end of the
* message must be on a record boundary.
*/
- if (SSL_IS_TLS13(s) && RECORD_LAYER_processed_read_pending(&s->rlayer)) {
+ if (SSL_CONNECTION_IS_TLS13(s)
+ && RECORD_LAYER_processed_read_pending(&s->rlayer)) {
SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_NOT_ON_RECORD_BOUNDARY);
return MSG_PROCESS_ERROR;
}
/* If this occurs, we have missed a message */
- if (!SSL_IS_TLS13(s) && !s->s3.change_cipher_spec) {
+ if (!SSL_CONNECTION_IS_TLS13(s) && !s->s3.change_cipher_spec) {
SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_GOT_A_FIN_BEFORE_A_CCS);
return MSG_PROCESS_ERROR;
}
* In TLS1.3 we also have to change cipher state and do any final processing
* of the initial server flight (if we are a client)
*/
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
if (s->server) {
if (s->post_handshake_auth != SSL_PHA_REQUESTED &&
- !s->method->ssl3_enc->change_cipher_state(s,
- SSL3_CC_APPLICATION | SSL3_CHANGE_CIPHER_SERVER_READ)) {
+ !ssl->method->ssl3_enc->change_cipher_state(s,
+ SSL3_CC_APPLICATION | SSL3_CHANGE_CIPHER_SERVER_READ)) {
/* SSLfatal() already called */
return MSG_PROCESS_ERROR;
}
} else {
/* TLS 1.3 gets the secret size from the handshake md */
size_t dummy;
- if (!s->method->ssl3_enc->generate_master_secret(s,
+ if (!ssl->method->ssl3_enc->generate_master_secret(s,
s->master_secret, s->handshake_secret, 0,
&dummy)) {
/* SSLfatal() already called */
return MSG_PROCESS_ERROR;
}
- if (!s->method->ssl3_enc->change_cipher_state(s,
+ if (!ssl->method->ssl3_enc->change_cipher_state(s,
SSL3_CC_APPLICATION | SSL3_CHANGE_CIPHER_CLIENT_READ)) {
/* SSLfatal() already called */
return MSG_PROCESS_ERROR;
return MSG_PROCESS_FINISHED_READING;
}
-int tls_construct_change_cipher_spec(SSL *s, WPACKET *pkt)
+int tls_construct_change_cipher_spec(SSL_CONNECTION *s, WPACKET *pkt)
{
if (!WPACKET_put_bytes_u8(pkt, SSL3_MT_CCS)) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
}
/* Add a certificate to the WPACKET */
-static int ssl_add_cert_to_wpacket(SSL *s, WPACKET *pkt, X509 *x, int chain)
+static int ssl_add_cert_to_wpacket(SSL_CONNECTION *s, WPACKET *pkt,
+ X509 *x, int chain)
{
int len;
unsigned char *outbytes;
return 0;
}
- if (SSL_IS_TLS13(s)
+ if (SSL_CONNECTION_IS_TLS13(s)
&& !tls_construct_extensions(s, pkt, SSL_EXT_TLS1_3_CERTIFICATE, x,
chain)) {
/* SSLfatal() already called */
}
/* Add certificate chain to provided WPACKET */
-static int ssl_add_cert_chain(SSL *s, WPACKET *pkt, CERT_PKEY *cpk)
+static int ssl_add_cert_chain(SSL_CONNECTION *s, WPACKET *pkt, CERT_PKEY *cpk)
{
int i, chain_count;
X509 *x;
STACK_OF(X509) *extra_certs;
STACK_OF(X509) *chain = NULL;
X509_STORE *chain_store;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
if (cpk == NULL || cpk->x509 == NULL)
return 1;
if (cpk->chain != NULL)
extra_certs = cpk->chain;
else
- extra_certs = s->ctx->extra_certs;
+ extra_certs = sctx->extra_certs;
if ((s->mode & SSL_MODE_NO_AUTO_CHAIN) || extra_certs)
chain_store = NULL;
else if (s->cert->chain_store)
chain_store = s->cert->chain_store;
else
- chain_store = s->ctx->cert_store;
+ chain_store = sctx->cert_store;
if (chain_store != NULL) {
- X509_STORE_CTX *xs_ctx = X509_STORE_CTX_new_ex(s->ctx->libctx,
- s->ctx->propq);
+ X509_STORE_CTX *xs_ctx = X509_STORE_CTX_new_ex(sctx->libctx,
+ sctx->propq);
if (xs_ctx == NULL) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
return 1;
}
-unsigned long ssl3_output_cert_chain(SSL *s, WPACKET *pkt, CERT_PKEY *cpk)
+unsigned long ssl3_output_cert_chain(SSL_CONNECTION *s, WPACKET *pkt,
+ CERT_PKEY *cpk)
{
if (!WPACKET_start_sub_packet_u24(pkt)) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
* in NBIO events. If |clearbufs| is set then init_buf and the wbio buffer is
* freed up as well.
*/
-WORK_STATE tls_finish_handshake(SSL *s, ossl_unused WORK_STATE wst,
+WORK_STATE tls_finish_handshake(SSL_CONNECTION *s, ossl_unused WORK_STATE wst,
int clearbufs, int stop)
{
void (*cb) (const SSL *ssl, int type, int val) = NULL;
int cleanuphand = s->statem.cleanuphand;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
if (clearbufs) {
- if (!SSL_IS_DTLS(s)
+ if (!SSL_CONNECTION_IS_DTLS(s)
#ifndef OPENSSL_NO_SCTP
/*
* RFC6083: SCTP provides a reliable and in-sequence transport service for DTLS
* MUST NOT be used.
* Hence the init_buf can be cleared when DTLS over SCTP as transport is used.
*/
- || BIO_dgram_is_sctp(SSL_get_wbio(s))
+ || BIO_dgram_is_sctp(SSL_get_wbio(ssl))
#endif
) {
/*
s->init_num = 0;
}
- if (SSL_IS_TLS13(s) && !s->server
+ if (SSL_CONNECTION_IS_TLS13(s) && !s->server
&& s->post_handshake_auth == SSL_PHA_REQUESTED)
s->post_handshake_auth = SSL_PHA_EXT_SENT;
* In TLSv1.3 we update the cache as part of constructing the
* NewSessionTicket
*/
- if (!SSL_IS_TLS13(s))
+ if (!SSL_CONNECTION_IS_TLS13(s))
ssl_update_cache(s, SSL_SESS_CACHE_SERVER);
/* N.B. s->ctx may not equal s->session_ctx */
- ssl_tsan_counter(s->ctx, &s->ctx->stats.sess_accept_good);
+ ssl_tsan_counter(sctx, &sctx->stats.sess_accept_good);
s->handshake_func = ossl_statem_accept;
} else {
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
/*
* We encourage applications to only use TLSv1.3 tickets once,
* so we remove this one from the cache.
&s->session_ctx->stats.sess_connect_good);
}
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
/* done with handshaking */
s->d1->handshake_read_seq = 0;
s->d1->handshake_write_seq = 0;
if (s->info_callback != NULL)
cb = s->info_callback;
- else if (s->ctx->info_callback != NULL)
- cb = s->ctx->info_callback;
+ else if (sctx->info_callback != NULL)
+ cb = sctx->info_callback;
/* The callback may expect us to not be in init at handshake done */
ossl_statem_set_in_init(s, 0);
if (cb != NULL) {
if (cleanuphand
- || !SSL_IS_TLS13(s)
+ || !SSL_CONNECTION_IS_TLS13(s)
|| SSL_IS_FIRST_HANDSHAKE(s))
- cb(s, SSL_CB_HANDSHAKE_DONE, 1);
+ cb(ssl, SSL_CB_HANDSHAKE_DONE, 1);
}
if (!stop) {
return WORK_FINISHED_STOP;
}
-int tls_get_message_header(SSL *s, int *mt)
+int tls_get_message_header(SSL_CONNECTION *s, int *mt)
{
/* s->init_num < SSL3_HM_HEADER_LENGTH */
int skip_message, i, recvd_type;
unsigned char *p;
size_t l, readbytes;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
p = (unsigned char *)s->init_buf->data;
do {
while (s->init_num < SSL3_HM_HEADER_LENGTH) {
- i = s->method->ssl_read_bytes(s, SSL3_RT_HANDSHAKE, &recvd_type,
- &p[s->init_num],
- SSL3_HM_HEADER_LENGTH - s->init_num,
- 0, &readbytes);
+ i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, &recvd_type,
+ &p[s->init_num],
+ SSL3_HM_HEADER_LENGTH - s->init_num,
+ 0, &readbytes);
if (i <= 0) {
s->rwstate = SSL_READING;
return 0;
if (s->msg_callback)
s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE,
- p, SSL3_HM_HEADER_LENGTH, s,
+ p, SSL3_HM_HEADER_LENGTH, ssl,
s->msg_callback_arg);
}
} while (skip_message);
return 1;
}
-int tls_get_message_body(SSL *s, size_t *len)
+int tls_get_message_body(SSL_CONNECTION *s, size_t *len)
{
size_t n, readbytes;
unsigned char *p;
int i;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
if (s->s3.tmp.message_type == SSL3_MT_CHANGE_CIPHER_SPEC) {
/* We've already read everything in */
p = s->init_msg;
n = s->s3.tmp.message_size - s->init_num;
while (n > 0) {
- i = s->method->ssl_read_bytes(s, SSL3_RT_HANDSHAKE, NULL,
- &p[s->init_num], n, 0, &readbytes);
+ i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, NULL,
+ &p[s->init_num], n, 0, &readbytes);
if (i <= 0) {
s->rwstate = SSL_READING;
*len = 0;
}
if (s->msg_callback)
s->msg_callback(0, SSL2_VERSION, 0, s->init_buf->data,
- (size_t)s->init_num, s, s->msg_callback_arg);
+ (size_t)s->init_num, ssl, s->msg_callback_arg);
} else {
/*
* We defer feeding in the HRR until later. We'll do it as part of
*/
#define SERVER_HELLO_RANDOM_OFFSET (SSL3_HM_HEADER_LENGTH + 2)
/* KeyUpdate and NewSessionTicket do not need to be added */
- if (!SSL_IS_TLS13(s) || (s->s3.tmp.message_type != SSL3_MT_NEWSESSION_TICKET
- && s->s3.tmp.message_type != SSL3_MT_KEY_UPDATE)) {
+ if (!SSL_CONNECTION_IS_TLS13(s)
+ || (s->s3.tmp.message_type != SSL3_MT_NEWSESSION_TICKET
+ && s->s3.tmp.message_type != SSL3_MT_KEY_UPDATE)) {
if (s->s3.tmp.message_type != SSL3_MT_SERVER_HELLO
|| s->init_num < SERVER_HELLO_RANDOM_OFFSET + SSL3_RANDOM_SIZE
|| memcmp(hrrrandom,
}
if (s->msg_callback)
s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE, s->init_buf->data,
- (size_t)s->init_num + SSL3_HM_HEADER_LENGTH, s,
+ (size_t)s->init_num + SSL3_HM_HEADER_LENGTH, ssl,
s->msg_callback_arg);
}
return tp->alert;
}
-int ssl_allow_compression(SSL *s)
+int ssl_allow_compression(SSL_CONNECTION *s)
{
if (s->options & SSL_OP_NO_COMPRESSION)
return 0;
return ssl_security(s, SSL_SECOP_COMPRESSION, 0, 0, NULL);
}
-static int version_cmp(const SSL *s, int a, int b)
+static int version_cmp(const SSL_CONNECTION *s, int a, int b)
{
- int dtls = SSL_IS_DTLS(s);
+ int dtls = SSL_CONNECTION_IS_DTLS(s);
if (a == b)
return 0;
*
* Returns 0 on success, or an SSL error reason on failure.
*/
-static int ssl_method_error(const SSL *s, const SSL_METHOD *method)
+static int ssl_method_error(const SSL_CONNECTION *s, const SSL_METHOD *method)
{
int version = method->version;
* certificate type, or has PSK or a certificate callback configured, or has
* a servername callback configure. Otherwise returns 0.
*/
-static int is_tls13_capable(const SSL *s)
+static int is_tls13_capable(const SSL_CONNECTION *s)
{
int i;
int curve;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
- if (!ossl_assert(s->ctx != NULL) || !ossl_assert(s->session_ctx != NULL))
+ if (!ossl_assert(sctx != NULL) || !ossl_assert(s->session_ctx != NULL))
return 0;
/*
* A servername callback can change the available certs, so if a servername
* cb is set then we just assume TLSv1.3 will be ok
*/
- if (s->ctx->ext.servername_cb != NULL
+ if (sctx->ext.servername_cb != NULL
|| s->session_ctx->ext.servername_cb != NULL)
return 1;
*
* Returns 1 when supported, otherwise 0
*/
-int ssl_version_supported(const SSL *s, int version, const SSL_METHOD **meth)
+int ssl_version_supported(const SSL_CONNECTION *s, int version,
+ const SSL_METHOD **meth)
{
const version_info *vent;
const version_info *table;
- switch (s->method->version) {
+ switch (SSL_CONNECTION_GET_SSL(s)->method->version) {
default:
/* Version should match method version for non-ANY method */
return version_cmp(s, version, s->version) == 0;
*
* Returns 1 when using the highest enabled version, 0 otherwise.
*/
-int ssl_check_version_downgrade(SSL *s)
+int ssl_check_version_downgrade(SSL_CONNECTION *s)
{
const version_info *vent;
const version_info *table;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
/*
* Check that the current protocol is the highest enabled version
* (according to s->ctx->method, as version negotiation may have changed
* s->method).
*/
- if (s->version == s->ctx->method->version)
+ if (s->version == sctx->method->version)
return 1;
/*
* Apparently we're using a version-flexible SSL_METHOD (not at its
* highest protocol version).
*/
- if (s->ctx->method->version == TLS_method()->version)
+ if (sctx->method->version == TLS_method()->version)
table = tls_version_table;
- else if (s->ctx->method->version == DTLS_method()->version)
+ else if (sctx->method->version == DTLS_method()->version)
table = dtls_version_table;
else {
/* Unexpected state; fail closed. */
return 1;
}
-static void check_for_downgrade(SSL *s, int vers, DOWNGRADE *dgrd)
+static void check_for_downgrade(SSL_CONNECTION *s, int vers, DOWNGRADE *dgrd)
{
if (vers == TLS1_2_VERSION
&& ssl_version_supported(s, TLS1_3_VERSION, NULL)) {
*dgrd = DOWNGRADE_TO_1_2;
- } else if (!SSL_IS_DTLS(s)
+ } else if (!SSL_CONNECTION_IS_DTLS(s)
&& vers < TLS1_2_VERSION
/*
* We need to ensure that a server that disables TLSv1.2
*
* Returns 0 on success or an SSL error reason number on failure.
*/
-int ssl_choose_server_version(SSL *s, CLIENTHELLO_MSG *hello, DOWNGRADE *dgrd)
+int ssl_choose_server_version(SSL_CONNECTION *s, CLIENTHELLO_MSG *hello,
+ DOWNGRADE *dgrd)
{
/*-
* With version-flexible methods we have an initial state with:
* So we detect version-flexible methods via the method version, not the
* handle version.
*/
- int server_version = s->method->version;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
+ int server_version = ssl->method->version;
int client_version = hello->legacy_version;
const version_info *vent;
const version_info *table;
switch (server_version) {
default:
- if (!SSL_IS_TLS13(s)) {
+ if (!SSL_CONNECTION_IS_TLS13(s)) {
if (version_cmp(s, client_version, s->version) < 0)
return SSL_R_WRONG_SSL_VERSION;
*dgrd = DOWNGRADE_NONE;
if (!suppversions->present && s->hello_retry_request != SSL_HRR_NONE)
return SSL_R_UNSUPPORTED_PROTOCOL;
- if (suppversions->present && !SSL_IS_DTLS(s)) {
+ if (suppversions->present && !SSL_CONNECTION_IS_DTLS(s)) {
unsigned int candidate_vers = 0;
unsigned int best_vers = 0;
const SSL_METHOD *best_method = NULL;
}
check_for_downgrade(s, best_vers, dgrd);
s->version = best_vers;
- s->method = best_method;
+ ssl->method = best_method;
return 0;
}
return SSL_R_UNSUPPORTED_PROTOCOL;
if (ssl_method_error(s, method) == 0) {
check_for_downgrade(s, vent->version, dgrd);
s->version = vent->version;
- s->method = method;
+ ssl->method = method;
return 0;
}
disabled = 1;
*
* Returns 1 on success or 0 on error.
*/
-int ssl_choose_client_version(SSL *s, int version, RAW_EXTENSION *extensions)
+int ssl_choose_client_version(SSL_CONNECTION *s, int version,
+ RAW_EXTENSION *extensions)
{
const version_info *vent;
const version_info *table;
int ret, ver_min, ver_max, real_max, origv;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
origv = s->version;
s->version = version;
return 0;
}
- switch (s->method->version) {
+ switch (ssl->method->version) {
default:
- if (s->version != s->method->version) {
+ if (s->version != ssl->method->version) {
s->version = origv;
SSLfatal(s, SSL_AD_PROTOCOL_VERSION, SSL_R_WRONG_SSL_VERSION);
return 0;
SSLfatal(s, SSL_AD_PROTOCOL_VERSION, ret);
return 0;
}
- if (SSL_IS_DTLS(s) ? DTLS_VERSION_LT(s->version, ver_min)
- : s->version < ver_min) {
+ if (SSL_CONNECTION_IS_DTLS(s) ? DTLS_VERSION_LT(s->version, ver_min)
+ : s->version < ver_min) {
s->version = origv;
SSLfatal(s, SSL_AD_PROTOCOL_VERSION, SSL_R_UNSUPPORTED_PROTOCOL);
return 0;
- } else if (SSL_IS_DTLS(s) ? DTLS_VERSION_GT(s->version, ver_max)
- : s->version > ver_max) {
+ } else if (SSL_CONNECTION_IS_DTLS(s) ? DTLS_VERSION_GT(s->version, ver_max)
+ : s->version > ver_max) {
s->version = origv;
SSLfatal(s, SSL_AD_PROTOCOL_VERSION, SSL_R_UNSUPPORTED_PROTOCOL);
return 0;
SSL_R_INAPPROPRIATE_FALLBACK);
return 0;
}
- } else if (!SSL_IS_DTLS(s)
+ } else if (!SSL_CONNECTION_IS_DTLS(s)
&& s->version < TLS1_2_VERSION
&& real_max > s->version) {
if (memcmp(tls11downgrade,
if (vent->cmeth == NULL || s->version != vent->version)
continue;
- s->method = vent->cmeth();
+ ssl->method = vent->cmeth();
return 1;
}
* Returns 0 on success or an SSL error reason number on failure. On failure
* min_version and max_version will also be set to 0.
*/
-int ssl_get_min_max_version(const SSL *s, int *min_version, int *max_version,
- int *real_max)
+int ssl_get_min_max_version(const SSL_CONNECTION *s, int *min_version,
+ int *max_version, int *real_max)
{
int version, tmp_real_max;
int hole;
const SSL_METHOD *method;
const version_info *table;
const version_info *vent;
+ const SSL *ssl = SSL_CONNECTION_GET_SSL(s);
- switch (s->method->version) {
+ switch (ssl->method->version) {
default:
/*
* If this SSL handle is not from a version flexible method we don't
*
* Returns 0 on success or an SSL error reason number on failure.
*/
-int ssl_set_client_hello_version(SSL *s)
+int ssl_set_client_hello_version(SSL_CONNECTION *s)
{
int ver_min, ver_max, ret;
s->version = ver_max;
/* TLS1.3 always uses TLS1.2 in the legacy_version field */
- if (!SSL_IS_DTLS(s) && ver_max > TLS1_2_VERSION)
+ if (!SSL_CONNECTION_IS_DTLS(s) && ver_max > TLS1_2_VERSION)
ver_max = TLS1_2_VERSION;
s->client_version = ver_max;
* used. Returns 1 if the group is in the list (and allowed if |checkallow| is
* 1) or 0 otherwise.
*/
-int check_in_list(SSL *s, uint16_t group_id, const uint16_t *groups,
+int check_in_list(SSL_CONNECTION *s, uint16_t group_id, const uint16_t *groups,
size_t num_groups, int checkallow)
{
size_t i;
}
/* Replace ClientHello1 in the transcript hash with a synthetic message */
-int create_synthetic_message_hash(SSL *s, const unsigned char *hashval,
+int create_synthetic_message_hash(SSL_CONNECTION *s,
+ const unsigned char *hashval,
size_t hashlen, const unsigned char *hrr,
size_t hrrlen)
{
return X509_NAME_cmp(*a, *b);
}
-int parse_ca_names(SSL *s, PACKET *pkt)
+int parse_ca_names(SSL_CONNECTION *s, PACKET *pkt)
{
STACK_OF(X509_NAME) *ca_sk = sk_X509_NAME_new(ca_dn_cmp);
X509_NAME *xn = NULL;
return 0;
}
-const STACK_OF(X509_NAME) *get_ca_names(SSL *s)
+const STACK_OF(X509_NAME) *get_ca_names(SSL_CONNECTION *s)
{
const STACK_OF(X509_NAME) *ca_sk = NULL;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
if (s->server) {
- ca_sk = SSL_get_client_CA_list(s);
+ ca_sk = SSL_get_client_CA_list(ssl);
if (ca_sk != NULL && sk_X509_NAME_num(ca_sk) == 0)
ca_sk = NULL;
}
if (ca_sk == NULL)
- ca_sk = SSL_get0_CA_list(s);
+ ca_sk = SSL_get0_CA_list(ssl);
return ca_sk;
}
-int construct_ca_names(SSL *s, const STACK_OF(X509_NAME) *ca_sk, WPACKET *pkt)
+int construct_ca_names(SSL_CONNECTION *s, const STACK_OF(X509_NAME) *ca_sk,
+ WPACKET *pkt)
{
/* Start sub-packet for client CA list */
if (!WPACKET_start_sub_packet_u16(pkt)) {
}
/* Create a buffer containing data to be signed for server key exchange */
-size_t construct_key_exchange_tbs(SSL *s, unsigned char **ptbs,
+size_t construct_key_exchange_tbs(SSL_CONNECTION *s, unsigned char **ptbs,
const void *param, size_t paramlen)
{
size_t tbslen = 2 * SSL3_RANDOM_SIZE + paramlen;
* Saves the current handshake digest for Post-Handshake Auth,
* Done after ClientFinished is processed, done exactly once
*/
-int tls13_save_handshake_digest_for_pha(SSL *s)
+int tls13_save_handshake_digest_for_pha(SSL_CONNECTION *s)
{
if (s->pha_dgst == NULL) {
if (!ssl3_digest_cached_records(s, 1))
* Restores the Post-Handshake Auth handshake digest
* Done just before sending/processing the Cert Request
*/
-int tls13_restore_handshake_digest_for_pha(SSL *s)
+int tls13_restore_handshake_digest_for_pha(SSL_CONNECTION *s)
{
if (s->pha_dgst == NULL) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
MSG_PROCESS_CONTINUE_READING
} MSG_PROCESS_RETURN;
-typedef int (*confunc_f) (SSL *s, WPACKET *pkt);
+typedef int (*confunc_f) (SSL_CONNECTION *s, WPACKET *pkt);
-int ssl3_take_mac(SSL *s);
-int check_in_list(SSL *s, uint16_t group_id, const uint16_t *groups,
+int ssl3_take_mac(SSL_CONNECTION *s);
+int check_in_list(SSL_CONNECTION *s, uint16_t group_id, const uint16_t *groups,
size_t num_groups, int checkallow);
-int create_synthetic_message_hash(SSL *s, const unsigned char *hashval,
+int create_synthetic_message_hash(SSL_CONNECTION *s,
+ const unsigned char *hashval,
size_t hashlen, const unsigned char *hrr,
size_t hrrlen);
-int parse_ca_names(SSL *s, PACKET *pkt);
-const STACK_OF(X509_NAME) *get_ca_names(SSL *s);
-int construct_ca_names(SSL *s, const STACK_OF(X509_NAME) *ca_sk, WPACKET *pkt);
-size_t construct_key_exchange_tbs(SSL *s, unsigned char **ptbs,
+int parse_ca_names(SSL_CONNECTION *s, PACKET *pkt);
+const STACK_OF(X509_NAME) *get_ca_names(SSL_CONNECTION *s);
+int construct_ca_names(SSL_CONNECTION *s, const STACK_OF(X509_NAME) *ca_sk,
+ WPACKET *pkt);
+size_t construct_key_exchange_tbs(SSL_CONNECTION *s, unsigned char **ptbs,
const void *param, size_t paramlen);
/*
* TLS/DTLS client state machine functions
*/
-int ossl_statem_client_read_transition(SSL *s, int mt);
-WRITE_TRAN ossl_statem_client_write_transition(SSL *s);
-WORK_STATE ossl_statem_client_pre_work(SSL *s, WORK_STATE wst);
-WORK_STATE ossl_statem_client_post_work(SSL *s, WORK_STATE wst);
-int ossl_statem_client_construct_message(SSL *s,
+int ossl_statem_client_read_transition(SSL_CONNECTION *s, int mt);
+WRITE_TRAN ossl_statem_client_write_transition(SSL_CONNECTION *s);
+WORK_STATE ossl_statem_client_pre_work(SSL_CONNECTION *s, WORK_STATE wst);
+WORK_STATE ossl_statem_client_post_work(SSL_CONNECTION *s, WORK_STATE wst);
+int ossl_statem_client_construct_message(SSL_CONNECTION *s,
confunc_f *confunc, int *mt);
-size_t ossl_statem_client_max_message_size(SSL *s);
-MSG_PROCESS_RETURN ossl_statem_client_process_message(SSL *s, PACKET *pkt);
-WORK_STATE ossl_statem_client_post_process_message(SSL *s, WORK_STATE wst);
+size_t ossl_statem_client_max_message_size(SSL_CONNECTION *s);
+MSG_PROCESS_RETURN ossl_statem_client_process_message(SSL_CONNECTION *s,
+ PACKET *pkt);
+WORK_STATE ossl_statem_client_post_process_message(SSL_CONNECTION *s,
+ WORK_STATE wst);
/*
* TLS/DTLS server state machine functions
*/
-int ossl_statem_server_read_transition(SSL *s, int mt);
-WRITE_TRAN ossl_statem_server_write_transition(SSL *s);
-WORK_STATE ossl_statem_server_pre_work(SSL *s, WORK_STATE wst);
-WORK_STATE ossl_statem_server_post_work(SSL *s, WORK_STATE wst);
-int ossl_statem_server_construct_message(SSL *s,
+int ossl_statem_server_read_transition(SSL_CONNECTION *s, int mt);
+WRITE_TRAN ossl_statem_server_write_transition(SSL_CONNECTION *s);
+WORK_STATE ossl_statem_server_pre_work(SSL_CONNECTION *s, WORK_STATE wst);
+WORK_STATE ossl_statem_server_post_work(SSL_CONNECTION *s, WORK_STATE wst);
+int ossl_statem_server_construct_message(SSL_CONNECTION *s,
confunc_f *confunc,int *mt);
-size_t ossl_statem_server_max_message_size(SSL *s);
-MSG_PROCESS_RETURN ossl_statem_server_process_message(SSL *s, PACKET *pkt);
-WORK_STATE ossl_statem_server_post_process_message(SSL *s, WORK_STATE wst);
+size_t ossl_statem_server_max_message_size(SSL_CONNECTION *s);
+MSG_PROCESS_RETURN ossl_statem_server_process_message(SSL_CONNECTION *s,
+ PACKET *pkt);
+WORK_STATE ossl_statem_server_post_process_message(SSL_CONNECTION *s,
+ WORK_STATE wst);
/* Functions for getting new message data */
-__owur int tls_get_message_header(SSL *s, int *mt);
-__owur int tls_get_message_body(SSL *s, size_t *len);
-__owur int dtls_get_message(SSL *s, int *mt);
-__owur int dtls_get_message_body(SSL *s, size_t *len);
+__owur int tls_get_message_header(SSL_CONNECTION *s, int *mt);
+__owur int tls_get_message_body(SSL_CONNECTION *s, size_t *len);
+__owur int dtls_get_message(SSL_CONNECTION *s, int *mt);
+__owur int dtls_get_message_body(SSL_CONNECTION *s, size_t *len);
/* Message construction and processing functions */
-__owur int tls_process_initial_server_flight(SSL *s);
-__owur MSG_PROCESS_RETURN tls_process_change_cipher_spec(SSL *s, PACKET *pkt);
-__owur MSG_PROCESS_RETURN tls_process_finished(SSL *s, PACKET *pkt);
-__owur int tls_construct_change_cipher_spec(SSL *s, WPACKET *pkt);
-__owur int dtls_construct_change_cipher_spec(SSL *s, WPACKET *pkt);
+__owur int tls_process_initial_server_flight(SSL_CONNECTION *s);
+__owur MSG_PROCESS_RETURN tls_process_change_cipher_spec(SSL_CONNECTION *s,
+ PACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_finished(SSL_CONNECTION *s, PACKET *pkt);
+__owur int tls_construct_change_cipher_spec(SSL_CONNECTION *s, WPACKET *pkt);
+__owur int dtls_construct_change_cipher_spec(SSL_CONNECTION *s, WPACKET *pkt);
-__owur int tls_construct_finished(SSL *s, WPACKET *pkt);
-__owur int tls_construct_key_update(SSL *s, WPACKET *pkt);
-__owur MSG_PROCESS_RETURN tls_process_key_update(SSL *s, PACKET *pkt);
-__owur WORK_STATE tls_finish_handshake(SSL *s, WORK_STATE wst, int clearbufs,
- int stop);
-__owur WORK_STATE dtls_wait_for_dry(SSL *s);
+__owur int tls_construct_finished(SSL_CONNECTION *s, WPACKET *pkt);
+__owur int tls_construct_key_update(SSL_CONNECTION *s, WPACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_key_update(SSL_CONNECTION *s,
+ PACKET *pkt);
+__owur WORK_STATE tls_finish_handshake(SSL_CONNECTION *s, WORK_STATE wst,
+ int clearbufs, int stop);
+__owur WORK_STATE dtls_wait_for_dry(SSL_CONNECTION *s);
/* some client-only functions */
-__owur int tls_construct_client_hello(SSL *s, WPACKET *pkt);
-__owur MSG_PROCESS_RETURN tls_process_server_hello(SSL *s, PACKET *pkt);
-__owur MSG_PROCESS_RETURN tls_process_certificate_request(SSL *s, PACKET *pkt);
-__owur MSG_PROCESS_RETURN tls_process_new_session_ticket(SSL *s, PACKET *pkt);
-__owur int tls_process_cert_status_body(SSL *s, PACKET *pkt);
-__owur MSG_PROCESS_RETURN tls_process_cert_status(SSL *s, PACKET *pkt);
-__owur MSG_PROCESS_RETURN tls_process_server_done(SSL *s, PACKET *pkt);
-__owur int tls_construct_cert_verify(SSL *s, WPACKET *pkt);
-__owur WORK_STATE tls_prepare_client_certificate(SSL *s, WORK_STATE wst);
-__owur int tls_construct_client_certificate(SSL *s, WPACKET *pkt);
-__owur int ssl_do_client_cert_cb(SSL *s, X509 **px509, EVP_PKEY **ppkey);
-__owur int tls_construct_client_key_exchange(SSL *s, WPACKET *pkt);
-__owur int tls_client_key_exchange_post_work(SSL *s);
-__owur int tls_construct_cert_status_body(SSL *s, WPACKET *pkt);
-__owur int tls_construct_cert_status(SSL *s, WPACKET *pkt);
-__owur MSG_PROCESS_RETURN tls_process_key_exchange(SSL *s, PACKET *pkt);
-__owur MSG_PROCESS_RETURN tls_process_server_certificate(SSL *s, PACKET *pkt);
-__owur WORK_STATE tls_post_process_server_certificate(SSL *s, WORK_STATE wst);
-__owur int ssl3_check_cert_and_algorithm(SSL *s);
+__owur int tls_construct_client_hello(SSL_CONNECTION *s, WPACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_server_hello(SSL_CONNECTION *s,
+ PACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_certificate_request(SSL_CONNECTION *s,
+ PACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_new_session_ticket(SSL_CONNECTION *s,
+ PACKET *pkt);
+__owur int tls_process_cert_status_body(SSL_CONNECTION *s, PACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_cert_status(SSL_CONNECTION *s,
+ PACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_server_done(SSL_CONNECTION *s,
+ PACKET *pkt);
+__owur int tls_construct_cert_verify(SSL_CONNECTION *s, WPACKET *pkt);
+__owur WORK_STATE tls_prepare_client_certificate(SSL_CONNECTION *s,
+ WORK_STATE wst);
+__owur int tls_construct_client_certificate(SSL_CONNECTION *s, WPACKET *pkt);
+__owur int ssl_do_client_cert_cb(SSL_CONNECTION *s, X509 **px509,
+ EVP_PKEY **ppkey);
+__owur int tls_construct_client_key_exchange(SSL_CONNECTION *s, WPACKET *pkt);
+__owur int tls_client_key_exchange_post_work(SSL_CONNECTION *s);
+__owur int tls_construct_cert_status_body(SSL_CONNECTION *s, WPACKET *pkt);
+__owur int tls_construct_cert_status(SSL_CONNECTION *s, WPACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_key_exchange(SSL_CONNECTION *s,
+ PACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_server_certificate(SSL_CONNECTION *s,
+ PACKET *pkt);
+__owur WORK_STATE tls_post_process_server_certificate(SSL_CONNECTION *s,
+ WORK_STATE wst);
+__owur int ssl3_check_cert_and_algorithm(SSL_CONNECTION *s);
#ifndef OPENSSL_NO_NEXTPROTONEG
-__owur int tls_construct_next_proto(SSL *s, WPACKET *pkt);
+__owur int tls_construct_next_proto(SSL_CONNECTION *s, WPACKET *pkt);
#endif
-__owur MSG_PROCESS_RETURN tls_process_hello_req(SSL *s, PACKET *pkt);
-__owur MSG_PROCESS_RETURN dtls_process_hello_verify(SSL *s, PACKET *pkt);
-__owur int tls_construct_end_of_early_data(SSL *s, WPACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_hello_req(SSL_CONNECTION *s, PACKET *pkt);
+__owur MSG_PROCESS_RETURN dtls_process_hello_verify(SSL_CONNECTION *s, PACKET *pkt);
+__owur int tls_construct_end_of_early_data(SSL_CONNECTION *s, WPACKET *pkt);
/* some server-only functions */
-__owur MSG_PROCESS_RETURN tls_process_client_hello(SSL *s, PACKET *pkt);
-__owur WORK_STATE tls_post_process_client_hello(SSL *s, WORK_STATE wst);
-__owur int tls_construct_server_hello(SSL *s, WPACKET *pkt);
-__owur int dtls_construct_hello_verify_request(SSL *s, WPACKET *pkt);
-__owur int tls_construct_server_certificate(SSL *s, WPACKET *pkt);
-__owur int tls_construct_server_key_exchange(SSL *s, WPACKET *pkt);
-__owur int tls_construct_certificate_request(SSL *s, WPACKET *pkt);
-__owur int tls_construct_server_done(SSL *s, WPACKET *pkt);
-__owur MSG_PROCESS_RETURN tls_process_client_certificate(SSL *s, PACKET *pkt);
-__owur MSG_PROCESS_RETURN tls_process_client_key_exchange(SSL *s, PACKET *pkt);
-__owur WORK_STATE tls_post_process_client_key_exchange(SSL *s, WORK_STATE wst);
-__owur MSG_PROCESS_RETURN tls_process_cert_verify(SSL *s, PACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_client_hello(SSL_CONNECTION *s,
+ PACKET *pkt);
+__owur WORK_STATE tls_post_process_client_hello(SSL_CONNECTION *s,
+ WORK_STATE wst);
+__owur int tls_construct_server_hello(SSL_CONNECTION *s, WPACKET *pkt);
+__owur int dtls_construct_hello_verify_request(SSL_CONNECTION *s, WPACKET *pkt);
+__owur int tls_construct_server_certificate(SSL_CONNECTION *s, WPACKET *pkt);
+__owur int tls_construct_server_key_exchange(SSL_CONNECTION *s, WPACKET *pkt);
+__owur int tls_construct_certificate_request(SSL_CONNECTION *s, WPACKET *pkt);
+__owur int tls_construct_server_done(SSL_CONNECTION *s, WPACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_client_certificate(SSL_CONNECTION *s,
+ PACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_client_key_exchange(SSL_CONNECTION *s,
+ PACKET *pkt);
+__owur WORK_STATE tls_post_process_client_key_exchange(SSL_CONNECTION *s,
+ WORK_STATE wst);
+__owur MSG_PROCESS_RETURN tls_process_cert_verify(SSL_CONNECTION *s,
+ PACKET *pkt);
#ifndef OPENSSL_NO_NEXTPROTONEG
-__owur MSG_PROCESS_RETURN tls_process_next_proto(SSL *s, PACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_next_proto(SSL_CONNECTION *s,
+ PACKET *pkt);
#endif
-__owur int tls_construct_new_session_ticket(SSL *s, WPACKET *pkt);
-MSG_PROCESS_RETURN tls_process_end_of_early_data(SSL *s, PACKET *pkt);
+__owur int tls_construct_new_session_ticket(SSL_CONNECTION *s, WPACKET *pkt);
+MSG_PROCESS_RETURN tls_process_end_of_early_data(SSL_CONNECTION *s,
+ PACKET *pkt);
#ifndef OPENSSL_NO_GOST
/* These functions are used in GOST18 CKE, both for client and server */
-int ossl_gost18_cke_cipher_nid(const SSL *s);
-int ossl_gost_ukm(const SSL *s, unsigned char *dgst_buf);
+int ossl_gost18_cke_cipher_nid(const SSL_CONNECTION *s);
+int ossl_gost_ukm(const SSL_CONNECTION *s, unsigned char *dgst_buf);
#endif
/* Extension processing */
EXT_RETURN_NOT_SENT
} EXT_RETURN;
-__owur int tls_validate_all_contexts(SSL *s, unsigned int thisctx,
+__owur int tls_validate_all_contexts(SSL_CONNECTION *s, unsigned int thisctx,
RAW_EXTENSION *exts);
-__owur int extension_is_relevant(SSL *s, unsigned int extctx,
+__owur int extension_is_relevant(SSL_CONNECTION *s, unsigned int extctx,
unsigned int thisctx);
-__owur int tls_collect_extensions(SSL *s, PACKET *packet, unsigned int context,
+__owur int tls_collect_extensions(SSL_CONNECTION *s, PACKET *packet,
+ unsigned int context,
RAW_EXTENSION **res, size_t *len, int init);
-__owur int tls_parse_extension(SSL *s, TLSEXT_INDEX idx, int context,
+__owur int tls_parse_extension(SSL_CONNECTION *s, TLSEXT_INDEX idx, int context,
RAW_EXTENSION *exts, X509 *x, size_t chainidx);
-__owur int tls_parse_all_extensions(SSL *s, int context, RAW_EXTENSION *exts,
+__owur int tls_parse_all_extensions(SSL_CONNECTION *s, int context,
+ RAW_EXTENSION *exts,
X509 *x, size_t chainidx, int fin);
-__owur int should_add_extension(SSL *s, unsigned int extctx,
+__owur int should_add_extension(SSL_CONNECTION *s, unsigned int extctx,
unsigned int thisctx, int max_version);
-__owur int tls_construct_extensions(SSL *s, WPACKET *pkt, unsigned int context,
+__owur int tls_construct_extensions(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
-__owur int tls_psk_do_binder(SSL *s, const EVP_MD *md,
+__owur int tls_psk_do_binder(SSL_CONNECTION *s, const EVP_MD *md,
const unsigned char *msgstart,
size_t binderoffset, const unsigned char *binderin,
unsigned char *binderout,
SSL_SESSION *sess, int sign, int external);
/* Server Extension processing */
-int tls_parse_ctos_renegotiate(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_ctos_renegotiate(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
-int tls_parse_ctos_server_name(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_ctos_server_name(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
-int tls_parse_ctos_maxfragmentlen(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_ctos_maxfragmentlen(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
#ifndef OPENSSL_NO_SRP
-int tls_parse_ctos_srp(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx);
+int tls_parse_ctos_srp(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
+ X509 *x, size_t chainidx);
#endif
-int tls_parse_ctos_early_data(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_ctos_early_data(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
-int tls_parse_ctos_ec_pt_formats(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_ctos_ec_pt_formats(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
-int tls_parse_ctos_supported_groups(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_ctos_supported_groups(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidxl);
-int tls_parse_ctos_session_ticket(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_ctos_session_ticket(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
-int tls_parse_ctos_sig_algs_cert(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_ctos_sig_algs_cert(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
-int tls_parse_ctos_sig_algs(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx);
+int tls_parse_ctos_sig_algs(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context, X509 *x, size_t chainidx);
#ifndef OPENSSL_NO_OCSP
-int tls_parse_ctos_status_request(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_ctos_status_request(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
#endif
#ifndef OPENSSL_NO_NEXTPROTONEG
-int tls_parse_ctos_npn(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx);
+int tls_parse_ctos_npn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
+ X509 *x, size_t chainidx);
#endif
-int tls_parse_ctos_alpn(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx);
+int tls_parse_ctos_alpn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
+ X509 *x, size_t chainidx);
#ifndef OPENSSL_NO_SRTP
-int tls_parse_ctos_use_srtp(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx);
+int tls_parse_ctos_use_srtp(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context, X509 *x, size_t chainidx);
#endif
-int tls_parse_ctos_etm(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx);
-int tls_parse_ctos_key_share(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx);
-int tls_parse_ctos_cookie(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx);
-int tls_parse_ctos_ems(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx);
-int tls_parse_ctos_psk_kex_modes(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_ctos_etm(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
+ X509 *x, size_t chainidx);
+int tls_parse_ctos_key_share(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context, X509 *x, size_t chainidx);
+int tls_parse_ctos_cookie(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
+ X509 *x, size_t chainidx);
+int tls_parse_ctos_ems(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
+ X509 *x, size_t chainidx);
+int tls_parse_ctos_psk_kex_modes(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
-int tls_parse_ctos_psk(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx);
-int tls_parse_ctos_post_handshake_auth(SSL *, PACKET *pkt, unsigned int context,
+int tls_parse_ctos_psk(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
+ X509 *x, size_t chainidx);
+int tls_parse_ctos_post_handshake_auth(SSL_CONNECTION *, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
-EXT_RETURN tls_construct_stoc_renegotiate(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_stoc_renegotiate(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx);
-EXT_RETURN tls_construct_stoc_server_name(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_stoc_server_name(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx);
-EXT_RETURN tls_construct_stoc_early_data(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_stoc_early_data(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx);
-EXT_RETURN tls_construct_stoc_maxfragmentlen(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_stoc_maxfragmentlen(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx);
-EXT_RETURN tls_construct_stoc_ec_pt_formats(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_stoc_ec_pt_formats(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx);
-EXT_RETURN tls_construct_stoc_supported_groups(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_stoc_supported_groups(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx);
-EXT_RETURN tls_construct_stoc_session_ticket(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_stoc_session_ticket(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx);
#ifndef OPENSSL_NO_OCSP
-EXT_RETURN tls_construct_stoc_status_request(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_stoc_status_request(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx);
#endif
#ifndef OPENSSL_NO_NEXTPROTONEG
-EXT_RETURN tls_construct_stoc_next_proto_neg(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_stoc_next_proto_neg(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx);
#endif
-EXT_RETURN tls_construct_stoc_alpn(SSL *s, WPACKET *pkt, unsigned int context,
+EXT_RETURN tls_construct_stoc_alpn(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
#ifndef OPENSSL_NO_SRTP
-EXT_RETURN tls_construct_stoc_use_srtp(SSL *s, WPACKET *pkt, unsigned int context,
- X509 *x, size_t chainidx);
+EXT_RETURN tls_construct_stoc_use_srtp(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
+ X509 *x, size_t chainidx);
#endif
-EXT_RETURN tls_construct_stoc_etm(SSL *s, WPACKET *pkt, unsigned int context,
+EXT_RETURN tls_construct_stoc_etm(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
-EXT_RETURN tls_construct_stoc_ems(SSL *s, WPACKET *pkt, unsigned int context,
+EXT_RETURN tls_construct_stoc_ems(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
-EXT_RETURN tls_construct_stoc_supported_versions(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_stoc_supported_versions(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx);
-EXT_RETURN tls_construct_stoc_key_share(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_stoc_key_share(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx);
-EXT_RETURN tls_construct_stoc_cookie(SSL *s, WPACKET *pkt, unsigned int context,
+EXT_RETURN tls_construct_stoc_cookie(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
/*
* Not in public headers as this is not an official extension. Only used when
* SSL_OP_CRYPTOPRO_TLSEXT_BUG is set.
*/
#define TLSEXT_TYPE_cryptopro_bug 0xfde8
-EXT_RETURN tls_construct_stoc_cryptopro_bug(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_stoc_cryptopro_bug(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx);
-EXT_RETURN tls_construct_stoc_psk(SSL *s, WPACKET *pkt, unsigned int context,
+EXT_RETURN tls_construct_stoc_psk(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
/* Client Extension processing */
-EXT_RETURN tls_construct_ctos_renegotiate(SSL *s, WPACKET *pkt, unsigned int context,
- X509 *x, size_t chainidx);
-EXT_RETURN tls_construct_ctos_server_name(SSL *s, WPACKET *pkt, unsigned int context,
- X509 *x, size_t chainidx);
-EXT_RETURN tls_construct_ctos_maxfragmentlen(SSL *s, WPACKET *pkt, unsigned int context,
+EXT_RETURN tls_construct_ctos_renegotiate(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
+ X509 *x, size_t chainidx);
+EXT_RETURN tls_construct_ctos_server_name(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
+ X509 *x, size_t chainidx);
+EXT_RETURN tls_construct_ctos_maxfragmentlen(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
#ifndef OPENSSL_NO_SRP
-EXT_RETURN tls_construct_ctos_srp(SSL *s, WPACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx);
+EXT_RETURN tls_construct_ctos_srp(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context, X509 *x,
+ size_t chainidx);
#endif
-EXT_RETURN tls_construct_ctos_ec_pt_formats(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_ctos_ec_pt_formats(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx);
-EXT_RETURN tls_construct_ctos_supported_groups(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_ctos_supported_groups(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx);
-EXT_RETURN tls_construct_ctos_early_data(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_ctos_early_data(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx);
-EXT_RETURN tls_construct_ctos_session_ticket(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_ctos_session_ticket(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx);
-EXT_RETURN tls_construct_ctos_sig_algs(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_ctos_sig_algs(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx);
#ifndef OPENSSL_NO_OCSP
-EXT_RETURN tls_construct_ctos_status_request(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_ctos_status_request(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx);
#endif
#ifndef OPENSSL_NO_NEXTPROTONEG
-EXT_RETURN tls_construct_ctos_npn(SSL *s, WPACKET *pkt, unsigned int context,
+EXT_RETURN tls_construct_ctos_npn(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
#endif
-EXT_RETURN tls_construct_ctos_alpn(SSL *s, WPACKET *pkt, unsigned int context,
+EXT_RETURN tls_construct_ctos_alpn(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
#ifndef OPENSSL_NO_SRTP
-EXT_RETURN tls_construct_ctos_use_srtp(SSL *s, WPACKET *pkt, unsigned int context,
+EXT_RETURN tls_construct_ctos_use_srtp(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
#endif
-EXT_RETURN tls_construct_ctos_etm(SSL *s, WPACKET *pkt, unsigned int context,
+EXT_RETURN tls_construct_ctos_etm(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
#ifndef OPENSSL_NO_CT
-EXT_RETURN tls_construct_ctos_sct(SSL *s, WPACKET *pkt, unsigned int context,
+EXT_RETURN tls_construct_ctos_sct(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
#endif
-EXT_RETURN tls_construct_ctos_ems(SSL *s, WPACKET *pkt, unsigned int context,
+EXT_RETURN tls_construct_ctos_ems(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
-EXT_RETURN tls_construct_ctos_supported_versions(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_ctos_supported_versions(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx);
-EXT_RETURN tls_construct_ctos_key_share(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_ctos_key_share(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx);
-EXT_RETURN tls_construct_ctos_psk_kex_modes(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_ctos_psk_kex_modes(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx);
-EXT_RETURN tls_construct_ctos_cookie(SSL *s, WPACKET *pkt, unsigned int context,
+EXT_RETURN tls_construct_ctos_cookie(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
-EXT_RETURN tls_construct_ctos_padding(SSL *s, WPACKET *pkt,
+EXT_RETURN tls_construct_ctos_padding(SSL_CONNECTION *s, WPACKET *pkt,
unsigned int context, X509 *x,
size_t chainidx);
-EXT_RETURN tls_construct_ctos_psk(SSL *s, WPACKET *pkt, unsigned int context,
+EXT_RETURN tls_construct_ctos_psk(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
-EXT_RETURN tls_construct_ctos_post_handshake_auth(SSL *s, WPACKET *pkt, unsigned int context,
+EXT_RETURN tls_construct_ctos_post_handshake_auth(SSL_CONNECTION *s, WPACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
-int tls_parse_stoc_renegotiate(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_stoc_renegotiate(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
-int tls_parse_stoc_server_name(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_stoc_server_name(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
-int tls_parse_stoc_early_data(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_stoc_early_data(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
-int tls_parse_stoc_maxfragmentlen(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_stoc_maxfragmentlen(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
-int tls_parse_stoc_ec_pt_formats(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_stoc_ec_pt_formats(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
-int tls_parse_stoc_session_ticket(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_stoc_session_ticket(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
#ifndef OPENSSL_NO_OCSP
-int tls_parse_stoc_status_request(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_stoc_status_request(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
#endif
#ifndef OPENSSL_NO_CT
-int tls_parse_stoc_sct(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx);
+int tls_parse_stoc_sct(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
+ X509 *x, size_t chainidx);
#endif
#ifndef OPENSSL_NO_NEXTPROTONEG
-int tls_parse_stoc_npn(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx);
+int tls_parse_stoc_npn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
+ X509 *x, size_t chainidx);
#endif
-int tls_parse_stoc_alpn(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx);
+int tls_parse_stoc_alpn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
+ X509 *x, size_t chainidx);
#ifndef OPENSSL_NO_SRTP
-int tls_parse_stoc_use_srtp(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx);
+int tls_parse_stoc_use_srtp(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context, X509 *x, size_t chainidx);
#endif
-int tls_parse_stoc_etm(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx);
-int tls_parse_stoc_ems(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx);
-int tls_parse_stoc_supported_versions(SSL *s, PACKET *pkt, unsigned int context,
+int tls_parse_stoc_etm(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
+ X509 *x, size_t chainidx);
+int tls_parse_stoc_ems(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
+ X509 *x, size_t chainidx);
+int tls_parse_stoc_supported_versions(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context,
X509 *x, size_t chainidx);
-int tls_parse_stoc_key_share(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx);
-int tls_parse_stoc_cookie(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx);
-int tls_parse_stoc_psk(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
- size_t chainidx);
+int tls_parse_stoc_key_share(SSL_CONNECTION *s, PACKET *pkt,
+ unsigned int context, X509 *x, size_t chainidx);
+int tls_parse_stoc_cookie(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
+ X509 *x, size_t chainidx);
+int tls_parse_stoc_psk(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
+ X509 *x, size_t chainidx);
-int tls_handle_alpn(SSL *s);
+int tls_handle_alpn(SSL_CONNECTION *s);
-int tls13_save_handshake_digest_for_pha(SSL *s);
-int tls13_restore_handshake_digest_for_pha(SSL *s);
+int tls13_save_handshake_digest_for_pha(SSL_CONNECTION *s);
+int tls13_restore_handshake_digest_for_pha(SSL_CONNECTION *s);
IMPLEMENT_ASN1_FUNCTIONS(GOST_KX_MESSAGE)
-static int tls_construct_encrypted_extensions(SSL *s, WPACKET *pkt);
+static int tls_construct_encrypted_extensions(SSL_CONNECTION *s, WPACKET *pkt);
/*
* ossl_statem_server13_read_transition() encapsulates the logic for the allowed
* Return values are 1 for success (transition allowed) and 0 on error
* (transition not allowed)
*/
-static int ossl_statem_server13_read_transition(SSL *s, int mt)
+static int ossl_statem_server13_read_transition(SSL_CONNECTION *s, int mt)
{
OSSL_STATEM *st = &s->statem;
* Return values are 1 for success (transition allowed) and 0 on error
* (transition not allowed)
*/
-int ossl_statem_server_read_transition(SSL *s, int mt)
+int ossl_statem_server_read_transition(SSL_CONNECTION *s, int mt)
{
OSSL_STATEM *st = &s->statem;
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
if (!ossl_statem_server13_read_transition(s, mt))
goto err;
return 1;
err:
/* No valid transition found */
- if (SSL_IS_DTLS(s) && mt == SSL3_MT_CHANGE_CIPHER_SPEC) {
+ if (SSL_CONNECTION_IS_DTLS(s) && mt == SSL3_MT_CHANGE_CIPHER_SPEC) {
BIO *rbio;
/*
*/
s->init_num = 0;
s->rwstate = SSL_READING;
- rbio = SSL_get_rbio(s);
+ rbio = SSL_get_rbio(SSL_CONNECTION_GET_SSL(s));
BIO_clear_retry_flags(rbio);
BIO_set_retry_read(rbio);
return 0;
* 1: Yes
* 0: No
*/
-static int send_server_key_exchange(SSL *s)
+static int send_server_key_exchange(SSL_CONNECTION *s)
{
unsigned long alg_k = s->s3.tmp.new_cipher->algorithm_mkey;
* 1: Yes
* 0: No
*/
-int send_certificate_request(SSL *s)
+int send_certificate_request(SSL_CONNECTION *s)
{
if (
/* don't request cert unless asked for it: */
* don't request if post-handshake-only unless doing
* post-handshake in TLSv1.3:
*/
- && (!SSL_IS_TLS13(s) || !(s->verify_mode & SSL_VERIFY_POST_HANDSHAKE)
+ && (!SSL_CONNECTION_IS_TLS13(s)
+ || !(s->verify_mode & SSL_VERIFY_POST_HANDSHAKE)
|| s->post_handshake_auth == SSL_PHA_REQUEST_PENDING)
/*
* if SSL_VERIFY_CLIENT_ONCE is set, don't request cert
* move to next when a TLSv1.3 server is writing messages to be sent to the
* client.
*/
-static WRITE_TRAN ossl_statem_server13_write_transition(SSL *s)
+static WRITE_TRAN ossl_statem_server13_write_transition(SSL_CONNECTION *s)
{
OSSL_STATEM *st = &s->statem;
* ossl_statem_server_write_transition() works out what handshake state to move
* to next when the server is writing messages to be sent to the client.
*/
-WRITE_TRAN ossl_statem_server_write_transition(SSL *s)
+WRITE_TRAN ossl_statem_server_write_transition(SSL_CONNECTION *s)
{
OSSL_STATEM *st = &s->statem;
* to negotiate yet, so we don't take this branch until later
*/
- if (SSL_IS_TLS13(s))
+ if (SSL_CONNECTION_IS_TLS13(s))
return ossl_statem_server13_write_transition(s);
switch (st->hand_state) {
return WRITE_TRAN_CONTINUE;
case TLS_ST_SR_CLNT_HELLO:
- if (SSL_IS_DTLS(s) && !s->d1->cookie_verified
- && (SSL_get_options(s) & SSL_OP_COOKIE_EXCHANGE)) {
+ if (SSL_CONNECTION_IS_DTLS(s) && !s->d1->cookie_verified
+ && (SSL_get_options(SSL_CONNECTION_GET_SSL(s)) & SSL_OP_COOKIE_EXCHANGE)) {
st->hand_state = DTLS_ST_SW_HELLO_VERIFY_REQUEST;
} else if (s->renegotiate == 0 && !SSL_IS_FIRST_HANDSHAKE(s)) {
/* We must have rejected the renegotiation */
* Perform any pre work that needs to be done prior to sending a message from
* the server to the client.
*/
-WORK_STATE ossl_statem_server_pre_work(SSL *s, WORK_STATE wst)
+WORK_STATE ossl_statem_server_pre_work(SSL_CONNECTION *s, WORK_STATE wst)
{
OSSL_STATEM *st = &s->statem;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
switch (st->hand_state) {
default:
case TLS_ST_SW_HELLO_REQ:
s->shutdown = 0;
- if (SSL_IS_DTLS(s))
+ if (SSL_CONNECTION_IS_DTLS(s))
dtls1_clear_sent_buffer(s);
break;
case DTLS_ST_SW_HELLO_VERIFY_REQUEST:
s->shutdown = 0;
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
dtls1_clear_sent_buffer(s);
/* We don't buffer this message so don't use the timer */
st->use_timer = 0;
break;
case TLS_ST_SW_SRVR_HELLO:
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
/*
* Messages we write from now on should be buffered and
* retransmitted if necessary, so we need to use the timer now
case TLS_ST_SW_SRVR_DONE:
#ifndef OPENSSL_NO_SCTP
- if (SSL_IS_DTLS(s) && BIO_dgram_is_sctp(SSL_get_wbio(s))) {
+ if (SSL_CONNECTION_IS_DTLS(s) && BIO_dgram_is_sctp(SSL_get_wbio(ssl))) {
/* Calls SSLfatal() as required */
return dtls_wait_for_dry(s);
}
return WORK_FINISHED_CONTINUE;
case TLS_ST_SW_SESSION_TICKET:
- if (SSL_IS_TLS13(s) && s->sent_tickets == 0
+ if (SSL_CONNECTION_IS_TLS13(s) && s->sent_tickets == 0
&& s->ext.extra_tickets_expected == 0) {
/*
* Actually this is the end of the handshake, but we're going
*/
return tls_finish_handshake(s, wst, 0, 0);
}
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
/*
* We're into the last flight. We don't retransmit the last flight
* unless we need to, so we don't use the timer
break;
case TLS_ST_SW_CHANGE:
- if (SSL_IS_TLS13(s))
+ if (SSL_CONNECTION_IS_TLS13(s))
break;
/* Writes to s->session are only safe for initial handshakes */
if (s->session->cipher == NULL) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return WORK_ERROR;
}
- if (!s->method->ssl3_enc->setup_key_block(s)) {
+ if (!ssl->method->ssl3_enc->setup_key_block(s)) {
/* SSLfatal() already called */
return WORK_ERROR;
}
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
/*
* We're into the last flight. We don't retransmit the last flight
* unless we need to, so we don't use the timer. This might have
* Perform any work that needs to be done after sending a message from the
* server to the client.
*/
-WORK_STATE ossl_statem_server_post_work(SSL *s, WORK_STATE wst)
+WORK_STATE ossl_statem_server_post_work(SSL_CONNECTION *s, WORK_STATE wst)
{
OSSL_STATEM *st = &s->statem;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
s->init_num = 0;
break;
case TLS_ST_SW_SRVR_HELLO:
- if (SSL_IS_TLS13(s) && s->hello_retry_request == SSL_HRR_PENDING) {
+ if (SSL_CONNECTION_IS_TLS13(s)
+ && s->hello_retry_request == SSL_HRR_PENDING) {
if ((s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) == 0
&& statem_flush(s) != 1)
return WORK_MORE_A;
break;
}
#ifndef OPENSSL_NO_SCTP
- if (SSL_IS_DTLS(s) && s->hit) {
+ if (SSL_CONNECTION_IS_DTLS(s) && s->hit) {
unsigned char sctpauthkey[64];
char labelbuffer[sizeof(DTLS1_SCTP_AUTH_LABEL)];
size_t labellen;
if (s->mode & SSL_MODE_DTLS_SCTP_LABEL_LENGTH_BUG)
labellen += 1;
- if (SSL_export_keying_material(s, sctpauthkey,
+ if (SSL_export_keying_material(ssl, sctpauthkey,
sizeof(sctpauthkey), labelbuffer,
labellen, NULL, 0,
0) <= 0) {
return WORK_ERROR;
}
- BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY,
+ BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY,
sizeof(sctpauthkey), sctpauthkey);
}
#endif
- if (!SSL_IS_TLS13(s)
+ if (!SSL_CONNECTION_IS_TLS13(s)
|| ((s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0
&& s->hello_retry_request != SSL_HRR_COMPLETE))
break;
break;
}
- if (SSL_IS_TLS13(s)) {
- if (!s->method->ssl3_enc->setup_key_block(s)
- || !s->method->ssl3_enc->change_cipher_state(s,
+ if (SSL_CONNECTION_IS_TLS13(s)) {
+ if (!ssl->method->ssl3_enc->setup_key_block(s)
+ || !ssl->method->ssl3_enc->change_cipher_state(s,
SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_SERVER_WRITE)) {
/* SSLfatal() already called */
return WORK_ERROR;
}
if (s->ext.early_data != SSL_EARLY_DATA_ACCEPTED
- && !s->method->ssl3_enc->change_cipher_state(s,
+ && !ssl->method->ssl3_enc->change_cipher_state(s,
SSL3_CC_HANDSHAKE |SSL3_CHANGE_CIPHER_SERVER_READ)) {
/* SSLfatal() already called */
return WORK_ERROR;
}
#ifndef OPENSSL_NO_SCTP
- if (SSL_IS_DTLS(s) && !s->hit) {
+ if (SSL_CONNECTION_IS_DTLS(s) && !s->hit) {
/*
* Change to new shared key of SCTP-Auth, will be ignored if
* no SCTP used.
*/
- BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY,
+ BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY,
0, NULL);
}
#endif
- if (!s->method->ssl3_enc->change_cipher_state(s,
- SSL3_CHANGE_CIPHER_SERVER_WRITE))
- {
+ if (!ssl->method->ssl3_enc->change_cipher_state(s,
+ SSL3_CHANGE_CIPHER_SERVER_WRITE)) {
/* SSLfatal() already called */
return WORK_ERROR;
}
- if (SSL_IS_DTLS(s))
+ if (SSL_CONNECTION_IS_DTLS(s))
dtls1_reset_seq_numbers(s, SSL3_CC_WRITE);
break;
if (statem_flush(s) != 1)
return WORK_MORE_A;
#ifndef OPENSSL_NO_SCTP
- if (SSL_IS_DTLS(s) && s->hit) {
+ if (SSL_CONNECTION_IS_DTLS(s) && s->hit) {
/*
* Change to new shared key of SCTP-Auth, will be ignored if
* no SCTP used.
*/
- BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY,
+ BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY,
0, NULL);
}
#endif
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
/* TLS 1.3 gets the secret size from the handshake md */
size_t dummy;
- if (!s->method->ssl3_enc->generate_master_secret(s,
+ if (!ssl->method->ssl3_enc->generate_master_secret(s,
s->master_secret, s->handshake_secret, 0,
&dummy)
- || !s->method->ssl3_enc->change_cipher_state(s,
+ || !ssl->method->ssl3_enc->change_cipher_state(s,
SSL3_CC_APPLICATION | SSL3_CHANGE_CIPHER_SERVER_WRITE))
/* SSLfatal() already called */
return WORK_ERROR;
case TLS_ST_SW_SESSION_TICKET:
clear_sys_error();
- if (SSL_IS_TLS13(s) && statem_flush(s) != 1) {
- if (SSL_get_error(s, 0) == SSL_ERROR_SYSCALL
+ if (SSL_CONNECTION_IS_TLS13(s) && statem_flush(s) != 1) {
+ if (SSL_get_error(ssl, 0) == SSL_ERROR_SYSCALL
&& conn_is_closed()) {
/*
* We ignore connection closed errors in TLSv1.3 when sending a
* 1: Success
* 0: Error
*/
-int ossl_statem_server_construct_message(SSL *s,
+int ossl_statem_server_construct_message(SSL_CONNECTION *s,
confunc_f *confunc, int *mt)
{
OSSL_STATEM *st = &s->statem;
return 0;
case TLS_ST_SW_CHANGE:
- if (SSL_IS_DTLS(s))
+ if (SSL_CONNECTION_IS_DTLS(s))
*confunc = dtls_construct_change_cipher_spec;
else
*confunc = tls_construct_change_cipher_spec;
* Returns the maximum allowed length for the current message that we are
* reading. Excludes the message header.
*/
-size_t ossl_statem_server_max_message_size(SSL *s)
+size_t ossl_statem_server_max_message_size(SSL_CONNECTION *s)
{
OSSL_STATEM *st = &s->statem;
/*
* Process a message that the server has received from the client.
*/
-MSG_PROCESS_RETURN ossl_statem_server_process_message(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN ossl_statem_server_process_message(SSL_CONNECTION *s,
+ PACKET *pkt)
{
OSSL_STATEM *st = &s->statem;
* Perform any further processing required following the receipt of a message
* from the client
*/
-WORK_STATE ossl_statem_server_post_process_message(SSL *s, WORK_STATE wst)
+WORK_STATE ossl_statem_server_post_process_message(SSL_CONNECTION *s,
+ WORK_STATE wst)
{
OSSL_STATEM *st = &s->statem;
#ifndef OPENSSL_NO_SRP
/* Returns 1 on success, 0 for retryable error, -1 for fatal error */
-static int ssl_check_srp_ext_ClientHello(SSL *s)
+static int ssl_check_srp_ext_ClientHello(SSL_CONNECTION *s)
{
int ret;
int al = SSL_AD_UNRECOGNIZED_NAME;
return 1;
}
-int dtls_construct_hello_verify_request(SSL *s, WPACKET *pkt)
+int dtls_construct_hello_verify_request(SSL_CONNECTION *s, WPACKET *pkt)
{
unsigned int cookie_leni;
- if (s->ctx->app_gen_cookie_cb == NULL ||
- s->ctx->app_gen_cookie_cb(s, s->d1->cookie,
- &cookie_leni) == 0 ||
- cookie_leni > DTLS1_COOKIE_LENGTH) {
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
+
+ if (sctx->app_gen_cookie_cb == NULL
+ || sctx->app_gen_cookie_cb(SSL_CONNECTION_GET_SSL(s), s->d1->cookie,
+ &cookie_leni) == 0
+ || cookie_leni > DTLS1_COOKIE_LENGTH) {
SSLfatal(s, SSL_AD_NO_ALERT, SSL_R_COOKIE_GEN_CALLBACK_FAILURE);
return 0;
}
s->d1->cookie_len = cookie_leni;
if (!dtls_raw_hello_verify_request(pkt, s->d1->cookie,
- s->d1->cookie_len)) {
+ s->d1->cookie_len)) {
SSLfatal(s, SSL_AD_NO_ALERT, ERR_R_INTERNAL_ERROR);
return 0;
}
* Sadly we cannot differentiate 10.6, 10.7 and 10.8.4 (which work), from
* 10.8..10.8.3 (which don't work).
*/
-static void ssl_check_for_safari(SSL *s, const CLIENTHELLO_MSG *hello)
+static void ssl_check_for_safari(SSL_CONNECTION *s,
+ const CLIENTHELLO_MSG *hello)
{
static const unsigned char kSafariExtensionsBlock[] = {
0x00, 0x0a, /* elliptic_curves extension */
if (type != TLSEXT_TYPE_server_name)
return;
- ext_len = TLS1_get_client_version(s) >= TLS1_2_VERSION ?
- sizeof(kSafariExtensionsBlock) : kSafariCommonExtensionsLength;
+ ext_len = TLS1_get_client_version(
+ SSL_CONNECTION_GET_SSL(s)) >= TLS1_2_VERSION ?
+ sizeof(kSafariExtensionsBlock) : kSafariCommonExtensionsLength;
s->s3.is_probably_safari = PACKET_equal(&tmppkt, kSafariExtensionsBlock,
ext_len);
((options & SSL_OP_NO_RENEGOTIATION) == 0 \
&& (options & SSL_OP_ALLOW_CLIENT_RENEGOTIATION) != 0)
-MSG_PROCESS_RETURN tls_process_client_hello(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_client_hello(SSL_CONNECTION *s, PACKET *pkt)
{
/* |cookie| will only be initialized for DTLS. */
PACKET session_id, compression, extensions, cookie;
/* Check if this is actually an unexpected renegotiation ClientHello */
if (s->renegotiate == 0 && !SSL_IS_FIRST_HANDSHAKE(s)) {
- if (!ossl_assert(!SSL_IS_TLS13(s))) {
+ if (!ossl_assert(!SSL_CONNECTION_IS_TLS13(s))) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
goto err;
}
goto err;
}
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
if (!PACKET_get_length_prefixed_1(pkt, &cookie)) {
SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
goto err;
* just return since we do not want to allocate any memory yet.
* So check cookie length...
*/
- if (SSL_get_options(s) & SSL_OP_COOKIE_EXCHANGE) {
+ if (SSL_get_options(SSL_CONNECTION_GET_SSL(s)) & SSL_OP_COOKIE_EXCHANGE) {
if (clienthello->dtls_cookie_len == 0) {
OPENSSL_free(clienthello);
return MSG_PROCESS_FINISHED_READING;
return MSG_PROCESS_ERROR;
}
-static int tls_early_post_process_client_hello(SSL *s)
+static int tls_early_post_process_client_hello(SSL_CONNECTION *s)
{
unsigned int j;
int i, al = SSL_AD_INTERNAL_ERROR;
STACK_OF(SSL_CIPHER) *scsvs = NULL;
CLIENTHELLO_MSG *clienthello = s->clienthello;
DOWNGRADE dgrd = DOWNGRADE_NONE;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
/* Finished parsing the ClientHello, now we can start processing it */
/* Give the ClientHello callback a crack at things */
- if (s->ctx->client_hello_cb != NULL) {
+ if (sctx->client_hello_cb != NULL) {
/* A failure in the ClientHello callback terminates the connection. */
- switch (s->ctx->client_hello_cb(s, &al, s->ctx->client_hello_cb_arg)) {
+ switch (sctx->client_hello_cb(ssl, &al, sctx->client_hello_cb_arg)) {
case SSL_CLIENT_HELLO_SUCCESS:
break;
case SSL_CLIENT_HELLO_RETRY:
* Do SSL/TLS version negotiation if applicable. For DTLS we just check
* versions are potentially compatible. Version negotiation comes later.
*/
- if (!SSL_IS_DTLS(s)) {
+ if (!SSL_CONNECTION_IS_DTLS(s)) {
protverr = ssl_choose_server_version(s, clienthello, &dgrd);
- } else if (s->method->version != DTLS_ANY_VERSION &&
+ } else if (ssl->method->version != DTLS_ANY_VERSION &&
DTLS_VERSION_LT((int)clienthello->legacy_version, s->version)) {
protverr = SSL_R_VERSION_TOO_LOW;
} else {
}
/* TLSv1.3 specifies that a ClientHello must end on a record boundary */
- if (SSL_IS_TLS13(s) && RECORD_LAYER_processed_read_pending(&s->rlayer)) {
+ if (SSL_CONNECTION_IS_TLS13(s)
+ && RECORD_LAYER_processed_read_pending(&s->rlayer)) {
SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_NOT_ON_RECORD_BOUNDARY);
goto err;
}
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
/* Empty cookie was already handled above by returning early. */
- if (SSL_get_options(s) & SSL_OP_COOKIE_EXCHANGE) {
- if (s->ctx->app_verify_cookie_cb != NULL) {
- if (s->ctx->app_verify_cookie_cb(s, clienthello->dtls_cookie,
+ if (SSL_get_options(ssl) & SSL_OP_COOKIE_EXCHANGE) {
+ if (sctx->app_verify_cookie_cb != NULL) {
+ if (sctx->app_verify_cookie_cb(ssl, clienthello->dtls_cookie,
clienthello->dtls_cookie_len) == 0) {
SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
SSL_R_COOKIE_MISMATCH);
}
s->d1->cookie_verified = 1;
}
- if (s->method->version == DTLS_ANY_VERSION) {
+ if (ssl->method->version == DTLS_ANY_VERSION) {
protverr = ssl_choose_server_version(s, clienthello, &dgrd);
if (protverr != 0) {
s->version = s->client_version;
if (!ssl_cache_cipherlist(s, &clienthello->ciphersuites,
clienthello->isv2) ||
- !bytes_to_cipher_list(s, &clienthello->ciphersuites, &ciphers, &scsvs,
- clienthello->isv2, 1)) {
+ !ossl_bytes_to_cipher_list(s, &clienthello->ciphersuites, &ciphers,
+ &scsvs, clienthello->isv2, 1)) {
/* SSLfatal() already called */
goto err;
}
}
/* For TLSv1.3 we must select the ciphersuite *before* session resumption */
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
const SSL_CIPHER *cipher =
- ssl3_choose_cipher(s, ciphers, SSL_get_ciphers(s));
+ ssl3_choose_cipher(s, ciphers, SSL_get_ciphers(ssl));
if (cipher == NULL) {
SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_SHARED_CIPHER);
}
}
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
memcpy(s->tmp_session_id, s->clienthello->session_id,
s->clienthello->session_id_len);
s->tmp_session_id_len = s->clienthello->session_id_len;
* If it is a hit, check that the cipher is in the list. In TLSv1.3 we check
* ciphersuite compatibility with the session as part of resumption.
*/
- if (!SSL_IS_TLS13(s) && s->hit) {
+ if (!SSL_CONNECTION_IS_TLS13(s) && s->hit) {
j = 0;
id = s->session->cipher->id;
if (!s->hit
&& s->version >= TLS1_VERSION
- && !SSL_IS_TLS13(s)
- && !SSL_IS_DTLS(s)
- && s->ext.session_secret_cb) {
+ && !SSL_CONNECTION_IS_TLS13(s)
+ && !SSL_CONNECTION_IS_DTLS(s)
+ && s->ext.session_secret_cb != NULL) {
const SSL_CIPHER *pref_cipher = NULL;
/*
* s->session->master_key_length is a size_t, but this is an int for
int master_key_length;
master_key_length = sizeof(s->session->master_key);
- if (s->ext.session_secret_cb(s, s->session->master_key,
+ if (s->ext.session_secret_cb(ssl, s->session->master_key,
&master_key_length, ciphers,
&pref_cipher,
s->ext.session_secret_cb_arg)
/* check if some cipher was preferred by call back */
if (pref_cipher == NULL)
pref_cipher = ssl3_choose_cipher(s, s->peer_ciphers,
- SSL_get_ciphers(s));
+ SSL_get_ciphers(ssl));
if (pref_cipher == NULL) {
SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_SHARED_CIPHER);
goto err;
* algorithms from the client, starting at q.
*/
s->s3.tmp.new_compression = NULL;
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
/*
* We already checked above that the NULL compression method appears in
* the list. Now we check there aren't any others (which is illegal in
goto err;
}
/* Look for resumed compression method */
- for (m = 0; m < sk_SSL_COMP_num(s->ctx->comp_methods); m++) {
- comp = sk_SSL_COMP_value(s->ctx->comp_methods, m);
+ for (m = 0; m < sk_SSL_COMP_num(sctx->comp_methods); m++) {
+ comp = sk_SSL_COMP_value(sctx->comp_methods, m);
if (comp_id == comp->id) {
s->s3.tmp.new_compression = comp;
break;
}
} else if (s->hit) {
comp = NULL;
- } else if (ssl_allow_compression(s) && s->ctx->comp_methods) {
+ } else if (ssl_allow_compression(s) && sctx->comp_methods) {
/* See if we have a match */
int m, nn, v, done = 0;
unsigned int o;
- nn = sk_SSL_COMP_num(s->ctx->comp_methods);
+ nn = sk_SSL_COMP_num(sctx->comp_methods);
for (m = 0; m < nn; m++) {
- comp = sk_SSL_COMP_value(s->ctx->comp_methods, m);
+ comp = sk_SSL_COMP_value(sctx->comp_methods, m);
v = comp->id;
for (o = 0; o < clienthello->compressions_len; o++) {
if (v == clienthello->compressions[o]) {
* Given s->peer_ciphers and SSL_get_ciphers, we must pick a cipher
*/
- if (!s->hit || SSL_IS_TLS13(s)) {
+ if (!s->hit || SSL_CONNECTION_IS_TLS13(s)) {
sk_SSL_CIPHER_free(s->peer_ciphers);
s->peer_ciphers = ciphers;
if (ciphers == NULL) {
* Call the status request callback if needed. Upon success, returns 1.
* Upon failure, returns 0.
*/
-static int tls_handle_status_request(SSL *s)
+static int tls_handle_status_request(SSL_CONNECTION *s)
{
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
+
s->ext.status_expected = 0;
/*
* and must be called after the cipher has been chosen because this may
* influence which certificate is sent
*/
- if (s->ext.status_type != TLSEXT_STATUSTYPE_nothing && s->ctx != NULL
- && s->ctx->ext.status_cb != NULL) {
+ if (s->ext.status_type != TLSEXT_STATUSTYPE_nothing && sctx != NULL
+ && sctx->ext.status_cb != NULL) {
int ret;
/* If no certificate can't return certificate status */
* et al can pick it up.
*/
s->cert->key = s->s3.tmp.cert;
- ret = s->ctx->ext.status_cb(s, s->ctx->ext.status_arg);
+ ret = sctx->ext.status_cb(SSL_CONNECTION_GET_SSL(s),
+ sctx->ext.status_arg);
switch (ret) {
/* We don't want to send a status request response */
case SSL_TLSEXT_ERR_NOACK:
* Call the alpn_select callback if needed. Upon success, returns 1.
* Upon failure, returns 0.
*/
-int tls_handle_alpn(SSL *s)
+int tls_handle_alpn(SSL_CONNECTION *s)
{
const unsigned char *selected = NULL;
unsigned char selected_len = 0;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
- if (s->ctx->ext.alpn_select_cb != NULL && s->s3.alpn_proposed != NULL) {
- int r = s->ctx->ext.alpn_select_cb(s, &selected, &selected_len,
- s->s3.alpn_proposed,
- (unsigned int)s->s3.alpn_proposed_len,
- s->ctx->ext.alpn_select_cb_arg);
+ if (sctx->ext.alpn_select_cb != NULL && s->s3.alpn_proposed != NULL) {
+ int r = sctx->ext.alpn_select_cb(SSL_CONNECTION_GET_SSL(s),
+ &selected, &selected_len,
+ s->s3.alpn_proposed,
+ (unsigned int)s->s3.alpn_proposed_len,
+ sctx->ext.alpn_select_cb_arg);
if (r == SSL_TLSEXT_ERR_OK) {
OPENSSL_free(s->s3.alpn_selected);
return 1;
}
-WORK_STATE tls_post_process_client_hello(SSL *s, WORK_STATE wst)
+WORK_STATE tls_post_process_client_hello(SSL_CONNECTION *s, WORK_STATE wst)
{
const SSL_CIPHER *cipher;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
if (wst == WORK_MORE_A) {
int rv = tls_early_post_process_client_hello(s);
wst = WORK_MORE_B;
}
if (wst == WORK_MORE_B) {
- if (!s->hit || SSL_IS_TLS13(s)) {
+ if (!s->hit || SSL_CONNECTION_IS_TLS13(s)) {
/* Let cert callback update server certificates if required */
if (!s->hit && s->cert->cert_cb != NULL) {
- int rv = s->cert->cert_cb(s, s->cert->cert_cb_arg);
+ int rv = s->cert->cert_cb(ssl, s->cert->cert_cb_arg);
if (rv == 0) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_CERT_CB_ERROR);
goto err;
}
/* In TLSv1.3 we selected the ciphersuite before resumption */
- if (!SSL_IS_TLS13(s)) {
+ if (!SSL_CONNECTION_IS_TLS13(s)) {
cipher =
- ssl3_choose_cipher(s, s->peer_ciphers, SSL_get_ciphers(s));
+ ssl3_choose_cipher(s, s->peer_ciphers,
+ SSL_get_ciphers(ssl));
if (cipher == NULL) {
SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
/* check whether we should disable session resumption */
if (s->not_resumable_session_cb != NULL)
s->session->not_resumable =
- s->not_resumable_session_cb(s,
+ s->not_resumable_session_cb(ssl,
((s->s3.tmp.new_cipher->algorithm_mkey
& (SSL_kDHE | SSL_kECDHE)) != 0));
if (s->session->not_resumable)
* we already did this because cipher negotiation happens earlier, and
* we must handle ALPN before we decide whether to accept early_data.
*/
- if (!SSL_IS_TLS13(s) && !tls_handle_alpn(s)) {
+ if (!SSL_CONNECTION_IS_TLS13(s) && !tls_handle_alpn(s)) {
/* SSLfatal() already called */
goto err;
}
return WORK_ERROR;
}
-int tls_construct_server_hello(SSL *s, WPACKET *pkt)
+int tls_construct_server_hello(SSL_CONNECTION *s, WPACKET *pkt)
{
int compm;
size_t sl, len;
int version;
unsigned char *session_id;
- int usetls13 = SSL_IS_TLS13(s) || s->hello_retry_request == SSL_HRR_PENDING;
+ int usetls13 = SSL_CONNECTION_IS_TLS13(s)
+ || s->hello_retry_request == SSL_HRR_PENDING;
version = usetls13 ? TLS1_2_VERSION : s->version;
if (!WPACKET_put_bytes_u16(pkt, version)
* to send back.
*/
if (s->session->not_resumable ||
- (!(s->ctx->session_cache_mode & SSL_SESS_CACHE_SERVER)
+ (!(SSL_CONNECTION_GET_CTX(s)->session_cache_mode & SSL_SESS_CACHE_SERVER)
&& !s->hit))
s->session->session_id_length = 0;
#endif
if (!WPACKET_sub_memcpy_u8(pkt, session_id, sl)
- || !s->method->put_cipher_by_char(s->s3.tmp.new_cipher, pkt, &len)
+ || !SSL_CONNECTION_GET_SSL(s)->method->put_cipher_by_char(s->s3.tmp.new_cipher,
+ pkt, &len)
|| !WPACKET_put_bytes_u8(pkt, compm)) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return 0;
if (!tls_construct_extensions(s, pkt,
s->hello_retry_request == SSL_HRR_PENDING
? SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST
- : (SSL_IS_TLS13(s)
+ : (SSL_CONNECTION_IS_TLS13(s)
? SSL_EXT_TLS1_3_SERVER_HELLO
: SSL_EXT_TLS1_2_SERVER_HELLO),
NULL, 0)) {
return 1;
}
-int tls_construct_server_done(SSL *s, WPACKET *pkt)
+int tls_construct_server_done(SSL_CONNECTION *s, WPACKET *pkt)
{
if (!s->s3.tmp.cert_request) {
if (!ssl3_digest_cached_records(s, 0)) {
return 1;
}
-int tls_construct_server_key_exchange(SSL *s, WPACKET *pkt)
+int tls_construct_server_key_exchange(SSL_CONNECTION *s, WPACKET *pkt)
{
EVP_PKEY *pkdh = NULL;
unsigned char *encodedPoint = NULL;
EVP_PKEY_CTX *pctx = NULL;
size_t paramlen, paramoffset;
int freer = 0, ret = 0;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
if (!WPACKET_get_total_written(pkt, ¶moffset)) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
}
#if !defined(OPENSSL_NO_DEPRECATED_3_0)
if ((pkdhp == NULL) && (s->cert->dh_tmp_cb != NULL)) {
- pkdh = ssl_dh_to_pkey(s->cert->dh_tmp_cb(s, 0, 1024));
+ pkdh = ssl_dh_to_pkey(s->cert->dh_tmp_cb(SSL_CONNECTION_GET_SSL(s),
+ 0, 1024));
if (pkdh == NULL) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
goto err;
unsigned char *sigbytes1, *sigbytes2, *tbs;
size_t siglen = 0, tbslen;
- if (pkey == NULL || !tls1_lookup_md(s->ctx, lu, &md)) {
+ if (pkey == NULL || !tls1_lookup_md(sctx, lu, &md)) {
/* Should never happen */
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
goto err;
if (EVP_DigestSignInit_ex(md_ctx, &pctx,
md == NULL ? NULL : EVP_MD_get0_name(md),
- s->ctx->libctx, s->ctx->propq, pkey,
+ sctx->libctx, sctx->propq, pkey,
NULL) <= 0) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
goto err;
return ret;
}
-int tls_construct_certificate_request(SSL *s, WPACKET *pkt)
+int tls_construct_certificate_request(SSL_CONNECTION *s, WPACKET *pkt)
{
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
/* Send random context when doing post-handshake auth */
if (s->post_handshake_auth == SSL_PHA_REQUEST_PENDING) {
OPENSSL_free(s->pha_context);
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return 0;
}
- if (RAND_bytes_ex(s->ctx->libctx, s->pha_context,
- s->pha_context_len, 0) <= 0
+ if (RAND_bytes_ex(SSL_CONNECTION_GET_CTX(s)->libctx,
+ s->pha_context, s->pha_context_len, 0) <= 0
|| !WPACKET_sub_memcpy_u8(pkt, s->pha_context,
s->pha_context_len)) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return 1;
}
-static int tls_process_cke_psk_preamble(SSL *s, PACKET *pkt)
+static int tls_process_cke_psk_preamble(SSL_CONNECTION *s, PACKET *pkt)
{
#ifndef OPENSSL_NO_PSK
unsigned char psk[PSK_MAX_PSK_LEN];
return 0;
}
- psklen = s->psk_server_callback(s, s->session->psk_identity,
+ psklen = s->psk_server_callback(SSL_CONNECTION_GET_SSL(s),
+ s->session->psk_identity,
psk, sizeof(psk));
if (psklen > PSK_MAX_PSK_LEN) {
#endif
}
-static int tls_process_cke_rsa(SSL *s, PACKET *pkt)
+static int tls_process_cke_rsa(SSL_CONNECTION *s, PACKET *pkt)
{
size_t outlen;
PACKET enc_premaster;
int ret = 0;
EVP_PKEY_CTX *ctx = NULL;
OSSL_PARAM params[3], *p = params;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
rsa = s->cert->pkeys[SSL_PKEY_RSA].privatekey;
if (rsa == NULL) {
return 0;
}
- ctx = EVP_PKEY_CTX_new_from_pkey(s->ctx->libctx, rsa, s->ctx->propq);
+ ctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, rsa, sctx->propq);
if (ctx == NULL) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
goto err;
return ret;
}
-static int tls_process_cke_dhe(SSL *s, PACKET *pkt)
+static int tls_process_cke_dhe(SSL_CONNECTION *s, PACKET *pkt)
{
EVP_PKEY *skey = NULL;
unsigned int i;
return ret;
}
-static int tls_process_cke_ecdhe(SSL *s, PACKET *pkt)
+static int tls_process_cke_ecdhe(SSL_CONNECTION *s, PACKET *pkt)
{
EVP_PKEY *skey = s->s3.tmp.pkey;
EVP_PKEY *ckey = NULL;
return ret;
}
-static int tls_process_cke_srp(SSL *s, PACKET *pkt)
+static int tls_process_cke_srp(SSL_CONNECTION *s, PACKET *pkt)
{
#ifndef OPENSSL_NO_SRP
unsigned int i;
#endif
}
-static int tls_process_cke_gost(SSL *s, PACKET *pkt)
+static int tls_process_cke_gost(SSL_CONNECTION *s, PACKET *pkt)
{
#ifndef OPENSSL_NO_GOST
EVP_PKEY_CTX *pkey_ctx;
GOST_KX_MESSAGE *pKX = NULL;
const unsigned char *ptr;
int ret = 0;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
/* Get our certificate private key */
alg_a = s->s3.tmp.new_cipher->algorithm_auth;
pk = s->cert->pkeys[SSL_PKEY_GOST01].privatekey;
}
- pkey_ctx = EVP_PKEY_CTX_new_from_pkey(s->ctx->libctx, pk, s->ctx->propq);
+ pkey_ctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, pk, sctx->propq);
if (pkey_ctx == NULL) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
return 0;
#endif
}
-static int tls_process_cke_gost18(SSL *s, PACKET *pkt)
+static int tls_process_cke_gost18(SSL_CONNECTION *s, PACKET *pkt)
{
#ifndef OPENSSL_NO_GOST
unsigned char rnd_dgst[32];
size_t outlen = 32, inlen = 0;
int ret = 0;
int cipher_nid = ossl_gost18_cke_cipher_nid(s);
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
if (cipher_nid == NID_undef) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
goto err;
}
- pkey_ctx = EVP_PKEY_CTX_new_from_pkey(s->ctx->libctx, pk, s->ctx->propq);
+ pkey_ctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, pk, sctx->propq);
if (pkey_ctx == NULL) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
goto err;
#endif
}
-MSG_PROCESS_RETURN tls_process_client_key_exchange(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_client_key_exchange(SSL_CONNECTION *s,
+ PACKET *pkt)
{
unsigned long alg_k;
return MSG_PROCESS_ERROR;
}
-WORK_STATE tls_post_process_client_key_exchange(SSL *s, WORK_STATE wst)
+WORK_STATE tls_post_process_client_key_exchange(SSL_CONNECTION *s,
+ WORK_STATE wst)
{
#ifndef OPENSSL_NO_SCTP
if (wst == WORK_MORE_A) {
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
unsigned char sctpauthkey[64];
char labelbuffer[sizeof(DTLS1_SCTP_AUTH_LABEL)];
size_t labellen;
if (s->mode & SSL_MODE_DTLS_SCTP_LABEL_LENGTH_BUG)
labellen += 1;
- if (SSL_export_keying_material(s, sctpauthkey,
+ if (SSL_export_keying_material(SSL_CONNECTION_GET_SSL(s),
+ sctpauthkey,
sizeof(sctpauthkey), labelbuffer,
labellen, NULL, 0,
0) <= 0) {
return WORK_FINISHED_CONTINUE;
}
-MSG_PROCESS_RETURN tls_process_client_certificate(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_client_certificate(SSL_CONNECTION *s,
+ PACKET *pkt)
{
int i;
MSG_PROCESS_RETURN ret = MSG_PROCESS_ERROR;
PACKET spkt, context;
size_t chainidx;
SSL_SESSION *new_sess = NULL;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
/*
* To get this far we must have read encrypted data from the client. We no
goto err;
}
- if (SSL_IS_TLS13(s) && (!PACKET_get_length_prefixed_1(pkt, &context)
- || (s->pha_context == NULL && PACKET_remaining(&context) != 0)
- || (s->pha_context != NULL &&
- !PACKET_equal(&context, s->pha_context, s->pha_context_len)))) {
+ if (SSL_CONNECTION_IS_TLS13(s)
+ && (!PACKET_get_length_prefixed_1(pkt, &context)
+ || (s->pha_context == NULL && PACKET_remaining(&context) != 0)
+ || (s->pha_context != NULL
+ && !PACKET_equal(&context, s->pha_context,
+ s->pha_context_len)))) {
SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_INVALID_CONTEXT);
goto err;
}
}
certstart = certbytes;
- x = X509_new_ex(s->ctx->libctx, s->ctx->propq);
+ x = X509_new_ex(sctx->libctx, sctx->propq);
if (x == NULL) {
SSLfatal(s, SSL_AD_DECODE_ERROR, ERR_R_MALLOC_FAILURE);
goto err;
goto err;
}
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
RAW_EXTENSION *rawexts = NULL;
PACKET extensions;
* Freeze the handshake buffer. For <TLS1.3 we do this after the CKE
* message
*/
- if (SSL_IS_TLS13(s) && !ssl3_digest_cached_records(s, 1)) {
+ if (SSL_CONNECTION_IS_TLS13(s) && !ssl3_digest_cached_records(s, 1)) {
/* SSLfatal() already called */
goto err;
}
*/
/* Save the current hash state for when we receive the CertificateVerify */
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
if (!ssl_handshake_hash(s, s->cert_verify_hash,
sizeof(s->cert_verify_hash),
&s->cert_verify_hash_len)) {
return ret;
}
-int tls_construct_server_certificate(SSL *s, WPACKET *pkt)
+int tls_construct_server_certificate(SSL_CONNECTION *s, WPACKET *pkt)
{
CERT_PKEY *cpk = s->s3.tmp.cert;
* In TLSv1.3 the certificate chain is always preceded by a 0 length context
* for the server Certificate message
*/
- if (SSL_IS_TLS13(s) && !WPACKET_put_bytes_u8(pkt, 0)) {
+ if (SSL_CONNECTION_IS_TLS13(s) && !WPACKET_put_bytes_u8(pkt, 0)) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return 0;
}
return 1;
}
-static int create_ticket_prequel(SSL *s, WPACKET *pkt, uint32_t age_add,
- unsigned char *tick_nonce)
+static int create_ticket_prequel(SSL_CONNECTION *s, WPACKET *pkt,
+ uint32_t age_add, unsigned char *tick_nonce)
{
uint32_t timeout = (uint32_t)s->session->timeout;
*/
#define ONE_WEEK_SEC (7 * 24 * 60 * 60)
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
if (s->session->timeout > ONE_WEEK_SEC)
timeout = ONE_WEEK_SEC;
} else if (s->hit)
return 0;
}
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
if (!WPACKET_put_bytes_u32(pkt, age_add)
|| !WPACKET_sub_memcpy_u8(pkt, tick_nonce, TICKET_NONCE_SIZE)) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
return 1;
}
-static int construct_stateless_ticket(SSL *s, WPACKET *pkt, uint32_t age_add,
+static int construct_stateless_ticket(SSL_CONNECTION *s, WPACKET *pkt,
+ uint32_t age_add,
unsigned char *tick_nonce)
{
unsigned char *senc = NULL;
unsigned char key_name[TLSEXT_KEYNAME_LENGTH];
int iv_len, ok = 0;
size_t macoffset, macendoffset;
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
/* get session encoding length */
slen_full = i2d_SSL_SESSION(s->session, NULL);
int ret = 0;
if (tctx->ext.ticket_key_evp_cb != NULL)
- ret = tctx->ext.ticket_key_evp_cb(s, key_name, iv, ctx,
+ ret = tctx->ext.ticket_key_evp_cb(ssl, key_name, iv, ctx,
ssl_hmac_get0_EVP_MAC_CTX(hctx),
1);
#ifndef OPENSSL_NO_DEPRECATED_3_0
else if (tctx->ext.ticket_key_cb != NULL)
/* if 0 is returned, write an empty ticket */
- ret = tctx->ext.ticket_key_cb(s, key_name, iv, ctx,
+ ret = tctx->ext.ticket_key_cb(ssl, key_name, iv, ctx,
ssl_hmac_get0_HMAC_CTX(hctx), 1);
#endif
}
iv_len = EVP_CIPHER_CTX_get_iv_length(ctx);
} else {
- EVP_CIPHER *cipher = EVP_CIPHER_fetch(s->ctx->libctx, "AES-256-CBC",
- s->ctx->propq);
+ EVP_CIPHER *cipher = EVP_CIPHER_fetch(sctx->libctx, "AES-256-CBC",
+ sctx->propq);
if (cipher == NULL) {
/* Error is already recorded */
iv_len = EVP_CIPHER_get_iv_length(cipher);
if (iv_len < 0
- || RAND_bytes_ex(s->ctx->libctx, iv, iv_len, 0) <= 0
+ || RAND_bytes_ex(sctx->libctx, iv, iv_len, 0) <= 0
|| !EVP_EncryptInit_ex(ctx, cipher, NULL,
tctx->ext.secure->tick_aes_key, iv)
|| !ssl_hmac_init(hctx, tctx->ext.secure->tick_hmac_key,
return ok;
}
-static int construct_stateful_ticket(SSL *s, WPACKET *pkt, uint32_t age_add,
+static int construct_stateful_ticket(SSL_CONNECTION *s, WPACKET *pkt,
+ uint32_t age_add,
unsigned char *tick_nonce)
{
if (!create_ticket_prequel(s, pkt, age_add, tick_nonce)) {
return 1;
}
-int tls_construct_new_session_ticket(SSL *s, WPACKET *pkt)
+int tls_construct_new_session_ticket(SSL_CONNECTION *s, WPACKET *pkt)
{
SSL_CTX *tctx = s->session_ctx;
unsigned char tick_nonce[TICKET_NONCE_SIZE];
age_add_u.age_add = 0;
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
size_t i, hashlen;
uint64_t nonce;
static const unsigned char nonce_label[] = "resumption";
/* SSLfatal() already called */
goto err;
}
- if (RAND_bytes_ex(s->ctx->libctx, age_add_u.age_add_c,
- sizeof(age_add_u), 0) <= 0) {
+ if (RAND_bytes_ex(SSL_CONNECTION_GET_CTX(s)->libctx,
+ age_add_u.age_add_c, sizeof(age_add_u), 0) <= 0) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
goto err;
}
}
if (tctx->generate_ticket_cb != NULL &&
- tctx->generate_ticket_cb(s, tctx->ticket_cb_data) == 0) {
+ tctx->generate_ticket_cb(SSL_CONNECTION_GET_SSL(s),
+ tctx->ticket_cb_data) == 0) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
goto err;
}
* SSL_OP_NO_TICKET is set - we are caching tickets anyway so there
* is no point in using full stateless tickets.
*/
- if (SSL_IS_TLS13(s)
+ if (SSL_CONNECTION_IS_TLS13(s)
&& ((s->options & SSL_OP_NO_TICKET) != 0
|| (s->max_early_data > 0
&& (s->options & SSL_OP_NO_ANTI_REPLAY) == 0))) {
goto err;
}
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
if (!tls_construct_extensions(s, pkt,
SSL_EXT_TLS1_3_NEW_SESSION_TICKET,
NULL, 0)) {
* In TLSv1.3 this is called from the extensions code, otherwise it is used to
* create a separate message. Returns 1 on success or 0 on failure.
*/
-int tls_construct_cert_status_body(SSL *s, WPACKET *pkt)
+int tls_construct_cert_status_body(SSL_CONNECTION *s, WPACKET *pkt)
{
if (!WPACKET_put_bytes_u8(pkt, s->ext.status_type)
|| !WPACKET_sub_memcpy_u24(pkt, s->ext.ocsp.resp,
return 1;
}
-int tls_construct_cert_status(SSL *s, WPACKET *pkt)
+int tls_construct_cert_status(SSL_CONNECTION *s, WPACKET *pkt)
{
if (!tls_construct_cert_status_body(s, pkt)) {
/* SSLfatal() already called */
* tls_process_next_proto reads a Next Protocol Negotiation handshake message.
* It sets the next_proto member in s if found
*/
-MSG_PROCESS_RETURN tls_process_next_proto(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_next_proto(SSL_CONNECTION *s, PACKET *pkt)
{
PACKET next_proto, padding;
size_t next_proto_len;
}
#endif
-static int tls_construct_encrypted_extensions(SSL *s, WPACKET *pkt)
+static int tls_construct_encrypted_extensions(SSL_CONNECTION *s, WPACKET *pkt)
{
if (!tls_construct_extensions(s, pkt, SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS,
NULL, 0)) {
return 1;
}
-MSG_PROCESS_RETURN tls_process_end_of_early_data(SSL *s, PACKET *pkt)
+MSG_PROCESS_RETURN tls_process_end_of_early_data(SSL_CONNECTION *s, PACKET *pkt)
{
if (PACKET_remaining(pkt) != 0) {
SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
}
s->early_data_state = SSL_EARLY_DATA_FINISHED_READING;
- if (!s->method->ssl3_enc->change_cipher_state(s,
+ if (!SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->change_cipher_state(s,
SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_SERVER_READ)) {
/* SSLfatal() already called */
return MSG_PROCESS_ERROR;
#include <openssl/trace.h>
/* seed1 through seed5 are concatenated */
-static int tls1_PRF(SSL *s,
+static int tls1_PRF(SSL_CONNECTION *s,
const void *seed1, size_t seed1_len,
const void *seed2, size_t seed2_len,
const void *seed3, size_t seed3_len,
ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
return 0;
}
- kdf = EVP_KDF_fetch(s->ctx->libctx, OSSL_KDF_NAME_TLS1_PRF, s->ctx->propq);
+ kdf = EVP_KDF_fetch(SSL_CONNECTION_GET_CTX(s)->libctx,
+ OSSL_KDF_NAME_TLS1_PRF,
+ SSL_CONNECTION_GET_CTX(s)->propq);
if (kdf == NULL)
goto err;
kctx = EVP_KDF_CTX_new(kdf);
return 0;
}
-static int tls1_generate_key_block(SSL *s, unsigned char *km, size_t num)
+static int tls1_generate_key_block(SSL_CONNECTION *s, unsigned char *km,
+ size_t num)
{
int ret;
return ret;
}
-int tls_provider_set_tls_params(SSL *s, EVP_CIPHER_CTX *ctx,
+int tls_provider_set_tls_params(SSL_CONNECTION *s, EVP_CIPHER_CTX *ctx,
const EVP_CIPHER *ciph,
const EVP_MD *md)
{
return EVP_CIPHER_get_iv_length(c);
}
-int tls1_change_cipher_state(SSL *s, int which)
+int tls1_change_cipher_state(SSL_CONNECTION *s, int which)
{
unsigned char *p, *mac_secret;
unsigned char *ms, *key, *iv;
/*
* this is done by dtls1_reset_seq_numbers for DTLS
*/
- if (!SSL_IS_DTLS(s))
+ if (!SSL_CONNECTION_IS_DTLS(s))
RECORD_LAYER_reset_read_sequence(&s->rlayer);
mac_secret = &(s->s3.read_mac_secret[0]);
mac_secret_size = &(s->s3.read_mac_secret_size);
s->mac_flags |= SSL_MAC_FLAG_WRITE_MAC_TLSTREE;
else
s->mac_flags &= ~SSL_MAC_FLAG_WRITE_MAC_TLSTREE;
- if (s->enc_write_ctx != NULL && !SSL_IS_DTLS(s)) {
+ if (s->enc_write_ctx != NULL && !SSL_CONNECTION_IS_DTLS(s)) {
reuse_dd = 1;
} else if ((s->enc_write_ctx = EVP_CIPHER_CTX_new()) == NULL) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
goto err;
}
dd = s->enc_write_ctx;
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
mac_ctx = EVP_MD_CTX_new();
if (mac_ctx == NULL) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
/*
* this is done by dtls1_reset_seq_numbers for DTLS
*/
- if (!SSL_IS_DTLS(s))
+ if (!SSL_CONNECTION_IS_DTLS(s))
RECORD_LAYER_reset_write_sequence(&s->rlayer);
mac_secret = &(s->s3.write_mac_secret[0]);
mac_secret_size = &(s->s3.write_mac_secret_size);
memcpy(mac_secret, ms, i);
if (!(EVP_CIPHER_get_flags(c) & EVP_CIPH_FLAG_AEAD_CIPHER)) {
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
+
if (mac_type == EVP_PKEY_HMAC) {
- mac_key = EVP_PKEY_new_raw_private_key_ex(s->ctx->libctx, "HMAC",
- s->ctx->propq, mac_secret,
+ mac_key = EVP_PKEY_new_raw_private_key_ex(sctx->libctx, "HMAC",
+ sctx->propq, mac_secret,
*mac_secret_size);
} else {
/*
}
if (mac_key == NULL
|| EVP_DigestSignInit_ex(mac_ctx, NULL, EVP_MD_get0_name(m),
- s->ctx->libctx, s->ctx->propq, mac_key,
+ sctx->libctx, sctx->propq, mac_key,
NULL) <= 0) {
EVP_PKEY_free(mac_key);
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
if (BIO_set_ktls(bio, &crypto_info, which & SSL3_CC_WRITE)) {
if (which & SSL3_CC_WRITE)
ssl3_release_write_buffer(s);
- SSL_set_options(s, SSL_OP_NO_RENEGOTIATION);
+ SSL_set_options(SSL_CONNECTION_GET_SSL(s), SSL_OP_NO_RENEGOTIATION);
}
skip_ktls:
return 0;
}
-int tls1_setup_key_block(SSL *s)
+int tls1_setup_key_block(SSL_CONNECTION *s)
{
unsigned char *p;
const EVP_CIPHER *c;
if (s->s3.tmp.key_block_length != 0)
return 1;
- if (!ssl_cipher_get_evp(s->ctx, s->session, &c, &hash, &mac_type,
- &mac_secret_size, &comp, s->ext.use_etm)) {
+ if (!ssl_cipher_get_evp(SSL_CONNECTION_GET_CTX(s), s->session, &c, &hash,
+ &mac_type, &mac_secret_size, &comp,
+ s->ext.use_etm)) {
/* Error is already recorded */
SSLfatal_alert(s, SSL_AD_INTERNAL_ERROR);
return 0;
} OSSL_TRACE_END(TLS);
if (!(s->options & SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS)
- && s->method->version <= TLS1_VERSION) {
+ && SSL_CONNECTION_GET_SSL(s)->method->version <= TLS1_VERSION) {
/*
* enable vulnerability countermeasure for CBC ciphers with known-IV
* problem (http://www.openssl.org/~bodo/tls-cbc.txt)
return ret;
}
-size_t tls1_final_finish_mac(SSL *s, const char *str, size_t slen,
- unsigned char *out)
+size_t tls1_final_finish_mac(SSL_CONNECTION *s, const char *str,
+ size_t slen, unsigned char *out)
{
size_t hashlen;
unsigned char hash[EVP_MAX_MD_SIZE];
return finished_size;
}
-int tls1_generate_master_secret(SSL *s, unsigned char *out, unsigned char *p,
- size_t len, size_t *secret_size)
+int tls1_generate_master_secret(SSL_CONNECTION *s, unsigned char *out,
+ unsigned char *p, size_t len,
+ size_t *secret_size)
{
if (s->session->flags & SSL_SESS_FLAG_EXTMS) {
unsigned char hash[EVP_MAX_MD_SIZE * 2];
return 1;
}
-int tls1_export_keying_material(SSL *s, unsigned char *out, size_t olen,
- const char *label, size_t llen,
+int tls1_export_keying_material(SSL_CONNECTION *s, unsigned char *out,
+ size_t olen, const char *label, size_t llen,
const unsigned char *context,
size_t contextlen, int use_context)
{
#include "ssl_local.h"
#include <openssl/ct.h>
-static const SIGALG_LOOKUP *find_sig_alg(SSL *s, X509 *x, EVP_PKEY *pkey);
-static int tls12_sigalg_allowed(const SSL *s, int op, const SIGALG_LOOKUP *lu);
+static const SIGALG_LOOKUP *find_sig_alg(SSL_CONNECTION *s, X509 *x, EVP_PKEY *pkey);
+static int tls12_sigalg_allowed(const SSL_CONNECTION *s, int op, const SIGALG_LOOKUP *lu);
SSL3_ENC_METHOD const TLSv1_enc_data = {
tls1_enc,
void tls1_free(SSL *s)
{
- OPENSSL_free(s->ext.session_ticket);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return;
+
+ OPENSSL_free(sc->ext.session_ticket);
ssl3_free(s);
}
int tls1_clear(SSL *s)
{
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
if (!ssl3_clear(s))
return 0;
if (s->method->version == TLS_ANY_VERSION)
- s->version = TLS_MAX_VERSION_INTERNAL;
+ sc->version = TLS_MAX_VERSION_INTERNAL;
else
- s->version = s->method->version;
+ sc->version = s->method->version;
return 1;
}
* Set *pgroups to the supported groups list and *pgroupslen to
* the number of groups supported.
*/
-void tls1_get_supported_groups(SSL *s, const uint16_t **pgroups,
+void tls1_get_supported_groups(SSL_CONNECTION *s, const uint16_t **pgroups,
size_t *pgroupslen)
{
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
+
/* For Suite B mode only include P-256, P-384 */
switch (tls1_suiteb(s)) {
case SSL_CERT_FLAG_SUITEB_128_LOS:
default:
if (s->ext.supportedgroups == NULL) {
- *pgroups = s->ctx->ext.supported_groups_default;
- *pgroupslen = s->ctx->ext.supported_groups_default_len;
+ *pgroups = sctx->ext.supported_groups_default;
+ *pgroupslen = sctx->ext.supported_groups_default_len;
} else {
*pgroups = s->ext.supportedgroups;
*pgroupslen = s->ext.supportedgroups_len;
}
}
-int tls_valid_group(SSL *s, uint16_t group_id, int minversion, int maxversion,
+int tls_valid_group(SSL_CONNECTION *s, uint16_t group_id,
+ int minversion, int maxversion,
int isec, int *okfortls13)
{
- const TLS_GROUP_INFO *ginfo = tls1_group_id_lookup(s->ctx, group_id);
+ const TLS_GROUP_INFO *ginfo = tls1_group_id_lookup(SSL_CONNECTION_GET_CTX(s),
+ group_id);
int ret;
if (okfortls13 != NULL)
if (ginfo == NULL)
return 0;
- if (SSL_IS_DTLS(s)) {
+ if (SSL_CONNECTION_IS_DTLS(s)) {
if (ginfo->mindtls < 0 || ginfo->maxdtls < 0)
return 0;
if (ginfo->maxdtls == 0)
}
/* See if group is allowed by security callback */
-int tls_group_allowed(SSL *s, uint16_t group, int op)
+int tls_group_allowed(SSL_CONNECTION *s, uint16_t group, int op)
{
- const TLS_GROUP_INFO *ginfo = tls1_group_id_lookup(s->ctx, group);
+ const TLS_GROUP_INFO *ginfo = tls1_group_id_lookup(SSL_CONNECTION_GET_CTX(s),
+ group);
unsigned char gtmp[2];
if (ginfo == NULL)
* For nmatch == -2, return the id of the group to use for
* a tmp key, or 0 if there is no match.
*/
-uint16_t tls1_shared_group(SSL *s, int nmatch)
+uint16_t tls1_shared_group(SSL_CONNECTION *s, int nmatch)
{
const uint16_t *pref, *supp;
size_t num_pref, num_supp, i;
uint16_t id = pref[i];
uint16_t cid = id;
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
if (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE)
cid = ssl_group_id_internal_to_tls13(id);
else
}
/* Check a group id matches preferences */
-int tls1_check_group_id(SSL *s, uint16_t group_id, int check_own_groups)
+int tls1_check_group_id(SSL_CONNECTION *s, uint16_t group_id,
+ int check_own_groups)
{
const uint16_t *groups;
size_t groups_len;
return tls1_in_list(group_id, groups, groups_len);
}
-void tls1_get_formatlist(SSL *s, const unsigned char **pformats,
+void tls1_get_formatlist(SSL_CONNECTION *s, const unsigned char **pformats,
size_t *num_formats)
{
/*
}
/* Check a key is compatible with compression extension */
-static int tls1_check_pkey_comp(SSL *s, EVP_PKEY *pkey)
+static int tls1_check_pkey_comp(SSL_CONNECTION *s, EVP_PKEY *pkey)
{
unsigned char comp_id;
size_t i;
return 0;
if (point_conv == POINT_CONVERSION_UNCOMPRESSED) {
comp_id = TLSEXT_ECPOINTFORMAT_uncompressed;
- } else if (SSL_IS_TLS13(s)) {
+ } else if (SSL_CONNECTION_IS_TLS13(s)) {
/*
* ec_point_formats extension is not used in TLSv1.3 so we ignore
* this check.
* Check cert parameters compatible with extensions: currently just checks EC
* certificates have compatible curves and compression.
*/
-static int tls1_check_cert_param(SSL *s, X509 *x, int check_ee_md)
+static int tls1_check_cert_param(SSL_CONNECTION *s, X509 *x, int check_ee_md)
{
uint16_t group_id;
EVP_PKEY *pkey;
*
* Returns 0 when the cipher can't be used or 1 when it can.
*/
-int tls1_check_ec_tmp_key(SSL *s, unsigned long cid)
+int tls1_check_ec_tmp_key(SSL_CONNECTION *s, unsigned long cid)
{
/* If not Suite B just need a shared group */
if (!tls1_suiteb(s))
}
/* Lookup TLS signature algorithm */
-static const SIGALG_LOOKUP *tls1_lookup_sigalg(const SSL *s, uint16_t sigalg)
+static const SIGALG_LOOKUP *tls1_lookup_sigalg(const SSL_CONNECTION *s,
+ uint16_t sigalg)
{
size_t i;
const SIGALG_LOOKUP *lu;
- for (i = 0, lu = s->ctx->sigalg_lookup_cache;
+ for (i = 0, lu = SSL_CONNECTION_GET_CTX(s)->sigalg_lookup_cache;
/* cache should have the same number of elements as sigalg_lookup_tbl */
i < OSSL_NELEM(sigalg_lookup_tbl);
lu++, i++) {
int tls1_lookup_md(SSL_CTX *ctx, const SIGALG_LOOKUP *lu, const EVP_MD **pmd)
{
const EVP_MD *md;
+
if (lu == NULL)
return 0;
/* lu->hash == NID_undef means no associated digest */
* certificate type from |s| will be used.
* Returns the signature algorithm to use, or NULL on error.
*/
-static const SIGALG_LOOKUP *tls1_get_legacy_sigalg(const SSL *s, int idx)
+static const SIGALG_LOOKUP *tls1_get_legacy_sigalg(const SSL_CONNECTION *s,
+ int idx)
{
if (idx == -1) {
if (s->server) {
if (lu == NULL)
return NULL;
- if (!tls1_lookup_md(s->ctx, lu, NULL))
+ if (!tls1_lookup_md(SSL_CONNECTION_GET_CTX(s), lu, NULL))
return NULL;
if (!tls12_sigalg_allowed(s, SSL_SECOP_SIGALG_SUPPORTED, lu))
return NULL;
return &legacy_rsa_sigalg;
}
/* Set peer sigalg based key type */
-int tls1_set_peer_legacy_sigalg(SSL *s, const EVP_PKEY *pkey)
+int tls1_set_peer_legacy_sigalg(SSL_CONNECTION *s, const EVP_PKEY *pkey)
{
size_t idx;
const SIGALG_LOOKUP *lu;
return 1;
}
-size_t tls12_get_psigalgs(SSL *s, int sent, const uint16_t **psigs)
+size_t tls12_get_psigalgs(SSL_CONNECTION *s, int sent, const uint16_t **psigs)
{
/*
* If Suite B mode use Suite B sigalgs only, ignore any other
* Called by servers only. Checks that we have a sig alg that supports the
* specified EC curve.
*/
-int tls_check_sigalg_curve(const SSL *s, int curve)
+int tls_check_sigalg_curve(const SSL_CONNECTION *s, int curve)
{
const uint16_t *sigs;
size_t siglen, i;
* algorithms and if so set relevant digest and signature scheme in
* s.
*/
-int tls12_check_peer_sigalg(SSL *s, uint16_t sig, EVP_PKEY *pkey)
+int tls12_check_peer_sigalg(SSL_CONNECTION *s, uint16_t sig, EVP_PKEY *pkey)
{
const uint16_t *sent_sigs;
const EVP_MD *md = NULL;
/* Should never happen */
if (pkeyid == -1)
return -1;
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
/* Disallow DSA for TLS 1.3 */
if (pkeyid == EVP_PKEY_DSA) {
SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_SIGNATURE_TYPE);
* is consistent with signature: RSA keys can be used for RSA-PSS
*/
if (lu == NULL
- || (SSL_IS_TLS13(s) && (lu->hash == NID_sha1 || lu->hash == NID_sha224))
+ || (SSL_CONNECTION_IS_TLS13(s)
+ && (lu->hash == NID_sha1 || lu->hash == NID_sha224))
|| (pkeyid != lu->sig
&& (lu->sig != EVP_PKEY_RSA_PSS || pkeyid != EVP_PKEY_RSA))) {
SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_SIGNATURE_TYPE);
}
/* For TLS 1.3 or Suite B check curve matches signature algorithm */
- if (SSL_IS_TLS13(s) || tls1_suiteb(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s) || tls1_suiteb(s)) {
int curve = ssl_get_EC_curve_nid(pkey);
if (lu->curve != NID_undef && curve != lu->curve) {
return 0;
}
}
- if (!SSL_IS_TLS13(s)) {
+ if (!SSL_CONNECTION_IS_TLS13(s)) {
/* Check curve matches extensions */
if (!tls1_check_group_id(s, tls1_get_group_id(pkey), 1)) {
SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_CURVE);
SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_WRONG_SIGNATURE_TYPE);
return 0;
}
- if (!tls1_lookup_md(s->ctx, lu, &md)) {
+ if (!tls1_lookup_md(SSL_CONNECTION_GET_CTX(s), lu, &md)) {
SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_UNKNOWN_DIGEST);
return 0;
}
*/
sigalgstr[0] = (sig >> 8) & 0xff;
sigalgstr[1] = sig & 0xff;
- secbits = sigalg_security_bits(s->ctx, lu);
+ secbits = sigalg_security_bits(SSL_CONNECTION_GET_CTX(s), lu);
if (secbits == 0 ||
!ssl_security(s, SSL_SECOP_SIGALG_CHECK, secbits,
md != NULL ? EVP_MD_get_type(md) : NID_undef,
int SSL_get_peer_signature_type_nid(const SSL *s, int *pnid)
{
- if (s->s3.tmp.peer_sigalg == NULL)
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
return 0;
- *pnid = s->s3.tmp.peer_sigalg->sig;
+
+ if (sc->s3.tmp.peer_sigalg == NULL)
+ return 0;
+ *pnid = sc->s3.tmp.peer_sigalg->sig;
return 1;
}
int SSL_get_signature_type_nid(const SSL *s, int *pnid)
{
- if (s->s3.tmp.sigalg == NULL)
+ const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ if (sc->s3.tmp.sigalg == NULL)
return 0;
- *pnid = s->s3.tmp.sigalg->sig;
+ *pnid = sc->s3.tmp.sigalg->sig;
return 1;
}
*
* Call ssl_cipher_disabled() to check that it's enabled or not.
*/
-int ssl_set_client_disabled(SSL *s)
+int ssl_set_client_disabled(SSL_CONNECTION *s)
{
s->s3.tmp.mask_a = 0;
s->s3.tmp.mask_k = 0;
*
* Returns 1 when it's disabled, 0 when enabled.
*/
-int ssl_cipher_disabled(const SSL *s, const SSL_CIPHER *c, int op, int ecdhe)
+int ssl_cipher_disabled(const SSL_CONNECTION *s, const SSL_CIPHER *c,
+ int op, int ecdhe)
{
if (c->algorithm_mkey & s->s3.tmp.mask_k
|| c->algorithm_auth & s->s3.tmp.mask_a)
return 1;
if (s->s3.tmp.max_ver == 0)
return 1;
- if (!SSL_IS_DTLS(s)) {
+ if (!SSL_CONNECTION_IS_DTLS(s)) {
int min_tls = c->min_tls;
/*
if ((min_tls > s->s3.tmp.max_ver) || (c->max_tls < s->s3.tmp.min_ver))
return 1;
}
- if (SSL_IS_DTLS(s) && (DTLS_VERSION_GT(c->min_dtls, s->s3.tmp.max_ver)
- || DTLS_VERSION_LT(c->max_dtls, s->s3.tmp.min_ver)))
+ if (SSL_CONNECTION_IS_DTLS(s)
+ && (DTLS_VERSION_GT(c->min_dtls, s->s3.tmp.max_ver)
+ || DTLS_VERSION_LT(c->max_dtls, s->s3.tmp.min_ver)))
return 1;
return !ssl_security(s, op, c->strength_bits, 0, (void *)c);
}
-int tls_use_ticket(SSL *s)
+int tls_use_ticket(SSL_CONNECTION *s)
{
if ((s->options & SSL_OP_NO_TICKET))
return 0;
return ssl_security(s, SSL_SECOP_TICKET, 0, 0, NULL);
}
-int tls1_set_server_sigalgs(SSL *s)
+int tls1_set_server_sigalgs(SSL_CONNECTION *s)
{
size_t i;
* ret: (output) on return, if a ticket was decrypted, then this is set to
* point to the resulting session.
*/
-SSL_TICKET_STATUS tls_get_ticket_from_client(SSL *s, CLIENTHELLO_MSG *hello,
+SSL_TICKET_STATUS tls_get_ticket_from_client(SSL_CONNECTION *s,
+ CLIENTHELLO_MSG *hello,
SSL_SESSION **ret)
{
size_t size;
* psess: (output) on return, if a ticket was decrypted, then this is set to
* point to the resulting session.
*/
-SSL_TICKET_STATUS tls_decrypt_ticket(SSL *s, const unsigned char *etick,
- size_t eticklen, const unsigned char *sess_id,
+SSL_TICKET_STATUS tls_decrypt_ticket(SSL_CONNECTION *s,
+ const unsigned char *etick,
+ size_t eticklen,
+ const unsigned char *sess_id,
size_t sesslen, SSL_SESSION **psess)
{
SSL_SESSION *sess = NULL;
ret = SSL_TICKET_EMPTY;
goto end;
}
- if (!SSL_IS_TLS13(s) && s->ext.session_secret_cb) {
+ if (!SSL_CONNECTION_IS_TLS13(s) && s->ext.session_secret_cb) {
/*
* Indicate that the ticket couldn't be decrypted rather than
* generating the session from ticket now, trigger
int rv = 0;
if (tctx->ext.ticket_key_evp_cb != NULL)
- rv = tctx->ext.ticket_key_evp_cb(s, nctick,
+ rv = tctx->ext.ticket_key_evp_cb(SSL_CONNECTION_GET_SSL(s), nctick,
nctick + TLSEXT_KEYNAME_LENGTH,
ctx,
ssl_hmac_get0_EVP_MAC_CTX(hctx),
#ifndef OPENSSL_NO_DEPRECATED_3_0
else if (tctx->ext.ticket_key_cb != NULL)
/* if 0 is returned, write an empty ticket */
- rv = tctx->ext.ticket_key_cb(s, nctick,
+ rv = tctx->ext.ticket_key_cb(SSL_CONNECTION_GET_SSL(s), nctick,
nctick + TLSEXT_KEYNAME_LENGTH,
ctx, ssl_hmac_get0_HMAC_CTX(hctx), 0);
#endif
renew_ticket = 1;
} else {
EVP_CIPHER *aes256cbc = NULL;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
/* Check key name matches */
if (memcmp(etick, tctx->ext.tick_key_name,
goto end;
}
- aes256cbc = EVP_CIPHER_fetch(s->ctx->libctx, "AES-256-CBC",
- s->ctx->propq);
+ aes256cbc = EVP_CIPHER_fetch(sctx->libctx, "AES-256-CBC",
+ sctx->propq);
if (aes256cbc == NULL
|| ssl_hmac_init(hctx, tctx->ext.secure->tick_hmac_key,
sizeof(tctx->ext.secure->tick_hmac_key),
goto end;
}
EVP_CIPHER_free(aes256cbc);
- if (SSL_IS_TLS13(s))
+ if (SSL_CONNECTION_IS_TLS13(s))
renew_ticket = 1;
}
/*
if (keyname_len > TLSEXT_KEYNAME_LENGTH)
keyname_len = TLSEXT_KEYNAME_LENGTH;
- retcb = s->session_ctx->decrypt_ticket_cb(s, sess, etick, keyname_len,
+ retcb = s->session_ctx->decrypt_ticket_cb(SSL_CONNECTION_GET_SSL(s),
+ sess, etick, keyname_len,
ret,
s->session_ctx->ticket_cb_data);
switch (retcb) {
}
}
- if (s->ext.session_secret_cb == NULL || SSL_IS_TLS13(s)) {
+ if (s->ext.session_secret_cb == NULL || SSL_CONNECTION_IS_TLS13(s)) {
switch (ret) {
case SSL_TICKET_NO_DECRYPT:
case SSL_TICKET_SUCCESS_RENEW:
}
/* Check to see if a signature algorithm is allowed */
-static int tls12_sigalg_allowed(const SSL *s, int op, const SIGALG_LOOKUP *lu)
+static int tls12_sigalg_allowed(const SSL_CONNECTION *s, int op,
+ const SIGALG_LOOKUP *lu)
{
unsigned char sigalgstr[2];
int secbits;
if (lu == NULL || !lu->enabled)
return 0;
/* DSA is not allowed in TLS 1.3 */
- if (SSL_IS_TLS13(s) && lu->sig == EVP_PKEY_DSA)
+ if (SSL_CONNECTION_IS_TLS13(s) && lu->sig == EVP_PKEY_DSA)
return 0;
/*
* At some point we should fully axe DSA/etc. in ClientHello as per TLS 1.3
* spec
*/
- if (!s->server && !SSL_IS_DTLS(s) && s->s3.tmp.min_ver >= TLS1_3_VERSION
+ if (!s->server && !SSL_CONNECTION_IS_DTLS(s)
+ && s->s3.tmp.min_ver >= TLS1_3_VERSION
&& (lu->sig == EVP_PKEY_DSA || lu->hash_idx == SSL_MD_SHA1_IDX
|| lu->hash_idx == SSL_MD_MD5_IDX
|| lu->hash_idx == SSL_MD_SHA224_IDX))
return 0;
/* See if public key algorithm allowed */
- if (ssl_cert_is_disabled(s->ctx, lu->sig_idx))
+ if (ssl_cert_is_disabled(SSL_CONNECTION_GET_CTX(s), lu->sig_idx))
return 0;
if (lu->sig == NID_id_GostR3410_2012_256
|| lu->sig == NID_id_GostR3410_2012_512
|| lu->sig == NID_id_GostR3410_2001) {
/* We never allow GOST sig algs on the server with TLSv1.3 */
- if (s->server && SSL_IS_TLS13(s))
+ if (s->server && SSL_CONNECTION_IS_TLS13(s))
return 0;
if (!s->server
- && s->method->version == TLS_ANY_VERSION
+ && SSL_CONNECTION_GET_SSL(s)->method->version == TLS_ANY_VERSION
&& s->s3.tmp.max_ver >= TLS1_3_VERSION) {
int i, num;
STACK_OF(SSL_CIPHER) *sk;
if (s->s3.tmp.min_ver >= TLS1_3_VERSION)
return 0;
- sk = SSL_get_ciphers(s);
+ sk = SSL_get_ciphers(SSL_CONNECTION_GET_SSL(s));
num = sk != NULL ? sk_SSL_CIPHER_num(sk) : 0;
for (i = 0; i < num; i++) {
const SSL_CIPHER *c;
}
/* Finally see if security callback allows it */
- secbits = sigalg_security_bits(s->ctx, lu);
+ secbits = sigalg_security_bits(SSL_CONNECTION_GET_CTX(s), lu);
sigalgstr[0] = (lu->sigalg >> 8) & 0xff;
sigalgstr[1] = lu->sigalg & 0xff;
return ssl_security(s, op, secbits, lu->hash, (void *)sigalgstr);
* disabled.
*/
-void ssl_set_sig_mask(uint32_t *pmask_a, SSL *s, int op)
+void ssl_set_sig_mask(uint32_t *pmask_a, SSL_CONNECTION *s, int op)
{
const uint16_t *sigalgs;
size_t i, sigalgslen;
*pmask_a |= disabled_mask;
}
-int tls12_copy_sigalgs(SSL *s, WPACKET *pkt,
+int tls12_copy_sigalgs(SSL_CONNECTION *s, WPACKET *pkt,
const uint16_t *psig, size_t psiglen)
{
size_t i;
* If TLS 1.3 must have at least one valid TLS 1.3 message
* signing algorithm: i.e. neither RSA nor SHA1/SHA224
*/
- if (rv == 0 && (!SSL_IS_TLS13(s)
+ if (rv == 0 && (!SSL_CONNECTION_IS_TLS13(s)
|| (lu->sig != EVP_PKEY_RSA
&& lu->hash != NID_sha1
&& lu->hash != NID_sha224)))
}
/* Given preference and allowed sigalgs set shared sigalgs */
-static size_t tls12_shared_sigalgs(SSL *s, const SIGALG_LOOKUP **shsig,
+static size_t tls12_shared_sigalgs(SSL_CONNECTION *s,
+ const SIGALG_LOOKUP **shsig,
const uint16_t *pref, size_t preflen,
const uint16_t *allow, size_t allowlen)
{
}
/* Set shared signature algorithms for SSL structures */
-static int tls1_set_shared_sigalgs(SSL *s)
+static int tls1_set_shared_sigalgs(SSL_CONNECTION *s)
{
const uint16_t *pref, *allow, *conf;
size_t preflen, allowlen, conflen;
return 1;
}
-int tls1_save_sigalgs(SSL *s, PACKET *pkt, int cert)
+int tls1_save_sigalgs(SSL_CONNECTION *s, PACKET *pkt, int cert)
{
/* Extension ignored for inappropriate versions */
if (!SSL_USE_SIGALGS(s))
/* Set preferred digest for each key type */
-int tls1_process_sigalgs(SSL *s)
+int tls1_process_sigalgs(SSL_CONNECTION *s)
{
size_t i;
uint32_t *pvalid = s->s3.tmp.valid_flags;
int idx = sigptr->sig_idx;
/* Ignore PKCS1 based sig algs in TLSv1.3 */
- if (SSL_IS_TLS13(s) && sigptr->sig == EVP_PKEY_RSA)
+ if (SSL_CONNECTION_IS_TLS13(s) && sigptr->sig == EVP_PKEY_RSA)
continue;
/* If not disabled indicate we can explicitly sign */
- if (pvalid[idx] == 0 && !ssl_cert_is_disabled(s->ctx, idx))
+ if (pvalid[idx] == 0
+ && !ssl_cert_is_disabled(SSL_CONNECTION_GET_CTX(s), idx))
pvalid[idx] = CERT_PKEY_EXPLICIT_SIGN | CERT_PKEY_SIGN;
}
return 1;
int *psign, int *phash, int *psignhash,
unsigned char *rsig, unsigned char *rhash)
{
- uint16_t *psig = s->s3.tmp.peer_sigalgs;
- size_t numsigalgs = s->s3.tmp.peer_sigalgslen;
+ uint16_t *psig;
+ size_t numsigalgs;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ psig = sc->s3.tmp.peer_sigalgs;
+ numsigalgs = sc->s3.tmp.peer_sigalgslen;
+
if (psig == NULL || numsigalgs > INT_MAX)
return 0;
if (idx >= 0) {
*rhash = (unsigned char)((*psig >> 8) & 0xff);
if (rsig != NULL)
*rsig = (unsigned char)(*psig & 0xff);
- lu = tls1_lookup_sigalg(s, *psig);
+ lu = tls1_lookup_sigalg(sc, *psig);
if (psign != NULL)
*psign = lu != NULL ? lu->sig : NID_undef;
if (phash != NULL)
unsigned char *rsig, unsigned char *rhash)
{
const SIGALG_LOOKUP *shsigalgs;
- if (s->shared_sigalgs == NULL
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ if (sc->shared_sigalgs == NULL
|| idx < 0
- || idx >= (int)s->shared_sigalgslen
- || s->shared_sigalgslen > INT_MAX)
+ || idx >= (int)sc->shared_sigalgslen
+ || sc->shared_sigalgslen > INT_MAX)
return 0;
- shsigalgs = s->shared_sigalgs[idx];
+ shsigalgs = sc->shared_sigalgs[idx];
if (phash != NULL)
*phash = shsigalgs->hash;
if (psign != NULL)
*rsig = (unsigned char)(shsigalgs->sigalg & 0xff);
if (rhash != NULL)
*rhash = (unsigned char)((shsigalgs->sigalg >> 8) & 0xff);
- return (int)s->shared_sigalgslen;
+ return (int)sc->shared_sigalgslen;
}
/* Maximum possible number of unique entries in sigalgs array */
return 0;
}
-static int tls1_check_sig_alg(SSL *s, X509 *x, int default_nid)
+static int tls1_check_sig_alg(SSL_CONNECTION *s, X509 *x, int default_nid)
{
int sig_nid, use_pc_sigalgs = 0;
size_t i;
const SIGALG_LOOKUP *sigalg;
size_t sigalgslen;
+
if (default_nid == -1)
return 1;
sig_nid = X509_get_signature_nid(x);
if (default_nid)
return sig_nid == default_nid ? 1 : 0;
- if (SSL_IS_TLS13(s) && s->s3.tmp.peer_cert_sigalgs != NULL) {
+ if (SSL_CONNECTION_IS_TLS13(s) && s->s3.tmp.peer_cert_sigalgs != NULL) {
/*
* If we're in TLSv1.3 then we only get here if we're checking the
* chain. If the peer has specified peer_cert_sigalgs then we use them
(CERT_PKEY_VALID_FLAGS|CERT_PKEY_CA_SIGNATURE|CERT_PKEY_CA_PARAM \
| CERT_PKEY_ISSUER_NAME|CERT_PKEY_CERT_TYPE)
-int tls1_check_chain(SSL *s, X509 *x, EVP_PKEY *pk, STACK_OF(X509) *chain,
- int idx)
+int tls1_check_chain(SSL_CONNECTION *s, X509 *x, EVP_PKEY *pk,
+ STACK_OF(X509) *chain, int idx)
{
int i;
int rv = 0;
CERT *c = s->cert;
uint32_t *pvalid;
unsigned int suiteb_flags = tls1_suiteb(s);
+
/* idx == -1 means checking server chains */
if (idx != -1) {
/* idx == -2 means checking client certificate chains */
* Check all signature algorithms are consistent with signature
* algorithms extension if TLS 1.2 or later and strict mode.
*/
- if (TLS1_get_version(s) >= TLS1_2_VERSION && strict_mode) {
+ if (TLS1_get_version(SSL_CONNECTION_GET_SSL(s)) >= TLS1_2_VERSION
+ && strict_mode) {
int default_nid;
int rsign = 0;
+
if (s->s3.tmp.peer_cert_sigalgs != NULL
|| s->s3.tmp.peer_sigalgs != NULL) {
default_nid = 0;
}
}
/* Check signature algorithm of each cert in chain */
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
/*
* We only get here if the application has called SSL_check_chain(),
* so check_flags is always set.
end:
- if (TLS1_get_version(s) >= TLS1_2_VERSION)
+ if (TLS1_get_version(SSL_CONNECTION_GET_SSL(s)) >= TLS1_2_VERSION)
rv |= *pvalid & (CERT_PKEY_EXPLICIT_SIGN | CERT_PKEY_SIGN);
else
rv |= CERT_PKEY_SIGN | CERT_PKEY_EXPLICIT_SIGN;
}
/* Set validity of certificates in an SSL structure */
-void tls1_set_cert_validity(SSL *s)
+void tls1_set_cert_validity(SSL_CONNECTION *s)
{
tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_RSA);
tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_RSA_PSS_SIGN);
/* User level utility function to check a chain is suitable */
int SSL_check_chain(SSL *s, X509 *x, EVP_PKEY *pk, STACK_OF(X509) *chain)
{
- return tls1_check_chain(s, x, pk, chain, -1);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ return tls1_check_chain(sc, x, pk, chain, -1);
}
-EVP_PKEY *ssl_get_auto_dh(SSL *s)
+EVP_PKEY *ssl_get_auto_dh(SSL_CONNECTION *s)
{
EVP_PKEY *dhp = NULL;
BIGNUM *p;
EVP_PKEY_CTX *pctx = NULL;
OSSL_PARAM_BLD *tmpl = NULL;
OSSL_PARAM *params = NULL;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
if (s->cert->dh_tmp_auto != 2) {
if (s->s3.tmp.new_cipher->algorithm_auth & (SSL_aNULL | SSL_aPSK)) {
}
/* Do not pick a prime that is too weak for the current security level */
- sec_level_bits = ssl_get_security_level_bits(s, NULL, NULL);
+ sec_level_bits = ssl_get_security_level_bits(SSL_CONNECTION_GET_SSL(s),
+ NULL, NULL);
if (dh_secbits < sec_level_bits)
dh_secbits = sec_level_bits;
if (p == NULL)
goto err;
- pctx = EVP_PKEY_CTX_new_from_name(s->ctx->libctx, "DH", s->ctx->propq);
+ pctx = EVP_PKEY_CTX_new_from_name(sctx->libctx, "DH", sctx->propq);
if (pctx == NULL
|| EVP_PKEY_fromdata_init(pctx) != 1)
goto err;
return dhp;
}
-static int ssl_security_cert_key(SSL *s, SSL_CTX *ctx, X509 *x, int op)
+static int ssl_security_cert_key(SSL_CONNECTION *s, SSL_CTX *ctx, X509 *x,
+ int op)
{
int secbits = -1;
EVP_PKEY *pkey = X509_get0_pubkey(x);
+
if (pkey) {
/*
* If no parameters this will return -1 and fail using the default
*/
secbits = EVP_PKEY_get_security_bits(pkey);
}
- if (s)
+ if (s != NULL)
return ssl_security(s, op, secbits, 0, x);
else
return ssl_ctx_security(ctx, op, secbits, 0, x);
}
-static int ssl_security_cert_sig(SSL *s, SSL_CTX *ctx, X509 *x, int op)
+static int ssl_security_cert_sig(SSL_CONNECTION *s, SSL_CTX *ctx, X509 *x,
+ int op)
{
/* Lookup signature algorithm digest */
int secbits, nid, pknid;
+
/* Don't check signature if self signed */
if ((X509_get_extension_flags(x) & EXFLAG_SS) != 0)
return 1;
/* If digest NID not defined use signature NID */
if (nid == NID_undef)
nid = pknid;
- if (s)
+ if (s != NULL)
return ssl_security(s, op, secbits, nid, x);
else
return ssl_ctx_security(ctx, op, secbits, nid, x);
}
-int ssl_security_cert(SSL *s, SSL_CTX *ctx, X509 *x, int vfy, int is_ee)
+int ssl_security_cert(SSL_CONNECTION *s, SSL_CTX *ctx, X509 *x, int vfy,
+ int is_ee)
{
if (vfy)
vfy = SSL_SECOP_PEER;
* one to the peer. Return values: 1 if ok otherwise error code to use
*/
-int ssl_security_cert_chain(SSL *s, STACK_OF(X509) *sk, X509 *x, int vfy)
+int ssl_security_cert_chain(SSL_CONNECTION *s, STACK_OF(X509) *sk,
+ X509 *x, int vfy)
{
int rv, start_idx, i;
+
if (x == NULL) {
x = sk_X509_value(sk, 0);
if (x == NULL)
* with the signature algorithm "lu" and return index of certificate.
*/
-static int tls12_get_cert_sigalg_idx(const SSL *s, const SIGALG_LOOKUP *lu)
+static int tls12_get_cert_sigalg_idx(const SSL_CONNECTION *s,
+ const SIGALG_LOOKUP *lu)
{
int sig_idx = lu->sig_idx;
const SSL_CERT_LOOKUP *clu = ssl_cert_lookup_by_idx(sig_idx);
* the key.
* Returns true if the cert is usable and false otherwise.
*/
-static int check_cert_usable(SSL *s, const SIGALG_LOOKUP *sig, X509 *x,
- EVP_PKEY *pkey)
+static int check_cert_usable(SSL_CONNECTION *s, const SIGALG_LOOKUP *sig,
+ X509 *x, EVP_PKEY *pkey)
{
const SIGALG_LOOKUP *lu;
int mdnid, pknid, supported;
size_t i;
const char *mdname = NULL;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
/*
* If the given EVP_PKEY cannot support signing with this digest,
*/
if (sig->hash != NID_undef)
mdname = OBJ_nid2sn(sig->hash);
- supported = EVP_PKEY_digestsign_supports_digest(pkey, s->ctx->libctx,
+ supported = EVP_PKEY_digestsign_supports_digest(pkey, sctx->libctx,
mdname,
- s->ctx->propq);
+ sctx->propq);
if (supported <= 0)
return 0;
* the signature_algorithm_cert restrictions sent by the peer (if any).
* Returns false if no usable certificate is found.
*/
-static int has_usable_cert(SSL *s, const SIGALG_LOOKUP *sig, int idx)
+static int has_usable_cert(SSL_CONNECTION *s, const SIGALG_LOOKUP *sig, int idx)
{
/* TLS 1.2 callers can override sig->sig_idx, but not TLS 1.3 callers. */
if (idx == -1)
* Returns true if the supplied cert |x| and key |pkey| is usable with the
* specified signature scheme |sig|, or false otherwise.
*/
-static int is_cert_usable(SSL *s, const SIGALG_LOOKUP *sig, X509 *x,
+static int is_cert_usable(SSL_CONNECTION *s, const SIGALG_LOOKUP *sig, X509 *x,
EVP_PKEY *pkey)
{
size_t idx;
* |pkey|. |x| and |pkey| may be NULL in which case we additionally look at our
* available certs/keys to find one that works.
*/
-static const SIGALG_LOOKUP *find_sig_alg(SSL *s, X509 *x, EVP_PKEY *pkey)
+static const SIGALG_LOOKUP *find_sig_alg(SSL_CONNECTION *s, X509 *x,
+ EVP_PKEY *pkey)
{
const SIGALG_LOOKUP *lu = NULL;
size_t i;
int curve = -1;
EVP_PKEY *tmppkey;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
/* Look for a shared sigalgs matching possible certificates */
for (i = 0; i < s->shared_sigalgslen; i++) {
|| lu->sig == EVP_PKEY_RSA)
continue;
/* Check that we have a cert, and signature_algorithms_cert */
- if (!tls1_lookup_md(s->ctx, lu, NULL))
+ if (!tls1_lookup_md(sctx, lu, NULL))
continue;
if ((pkey == NULL && !has_usable_cert(s, lu, -1))
|| (pkey != NULL && !is_cert_usable(s, lu, x, pkey)))
continue;
} else if (lu->sig == EVP_PKEY_RSA_PSS) {
/* validate that key is large enough for the signature algorithm */
- if (!rsa_pss_check_min_key_size(s->ctx, tmppkey, lu))
+ if (!rsa_pss_check_min_key_size(sctx, tmppkey, lu))
continue;
}
break;
* a fatal error: we will either try another certificate or not present one
* to the server. In this case no error is set.
*/
-int tls_choose_sigalg(SSL *s, int fatalerrs)
+int tls_choose_sigalg(SSL_CONNECTION *s, int fatalerrs)
{
const SIGALG_LOOKUP *lu = NULL;
int sig_idx = -1;
s->s3.tmp.cert = NULL;
s->s3.tmp.sigalg = NULL;
- if (SSL_IS_TLS13(s)) {
+ if (SSL_CONNECTION_IS_TLS13(s)) {
lu = find_sig_alg(s, NULL, NULL);
if (lu == NULL) {
if (!fatalerrs)
size_t i;
if (s->s3.tmp.peer_sigalgs != NULL) {
int curve = -1;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
/* For Suite B need to match signature algorithm to curve */
if (tls1_suiteb(s))
/* validate that key is large enough for the signature algorithm */
EVP_PKEY *pkey = s->cert->pkeys[sig_idx].privatekey;
- if (!rsa_pss_check_min_key_size(s->ctx, pkey, lu))
+ if (!rsa_pss_check_min_key_size(sctx, pkey, lu))
continue;
}
if (curve == -1 || lu->curve == curve)
* in supported_algorithms extension, so when we have GOST-based ciphersuite,
* we have to assume GOST support.
*/
- if (i == s->shared_sigalgslen && s->s3.tmp.new_cipher->algorithm_auth & (SSL_aGOST01 | SSL_aGOST12)) {
+ if (i == s->shared_sigalgslen
+ && (s->s3.tmp.new_cipher->algorithm_auth
+ & (SSL_aGOST01 | SSL_aGOST12)) != 0) {
if ((lu = tls1_get_legacy_sigalg(s, -1)) == NULL) {
if (!fatalerrs)
return 1;
int SSL_set_tlsext_max_fragment_length(SSL *ssl, uint8_t mode)
{
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
+
+ if (sc == NULL)
+ return 0;
+
if (mode != TLSEXT_max_fragment_length_DISABLED
&& !IS_MAX_FRAGMENT_LENGTH_EXT_VALID(mode)) {
ERR_raise(ERR_LIB_SSL, SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH);
return 0;
}
- ssl->ext.max_fragment_len_mode = mode;
+ sc->ext.max_fragment_len_mode = mode;
return 1;
}
return 1;
}
-static int ssl_print_signature(BIO *bio, int indent, const SSL *ssl,
+static int ssl_print_signature(BIO *bio, int indent, const SSL_CONNECTION *sc,
const unsigned char **pmsg, size_t *pmsglen)
{
if (*pmsglen < 2)
return 0;
- if (SSL_USE_SIGALGS(ssl)) {
+ if (SSL_USE_SIGALGS(sc)) {
const unsigned char *p = *pmsg;
unsigned int sigalg = (p[0] << 8) | p[1];
return 1;
}
-static int ssl_print_client_hello(BIO *bio, const SSL *ssl, int indent,
+static int ssl_print_client_hello(BIO *bio, const SSL_CONNECTION *sc, int indent,
const unsigned char *msg, size_t msglen)
{
size_t len;
return 0;
if (!ssl_print_hexbuf(bio, indent, "session_id", 1, &msg, &msglen))
return 0;
- if (SSL_IS_DTLS(ssl)) {
+ if (SSL_CONNECTION_IS_DTLS(sc)) {
if (!ssl_print_hexbuf(bio, indent, "cookie", 1, &msg, &msglen))
return 0;
}
return 1;
}
-static int ssl_get_keyex(const char **pname, const SSL *ssl)
+static int ssl_get_keyex(const char **pname, const SSL_CONNECTION *sc)
{
- unsigned long alg_k = ssl->s3.tmp.new_cipher->algorithm_mkey;
+ unsigned long alg_k = sc->s3.tmp.new_cipher->algorithm_mkey;
if (alg_k & SSL_kRSA) {
*pname = "rsa";
return 0;
}
-static int ssl_print_client_keyex(BIO *bio, int indent, const SSL *ssl,
+static int ssl_print_client_keyex(BIO *bio, int indent, const SSL_CONNECTION *sc,
const unsigned char *msg, size_t msglen)
{
const char *algname;
- int id = ssl_get_keyex(&algname, ssl);
+ int id = ssl_get_keyex(&algname, sc);
BIO_indent(bio, indent, 80);
BIO_printf(bio, "KeyExchangeAlgorithm=%s\n", algname);
case SSL_kRSA:
case SSL_kRSAPSK:
- if (TLS1_get_version(ssl) == SSL3_VERSION) {
+ if (TLS1_get_version(SSL_CONNECTION_GET_SSL(sc)) == SSL3_VERSION) {
ssl_print_hex(bio, indent + 2,
"EncryptedPreMasterSecret", msg, msglen);
} else {
return !msglen;
}
-static int ssl_print_server_keyex(BIO *bio, int indent, const SSL *ssl,
+static int ssl_print_server_keyex(BIO *bio, int indent, const SSL_CONNECTION *sc,
const unsigned char *msg, size_t msglen)
{
const char *algname;
- int id = ssl_get_keyex(&algname, ssl);
+ int id = ssl_get_keyex(&algname, sc);
BIO_indent(bio, indent, 80);
BIO_printf(bio, "KeyExchangeAlgorithm=%s\n", algname);
break;
}
if (!(id & SSL_PSK))
- ssl_print_signature(bio, indent, ssl, &msg, &msglen);
+ ssl_print_signature(bio, indent, sc, &msg, &msglen);
return !msglen;
}
return 1;
}
-static int ssl_print_certificates(BIO *bio, const SSL *ssl, int server,
+static int ssl_print_certificates(BIO *bio, const SSL_CONNECTION *sc, int server,
int indent, const unsigned char *msg,
size_t msglen)
{
size_t clen;
- if (SSL_IS_TLS13(ssl)
+ if (SSL_CONNECTION_IS_TLS13(sc)
&& !ssl_print_hexbuf(bio, indent, "context", 1, &msg, &msglen))
return 0;
while (clen > 0) {
if (!ssl_print_certificate(bio, indent + 2, &msg, &clen))
return 0;
- if (SSL_IS_TLS13(ssl)
+ if (SSL_CONNECTION_IS_TLS13(sc)
&& !ssl_print_extensions(bio, indent + 2, server,
SSL3_MT_CERTIFICATE, &msg, &clen))
return 0;
return 1;
}
-static int ssl_print_cert_request(BIO *bio, int indent, const SSL *ssl,
+static int ssl_print_cert_request(BIO *bio, int indent, const SSL_CONNECTION *sc,
const unsigned char *msg, size_t msglen)
{
size_t xlen;
unsigned int sigalg;
- if (SSL_IS_TLS13(ssl)) {
+ if (SSL_CONNECTION_IS_TLS13(sc)) {
if (!ssl_print_hexbuf(bio, indent, "request_context", 1, &msg, &msglen))
return 0;
if (!ssl_print_extensions(bio, indent, 1,
msg += xlen;
msglen -= xlen + 1;
}
- if (SSL_USE_SIGALGS(ssl)) {
+ if (SSL_USE_SIGALGS(sc)) {
if (msglen < 2)
return 0;
xlen = (msg[0] << 8) | msg[1];
xlen -= dlen + 2;
msg += dlen;
}
- if (SSL_IS_TLS13(ssl)) {
+ if (SSL_CONNECTION_IS_TLS13(sc)) {
if (!ssl_print_hexbuf(bio, indent, "request_extensions", 2,
&msg, &msglen))
return 0;
return msglen == 0;
}
-static int ssl_print_ticket(BIO *bio, int indent, const SSL *ssl,
+static int ssl_print_ticket(BIO *bio, int indent, const SSL_CONNECTION *sc,
const unsigned char *msg, size_t msglen)
{
unsigned int tick_life;
msg += 4;
BIO_indent(bio, indent + 2, 80);
BIO_printf(bio, "ticket_lifetime_hint=%u\n", tick_life);
- if (SSL_IS_TLS13(ssl)) {
+ if (SSL_CONNECTION_IS_TLS13(sc)) {
unsigned int ticket_age_add;
if (msglen < 4)
}
if (!ssl_print_hexbuf(bio, indent + 2, "ticket", 2, &msg, &msglen))
return 0;
- if (SSL_IS_TLS13(ssl)
+ if (SSL_CONNECTION_IS_TLS13(sc)
&& !ssl_print_extensions(bio, indent + 2, 0,
SSL3_MT_NEWSESSION_TICKET, &msg, &msglen))
return 0;
return 1;
}
-static int ssl_print_handshake(BIO *bio, const SSL *ssl, int server,
+static int ssl_print_handshake(BIO *bio, const SSL_CONNECTION *sc, int server,
const unsigned char *msg, size_t msglen,
int indent)
{
ssl_trace_str(htype, ssl_handshake_tbl), (int)hlen);
msg += 4;
msglen -= 4;
- if (SSL_IS_DTLS(ssl)) {
+ if (SSL_CONNECTION_IS_DTLS(sc)) {
if (msglen < 8)
return 0;
BIO_indent(bio, indent, 80);
return 0;
switch (htype) {
case SSL3_MT_CLIENT_HELLO:
- if (!ssl_print_client_hello(bio, ssl, indent + 2, msg, msglen))
+ if (!ssl_print_client_hello(bio, sc, indent + 2, msg, msglen))
return 0;
break;
break;
case SSL3_MT_SERVER_KEY_EXCHANGE:
- if (!ssl_print_server_keyex(bio, indent + 2, ssl, msg, msglen))
+ if (!ssl_print_server_keyex(bio, indent + 2, sc, msg, msglen))
return 0;
break;
case SSL3_MT_CLIENT_KEY_EXCHANGE:
- if (!ssl_print_client_keyex(bio, indent + 2, ssl, msg, msglen))
+ if (!ssl_print_client_keyex(bio, indent + 2, sc, msg, msglen))
return 0;
break;
case SSL3_MT_CERTIFICATE:
- if (!ssl_print_certificates(bio, ssl, server, indent + 2, msg, msglen))
+ if (!ssl_print_certificates(bio, sc, server, indent + 2, msg, msglen))
return 0;
break;
case SSL3_MT_CERTIFICATE_VERIFY:
- if (!ssl_print_signature(bio, indent + 2, ssl, &msg, &msglen))
+ if (!ssl_print_signature(bio, indent + 2, sc, &msg, &msglen))
return 0;
break;
case SSL3_MT_CERTIFICATE_REQUEST:
- if (!ssl_print_cert_request(bio, indent + 2, ssl, msg, msglen))
+ if (!ssl_print_cert_request(bio, indent + 2, sc, msg, msglen))
return 0;
break;
break;
case SSL3_MT_NEWSESSION_TICKET:
- if (!ssl_print_ticket(bio, indent + 2, ssl, msg, msglen))
+ if (!ssl_print_ticket(bio, indent + 2, sc, msg, msglen))
return 0;
break;
{
const unsigned char *msg = buf;
BIO *bio = arg;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
+
+ if (sc == NULL)
+ return;
switch (content_type) {
case SSL3_RT_HEADER:
int hvers;
/* avoid overlapping with length at the end of buffer */
- if (msglen < (size_t)(SSL_IS_DTLS(ssl) ?
+ if (msglen < (size_t)(SSL_CONNECTION_IS_DTLS(sc) ?
DTLS1_RT_HEADER_LENGTH : SSL3_RT_HEADER_LENGTH)) {
BIO_puts(bio, write_p ? "Sent" : "Received");
ssl_print_hex(bio, 0, " too short message", msg, msglen);
BIO_puts(bio, write_p ? "Sent" : "Received");
BIO_printf(bio, " Record\nHeader:\n Version = %s (0x%x)\n",
ssl_trace_str(hvers, ssl_version_tbl), hvers);
- if (SSL_IS_DTLS(ssl)) {
+ if (SSL_CONNECTION_IS_DTLS(sc)) {
BIO_printf(bio,
" epoch=%d, sequence_number=%04x%04x%04x\n",
(msg[3] << 8 | msg[4]),
break;
case SSL3_RT_HANDSHAKE:
- if (!ssl_print_handshake(bio, ssl, ssl->server ? write_p : !write_p,
+ if (!ssl_print_handshake(bio, sc, sc->server ? write_p : !write_p,
msg, msglen, 4))
BIO_printf(bio, "Message length parse error!\n");
break;
* The |data| value may be zero length. Any errors will be treated as fatal if
* |fatal| is set. Returns 1 on success 0 on failure.
*/
-int tls13_hkdf_expand(SSL *s, const EVP_MD *md, const unsigned char *secret,
+int tls13_hkdf_expand(SSL_CONNECTION *s, const EVP_MD *md,
+ const unsigned char *secret,
const unsigned char *label, size_t labellen,
const unsigned char *data, size_t datalen,
unsigned char *out, size_t outlen, int fatal)
{
- EVP_KDF *kdf = EVP_KDF_fetch(s->ctx->libctx, OSSL_KDF_NAME_TLS1_3_KDF,
- s->ctx->propq);
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
+ EVP_KDF *kdf = EVP_KDF_fetch(sctx->libctx, OSSL_KDF_NAME_TLS1_3_KDF,
+ sctx->propq);
EVP_KDF_CTX *kctx;
OSSL_PARAM params[7], *p = params;
int mode = EVP_PKEY_HKDEF_MODE_EXPAND_ONLY;
* Given a |secret| generate a |key| of length |keylen| bytes. Returns 1 on
* success 0 on failure.
*/
-int tls13_derive_key(SSL *s, const EVP_MD *md, const unsigned char *secret,
+int tls13_derive_key(SSL_CONNECTION *s, const EVP_MD *md,
+ const unsigned char *secret,
unsigned char *key, size_t keylen)
{
#ifdef CHARSET_EBCDIC
* Given a |secret| generate an |iv| of length |ivlen| bytes. Returns 1 on
* success 0 on failure.
*/
-int tls13_derive_iv(SSL *s, const EVP_MD *md, const unsigned char *secret,
+int tls13_derive_iv(SSL_CONNECTION *s, const EVP_MD *md,
+ const unsigned char *secret,
unsigned char *iv, size_t ivlen)
{
#ifdef CHARSET_EBCDIC
NULL, 0, iv, ivlen, 1);
}
-int tls13_derive_finishedkey(SSL *s, const EVP_MD *md,
+int tls13_derive_finishedkey(SSL_CONNECTION *s, const EVP_MD *md,
const unsigned char *secret,
unsigned char *fin, size_t finlen)
{
* length |insecretlen|, generate a new secret and store it in the location
* pointed to by |outsecret|. Returns 1 on success 0 on failure.
*/
-int tls13_generate_secret(SSL *s, const EVP_MD *md,
+int tls13_generate_secret(SSL_CONNECTION *s, const EVP_MD *md,
const unsigned char *prevsecret,
const unsigned char *insecret,
size_t insecretlen,
#else
static const char derived_secret_label[] = "derived";
#endif
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
- kdf = EVP_KDF_fetch(s->ctx->libctx, OSSL_KDF_NAME_TLS1_3_KDF, s->ctx->propq);
+ kdf = EVP_KDF_fetch(sctx->libctx, OSSL_KDF_NAME_TLS1_3_KDF, sctx->propq);
kctx = EVP_KDF_CTX_new(kdf);
EVP_KDF_free(kdf);
if (kctx == NULL) {
* handshake secret. This requires the early secret to already have been
* generated. Returns 1 on success 0 on failure.
*/
-int tls13_generate_handshake_secret(SSL *s, const unsigned char *insecret,
- size_t insecretlen)
+int tls13_generate_handshake_secret(SSL_CONNECTION *s,
+ const unsigned char *insecret,
+ size_t insecretlen)
{
/* Calls SSLfatal() if required */
return tls13_generate_secret(s, ssl_handshake_md(s), s->early_secret,
* secret and store its length in |*secret_size|. Returns 1 on success 0 on
* failure.
*/
-int tls13_generate_master_secret(SSL *s, unsigned char *out,
+int tls13_generate_master_secret(SSL_CONNECTION *s, unsigned char *out,
unsigned char *prev, size_t prevlen,
size_t *secret_size)
{
* Generates the mac for the Finished message. Returns the length of the MAC or
* 0 on error.
*/
-size_t tls13_final_finish_mac(SSL *s, const char *str, size_t slen,
+size_t tls13_final_finish_mac(SSL_CONNECTION *s, const char *str, size_t slen,
unsigned char *out)
{
const EVP_MD *md = ssl_handshake_md(s);
unsigned char *key = NULL;
size_t len = 0, hashlen;
OSSL_PARAM params[2], *p = params;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
if (md == NULL)
return 0;
/* Safe to cast away const here since we're not "getting" any data */
- if (s->ctx->propq != NULL)
+ if (sctx->propq != NULL)
*p++ = OSSL_PARAM_construct_utf8_string(OSSL_ALG_PARAM_PROPERTIES,
- (char *)s->ctx->propq,
+ (char *)sctx->propq,
0);
*p = OSSL_PARAM_construct_end();
goto err;
}
- if (str == s->method->ssl3_enc->server_finished_label) {
+ if (str == SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->server_finished_label) {
key = s->server_finished_secret;
} else if (SSL_IS_FIRST_HANDSHAKE(s)) {
key = s->client_finished_secret;
key = finsecret;
}
- if (!EVP_Q_mac(s->ctx->libctx, "HMAC", s->ctx->propq, mdname,
+ if (!EVP_Q_mac(sctx->libctx, "HMAC", sctx->propq, mdname,
params, key, hashlen, hash, hashlen,
/* outsize as per sizeof(peer_finish_md) */
out, EVP_MAX_MD_SIZE * 2, &len)) {
* There isn't really a key block in TLSv1.3, but we still need this function
* for initialising the cipher and hash. Returns 1 on success or 0 on failure.
*/
-int tls13_setup_key_block(SSL *s)
+int tls13_setup_key_block(SSL_CONNECTION *s)
{
const EVP_CIPHER *c;
const EVP_MD *hash;
s->session->cipher = s->s3.tmp.new_cipher;
- if (!ssl_cipher_get_evp(s->ctx, s->session, &c, &hash, NULL, NULL, NULL,
- 0)) {
+ if (!ssl_cipher_get_evp(SSL_CONNECTION_GET_CTX(s), s->session, &c, &hash,
+ NULL, NULL, NULL, 0)) {
/* Error is already recorded */
SSLfatal_alert(s, SSL_AD_INTERNAL_ERROR);
return 0;
return 1;
}
-static int derive_secret_key_and_iv(SSL *s, int sending, const EVP_MD *md,
+static int derive_secret_key_and_iv(SSL_CONNECTION *s, int sending,
+ const EVP_MD *md,
const EVP_CIPHER *ciph,
const unsigned char *insecret,
const unsigned char *hash,
return 1;
}
-int tls13_change_cipher_state(SSL *s, int which)
+int tls13_change_cipher_state(SSL_CONNECTION *s, int which)
{
#ifdef CHARSET_EBCDIC
static const unsigned char client_early_traffic[] = {0x63, 0x20, 0x65, 0x20, /*traffic*/0x74, 0x72, 0x61, 0x66, 0x66, 0x69, 0x63, 0x00};
int ret = 0;
const EVP_MD *md = NULL;
const EVP_CIPHER *cipher = NULL;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
#if !defined(OPENSSL_NO_KTLS) && defined(OPENSSL_KTLS_TLS13)
ktls_crypto_info_t crypto_info;
void *rl_sequence;
* This ups the ref count on cipher so we better make sure we free
* it again
*/
- if (!ssl_cipher_get_evp_cipher(s->ctx, sslcipher, &cipher)) {
+ if (!ssl_cipher_get_evp_cipher(sctx, sslcipher, &cipher)) {
/* Error is already recorded */
SSLfatal_alert(s, SSL_AD_INTERNAL_ERROR);
EVP_MD_CTX_free(mdctx);
goto err;
}
- md = ssl_md(s->ctx, sslcipher->algorithm2);
+ md = ssl_md(sctx, sslcipher->algorithm2);
if (md == NULL || !EVP_DigestInit_ex(mdctx, md, NULL)
|| !EVP_DigestUpdate(mdctx, hdata, handlen)
|| !EVP_DigestFinal_ex(mdctx, hashval, &hashlenui)) {
return ret;
}
-int tls13_update_key(SSL *s, int sending)
+int tls13_update_key(SSL_CONNECTION *s, int sending)
{
#ifdef CHARSET_EBCDIC
static const unsigned char application_traffic[] = { 0x74, 0x72 ,0x61 ,0x66 ,0x66 ,0x69 ,0x63 ,0x20 ,0x75 ,0x70 ,0x64, 0x00};
return tls1_alert_code(code);
}
-int tls13_export_keying_material(SSL *s, unsigned char *out, size_t olen,
+int tls13_export_keying_material(SSL_CONNECTION *s,
+ unsigned char *out, size_t olen,
const char *label, size_t llen,
const unsigned char *context,
size_t contextlen, int use_context)
return ret;
}
-int tls13_export_keying_material_early(SSL *s, unsigned char *out, size_t olen,
+int tls13_export_keying_material_early(SSL_CONNECTION *s,
+ unsigned char *out, size_t olen,
const char *label, size_t llen,
const unsigned char *context,
size_t contextlen)
else
sslcipher = SSL_SESSION_get0_cipher(s->session);
- md = ssl_md(s->ctx, sslcipher->algorithm2);
+ md = ssl_md(SSL_CONNECTION_GET_CTX(s), sslcipher->algorithm2);
/*
* Calculate the hash value and store it in |data|. The reason why
}
#ifndef OPENSSL_NO_ENGINE
-int tls_engine_load_ssl_client_cert(SSL *s, X509 **px509, EVP_PKEY **ppkey)
+int tls_engine_load_ssl_client_cert(SSL_CONNECTION *s, X509 **px509,
+ EVP_PKEY **ppkey)
{
- return ENGINE_load_ssl_client_cert(s->ctx->client_cert_engine, s,
- SSL_get_client_CA_list(s),
+ SSL *ssl = SSL_CONNECTION_GET_SSL(s);
+
+ return ENGINE_load_ssl_client_cert(SSL_CONNECTION_GET_CTX(s)->client_cert_engine,
+ ssl,
+ SSL_get_client_CA_list(ssl),
px509, ppkey, NULL, NULL, NULL);
}
#endif
* The public API SSL_SRP_CTX_free() is deprecated so we use
* ssl_srp_ctx_free_intern() internally.
*/
-int ssl_srp_ctx_free_intern(SSL *s)
+int ssl_srp_ctx_free_intern(SSL_CONNECTION *s)
{
if (s == NULL)
return 0;
int SSL_SRP_CTX_free(SSL *s)
{
- return ssl_srp_ctx_free_intern(s);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ /* the call works with NULL sc */
+ return ssl_srp_ctx_free_intern(sc);
}
/*
* The public API SSL_SRP_CTX_init() is deprecated so we use
* ssl_srp_ctx_init_intern() internally.
*/
-int ssl_srp_ctx_init_intern(SSL *s)
+int ssl_srp_ctx_init_intern(SSL_CONNECTION *s)
{
- SSL_CTX *ctx;
+ SSL_CTX *ctx = SSL_CONNECTION_GET_CTX(s);
- if ((s == NULL) || ((ctx = s->ctx) == NULL))
+ if (s == NULL || ctx == NULL)
return 0;
memset(&s->srp_ctx, 0, sizeof(s->srp_ctx));
int SSL_SRP_CTX_init(SSL *s)
{
- return ssl_srp_ctx_init_intern(s);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ /* the call works with NULL sc */
+ return ssl_srp_ctx_init_intern(sc);
}
/*
* The public API SSL_srp_server_param_with_username() is deprecated so we use
* ssl_srp_server_param_with_username_intern() internally.
*/
-int ssl_srp_server_param_with_username_intern(SSL *s, int *ad)
+int ssl_srp_server_param_with_username_intern(SSL_CONNECTION *s, int *ad)
{
unsigned char b[SSL_MAX_MASTER_KEY_LENGTH];
int al;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
*ad = SSL_AD_UNKNOWN_PSK_IDENTITY;
if ((s->srp_ctx.TLS_ext_srp_username_callback != NULL) &&
((al =
- s->srp_ctx.TLS_ext_srp_username_callback(s, ad,
+ s->srp_ctx.TLS_ext_srp_username_callback(SSL_CONNECTION_GET_SSL(s),
+ ad,
s->srp_ctx.SRP_cb_arg)) !=
SSL_ERROR_NONE))
return al;
(s->srp_ctx.s == NULL) || (s->srp_ctx.v == NULL))
return SSL3_AL_FATAL;
- if (RAND_priv_bytes_ex(s->ctx->libctx, b, sizeof(b), 0) <= 0)
+ if (RAND_priv_bytes_ex(SSL_CONNECTION_GET_CTX(s)->libctx, b, sizeof(b),
+ 0) <= 0)
return SSL3_AL_FATAL;
s->srp_ctx.b = BN_bin2bn(b, sizeof(b), NULL);
OPENSSL_cleanse(b, sizeof(b));
return ((s->srp_ctx.B =
SRP_Calc_B_ex(s->srp_ctx.b, s->srp_ctx.N, s->srp_ctx.g,
- s->srp_ctx.v, s->ctx->libctx, s->ctx->propq)) !=
+ s->srp_ctx.v, sctx->libctx, sctx->propq)) !=
NULL) ? SSL_ERROR_NONE : SSL3_AL_FATAL;
}
int SSL_srp_server_param_with_username(SSL *s, int *ad)
{
- return ssl_srp_server_param_with_username_intern(s, ad);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return SSL3_AL_FATAL;
+
+ return ssl_srp_server_param_with_username_intern(sc, ad);
}
/*
int SSL_set_srp_server_param_pw(SSL *s, const char *user, const char *pass,
const char *grp)
{
- SRP_gN *GN = SRP_get_default_gN(grp);
+ SRP_gN *GN;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return -1;
+
+ GN = SRP_get_default_gN(grp);
if (GN == NULL)
return -1;
- s->srp_ctx.N = BN_dup(GN->N);
- s->srp_ctx.g = BN_dup(GN->g);
- BN_clear_free(s->srp_ctx.v);
- s->srp_ctx.v = NULL;
- BN_clear_free(s->srp_ctx.s);
- s->srp_ctx.s = NULL;
- if (!SRP_create_verifier_BN_ex(user, pass, &s->srp_ctx.s, &s->srp_ctx.v,
- s->srp_ctx.N, s->srp_ctx.g, s->ctx->libctx,
+ sc->srp_ctx.N = BN_dup(GN->N);
+ sc->srp_ctx.g = BN_dup(GN->g);
+ BN_clear_free(sc->srp_ctx.v);
+ sc->srp_ctx.v = NULL;
+ BN_clear_free(sc->srp_ctx.s);
+ sc->srp_ctx.s = NULL;
+ if (!SRP_create_verifier_BN_ex(user, pass, &sc->srp_ctx.s, &sc->srp_ctx.v,
+ sc->srp_ctx.N, sc->srp_ctx.g, s->ctx->libctx,
s->ctx->propq))
return -1;
int SSL_set_srp_server_param(SSL *s, const BIGNUM *N, const BIGNUM *g,
BIGNUM *sa, BIGNUM *v, char *info)
{
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return -1;
+
if (N != NULL) {
- if (s->srp_ctx.N != NULL) {
- if (!BN_copy(s->srp_ctx.N, N)) {
- BN_free(s->srp_ctx.N);
- s->srp_ctx.N = NULL;
+ if (sc->srp_ctx.N != NULL) {
+ if (!BN_copy(sc->srp_ctx.N, N)) {
+ BN_free(sc->srp_ctx.N);
+ sc->srp_ctx.N = NULL;
}
} else
- s->srp_ctx.N = BN_dup(N);
+ sc->srp_ctx.N = BN_dup(N);
}
if (g != NULL) {
- if (s->srp_ctx.g != NULL) {
- if (!BN_copy(s->srp_ctx.g, g)) {
- BN_free(s->srp_ctx.g);
- s->srp_ctx.g = NULL;
+ if (sc->srp_ctx.g != NULL) {
+ if (!BN_copy(sc->srp_ctx.g, g)) {
+ BN_free(sc->srp_ctx.g);
+ sc->srp_ctx.g = NULL;
}
} else
- s->srp_ctx.g = BN_dup(g);
+ sc->srp_ctx.g = BN_dup(g);
}
if (sa != NULL) {
- if (s->srp_ctx.s != NULL) {
- if (!BN_copy(s->srp_ctx.s, sa)) {
- BN_free(s->srp_ctx.s);
- s->srp_ctx.s = NULL;
+ if (sc->srp_ctx.s != NULL) {
+ if (!BN_copy(sc->srp_ctx.s, sa)) {
+ BN_free(sc->srp_ctx.s);
+ sc->srp_ctx.s = NULL;
}
} else
- s->srp_ctx.s = BN_dup(sa);
+ sc->srp_ctx.s = BN_dup(sa);
}
if (v != NULL) {
- if (s->srp_ctx.v != NULL) {
- if (!BN_copy(s->srp_ctx.v, v)) {
- BN_free(s->srp_ctx.v);
- s->srp_ctx.v = NULL;
+ if (sc->srp_ctx.v != NULL) {
+ if (!BN_copy(sc->srp_ctx.v, v)) {
+ BN_free(sc->srp_ctx.v);
+ sc->srp_ctx.v = NULL;
}
} else
- s->srp_ctx.v = BN_dup(v);
+ sc->srp_ctx.v = BN_dup(v);
}
if (info != NULL) {
- if (s->srp_ctx.info)
- OPENSSL_free(s->srp_ctx.info);
- if ((s->srp_ctx.info = OPENSSL_strdup(info)) == NULL)
+ if (sc->srp_ctx.info)
+ OPENSSL_free(sc->srp_ctx.info);
+ if ((sc->srp_ctx.info = OPENSSL_strdup(info)) == NULL)
return -1;
}
- if (!(s->srp_ctx.N) ||
- !(s->srp_ctx.g) || !(s->srp_ctx.s) || !(s->srp_ctx.v))
+ if (!(sc->srp_ctx.N) ||
+ !(sc->srp_ctx.g) || !(sc->srp_ctx.s) || !(sc->srp_ctx.v))
return -1;
return 1;
}
-int srp_generate_server_master_secret(SSL *s)
+int srp_generate_server_master_secret(SSL_CONNECTION *s)
{
BIGNUM *K = NULL, *u = NULL;
int ret = 0, tmp_len = 0;
unsigned char *tmp = NULL;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
if (!SRP_Verify_A_mod_N(s->srp_ctx.A, s->srp_ctx.N))
goto err;
if ((u = SRP_Calc_u_ex(s->srp_ctx.A, s->srp_ctx.B, s->srp_ctx.N,
- s->ctx->libctx, s->ctx->propq)) == NULL)
+ sctx->libctx, sctx->propq)) == NULL)
goto err;
if ((K = SRP_Calc_server_key(s->srp_ctx.A, s->srp_ctx.v, u, s->srp_ctx.b,
s->srp_ctx.N)) == NULL)
}
/* client side */
-int srp_generate_client_master_secret(SSL *s)
+int srp_generate_client_master_secret(SSL_CONNECTION *s)
{
BIGNUM *x = NULL, *u = NULL, *K = NULL;
int ret = 0, tmp_len = 0;
char *passwd = NULL;
unsigned char *tmp = NULL;
+ SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
/*
* Checks if b % n == 0
*/
if (SRP_Verify_B_mod_N(s->srp_ctx.B, s->srp_ctx.N) == 0
|| (u = SRP_Calc_u_ex(s->srp_ctx.A, s->srp_ctx.B, s->srp_ctx.N,
- s->ctx->libctx, s->ctx->propq))
+ sctx->libctx, sctx->propq))
== NULL
|| s->srp_ctx.SRP_give_srp_client_pwd_callback == NULL) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
goto err;
}
- if ((passwd = s->srp_ctx.SRP_give_srp_client_pwd_callback(s,
- s->srp_ctx.SRP_cb_arg))
+ if ((passwd = s->srp_ctx.SRP_give_srp_client_pwd_callback(SSL_CONNECTION_GET_SSL(s),
+ s->srp_ctx.SRP_cb_arg))
== NULL) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_CALLBACK_FAILED);
goto err;
}
if ((x = SRP_Calc_x_ex(s->srp_ctx.s, s->srp_ctx.login, passwd,
- s->ctx->libctx, s->ctx->propq)) == NULL
+ sctx->libctx, sctx->propq)) == NULL
|| (K = SRP_Calc_client_key_ex(s->srp_ctx.N, s->srp_ctx.B,
s->srp_ctx.g, x,
s->srp_ctx.a, u,
- s->ctx->libctx,
- s->ctx->propq)) == NULL) {
+ sctx->libctx,
+ sctx->propq)) == NULL) {
SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
goto err;
}
return ret;
}
-int srp_verify_server_param(SSL *s)
+int srp_verify_server_param(SSL_CONNECTION *s)
{
SRP_CTX *srp = &s->srp_ctx;
/*
}
if (srp->SRP_verify_param_callback) {
- if (srp->SRP_verify_param_callback(s, srp->SRP_cb_arg) <= 0) {
+ if (srp->SRP_verify_param_callback(SSL_CONNECTION_GET_SSL(s),
+ srp->SRP_cb_arg) <= 0) {
SSLfatal(s, SSL_AD_INSUFFICIENT_SECURITY, SSL_R_CALLBACK_FAILED);
return 0;
}
* The public API SRP_Calc_A_param() is deprecated so we use
* ssl_srp_calc_a_param_intern() internally.
*/
-int ssl_srp_calc_a_param_intern(SSL *s)
+int ssl_srp_calc_a_param_intern(SSL_CONNECTION *s)
{
unsigned char rnd[SSL_MAX_MASTER_KEY_LENGTH];
- if (RAND_priv_bytes_ex(s->ctx->libctx, rnd, sizeof(rnd), 0) <= 0)
+ if (RAND_priv_bytes_ex(SSL_CONNECTION_GET_CTX(s)->libctx,
+ rnd, sizeof(rnd), 0) <= 0)
return 0;
s->srp_ctx.a = BN_bin2bn(rnd, sizeof(rnd), s->srp_ctx.a);
OPENSSL_cleanse(rnd, sizeof(rnd));
int SRP_Calc_A_param(SSL *s)
{
- return ssl_srp_calc_a_param_intern(s);
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return 0;
+
+ return ssl_srp_calc_a_param_intern(sc);
}
BIGNUM *SSL_get_srp_g(SSL *s)
{
- if (s->srp_ctx.g != NULL)
- return s->srp_ctx.g;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return NULL;
+
+ if (sc->srp_ctx.g != NULL)
+ return sc->srp_ctx.g;
return s->ctx->srp_ctx.g;
}
BIGNUM *SSL_get_srp_N(SSL *s)
{
- if (s->srp_ctx.N != NULL)
- return s->srp_ctx.N;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return NULL;
+
+ if (sc->srp_ctx.N != NULL)
+ return sc->srp_ctx.N;
return s->ctx->srp_ctx.N;
}
char *SSL_get_srp_username(SSL *s)
{
- if (s->srp_ctx.login != NULL)
- return s->srp_ctx.login;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return NULL;
+
+ if (sc->srp_ctx.login != NULL)
+ return sc->srp_ctx.login;
return s->ctx->srp_ctx.login;
}
char *SSL_get_srp_userinfo(SSL *s)
{
- if (s->srp_ctx.info != NULL)
- return s->srp_ctx.info;
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+ if (sc == NULL)
+ return NULL;
+
+ if (sc->srp_ctx.info != NULL)
+ return sc->srp_ctx.info;
return s->ctx->srp_ctx.info;
}
size_t mtus[30];
unsigned char buf[600];
int rv = 0;
+ SSL_CONNECTION *clnt_sc;
memset(buf, 0x5a, sizeof(buf));
}
}
}
+ if (!TEST_ptr(clnt_sc = SSL_CONNECTION_FROM_SSL_ONLY(clnt_ssl)))
+ goto end;
rv = 1;
- if (SSL_READ_ETM(clnt_ssl))
+ if (SSL_READ_ETM(clnt_sc))
rv = 2;
end:
SSL_free(clnt_ssl);
return;
} else if (test_ctx->handshake_mode == SSL_TEST_HANDSHAKE_POST_HANDSHAKE_AUTH) {
if (SSL_is_server(peer->ssl)) {
+ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(peer->ssl);
+
+ if (sc == NULL) {
+ peer->status = PEER_ERROR;
+ return;
+ }
/* Make the server believe it's received the extension */
if (test_ctx->extra.server.force_pha)
- peer->ssl->post_handshake_auth = SSL_PHA_EXT_RECEIVED;
+ sc->post_handshake_auth = SSL_PHA_EXT_RECEIVED;
ret = SSL_verify_client_post_handshake(peer->ssl);
if (!ret) {
peer->status = PEER_ERROR;
char srec_wseq_after[SEQ_NUM_SIZE];
char srec_rseq_before[SEQ_NUM_SIZE];
char srec_rseq_after[SEQ_NUM_SIZE];
+ SSL_CONNECTION *clientsc, *serversc;
+
+ if (!TEST_ptr(clientsc = SSL_CONNECTION_FROM_SSL_ONLY(clientssl))
+ || !TEST_ptr(serversc = SSL_CONNECTION_FROM_SSL_ONLY(serverssl)))
+ goto end;
cbuf[0] = count++;
- memcpy(crec_wseq_before, &clientssl->rlayer.write_sequence, SEQ_NUM_SIZE);
- memcpy(crec_rseq_before, &clientssl->rlayer.read_sequence, SEQ_NUM_SIZE);
- memcpy(srec_wseq_before, &serverssl->rlayer.write_sequence, SEQ_NUM_SIZE);
- memcpy(srec_rseq_before, &serverssl->rlayer.read_sequence, SEQ_NUM_SIZE);
+ memcpy(crec_wseq_before, &clientsc->rlayer.write_sequence, SEQ_NUM_SIZE);
+ memcpy(crec_rseq_before, &clientsc->rlayer.read_sequence, SEQ_NUM_SIZE);
+ memcpy(srec_wseq_before, &serversc->rlayer.write_sequence, SEQ_NUM_SIZE);
+ memcpy(srec_rseq_before, &serversc->rlayer.read_sequence, SEQ_NUM_SIZE);
if (!TEST_true(SSL_write(clientssl, cbuf, sizeof(cbuf)) == sizeof(cbuf)))
goto end;
}
}
- memcpy(crec_wseq_after, &clientssl->rlayer.write_sequence, SEQ_NUM_SIZE);
- memcpy(crec_rseq_after, &clientssl->rlayer.read_sequence, SEQ_NUM_SIZE);
- memcpy(srec_wseq_after, &serverssl->rlayer.write_sequence, SEQ_NUM_SIZE);
- memcpy(srec_rseq_after, &serverssl->rlayer.read_sequence, SEQ_NUM_SIZE);
+ memcpy(crec_wseq_after, &clientsc->rlayer.write_sequence, SEQ_NUM_SIZE);
+ memcpy(crec_rseq_after, &clientsc->rlayer.read_sequence, SEQ_NUM_SIZE);
+ memcpy(srec_wseq_after, &serversc->rlayer.write_sequence, SEQ_NUM_SIZE);
+ memcpy(srec_rseq_after, &serversc->rlayer.read_sequence, SEQ_NUM_SIZE);
/* verify the payload */
if (!TEST_mem_eq(cbuf, sizeof(cbuf), sbuf, sizeof(sbuf)))
* If ktls is used then kernel sequences are used instead of
* OpenSSL sequences
*/
- if (!BIO_get_ktls_send(clientssl->wbio)) {
+ if (!BIO_get_ktls_send(clientsc->wbio)) {
if (!TEST_mem_ne(crec_wseq_before, SEQ_NUM_SIZE,
crec_wseq_after, SEQ_NUM_SIZE))
goto end;
goto end;
}
- if (!BIO_get_ktls_send(serverssl->wbio)) {
+ if (!BIO_get_ktls_send(serversc->wbio)) {
if (!TEST_mem_ne(srec_wseq_before, SEQ_NUM_SIZE,
srec_wseq_after, SEQ_NUM_SIZE))
goto end;
goto end;
}
- if (!BIO_get_ktls_recv(clientssl->wbio)) {
+ if (!BIO_get_ktls_recv(clientsc->wbio)) {
if (!TEST_mem_ne(crec_rseq_before, SEQ_NUM_SIZE,
crec_rseq_after, SEQ_NUM_SIZE))
goto end;
goto end;
}
- if (!BIO_get_ktls_recv(serverssl->wbio)) {
+ if (!BIO_get_ktls_recv(serversc->wbio)) {
if (!TEST_mem_ne(srec_rseq_before, SEQ_NUM_SIZE,
srec_rseq_after, SEQ_NUM_SIZE))
goto end;
int ktls_used = 0, testresult = 0;
int cfd = -1, sfd = -1;
int rx_supported;
+ SSL_CONNECTION *clientsc, *serversc;
if (!TEST_true(create_test_sockets(&cfd, &sfd)))
goto end;
&clientssl, sfd, cfd)))
goto end;
+ if (!TEST_ptr(clientsc = SSL_CONNECTION_FROM_SSL_ONLY(clientssl))
+ || !TEST_ptr(serversc = SSL_CONNECTION_FROM_SSL_ONLY(serverssl)))
+ goto end;
+
if (cis_ktls) {
if (!TEST_true(SSL_set_options(clientssl, SSL_OP_ENABLE_KTLS)))
goto end;
* isn't enabled.
*/
if (!cis_ktls) {
- if (!TEST_false(BIO_get_ktls_send(clientssl->wbio)))
+ if (!TEST_false(BIO_get_ktls_send(clientsc->wbio)))
goto end;
} else {
- if (BIO_get_ktls_send(clientssl->wbio))
+ if (BIO_get_ktls_send(clientsc->wbio))
ktls_used = 1;
}
if (!sis_ktls) {
- if (!TEST_false(BIO_get_ktls_send(serverssl->wbio)))
+ if (!TEST_false(BIO_get_ktls_send(serversc->wbio)))
goto end;
} else {
- if (BIO_get_ktls_send(serverssl->wbio))
+ if (BIO_get_ktls_send(serversc->wbio))
ktls_used = 1;
}
rx_supported = 1;
#endif
if (!cis_ktls || !rx_supported) {
- if (!TEST_false(BIO_get_ktls_recv(clientssl->rbio)))
+ if (!TEST_false(BIO_get_ktls_recv(clientsc->rbio)))
goto end;
} else {
- if (BIO_get_ktls_send(clientssl->rbio))
+ if (BIO_get_ktls_send(clientsc->rbio))
ktls_used = 1;
}
if (!sis_ktls || !rx_supported) {
- if (!TEST_false(BIO_get_ktls_recv(serverssl->rbio)))
+ if (!TEST_false(BIO_get_ktls_recv(serversc->rbio)))
goto end;
} else {
- if (BIO_get_ktls_send(serverssl->rbio))
+ if (BIO_get_ktls_send(serversc->rbio))
ktls_used = 1;
}
off_t chunk_off = 0;
int testresult = 0;
FILE *ffdp;
+ SSL_CONNECTION *serversc;
buf = OPENSSL_zalloc(SENDFILE_SZ);
buf_dst = OPENSSL_zalloc(SENDFILE_SZ);
&clientssl, sfd, cfd)))
goto end;
+ if (!TEST_ptr(serversc = SSL_CONNECTION_FROM_SSL_ONLY(serverssl)))
+ goto end;
+
if (!TEST_true(SSL_set_options(serverssl, SSL_OP_ENABLE_KTLS)))
goto end;
SSL_ERROR_NONE)))
goto end;
- if (!BIO_get_ktls_send(serverssl->wbio)) {
+ if (!BIO_get_ktls_send(serversc->wbio)) {
testresult = TEST_skip("Failed to enable KTLS for %s cipher %s",
tls_version == TLS1_3_VERSION ? "TLS 1.3" :
"TLS 1.2", cipher);
int testresult = 0;
SSL3_RECORD *rr;
void *zbuf;
+ SSL_CONNECTION *serversc;
static unsigned char cbuf[16000];
static unsigned char sbuf[16000];
* layer is a plaintext record. We can gather the pointer to check
* for zeroization after SSL_read().
*/
- rr = serverssl->rlayer.rrec;
+ if (!TEST_ptr(serversc = SSL_CONNECTION_FROM_SSL_ONLY(serverssl)))
+ goto end;
+ rr = serversc->rlayer.rrec;
zbuf = &rr->data[rr->off];
if (!TEST_int_eq(rr->length, sizeof(cbuf)))
goto end;
static int test_tls13_encryption(void)
{
SSL_CTX *ctx = NULL;
- SSL *s = NULL;
+ SSL *ssl = NULL;
SSL3_RECORD rec;
unsigned char *key = NULL, *iv = NULL, *seq = NULL;
const EVP_CIPHER *ciph = EVP_aes_128_gcm();
int ret = 0;
size_t ivlen, ctr;
+ SSL_CONNECTION *s;
/*
* Encrypted TLSv1.3 records always have an outer content type of
goto err;
}
- s = SSL_new(ctx);
- if (!TEST_ptr(s)) {
+ ssl = SSL_new(ctx);
+ if (!TEST_ptr(ssl) || !TEST_ptr(s = SSL_CONNECTION_FROM_SSL_ONLY(ssl))) {
TEST_info("Failed creating SSL");
goto err;
}
if (!TEST_ptr(s->enc_write_ctx))
goto err;
- s->s3.tmp.new_cipher = SSL_CIPHER_find(s, TLS13_AES_128_GCM_SHA256_BYTES);
+ s->s3.tmp.new_cipher = SSL_CIPHER_find(ssl, TLS13_AES_128_GCM_SHA256_BYTES);
if (!TEST_ptr(s->s3.tmp.new_cipher)) {
TEST_info("Failed to find cipher");
goto err;
OPENSSL_free(key);
OPENSSL_free(iv);
OPENSSL_free(seq);
- SSL_free(s);
+ SSL_free(ssl);
SSL_CTX_free(ctx);
return ret;
}
};
/* Mocked out implementations of various functions */
-int ssl3_digest_cached_records(SSL *s, int keep)
+int ssl3_digest_cached_records(SSL_CONNECTION *s, int keep)
{
return 1;
}
static int full_hash = 0;
/* Give a hash of the currently set handshake */
-int ssl_handshake_hash(SSL *s, unsigned char *out, size_t outlen,
+int ssl_handshake_hash(SSL_CONNECTION *s, unsigned char *out, size_t outlen,
size_t *hashlen)
{
if (sizeof(hs_start_hash) > outlen
return 1;
}
-const EVP_MD *ssl_handshake_md(SSL *s)
+const EVP_MD *ssl_handshake_md(SSL_CONNECTION *s)
{
return EVP_sha256();
}
return code;
}
-int ssl_log_secret(SSL *ssl,
+int ssl_log_secret(SSL_CONNECTION *sc,
const char *label,
const uint8_t *secret,
size_t secret_len)
return EVP_sha256();
}
-void ossl_statem_send_fatal(SSL *s, int al)
+void ossl_statem_send_fatal(SSL_CONNECTION *s, int al)
{
}
-void ossl_statem_fatal(SSL *s, int al, int reason, const char *fmt, ...)
+void ossl_statem_fatal(SSL_CONNECTION *s, int al, int reason,
+ const char *fmt, ...)
{
}
-int ossl_statem_export_allowed(SSL *s)
+int ossl_statem_export_allowed(SSL_CONNECTION *s)
{
return 1;
}
-int ossl_statem_export_early_allowed(SSL *s)
+int ossl_statem_export_early_allowed(SSL_CONNECTION *s)
{
return 1;
}
/* End of mocked out code */
-static int test_secret(SSL *s, unsigned char *prk,
+static int test_secret(SSL_CONNECTION *s, unsigned char *prk,
const unsigned char *label, size_t labellen,
const unsigned char *ref_secret,
const unsigned char *ref_key, const unsigned char *ref_iv)
static int test_handshake_secrets(void)
{
SSL_CTX *ctx = NULL;
- SSL *s = NULL;
+ SSL *ssl = NULL;
+ SSL_CONNECTION *s;
int ret = 0;
size_t hashsize;
unsigned char out_master_secret[EVP_MAX_MD_SIZE];
if (!TEST_ptr(ctx))
goto err;
- s = SSL_new(ctx);
- if (!TEST_ptr(s ))
+ ssl = SSL_new(ctx);
+ if (!TEST_ptr(ssl) || !TEST_ptr(s = SSL_CONNECTION_FROM_SSL_ONLY(ssl)))
goto err;
s->session = SSL_SESSION_new();
ret = 1;
err:
- SSL_free(s);
+ SSL_free(ssl);
SSL_CTX_free(ctx);
return ret;
}
projects / openssl.git / commitdiff