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#ifndef MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED
90#ifdef MBEDTLS_KEY_EXCHANGE_SOME_PSK_ENABLED
91#define MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED
95#if ! COAP_SERVER_SUPPORT
96#undef MBEDTLS_SSL_SRV_C
98#if ! COAP_CLIENT_SUPPORT
99#undef MBEDTLS_SSL_CLI_C
103#define strcasecmp _stricmp
106#define IS_PSK (1 << 0)
107#define IS_PKI (1 << 1)
108#define IS_CLIENT (1 << 6)
109#define IS_SERVER (1 << 7)
111typedef struct coap_ssl_t {
122typedef struct coap_mbedtls_env_t {
123 mbedtls_ssl_context ssl;
124 mbedtls_entropy_context entropy;
125 mbedtls_ctr_drbg_context ctr_drbg;
126 mbedtls_ssl_config conf;
127 mbedtls_timing_delay_context timer;
128 mbedtls_x509_crt cacert;
129 mbedtls_x509_crt public_cert;
130 mbedtls_pk_context private_key;
131 mbedtls_ssl_cookie_ctx cookie_ctx;
135 int seen_client_hello;
137 unsigned int retry_scalar;
138 coap_ssl_t coap_ssl_data;
141typedef struct pki_sni_entry {
144 mbedtls_x509_crt cacert;
145 mbedtls_x509_crt public_cert;
146 mbedtls_pk_context private_key;
149typedef struct psk_sni_entry {
154typedef struct coap_mbedtls_context_t {
156 size_t pki_sni_count;
157 pki_sni_entry *pki_sni_entry_list;
158 size_t psk_sni_count;
159 psk_sni_entry *psk_sni_entry_list;
163} coap_mbedtls_context_t;
165typedef enum coap_enc_method_t {
170#ifndef MBEDTLS_2_X_COMPAT
175coap_rng(
void *ctx
COAP_UNUSED,
unsigned char *buf,
size_t len) {
176 return coap_prng(buf, len) ? 0 : MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED;
181coap_dgram_read(
void *ctx,
unsigned char *out,
size_t outl) {
186 if (!c_session->
tls) {
188 return MBEDTLS_ERR_SSL_WANT_READ;
190 data = &((coap_mbedtls_env_t *)c_session->
tls)->coap_ssl_data;
193 if (data->pdu_len > 0) {
194 if (outl < data->pdu_len) {
195 memcpy(out, data->pdu, outl);
198 data->pdu_len -= outl;
200 memcpy(out, data->pdu, data->pdu_len);
202 if (!data->peekmode) {
208 ret = MBEDTLS_ERR_SSL_WANT_READ;
222coap_dgram_write(
void *ctx,
const unsigned char *send_buffer,
223 size_t send_buffer_length) {
228 coap_mbedtls_env_t *m_env = (coap_mbedtls_env_t *)c_session->
tls;
240 send_buffer, send_buffer_length);
241 if (result != (ssize_t)send_buffer_length) {
243 result, send_buffer_length);
248 m_env->last_timeout = now;
256#if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED) && defined(MBEDTLS_SSL_SRV_C)
261psk_server_callback(
void *p_info, mbedtls_ssl_context *ssl,
262 const unsigned char *identity,
size_t identity_len) {
265 coap_mbedtls_env_t *m_env;
269 if (c_session == NULL)
273 lidentity.
s = identity ? (
const uint8_t *)identity : (const uint8_t *)
"";
274 lidentity.
length = identity ? identity_len : 0;
278 (
int)lidentity.
length, (
const char *)lidentity.
s);
280 m_env = (coap_mbedtls_env_t *)c_session->
tls;
295 mbedtls_ssl_set_hs_psk(ssl, psk_key->
s, psk_key->
length);
296 m_env->seen_client_hello = 1;
302get_san_or_cn_from_cert(mbedtls_x509_crt *crt) {
304 const mbedtls_asn1_named_data *cn_data;
306 if (crt->ext_types & MBEDTLS_X509_EXT_SUBJECT_ALT_NAME) {
307 mbedtls_asn1_sequence *seq = &crt->subject_alt_names;
308 while (seq && seq->buf.p == NULL) {
313 return mbedtls_strndup((
const char *)seq->buf.p,
318 cn_data = mbedtls_asn1_find_named_data(&crt->subject,
320 MBEDTLS_OID_SIZE(MBEDTLS_OID_AT_CN));
323 return mbedtls_strndup((
const char *)cn_data->val.p,
330#if COAP_MAX_LOGGING_LEVEL > 0
332get_error_string(
int ret) {
333 static char buf[128] = {0};
334 mbedtls_strerror(ret, buf,
sizeof(buf)-1);
340self_signed_cert_verify_callback_mbedtls(
void *data,
345 const coap_mbedtls_context_t *m_context =
349 if (*flags & MBEDTLS_X509_BADCERT_EXPIRED) {
351 *flags &= ~MBEDTLS_X509_BADCERT_EXPIRED;
362cert_verify_callback_mbedtls(
void *data, mbedtls_x509_crt *crt,
363 int depth, uint32_t *flags) {
365 coap_mbedtls_context_t *m_context =
373 cn = get_san_or_cn_from_cert(crt);
375 if (*flags & MBEDTLS_X509_BADCERT_EXPIRED) {
377 *flags &= ~MBEDTLS_X509_BADCERT_EXPIRED;
380 "The certificate has expired", cn ? cn :
"?", depth);
383 if (*flags & MBEDTLS_X509_BADCERT_FUTURE) {
385 *flags &= ~MBEDTLS_X509_BADCERT_FUTURE;
388 "The certificate has a future date", cn ? cn :
"?", depth);
391 if (*flags & MBEDTLS_X509_BADCERT_BAD_MD) {
393 *flags &= ~MBEDTLS_X509_BADCERT_BAD_MD;
396 "The certificate has a bad MD hash", cn ? cn :
"?", depth);
399 if (*flags & MBEDTLS_X509_BADCERT_BAD_KEY) {
401 *flags &= ~MBEDTLS_X509_BADCERT_BAD_KEY;
404 "The certificate has a short RSA length", cn ? cn :
"?", depth);
407 if (*flags & MBEDTLS_X509_BADCERT_NOT_TRUSTED) {
409 int self_signed = !mbedtls_x509_crt_verify(crt, crt, NULL, NULL, &lflags,
410 self_signed_cert_verify_callback_mbedtls,
412 if (self_signed && depth == 0) {
415 *flags &= ~MBEDTLS_X509_BADCERT_NOT_TRUSTED;
419 cn ? cn :
"?", depth);
423 *flags &= ~MBEDTLS_X509_BADCERT_NOT_TRUSTED;
426 "The certificate's CA does not match", cn ? cn :
"?", depth);
430 if (*flags & MBEDTLS_X509_BADCRL_EXPIRED) {
432 *flags &= ~MBEDTLS_X509_BADCRL_EXPIRED;
435 "The certificate's CRL has expired", cn ? cn :
"?", depth);
437 *flags &= ~MBEDTLS_X509_BADCRL_EXPIRED;
440 if (*flags & MBEDTLS_X509_BADCRL_FUTURE) {
442 *flags &= ~MBEDTLS_X509_BADCRL_FUTURE;
445 "The certificate's CRL has a future date", cn ? cn :
"?", depth);
447 *flags &= ~MBEDTLS_X509_BADCRL_FUTURE;
452 *flags |= MBEDTLS_X509_BADCERT_OTHER;
455 "The certificate's verify depth is too long",
456 cn ? cn :
"?", depth);
459 if (*flags & MBEDTLS_X509_BADCERT_CN_MISMATCH) {
460 *flags &= ~MBEDTLS_X509_BADCERT_CN_MISMATCH;
470 *flags |= MBEDTLS_X509_BADCERT_CN_MISMATCH;
476 int ret = mbedtls_x509_crt_verify_info(buf,
sizeof(buf),
"", *flags);
479 tcp = strchr(buf,
'\n');
484 buf, *flags, cn ? cn :
"?", depth);
485 tcp = strchr(tcp+1,
'\n');
488 coap_log_err(
"mbedtls_x509_crt_verify_info returned -0x%x: '%s'\n",
489 -ret, get_error_string(ret));
500setup_pki_credentials(mbedtls_x509_crt *cacert,
501 mbedtls_x509_crt *public_cert,
502 mbedtls_pk_context *private_key,
503 coap_mbedtls_env_t *m_env,
504 coap_mbedtls_context_t *m_context,
510 int done_private_key = 0;
511 int done_public_cert = 0;
529#if defined(MBEDTLS_FS_IO)
530 mbedtls_pk_init(private_key);
531#ifdef MBEDTLS_2_X_COMPAT
532 ret = mbedtls_pk_parse_keyfile(private_key,
535 ret = mbedtls_pk_parse_keyfile(private_key,
537 NULL, coap_rng, (
void *)&m_env->ctr_drbg);
544 done_private_key = 1;
552 mbedtls_pk_init(private_key);
556 buffer = mbedtls_malloc(length + 1);
562 buffer[length] =
'\000';
564#ifdef MBEDTLS_2_X_COMPAT
565 ret = mbedtls_pk_parse_key(private_key, buffer, length, NULL, 0);
567 ret = mbedtls_pk_parse_key(private_key, buffer, length,
568 NULL, 0, coap_rng, (
void *)&m_env->ctr_drbg);
570 mbedtls_free(buffer);
572#ifdef MBEDTLS_2_X_COMPAT
573 ret = mbedtls_pk_parse_key(private_key,
577 ret = mbedtls_pk_parse_key(private_key,
580 NULL, 0, coap_rng, (
void *)&m_env->ctr_drbg);
588 done_private_key = 1;
591 mbedtls_pk_init(private_key);
592#ifdef MBEDTLS_2_X_COMPAT
593 ret = mbedtls_pk_parse_key(private_key,
597 ret = mbedtls_pk_parse_key(private_key,
600 (
void *)&m_env->ctr_drbg);
607 done_private_key = 1;
635#if defined(MBEDTLS_FS_IO)
636 mbedtls_x509_crt_init(public_cert);
637 ret = mbedtls_x509_crt_parse_file(public_cert,
644 done_public_cert = 1;
652 mbedtls_x509_crt_init(public_cert);
657 buffer = mbedtls_malloc(length + 1);
663 buffer[length] =
'\000';
665 ret = mbedtls_x509_crt_parse(public_cert, buffer, length);
666 mbedtls_free(buffer);
668 ret = mbedtls_x509_crt_parse(public_cert,
677 done_public_cert = 1;
684 mbedtls_x509_crt_init(public_cert);
685 ret = mbedtls_x509_crt_parse(public_cert,
693 done_public_cert = 1;
711 if (done_private_key && done_public_cert) {
712 ret = mbedtls_ssl_conf_own_cert(&m_env->conf, public_cert, private_key);
714 coap_log_err(
"mbedtls_ssl_conf_own_cert returned -0x%x: '%s'\n",
715 -ret, get_error_string(ret));
729#if defined(MBEDTLS_FS_IO)
730 mbedtls_x509_crt_init(cacert);
731 ret = mbedtls_x509_crt_parse_file(cacert,
738 mbedtls_ssl_conf_ca_chain(&m_env->conf, cacert, NULL);
746 mbedtls_x509_crt_init(cacert);
750 buffer = mbedtls_malloc(length + 1);
756 buffer[length] =
'\000';
758 ret = mbedtls_x509_crt_parse(cacert, buffer, length);
759 mbedtls_free(buffer);
761 ret = mbedtls_x509_crt_parse(cacert,
770 mbedtls_ssl_conf_ca_chain(&m_env->conf, cacert, NULL);
777 mbedtls_x509_crt_init(cacert);
778 ret = mbedtls_x509_crt_parse(cacert,
786 mbedtls_ssl_conf_ca_chain(&m_env->conf, cacert, NULL);
800#if defined(MBEDTLS_FS_IO)
801 if (m_context->root_ca_file) {
802 ret = mbedtls_x509_crt_parse_file(cacert, m_context->root_ca_file);
809 mbedtls_ssl_conf_ca_chain(&m_env->conf, cacert, NULL);
811 if (m_context->root_ca_path) {
812 ret = mbedtls_x509_crt_parse_file(cacert, m_context->root_ca_path);
819 mbedtls_ssl_conf_ca_chain(&m_env->conf, cacert, NULL);
828#if defined(MBEDTLS_SSL_SRV_C)
829 mbedtls_ssl_conf_cert_req_ca_list(&m_env->conf,
831 MBEDTLS_SSL_CERT_REQ_CA_LIST_ENABLED :
832 MBEDTLS_SSL_CERT_REQ_CA_LIST_DISABLED);
835 MBEDTLS_SSL_VERIFY_REQUIRED :
836 MBEDTLS_SSL_VERIFY_NONE);
841 mbedtls_ssl_conf_verify(&m_env->conf,
842 cert_verify_callback_mbedtls, c_session);
847#if defined(MBEDTLS_SSL_SRV_C)
852pki_sni_callback(
void *p_info, mbedtls_ssl_context *ssl,
853 const unsigned char *uname,
size_t name_len) {
857 coap_mbedtls_env_t *m_env = (coap_mbedtls_env_t *)c_session->
tls;
858 coap_mbedtls_context_t *m_context =
862 name = mbedtls_malloc(name_len+1);
866 memcpy(name, uname, name_len);
867 name[name_len] =
'\000';
870 for (i = 0; i < m_context->pki_sni_count; i++) {
871 if (strcasecmp(name, m_context->pki_sni_entry_list[i].sni) == 0) {
875 if (i == m_context->pki_sni_count) {
880 pki_sni_entry *pki_sni_entry_list;
883 m_context->setup_data.validate_sni_call_back(name,
884 m_context->setup_data.sni_call_back_arg);
890 pki_sni_entry_list = mbedtls_realloc(m_context->pki_sni_entry_list,
891 (i+1)*
sizeof(pki_sni_entry));
893 if (pki_sni_entry_list == NULL) {
897 m_context->pki_sni_entry_list = pki_sni_entry_list;
898 memset(&m_context->pki_sni_entry_list[i], 0,
899 sizeof(m_context->pki_sni_entry_list[i]));
900 m_context->pki_sni_entry_list[i].sni = name;
901 m_context->pki_sni_entry_list[i].pki_key = *new_entry;
902 sni_setup_data = m_context->setup_data;
903 sni_setup_data.pki_key = *new_entry;
904 if (setup_pki_credentials(&m_context->pki_sni_entry_list[i].cacert,
905 &m_context->pki_sni_entry_list[i].public_cert,
906 &m_context->pki_sni_entry_list[i].private_key,
915 m_context->pki_sni_count++;
920 mbedtls_ssl_set_hs_ca_chain(ssl, &m_context->pki_sni_entry_list[i].cacert,
922 return mbedtls_ssl_set_hs_own_cert(ssl,
923 &m_context->pki_sni_entry_list[i].public_cert,
924 &m_context->pki_sni_entry_list[i].private_key);
927#if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
932psk_sni_callback(
void *p_info, mbedtls_ssl_context *ssl,
933 const unsigned char *uname,
size_t name_len) {
936 coap_mbedtls_context_t *m_context =
940 name = mbedtls_malloc(name_len+1);
944 memcpy(name, uname, name_len);
945 name[name_len] =
'\000';
948 for (i = 0; i < m_context->psk_sni_count; i++) {
949 if (strcasecmp(name, m_context->psk_sni_entry_list[i].sni) == 0) {
953 if (i == m_context->psk_sni_count) {
958 psk_sni_entry *psk_sni_entry_list;
969 psk_sni_entry_list = mbedtls_realloc(m_context->psk_sni_entry_list,
970 (i+1)*
sizeof(psk_sni_entry));
972 if (psk_sni_entry_list == NULL) {
976 m_context->psk_sni_entry_list = psk_sni_entry_list;
977 m_context->psk_sni_entry_list[i].sni = name;
978 m_context->psk_sni_entry_list[i].psk_info = *new_entry;
980 m_context->psk_sni_count++;
986 &m_context->psk_sni_entry_list[i].psk_info.hint);
988 &m_context->psk_sni_entry_list[i].psk_info.key);
989 return mbedtls_ssl_set_hs_psk(ssl,
990 m_context->psk_sni_entry_list[i].psk_info.key.s,
991 m_context->psk_sni_entry_list[i].psk_info.key.length);
997 coap_mbedtls_env_t *m_env) {
998 coap_mbedtls_context_t *m_context =
1001 m_context->psk_pki_enabled |= IS_SERVER;
1003 mbedtls_ssl_cookie_init(&m_env->cookie_ctx);
1004 if ((ret = mbedtls_ssl_config_defaults(&m_env->conf,
1005 MBEDTLS_SSL_IS_SERVER,
1007 MBEDTLS_SSL_TRANSPORT_DATAGRAM :
1008 MBEDTLS_SSL_TRANSPORT_STREAM,
1009 MBEDTLS_SSL_PRESET_DEFAULT)) != 0) {
1010 coap_log_err(
"mbedtls_ssl_config_defaults returned -0x%x: '%s'\n",
1011 -ret, get_error_string(ret));
1015 mbedtls_ssl_conf_rng(&m_env->conf, mbedtls_ctr_drbg_random, &m_env->ctr_drbg);
1017#if defined(MBEDTLS_SSL_PROTO_DTLS)
1018 mbedtls_ssl_conf_handshake_timeout(&m_env->conf, COAP_DTLS_RETRANSMIT_MS,
1019 COAP_DTLS_RETRANSMIT_TOTAL_MS);
1022 if (m_context->psk_pki_enabled & IS_PSK) {
1023#if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
1024 mbedtls_ssl_conf_psk_cb(&m_env->conf, psk_server_callback, c_session);
1026 mbedtls_ssl_conf_sni(&m_env->conf, psk_sni_callback, c_session);
1033 if (m_context->psk_pki_enabled & IS_PKI) {
1034 ret = setup_pki_credentials(&m_env->cacert, &m_env->public_cert,
1035 &m_env->private_key, m_env, m_context,
1036 c_session, &m_context->setup_data,
1042 if (m_context->setup_data.validate_sni_call_back) {
1043 mbedtls_ssl_conf_sni(&m_env->conf, pki_sni_callback, c_session);
1047 if ((ret = mbedtls_ssl_cookie_setup(&m_env->cookie_ctx,
1048 mbedtls_ctr_drbg_random,
1049 &m_env->ctr_drbg)) != 0) {
1050 coap_log_err(
"mbedtls_ssl_cookie_setup: returned -0x%x: '%s'\n",
1051 -ret, get_error_string(ret));
1055#if defined(MBEDTLS_SSL_PROTO_DTLS)
1056 mbedtls_ssl_conf_dtls_cookies(&m_env->conf, mbedtls_ssl_cookie_write,
1057 mbedtls_ssl_cookie_check,
1058 &m_env->cookie_ctx);
1059#if MBEDTLS_VERSION_NUMBER >= 0x02100100
1060 mbedtls_ssl_set_mtu(&m_env->ssl, (uint16_t)c_session->
mtu);
1063#ifdef MBEDTLS_SSL_DTLS_CONNECTION_ID
1071 mbedtls_ssl_conf_cid(&m_env->conf, COAP_DTLS_CID_LENGTH, MBEDTLS_SSL_UNEXPECTED_CID_IGNORE);
1078#if COAP_CLIENT_SUPPORT
1079static int *psk_ciphers = NULL;
1080static int *pki_ciphers = NULL;
1081static int processed_ciphers = 0;
1083#if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
1085coap_ssl_ciphersuite_uses_psk(
const mbedtls_ssl_ciphersuite_t *info) {
1086#if MBEDTLS_VERSION_NUMBER >= 0x03060000
1087 switch (info->key_exchange) {
1088 case MBEDTLS_KEY_EXCHANGE_PSK:
1089 case MBEDTLS_KEY_EXCHANGE_RSA_PSK:
1090 case MBEDTLS_KEY_EXCHANGE_DHE_PSK:
1091 case MBEDTLS_KEY_EXCHANGE_ECDHE_PSK:
1093 case MBEDTLS_KEY_EXCHANGE_NONE:
1094 case MBEDTLS_KEY_EXCHANGE_RSA:
1095 case MBEDTLS_KEY_EXCHANGE_DHE_RSA:
1096 case MBEDTLS_KEY_EXCHANGE_ECDHE_RSA:
1097 case MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA:
1098 case MBEDTLS_KEY_EXCHANGE_ECDH_RSA:
1099 case MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA:
1100 case MBEDTLS_KEY_EXCHANGE_ECJPAKE:
1105 return mbedtls_ssl_ciphersuite_uses_psk(info);
1111set_ciphersuites(mbedtls_ssl_config *conf, coap_enc_method_t method) {
1112 if (!processed_ciphers) {
1113 const int *list = mbedtls_ssl_list_ciphersuites();
1114 const int *base = list;
1121 const mbedtls_ssl_ciphersuite_t *cur =
1122 mbedtls_ssl_ciphersuite_from_id(*list);
1124#if MBEDTLS_VERSION_NUMBER >= 0x03020000
1126 if (cur->max_tls_version < MBEDTLS_SSL_VERSION_TLS1_2) {
1131 if (cur->max_minor_ver < MBEDTLS_SSL_MINOR_VERSION_3) {
1135#if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
1136 else if (coap_ssl_ciphersuite_uses_psk(cur)) {
1148 psk_ciphers = mbedtls_malloc(psk_count *
sizeof(psk_ciphers[0]));
1149 if (psk_ciphers == NULL) {
1150 coap_log_err(
"set_ciphers: mbedtls_malloc with count %d failed\n", psk_count);
1153 pki_ciphers = mbedtls_malloc(pki_count *
sizeof(pki_ciphers[0]));
1154 if (pki_ciphers == NULL) {
1155 coap_log_err(
"set_ciphers: mbedtls_malloc with count %d failed\n", pki_count);
1156 mbedtls_free(psk_ciphers);
1161 psk_list = psk_ciphers;
1162 pki_list = pki_ciphers;
1165 const mbedtls_ssl_ciphersuite_t *cur =
1166 mbedtls_ssl_ciphersuite_from_id(*list);
1167#if MBEDTLS_VERSION_NUMBER >= 0x03020000
1169 if (cur->max_tls_version < MBEDTLS_SSL_VERSION_TLS1_2) {
1174 if (cur->max_minor_ver < MBEDTLS_SSL_MINOR_VERSION_3) {
1178#if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
1179 else if (coap_ssl_ciphersuite_uses_psk(cur)) {
1194 processed_ciphers = 1;
1196 mbedtls_ssl_conf_ciphersuites(conf, method == COAP_ENC_PSK ? psk_ciphers : pki_ciphers);
1201 coap_mbedtls_env_t *m_env) {
1204 coap_mbedtls_context_t *m_context =
1207 m_context->psk_pki_enabled |= IS_CLIENT;
1209 if ((ret = mbedtls_ssl_config_defaults(&m_env->conf,
1210 MBEDTLS_SSL_IS_CLIENT,
1212 MBEDTLS_SSL_TRANSPORT_DATAGRAM :
1213 MBEDTLS_SSL_TRANSPORT_STREAM,
1214 MBEDTLS_SSL_PRESET_DEFAULT)) != 0) {
1215 coap_log_err(
"mbedtls_ssl_config_defaults returned -0x%x: '%s'\n",
1216 -ret, get_error_string(ret));
1220#if defined(MBEDTLS_SSL_PROTO_DTLS)
1221 mbedtls_ssl_conf_handshake_timeout(&m_env->conf, COAP_DTLS_RETRANSMIT_MS,
1222 COAP_DTLS_RETRANSMIT_TOTAL_MS);
1225 mbedtls_ssl_conf_authmode(&m_env->conf, MBEDTLS_SSL_VERIFY_REQUIRED);
1226 mbedtls_ssl_conf_rng(&m_env->conf, mbedtls_ctr_drbg_random, &m_env->ctr_drbg);
1228 if (m_context->psk_pki_enabled & IS_PSK) {
1229#if defined(MBEDTLS_KEY_EXCHANGE__SOME__PSK_ENABLED)
1237 if (psk_key == NULL || psk_identity == NULL) {
1238 ret = MBEDTLS_ERR_SSL_ALLOC_FAILED;
1242 if ((ret = mbedtls_ssl_conf_psk(&m_env->conf, psk_key->
s,
1243 psk_key->
length, psk_identity->
s,
1244 psk_identity->
length)) != 0) {
1245 coap_log_err(
"mbedtls_ssl_conf_psk returned -0x%x: '%s'\n",
1246 -ret, get_error_string(ret));
1250 if ((ret = mbedtls_ssl_set_hostname(&m_env->ssl,
1252 coap_log_err(
"mbedtls_ssl_set_hostname returned -0x%x: '%s'\n",
1253 -ret, get_error_string(ret));
1259 set_ciphersuites(&m_env->conf, COAP_ENC_PSK);
1263 }
else if ((m_context->psk_pki_enabled & IS_PKI) ||
1264 (m_context->psk_pki_enabled & (IS_PSK | IS_PKI)) == 0) {
1269 mbedtls_ssl_conf_authmode(&m_env->conf, MBEDTLS_SSL_VERIFY_OPTIONAL);
1270 ret = setup_pki_credentials(&m_env->cacert, &m_env->public_cert,
1271 &m_env->private_key, m_env, m_context,
1272 c_session, &m_context->setup_data,
1278#if defined(MBEDTLS_SSL_SRV_C) && defined(MBEDTLS_SSL_ALPN)
1281 static const char *alpn_list[] = {
"coap", NULL };
1283 ret = mbedtls_ssl_conf_alpn_protocols(&m_env->conf, alpn_list);
1289 if (m_context->setup_data.client_sni) {
1290 mbedtls_ssl_set_hostname(&m_env->ssl, m_context->setup_data.client_sni);
1292#if defined(MBEDTLS_SSL_PROTO_DTLS)
1293#if MBEDTLS_VERSION_NUMBER >= 0x02100100
1294 mbedtls_ssl_set_mtu(&m_env->ssl, (uint16_t)c_session->
mtu);
1297 set_ciphersuites(&m_env->conf, COAP_ENC_PKI);
1307mbedtls_cleanup(coap_mbedtls_env_t *m_env) {
1312 mbedtls_x509_crt_free(&m_env->cacert);
1313 mbedtls_x509_crt_free(&m_env->public_cert);
1314 mbedtls_pk_free(&m_env->private_key);
1315 mbedtls_entropy_free(&m_env->entropy);
1316 mbedtls_ssl_config_free(&m_env->conf);
1317 mbedtls_ctr_drbg_free(&m_env->ctr_drbg);
1318 mbedtls_ssl_free(&m_env->ssl);
1319 mbedtls_ssl_cookie_free(&m_env->cookie_ctx);
1323coap_dtls_free_mbedtls_env(coap_mbedtls_env_t *m_env) {
1325 if (!m_env->sent_alert)
1326 mbedtls_ssl_close_notify(&m_env->ssl);
1327 mbedtls_cleanup(m_env);
1328 mbedtls_free(m_env);
1332#if COAP_MAX_LOGGING_LEVEL > 0
1334report_mbedtls_alert(
unsigned char alert) {
1336 case MBEDTLS_SSL_ALERT_MSG_BAD_RECORD_MAC:
1337 return ": Bad Record MAC";
1338 case MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE:
1339 return ": Handshake failure";
1340 case MBEDTLS_SSL_ALERT_MSG_NO_CERT:
1341 return ": No Certificate provided";
1342 case MBEDTLS_SSL_ALERT_MSG_BAD_CERT:
1343 return ": Certificate is bad";
1344 case MBEDTLS_SSL_ALERT_MSG_CERT_UNKNOWN:
1345 return ": Certificate is unknown";
1346 case MBEDTLS_SSL_ALERT_MSG_UNKNOWN_CA:
1347 return ": CA is unknown";
1348 case MBEDTLS_SSL_ALERT_MSG_ACCESS_DENIED:
1349 return ": Access was denied";
1350 case MBEDTLS_SSL_ALERT_MSG_DECRYPT_ERROR:
1351 return ": Decrypt error";
1365 coap_mbedtls_env_t *m_env) {
1369 ret = mbedtls_ssl_handshake(&m_env->ssl);
1372 m_env->established = 1;
1377 case MBEDTLS_ERR_SSL_WANT_READ:
1378 case MBEDTLS_ERR_SSL_WANT_WRITE:
1382 case MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED:
1385 case MBEDTLS_ERR_SSL_INVALID_MAC:
1387#ifdef MBEDTLS_2_X_COMPAT
1388 case MBEDTLS_ERR_SSL_UNKNOWN_CIPHER:
1390 case MBEDTLS_ERR_SSL_DECODE_ERROR:
1393 case MBEDTLS_ERR_SSL_NO_CLIENT_CERTIFICATE:
1394 alert = MBEDTLS_SSL_ALERT_MSG_NO_CERT;
1396#ifdef MBEDTLS_2_X_COMPAT
1397 case MBEDTLS_ERR_SSL_BAD_HS_CLIENT_HELLO:
1398 case MBEDTLS_ERR_SSL_BAD_HS_SERVER_HELLO:
1399 alert = MBEDTLS_SSL_ALERT_MSG_HANDSHAKE_FAILURE;
1402 case MBEDTLS_ERR_X509_CERT_VERIFY_FAILED:
1404 case MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE:
1405 if (m_env->ssl.in_msg[1] != MBEDTLS_SSL_ALERT_MSG_CLOSE_NOTIFY)
1408 report_mbedtls_alert(m_env->ssl.in_msg[1]));
1410 case MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY:
1411 case MBEDTLS_ERR_SSL_CONN_EOF:
1412 case MBEDTLS_ERR_NET_CONN_RESET:
1418 "returned -0x%x: '%s'\n",
1419 -ret, get_error_string(ret));
1426 mbedtls_ssl_send_alert_message(&m_env->ssl,
1427 MBEDTLS_SSL_ALERT_LEVEL_FATAL,
1429 m_env->sent_alert = 1;
1434 get_error_string(ret));
1436 mbedtls_ssl_session_reset(&m_env->ssl);
1441mbedtls_debug_out(
void *ctx
COAP_UNUSED,
int level,
1474#if !COAP_DISABLE_TCP
1482coap_sock_read(
void *ctx,
unsigned char *out,
size_t outl) {
1483 int ret = MBEDTLS_ERR_SSL_CONN_EOF;
1490 if (errno == ECONNRESET) {
1492 ret = MBEDTLS_ERR_SSL_CONN_EOF;
1494 ret = MBEDTLS_ERR_NET_RECV_FAILED;
1496 }
else if (ret == 0) {
1498 ret = MBEDTLS_ERR_SSL_WANT_READ;
1511coap_sock_write(
void *context,
const unsigned char *in,
size_t inl) {
1516 (
const uint8_t *)in,
1522 (errno == EPIPE || errno == ECONNRESET)) {
1537 int lasterror = WSAGetLastError();
1539 if (lasterror == WSAEWOULDBLOCK) {
1540 ret = MBEDTLS_ERR_SSL_WANT_WRITE;
1541 }
else if (lasterror == WSAECONNRESET) {
1542 ret = MBEDTLS_ERR_NET_CONN_RESET;
1545 if (errno == EAGAIN || errno == EINTR) {
1546 ret = MBEDTLS_ERR_SSL_WANT_WRITE;
1547 }
else if (errno == EPIPE || errno == ECONNRESET) {
1548 ret = MBEDTLS_ERR_NET_CONN_RESET;
1552 ret = MBEDTLS_ERR_NET_SEND_FAILED;
1561 ret = MBEDTLS_ERR_SSL_WANT_WRITE;
1567static coap_mbedtls_env_t *
1572 coap_mbedtls_env_t *m_env = (coap_mbedtls_env_t *)c_session->
tls;
1577 m_env = (coap_mbedtls_env_t *)mbedtls_malloc(
sizeof(coap_mbedtls_env_t));
1581 memset(m_env, 0,
sizeof(coap_mbedtls_env_t));
1583 mbedtls_ssl_init(&m_env->ssl);
1584 mbedtls_ctr_drbg_init(&m_env->ctr_drbg);
1585 mbedtls_ssl_config_init(&m_env->conf);
1586 mbedtls_entropy_init(&m_env->entropy);
1588#if defined(MBEDTLS_PSA_CRYPTO_C)
1592#if defined(ESPIDF_VERSION) && defined(CONFIG_MBEDTLS_DEBUG)
1593 mbedtls_esp_enable_debug_log(&m_env->conf, CONFIG_MBEDTLS_DEBUG_LEVEL);
1595 if ((ret = mbedtls_ctr_drbg_seed(&m_env->ctr_drbg,
1596 mbedtls_entropy_func, &m_env->entropy, NULL, 0)) != 0) {
1597 coap_log_err(
"mbedtls_ctr_drbg_seed returned -0x%x: '%s'\n",
1598 -ret, get_error_string(ret));
1603#if COAP_CLIENT_SUPPORT
1604 if (setup_client_ssl_session(c_session, m_env) != 0) {
1611#if defined(MBEDTLS_SSL_SRV_C)
1612 if (setup_server_ssl_session(c_session, m_env) != 0) {
1622#if MBEDTLS_VERSION_NUMBER >= 0x03020000
1623 mbedtls_ssl_conf_min_tls_version(&m_env->conf, MBEDTLS_SSL_VERSION_TLS1_2);
1625 mbedtls_ssl_conf_min_version(&m_env->conf, MBEDTLS_SSL_MAJOR_VERSION_3,
1626 MBEDTLS_SSL_MINOR_VERSION_3);
1629 if (mbedtls_ssl_setup(&m_env->ssl, &m_env->conf) != 0) {
1633 mbedtls_ssl_set_bio(&m_env->ssl, c_session, coap_dgram_write,
1634 coap_dgram_read, NULL);
1635#ifdef MBEDTLS_SSL_DTLS_CONNECTION_ID
1638 u_char cid[COAP_DTLS_CID_LENGTH];
1647 mbedtls_ssl_set_cid(&m_env->ssl, MBEDTLS_SSL_CID_ENABLED, cid,
1652#if !COAP_DISABLE_TCP
1655 mbedtls_ssl_set_bio(&m_env->ssl, c_session, coap_sock_write,
1656 coap_sock_read, NULL);
1659 mbedtls_ssl_set_timer_cb(&m_env->ssl, &m_env->timer,
1660 mbedtls_timing_set_delay,
1661 mbedtls_timing_get_delay);
1663 mbedtls_ssl_conf_dbg(&m_env->conf, mbedtls_debug_out, stdout);
1668 mbedtls_free(m_env);
1675#if defined(MBEDTLS_SSL_PROTO_DTLS)
1678 static int reported = 0;
1682 " - update Mbed TLS to include DTLS\n");
1690#if !COAP_DISABLE_TCP
1735 coap_mbedtls_context_t *m_context;
1738 m_context = (coap_mbedtls_context_t *)mbedtls_malloc(
sizeof(coap_mbedtls_context_t));
1740 memset(m_context, 0,
sizeof(coap_mbedtls_context_t));
1745#if COAP_SERVER_SUPPORT
1754 coap_mbedtls_context_t *m_context =
1757#if !defined(MBEDTLS_SSL_SRV_C)
1759 " libcoap not compiled for Server Mode for Mbed TLS"
1760 " - update Mbed TLS to include Server Mode\n");
1763 if (!m_context || !setup_data)
1766 m_context->psk_pki_enabled |= IS_PSK;
1771#if COAP_CLIENT_SUPPORT
1780#if !defined(MBEDTLS_SSL_CLI_C)
1785 " libcoap not compiled for Client Mode for Mbed TLS"
1786 " - update Mbed TLS to include Client Mode\n");
1789 coap_mbedtls_context_t *m_context =
1792 if (!m_context || !setup_data)
1796 coap_log_warn(
"CoAP Client with Mbed TLS does not support Identity Hint selection\n");
1798 m_context->psk_pki_enabled |= IS_PSK;
1808 coap_mbedtls_context_t *m_context =
1811 m_context->setup_data = *setup_data;
1812 if (!m_context->setup_data.verify_peer_cert) {
1814 m_context->setup_data.check_common_ca = 0;
1816 m_context->setup_data.allow_self_signed = 1;
1817 m_context->setup_data.allow_expired_certs = 1;
1818 m_context->setup_data.cert_chain_validation = 1;
1819 m_context->setup_data.cert_chain_verify_depth = 10;
1820 m_context->setup_data.check_cert_revocation = 1;
1821 m_context->setup_data.allow_no_crl = 1;
1822 m_context->setup_data.allow_expired_crl = 1;
1823 m_context->setup_data.allow_bad_md_hash = 1;
1824 m_context->setup_data.allow_short_rsa_length = 1;
1826 m_context->psk_pki_enabled |= IS_PKI;
1832 const char *ca_file,
1833 const char *ca_path) {
1834 coap_mbedtls_context_t *m_context =
1838 coap_log_warn(
"coap_context_set_pki_root_cas: (D)TLS environment "
1843 if (ca_file == NULL && ca_path == NULL) {
1844 coap_log_warn(
"coap_context_set_pki_root_cas: ca_file and/or ca_path "
1848 if (m_context->root_ca_file) {
1849 mbedtls_free(m_context->root_ca_file);
1850 m_context->root_ca_file = NULL;
1854 m_context->root_ca_file = mbedtls_strdup(ca_file);
1857 if (m_context->root_ca_path) {
1858 mbedtls_free(m_context->root_ca_path);
1859 m_context->root_ca_path = NULL;
1863 m_context->root_ca_path = mbedtls_strdup(ca_path);
1870 coap_mbedtls_context_t *m_context =
1872 return m_context->psk_pki_enabled ? 1 : 0;
1877 coap_mbedtls_context_t *m_context = (coap_mbedtls_context_t *)dtls_context;
1880 for (i = 0; i < m_context->pki_sni_count; i++) {
1881 mbedtls_free(m_context->pki_sni_entry_list[i].sni);
1883 mbedtls_x509_crt_free(&m_context->pki_sni_entry_list[i].public_cert);
1885 mbedtls_pk_free(&m_context->pki_sni_entry_list[i].private_key);
1887 mbedtls_x509_crt_free(&m_context->pki_sni_entry_list[i].cacert);
1889 if (m_context->pki_sni_entry_list)
1890 mbedtls_free(m_context->pki_sni_entry_list);
1892 for (i = 0; i < m_context->psk_sni_count; i++) {
1893 mbedtls_free(m_context->psk_sni_entry_list[i].sni);
1895 if (m_context->psk_sni_entry_list)
1896 mbedtls_free(m_context->psk_sni_entry_list);
1898 if (m_context->root_ca_path)
1899 mbedtls_free(m_context->root_ca_path);
1900 if (m_context->root_ca_file)
1901 mbedtls_free(m_context->root_ca_file);
1903 mbedtls_free(m_context);
1906#if COAP_CLIENT_SUPPORT
1909#if !defined(MBEDTLS_SSL_CLI_C)
1912 " libcoap not compiled for Client Mode for Mbed TLS"
1913 " - update Mbed TLS to include Client Mode\n");
1916 coap_mbedtls_env_t *m_env = coap_dtls_new_mbedtls_env(c_session,
1923#ifdef MBEDTLS_SSL_DTLS_CONNECTION_ID
1932 mbedtls_ssl_set_cid(&m_env->ssl, MBEDTLS_SSL_CID_ENABLED, NULL, 0);
1936 m_env->last_timeout = now;
1937 ret = do_mbedtls_handshake(c_session, m_env);
1939 coap_dtls_free_mbedtls_env(m_env);
1948#if COAP_SERVER_SUPPORT
1951#if !defined(MBEDTLS_SSL_SRV_C)
1954 " libcoap not compiled for Server Mode for Mbed TLS"
1955 " - update Mbed TLS to include Server Mode\n");
1958 coap_mbedtls_env_t *m_env =
1959 (coap_mbedtls_env_t *)c_session->
tls;
1961#if defined(MBEDTLS_SSL_PROTO_DTLS)
1962#if MBEDTLS_VERSION_NUMBER >= 0x02100100
1963 mbedtls_ssl_set_mtu(&m_env->ssl, (uint16_t)c_session->
mtu);
1974 if (c_session && c_session->
context && c_session->
tls) {
1975 coap_dtls_free_mbedtls_env(c_session->
tls);
1976 c_session->
tls = NULL;
1984#if defined(MBEDTLS_SSL_PROTO_DTLS)
1985 coap_mbedtls_env_t *m_env =
1986 (coap_mbedtls_env_t *)c_session->
tls;
1988#if MBEDTLS_VERSION_NUMBER >= 0x02100100
1989 mbedtls_ssl_set_mtu(&m_env->ssl, (uint16_t)c_session->
mtu);
1999 const uint8_t *data,
size_t data_len) {
2001 coap_mbedtls_env_t *m_env = (coap_mbedtls_env_t *)c_session->
tls;
2003 assert(m_env != NULL);
2009 if (m_env->established) {
2010 ret = mbedtls_ssl_write(&m_env->ssl, (
const unsigned char *) data, data_len);
2013 case MBEDTLS_ERR_SSL_WANT_READ:
2014 case MBEDTLS_ERR_SSL_WANT_WRITE:
2017 case MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE:
2023 "returned -0x%x: '%s'\n",
2024 -ret, get_error_string(ret));
2033 ret = do_mbedtls_handshake(c_session, m_env);
2052 if (ret == (ssize_t)data_len)
2074 coap_mbedtls_env_t *m_env = (coap_mbedtls_env_t *)c_session->
tls;
2075 int ret = mbedtls_timing_get_delay(&m_env->timer);
2076 unsigned int scalar = 1 << m_env->retry_scalar;
2086 m_env->last_timeout = now;
2099 m_env->last_timeout = now;
2117 coap_mbedtls_env_t *m_env = (coap_mbedtls_env_t *)c_session->
tls;
2120 m_env->retry_scalar++;
2122 (do_mbedtls_handshake(c_session, m_env) < 0)) {
2137 const uint8_t *data,
2142 coap_mbedtls_env_t *m_env = (coap_mbedtls_env_t *)c_session->
tls;
2143 coap_ssl_t *ssl_data;
2145 assert(m_env != NULL);
2147 ssl_data = &m_env->coap_ssl_data;
2148 if (ssl_data->pdu_len) {
2149 coap_log_err(
"** %s: Previous data not read %u bytes\n",
2152 ssl_data->pdu = data;
2153 ssl_data->pdu_len = (unsigned)data_len;
2155 if (m_env->established) {
2156#if COAP_CONSTRAINED_STACK
2163#if COAP_CONSTRAINED_STACK
2173 ret = mbedtls_ssl_read(&m_env->ssl, pdu,
sizeof(pdu));
2176#if COAP_CONSTRAINED_STACK
2183 case MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY:
2184 case MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE:
2187 case MBEDTLS_ERR_SSL_WANT_READ:
2191 "returned -0x%x: '%s' (length %zd)\n",
2192 -ret, get_error_string(ret), data_len);
2195#if COAP_CONSTRAINED_STACK
2200 ret = do_mbedtls_handshake(c_session, m_env);
2205 if (ssl_data->pdu_len) {
2207 ret = do_mbedtls_handshake(c_session, m_env);
2228 if (ssl_data && ssl_data->pdu_len) {
2230 coap_log_debug(
"coap_dtls_receive: ret %d: remaining data %u\n", ret, ssl_data->pdu_len);
2231 ssl_data->pdu_len = 0;
2232 ssl_data->pdu = NULL;
2241#if COAP_SERVER_SUPPORT
2249 const uint8_t *data,
2251#if !defined(MBEDTLS_SSL_PROTO_DTLS) || !defined(MBEDTLS_SSL_SRV_C)
2256 " libcoap not compiled for DTLS or Server Mode for Mbed TLS"
2257 " - update Mbed TLS to include DTLS and Server Mode\n");
2260 coap_mbedtls_env_t *m_env = (coap_mbedtls_env_t *)c_session->
tls;
2261 coap_ssl_t *ssl_data;
2268 c_session->
tls = m_env;
2275 if ((ret = mbedtls_ssl_set_client_transport_id(&m_env->ssl,
2278 coap_log_err(
"mbedtls_ssl_set_client_transport_id() returned -0x%x: '%s'\n",
2279 -ret, get_error_string(ret));
2283 ssl_data = &m_env->coap_ssl_data;
2284 if (ssl_data->pdu_len) {
2285 coap_log_err(
"** %s: Previous data not read %u bytes\n",
2288 ssl_data->pdu = data;
2289 ssl_data->pdu_len = (unsigned)data_len;
2291 ret = do_mbedtls_handshake(c_session, m_env);
2292 if (ret == 0 || m_env->seen_client_hello) {
2298 m_env->seen_client_hello = 0;
2304 if (ssl_data->pdu_len) {
2306 coap_log_debug(
"coap_dtls_hello: ret %d: remaining data %u\n", ret, ssl_data->pdu_len);
2307 ssl_data->pdu_len = 0;
2308 ssl_data->pdu = NULL;
2317 coap_mbedtls_env_t *m_env = (coap_mbedtls_env_t *)c_session->
tls;
2318 int expansion = mbedtls_ssl_get_record_expansion(&m_env->ssl);
2320 if (expansion == MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE) {
2326#if !COAP_DISABLE_TCP
2327#if COAP_CLIENT_SUPPORT
2330#if !defined(MBEDTLS_SSL_CLI_C)
2334 " libcoap not compiled for Client Mode for Mbed TLS"
2335 " - update Mbed TLS to include Client Mode\n");
2338 coap_mbedtls_env_t *m_env = coap_dtls_new_mbedtls_env(c_session,
2348 m_env->last_timeout = now;
2349 c_session->
tls = m_env;
2350 ret = do_mbedtls_handshake(c_session, m_env);
2360#if COAP_SERVER_SUPPORT
2363#if !defined(MBEDTLS_SSL_SRV_C)
2368 " libcoap not compiled for Server Mode for Mbed TLS"
2369 " - update Mbed TLS to include Server Mode\n");
2372 coap_mbedtls_env_t *m_env = coap_dtls_new_mbedtls_env(c_session,
2380 c_session->
tls = m_env;
2381 ret = do_mbedtls_handshake(c_session, m_env);
2406 coap_mbedtls_env_t *m_env = (coap_mbedtls_env_t *)c_session->
tls;
2407 size_t amount_sent = 0;
2409 assert(m_env != NULL);
2416 if (m_env->established) {
2417 while (amount_sent < data_len) {
2418 ret = mbedtls_ssl_write(&m_env->ssl, &data[amount_sent],
2419 data_len - amount_sent);
2422 case MBEDTLS_ERR_SSL_WANT_READ:
2423 case MBEDTLS_ERR_SSL_WANT_WRITE:
2430 case MBEDTLS_ERR_NET_CONN_RESET:
2431 case MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE:
2436 "returned -0x%x: '%s'\n",
2437 -ret, get_error_string(ret));
2449 ret = do_mbedtls_handshake(c_session, m_env);
2470 if (ret == (ssize_t)data_len)
2489 coap_mbedtls_env_t *m_env = (coap_mbedtls_env_t *)c_session->
tls;
2498 if (!m_env->established && !m_env->sent_alert) {
2499 ret = do_mbedtls_handshake(c_session, m_env);
2508 ret = mbedtls_ssl_read(&m_env->ssl, data, data_len);
2512 case MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY:
2516 case MBEDTLS_ERR_SSL_FATAL_ALERT_MESSAGE:
2518 m_env->sent_alert = 1;
2521 case MBEDTLS_ERR_SSL_WANT_READ:
2527 "returned -0x%x: '%s' (length %zd)\n",
2528 -ret, get_error_string(ret), data_len);
2532 }
else if (ret < (
int)data_len) {
2533 c_session->
sock.
flags &= ~COAP_SOCKET_CAN_READ;
2561#if COAP_CLIENT_SUPPORT
2562 mbedtls_free(psk_ciphers);
2563 mbedtls_free(pki_ciphers);
2566 processed_ciphers = 0;
2576 if (c_session && c_session->
tls) {
2577 coap_mbedtls_env_t *m_env;
2580 memcpy(&m_env, &c_session->
tls,
sizeof(m_env));
2582 return (
void *)&m_env->ssl;
2591#if !defined(ESPIDF_VERSION)
2601 switch ((
int)level) {
2622 mbedtls_debug_set_threshold(use_level);
2624 keep_log_level = level;
2629 return keep_log_level;
2635 version.
version = mbedtls_version_get_number();
2641#if COAP_SERVER_SUPPORT
2644 mbedtls_sha256_context *digest_ctx = mbedtls_malloc(
sizeof(mbedtls_sha256_context));
2647 mbedtls_sha256_init(digest_ctx);
2648#ifdef MBEDTLS_2_X_COMPAT
2649 if (mbedtls_sha256_starts_ret(digest_ctx, 0) != 0) {
2651 if (mbedtls_sha256_starts(digest_ctx, 0) != 0) {
2662 mbedtls_sha256_free(digest_ctx);
2663 mbedtls_free(digest_ctx);
2668 const uint8_t *data,
2670#ifdef MBEDTLS_2_X_COMPAT
2671 int ret = mbedtls_sha256_update_ret(digest_ctx, data, data_len);
2673 int ret = mbedtls_sha256_update(digest_ctx, data, data_len);
2682#ifdef MBEDTLS_2_X_COMPAT
2683 int ret = mbedtls_sha256_finish_ret(digest_ctx, (uint8_t *)digest_buffer);
2685 int ret = mbedtls_sha256_finish(digest_ctx, (uint8_t *)digest_buffer);
2693#include <mbedtls/cipher.h>
2694#include <mbedtls/md.h>
2696#ifndef MBEDTLS_CIPHER_MODE_AEAD
2697#error need MBEDTLS_CIPHER_MODE_AEAD, please enable MBEDTLS_CCM_C
2700#ifdef MBEDTLS_ERROR_C
2701#include <mbedtls/error.h>
2704#ifdef MBEDTLS_ERROR_C
2707 int c_tmp = (int)(Func); \
2709 char error_buf[64]; \
2710 mbedtls_strerror(c_tmp, error_buf, sizeof(error_buf)); \
2711 coap_log_err("mbedtls: -0x%04x: %s\n", -c_tmp, error_buf); \
2718 int c_tmp = (int)(Func); \
2720 coap_log_err("mbedtls: %d\n", tmp); \
2731static struct hash_algs {
2733 mbedtls_md_type_t hash_type;
2741static mbedtls_md_type_t
2742get_hash_alg(
cose_alg_t alg,
size_t *hash_len) {
2745 for (idx = 0; idx <
sizeof(hashs) /
sizeof(
struct hash_algs); idx++) {
2746 if (hashs[idx].alg == alg) {
2747 *hash_len = hashs[idx].hash_size;
2748 return hashs[idx].hash_type;
2751 coap_log_debug(
"get_hash_alg: COSE hash %d not supported\n", alg);
2752 return MBEDTLS_MD_NONE;
2759 mbedtls_md_context_t ctx;
2761 const mbedtls_md_info_t *md_info;
2765 mbedtls_md_type_t dig_type = get_hash_alg(alg, &hash_length);
2767 if (dig_type == MBEDTLS_MD_NONE) {
2768 coap_log_debug(
"coap_crypto_hash: algorithm %d not supported\n", alg);
2771 md_info = mbedtls_md_info_from_type(dig_type);
2773 len = mbedtls_md_get_size(md_info);
2778 mbedtls_md_init(&ctx);
2779 C(mbedtls_md_setup(&ctx, md_info, 0));
2781 C(mbedtls_md_starts(&ctx));
2782 C(mbedtls_md_update(&ctx, (
const unsigned char *)data->
s, data->
length));
2786 C(mbedtls_md_finish(&ctx,
dummy->s));
2791 mbedtls_md_free(&ctx);
2796#if COAP_OSCORE_SUPPORT
2807static struct cipher_algs {
2809 mbedtls_cipher_type_t cipher_type;
2814static mbedtls_cipher_type_t
2818 for (idx = 0; idx <
sizeof(ciphers) /
sizeof(
struct cipher_algs); idx++) {
2819 if (ciphers[idx].alg == alg)
2820 return ciphers[idx].cipher_type;
2822 coap_log_debug(
"get_cipher_alg: COSE cipher %d not supported\n", alg);
2831static struct hmac_algs {
2833 mbedtls_md_type_t hmac_type;
2840static mbedtls_md_type_t
2844 for (idx = 0; idx <
sizeof(hmacs) /
sizeof(
struct hmac_algs); idx++) {
2845 if (hmacs[idx].hmac_alg == hmac_alg)
2846 return hmacs[idx].hmac_type;
2848 coap_log_debug(
"get_hmac_alg: COSE HMAC %d not supported\n", hmac_alg);
2854 return get_cipher_alg(alg) != 0;
2863 return get_hmac_alg(hmac_alg) != 0;
2871setup_cipher_context(mbedtls_cipher_context_t *ctx,
2873 const uint8_t *key_data,
2875 mbedtls_operation_t mode) {
2876 const mbedtls_cipher_info_t *cipher_info;
2877 mbedtls_cipher_type_t cipher_type;
2881 memset(key, 0,
sizeof(key));
2883 if ((cipher_type = get_cipher_alg(coap_alg)) == 0) {
2884 coap_log_debug(
"coap_crypto_encrypt: algorithm %d not supported\n",
2888 cipher_info = mbedtls_cipher_info_from_type(cipher_type);
2890 coap_log_crit(
"coap_crypto_encrypt: cannot get cipher info\n");
2894 mbedtls_cipher_init(ctx);
2896 C(mbedtls_cipher_setup(ctx, cipher_info));
2897 klen = mbedtls_cipher_get_key_bitlen(ctx);
2898 if ((klen > (
int)(
sizeof(key) * 8)) || (key_length >
sizeof(key))) {
2902 memcpy(key, key_data, key_length);
2903 C(mbedtls_cipher_setkey(ctx, key, klen, mode));
2908 mbedtls_cipher_free(ctx);
2917 size_t *max_result_len) {
2918 mbedtls_cipher_context_t ctx;
2920#if (MBEDTLS_VERSION_NUMBER < 0x02150000)
2921 unsigned char tag[16];
2924 size_t result_len = *max_result_len;
2930 assert(params != NULL);
2937 if (!setup_cipher_context(&ctx,
2952#if (MBEDTLS_VERSION_NUMBER < 0x02150000)
2953 C(mbedtls_cipher_auth_encrypt(&ctx,
2966 if ((result_len + ccm->
tag_len) > *max_result_len) {
2971 memcpy(result + result_len, tag, ccm->
tag_len);
2972 *max_result_len = result_len + ccm->
tag_len;
2975 C(mbedtls_cipher_auth_encrypt_ext(&ctx,
2987 *max_result_len = result_len;
2992 mbedtls_cipher_free(&ctx);
3001 size_t *max_result_len) {
3002 mbedtls_cipher_context_t ctx;
3004#if (MBEDTLS_VERSION_NUMBER < 0x02150000)
3005 const unsigned char *tag;
3008 size_t result_len = *max_result_len;
3014 assert(params != NULL);
3022 if (!setup_cipher_context(&ctx,
3042#if (MBEDTLS_VERSION_NUMBER < 0x02150000)
3044 C(mbedtls_cipher_auth_decrypt(&ctx,
3057 C(mbedtls_cipher_auth_decrypt_ext(&ctx,
3072 *max_result_len = result_len;
3075 mbedtls_cipher_free(&ctx);
3084 mbedtls_md_context_t ctx;
3086 const int use_hmac = 1;
3087 const mbedtls_md_info_t *md_info;
3088 mbedtls_md_type_t mac_algo;
3096 if ((mac_algo = get_hmac_alg(hmac_alg)) == 0) {
3097 coap_log_debug(
"coap_crypto_hmac: algorithm %d not supported\n", hmac_alg);
3100 md_info = mbedtls_md_info_from_type(mac_algo);
3102 len = mbedtls_md_get_size(md_info);
3107 mbedtls_md_init(&ctx);
3108 C(mbedtls_md_setup(&ctx, md_info, use_hmac));
3110 C(mbedtls_md_hmac_starts(&ctx, key->
s, key->
length));
3111 C(mbedtls_md_hmac_update(&ctx, (
const unsigned char *)data->
s, data->
length));
3115 C(mbedtls_md_hmac_finish(&ctx,
dummy->s));
3120 mbedtls_md_free(&ctx);
3132#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.
#define coap_mutex_unlock(a)
#define coap_mutex_lock(a)
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_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(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 *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_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.
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_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_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_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
int coap_oscore_is_supported(void)
Check whether OSCORE is available.
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_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_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.
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.
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.
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.
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 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 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.
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_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)
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_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