36#if defined(ENABLE_CRYPTO_MBEDTLS)
50#include <mbedtls/debug.h>
51#include <mbedtls/error.h>
52#include <mbedtls/version.h>
54#if MBEDTLS_VERSION_NUMBER >= 0x02040000
55#include <mbedtls/net_sockets.h>
57#include <mbedtls/net.h>
60#include <mbedtls/oid.h>
61#include <mbedtls/pem.h>
63static const mbedtls_x509_crt_profile openvpn_x509_crt_profile_legacy = {
65 MBEDTLS_X509_ID_FLAG(MBEDTLS_MD_SHA1) | MBEDTLS_X509_ID_FLAG(MBEDTLS_MD_RIPEMD160)
66 | MBEDTLS_X509_ID_FLAG(MBEDTLS_MD_SHA224) | MBEDTLS_X509_ID_FLAG(MBEDTLS_MD_SHA256)
67 | MBEDTLS_X509_ID_FLAG(MBEDTLS_MD_SHA384) | MBEDTLS_X509_ID_FLAG(MBEDTLS_MD_SHA512),
73static const mbedtls_x509_crt_profile openvpn_x509_crt_profile_preferred = {
75 MBEDTLS_X509_ID_FLAG(MBEDTLS_MD_SHA224) | MBEDTLS_X509_ID_FLAG(MBEDTLS_MD_SHA256)
76 | MBEDTLS_X509_ID_FLAG(MBEDTLS_MD_SHA384) | MBEDTLS_X509_ID_FLAG(MBEDTLS_MD_SHA512),
82#define openvpn_x509_crt_profile_suiteb mbedtls_x509_crt_profile_suiteb;
105 ctx->
endpoint = MBEDTLS_SSL_IS_SERVER;
118 ctx->
endpoint = MBEDTLS_SSL_IS_CLIENT;
130 mbedtls_x509_crt_free(ctx->
ca_chain);
136 mbedtls_dhm_free(ctx->
dhm_ctx);
139 mbedtls_x509_crl_free(ctx->
crl);
142#if defined(ENABLE_PKCS11)
146 if (ctx->pkcs11_cert)
148 pkcs11h_certificate_freeCertificate(ctx->pkcs11_cert);
168#ifdef MBEDTLS_SSL_KEYING_MATERIAL_EXPORT
170#elif defined(HAVE_MBEDTLS_SSL_CONF_EXPORT_KEYS_EXT_CB)
180mbedtls_ssl_export_keys_cb(
void *p_expkey,
const unsigned char *ms,
const unsigned char *kb,
181 size_t maclen,
size_t keylen,
size_t ivlen,
182 const unsigned char client_random[32],
183 const unsigned char server_random[32],
184 mbedtls_tls_prf_types tls_prf_type)
190 static_assert(
sizeof(ks_ssl->
ctx->session->master) ==
sizeof(cache->
master_secret),
191 "master size mismatch");
200#elif defined(HAVE_MBEDTLS_SSL_SET_EXPORT_KEYS_CB)
213mbedtls_ssl_export_keys_cb(
void *p_expkey, mbedtls_ssl_key_export_type type,
214 const unsigned char *secret,
size_t secret_len,
215 const unsigned char client_random[32],
216 const unsigned char server_random[32],
221 if (type != MBEDTLS_SSL_KEY_EXPORT_TLS12_MASTER_SECRET)
234 msg(
M_FATAL,
"ERROR: Incorrect TLS 1.2 master secret length: Got %zu, expected %zu",
244#error mbedtls_ssl_conf_export_keys_ext_cb, mbedtls_ssl_set_export_keys_cb or mbedtls_ssl_export_keying_material must be available in mbed TLS
250 void *ekm,
size_t ekm_size)
252 ASSERT(strlen(label) == label_size);
254#if defined(MBEDTLS_SSL_KEYING_MATERIAL_EXPORT)
259 mbedtls_ssl_export_keying_material(ctx, ekm, ekm_size, label, label_size, NULL, 0, 0)))
301tls_translate_cipher_name(
const char *cipher_name)
311 if (0 != strcmp(cipher_name, pair->
iana_name))
314 msg(
M_WARN,
"Deprecated cipher suite name '%s', please use IANA name '%s'",
331 "mbed TLS does not support setting tls-ciphersuites. "
332 "Ignoring TLS 1.3 cipher list: %s",
339 char *tmp_ciphers, *tmp_ciphers_orig, *token;
356 tmp_ciphers_orig = tmp_ciphers =
string_alloc(ciphers, NULL);
358 token = strtok(tmp_ciphers, ":");
361 ctx->
allowed_ciphers[
i] = mbedtls_ssl_get_ciphersuite_id(tls_translate_cipher_name(token));
366 token = strtok(NULL,
":");
368 free(tmp_ciphers_orig);
374 if (!profile || 0 == strcmp(profile,
"legacy") || 0 == strcmp(profile,
"insecure"))
378 else if (0 == strcmp(profile,
"preferred"))
382 else if (0 == strcmp(profile,
"suiteb"))
388 msg(
M_FATAL,
"ERROR: Invalid cert profile: %s", profile);
407 while ((token =
strsep(&tmp_groups, ":")))
409 const mbedtls_ecp_curve_info *ci = mbedtls_ecp_curve_info_from_name(token);
412 msg(
M_WARN,
"Warning unknown curve/group specified: %s", token);
439 if (mbedtls_x509_time_is_future(&ctx->
crt_chain->valid_from))
441 msg(
M_WARN,
"WARNING: Your certificate is not yet valid!");
444 if (mbedtls_x509_time_is_past(&ctx->
crt_chain->valid_to))
446 msg(
M_WARN,
"WARNING: Your certificate has expired!");
455 if (!
mbed_ok(mbedtls_dhm_parse_dhm(ctx->
dhm_ctx, (
const unsigned char *)dh_file,
456 strlen(dh_file) + 1)))
458 msg(
M_FATAL,
"Cannot read inline DH parameters");
465 msg(
M_FATAL,
"Cannot read DH parameters from file %s", dh_file);
476 if (NULL != curve_name)
478 msg(
M_WARN,
"WARNING: mbed TLS builds do not support specifying an "
479 "ECDH curve with --ecdh-curve, using default curves. Use "
480 "--tls-groups to specify curves.");
488 msg(
M_FATAL,
"PKCS #12 files not yet supported for mbed TLS.");
492#ifdef ENABLE_CRYPTOAPI
496 msg(
M_FATAL,
"Windows CryptoAPI not yet supported for mbed TLS.");
512 if (!
mbed_ok(mbedtls_x509_crt_parse(ctx->
crt_chain, (
const unsigned char *)cert_file,
513 strlen(cert_file) + 1)))
515 msg(
M_FATAL,
"Cannot load inline certificate file");
522 msg(
M_FATAL,
"Cannot load certificate file %s", cert_file);
541 strlen(priv_key_file) + 1, NULL, 0,
544 if (MBEDTLS_ERR_PK_PASSWORD_REQUIRED ==
status)
549 ctx->
priv_key, (
const unsigned char *)priv_key_file, strlen(priv_key_file) + 1,
557 if (MBEDTLS_ERR_PK_PASSWORD_REQUIRED ==
status)
567#ifdef ENABLE_MANAGEMENT
573 msg(
M_WARN,
"Cannot load private key file %s",
581 msg(
M_WARN,
"Private key does not match the certificate");
607external_pkcs1_sign(
void *ctx_voidptr,
int (*f_rng)(
void *,
unsigned char *,
size_t),
void *p_rng,
608#
if MBEDTLS_VERSION_NUMBER < 0x03020100
611 mbedtls_md_type_t md_alg,
unsigned int hashlen,
const unsigned char *
hash,
616 uint8_t *to_sign = NULL;
617 size_t asn_len = 0, oid_size = 0;
618 const char *oid = NULL;
622 return MBEDTLS_ERR_RSA_BAD_INPUT_DATA;
625#if MBEDTLS_VERSION_NUMBER < 0x03020100
626 if (MBEDTLS_RSA_PRIVATE != mode)
628 return MBEDTLS_ERR_RSA_BAD_INPUT_DATA;
638 if (md_alg != MBEDTLS_MD_NONE)
640 const mbedtls_md_info_t *md_info = mbedtls_md_info_from_type(md_alg);
643 return (MBEDTLS_ERR_RSA_BAD_INPUT_DATA);
646 if (!
mbed_ok(mbedtls_oid_get_oid_by_md(md_alg, &oid, &oid_size)))
648 return (MBEDTLS_ERR_RSA_BAD_INPUT_DATA);
651 hashlen = mbedtls_md_get_size(md_info);
652 asn_len = 10 + oid_size;
655 if ((SIZE_MAX - hashlen) < asn_len || ctx->
signature_length < (asn_len + hashlen))
657 return MBEDTLS_ERR_RSA_BAD_INPUT_DATA;
661 uint8_t *p = to_sign;
662 if (md_alg != MBEDTLS_MD_NONE)
673 *p++ = MBEDTLS_ASN1_SEQUENCE | MBEDTLS_ASN1_CONSTRUCTED;
674 *p++ = (
unsigned char)(0x08 + oid_size + hashlen);
675 *p++ = MBEDTLS_ASN1_SEQUENCE | MBEDTLS_ASN1_CONSTRUCTED;
676 *p++ = (
unsigned char)(0x04 + oid_size);
677 *p++ = MBEDTLS_ASN1_OID;
678 *p++ = oid_size & 0xFF;
679 memcpy(p, oid, oid_size);
681 *p++ = MBEDTLS_ASN1_NULL;
683 *p++ = MBEDTLS_ASN1_OCTET_STRING;
687 ASSERT(asn_len == p - to_sign);
691 memcpy(p,
hash, hashlen);
696 rv = MBEDTLS_ERR_RSA_PRIVATE_FAILED;
708external_key_len(
void *vctx)
723 msg(
M_WARN,
"ERROR: external key requires a certificate.");
727 if (mbedtls_pk_get_type(&ctx->
crt_chain->pk) != MBEDTLS_PK_RSA)
729 msg(
M_WARN,
"ERROR: external key with mbed TLS requires a "
730 "certificate with an RSA key.");
740 external_pkcs1_sign, external_key_len)))
748#ifdef ENABLE_MANAGEMENT
751management_sign_func(
void *
sign_ctx,
const void *src,
size_t src_len,
void *dst,
size_t dst_len)
754 char *src_b64 = NULL;
755 char *dst_b64 = NULL;
798 msg(
M_FATAL,
"ERROR: mbed TLS cannot handle the capath directive");
801 if (ca_file && ca_inline)
803 if (!
mbed_ok(mbedtls_x509_crt_parse(ctx->
ca_chain, (
const unsigned char *)ca_file,
804 strlen(ca_file) + 1)))
806 msg(
M_FATAL,
"Cannot load inline CA certificates");
814 msg(
M_FATAL,
"Cannot load CA certificate file %s", ca_file);
821 bool extra_certs_inline)
830 if (extra_certs_inline)
832 if (!
mbed_ok(mbedtls_x509_crt_parse(ctx->
crt_chain, (
const unsigned char *)extra_certs_file,
833 strlen(extra_certs_file) + 1)))
835 msg(
M_FATAL,
"Cannot load inline extra-certs file");
840 if (!
mbed_ok(mbedtls_x509_crt_parse_file(ctx->
crt_chain, extra_certs_file)))
842 msg(
M_FATAL,
"Cannot load extra-certs file: %s", extra_certs_file);
874 buf_free_entry(cur_block);
880endless_buf_read(
endless_buffer *in,
unsigned char *out,
size_t out_len)
886 return MBEDTLS_ERR_SSL_WANT_READ;
889 while (in->
first_block != NULL && read_len < out_len)
892 if (block_len <= out_len - read_len)
895 memcpy(out + read_len, cur_entry->data + in->
data_start, block_len);
897 read_len += block_len;
907 buf_free_entry(cur_entry);
921endless_buf_write(
endless_buffer *out,
const unsigned char *in,
size_t len)
924 if (NULL == new_block)
926 return MBEDTLS_ERR_NET_SEND_FAILED;
929 new_block->data = malloc(len);
930 if (NULL == new_block->data)
933 return MBEDTLS_ERR_NET_SEND_FAILED;
936 new_block->length = len;
937 new_block->next_block = NULL;
939 memcpy(new_block->data, in, len);
957ssl_bio_read(
void *ctx,
unsigned char *out,
size_t out_len)
960 return endless_buf_read(&my_ctx->
in, out, out_len);
964ssl_bio_write(
void *ctx,
const unsigned char *in,
size_t in_len)
967 return endless_buf_write(&my_ctx->
out, in, in_len);
971my_debug(
void *ctx,
int level,
const char *file,
int line,
const char *str)
974 msg(my_loglevel,
"mbed TLS msg (%s:%d): %s", file, line, str);
983 static char old_sha256_hash[32] = { 0 };
984 unsigned char sha256_hash[32] = { 0 };
991 if (!
md_full(
"SHA256", cert->tbs.p, cert->tbs.len, sha256_hash))
993 msg(
M_WARN,
"WARNING: failed to personalise random");
996 if (0 != memcmp(old_sha256_hash, sha256_hash,
sizeof(sha256_hash)))
1000 msg(
M_WARN,
"WARNING: failed to personalise random, could not update CTR_DRBG");
1002 memcpy(old_sha256_hash, sha256_hash,
sizeof(old_sha256_hash));
1011#if defined(MBEDTLS_SSL_PROTO_TLS1_3) && defined(MBEDTLS_SSL_KEYING_MATERIAL_EXPORT)
1013#elif defined(MBEDTLS_SSL_PROTO_TLS1_2)
1016#error mbedtls is compiled without support for TLS 1.2 or 1.3
1028tls_version_to_ssl_version(
int tls_ver)
1032#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
1037#if defined(MBEDTLS_SSL_PROTO_TLS1_3)
1043 msg(
M_FATAL,
"%s: invalid or unsupported TLS version %d", __func__, tls_ver);
1053 if (ctx->
crl == NULL)
1057 mbedtls_x509_crl_free(ctx->
crl);
1061 if (!
mbed_ok(mbedtls_x509_crl_parse(ctx->
crl, (
const unsigned char *)crl_file,
1062 strlen(crl_file) + 1)))
1064 msg(
M_WARN,
"CRL: cannot parse inline CRL");
1070 if (!
mbed_ok(mbedtls_x509_crl_parse_file(ctx->
crl, crl_file)))
1072 msg(
M_WARN,
"CRL: cannot read CRL from file %s", crl_file);
1079 mbedtls_x509_crl_free(ctx->
crl);
1093 mbedtls_ssl_config_defaults(ks_ssl->
ssl_config, ssl_ctx->
endpoint, MBEDTLS_SSL_TRANSPORT_STREAM,
1094 MBEDTLS_SSL_PRESET_DEFAULT);
1095#ifdef MBEDTLS_DEBUG_C
1102 mbedtls_debug_set_threshold(3);
1106 mbedtls_debug_set_threshold(2);
1109 mbedtls_ssl_conf_dbg(ks_ssl->
ssl_config, my_debug, NULL);
1127#if defined(MBEDTLS_SSL_RENEGOTIATION)
1128 mbedtls_ssl_conf_renegotiation(ks_ssl->
ssl_config, MBEDTLS_SSL_RENEGOTIATION_DISABLED);
1135#if defined(MBEDTLS_SSL_CBC_RECORD_SPLITTING)
1136 mbedtls_ssl_conf_cbc_record_splitting(ks_ssl->
ssl_config,
1137 MBEDTLS_SSL_CBC_RECORD_SPLITTING_DISABLED);
1151 mbedtls_ssl_conf_authmode(ks_ssl->
ssl_config, MBEDTLS_SSL_VERIFY_OPTIONAL);
1155 mbedtls_ssl_conf_authmode(ks_ssl->
ssl_config, MBEDTLS_SSL_VERIFY_REQUIRED);
1164 const int configured_tls_version_min =
1172 version = tls_version_to_ssl_version(configured_tls_version_min);
1180 const int configured_tls_version_max =
1187 version = tls_version_to_ssl_version(configured_tls_version_max);
1198#if defined(HAVE_MBEDTLS_SSL_CONF_EXPORT_KEYS_EXT_CB) \
1199 && !defined(MBEDTLS_SSL_KEYING_MATERIAL_EXPORT)
1201 mbedtls_ssl_conf_export_keys_ext_cb(ks_ssl->
ssl_config, mbedtls_ssl_export_keys_cb,
session);
1206 mbedtls_ssl_init(ks_ssl->
ctx);
1213#if defined(HAVE_MBEDTLS_SSL_SET_EXPORT_KEYS_CB) && !defined(MBEDTLS_SSL_KEYING_MATERIAL_EXPORT)
1215 mbedtls_ssl_set_export_keys_cb(ks_ssl->
ctx, mbedtls_ssl_export_keys_cb,
session);
1220 mbedtls_ssl_set_bio(ks_ssl->
ctx, ks_ssl->
bio_ctx, ssl_bio_write, ssl_bio_read, NULL);
1227 mbedtls_ssl_send_alert_message(ks_ssl->
ctx, MBEDTLS_SSL_ALERT_LEVEL_FATAL,
1228 MBEDTLS_SSL_ALERT_MSG_CLOSE_NOTIFY);
1240 mbedtls_ssl_free(ks_ssl->
ctx);
1293 retval = mbedtls_ssl_write(ks->
ctx, data, len);
1298 if (MBEDTLS_ERR_SSL_WANT_WRITE == retval || MBEDTLS_ERR_SSL_WANT_READ == retval)
1308 msg(
D_TLS_ERRORS,
"TLS ERROR: write tls_write_plaintext_const incomplete %d/%d", retval,
1347 if (MBEDTLS_ERR_SSL_WANT_WRITE == retval || MBEDTLS_ERR_SSL_WANT_READ == retval)
1392 if (MBEDTLS_ERR_SSL_WANT_WRITE == retval || MBEDTLS_ERR_SSL_WANT_READ == retval)
1400 if (retval != buf->
len)
1402 msg(
D_TLS_ERRORS,
"TLS ERROR: write tls_write_ciphertext incomplete %d/%d", retval,
1438 retval = mbedtls_ssl_read(ks->
ctx,
BPTR(buf), len);
1443 if (MBEDTLS_ERR_SSL_WANT_WRITE == retval || MBEDTLS_ERR_SSL_WANT_READ == retval)
1478 const mbedtls_x509_crt *cert;
1483 snprintf(s1,
sizeof(s1),
"%s %s, cipher %s", prefix, mbedtls_ssl_get_version(ks_ssl->
ctx),
1484 mbedtls_ssl_get_ciphersuite(ks_ssl->
ctx));
1486 cert = mbedtls_ssl_get_peer_cert(ks_ssl->
ctx);
1489 snprintf(s2,
sizeof(s2),
", %u bit key", (
unsigned int)mbedtls_pk_get_bitlen(&cert->pk));
1504 const int *ciphers = mbedtls_ssl_list_ciphersuites();
1510 if (tls_ctx.allowed_ciphers)
1512 ciphers = tls_ctx.allowed_ciphers;
1515 while (*ciphers != 0)
1517 printf(
"%s\n", mbedtls_ssl_get_ciphersuite_name(*ciphers));
1526 const mbedtls_ecp_curve_info *pcurve = mbedtls_ecp_curve_list();
1530 msg(
M_FATAL,
"Cannot retrieve curve list from mbed TLS");
1534 printf(
"Available Elliptic curves, listed in order of preference:\n\n");
1535 while (MBEDTLS_ECP_DP_NONE != pcurve->grp_id)
1537 printf(
"%s\n", pcurve->name);
1545 static char mbedtls_version[30];
1546 unsigned int pv = mbedtls_version_get_number();
1547 snprintf(mbedtls_version,
sizeof(mbedtls_version),
"mbed TLS %d.%d.%d", (pv >> 24) & 0xff,
1548 (pv >> 16) & 0xff, (pv >> 8) & 0xff);
1549 return mbedtls_version;
char * string_alloc(const char *str, struct gc_arena *gc)
#define ALLOC_ARRAY_CLEAR(dptr, type, n)
static int buf_forward_capacity(const struct buffer *buf)
static void secure_memzero(void *data, size_t len)
Securely zeroise memory.
static void gc_free(struct gc_arena *a)
#define ALLOC_OBJ_CLEAR(dptr, type)
static struct gc_arena gc_new(void)
char * strsep(char **stringp, const char *delim)
const char * print_key_filename(const char *str, bool is_inline)
To be used when printing a string that may contain inline data.
int md_full(const char *mdname, const uint8_t *src, int src_len, uint8_t *dst)
Calculates the message digest for the given buffer.
mbedtls_ctr_drbg_context * rand_ctx_get(void)
Returns a singleton instance of the mbed TLS random number generator.
#define mbed_ok(errval)
Check errval and log on error.
bool mbed_log_err(unsigned int flags, int errval, const char *prefix)
Log the supplied mbed TLS error, prefixed by supplied prefix.
#define D_HANDSHAKE_VERBOSE
#define KS_PRIMARY
Primary key state index.
int key_state_read_plaintext(struct key_state_ssl *ks_ssl, struct buffer *buf)
Extract plaintext data from the TLS module.
int key_state_write_ciphertext(struct key_state_ssl *ks_ssl, struct buffer *buf)
Insert a ciphertext buffer into the TLS module.
int key_state_read_ciphertext(struct key_state_ssl *ks_ssl, struct buffer *buf)
Extract ciphertext data from the TLS module.
int key_state_write_plaintext_const(struct key_state_ssl *ks_ssl, const uint8_t *data, int len)
Insert plaintext data into the TLS module.
int key_state_write_plaintext(struct key_state_ssl *ks_ssl, struct buffer *buf)
Insert a plaintext buffer into the TLS module.
int verify_callback(void *session_obj, mbedtls_x509_crt *cert, int cert_depth, uint32_t *flags)
Verify that the remote OpenVPN peer's certificate allows setting up a VPN tunnel.
static SERVICE_STATUS status
void management_auth_failure(struct management *man, const char *type, const char *reason)
char * management_query_pk_sig(struct management *man, const char *b64_data, const char *algorithm)
mbedtls compatibility stub.
static int mbedtls_compat_pk_parse_key(mbedtls_pk_context *ctx, const unsigned char *key, size_t keylen, const unsigned char *pwd, size_t pwdlen, int(*f_rng)(void *, unsigned char *, size_t), void *p_rng)
mbedtls_ssl_protocol_version
@ MBEDTLS_SSL_VERSION_TLS1_2
@ MBEDTLS_SSL_VERSION_TLS1_3
@ MBEDTLS_SSL_VERSION_UNKNOWN
static void mbedtls_compat_psa_crypto_init(void)
static mbedtls_compat_group_id mbedtls_compat_get_group_id(const mbedtls_ecp_curve_info *curve_info)
static int mbedtls_compat_ctr_drbg_update(mbedtls_ctr_drbg_context *ctx, const unsigned char *additional, size_t add_len)
static int mbedtls_compat_pk_check_pair(const mbedtls_pk_context *pub, const mbedtls_pk_context *prv, int(*f_rng)(void *, unsigned char *, size_t), void *p_rng)
static void mbedtls_ssl_conf_groups(mbedtls_ssl_config *conf, mbedtls_compat_group_id *groups)
static size_t mbedtls_dhm_get_bitlen(const mbedtls_dhm_context *ctx)
static void mbedtls_ssl_conf_max_tls_version(mbedtls_ssl_config *conf, mbedtls_ssl_protocol_version tls_version)
mbedtls_ecp_group_id mbedtls_compat_group_id
static void mbedtls_ssl_conf_min_tls_version(mbedtls_ssl_config *conf, mbedtls_ssl_protocol_version tls_version)
static int mbedtls_compat_pk_parse_keyfile(mbedtls_pk_context *ctx, const char *path, const char *password, int(*f_rng)(void *, unsigned char *, size_t), void *p_rng)
static void perf_push(int type)
#define PERF_BIO_READ_PLAINTEXT
#define PERF_BIO_WRITE_CIPHERTEXT
static void perf_pop(void)
#define PERF_BIO_READ_CIPHERTEXT
#define PERF_BIO_WRITE_PLAINTEXT
PKCS #11 SSL library-specific backend.
int openvpn_base64_decode(const char *str, void *data, int size)
int openvpn_base64_encode(const void *data, int size, char **str)
static struct user_pass passbuf
int pem_password_callback(char *buf, int size, int rwflag, void *u)
Callback to retrieve the user's password.
void load_xkey_provider(void)
Load ovpn.xkey provider used for external key signing.
Control Channel SSL library backend module.
void tls_ctx_set_tls_groups(struct tls_root_ctx *ctx, const char *groups)
Set the (elliptic curve) group allowed for signatures and key exchange.
void tls_ctx_free(struct tls_root_ctx *ctx)
Frees the library-specific TLSv1 context.
const char * get_ssl_library_version(void)
return a pointer to a static memory area containing the name and version number of the SSL library in...
bool key_state_export_keying_material(struct tls_session *session, const char *label, size_t label_size, void *ekm, size_t ekm_size)
Keying Material Exporters [RFC 5705] allows additional keying material to be derived from existing TL...
void show_available_tls_ciphers_list(const char *cipher_list, const char *tls_cert_profile, bool tls13)
Show the TLS ciphers that are available for us to use in the library depending on the TLS version.
void tls_ctx_server_new(struct tls_root_ctx *ctx)
Initialise a library-specific TLS context for a server.
void show_available_curves(void)
Show the available elliptic curves in the crypto library.
void key_state_ssl_free(struct key_state_ssl *ks_ssl)
Free the SSL channel part of the given key state.
int tls_ctx_load_priv_file(struct tls_root_ctx *ctx, const char *priv_key_file, bool priv_key_file_inline)
Load private key file into the given TLS context.
void key_state_ssl_shutdown(struct key_state_ssl *ks_ssl)
Sets a TLS session to be shutdown state, so the TLS library will generate a shutdown alert.
void tls_ctx_load_extra_certs(struct tls_root_ctx *ctx, const char *extra_certs_file, bool extra_certs_file_inline)
Load extra certificate authority certificates from the given file or path.
void tls_ctx_check_cert_time(const struct tls_root_ctx *ctx)
Check our certificate notBefore and notAfter fields, and warn if the cert is either not yet valid or ...
void tls_ctx_restrict_ciphers_tls13(struct tls_root_ctx *ctx, const char *ciphers)
Restrict the list of ciphers that can be used within the TLS context for TLS 1.3 and higher.
int tls_ctx_load_pkcs12(struct tls_root_ctx *ctx, const char *pkcs12_file, bool pkcs12_file_inline, bool load_ca_file)
Load PKCS #12 file for key, cert and (optionally) CA certs, and add to library-specific TLS context.
bool tls_ctx_initialised(struct tls_root_ctx *ctx)
Checks whether the given TLS context is initialised.
void key_state_ssl_init(struct key_state_ssl *ks_ssl, const struct tls_root_ctx *ssl_ctx, bool is_server, struct tls_session *session)
Initialise the SSL channel part of the given key state.
void tls_free_lib(void)
Free any global SSL library-specific data structures.
void tls_ctx_load_ecdh_params(struct tls_root_ctx *ctx, const char *curve_name)
Load Elliptic Curve Parameters, and load them into the library-specific TLS context.
void tls_init_lib(void)
Perform any static initialisation necessary by the library.
void print_details(struct key_state_ssl *ks_ssl, const char *prefix)
Print a one line summary of SSL/TLS session handshake.
int tls_version_max(void)
Return the maximum TLS version (as a TLS_VER_x constant) supported by current SSL implementation.
void backend_tls_ctx_reload_crl(struct tls_root_ctx *ssl_ctx, const char *crl_file, bool crl_inline)
Reload the Certificate Revocation List for the SSL channel.
void tls_ctx_restrict_ciphers(struct tls_root_ctx *ctx, const char *ciphers)
Restrict the list of ciphers that can be used within the TLS context for TLS 1.2 and below.
void tls_ctx_load_ca(struct tls_root_ctx *ctx, const char *ca_file, bool ca_file_inline, const char *ca_path, bool tls_server)
Load certificate authority certificates from the given file or path.
void tls_ctx_set_cert_profile(struct tls_root_ctx *ctx, const char *profile)
Set the TLS certificate profile.
int tls_ctx_use_management_external_key(struct tls_root_ctx *ctx)
Tell the management interface to load the given certificate and the external private key matching the...
void tls_ctx_load_cryptoapi(struct tls_root_ctx *ctx, const char *cryptoapi_cert)
Use Windows cryptoapi for key and cert, and add to library-specific TLS context.
bool tls_ctx_set_options(struct tls_root_ctx *ctx, unsigned int ssl_flags)
Set any library specific options.
void tls_ctx_load_dh_params(struct tls_root_ctx *ctx, const char *dh_file, bool dh_file_inline)
Load Diffie Hellman Parameters, and load them into the library-specific TLS context.
void tls_ctx_client_new(struct tls_root_ctx *ctx)
Initialises a library-specific TLS context for a client.
void tls_ctx_load_cert_file(struct tls_root_ctx *ctx, const char *cert_file, bool cert_file_inline)
Load certificate file into the given TLS context.
Control Channel Common Data Structures.
#define SSLF_TLS_VERSION_MAX_SHIFT
#define UP_TYPE_PRIVATE_KEY
#define SSLF_CLIENT_CERT_OPTIONAL
#define SSLF_CLIENT_CERT_NOT_REQUIRED
#define SSLF_TLS_DEBUG_ENABLED
#define SSLF_TLS_VERSION_MAX_MASK
#define SSLF_TLS_VERSION_MIN_SHIFT
#define SSLF_TLS_VERSION_MIN_MASK
int tls_ctx_use_external_signing_func(struct tls_root_ctx *ctx, external_sign_func sign_func, void *sign_ctx)
Call the supplied signing function to create a TLS signature during the TLS handshake.
bool(* external_sign_func)(void *sign_ctx, const void *src, size_t src_size, void *dst, size_t dst_size)
External signing function prototype.
int get_num_elements(const char *string, char delimiter)
Returns the occurrences of 'delimiter' in a string +1 This is typically used to find out the number e...
const tls_cipher_name_pair * tls_get_cipher_name_pair(const char *cipher_name, size_t len)
Control Channel Verification Module mbed TLS backend.
buffer_entry * next_block
Wrapper structure for dynamically allocated memory.
int len
Length in bytes of the actual content within the allocated memory.
buffer_entry * first_block
buffer_entry * last_block
Context used by external_pkcs1_sign()
Garbage collection arena used to keep track of dynamically allocated memory.
mbedtls_ssl_config * ssl_config
mbedTLS global ssl config
mbedtls_ssl_context * ctx
mbedTLS connection context
struct tls_key_cache tls_key_cache
Get a tls_cipher_name_pair containing OpenSSL and IANA names for supplied TLS cipher name.
const char * openssl_name
struct to cache TLS secrets for keying material exporter (RFC 5705).
unsigned char master_secret[48]
mbedtls_tls_prf_types tls_prf_type
unsigned char client_server_random[64]
Structure that wraps the TLS context.
mbedtls_x509_crl * crl
Certificate Revocation List.
mbedtls_x509_crt * crt_chain
Local Certificate chain.
mbedtls_x509_crt * ca_chain
CA chain for remote verification.
mbedtls_compat_group_id * groups
List of allowed groups for this connection.
int * allowed_ciphers
List of allowed ciphers for this connection.
mbedtls_dhm_context * dhm_ctx
Diffie-Helmann-Merkle context.
mbedtls_x509_crt_profile cert_profile
Allowed certificate types.
bool initialised
True if the context has been initialised.
int endpoint
Whether or not this is a server or a client.
struct external_context external_key
External key context.
mbedtls_pk_context * priv_key
Local private key.
Security parameter state of a single session within a VPN tunnel.
static int cleanup(void **state)