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