37#ifdef COAP_WITH_LIBMBEDTLS
53#include <mbedtls/version.h>
56#if (MBEDTLS_VERSION_NUMBER < 0x03000000)
57#define MBEDTLS_2_X_COMPAT
60#ifndef MBEDTLS_ALLOW_PRIVATE_ACCESS
61#define MBEDTLS_ALLOW_PRIVATE_ACCESS
65#include <mbedtls/platform.h>
66#include <mbedtls/net_sockets.h>
67#include <mbedtls/ssl.h>
68#include <mbedtls/entropy.h>
69#include <mbedtls/ctr_drbg.h>
70#include <mbedtls/error.h>
71#include <mbedtls/timing.h>
72#include <mbedtls/ssl_cookie.h>
73#include <mbedtls/oid.h>
74#include <mbedtls/debug.h>
75#include <mbedtls/sha256.h>
76#if defined(ESPIDF_VERSION) && defined(CONFIG_MBEDTLS_DEBUG)
77#include <mbedtls/esp_debug.h>
79#if defined(MBEDTLS_PSA_CRYPTO_C)
80#include <psa/crypto.h>
83#define mbedtls_malloc(a) malloc(a)
84#define mbedtls_realloc(a,b) realloc(a,b)
85#define mbedtls_strdup(a) strdup(a)
86#define mbedtls_strndup(a,b) strndup(a,b)
88#define mbedtls_free(a) free(a)
90#ifndef MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED
92#ifdef MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED
93#define MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED
97#if ! COAP_SERVER_SUPPORT
98#undef MBEDTLS_SSL_SRV_C
100#if ! COAP_CLIENT_SUPPORT
101#undef MBEDTLS_SSL_CLI_C
105#define strcasecmp _stricmp
108#define IS_PSK (1 << 0)
109#define IS_PKI (1 << 1)
110#define IS_CLIENT (1 << 6)
111#define IS_SERVER (1 << 7)
113typedef struct coap_ssl_t {
124typedef struct coap_mbedtls_env_t {
125 mbedtls_ssl_context ssl;
126 mbedtls_entropy_context entropy;
127 mbedtls_ctr_drbg_context ctr_drbg;
128 mbedtls_ssl_config conf;
129 mbedtls_timing_delay_context timer;
130 mbedtls_x509_crt cacert;
131 mbedtls_x509_crt public_cert;
132 mbedtls_pk_context private_key;
133 mbedtls_ssl_cookie_ctx cookie_ctx;
137 int seen_client_hello;
140 unsigned int retry_scalar;
141 coap_ssl_t coap_ssl_data;
142 uint32_t server_hello_cnt;
145typedef struct pki_sni_entry {
148 mbedtls_x509_crt cacert;
149 mbedtls_x509_crt public_cert;
150 mbedtls_pk_context private_key;
153typedef struct psk_sni_entry {
158typedef struct coap_mbedtls_context_t {
160 size_t pki_sni_count;
161 pki_sni_entry *pki_sni_entry_list;
162 size_t psk_sni_count;
163 psk_sni_entry *psk_sni_entry_list;
166 int trust_store_defined;
168} coap_mbedtls_context_t;
170typedef enum coap_enc_method_t {
182} zephyr_timing_delay_context;
185zephyr_timing_set_delay(
void *data, uint32_t int_ms, uint32_t fin_ms) {
186 zephyr_timing_delay_context *ctx = (zephyr_timing_delay_context *)data;
192 ctx->start_time = k_uptime_get_32();
195 ctx->int_time = ctx->start_time + int_ms;
196 ctx->fin_time = ctx->start_time + fin_ms;
204zephyr_timing_get_delay(
void *data) {
205 zephyr_timing_delay_context *ctx = (zephyr_timing_delay_context *)data;
208 if (ctx == NULL || ctx->fin_time == 0) {
212 now = k_uptime_get_32();
214 if (now >= ctx->fin_time) {
218 if (now >= ctx->int_time) {
227#ifndef MBEDTLS_2_X_COMPAT
232coap_rng(
void *ctx
COAP_UNUSED,
unsigned char *buf,
size_t len) {
233 return coap_prng_lkd(buf, len) ? 0 : MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED;
238coap_dgram_read(
void *ctx,
unsigned char *out,
size_t outl) {
243 if (!c_session->
tls) {
245 return MBEDTLS_ERR_SSL_WANT_READ;
247 data = &((coap_mbedtls_env_t *)c_session->
tls)->coap_ssl_data;
250 if (data->pdu_len > 0) {
251 if (outl < data->pdu_len) {
252 memcpy(out, data->pdu, outl);
255 data->pdu_len -= outl;
257 memcpy(out, data->pdu, data->pdu_len);
259 if (!data->peekmode) {
265 ret = MBEDTLS_ERR_SSL_WANT_READ;
279coap_dgram_write(
void *ctx,
const unsigned char *send_buffer,
280 size_t send_buffer_length) {
285 coap_mbedtls_env_t *m_env = (coap_mbedtls_env_t *)c_session->
tls;
297 send_buffer, send_buffer_length);
298 if (result != (ssize_t)send_buffer_length) {
299 int keep_errno = errno;
302 result, send_buffer_length);
305 if (errno == ENOTCONN || errno == ECONNREFUSED)
314 m_env->last_timeout = now;
322#if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED) && defined(MBEDTLS_SSL_SRV_C)
327psk_server_callback(
void *p_info, mbedtls_ssl_context *ssl,
328 const unsigned char *identity,
size_t identity_len) {
331 coap_mbedtls_env_t *m_env;
335 if (c_session == NULL)
339 lidentity.
s = identity ? (
const uint8_t *)identity : (const uint8_t *)
"";
340 lidentity.
length = identity ? identity_len : 0;
344 (
int)lidentity.
length, (
const char *)lidentity.
s);
346 m_env = (coap_mbedtls_env_t *)c_session->
tls;
361 mbedtls_ssl_set_hs_psk(ssl, psk_key->
s, psk_key->
length);
362 m_env->seen_client_hello = 1;
368get_san_or_cn_from_cert(mbedtls_x509_crt *crt) {
370 const mbedtls_asn1_named_data *cn_data;
372 if (crt->ext_types & MBEDTLS_X509_EXT_SUBJECT_ALT_NAME) {
373 mbedtls_asn1_sequence *seq = &crt->subject_alt_names;
374 while (seq && seq->buf.p == NULL) {
379 return mbedtls_strndup((
const char *)seq->buf.p,
384 cn_data = mbedtls_asn1_find_named_data(&crt->subject,
386 MBEDTLS_OID_SIZE(MBEDTLS_OID_AT_CN));
389 return mbedtls_strndup((
const char *)cn_data->val.p,
396#if COAP_MAX_LOGGING_LEVEL > 0
398get_error_string(
int ret) {
399 static char buf[128] = {0};
400 mbedtls_strerror(ret, buf,
sizeof(buf)-1);
406self_signed_cert_verify_callback_mbedtls(
void *data,
411 const coap_mbedtls_context_t *m_context =
415 if (*flags & MBEDTLS_X509_BADCERT_EXPIRED) {
417 *flags &= ~MBEDTLS_X509_BADCERT_EXPIRED;
428cert_verify_callback_mbedtls(
void *data, mbedtls_x509_crt *crt,
429 int depth, uint32_t *flags) {
431 coap_mbedtls_context_t *m_context =
439 cn = get_san_or_cn_from_cert(crt);
441 if (*flags & MBEDTLS_X509_BADCERT_EXPIRED) {
443 *flags &= ~MBEDTLS_X509_BADCERT_EXPIRED;
446 "The certificate has expired", cn ? cn :
"?", depth);
449 if (*flags & MBEDTLS_X509_BADCERT_FUTURE) {
451 *flags &= ~MBEDTLS_X509_BADCERT_FUTURE;
454 "The certificate has a future date", cn ? cn :
"?", depth);
457 if (*flags & MBEDTLS_X509_BADCERT_BAD_MD) {
459 *flags &= ~MBEDTLS_X509_BADCERT_BAD_MD;
462 "The certificate has a bad MD hash", cn ? cn :
"?", depth);
465 if (*flags & MBEDTLS_X509_BADCERT_BAD_KEY) {
467 *flags &= ~MBEDTLS_X509_BADCERT_BAD_KEY;
470 "The certificate has a short RSA length", cn ? cn :
"?", depth);
473 if (*flags & MBEDTLS_X509_BADCERT_NOT_TRUSTED) {
475 int self_signed = !mbedtls_x509_crt_verify(crt, crt, NULL, NULL, &lflags,
476 self_signed_cert_verify_callback_mbedtls,
478 if (self_signed && depth == 0) {
481 *flags &= ~MBEDTLS_X509_BADCERT_NOT_TRUSTED;
485 cn ? cn :
"?", depth);
487 }
else if (self_signed) {
489 *flags &= ~MBEDTLS_X509_BADCERT_NOT_TRUSTED;
492 "Self-signed", cn ? cn :
"?", depth);
496 *flags &= ~MBEDTLS_X509_BADCERT_NOT_TRUSTED;
499 "The certificate's CA is not trusted", cn ? cn :
"?", depth);
503 if (*flags & MBEDTLS_X509_BADCRL_EXPIRED) {
505 *flags &= ~MBEDTLS_X509_BADCRL_EXPIRED;
508 "The certificate's CRL has expired", cn ? cn :
"?", depth);
510 *flags &= ~MBEDTLS_X509_BADCRL_EXPIRED;
513 if (*flags & MBEDTLS_X509_BADCRL_FUTURE) {
515 *flags &= ~MBEDTLS_X509_BADCRL_FUTURE;
518 "The certificate's CRL has a future date", cn ? cn :
"?", depth);
520 *flags &= ~MBEDTLS_X509_BADCRL_FUTURE;
525 *flags |= MBEDTLS_X509_BADCERT_OTHER;
528 "The certificate's verify depth is too long",
529 cn ? cn :
"?", depth);
532 if (*flags & MBEDTLS_X509_BADCERT_CN_MISMATCH) {
533 *flags &= ~MBEDTLS_X509_BADCERT_CN_MISMATCH;
547 *flags |= MBEDTLS_X509_BADCERT_CN_MISMATCH;
553 int ret = mbedtls_x509_crt_verify_info(buf,
sizeof(buf),
"", *flags);
556 tcp = strchr(buf,
'\n');
561 buf, *flags, cn ? cn :
"?", depth);
562 tcp = strchr(tcp+1,
'\n');
565 coap_log_err(
"mbedtls_x509_crt_verify_info returned -0x%x: '%s'\n",
566 -ret, get_error_string(ret));
577setup_pki_credentials(mbedtls_x509_crt *cacert,
578 mbedtls_x509_crt *public_cert,
579 mbedtls_pk_context *private_key,
580 coap_mbedtls_env_t *m_env,
581 coap_mbedtls_context_t *m_context,
587 int done_private_key = 0;
588 int done_public_cert = 0;
606#if defined(MBEDTLS_FS_IO)
607 mbedtls_pk_init(private_key);
608#ifdef MBEDTLS_2_X_COMPAT
609 ret = mbedtls_pk_parse_keyfile(private_key,
612 ret = mbedtls_pk_parse_keyfile(private_key,
614 NULL, coap_rng, (
void *)&m_env->ctr_drbg);
621 done_private_key = 1;
629 mbedtls_pk_init(private_key);
633 buffer = mbedtls_malloc(length + 1);
639 buffer[length] =
'\000';
641#ifdef MBEDTLS_2_X_COMPAT
642 ret = mbedtls_pk_parse_key(private_key, buffer, length, NULL, 0);
644 ret = mbedtls_pk_parse_key(private_key, buffer, length,
645 NULL, 0, coap_rng, (
void *)&m_env->ctr_drbg);
647 mbedtls_free(buffer);
649#ifdef MBEDTLS_2_X_COMPAT
650 ret = mbedtls_pk_parse_key(private_key,
654 ret = mbedtls_pk_parse_key(private_key,
657 NULL, 0, coap_rng, (
void *)&m_env->ctr_drbg);
665 done_private_key = 1;
668 mbedtls_pk_init(private_key);
669#ifdef MBEDTLS_2_X_COMPAT
670 ret = mbedtls_pk_parse_key(private_key,
674 ret = mbedtls_pk_parse_key(private_key,
677 (
void *)&m_env->ctr_drbg);
684 done_private_key = 1;
712#if defined(MBEDTLS_FS_IO)
713 mbedtls_x509_crt_init(public_cert);
714 ret = mbedtls_x509_crt_parse_file(public_cert,
721 done_public_cert = 1;
729 mbedtls_x509_crt_init(public_cert);
734 buffer = mbedtls_malloc(length + 1);
740 buffer[length] =
'\000';
742 ret = mbedtls_x509_crt_parse(public_cert, buffer, length);
743 mbedtls_free(buffer);
745 ret = mbedtls_x509_crt_parse(public_cert,
754 done_public_cert = 1;
761 mbedtls_x509_crt_init(public_cert);
762 ret = mbedtls_x509_crt_parse(public_cert,
770 done_public_cert = 1;
788 if (done_private_key && done_public_cert) {
789 ret = mbedtls_ssl_conf_own_cert(&m_env->conf, public_cert, private_key);
791 coap_log_err(
"mbedtls_ssl_conf_own_cert returned -0x%x: '%s'\n",
792 -ret, get_error_string(ret));
807#if defined(MBEDTLS_FS_IO)
808 mbedtls_x509_crt_init(cacert);
809 ret = mbedtls_x509_crt_parse_file(cacert,
816 mbedtls_ssl_conf_ca_chain(&m_env->conf, cacert, NULL);
824 mbedtls_x509_crt_init(cacert);
828 buffer = mbedtls_malloc(length + 1);
834 buffer[length] =
'\000';
836 ret = mbedtls_x509_crt_parse(cacert, buffer, length);
837 mbedtls_free(buffer);
839 ret = mbedtls_x509_crt_parse(cacert,
848 mbedtls_ssl_conf_ca_chain(&m_env->conf, cacert, NULL);
855 mbedtls_x509_crt_init(cacert);
856 ret = mbedtls_x509_crt_parse(cacert,
864 mbedtls_ssl_conf_ca_chain(&m_env->conf, cacert, NULL);
878#if defined(MBEDTLS_FS_IO)
879 if (m_context->root_ca_file) {
880 ret = mbedtls_x509_crt_parse_file(cacert, m_context->root_ca_file);
887 mbedtls_ssl_conf_ca_chain(&m_env->conf, cacert, NULL);
889 if (m_context->root_ca_path) {
890 ret = mbedtls_x509_crt_parse_path(cacert, m_context->root_ca_path);
897 mbedtls_ssl_conf_ca_chain(&m_env->conf, cacert, NULL);
899 if (m_context->trust_store_defined) {
901 const char *trust_list[] = {
902 "/etc/ssl/ca-bundle.pem",
903 "/etc/ssl/certs/ca-certificates.crt",
904 "/etc/pki/tls/cert.pem",
905 "/usr/local/share/certs/ca-root-nss.crt",
908 static const char *trust_file_found = NULL;
909 static int trust_file_done = 0;
912 if (trust_file_found) {
913 ret = mbedtls_x509_crt_parse_file(cacert, trust_file_found);
915 mbedtls_ssl_conf_ca_chain(&m_env->conf, cacert, NULL);
920 }
else if (!trust_file_done) {
922 for (i = 0; i <
sizeof(trust_list)/
sizeof(trust_list[0]); i++) {
923 ret = mbedtls_x509_crt_parse_file(cacert, trust_list[i]);
925 mbedtls_ssl_conf_ca_chain(&m_env->conf, cacert, NULL);
926 trust_file_found = trust_list[i];
930 if (i ==
sizeof(trust_list)/
sizeof(trust_list[0])) {
942#if defined(MBEDTLS_SSL_SRV_C)
943 mbedtls_ssl_conf_cert_req_ca_list(&m_env->conf,
945 MBEDTLS_SSL_CERT_REQ_CA_LIST_ENABLED :
946 MBEDTLS_SSL_CERT_REQ_CA_LIST_DISABLED);
949 MBEDTLS_SSL_VERIFY_REQUIRED :
950 MBEDTLS_SSL_VERIFY_NONE);
955 mbedtls_ssl_conf_verify(&m_env->conf,
956 cert_verify_callback_mbedtls, c_session);
961#if defined(MBEDTLS_SSL_SRV_C)
966pki_sni_callback(
void *p_info, mbedtls_ssl_context *ssl,
967 const unsigned char *uname,
size_t name_len) {
971 coap_mbedtls_env_t *m_env = (coap_mbedtls_env_t *)c_session->
tls;
972 coap_mbedtls_context_t *m_context =
976 name = mbedtls_malloc(name_len+1);
980 memcpy(name, uname, name_len);
981 name[name_len] =
'\000';
984 for (i = 0; i < m_context->pki_sni_count; i++) {
985 if (strcasecmp(name, m_context->pki_sni_entry_list[i].sni) == 0) {
989 if (i == m_context->pki_sni_count) {
994 pki_sni_entry *pki_sni_entry_list;
997 m_context->setup_data.validate_sni_call_back(name,
998 m_context->setup_data.sni_call_back_arg));
1004 pki_sni_entry_list = mbedtls_realloc(m_context->pki_sni_entry_list,
1005 (i+1)*
sizeof(pki_sni_entry));
1007 if (pki_sni_entry_list == NULL) {
1011 m_context->pki_sni_entry_list = pki_sni_entry_list;
1012 memset(&m_context->pki_sni_entry_list[i], 0,
1013 sizeof(m_context->pki_sni_entry_list[i]));
1014 m_context->pki_sni_entry_list[i].sni = name;
1015 m_context->pki_sni_entry_list[i].pki_key = *new_entry;
1016 sni_setup_data = m_context->setup_data;
1017 sni_setup_data.pki_key = *new_entry;
1018 if (setup_pki_credentials(&m_context->pki_sni_entry_list[i].cacert,
1019 &m_context->pki_sni_entry_list[i].public_cert,
1020 &m_context->pki_sni_entry_list[i].private_key,
1029 m_context->pki_sni_count++;
1034 mbedtls_ssl_set_hs_ca_chain(ssl, &m_context->pki_sni_entry_list[i].cacert,
1036 return mbedtls_ssl_set_hs_own_cert(ssl,
1037 &m_context->pki_sni_entry_list[i].public_cert,
1038 &m_context->pki_sni_entry_list[i].private_key);
1041#if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
1046psk_sni_callback(
void *p_info, mbedtls_ssl_context *ssl,
1047 const unsigned char *uname,
size_t name_len) {
1050 coap_mbedtls_context_t *m_context =
1054 name = mbedtls_malloc(name_len+1);
1058 memcpy(name, uname, name_len);
1059 name[name_len] =
'\000';
1062 for (i = 0; i < m_context->psk_sni_count; i++) {
1063 if (strcasecmp(name, m_context->psk_sni_entry_list[i].sni) == 0) {
1067 if (i == m_context->psk_sni_count) {
1072 psk_sni_entry *psk_sni_entry_list;
1083 psk_sni_entry_list = mbedtls_realloc(m_context->psk_sni_entry_list,
1084 (i+1)*
sizeof(psk_sni_entry));
1086 if (psk_sni_entry_list == NULL) {
1090 m_context->psk_sni_entry_list = psk_sni_entry_list;
1091 m_context->psk_sni_entry_list[i].sni = name;
1092 m_context->psk_sni_entry_list[i].psk_info = *new_entry;
1094 m_context->psk_sni_count++;
1100 &m_context->psk_sni_entry_list[i].psk_info.hint);
1102 &m_context->psk_sni_entry_list[i].psk_info.key);
1103 return mbedtls_ssl_set_hs_psk(ssl,
1104 m_context->psk_sni_entry_list[i].psk_info.key.s,
1105 m_context->psk_sni_entry_list[i].psk_info.key.length);
1111 coap_mbedtls_env_t *m_env) {
1112 coap_mbedtls_context_t *m_context =
1115 m_context->psk_pki_enabled |= IS_SERVER;
1117 mbedtls_ssl_cookie_init(&m_env->cookie_ctx);
1118 if ((ret = mbedtls_ssl_config_defaults(&m_env->conf,
1119 MBEDTLS_SSL_IS_SERVER,
1121 MBEDTLS_SSL_TRANSPORT_DATAGRAM :
1122 MBEDTLS_SSL_TRANSPORT_STREAM,
1123 MBEDTLS_SSL_PRESET_DEFAULT)) != 0) {
1124 coap_log_err(
"mbedtls_ssl_config_defaults returned -0x%x: '%s'\n",
1125 -ret, get_error_string(ret));
1129 mbedtls_ssl_conf_rng(&m_env->conf, mbedtls_ctr_drbg_random, &m_env->ctr_drbg);
1131#if defined(MBEDTLS_SSL_PROTO_DTLS)
1132 mbedtls_ssl_conf_handshake_timeout(&m_env->conf, COAP_DTLS_RETRANSMIT_MS,
1133 COAP_DTLS_RETRANSMIT_TOTAL_MS);
1136 if (m_context->psk_pki_enabled & IS_PSK) {
1137#if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
1138 mbedtls_ssl_conf_psk_cb(&m_env->conf, psk_server_callback, c_session);
1140 mbedtls_ssl_conf_sni(&m_env->conf, psk_sni_callback, c_session);
1142#ifdef MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED
1150 if (m_context->psk_pki_enabled & IS_PKI) {
1151 ret = setup_pki_credentials(&m_env->cacert, &m_env->public_cert,
1152 &m_env->private_key, m_env, m_context,
1153 c_session, &m_context->setup_data,
1159 if (m_context->setup_data.validate_sni_call_back) {
1160 mbedtls_ssl_conf_sni(&m_env->conf, pki_sni_callback, c_session);
1164 if ((ret = mbedtls_ssl_cookie_setup(&m_env->cookie_ctx,
1165 mbedtls_ctr_drbg_random,
1166 &m_env->ctr_drbg)) != 0) {
1167 coap_log_err(
"mbedtls_ssl_cookie_setup: returned -0x%x: '%s'\n",
1168 -ret, get_error_string(ret));
1172#if defined(MBEDTLS_SSL_PROTO_DTLS)
1173 mbedtls_ssl_conf_dtls_cookies(&m_env->conf, mbedtls_ssl_cookie_write,
1174 mbedtls_ssl_cookie_check,
1175 &m_env->cookie_ctx);
1176#if MBEDTLS_VERSION_NUMBER >= 0x02100100
1177 mbedtls_ssl_set_mtu(&m_env->ssl, (uint16_t)c_session->
mtu);
1180#ifdef MBEDTLS_SSL_DTLS_CONNECTION_ID
1188 mbedtls_ssl_conf_cid(&m_env->conf, COAP_DTLS_CID_LENGTH, MBEDTLS_SSL_UNEXPECTED_CID_IGNORE);
1195#if COAP_CLIENT_SUPPORT
1196static int *psk_ciphers = NULL;
1197static int *pki_ciphers = NULL;
1198static int *ecjpake_ciphers = NULL;
1199static int processed_ciphers = 0;
1201#if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
1203coap_ssl_ciphersuite_uses_psk(
const mbedtls_ssl_ciphersuite_t *info) {
1204#if MBEDTLS_VERSION_NUMBER >= 0x03060000
1205 switch (info->key_exchange) {
1206 case MBEDTLS_KEY_EXCHANGE_PSK:
1207 case MBEDTLS_KEY_EXCHANGE_RSA_PSK:
1208 case MBEDTLS_KEY_EXCHANGE_DHE_PSK:
1209 case MBEDTLS_KEY_EXCHANGE_ECDHE_PSK:
1211 case MBEDTLS_KEY_EXCHANGE_NONE:
1212 case MBEDTLS_KEY_EXCHANGE_RSA:
1213 case MBEDTLS_KEY_EXCHANGE_DHE_RSA:
1214 case MBEDTLS_KEY_EXCHANGE_ECDHE_RSA:
1215 case MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA:
1216 case MBEDTLS_KEY_EXCHANGE_ECDH_RSA:
1217 case MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA:
1218 case MBEDTLS_KEY_EXCHANGE_ECJPAKE:
1223 return mbedtls_ssl_ciphersuite_uses_psk(info);
1229set_ciphersuites(mbedtls_ssl_config *conf, coap_enc_method_t method) {
1230 if (!processed_ciphers) {
1231 const int *list = mbedtls_ssl_list_ciphersuites();
1232 const int *base = list;
1235#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
1237 int ecjpake_count = 1;
1243 const mbedtls_ssl_ciphersuite_t *cur =
1244 mbedtls_ssl_ciphersuite_from_id(*list);
1247#if MBEDTLS_VERSION_NUMBER >= 0x03020000
1248 if (cur->max_tls_version < MBEDTLS_SSL_VERSION_TLS1_2) {
1252 if (cur->max_minor_ver < MBEDTLS_SSL_MINOR_VERSION_3) {
1256#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
1257 else if (cur->key_exchange == MBEDTLS_KEY_EXCHANGE_ECJPAKE) {
1261#if MBEDTLS_VERSION_NUMBER >= 0x03060000
1262 else if (cur->min_tls_version >= MBEDTLS_SSL_VERSION_TLS1_3) {
1267#if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
1268 else if (coap_ssl_ciphersuite_uses_psk(cur)) {
1280 psk_ciphers = mbedtls_malloc(psk_count *
sizeof(psk_ciphers[0]));
1281 if (psk_ciphers == NULL) {
1282 coap_log_err(
"set_ciphers: mbedtls_malloc with count %d failed\n", psk_count);
1285 pki_ciphers = mbedtls_malloc(pki_count *
sizeof(pki_ciphers[0]));
1286 if (pki_ciphers == NULL) {
1287 coap_log_err(
"set_ciphers: mbedtls_malloc with count %d failed\n", pki_count);
1288 mbedtls_free(psk_ciphers);
1292#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
1293 ecjpake_ciphers = mbedtls_malloc(ecjpake_count *
sizeof(ecjpake_ciphers[0]));
1294 if (ecjpake_ciphers == NULL) {
1295 coap_log_err(
"set_ciphers: mbedtls_malloc with count %d failed\n", pki_count);
1296 mbedtls_free(psk_ciphers);
1297 mbedtls_free(pki_ciphers);
1304 psk_list = psk_ciphers;
1305 pki_list = pki_ciphers;
1306#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
1307 ecjpake_list = ecjpake_ciphers;
1311 const mbedtls_ssl_ciphersuite_t *cur =
1312 mbedtls_ssl_ciphersuite_from_id(*list);
1314#if MBEDTLS_VERSION_NUMBER >= 0x03020000
1315 if (cur->max_tls_version < MBEDTLS_SSL_VERSION_TLS1_2) {
1319 if (cur->max_minor_ver < MBEDTLS_SSL_MINOR_VERSION_3) {
1323#if defined(MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED)
1324 else if (cur->key_exchange == MBEDTLS_KEY_EXCHANGE_ECJPAKE) {
1325 *ecjpake_list = *list;
1329#if MBEDTLS_VERSION_NUMBER >= 0x03060000
1330 else if (cur->min_tls_version >= MBEDTLS_SSL_VERSION_TLS1_3) {
1337#if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
1338 else if (coap_ssl_ciphersuite_uses_psk(cur)) {
1353 processed_ciphers = 1;
1357 mbedtls_ssl_conf_ciphersuites(conf, psk_ciphers);
1360 mbedtls_ssl_conf_ciphersuites(conf, pki_ciphers);
1362 case COAP_ENC_ECJPAKE:
1363 mbedtls_ssl_conf_ciphersuites(conf, ecjpake_ciphers);
1373 coap_mbedtls_env_t *m_env) {
1376 coap_mbedtls_context_t *m_context =
1379 m_context->psk_pki_enabled |= IS_CLIENT;
1381 if ((ret = mbedtls_ssl_config_defaults(&m_env->conf,
1382 MBEDTLS_SSL_IS_CLIENT,
1384 MBEDTLS_SSL_TRANSPORT_DATAGRAM :
1385 MBEDTLS_SSL_TRANSPORT_STREAM,
1386 MBEDTLS_SSL_PRESET_DEFAULT)) != 0) {
1387 coap_log_err(
"mbedtls_ssl_config_defaults returned -0x%x: '%s'\n",
1388 -ret, get_error_string(ret));
1392#if defined(MBEDTLS_SSL_PROTO_DTLS)
1393 mbedtls_ssl_conf_handshake_timeout(&m_env->conf, COAP_DTLS_RETRANSMIT_MS,
1394 COAP_DTLS_RETRANSMIT_TOTAL_MS);
1397 mbedtls_ssl_conf_authmode(&m_env->conf, MBEDTLS_SSL_VERIFY_REQUIRED);
1398 mbedtls_ssl_conf_rng(&m_env->conf, mbedtls_ctr_drbg_random, &m_env->ctr_drbg);
1400 if (m_context->psk_pki_enabled & IS_PSK) {
1401#if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
1409 if (psk_key == NULL || psk_identity == NULL) {
1410 ret = MBEDTLS_ERR_SSL_ALLOC_FAILED;
1414 if ((ret = mbedtls_ssl_conf_psk(&m_env->conf, psk_key->
s,
1415 psk_key->
length, psk_identity->
s,
1416 psk_identity->
length)) != 0) {
1417 coap_log_err(
"mbedtls_ssl_conf_psk returned -0x%x: '%s'\n",
1418 -ret, get_error_string(ret));
1422 if ((ret = mbedtls_ssl_set_hostname(&m_env->ssl,
1424 coap_log_err(
"mbedtls_ssl_set_hostname returned -0x%x: '%s'\n",
1425 -ret, get_error_string(ret));
1431#ifdef MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED
1433 m_env->ec_jpake = 1;
1434 set_ciphersuites(&m_env->conf, COAP_ENC_ECJPAKE);
1435#if MBEDTLS_VERSION_NUMBER >= 0x03020000
1436 mbedtls_ssl_conf_max_tls_version(&m_env->conf, MBEDTLS_SSL_VERSION_TLS1_2);
1439 set_ciphersuites(&m_env->conf, COAP_ENC_PSK);
1442 set_ciphersuites(&m_env->conf, COAP_ENC_PSK);
1447 }
else if ((m_context->psk_pki_enabled & IS_PKI) ||
1448 (m_context->psk_pki_enabled & (IS_PSK | IS_PKI)) == 0) {
1455 if (!(m_context->psk_pki_enabled & IS_PKI)) {
1469 mbedtls_ssl_conf_authmode(&m_env->conf, MBEDTLS_SSL_VERIFY_OPTIONAL);
1470 ret = setup_pki_credentials(&m_env->cacert, &m_env->public_cert,
1471 &m_env->private_key, m_env, m_context,
1472 c_session, setup_data,
1478#if defined(MBEDTLS_SSL_SRV_C) && defined(MBEDTLS_SSL_ALPN)
1481 static const char *alpn_list[] = {
"coap", NULL };
1483 ret = mbedtls_ssl_conf_alpn_protocols(&m_env->conf, alpn_list);
1489 mbedtls_ssl_set_hostname(&m_env->ssl, m_context->setup_data.client_sni);
1490#if defined(MBEDTLS_SSL_PROTO_DTLS)
1491#if MBEDTLS_VERSION_NUMBER >= 0x02100100
1492 mbedtls_ssl_set_mtu(&m_env->ssl, (uint16_t)c_session->
mtu);
1495 set_ciphersuites(&m_env->conf, COAP_ENC_PKI);
1505mbedtls_cleanup(coap_mbedtls_env_t *m_env) {
1510 mbedtls_x509_crt_free(&m_env->cacert);
1511 mbedtls_x509_crt_free(&m_env->public_cert);
1512 mbedtls_pk_free(&m_env->private_key);
1513 mbedtls_entropy_free(&m_env->entropy);
1514 mbedtls_ssl_config_free(&m_env->conf);
1515 mbedtls_ctr_drbg_free(&m_env->ctr_drbg);
1516 mbedtls_ssl_free(&m_env->ssl);
1517 mbedtls_ssl_cookie_free(&m_env->cookie_ctx);
1521coap_dtls_free_mbedtls_env(coap_mbedtls_env_t *m_env) {
1523 if (!m_env->sent_alert)
1524 mbedtls_ssl_close_notify(&m_env->ssl);
1525 mbedtls_cleanup(m_env);
1526 mbedtls_free(m_env);
1530#if COAP_MAX_LOGGING_LEVEL > 0
1532report_mbedtls_alert(
unsigned char alert) {
1534 case MBEDTLS_SSL_ALERT_MSG_BAD_RECORD_MAC:
1535 return ": Bad Record MAC";
1536 case MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE:
1537 return ": Handshake failure";
1538 case MBEDTLS_SSL_ALERT_MSG_NO_CERT:
1539 return ": No Certificate provided";
1540 case MBEDTLS_SSL_ALERT_MSG_BAD_CERT:
1541 return ": Certificate is bad";
1542 case MBEDTLS_SSL_ALERT_MSG_CERT_UNKNOWN:
1543 return ": Certificate is unknown";
1544 case MBEDTLS_SSL_ALERT_MSG_UNKNOWN_CA:
1545 return ": CA is unknown";
1546 case MBEDTLS_SSL_ALERT_MSG_ACCESS_DENIED:
1547 return ": Access was denied";
1548 case MBEDTLS_SSL_ALERT_MSG_DECRYPT_ERROR:
1549 return ": Decrypt error";
1563 coap_mbedtls_env_t *m_env) {
1567 ret = mbedtls_ssl_handshake(&m_env->ssl);
1570 m_env->established = 1;
1574#ifdef MBEDTLS_SSL_DTLS_CONNECTION_ID
1575#if COAP_CLIENT_SUPPORT
1578 coap_mbedtls_context_t *m_context;
1582 m_context->setup_data.use_cid) {
1583 unsigned char peer_cid[MBEDTLS_SSL_CID_OUT_LEN_MAX];
1585 size_t peer_cid_len;
1588 if (mbedtls_ssl_get_peer_cid(&m_env->ssl, &enabled, peer_cid, &peer_cid_len) == 0 &&
1589 enabled == MBEDTLS_SSL_CID_ENABLED) {
1600 case MBEDTLS_ERR_SSL_WANT_READ:
1601 case MBEDTLS_ERR_SSL_WANT_WRITE:
1602 if (m_env->ssl.state == MBEDTLS_SSL_SERVER_HELLO
1603#
if MBEDTLS_VERSION_NUMBER >= 0x03030000
1604 || m_env->ssl.state == MBEDTLS_SSL_NEW_SESSION_TICKET
1607 if (++m_env->server_hello_cnt > 10) {
1615 case MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED:
1618 case MBEDTLS_ERR_SSL_INVALID_MAC:
1620#ifdef MBEDTLS_2_X_COMPAT
1621 case MBEDTLS_ERR_SSL_UNKNOWN_CIPHER:
1623 case MBEDTLS_ERR_SSL_DECODE_ERROR:
1626 case MBEDTLS_ERR_SSL_NO_CLIENT_CERTIFICATE:
1627 alert = MBEDTLS_SSL_ALERT_MSG_NO_CERT;
1629#ifdef MBEDTLS_2_X_COMPAT
1630 case MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO:
1631 case MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO:
1632 alert = MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE;
1635 case MBEDTLS_ERR_X509_CERT_VERIFY_FAILED:
1637 case MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE:
1638 if (m_env->ssl.in_msg[1] != MBEDTLS_SSL_ALERT_MSG_CLOSE_NOTIFY)
1641 report_mbedtls_alert(m_env->ssl.in_msg[1]));
1643 case MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY:
1644 case MBEDTLS_ERR_SSL_CONN_EOF:
1645 case MBEDTLS_ERR_NET_CONN_RESET:
1651 "returned -0x%x: '%s'\n",
1652 -ret, get_error_string(ret));
1659 mbedtls_ssl_send_alert_message(&m_env->ssl,
1660 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
1662 m_env->sent_alert = 1;
1667 get_error_string(ret));
1669 mbedtls_ssl_session_reset(&m_env->ssl);
1670#ifdef MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED
1671 if (m_env->ec_jpake) {
1674#if COAP_CLIENT_SUPPORT && COAP_SERVER_SUPPORT
1680#elif COAP_CLIENT_SUPPORT
1686 mbedtls_ssl_set_hs_ecjpake_password(&m_env->ssl, psk_key->
s, psk_key->
length);
1694mbedtls_debug_out(
void *ctx
COAP_UNUSED,
int level,
1727#if !COAP_DISABLE_TCP
1735coap_sock_read(
void *ctx,
unsigned char *out,
size_t outl) {
1736 int ret = MBEDTLS_ERR_SSL_CONN_EOF;
1743 if (errno == ECONNRESET) {
1745 ret = MBEDTLS_ERR_SSL_CONN_EOF;
1747 ret = MBEDTLS_ERR_NET_RECV_FAILED;
1749 }
else if (ret == 0) {
1751 ret = MBEDTLS_ERR_SSL_WANT_READ;
1764coap_sock_write(
void *context,
const unsigned char *in,
size_t inl) {
1769 (
const uint8_t *)in,
1775 (errno == EPIPE || errno == ECONNRESET)) {
1790 int lasterror = WSAGetLastError();
1792 if (lasterror == WSAEWOULDBLOCK) {
1793 ret = MBEDTLS_ERR_SSL_WANT_WRITE;
1794 }
else if (lasterror == WSAECONNRESET) {
1795 ret = MBEDTLS_ERR_NET_CONN_RESET;
1798 if (errno == EAGAIN || errno == EINTR) {
1799 ret = MBEDTLS_ERR_SSL_WANT_WRITE;
1800 }
else if (errno == EPIPE || errno == ECONNRESET) {
1801 ret = MBEDTLS_ERR_NET_CONN_RESET;
1805 ret = MBEDTLS_ERR_NET_SEND_FAILED;
1814 ret = MBEDTLS_ERR_SSL_WANT_WRITE;
1820static coap_mbedtls_env_t *
1825 coap_mbedtls_env_t *m_env = (coap_mbedtls_env_t *)c_session->
tls;
1830 m_env = (coap_mbedtls_env_t *)mbedtls_malloc(
sizeof(coap_mbedtls_env_t));
1834 memset(m_env, 0,
sizeof(coap_mbedtls_env_t));
1836 mbedtls_ssl_init(&m_env->ssl);
1837 mbedtls_ctr_drbg_init(&m_env->ctr_drbg);
1838 mbedtls_ssl_config_init(&m_env->conf);
1839 mbedtls_entropy_init(&m_env->entropy);
1841#if defined(MBEDTLS_PSA_CRYPTO_C)
1845#if defined(ESPIDF_VERSION) && defined(CONFIG_MBEDTLS_DEBUG)
1846 mbedtls_esp_enable_debug_log(&m_env->conf, CONFIG_MBEDTLS_DEBUG_LEVEL);
1848 if ((ret = mbedtls_ctr_drbg_seed(&m_env->ctr_drbg,
1849 mbedtls_entropy_func, &m_env->entropy, NULL, 0)) != 0) {
1850 if (ret != MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED) {
1851 coap_log_info(
"mbedtls_ctr_drbg_seed returned -0x%x: '%s'\n",
1852 -ret, get_error_string(ret));
1855 coap_log_err(
"mbedtls_ctr_drbg_seed returned -0x%x: '%s'\n",
1856 -ret, get_error_string(ret));
1860#if COAP_CLIENT_SUPPORT
1861 if (setup_client_ssl_session(c_session, m_env) != 0) {
1868#if defined(MBEDTLS_SSL_SRV_C)
1869 if (setup_server_ssl_session(c_session, m_env) != 0) {
1879#if MBEDTLS_VERSION_NUMBER >= 0x03020000
1880 mbedtls_ssl_conf_min_tls_version(&m_env->conf, MBEDTLS_SSL_VERSION_TLS1_2);
1882 mbedtls_ssl_conf_min_version(&m_env->conf, MBEDTLS_SSL_MAJOR_VERSION_3,
1883 MBEDTLS_SSL_MINOR_VERSION_3);
1886 if (mbedtls_ssl_setup(&m_env->ssl, &m_env->conf) != 0) {
1890 mbedtls_ssl_set_bio(&m_env->ssl, c_session, coap_dgram_write,
1891 coap_dgram_read, NULL);
1892#ifdef MBEDTLS_SSL_DTLS_CONNECTION_ID
1895#if COAP_CLIENT_SUPPORT
1896 coap_mbedtls_context_t *m_context =
1900 m_context->setup_data.use_cid) {
1908 mbedtls_ssl_set_cid(&m_env->ssl, MBEDTLS_SSL_CID_ENABLED, NULL, 0);
1912#if COAP_SERVER_SUPPORT
1913 uint8_t cid[COAP_DTLS_CID_LENGTH];
1922 mbedtls_ssl_set_cid(&m_env->ssl, MBEDTLS_SSL_CID_ENABLED, cid,
1930#if !COAP_DISABLE_TCP
1933 mbedtls_ssl_set_bio(&m_env->ssl, c_session, coap_sock_write,
1934 coap_sock_read, NULL);
1937#ifdef MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED
1938 coap_mbedtls_context_t *m_context =
1940 if ((m_context->psk_pki_enabled & IS_PSK) &&
1944#if COAP_CLIENT_SUPPORT && COAP_SERVER_SUPPORT
1950#elif COAP_CLIENT_SUPPORT
1955 mbedtls_ssl_set_hs_ecjpake_password(&m_env->ssl, psk_key->
s, psk_key->
length);
1959 mbedtls_ssl_set_timer_cb(&m_env->ssl, &m_env->timer,
1960 zephyr_timing_set_delay,
1961 zephyr_timing_get_delay);
1963 mbedtls_ssl_set_timer_cb(&m_env->ssl, &m_env->timer,
1964 mbedtls_timing_set_delay,
1965 mbedtls_timing_get_delay);
1968 mbedtls_ssl_conf_dbg(&m_env->conf, mbedtls_debug_out, stdout);
1973 mbedtls_free(m_env);
1980#if defined(MBEDTLS_SSL_PROTO_DTLS)
1983 static int reported = 0;
1987 " - update Mbed TLS to include DTLS\n");
1995#if !COAP_DISABLE_TCP
2044#ifdef MBEDTLS_SSL_DTLS_CONNECTION_ID
2051#if COAP_CLIENT_SUPPORT
2054#ifdef MBEDTLS_SSL_DTLS_CONNECTION_ID
2067 coap_mbedtls_context_t *m_context;
2070 m_context = (coap_mbedtls_context_t *)mbedtls_malloc(
sizeof(coap_mbedtls_context_t));
2072 memset(m_context, 0,
sizeof(coap_mbedtls_context_t));
2077#if COAP_SERVER_SUPPORT
2086 coap_mbedtls_context_t *m_context =
2089#if !defined(MBEDTLS_SSL_SRV_C)
2091 " libcoap not compiled for Server Mode for Mbed TLS"
2092 " - update Mbed TLS to include Server Mode\n");
2095 if (!m_context || !setup_data)
2099#ifndef MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED
2100 coap_log_warn(
"Mbed TLS not compiled for EC-JPAKE support\n");
2103 m_context->psk_pki_enabled |= IS_PSK;
2108#if COAP_CLIENT_SUPPORT
2117#if !defined(MBEDTLS_SSL_CLI_C)
2122 " libcoap not compiled for Client Mode for Mbed TLS"
2123 " - update Mbed TLS to include Client Mode\n");
2126 coap_mbedtls_context_t *m_context =
2129 if (!m_context || !setup_data)
2133 coap_log_warn(
"CoAP Client with Mbed TLS does not support Identity Hint selection\n");
2136#ifndef MBEDTLS_KEY_EXCHANGE_ECJPAKE_ENABLED
2137 coap_log_warn(
"Mbed TLS not compiled for EC-JPAKE support\n");
2141#ifndef MBEDTLS_SSL_DTLS_CONNECTION_ID
2142 coap_log_warn(
"Mbed TLS not compiled for Connection-ID support\n");
2145 m_context->psk_pki_enabled |= IS_PSK;
2155 coap_mbedtls_context_t *m_context =
2158 m_context->setup_data = *setup_data;
2159 if (!m_context->setup_data.verify_peer_cert) {
2161 m_context->setup_data.check_common_ca = 0;
2163 m_context->setup_data.allow_self_signed = 1;
2164 m_context->setup_data.allow_expired_certs = 1;
2165 m_context->setup_data.cert_chain_validation = 1;
2166 m_context->setup_data.cert_chain_verify_depth = 10;
2167 m_context->setup_data.check_cert_revocation = 1;
2168 m_context->setup_data.allow_no_crl = 1;
2169 m_context->setup_data.allow_expired_crl = 1;
2170 m_context->setup_data.allow_bad_md_hash = 1;
2171 m_context->setup_data.allow_short_rsa_length = 1;
2173 m_context->psk_pki_enabled |= IS_PKI;
2175#ifndef MBEDTLS_SSL_DTLS_CONNECTION_ID
2176 coap_log_warn(
"Mbed TLS not compiled for Connection-ID support\n");
2184 const char *ca_file,
2185 const char *ca_path) {
2186 coap_mbedtls_context_t *m_context =
2190 coap_log_warn(
"coap_context_set_pki_root_cas: (D)TLS environment "
2195 if (ca_file == NULL && ca_path == NULL) {
2196 coap_log_warn(
"coap_context_set_pki_root_cas: ca_file and/or ca_path "
2200 if (m_context->root_ca_file) {
2201 mbedtls_free(m_context->root_ca_file);
2202 m_context->root_ca_file = NULL;
2206 m_context->root_ca_file = mbedtls_strdup(ca_file);
2209 if (m_context->root_ca_path) {
2210 mbedtls_free(m_context->root_ca_path);
2211 m_context->root_ca_path = NULL;
2215 m_context->root_ca_path = mbedtls_strdup(ca_path);
2226 coap_mbedtls_context_t *m_context =
2230 coap_log_warn(
"coap_context_load_pki_trust_store: (D)TLS environment "
2234 m_context->trust_store_defined = 1;
2243 coap_mbedtls_context_t *m_context =
2245 return m_context->psk_pki_enabled ? 1 : 0;
2250 coap_mbedtls_context_t *m_context = (coap_mbedtls_context_t *)dtls_context;
2253 for (i = 0; i < m_context->pki_sni_count; i++) {
2254 mbedtls_free(m_context->pki_sni_entry_list[i].sni);
2256 mbedtls_x509_crt_free(&m_context->pki_sni_entry_list[i].public_cert);
2258 mbedtls_pk_free(&m_context->pki_sni_entry_list[i].private_key);
2260 mbedtls_x509_crt_free(&m_context->pki_sni_entry_list[i].cacert);
2262 if (m_context->pki_sni_entry_list)
2263 mbedtls_free(m_context->pki_sni_entry_list);
2265 for (i = 0; i < m_context->psk_sni_count; i++) {
2266 mbedtls_free(m_context->psk_sni_entry_list[i].sni);
2268 if (m_context->psk_sni_entry_list)
2269 mbedtls_free(m_context->psk_sni_entry_list);
2271 if (m_context->root_ca_path)
2272 mbedtls_free(m_context->root_ca_path);
2273 if (m_context->root_ca_file)
2274 mbedtls_free(m_context->root_ca_file);
2276 mbedtls_free(m_context);
2279#if COAP_CLIENT_SUPPORT
2282#if !defined(MBEDTLS_SSL_CLI_C)
2285 " libcoap not compiled for Client Mode for Mbed TLS"
2286 " - update Mbed TLS to include Client Mode\n");
2289 coap_mbedtls_env_t *m_env = coap_dtls_new_mbedtls_env(c_session,
2298 m_env->last_timeout = now;
2299 ret = do_mbedtls_handshake(c_session, m_env);
2301 coap_dtls_free_mbedtls_env(m_env);
2310#if COAP_SERVER_SUPPORT
2313#if !defined(MBEDTLS_SSL_SRV_C)
2316 " libcoap not compiled for Server Mode for Mbed TLS"
2317 " - update Mbed TLS to include Server Mode\n");
2320 coap_mbedtls_env_t *m_env =
2321 (coap_mbedtls_env_t *)c_session->
tls;
2323#if defined(MBEDTLS_SSL_PROTO_DTLS)
2324#if MBEDTLS_VERSION_NUMBER >= 0x02100100
2325 mbedtls_ssl_set_mtu(&m_env->ssl, (uint16_t)c_session->
mtu);
2336 if (c_session && c_session->
context && c_session->
tls) {
2337 coap_dtls_free_mbedtls_env(c_session->
tls);
2338 c_session->
tls = NULL;
2346#if defined(MBEDTLS_SSL_PROTO_DTLS)
2347 coap_mbedtls_env_t *m_env =
2348 (coap_mbedtls_env_t *)c_session->
tls;
2350#if MBEDTLS_VERSION_NUMBER >= 0x02100100
2351 mbedtls_ssl_set_mtu(&m_env->ssl, (uint16_t)c_session->
mtu);
2361 const uint8_t *data,
size_t data_len) {
2363 coap_mbedtls_env_t *m_env = (coap_mbedtls_env_t *)c_session->
tls;
2365 assert(m_env != NULL);
2373 if (m_env->established) {
2374 ret = mbedtls_ssl_write(&m_env->ssl, (
const unsigned char *) data, data_len);
2377 case MBEDTLS_ERR_SSL_WANT_READ:
2378 case MBEDTLS_ERR_SSL_WANT_WRITE:
2381 case MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE:
2387 "returned -0x%x: '%s'\n",
2388 -ret, get_error_string(ret));
2397 ret = do_mbedtls_handshake(c_session, m_env);
2430 coap_mbedtls_env_t *m_env = (coap_mbedtls_env_t *)c_session->
tls;
2432 int ret = zephyr_timing_get_delay(&m_env->timer);
2434 int ret = mbedtls_timing_get_delay(&m_env->timer);
2436 unsigned int scalar = 1 << m_env->retry_scalar;
2446 m_env->last_timeout = now;
2459 m_env->last_timeout = now;
2477 coap_mbedtls_env_t *m_env = (coap_mbedtls_env_t *)c_session->
tls;
2480 m_env->retry_scalar++;
2482 (do_mbedtls_handshake(c_session, m_env) < 0)) {
2497 const uint8_t *data,
2502 coap_mbedtls_env_t *m_env = (coap_mbedtls_env_t *)c_session->
tls;
2503 coap_ssl_t *ssl_data;
2505 assert(m_env != NULL);
2507 ssl_data = &m_env->coap_ssl_data;
2508 if (ssl_data->pdu_len) {
2509 coap_log_err(
"** %s: Previous data not read %u bytes\n",
2512 ssl_data->pdu = data;
2513 ssl_data->pdu_len = (unsigned)data_len;
2515 if (m_env->established) {
2516#if COAP_CONSTRAINED_STACK
2529 ret = mbedtls_ssl_read(&m_env->ssl, pdu,
sizeof(pdu));
2538 case MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY:
2539 case MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE:
2542 case MBEDTLS_ERR_SSL_WANT_READ:
2546 "returned -0x%x: '%s' (length %zd)\n",
2547 -ret, get_error_string(ret), data_len);
2552 ret = do_mbedtls_handshake(c_session, m_env);
2557 if (ssl_data->pdu_len) {
2559 ret = do_mbedtls_handshake(c_session, m_env);
2580 if (ssl_data && ssl_data->pdu_len) {
2582 coap_log_debug(
"coap_dtls_receive: ret %d: remaining data %u\n", ret, ssl_data->pdu_len);
2583 ssl_data->pdu_len = 0;
2584 ssl_data->pdu = NULL;
2589#if COAP_SERVER_SUPPORT
2597 const uint8_t *data,
2599#if !defined(MBEDTLS_SSL_PROTO_DTLS) || !defined(MBEDTLS_SSL_SRV_C)
2604 " libcoap not compiled for DTLS or Server Mode for Mbed TLS"
2605 " - update Mbed TLS to include DTLS and Server Mode\n");
2608 coap_mbedtls_env_t *m_env = (coap_mbedtls_env_t *)c_session->
tls;
2609 coap_ssl_t *ssl_data;
2616 c_session->
tls = m_env;
2623 if ((ret = mbedtls_ssl_set_client_transport_id(&m_env->ssl,
2626 coap_log_err(
"mbedtls_ssl_set_client_transport_id() returned -0x%x: '%s'\n",
2627 -ret, get_error_string(ret));
2631 ssl_data = &m_env->coap_ssl_data;
2632 if (ssl_data->pdu_len) {
2633 coap_log_err(
"** %s: Previous data not read %u bytes\n",
2636 ssl_data->pdu = data;
2637 ssl_data->pdu_len = (unsigned)data_len;
2639 ret = do_mbedtls_handshake(c_session, m_env);
2640 if (ret == 0 || m_env->seen_client_hello) {
2646 m_env->seen_client_hello = 0;
2652 if (ssl_data->pdu_len) {
2654 coap_log_debug(
"coap_dtls_hello: ret %d: remaining data %u\n", ret, ssl_data->pdu_len);
2655 ssl_data->pdu_len = 0;
2656 ssl_data->pdu = NULL;
2665 coap_mbedtls_env_t *m_env = (coap_mbedtls_env_t *)c_session->
tls;
2666 int expansion = mbedtls_ssl_get_record_expansion(&m_env->ssl);
2668 if (expansion == MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE) {
2674#if !COAP_DISABLE_TCP
2675#if COAP_CLIENT_SUPPORT
2678#if !defined(MBEDTLS_SSL_CLI_C)
2682 " libcoap not compiled for Client Mode for Mbed TLS"
2683 " - update Mbed TLS to include Client Mode\n");
2686 coap_mbedtls_env_t *m_env = coap_dtls_new_mbedtls_env(c_session,
2696 m_env->last_timeout = now;
2697 c_session->
tls = m_env;
2698 ret = do_mbedtls_handshake(c_session, m_env);
2708#if COAP_SERVER_SUPPORT
2711#if !defined(MBEDTLS_SSL_SRV_C)
2716 " libcoap not compiled for Server Mode for Mbed TLS"
2717 " - update Mbed TLS to include Server Mode\n");
2720 coap_mbedtls_env_t *m_env = coap_dtls_new_mbedtls_env(c_session,
2728 c_session->
tls = m_env;
2729 ret = do_mbedtls_handshake(c_session, m_env);
2754 coap_mbedtls_env_t *m_env = (coap_mbedtls_env_t *)c_session->
tls;
2755 size_t amount_sent = 0;
2757 assert(m_env != NULL);
2764 if (m_env->established) {
2765 while (amount_sent < data_len) {
2766 ret = mbedtls_ssl_write(&m_env->ssl, &data[amount_sent],
2767 data_len - amount_sent);
2770 case MBEDTLS_ERR_SSL_WANT_READ:
2771 case MBEDTLS_ERR_SSL_WANT_WRITE:
2778 case MBEDTLS_ERR_NET_CONN_RESET:
2779 case MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE:
2784 "returned -0x%x: '%s'\n",
2785 -ret, get_error_string(ret));
2797 ret = do_mbedtls_handshake(c_session, m_env);
2818 if (ret == (ssize_t)data_len)
2837 coap_mbedtls_env_t *m_env = (coap_mbedtls_env_t *)c_session->
tls;
2846 if (!m_env->established && !m_env->sent_alert) {
2847 ret = do_mbedtls_handshake(c_session, m_env);
2856 ret = mbedtls_ssl_read(&m_env->ssl, data, data_len);
2860 case MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY:
2864 case MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE:
2866 m_env->sent_alert = 1;
2869#if MBEDTLS_VERSION_NUMBER >= 0x03060000
2870 case MBEDTLS_ERR_SSL_RECEIVED_NEW_SESSION_TICKET:
2872 case MBEDTLS_ERR_SSL_WANT_READ:
2878 "returned -0x%x: '%s' (length %zd)\n",
2879 -ret, get_error_string(ret), data_len);
2883 }
else if (ret < (
int)data_len) {
2884 c_session->
sock.
flags &= ~COAP_SOCKET_CAN_READ;
2912#if COAP_CLIENT_SUPPORT
2913 mbedtls_free(psk_ciphers);
2914 mbedtls_free(pki_ciphers);
2915 mbedtls_free(ecjpake_ciphers);
2918 ecjpake_ciphers = NULL;
2919 processed_ciphers = 0;
2929 if (c_session && c_session->
tls) {
2930 coap_mbedtls_env_t *m_env;
2933 memcpy(&m_env, &c_session->
tls,
sizeof(m_env));
2935 return (
void *)&m_env->ssl;
2944#if !defined(ESPIDF_VERSION)
2954 switch ((
int)level) {
2975 mbedtls_debug_set_threshold(use_level);
2977 keep_log_level = level;
2982 return keep_log_level;
2988 version.
version = mbedtls_version_get_number();
2994#if COAP_SERVER_SUPPORT
2997 mbedtls_sha256_context *digest_ctx = mbedtls_malloc(
sizeof(mbedtls_sha256_context));
3000 mbedtls_sha256_init(digest_ctx);
3001#ifdef MBEDTLS_2_X_COMPAT
3002 if (mbedtls_sha256_starts_ret(digest_ctx, 0) != 0) {
3004 if (mbedtls_sha256_starts(digest_ctx, 0) != 0) {
3016 mbedtls_sha256_free(digest_ctx);
3017 mbedtls_free(digest_ctx);
3023 const uint8_t *data,
3025#ifdef MBEDTLS_2_X_COMPAT
3026 int ret = mbedtls_sha256_update_ret(digest_ctx, data, data_len);
3028 int ret = mbedtls_sha256_update(digest_ctx, data, data_len);
3037#ifdef MBEDTLS_2_X_COMPAT
3038 int ret = mbedtls_sha256_finish_ret(digest_ctx, (uint8_t *)digest_buffer);
3040 int ret = mbedtls_sha256_finish(digest_ctx, (uint8_t *)digest_buffer);
3048#include <mbedtls/cipher.h>
3049#include <mbedtls/md.h>
3051#ifndef MBEDTLS_CIPHER_MODE_AEAD
3052#error need MBEDTLS_CIPHER_MODE_AEAD, please enable MBEDTLS_CCM_C
3055#ifdef MBEDTLS_ERROR_C
3056#include <mbedtls/error.h>
3059#ifdef MBEDTLS_ERROR_C
3062 int c_tmp = (int)(Func); \
3064 char error_buf[64]; \
3065 mbedtls_strerror(c_tmp, error_buf, sizeof(error_buf)); \
3066 coap_log_err("mbedtls: -0x%04x: %s\n", -c_tmp, error_buf); \
3073 int c_tmp = (int)(Func); \
3075 coap_log_err("mbedtls: %d\n", tmp); \
3086static struct hash_algs {
3088 mbedtls_md_type_t hash_type;
3096static mbedtls_md_type_t
3097get_hash_alg(
cose_alg_t alg,
size_t *hash_len) {
3100 for (idx = 0; idx <
sizeof(hashs) /
sizeof(
struct hash_algs); idx++) {
3101 if (hashs[idx].alg == alg) {
3102 *hash_len = hashs[idx].hash_size;
3103 return hashs[idx].hash_type;
3106 coap_log_debug(
"get_hash_alg: COSE hash %d not supported\n", alg);
3107 return MBEDTLS_MD_NONE;
3114 mbedtls_md_context_t ctx;
3116 const mbedtls_md_info_t *md_info;
3120 mbedtls_md_type_t dig_type = get_hash_alg(alg, &hash_length);
3122 if (dig_type == MBEDTLS_MD_NONE) {
3123 coap_log_debug(
"coap_crypto_hash: algorithm %d not supported\n", alg);
3126 md_info = mbedtls_md_info_from_type(dig_type);
3128 len = mbedtls_md_get_size(md_info);
3133 mbedtls_md_init(&ctx);
3134 C(mbedtls_md_setup(&ctx, md_info, 0));
3136 C(mbedtls_md_starts(&ctx));
3137 C(mbedtls_md_update(&ctx, (
const unsigned char *)data->
s, data->
length));
3141 C(mbedtls_md_finish(&ctx,
dummy->s));
3146 mbedtls_md_free(&ctx);
3151#if COAP_OSCORE_SUPPORT
3162static struct cipher_algs {
3164 mbedtls_cipher_type_t cipher_type;
3169static mbedtls_cipher_type_t
3173 for (idx = 0; idx <
sizeof(ciphers) /
sizeof(
struct cipher_algs); idx++) {
3174 if (ciphers[idx].alg == alg)
3175 return ciphers[idx].cipher_type;
3177 coap_log_debug(
"get_cipher_alg: COSE cipher %d not supported\n", alg);
3186static struct hmac_algs {
3188 mbedtls_md_type_t hmac_type;
3195static mbedtls_md_type_t
3199 for (idx = 0; idx <
sizeof(hmacs) /
sizeof(
struct hmac_algs); idx++) {
3200 if (hmacs[idx].hmac_alg == hmac_alg)
3201 return hmacs[idx].hmac_type;
3203 coap_log_debug(
"get_hmac_alg: COSE HMAC %d not supported\n", hmac_alg);
3209 return get_cipher_alg(alg) != 0;
3218 return get_hmac_alg(hmac_alg) != 0;
3226setup_cipher_context(mbedtls_cipher_context_t *ctx,
3228 const uint8_t *key_data,
3230 mbedtls_operation_t mode) {
3231 const mbedtls_cipher_info_t *cipher_info;
3232 mbedtls_cipher_type_t cipher_type;
3236 memset(key, 0,
sizeof(key));
3238 if ((cipher_type = get_cipher_alg(coap_alg)) == 0) {
3239 coap_log_debug(
"coap_crypto_encrypt: algorithm %d not supported\n",
3243 cipher_info = mbedtls_cipher_info_from_type(cipher_type);
3245 coap_log_crit(
"coap_crypto_encrypt: cannot get cipher info\n");
3249 mbedtls_cipher_init(ctx);
3251 C(mbedtls_cipher_setup(ctx, cipher_info));
3252 klen = mbedtls_cipher_get_key_bitlen(ctx);
3253 if ((klen > (
int)(
sizeof(key) * 8)) || (key_length >
sizeof(key))) {
3257 memcpy(key, key_data, key_length);
3258 C(mbedtls_cipher_setkey(ctx, key, klen, mode));
3263 mbedtls_cipher_free(ctx);
3272 size_t *max_result_len) {
3273 mbedtls_cipher_context_t ctx;
3275#if (MBEDTLS_VERSION_NUMBER < 0x02150000)
3276 unsigned char tag[16];
3279 size_t result_len = *max_result_len;
3285 assert(params != NULL);
3292 if (!setup_cipher_context(&ctx,
3307#if (MBEDTLS_VERSION_NUMBER < 0x02150000)
3308 C(mbedtls_cipher_auth_encrypt(&ctx,
3321 if ((result_len + ccm->
tag_len) > *max_result_len) {
3326 memcpy(result + result_len, tag, ccm->
tag_len);
3327 *max_result_len = result_len + ccm->
tag_len;
3330 C(mbedtls_cipher_auth_encrypt_ext(&ctx,
3342 *max_result_len = result_len;
3347 mbedtls_cipher_free(&ctx);
3356 size_t *max_result_len) {
3357 mbedtls_cipher_context_t ctx;
3359#if (MBEDTLS_VERSION_NUMBER < 0x02150000)
3360 const unsigned char *tag;
3363 size_t result_len = *max_result_len;
3369 assert(params != NULL);
3377 if (!setup_cipher_context(&ctx,
3397#if (MBEDTLS_VERSION_NUMBER < 0x02150000)
3399 C(mbedtls_cipher_auth_decrypt(&ctx,
3412 C(mbedtls_cipher_auth_decrypt_ext(&ctx,
3427 *max_result_len = result_len;
3430 mbedtls_cipher_free(&ctx);
3439 mbedtls_md_context_t ctx;
3441 const int use_hmac = 1;
3442 const mbedtls_md_info_t *md_info;
3443 mbedtls_md_type_t mac_algo;
3451 if ((mac_algo = get_hmac_alg(hmac_alg)) == 0) {
3452 coap_log_debug(
"coap_crypto_hmac: algorithm %d not supported\n", hmac_alg);
3455 md_info = mbedtls_md_info_from_type(mac_algo);
3457 len = mbedtls_md_get_size(md_info);
3462 mbedtls_md_init(&ctx);
3463 C(mbedtls_md_setup(&ctx, md_info, use_hmac));
3465 C(mbedtls_md_hmac_starts(&ctx, key->
s, key->
length));
3466 C(mbedtls_md_hmac_update(&ctx, (
const unsigned char *)data->
s, data->
length));
3470 C(mbedtls_md_hmac_finish(&ctx,
dummy->s));
3475 mbedtls_md_free(&ctx);
3487#pragma GCC diagnostic ignored "-Wunused-function"
#define COAP_SERVER_SUPPORT
const char * coap_socket_strerror(void)
#define COAP_RXBUFFER_SIZE
#define COAP_SOCKET_WANT_WRITE
non blocking socket is waiting for writing
Library specific build wrapper for coap_internal.h.
int coap_dtls_context_set_pki(coap_context_t *ctx COAP_UNUSED, const coap_dtls_pki_t *setup_data COAP_UNUSED, const coap_dtls_role_t role COAP_UNUSED)
coap_tick_t coap_dtls_get_timeout(coap_session_t *session COAP_UNUSED, coap_tick_t now COAP_UNUSED)
ssize_t coap_tls_read(coap_session_t *session COAP_UNUSED, uint8_t *data COAP_UNUSED, size_t data_len COAP_UNUSED)
coap_tick_t coap_dtls_get_context_timeout(void *dtls_context COAP_UNUSED)
int coap_dtls_receive(coap_session_t *session COAP_UNUSED, const uint8_t *data COAP_UNUSED, size_t data_len COAP_UNUSED)
void * coap_dtls_get_tls(const coap_session_t *c_session COAP_UNUSED, coap_tls_library_t *tls_lib)
unsigned int coap_dtls_get_overhead(coap_session_t *session COAP_UNUSED)
int coap_dtls_context_load_pki_trust_store(coap_context_t *ctx COAP_UNUSED)
int coap_dtls_context_check_keys_enabled(coap_context_t *ctx COAP_UNUSED)
ssize_t coap_dtls_send(coap_session_t *session COAP_UNUSED, const uint8_t *data COAP_UNUSED, size_t data_len COAP_UNUSED)
ssize_t coap_tls_write(coap_session_t *session COAP_UNUSED, const uint8_t *data COAP_UNUSED, size_t data_len COAP_UNUSED)
void coap_dtls_session_update_mtu(coap_session_t *session COAP_UNUSED)
int coap_dtls_context_set_pki_root_cas(coap_context_t *ctx COAP_UNUSED, const char *ca_file COAP_UNUSED, const char *ca_path COAP_UNUSED)
int coap_dtls_handle_timeout(coap_session_t *session COAP_UNUSED)
void coap_dtls_free_context(void *handle COAP_UNUSED)
void coap_dtls_free_session(coap_session_t *coap_session COAP_UNUSED)
void * coap_dtls_new_context(coap_context_t *coap_context COAP_UNUSED)
void coap_tls_free_session(coap_session_t *coap_session COAP_UNUSED)
void coap_digest_free(coap_digest_ctx_t *digest_ctx)
Free off coap_digest_ctx_t.
int coap_digest_final(coap_digest_ctx_t *digest_ctx, coap_digest_t *digest_buffer)
Finalize the coap_digest information into the provided digest_buffer.
int coap_digest_update(coap_digest_ctx_t *digest_ctx, const uint8_t *data, size_t data_len)
Update the coap_digest information with the next chunk of data.
coap_digest_ctx_t * coap_digest_setup(void)
Initialize a coap_digest.
uint64_t coap_tick_t
This data type represents internal timer ticks with COAP_TICKS_PER_SECOND resolution.
int coap_prng_lkd(void *buf, size_t len)
Fills buf with len random bytes using the default pseudo random number generator.
int coap_handle_event_lkd(coap_context_t *context, coap_event_t event, coap_session_t *session)
Invokes the event handler of context for the given event and data.
int coap_handle_dgram(coap_context_t *ctx, coap_session_t *session, uint8_t *msg, size_t msg_len)
Parses and interprets a CoAP datagram with context ctx.
void coap_ticks(coap_tick_t *)
Returns the current value of an internal tick counter.
int coap_crypto_hmac(cose_hmac_alg_t hmac_alg, coap_bin_const_t *key, coap_bin_const_t *data, coap_bin_const_t **hmac)
Create a HMAC hash of the provided data.
int coap_crypto_aead_decrypt(const coap_crypto_param_t *params, coap_bin_const_t *data, coap_bin_const_t *aad, uint8_t *result, size_t *max_result_len)
Decrypt the provided encrypted data into plaintext.
int coap_crypto_aead_encrypt(const coap_crypto_param_t *params, coap_bin_const_t *data, coap_bin_const_t *aad, uint8_t *result, size_t *max_result_len)
Encrypt the provided plaintext data.
#define COAP_CRYPTO_MAX_KEY_SIZE
int coap_crypto_hash(cose_alg_t alg, const coap_bin_const_t *data, coap_bin_const_t **hash)
Create a hash of the provided data.
int coap_crypto_check_hkdf_alg(cose_hkdf_alg_t hkdf_alg)
Check whether the defined hkdf algorithm is supported by the underlying crypto library.
int coap_crypto_check_cipher_alg(cose_alg_t alg)
Check whether the defined cipher algorithm is supported by the underlying crypto library.
void * coap_tls_new_server_session(coap_session_t *coap_session)
Create a TLS new server-side session.
const coap_bin_const_t * coap_get_session_client_psk_identity(const coap_session_t *coap_session)
Get the current client's PSK identity.
void coap_dtls_startup(void)
Initialize the underlying (D)TLS Library layer.
int coap_dtls_define_issue(coap_define_issue_key_t type, coap_define_issue_fail_t fail, coap_dtls_key_t *key, const coap_dtls_role_t role, int ret)
Report PKI DEFINE type issue.
void * coap_dtls_new_client_session(coap_session_t *coap_session)
Create a new client-side session.
void * coap_dtls_new_server_session(coap_session_t *coap_session)
Create a new DTLS server-side session.
int coap_dtls_hello(coap_session_t *coap_session, const uint8_t *data, size_t data_len)
Handling client HELLO messages from a new candiate peer.
int coap_dtls_set_cid_tuple_change(coap_context_t *context, uint8_t every)
Set the Connection ID client tuple frequency change for testing CIDs.
int coap_dtls_is_context_timeout(void)
Check if timeout is handled per CoAP session or per CoAP context.
int coap_dtls_context_set_cpsk(coap_context_t *coap_context, coap_dtls_cpsk_t *setup_data)
Set the DTLS context's default client PSK information.
int coap_dtls_context_set_spsk(coap_context_t *coap_context, coap_dtls_spsk_t *setup_data)
Set the DTLS context's default server PSK information.
void coap_dtls_shutdown(void)
Close down the underlying (D)TLS Library layer.
const coap_bin_const_t * coap_get_session_client_psk_key(const coap_session_t *coap_session)
Get the current client's PSK key.
void * coap_tls_new_client_session(coap_session_t *coap_session)
Create a new TLS client-side session.
#define COAP_DTLS_RETRANSMIT_COAP_TICKS
void coap_dtls_map_key_type_to_define(const coap_dtls_pki_t *setup_data, coap_dtls_key_t *key)
Map the PKI key definitions to the new DEFINE format.
const coap_bin_const_t * coap_get_session_server_psk_key(const coap_session_t *coap_session)
Get the current server's PSK key.
@ COAP_DEFINE_KEY_PRIVATE
@ COAP_DEFINE_KEY_ROOT_CA
@ COAP_DEFINE_FAIL_NOT_SUPPORTED
coap_tls_version_t * coap_get_tls_library_version(void)
Determine the type and version of the underlying (D)TLS library.
@ COAP_PKI_KEY_DEF_PKCS11
The PKI key type is PKCS11 (pkcs11:...).
@ COAP_PKI_KEY_DEF_DER_BUF
The PKI key type is DER buffer (ASN.1).
@ COAP_PKI_KEY_DEF_PEM_BUF
The PKI key type is PEM buffer.
@ COAP_PKI_KEY_DEF_PEM
The PKI key type is PEM file.
@ COAP_PKI_KEY_DEF_ENGINE
The PKI key type is to be passed to ENGINE.
@ COAP_PKI_KEY_DEF_RPK_BUF
The PKI key type is RPK in buffer.
@ COAP_PKI_KEY_DEF_DER
The PKI key type is DER file.
@ COAP_PKI_KEY_DEF_PKCS11_RPK
The PKI key type is PKCS11 w/ RPK (pkcs11:...).
@ COAP_DTLS_ROLE_SERVER
Internal function invoked for server.
@ COAP_DTLS_ROLE_CLIENT
Internal function invoked for client.
@ COAP_PKI_KEY_DEFINE
The individual PKI key types are Definable.
@ COAP_TLS_LIBRARY_MBEDTLS
Using Mbed TLS library.
@ COAP_EVENT_DTLS_CLOSED
Triggerred when (D)TLS session closed.
@ COAP_EVENT_DTLS_CONNECTED
Triggered when (D)TLS session connected.
@ COAP_EVENT_DTLS_ERROR
Triggered when (D)TLS error occurs.
#define coap_lock_callback_ret(r, func)
Dummy for no thread-safe code.
#define coap_log_debug(...)
#define coap_log_emerg(...)
coap_log_t coap_dtls_get_log_level(void)
Get the current (D)TLS logging.
#define coap_dtls_log(level,...)
Logging function.
void coap_dtls_set_log_level(coap_log_t level)
Sets the (D)TLS logging level to the specified level.
const char * coap_session_str(const coap_session_t *session)
Get session description.
#define coap_log_info(...)
#define coap_log_warn(...)
#define coap_log_err(...)
#define coap_log_crit(...)
int coap_netif_available(coap_session_t *session)
Function interface to check whether netif for session is still available.
int cose_get_hmac_alg_for_hkdf(cose_hkdf_alg_t hkdf_alg, cose_hmac_alg_t *hmac_alg)
@ COSE_HMAC_ALG_HMAC384_384
@ COSE_HMAC_ALG_HMAC256_256
@ COSE_HMAC_ALG_HMAC512_512
@ COSE_ALGORITHM_SHA_256_256
@ COSE_ALGORITHM_AES_CCM_16_64_128
@ COSE_ALGORITHM_AES_CCM_16_64_256
coap_proto_t
CoAP protocol types.
int coap_session_refresh_psk_hint(coap_session_t *session, const coap_bin_const_t *psk_hint)
Refresh the session's current Identity Hint (PSK).
int coap_session_refresh_psk_key(coap_session_t *session, const coap_bin_const_t *psk_key)
Refresh the session's current pre-shared key (PSK).
void coap_session_connected(coap_session_t *session)
Notify session that it has just connected or reconnected.
int coap_session_refresh_psk_identity(coap_session_t *session, const coap_bin_const_t *psk_identity)
Refresh the session's current pre-shared identity (PSK).
void coap_session_disconnected_lkd(coap_session_t *session, coap_nack_reason_t reason)
Notify session that it has failed.
#define COAP_PROTO_NOT_RELIABLE(p)
@ COAP_SESSION_TYPE_CLIENT
client-side
@ COAP_SESSION_STATE_HANDSHAKE
@ COAP_SESSION_STATE_NONE
coap_binary_t * coap_new_binary(size_t size)
Returns a new binary object with at least size bytes storage allocated.
coap_bin_const_t * coap_new_bin_const(const uint8_t *data, size_t size)
Take the specified byte array (text) and create a coap_bin_const_t * Returns a new const binary objec...
int coap_dtls_cid_is_supported(void)
Check whether (D)TLS CID is available.
int coap_dtls_psk_is_supported(void)
Check whether (D)TLS PSK is available.
int coap_tls_is_supported(void)
Check whether TLS is available.
int coap_oscore_is_supported(void)
Check whether OSCORE is available.
int coap_dtls_is_supported(void)
Check whether DTLS is available.
int coap_dtls_pki_is_supported(void)
Check whether (D)TLS PKI is available.
int coap_dtls_rpk_is_supported(void)
Check whether (D)TLS RPK is available.
int coap_dtls_pkcs11_is_supported(void)
Check whether (D)TLS PKCS11 is available.
coap_address_t remote
remote address and port
CoAP binary data definition with const data.
size_t length
length of binary data
const uint8_t * s
read-only binary data
CoAP binary data definition.
The CoAP stack's global state is stored in a coap_context_t object.
uint8_t testing_cids
Change client's source port every testing_cids.
coap_dtls_spsk_t spsk_setup_data
Contains the initial PSK server setup data.
The structure that holds the AES Crypto information.
size_t l
The number of bytes in the length field.
const uint8_t * nonce
must be exactly 15 - l bytes
coap_crypto_key_t key
The Key to use.
size_t tag_len
The size of the Tag.
The common structure that holds the Crypto information.
union coap_crypto_param_t::@2 params
coap_crypto_aes_ccm_t aes
Used if AES type encryption.
cose_alg_t alg
The COSE algorith to use.
The structure used for defining the Client PSK setup data to be used.
uint8_t use_cid
Set to 1 if DTLS Connection ID is to be used.
char * client_sni
If not NULL, SNI to use in client TLS setup.
coap_dtls_ih_callback_t validate_ih_call_back
Identity Hint check callback function.
uint8_t ec_jpake
Set to COAP_DTLS_CPSK_SETUP_VERSION to support this version of the struct.
The structure that holds the PKI key information.
coap_pki_key_define_t define
for definable type keys
union coap_dtls_key_t::@3 key
coap_pki_key_t key_type
key format type
The structure used for defining the PKI setup data to be used.
uint8_t allow_no_crl
1 ignore if CRL not there
void * cn_call_back_arg
Passed in to the CN callback function.
uint8_t allow_short_rsa_length
1 if small RSA keysizes are allowed
uint8_t cert_chain_validation
1 if to check cert_chain_verify_depth
uint8_t allow_bad_md_hash
1 if unsupported MD hashes are allowed
uint8_t use_cid
1 if DTLS Connection ID is to be used (Client only, server always enabled) if supported
uint8_t check_cert_revocation
1 if revocation checks wanted
uint8_t cert_chain_verify_depth
recommended depth is 3
uint8_t allow_expired_certs
1 if expired certs are allowed
uint8_t verify_peer_cert
Set to COAP_DTLS_PKI_SETUP_VERSION to support this version of the struct.
uint8_t allow_self_signed
1 if self-signed certs are allowed.
coap_dtls_cn_callback_t validate_cn_call_back
CN check callback function.
uint8_t allow_expired_crl
1 if expired crl is allowed
uint8_t is_rpk_not_cert
1 is RPK instead of Public Certificate.
uint8_t check_common_ca
1 if peer cert is to be signed by the same CA as the local cert
The structure that holds the Server Pre-Shared Key and Identity Hint information.
The structure used for defining the Server PSK setup data to be used.
coap_dtls_psk_sni_callback_t validate_sni_call_back
SNI check callback function.
coap_dtls_id_callback_t validate_id_call_back
Identity check callback function.
void * id_call_back_arg
Passed in to the Identity callback function.
uint8_t ec_jpake
Set to COAP_DTLS_SPSK_SETUP_VERSION to support this version of the struct.
void * sni_call_back_arg
Passed in to the SNI callback function.
coap_layer_write_t l_write
coap_layer_establish_t l_establish
coap_const_char_ptr_t public_cert
define: Public Cert
coap_const_char_ptr_t private_key
define: Private Key
coap_const_char_ptr_t ca
define: Common CA Certificate
size_t public_cert_len
define Public Cert length (if needed)
size_t ca_len
define CA Cert length (if needed)
coap_pki_define_t private_key_def
define: Private Key type definition
size_t private_key_len
define Private Key length (if needed)
coap_pki_define_t ca_def
define: Common CA type definition
coap_pki_define_t public_cert_def
define: Public Cert type definition
Abstraction of virtual session that can be attached to coap_context_t (client) or coap_endpoint_t (se...
unsigned int dtls_timeout_count
dtls setup retry counter
coap_endpoint_t * endpoint
session's endpoint
coap_socket_t sock
socket object for the session, if any
coap_session_state_t state
current state of relationship with peer
coap_bin_const_t * client_cid
Contains client CID or NULL.
coap_addr_tuple_t addr_info
remote/local address info
coap_proto_t proto
protocol used
coap_dtls_cpsk_t cpsk_setup_data
client provided PSK initial setup data
size_t mtu
path or CSM mtu (xmt)
uint8_t negotiated_cid
Set for a client if CID negotiated.
int dtls_event
Tracking any (D)TLS events on this session.
void * tls
security parameters
uint16_t max_retransmit
maximum re-transmit count (default 4)
coap_session_type_t type
client or server side socket
coap_context_t * context
session's context
coap_layer_func_t lfunc[COAP_LAYER_LAST]
Layer functions to use.
coap_socket_flags_t flags
1 or more of COAP_SOCKET* flag values
The structure used for returning the underlying (D)TLS library information.
uint64_t built_version
(D)TLS Built against Library Version
coap_tls_library_t type
Library type.
uint64_t version
(D)TLS runtime Library Version
const char * s_byte
signed char ptr
const uint8_t * u_byte
unsigned char ptr