20#ifdef COAP_WITH_LIBOPENSSL
69#include <openssl/ssl.h>
70#include <openssl/engine.h>
71#include <openssl/err.h>
72#include <openssl/rand.h>
73#include <openssl/hmac.h>
74#include <openssl/x509v3.h>
76#if OPENSSL_VERSION_NUMBER >= 0x30000000L
79#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
82#if !defined(__MINGW32__)
83#pragma warning(disable : 4996)
88#ifdef COAP_EPOLL_SUPPORT
89# include <sys/epoll.h>
92#if OPENSSL_VERSION_NUMBER < 0x10100000L
93#error Must be compiled against OpenSSL 1.1.0 or later
97#define strcasecmp _stricmp
98#define strncasecmp _strnicmp
102#ifndef TLSEXT_TYPE_client_certificate_type
103#define TLSEXT_TYPE_client_certificate_type 19
105#ifndef TLSEXT_TYPE_server_certificate_type
106#define TLSEXT_TYPE_server_certificate_type 20
109#ifndef COAP_OPENSSL_CIPHERS
110#if OPENSSL_VERSION_NUMBER >= 0x10101000L
111#define COAP_OPENSSL_CIPHERS "TLSv1.3:TLSv1.2:!NULL"
113#define COAP_OPENSSL_CIPHERS "TLSv1.2:!NULL"
117#ifndef COAP_OPENSSL_PSK_CIPHERS
118#define COAP_OPENSSL_PSK_CIPHERS "PSK:!NULL"
121#ifndef COAP_OPENSSL_PKCS11_ENGINE_ID
122#define COAP_OPENSSL_PKCS11_ENGINE_ID "pkcs11"
126typedef struct coap_dtls_context_t {
129 HMAC_CTX *cookie_hmac;
132} coap_dtls_context_t;
134typedef struct coap_tls_context_t {
142typedef struct sni_entry {
144#if OPENSSL_VERSION_NUMBER < 0x10101000L
151typedef struct psk_sni_entry {
153#if OPENSSL_VERSION_NUMBER < 0x10101000L
159typedef struct coap_openssl_context_t {
160 coap_dtls_context_t dtls;
162 coap_tls_context_t tls;
167 sni_entry *sni_entry_list;
168 size_t psk_sni_count;
169 psk_sni_entry *psk_sni_entry_list;
170} coap_openssl_context_t;
172#if COAP_SERVER_SUPPORT
173#if OPENSSL_VERSION_NUMBER < 0x10101000L
174static int psk_tls_server_name_call_back(SSL *ssl,
int *sd,
void *arg);
176static int psk_tls_client_hello_call_back(SSL *ssl,
int *al,
void *arg);
182 if (SSLeay() < 0x10100000L) {
183 coap_log_warn(
"OpenSSL version 1.1.0 or later is required\n");
186#if OPENSSL_VERSION_NUMBER >= 0x10101000L
194 if (SSLeay() < 0x10101000L) {
195 coap_log_warn(
"OpenSSL version 1.1.1 or later is required\n");
205 if (SSLeay() < 0x10100000L) {
206 coap_log_warn(
"OpenSSL version 1.1.0 or later is required\n");
209#if OPENSSL_VERSION_NUMBER >= 0x10101000L
210 if (SSLeay() < 0x10101000L) {
211 coap_log_warn(
"OpenSSL version 1.1.1 or later is required\n");
266static ENGINE *ssl_engine = NULL;
270 SSL_load_error_strings();
272 ENGINE_load_dynamic();
279 ENGINE_finish(ssl_engine);
281 ENGINE_free(ssl_engine);
294 return c_session->
tls;
314typedef struct coap_ssl_st {
323coap_dgram_create(BIO *a) {
324 coap_ssl_data *data = NULL;
325 data = malloc(
sizeof(coap_ssl_data));
329 BIO_set_data(a, data);
330 memset(data, 0x00,
sizeof(coap_ssl_data));
335coap_dgram_destroy(BIO *a) {
339 data = (coap_ssl_data *)BIO_get_data(a);
346coap_dgram_read(BIO *a,
char *out,
int outl) {
348 coap_ssl_data *data = (coap_ssl_data *)BIO_get_data(a);
351 if (data != NULL && data->pdu_len > 0) {
352 if (outl < (
int)data->pdu_len) {
353 memcpy(out, data->pdu, outl);
356 memcpy(out, data->pdu, data->pdu_len);
357 ret = (int)data->pdu_len;
359 if (!data->peekmode) {
366 BIO_clear_retry_flags(a);
368 BIO_set_retry_read(a);
374coap_dgram_write(BIO *a,
const char *in,
int inl) {
376 coap_ssl_data *data = (coap_ssl_data *)BIO_get_data(a);
380#if COAP_SERVER_SUPPORT
381 && data->session->endpoint == NULL
385 BIO_clear_retry_flags(a);
389 ret = (int)data->session->sock.lfunc[
COAP_LAYER_TLS].l_write(data->session,
392 BIO_clear_retry_flags(a);
394 BIO_set_retry_write(a);
396 BIO_clear_retry_flags(a);
403coap_dgram_puts(BIO *a,
const char *pstr) {
404 return coap_dgram_write(a, pstr, (
int)strlen(pstr));
408coap_dgram_ctrl(BIO *a,
int cmd,
long num,
void *ptr) {
410 coap_ssl_data *data = BIO_get_data(a);
415 case BIO_CTRL_GET_CLOSE:
416 ret = BIO_get_shutdown(a);
418 case BIO_CTRL_SET_CLOSE:
419 BIO_set_shutdown(a, (
int)num);
422 case BIO_CTRL_DGRAM_SET_PEEK_MODE:
423 data->peekmode = (unsigned)num;
425 case BIO_CTRL_DGRAM_CONNECT:
428 case BIO_CTRL_DGRAM_SET_DONT_FRAG:
429 case BIO_CTRL_DGRAM_GET_MTU:
430 case BIO_CTRL_DGRAM_SET_MTU:
431 case BIO_CTRL_DGRAM_QUERY_MTU:
432 case BIO_CTRL_DGRAM_GET_FALLBACK_MTU:
437 case BIO_CTRL_DGRAM_MTU_DISCOVER:
438 case BIO_CTRL_DGRAM_SET_CONNECTED:
441 case BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT:
443 struct timeval *)ptr)->tv_usec);
447 case BIO_C_FILE_SEEK:
448 case BIO_C_FILE_TELL:
450 case BIO_CTRL_PENDING:
451 case BIO_CTRL_WPENDING:
452 case BIO_CTRL_DGRAM_GET_PEER:
453 case BIO_CTRL_DGRAM_SET_PEER:
454 case BIO_CTRL_DGRAM_SET_RECV_TIMEOUT:
455 case BIO_CTRL_DGRAM_GET_RECV_TIMEOUT:
456 case BIO_CTRL_DGRAM_SET_SEND_TIMEOUT:
457 case BIO_CTRL_DGRAM_GET_SEND_TIMEOUT:
458 case BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP:
459 case BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP:
460 case BIO_CTRL_DGRAM_MTU_EXCEEDED:
461 case BIO_CTRL_DGRAM_GET_MTU_OVERHEAD:
470coap_dtls_generate_cookie(SSL *ssl,
471 unsigned char *cookie,
472 unsigned int *cookie_len) {
473 coap_dtls_context_t *dtls =
474 (coap_dtls_context_t *)SSL_CTX_get_app_data(SSL_get_SSL_CTX(ssl));
475 coap_ssl_data *data = (coap_ssl_data *)BIO_get_data(SSL_get_rbio(ssl));
476 int r = HMAC_Init_ex(dtls->cookie_hmac, NULL, 0, NULL, NULL);
477 r &= HMAC_Update(dtls->cookie_hmac,
478 (
const uint8_t *)&data->session->addr_info.local.addr,
479 (
size_t)data->session->addr_info.local.size);
480 r &= HMAC_Update(dtls->cookie_hmac,
481 (
const uint8_t *)&data->session->addr_info.remote.addr,
482 (
size_t)data->session->addr_info.remote.size);
483 r &= HMAC_Final(dtls->cookie_hmac, cookie, cookie_len);
488coap_dtls_verify_cookie(SSL *ssl,
489 const uint8_t *cookie,
490 unsigned int cookie_len) {
493 if (coap_dtls_generate_cookie(ssl, hmac, &len) &&
494 cookie_len == len && memcmp(cookie, hmac, len) == 0)
500#if COAP_CLIENT_SUPPORT
502coap_dtls_psk_client_callback(SSL *ssl,
505 unsigned int max_identity_len,
507 unsigned int max_psk_len) {
509 coap_openssl_context_t *o_context;
517 if (c_session == NULL)
520 if (o_context == NULL)
524 temp.
s = hint ? (
const uint8_t *)hint : (const uint8_t *)
"";
525 temp.
length = strlen((
const char *)temp.
s);
529 (
const char *)temp.
s);
541 if (cpsk_info == NULL)
546 psk_identity = &cpsk_info->
identity;
547 psk_key = &cpsk_info->
key;
553 if (psk_identity == NULL || psk_key == NULL) {
559 if (!max_identity_len)
562 if (psk_identity->
length > max_identity_len) {
563 coap_log_warn(
"psk_identity too large, truncated to %d bytes\n",
567 max_identity_len = (
unsigned int)psk_identity->
length;
569 memcpy(identity, psk_identity->
s, max_identity_len);
570 identity[max_identity_len] =
'\000';
572 if (psk_key->
length > max_psk_len) {
577 max_psk_len = (
unsigned int)psk_key->
length;
579 memcpy(psk, psk_key->
s, max_psk_len);
584#if COAP_SERVER_SUPPORT
586coap_dtls_psk_server_callback(
588 const char *identity,
590 unsigned int max_psk_len
598 if (c_session == NULL)
604 lidentity.
s = identity ? (
const uint8_t *)identity : (const uint8_t *)
"";
605 lidentity.
length = strlen((
const char *)lidentity.
s);
609 (
int)lidentity.
length, (
const char *)lidentity.
s);
624 if (psk_key->
length > max_psk_len) {
629 max_psk_len = (
unsigned int)psk_key->
length;
631 memcpy(psk, psk_key->
s, max_psk_len);
637ssl_function_definition(
unsigned long e) {
638#if OPENSSL_VERSION_NUMBER >= 0x30000000L
642 static char buff[80];
644 snprintf(buff,
sizeof(buff),
" at %s:%s",
645 ERR_lib_error_string(e), ERR_func_error_string(e));
651coap_dtls_info_callback(
const SSL *ssl,
int where,
int ret) {
654 int w = where &~SSL_ST_MASK;
656 if (w & SSL_ST_CONNECT)
657 pstr =
"SSL_connect";
658 else if (w & SSL_ST_ACCEPT)
663 if (where & SSL_CB_LOOP) {
666 }
else if (where & SSL_CB_ALERT) {
668 pstr = (where & SSL_CB_READ) ?
"read" :
"write";
669 if ((where & (SSL_CB_WRITE|SSL_CB_READ)) && (ret >> 8) == SSL3_AL_FATAL) {
671 if ((ret & 0xff) != SSL3_AD_CLOSE_NOTIFY)
675 coap_log(log_level,
"* %s: SSL3 alert %s:%s:%s\n",
678 SSL_alert_type_string_long(ret),
679 SSL_alert_desc_string_long(ret));
680 }
else if (where & SSL_CB_EXIT) {
686 while ((e = ERR_get_error()))
689 ssl_function_definition(e));
691 }
else if (ret < 0) {
693 int err = SSL_get_error(ssl, ret);
694 if (err != SSL_ERROR_WANT_READ && err != SSL_ERROR_WANT_WRITE &&
695 err != SSL_ERROR_WANT_CONNECT && err != SSL_ERROR_WANT_ACCEPT &&
696 err != SSL_ERROR_WANT_X509_LOOKUP) {
700 while ((e = ERR_get_error()))
703 ssl_function_definition(e));
709 if (where == SSL_CB_HANDSHAKE_START && SSL_get_state(ssl) == TLS_ST_OK)
715coap_sock_create(BIO *a) {
721coap_sock_destroy(BIO *a) {
733coap_sock_read(BIO *a,
char *out,
int outl) {
742 BIO_set_retry_read(a);
745 BIO_clear_retry_flags(a);
758coap_sock_write(BIO *a,
const char *in,
int inl) {
766 BIO_clear_retry_flags(a);
768 BIO_set_retry_read(a);
771 BIO_clear_retry_flags(a);
775 (errno == EPIPE || errno == ECONNRESET)) {
795coap_sock_puts(BIO *a,
const char *pstr) {
796 return coap_sock_write(a, pstr, (
int)strlen(pstr));
800coap_sock_ctrl(BIO *a,
int cmd,
long num,
void *ptr) {
811 case BIO_CTRL_SET_CLOSE:
817 case BIO_CTRL_GET_CLOSE:
826coap_set_user_prefs(SSL_CTX *ctx) {
827 SSL_CTX_set_cipher_list(ctx, COAP_OPENSSL_CIPHERS);
829#ifdef COAP_OPENSSL_SIGALGS
830 SSL_CTX_set1_sigalgs_list(ctx, COAP_OPENSSL_SIGALGS);
831 SSL_CTX_set1_client_sigalgs_list(ctx, COAP_OPENSSL_SIGALGS);
834#if OPENSSL_VERSION_NUMBER >= 0x10101000L && defined(COAP_OPENSSL_GROUPS)
835 SSL_CTX_set1_groups_list(ctx, COAP_OPENSSL_GROUPS);
841 coap_openssl_context_t *context;
846 uint8_t cookie_secret[32];
848 memset(context, 0,
sizeof(coap_openssl_context_t));
851 context->dtls.ctx = SSL_CTX_new(DTLS_method());
852 if (!context->dtls.ctx)
854 SSL_CTX_set_min_proto_version(context->dtls.ctx, DTLS1_2_VERSION);
855 SSL_CTX_set_app_data(context->dtls.ctx, &context->dtls);
856 SSL_CTX_set_read_ahead(context->dtls.ctx, 1);
857 coap_set_user_prefs(context->dtls.ctx);
858 memset(cookie_secret, 0,
sizeof(cookie_secret));
859 if (!RAND_bytes(cookie_secret, (
int)
sizeof(cookie_secret))) {
861 "Insufficient entropy for random cookie generation");
862 coap_prng(cookie_secret,
sizeof(cookie_secret));
864 context->dtls.cookie_hmac = HMAC_CTX_new();
865 if (!HMAC_Init_ex(context->dtls.cookie_hmac, cookie_secret, (
int)
sizeof(cookie_secret),
868 SSL_CTX_set_cookie_generate_cb(context->dtls.ctx, coap_dtls_generate_cookie);
869 SSL_CTX_set_cookie_verify_cb(context->dtls.ctx, coap_dtls_verify_cookie);
870 SSL_CTX_set_info_callback(context->dtls.ctx, coap_dtls_info_callback);
871 SSL_CTX_set_options(context->dtls.ctx, SSL_OP_NO_QUERY_MTU);
872#if OPENSSL_VERSION_NUMBER >= 0x30000000L
873 SSL_CTX_set_options(context->dtls.ctx, SSL_OP_LEGACY_SERVER_CONNECT);
875 context->dtls.meth = BIO_meth_new(BIO_TYPE_DGRAM,
"coapdgram");
876 if (!context->dtls.meth)
878 context->dtls.bio_addr = BIO_ADDR_new();
879 if (!context->dtls.bio_addr)
881 BIO_meth_set_write(context->dtls.meth, coap_dgram_write);
882 BIO_meth_set_read(context->dtls.meth, coap_dgram_read);
883 BIO_meth_set_puts(context->dtls.meth, coap_dgram_puts);
884 BIO_meth_set_ctrl(context->dtls.meth, coap_dgram_ctrl);
885 BIO_meth_set_create(context->dtls.meth, coap_dgram_create);
886 BIO_meth_set_destroy(context->dtls.meth, coap_dgram_destroy);
890 context->tls.ctx = SSL_CTX_new(TLS_method());
891 if (!context->tls.ctx)
893 SSL_CTX_set_app_data(context->tls.ctx, &context->tls);
894 SSL_CTX_set_min_proto_version(context->tls.ctx, TLS1_VERSION);
895 coap_set_user_prefs(context->tls.ctx);
896 SSL_CTX_set_info_callback(context->tls.ctx, coap_dtls_info_callback);
897 context->tls.meth = BIO_meth_new(BIO_TYPE_SOCKET,
"coapsock");
898 if (!context->tls.meth)
900 BIO_meth_set_write(context->tls.meth, coap_sock_write);
901 BIO_meth_set_read(context->tls.meth, coap_sock_read);
902 BIO_meth_set_puts(context->tls.meth, coap_sock_puts);
903 BIO_meth_set_ctrl(context->tls.meth, coap_sock_ctrl);
904 BIO_meth_set_create(context->tls.meth, coap_sock_create);
905 BIO_meth_set_destroy(context->tls.meth, coap_sock_destroy);
916#if COAP_SERVER_SUPPORT
921 coap_openssl_context_t *o_context =
925 if (!setup_data || !o_context)
928 SSL_CTX_set_psk_server_callback(o_context->dtls.ctx,
929 coap_dtls_psk_server_callback);
931 SSL_CTX_set_psk_server_callback(o_context->tls.ctx,
932 coap_dtls_psk_server_callback);
938 SSL_CTX_use_psk_identity_hint(o_context->dtls.ctx, hint);
940 SSL_CTX_use_psk_identity_hint(o_context->tls.ctx, hint);
944#if OPENSSL_VERSION_NUMBER < 0x10101000L
945 SSL_CTX_set_tlsext_servername_arg(o_context->dtls.ctx,
947 SSL_CTX_set_tlsext_servername_callback(o_context->dtls.ctx,
948 psk_tls_server_name_call_back);
950 SSL_CTX_set_tlsext_servername_arg(o_context->tls.ctx,
952 SSL_CTX_set_tlsext_servername_callback(o_context->tls.ctx,
953 psk_tls_server_name_call_back);
956 SSL_CTX_set_client_hello_cb(o_context->dtls.ctx,
957 psk_tls_client_hello_call_back,
960 SSL_CTX_set_client_hello_cb(o_context->tls.ctx,
961 psk_tls_client_hello_call_back,
967 if (!o_context->dtls.ssl) {
969 o_context->dtls.ssl = SSL_new(o_context->dtls.ctx);
970 if (!o_context->dtls.ssl)
972 bio = BIO_new(o_context->dtls.meth);
974 SSL_free(o_context->dtls.ssl);
975 o_context->dtls.ssl = NULL;
978 SSL_set_bio(o_context->dtls.ssl, bio, bio);
979 SSL_set_app_data(o_context->dtls.ssl, NULL);
980 SSL_set_options(o_context->dtls.ssl, SSL_OP_COOKIE_EXCHANGE);
983 o_context->psk_pki_enabled |= IS_PSK;
988#if COAP_CLIENT_SUPPORT
993 coap_openssl_context_t *o_context =
997 if (!setup_data || !o_context)
1000 if (!o_context->dtls.ssl) {
1002 o_context->dtls.ssl = SSL_new(o_context->dtls.ctx);
1003 if (!o_context->dtls.ssl)
1005 bio = BIO_new(o_context->dtls.meth);
1007 SSL_free(o_context->dtls.ssl);
1008 o_context->dtls.ssl = NULL;
1011 SSL_set_bio(o_context->dtls.ssl, bio, bio);
1012 SSL_set_app_data(o_context->dtls.ssl, NULL);
1013 SSL_set_options(o_context->dtls.ssl, SSL_OP_COOKIE_EXCHANGE);
1016 o_context->psk_pki_enabled |= IS_PSK;
1022map_key_type(
int asn1_private_key_type
1024 switch (asn1_private_key_type) {
1026 return EVP_PKEY_NONE;
1028 return EVP_PKEY_RSA;
1030 return EVP_PKEY_RSA2;
1032 return EVP_PKEY_DSA;
1034 return EVP_PKEY_DSA1;
1036 return EVP_PKEY_DSA2;
1038 return EVP_PKEY_DSA3;
1040 return EVP_PKEY_DSA4;
1044 return EVP_PKEY_DHX;
1048 return EVP_PKEY_HMAC;
1050 return EVP_PKEY_CMAC;
1052 return EVP_PKEY_TLS1_PRF;
1054 return EVP_PKEY_HKDF;
1056 coap_log_warn(
"*** setup_pki: DTLS: Unknown Private Key type %d for ASN1\n",
1057 asn1_private_key_type);
1062#if !COAP_DISABLE_TCP
1063static uint8_t coap_alpn[] = { 4,
'c',
'o',
'a',
'p' };
1065#if COAP_SERVER_SUPPORT
1068 const unsigned char **out,
1069 unsigned char *outlen,
1070 const unsigned char *in,
1074 unsigned char *tout = NULL;
1077 return SSL_TLSEXT_ERR_NOACK;
1078 ret = SSL_select_next_proto(&tout,
1085 return (ret != OPENSSL_NPN_NEGOTIATED) ? SSL_TLSEXT_ERR_NOACK : SSL_TLSEXT_ERR_OK;
1091add_ca_to_cert_store(X509_STORE *st, X509 *x509) {
1095 while ((e = ERR_get_error()) != 0) {
1098 if (!X509_STORE_add_cert(st, x509)) {
1099 while ((e = ERR_get_error()) != 0) {
1100 int r = ERR_GET_REASON(e);
1101 if (r != X509_R_CERT_ALREADY_IN_HASH_TABLE) {
1104 ERR_reason_error_string(e),
1105 ssl_function_definition(e));
1112missing_ENGINE_load_cert(
const char *cert_id) {
1114 const char *cert_id;
1118 params.cert_id = cert_id;
1122 if (!ENGINE_ctrl_cmd(ssl_engine,
"LOAD_CERT_CTRL", 0, ¶ms, NULL, 1)) {
1128#if OPENSSL_VERSION_NUMBER < 0x10101000L && COAP_SERVER_SUPPORT
1130setup_pki_server(SSL_CTX *ctx,
1137 if (!(SSL_CTX_use_certificate_file(ctx,
1139 SSL_FILETYPE_PEM))) {
1140 coap_log_warn(
"*** setup_pki: (D)TLS: %s: Unable to configure "
1141 "Server Certificate\n",
1146 coap_log_err(
"*** setup_pki: (D)TLS: No Server Certificate defined\n");
1152 if (!(SSL_CTX_use_PrivateKey_file(ctx,
1154 SSL_FILETYPE_PEM))) {
1155 coap_log_warn(
"*** setup_pki: (D)TLS: %s: Unable to configure "
1156 "Server Private Key\n",
1161 coap_log_err(
"*** setup_pki: (D)TLS: No Server Private Key defined\n");
1167 STACK_OF(X509_NAME) *cert_names;
1171 char *rw_var = NULL;
1173 if (cert_names != NULL)
1174 SSL_CTX_set_client_CA_list(ctx, cert_names);
1176 coap_log_warn(
"*** setup_pki: (D)TLS: %s: Unable to configure "
1183 st = SSL_CTX_get_cert_store(ctx);
1184 in = BIO_new(BIO_s_file());
1187 if (!BIO_read_filename(in, rw_var)) {
1194 if ((x = PEM_read_bio_X509(in, NULL, NULL, NULL)) == NULL)
1196 add_ca_to_cert_store(st, x);
1208 X509 *cert = bp ? PEM_read_bio_X509(bp, NULL, 0, NULL) : NULL;
1210 if (!cert || !SSL_CTX_use_certificate(ctx, cert)) {
1212 "Server PEM Certificate\n");
1224 coap_log_err(
"*** setup_pki: (D)TLS: No Server Certificate defined\n");
1232 EVP_PKEY *pkey = bp ? PEM_read_bio_PrivateKey(bp, NULL, 0, NULL) : NULL;
1234 if (!pkey || !SSL_CTX_use_PrivateKey(ctx, pkey)) {
1236 "Server PEM Private Key\n");
1240 EVP_PKEY_free(pkey);
1246 EVP_PKEY_free(pkey);
1248 coap_log_err(
"*** setup_pki: (D)TLS: No Server Private Key defined\n");
1259 st = SSL_CTX_get_cert_store(ctx);
1262 if ((x = PEM_read_bio_X509(bp, NULL, NULL, NULL)) == NULL)
1264 add_ca_to_cert_store(st, x);
1265 SSL_CTX_add_client_CA(ctx, x);
1276 if (!(SSL_CTX_use_certificate_ASN1(ctx,
1279 coap_log_warn(
"*** setup_pki: (D)TLS: %s: Unable to configure "
1280 "Server Certificate\n",
1285 coap_log_err(
"*** setup_pki: (D)TLS: No Server Certificate defined\n");
1292 if (!(SSL_CTX_use_PrivateKey_ASN1(pkey_type, ctx,
1295 coap_log_warn(
"*** setup_pki: (D)TLS: %s: Unable to configure "
1296 "Server Private Key\n",
1301 coap_log_err(
"*** setup_pki: (D)TLS: No Server Private Key defined\n");
1311 if (!x509 || !SSL_CTX_add_client_CA(ctx, x509)) {
1312 coap_log_warn(
"*** setup_pki: (D)TLS: %s: Unable to configure "
1319 st = SSL_CTX_get_cert_store(ctx);
1320 add_ca_to_cert_store(st, x509);
1327 ssl_engine = ENGINE_by_id(COAP_OPENSSL_PKCS11_ENGINE_ID);
1329 coap_log_err(
"*** setup_pki: (D)TLS: No PKCS11 support\nn");
1332 if (!ENGINE_init(ssl_engine)) {
1334 ENGINE_free(ssl_engine);
1336 coap_log_err(
"*** setup_pki: (D)TLS: PKCS11 engine initialize failed\n");
1343 if (ENGINE_ctrl_cmd_string(ssl_engine,
"PIN",
1345 coap_log_warn(
"*** setup_pki: (D)TLS: PKCS11: %s: Unable to set pin\n",
1354 "pkcs11:", 7) == 0) {
1355 EVP_PKEY *pkey = ENGINE_load_private_key(ssl_engine,
1361 "Server Private Key\n",
1365 if (!SSL_CTX_use_PrivateKey(ctx, pkey)) {
1366 coap_log_warn(
"*** setup_pki: (D)TLS: %s: Unable to configure "
1367 "Server Private Key\n",
1369 EVP_PKEY_free(pkey);
1372 EVP_PKEY_free(pkey);
1374 if (!(SSL_CTX_use_PrivateKey_file(ctx,
1376 SSL_FILETYPE_ASN1))) {
1377 coap_log_warn(
"*** setup_pki: (D)TLS: %s: Unable to configure "
1378 "Server Private Key\n",
1384 coap_log_err(
"*** setup_pki: (D)TLS: No Server Private Key defined\n");
1391 "pkcs11:", 7) == 0) {
1394 x509 = missing_ENGINE_load_cert(
1398 "Server Certificate\n",
1402 if (!SSL_CTX_use_certificate(ctx, x509)) {
1403 coap_log_warn(
"*** setup_pki: (D)TLS: %s: Unable to configure "
1404 "Server Certificate\n",
1411 if (!(SSL_CTX_use_certificate_file(ctx,
1413 SSL_FILETYPE_ASN1))) {
1414 coap_log_warn(
"*** setup_pki: (D)TLS: %s: Unable to configure "
1415 "Server Certificate\n",
1421 coap_log_err(
"*** setup_pki: (D)TLS: No Server Certificate defined\n");
1432 x509 = missing_ENGINE_load_cert(
1436 "Server CA Certificate\n",
1440 if (!SSL_CTX_add_client_CA(ctx, x509)) {
1441 coap_log_warn(
"*** setup_pki: (D)TLS: %s: Unable to configure "
1447 st = SSL_CTX_get_cert_store(ctx);
1448 add_ca_to_cert_store(st, x509);
1452 X509 *x509 = fp ? d2i_X509_fp(fp, NULL) : NULL;
1454 if (!x509 || !SSL_CTX_add_client_CA(ctx, x509)) {
1455 coap_log_warn(
"*** setup_pki: (D)TLS: %s: Unable to configure "
1462 st = SSL_CTX_get_cert_store(ctx);
1463 add_ca_to_cert_store(st, x509);
1470 coap_log_err(
"*** setup_pki: (D)TLS: Unknown key type %d\n",
1479#if OPENSSL_VERSION_NUMBER >= 0x10101000L || COAP_CLIENT_SUPPORT
1481setup_pki_ssl(SSL *ssl,
1485 coap_log_err(
"RPK Support not available in OpenSSL\n");
1492 if (!(SSL_use_certificate_file(ssl,
1494 SSL_FILETYPE_PEM))) {
1495 coap_log_warn(
"*** setup_pki: (D)TLS: %s: Unable to configure "
1504 coap_log_err(
"*** setup_pki: (D)TLS: No %s Certificate defined\n",
1510 if (!(SSL_use_PrivateKey_file(ssl,
1512 SSL_FILETYPE_PEM))) {
1513 coap_log_warn(
"*** setup_pki: (D)TLS: %s: Unable to configure "
1514 "Client Private Key\n",
1521 coap_log_err(
"*** setup_pki: (D)TLS: No %s Private Key defined\n",
1530 char *rw_var = NULL;
1531 SSL_CTX *ctx = SSL_get_SSL_CTX(ssl);
1534 STACK_OF(X509_NAME) *cert_names = SSL_load_client_CA_file(setup_data->
pki_key.
key.
pem.
ca_file);
1536 if (cert_names != NULL)
1537 SSL_set_client_CA_list(ssl, cert_names);
1539 coap_log_warn(
"*** setup_pki: (D)TLS: %s: Unable to configure "
1548 in = BIO_new(BIO_s_file());
1551 if (!BIO_read_filename(in, rw_var)) {
1555 st = SSL_CTX_get_cert_store(ctx);
1557 if ((x = PEM_read_bio_X509(in, NULL, NULL, NULL)) == NULL)
1559 add_ca_to_cert_store(st, x);
1571 X509 *cert = bp ? PEM_read_bio_X509(bp, NULL, 0, NULL) : NULL;
1573 if (!cert || !SSL_use_certificate(ssl, cert)) {
1575 "Server PEM Certificate\n");
1587 coap_log_err(
"*** setup_pki: (D)TLS: No Server Certificate defined\n");
1595 EVP_PKEY *pkey = bp ? PEM_read_bio_PrivateKey(bp, NULL, 0, NULL) : NULL;
1597 if (!pkey || !SSL_use_PrivateKey(ssl, pkey)) {
1599 "Server PEM Private Key\n");
1603 EVP_PKEY_free(pkey);
1609 EVP_PKEY_free(pkey);
1611 coap_log_err(
"*** setup_pki: (D)TLS: No Server Private Key defined\n");
1619 SSL_CTX *ctx = SSL_get_SSL_CTX(ssl);
1621 X509_STORE *st = SSL_CTX_get_cert_store(ctx);
1625 if ((x = PEM_read_bio_X509(bp, NULL, 0, NULL)) == NULL)
1627 add_ca_to_cert_store(st, x);
1628 SSL_add_client_CA(ssl, x);
1639 if (!(SSL_use_certificate_ASN1(ssl,
1642 coap_log_warn(
"*** setup_pki: (D)TLS: %s: Unable to configure "
1651 coap_log_err(
"*** setup_pki: (D)TLS: No %s Certificate defined\n",
1658 if (!(SSL_use_PrivateKey_ASN1(pkey_type, ssl,
1661 coap_log_warn(
"*** setup_pki: (D)TLS: %s: Unable to configure "
1670 coap_log_err(
"*** setup_pki: (D)TLS: No %s Private Key defined",
1680 SSL_CTX *ctx = SSL_get_SSL_CTX(ssl);
1683 if (!x509 || !SSL_add_client_CA(ssl, x509)) {
1684 coap_log_warn(
"*** setup_pki: (D)TLS: %s: Unable to configure "
1693 st = SSL_CTX_get_cert_store(ctx);
1694 add_ca_to_cert_store(st, x509);
1701 ssl_engine = ENGINE_by_id(COAP_OPENSSL_PKCS11_ENGINE_ID);
1703 coap_log_err(
"*** setup_pki: (D)TLS: No PKCS11 support - need OpenSSL pkcs11 engine\n");
1706 if (!ENGINE_init(ssl_engine)) {
1708 ENGINE_free(ssl_engine);
1710 coap_log_err(
"*** setup_pki: (D)TLS: PKCS11 engine initialize failed\n");
1717 if (ENGINE_ctrl_cmd_string(ssl_engine,
1720 coap_log_warn(
"*** setup_pki: (D)TLS: PKCS11: %s: Unable to set pin\n",
1729 "pkcs11:", 7) == 0) {
1730 EVP_PKEY *pkey = ENGINE_load_private_key(ssl_engine,
1741 if (!SSL_use_PrivateKey(ssl, pkey)) {
1742 coap_log_warn(
"*** setup_pki: (D)TLS: %s: Unable to configure "
1746 EVP_PKEY_free(pkey);
1749 EVP_PKEY_free(pkey);
1751 if (!(SSL_use_PrivateKey_file(ssl,
1753 SSL_FILETYPE_ASN1))) {
1754 coap_log_warn(
"*** setup_pki: (D)TLS: %s: Unable to configure "
1762 coap_log_err(
"*** setup_pki: (D)TLS: No Server Private Key defined\n");
1769 "pkcs11:", 7) == 0) {
1772 x509 = missing_ENGINE_load_cert(
1781 if (!SSL_use_certificate(ssl, x509)) {
1782 coap_log_warn(
"*** setup_pki: (D)TLS: %s: Unable to configure "
1791 if (!(SSL_use_certificate_file(ssl,
1793 SSL_FILETYPE_ASN1))) {
1794 coap_log_warn(
"*** setup_pki: (D)TLS: %s: Unable to configure "
1802 coap_log_err(
"*** setup_pki: (D)TLS: No Server Certificate defined\n");
1812 SSL_CTX *ctx = SSL_get_SSL_CTX(ssl);
1814 x509 = missing_ENGINE_load_cert(
1818 "%s CA Certificate\n",
1823 if (!SSL_add_client_CA(ssl, x509)) {
1824 coap_log_warn(
"*** setup_pki: (D)TLS: %s: Unable to configure "
1825 "%s CA Certificate\n",
1831 st = SSL_CTX_get_cert_store(ctx);
1832 add_ca_to_cert_store(st, x509);
1836 X509 *x509 = fp ? d2i_X509_fp(fp, NULL) : NULL;
1837 SSL_CTX *ctx = SSL_get_SSL_CTX(ssl);
1839 if (!x509 || !SSL_add_client_CA(ssl, x509)) {
1840 coap_log_warn(
"*** setup_pki: (D)TLS: %s: Unable to configure "
1848 st = SSL_CTX_get_cert_store(ctx);
1849 add_ca_to_cert_store(st, x509);
1856 coap_log_err(
"*** setup_pki: (D)TLS: Unknown key type %d\n",
1865get_san_or_cn_from_cert(X509 *x509) {
1869 STACK_OF(GENERAL_NAME) *san_list;
1872 san_list = X509_get_ext_d2i(x509, NID_subject_alt_name, NULL, NULL);
1874 int san_count = sk_GENERAL_NAME_num(san_list);
1876 for (n = 0; n < san_count; n++) {
1877 const GENERAL_NAME *name = sk_GENERAL_NAME_value(san_list, n);
1879 if (name->type == GEN_DNS) {
1880 const char *dns_name = (
const char *)ASN1_STRING_get0_data(name->d.dNSName);
1883 if (ASN1_STRING_length(name->d.dNSName) != (int)strlen(dns_name))
1885 cn = OPENSSL_strdup(dns_name);
1886 sk_GENERAL_NAME_pop_free(san_list, GENERAL_NAME_free);
1890 sk_GENERAL_NAME_pop_free(san_list, GENERAL_NAME_free);
1893 X509_NAME_oneline(X509_get_subject_name(x509), buffer,
sizeof(buffer));
1896 n = (int)strlen(buffer) - 3;
1899 if (((cn[0] ==
'C') || (cn[0] ==
'c')) &&
1900 ((cn[1] ==
'N') || (cn[1] ==
'n')) &&
1909 char *ecn = strchr(cn,
'/');
1911 return OPENSSL_strndup(cn, ecn-cn);
1913 return OPENSSL_strdup(cn);
1921tls_verify_call_back(
int preverify_ok, X509_STORE_CTX *ctx) {
1922 SSL *ssl = X509_STORE_CTX_get_ex_data(ctx,
1923 SSL_get_ex_data_X509_STORE_CTX_idx());
1925 coap_openssl_context_t *context =
1928 int depth = X509_STORE_CTX_get_error_depth(ctx);
1929 int err = X509_STORE_CTX_get_error(ctx);
1930 X509 *x509 = X509_STORE_CTX_get_current_cert(ctx);
1931 char *cn = get_san_or_cn_from_cert(x509);
1932 int keep_preverify_ok = preverify_ok;
1934 if (!preverify_ok) {
1936 case X509_V_ERR_CERT_NOT_YET_VALID:
1937 case X509_V_ERR_CERT_HAS_EXPIRED:
1941 case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
1945 case X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN:
1949 case X509_V_ERR_UNABLE_TO_GET_CRL:
1953 case X509_V_ERR_CRL_NOT_YET_VALID:
1954 case X509_V_ERR_CRL_HAS_EXPIRED:
1958 case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY:
1959 case X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE:
1960 case X509_V_ERR_AKID_SKID_MISMATCH:
1970 err = X509_V_ERR_CERT_CHAIN_TOO_LONG;
1971 X509_STORE_CTX_set_error(ctx, err);
1973 if (!preverify_ok) {
1974 if (err == X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN) {
1977 "Unknown CA", cn ? cn :
"?", depth);
1981 X509_verify_cert_error_string(err), cn ? cn :
"?", depth);
1986 X509_verify_cert_error_string(err), cn ? cn :
"?", depth);
1991 int length = i2d_X509(x509, NULL);
1993 uint8_t *base_buf2 = base_buf = OPENSSL_malloc(length);
1996 i2d_X509(x509, &base_buf2);
1998 depth, preverify_ok,
2001 X509_STORE_CTX_set_error(ctx, X509_V_ERR_CERT_REJECTED);
2003 X509_STORE_CTX_set_error(ctx, X509_V_ERR_INVALID_CA);
2007 OPENSSL_free(base_buf);
2010 return preverify_ok;
2013#if COAP_SERVER_SUPPORT
2014#if OPENSSL_VERSION_NUMBER < 0x10101000L
2023tls_secret_call_back(SSL *ssl,
2026 STACK_OF(SSL_CIPHER) *peer_ciphers,
2031 int psk_requested = 0;
2036 assert(session != NULL);
2037 assert(session->
context != NULL);
2038 if (session == NULL ||
2046 for (ii = 0; ii < sk_SSL_CIPHER_num(peer_ciphers); ii++) {
2047 const SSL_CIPHER *peer_cipher = sk_SSL_CIPHER_value(peer_ciphers, ii);
2050 SSL_CIPHER_get_name(peer_cipher));
2051 if (strstr(SSL_CIPHER_get_name(peer_cipher),
"PSK")) {
2057 if (!psk_requested) {
2064 SSL_VERIFY_CLIENT_ONCE |
2065 SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
2066 tls_verify_call_back);
2068 SSL_set_verify(ssl, SSL_VERIFY_NONE, tls_verify_call_back);
2077 X509_VERIFY_PARAM *param;
2079 param = X509_VERIFY_PARAM_new();
2080 X509_VERIFY_PARAM_set_flags(param, X509_V_FLAG_CRL_CHECK);
2081 SSL_set1_param(ssl, param);
2082 X509_VERIFY_PARAM_free(param);
2104 SSL_set_cipher_list(ssl, COAP_OPENSSL_PSK_CIPHERS);
2105 SSL_set_psk_server_callback(ssl, coap_dtls_psk_server_callback);
2119tls_server_name_call_back(SSL *ssl,
2126 return SSL_TLSEXT_ERR_NOACK;
2132 coap_openssl_context_t *context =
2134 const char *sni = SSL_get_servername(ssl, TLSEXT_NAMETYPE_host_name);
2137 if (!sni || !sni[0]) {
2140 for (i = 0; i < context->sni_count; i++) {
2141 if (!strcasecmp(sni, context->sni_entry_list[i].sni)) {
2145 if (i == context->sni_count) {
2151 return SSL_TLSEXT_ERR_ALERT_FATAL;
2156 ctx = SSL_CTX_new(DTLS_method());
2159 SSL_CTX_set_min_proto_version(ctx, DTLS1_2_VERSION);
2160 SSL_CTX_set_app_data(ctx, &context->dtls);
2161 SSL_CTX_set_read_ahead(ctx, 1);
2162 coap_set_user_prefs(ctx);
2163 SSL_CTX_set_cookie_generate_cb(ctx, coap_dtls_generate_cookie);
2164 SSL_CTX_set_cookie_verify_cb(ctx, coap_dtls_verify_cookie);
2165 SSL_CTX_set_info_callback(ctx, coap_dtls_info_callback);
2166 SSL_CTX_set_options(ctx, SSL_OP_NO_QUERY_MTU);
2168#if !COAP_DISABLE_TCP
2171 ctx = SSL_CTX_new(TLS_method());
2174 SSL_CTX_set_app_data(ctx, &context->tls);
2175 SSL_CTX_set_min_proto_version(ctx, TLS1_VERSION);
2176 coap_set_user_prefs(ctx);
2177 SSL_CTX_set_info_callback(ctx, coap_dtls_info_callback);
2178 SSL_CTX_set_alpn_select_cb(ctx, server_alpn_callback, NULL);
2181 sni_setup_data = *setup_data;
2182 sni_setup_data.
pki_key = *new_entry;
2183 setup_pki_server(ctx, &sni_setup_data);
2185 context->sni_entry_list = OPENSSL_realloc(context->sni_entry_list,
2186 (context->sni_count+1)*
sizeof(sni_entry));
2187 context->sni_entry_list[context->sni_count].sni = OPENSSL_strdup(sni);
2188 context->sni_entry_list[context->sni_count].ctx = ctx;
2189 context->sni_count++;
2191 SSL_set_SSL_CTX(ssl, context->sni_entry_list[i].ctx);
2192 SSL_clear_options(ssl, 0xFFFFFFFFL);
2193 SSL_set_options(ssl, SSL_CTX_get_options(context->sni_entry_list[i].ctx));
2200 SSL_set_session_secret_cb(ssl, tls_secret_call_back, arg);
2201 return SSL_TLSEXT_ERR_OK;
2204 return SSL_TLSEXT_ERR_ALERT_WARNING;
2215psk_tls_server_name_call_back(SSL *ssl,
2222 return SSL_TLSEXT_ERR_NOACK;
2228 coap_openssl_context_t *o_context =
2230 const char *sni = SSL_get_servername(ssl, TLSEXT_NAMETYPE_host_name);
2234 if (!sni || !sni[0]) {
2237 for (i = 0; i < o_context->psk_sni_count; i++) {
2238 if (!strcasecmp(sni, (
char *)o_context->psk_sni_entry_list[i].sni)) {
2242 if (i == o_context->psk_sni_count) {
2249 return SSL_TLSEXT_ERR_ALERT_FATAL;
2254 ctx = SSL_CTX_new(DTLS_method());
2257 SSL_CTX_set_min_proto_version(ctx, DTLS1_2_VERSION);
2258 SSL_CTX_set_app_data(ctx, &o_context->dtls);
2259 SSL_CTX_set_read_ahead(ctx, 1);
2260 SSL_CTX_set_cipher_list(ctx, COAP_OPENSSL_CIPHERS);
2261 SSL_CTX_set_cookie_generate_cb(ctx, coap_dtls_generate_cookie);
2262 SSL_CTX_set_cookie_verify_cb(ctx, coap_dtls_verify_cookie);
2263 SSL_CTX_set_info_callback(ctx, coap_dtls_info_callback);
2264 SSL_CTX_set_options(ctx, SSL_OP_NO_QUERY_MTU);
2266#if !COAP_DISABLE_TCP
2269 ctx = SSL_CTX_new(TLS_method());
2272 SSL_CTX_set_app_data(ctx, &o_context->tls);
2273 SSL_CTX_set_min_proto_version(ctx, TLS1_VERSION);
2274 SSL_CTX_set_cipher_list(ctx, COAP_OPENSSL_CIPHERS);
2275 SSL_CTX_set_info_callback(ctx, coap_dtls_info_callback);
2276 SSL_CTX_set_alpn_select_cb(ctx, server_alpn_callback, NULL);
2280 o_context->psk_sni_entry_list =
2281 OPENSSL_realloc(o_context->psk_sni_entry_list,
2282 (o_context->psk_sni_count+1)*
sizeof(psk_sni_entry));
2283 o_context->psk_sni_entry_list[o_context->psk_sni_count].sni =
2284 OPENSSL_strdup(sni);
2285 o_context->psk_sni_entry_list[o_context->psk_sni_count].psk_info =
2287 o_context->psk_sni_entry_list[o_context->psk_sni_count].ctx =
2289 o_context->psk_sni_count++;
2291 SSL_set_SSL_CTX(ssl, o_context->psk_sni_entry_list[i].ctx);
2292 SSL_clear_options(ssl, 0xFFFFFFFFL);
2293 SSL_set_options(ssl,
2294 SSL_CTX_get_options(o_context->psk_sni_entry_list[i].ctx));
2296 &o_context->psk_sni_entry_list[i].psk_info.key);
2297 snprintf(lhint,
sizeof(lhint),
"%.*s",
2298 (
int)o_context->psk_sni_entry_list[i].psk_info.hint.length,
2299 o_context->psk_sni_entry_list[i].psk_info.hint.s);
2300 SSL_use_psk_identity_hint(ssl, lhint);
2307 SSL_set_session_secret_cb(ssl, tls_secret_call_back, arg);
2308 return SSL_TLSEXT_ERR_OK;
2311 return SSL_TLSEXT_ERR_ALERT_WARNING;
2323tls_client_hello_call_back(SSL *ssl,
2328 coap_openssl_context_t *dtls_context;
2330 int psk_requested = 0;
2331 const unsigned char *out;
2335 *al = SSL_AD_INTERNAL_ERROR;
2336 return SSL_CLIENT_HELLO_ERROR;
2339 assert(session != NULL);
2340 assert(session->
context != NULL);
2342 if (session == NULL ||
2345 *al = SSL_AD_INTERNAL_ERROR;
2346 return SSL_CLIENT_HELLO_ERROR;
2349 setup_data = &dtls_context->setup_data;
2357 size_t len = SSL_client_hello_get0_ciphers(ssl, &out);
2358 STACK_OF(SSL_CIPHER) *peer_ciphers = NULL;
2359 STACK_OF(SSL_CIPHER) *scsvc = NULL;
2361 if (len && SSL_bytes_to_cipher_list(ssl, out, len,
2362 SSL_client_hello_isv2(ssl),
2363 &peer_ciphers, &scsvc)) {
2365 for (ii = 0; ii < sk_SSL_CIPHER_num(peer_ciphers); ii++) {
2366 const SSL_CIPHER *peer_cipher = sk_SSL_CIPHER_value(peer_ciphers, ii);
2369 "Client cipher: %s (%04x)\n",
2370 SSL_CIPHER_get_name(peer_cipher),
2371 SSL_CIPHER_get_protocol_id(peer_cipher));
2372 if (strstr(SSL_CIPHER_get_name(peer_cipher),
"PSK")) {
2378 sk_SSL_CIPHER_free(peer_ciphers);
2379 sk_SSL_CIPHER_free(scsvc);
2382 if (psk_requested) {
2388 SSL_set_psk_server_callback(ssl, coap_dtls_psk_server_callback);
2394 return SSL_CLIENT_HELLO_SUCCESS;
2404 if (SSL_client_hello_get0_ext(ssl, TLSEXT_TYPE_client_certificate_type,
2407 for (ii = 0; ii < outlen; ii++) {
2423 *al = SSL_AD_UNSUPPORTED_EXTENSION;
2424 return SSL_CLIENT_HELLO_ERROR;
2433 coap_openssl_context_t *context =
2435 const char *sni =
"";
2436 char *sni_tmp = NULL;
2439 if (SSL_client_hello_get0_ext(ssl, TLSEXT_TYPE_server_name, &out, &outlen) &&
2441 (((out[0]<<8) + out[1] +2) == (int)outlen) &&
2442 out[2] == TLSEXT_NAMETYPE_host_name &&
2443 (((out[3]<<8) + out[4] +2 +3) == (int)outlen)) {
2447 sni_tmp = OPENSSL_malloc(outlen+1);
2448 sni_tmp[outlen] =
'\000';
2449 memcpy(sni_tmp, out, outlen);
2453 for (i = 0; i < context->sni_count; i++) {
2454 if (!strcasecmp(sni, context->sni_entry_list[i].sni)) {
2458 if (i == context->sni_count) {
2465 *al = SSL_AD_UNRECOGNIZED_NAME;
2466 return SSL_CLIENT_HELLO_ERROR;
2470 context->sni_entry_list = OPENSSL_realloc(context->sni_entry_list,
2471 (context->sni_count+1)*
sizeof(sni_entry));
2472 context->sni_entry_list[context->sni_count].sni = OPENSSL_strdup(sni);
2473 context->sni_entry_list[context->sni_count].pki_key = *new_entry;
2474 context->sni_count++;
2477 OPENSSL_free(sni_tmp);
2479 sni_setup_data = *setup_data;
2480 sni_setup_data.
pki_key = context->sni_entry_list[i].pki_key;
2492 SSL_VERIFY_CLIENT_ONCE |
2493 SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
2494 tls_verify_call_back);
2496 SSL_set_verify(ssl, SSL_VERIFY_NONE, tls_verify_call_back);
2505 X509_VERIFY_PARAM *param;
2507 param = X509_VERIFY_PARAM_new();
2508 X509_VERIFY_PARAM_set_flags(param, X509_V_FLAG_CRL_CHECK);
2509 SSL_set1_param(ssl, param);
2510 X509_VERIFY_PARAM_free(param);
2517 return SSL_CLIENT_HELLO_SUCCESS;
2528psk_tls_client_hello_call_back(SSL *ssl,
2533 coap_openssl_context_t *o_context;
2535 const unsigned char *out;
2541 if (!c_session || !c_session->
context) {
2554 const char *sni =
"";
2555 char *sni_tmp = NULL;
2559 if (SSL_client_hello_get0_ext(ssl, TLSEXT_TYPE_server_name, &out, &outlen) &&
2561 (((out[0]<<8) + out[1] +2) == (
int)outlen) &&
2562 out[2] == TLSEXT_NAMETYPE_host_name &&
2563 (((out[3]<<8) + out[4] +2 +3) == (
int)outlen)) {
2567 sni_tmp = OPENSSL_malloc(outlen+1);
2569 sni_tmp[outlen] =
'\000';
2570 memcpy(sni_tmp, out, outlen);
2576 for (i = 0; i < o_context->psk_sni_count; i++) {
2577 if (strcasecmp(sni, o_context->psk_sni_entry_list[i].sni) == 0) {
2581 if (i == o_context->psk_sni_count) {
2585 psk_sni_entry *tmp_entry;
2591 *al = SSL_AD_UNRECOGNIZED_NAME;
2592 return SSL_CLIENT_HELLO_ERROR;
2596 OPENSSL_realloc(o_context->psk_sni_entry_list,
2597 (o_context->psk_sni_count+1)*
sizeof(sni_entry));
2599 o_context->psk_sni_entry_list = tmp_entry;
2600 o_context->psk_sni_entry_list[o_context->psk_sni_count].sni =
2601 OPENSSL_strdup(sni);
2602 if (o_context->psk_sni_entry_list[o_context->psk_sni_count].sni) {
2603 o_context->psk_sni_entry_list[o_context->psk_sni_count].psk_info =
2605 o_context->psk_sni_count++;
2610 OPENSSL_free(sni_tmp);
2613 &o_context->psk_sni_entry_list[i].psk_info.hint)
2618 &o_context->psk_sni_entry_list[i].psk_info.key)
2622 if (o_context->psk_sni_entry_list[i].psk_info.hint.s) {
2623 snprintf(lhint,
sizeof(lhint),
"%.*s",
2624 (
int)o_context->psk_sni_entry_list[i].psk_info.hint.length,
2625 o_context->psk_sni_entry_list[i].psk_info.hint.s);
2626 SSL_use_psk_identity_hint(ssl, lhint);
2629 return SSL_CLIENT_HELLO_SUCCESS;
2632 *al = SSL_AD_INTERNAL_ERROR;
2633 return SSL_CLIENT_HELLO_ERROR;
2643 coap_openssl_context_t *context =
2648 context->setup_data = *setup_data;
2649 if (!context->setup_data.verify_peer_cert) {
2651 context->setup_data.check_common_ca = 0;
2653 context->setup_data.allow_self_signed = 1;
2654 context->setup_data.allow_expired_certs = 1;
2655 context->setup_data.cert_chain_validation = 1;
2656 context->setup_data.cert_chain_verify_depth = 10;
2657 context->setup_data.check_cert_revocation = 1;
2658 context->setup_data.allow_no_crl = 1;
2659 context->setup_data.allow_expired_crl = 1;
2660 context->setup_data.allow_bad_md_hash = 1;
2661 context->setup_data.allow_short_rsa_length = 1;
2663#if COAP_SERVER_SUPPORT
2665 if (context->dtls.ctx) {
2667#if OPENSSL_VERSION_NUMBER < 0x10101000L
2668 if (!setup_pki_server(context->dtls.ctx, setup_data))
2677#if OPENSSL_VERSION_NUMBER < 0x10101000L
2678 if (SSLeay() >= 0x10101000L) {
2679 coap_log_warn(
"OpenSSL compiled with %lux, linked with %lux, so "
2680 "no certificate checking\n",
2681 OPENSSL_VERSION_NUMBER, SSLeay());
2683 SSL_CTX_set_tlsext_servername_arg(context->dtls.ctx, &context->setup_data);
2684 SSL_CTX_set_tlsext_servername_callback(context->dtls.ctx,
2685 tls_server_name_call_back);
2687 SSL_CTX_set_client_hello_cb(context->dtls.ctx,
2688 tls_client_hello_call_back,
2692#if !COAP_DISABLE_TCP
2693 if (context->tls.ctx) {
2695#if OPENSSL_VERSION_NUMBER < 0x10101000L
2696 if (!setup_pki_server(context->tls.ctx, setup_data))
2705#if OPENSSL_VERSION_NUMBER < 0x10101000L
2706 if (SSLeay() >= 0x10101000L) {
2707 coap_log_warn(
"OpenSSL compiled with %lux, linked with %lux, so "
2708 "no certificate checking\n",
2709 OPENSSL_VERSION_NUMBER, SSLeay());
2711 SSL_CTX_set_tlsext_servername_arg(context->tls.ctx, &context->setup_data);
2712 SSL_CTX_set_tlsext_servername_callback(context->tls.ctx,
2713 tls_server_name_call_back);
2715 SSL_CTX_set_client_hello_cb(context->tls.ctx,
2716 tls_client_hello_call_back,
2720 SSL_CTX_set_alpn_select_cb(context->tls.ctx, server_alpn_callback, NULL);
2728 if (!context->dtls.ssl) {
2730 context->dtls.ssl = SSL_new(context->dtls.ctx);
2731 if (!context->dtls.ssl)
2733 bio = BIO_new(context->dtls.meth);
2735 SSL_free(context->dtls.ssl);
2736 context->dtls.ssl = NULL;
2739 SSL_set_bio(context->dtls.ssl, bio, bio);
2740 SSL_set_app_data(context->dtls.ssl, NULL);
2741 SSL_set_options(context->dtls.ssl, SSL_OP_COOKIE_EXCHANGE);
2744 context->psk_pki_enabled |= IS_PKI;
2750 const char *ca_file,
2753 coap_openssl_context_t *context =
2755 if (context->dtls.ctx) {
2756 if (!SSL_CTX_load_verify_locations(context->dtls.ctx, ca_file, ca_dir)) {
2758 ca_file ? ca_file :
"NULL", ca_dir ? ca_dir :
"NULL");
2762#if !COAP_DISABLE_TCP
2763 if (context->tls.ctx) {
2764 if (!SSL_CTX_load_verify_locations(context->tls.ctx, ca_file, ca_dir)) {
2766 ca_file ? ca_file :
"NULL", ca_dir ? ca_dir :
"NULL");
2776 coap_openssl_context_t *context =
2778 return context->psk_pki_enabled ? 1 : 0;
2785 coap_openssl_context_t *context = (coap_openssl_context_t *)handle;
2787 if (context->dtls.ssl)
2788 SSL_free(context->dtls.ssl);
2789 if (context->dtls.ctx)
2790 SSL_CTX_free(context->dtls.ctx);
2791 if (context->dtls.cookie_hmac)
2792 HMAC_CTX_free(context->dtls.cookie_hmac);
2793 if (context->dtls.meth)
2794 BIO_meth_free(context->dtls.meth);
2795 if (context->dtls.bio_addr)
2796 BIO_ADDR_free(context->dtls.bio_addr);
2797#if !COAP_DISABLE_TCP
2798 if (context->tls.ctx)
2799 SSL_CTX_free(context->tls.ctx);
2800 if (context->tls.meth)
2801 BIO_meth_free(context->tls.meth);
2803 for (i = 0; i < context->sni_count; i++) {
2804 OPENSSL_free(context->sni_entry_list[i].sni);
2805#if OPENSSL_VERSION_NUMBER < 0x10101000L
2806 SSL_CTX_free(context->sni_entry_list[i].ctx);
2809 if (context->sni_count)
2810 OPENSSL_free(context->sni_entry_list);
2811 for (i = 0; i < context->psk_sni_count; i++) {
2812 OPENSSL_free((
char *)context->psk_sni_entry_list[i].sni);
2813#if OPENSSL_VERSION_NUMBER < 0x10101000L
2814 SSL_CTX_free(context->psk_sni_entry_list[i].ctx);
2817 if (context->psk_sni_count)
2818 OPENSSL_free(context->psk_sni_entry_list);
2822#if COAP_SERVER_SUPPORT
2826 SSL *nssl = NULL, *ssl = NULL;
2827 coap_ssl_data *data;
2828 coap_dtls_context_t *dtls = &((coap_openssl_context_t *)session->
context->
dtls_context)->dtls;
2832 nssl = SSL_new(dtls->ctx);
2835 nbio = BIO_new(dtls->meth);
2838 SSL_set_bio(nssl, nbio, nbio);
2839 SSL_set_app_data(nssl, NULL);
2840 SSL_set_options(nssl, SSL_OP_COOKIE_EXCHANGE);
2841 SSL_set_mtu(nssl, (
long)session->
mtu);
2845 SSL_set_app_data(ssl, session);
2847 data = (coap_ssl_data *)BIO_get_data(SSL_get_rbio(ssl));
2848 data->session = session;
2852 if (psk_hint != NULL && psk_hint->
length) {
2853 char *hint = OPENSSL_malloc(psk_hint->
length + 1);
2856 memcpy(hint, psk_hint->
s, psk_hint->
length);
2857 hint[psk_hint->
length] =
'\000';
2858 SSL_use_psk_identity_hint(ssl, hint);
2865 r = SSL_accept(ssl);
2867 int err = SSL_get_error(ssl, r);
2868 if (err != SSL_ERROR_WANT_READ && err != SSL_ERROR_WANT_WRITE)
2886#if COAP_CLIENT_SUPPORT
2890 coap_openssl_context_t *context =
2893 if (context->psk_pki_enabled & IS_PSK) {
2898 SSL_set_tlsext_host_name(ssl, setup_data->
client_sni) != 1) {
2902 SSL_set_psk_client_callback(ssl, coap_dtls_psk_client_callback);
2903#if COAP_SERVER_SUPPORT
2904 SSL_set_psk_server_callback(ssl, coap_dtls_psk_server_callback);
2906 SSL_set_cipher_list(ssl, COAP_OPENSSL_PSK_CIPHERS);
2909 SSL_set_max_proto_version(ssl, DTLS1_2_VERSION);
2911#if !COAP_DISABLE_TCP
2913 SSL_set_max_proto_version(ssl, TLS1_2_VERSION);
2916 coap_log_debug(
"CoAP Client restricted to (D)TLS1.2 with Identity Hint callback\n");
2919 if (context->psk_pki_enabled & IS_PKI) {
2924#if !COAP_DISABLE_TCP
2926 SSL_set_alpn_protos(ssl, coap_alpn,
sizeof(coap_alpn));
2931 SSL_set_tlsext_host_name(ssl, setup_data->
client_sni) != 1) {
2937 X509_VERIFY_PARAM *param;
2939 param = X509_VERIFY_PARAM_new();
2940 X509_VERIFY_PARAM_set_flags(param, X509_V_FLAG_CRL_CHECK);
2941 SSL_set1_param(ssl, param);
2942 X509_VERIFY_PARAM_free(param);
2949 SSL_VERIFY_CLIENT_ONCE |
2950 SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
2951 tls_verify_call_back);
2953 SSL_set_verify(ssl, SSL_VERIFY_NONE, tls_verify_call_back);
2967 coap_ssl_data *data;
2969 coap_openssl_context_t *context = ((coap_openssl_context_t *)session->
context->
dtls_context);
2970 coap_dtls_context_t *dtls = &context->dtls;
2972 ssl = SSL_new(dtls->ctx);
2975 bio = BIO_new(dtls->meth);
2978 data = (coap_ssl_data *)BIO_get_data(bio);
2979 data->session = session;
2980 SSL_set_bio(ssl, bio, bio);
2981 SSL_set_app_data(ssl, session);
2982 SSL_set_options(ssl, SSL_OP_COOKIE_EXCHANGE);
2983 SSL_set_mtu(ssl, (
long)session->
mtu);
2985 if (!setup_client_ssl_session(session, ssl))
2990 r = SSL_connect(ssl);
2992 int ret = SSL_get_error(ssl, r);
2993 if (ret != SSL_ERROR_WANT_READ && ret != SSL_ERROR_WANT_WRITE)
3011 SSL *ssl = (SSL *)session->
tls;
3013 SSL_set_mtu(ssl, (
long)session->
mtu);
3019 SSL *ssl = (SSL *)session->
tls;
3021 if (!SSL_in_init(ssl) && !(SSL_get_shutdown(ssl) & SSL_SENT_SHUTDOWN)) {
3022 int r = SSL_shutdown(ssl);
3024 r = SSL_shutdown(ssl);
3027 session->
tls = NULL;
3035 const uint8_t *data,
size_t data_len) {
3037 SSL *ssl = (SSL *)session->
tls;
3039 assert(ssl != NULL);
3042 r = SSL_write(ssl, data, (
int)data_len);
3045 int err = SSL_get_error(ssl, r);
3046 if (err == SSL_ERROR_WANT_READ || err == SSL_ERROR_WANT_WRITE) {
3050 if (err == SSL_ERROR_ZERO_RETURN)
3052 else if (err == SSL_ERROR_SSL)
3070 if (r == (ssize_t)data_len)
3093 SSL *ssl = (SSL *)session->
tls;
3094 coap_ssl_data *ssl_data;
3097 ssl_data = (coap_ssl_data *)BIO_get_data(SSL_get_rbio(ssl));
3098 return ssl_data->timeout;
3107 SSL *ssl = (SSL *)session->
tls;
3111 (DTLSv1_handle_timeout(ssl) < 0)) {
3119#if COAP_SERVER_SUPPORT
3122 const uint8_t *data,
size_t data_len) {
3123 coap_dtls_context_t *dtls = &((coap_openssl_context_t *)session->
context->
dtls_context)->dtls;
3124 coap_ssl_data *ssl_data;
3127 SSL_set_mtu(dtls->ssl, (
long)session->
mtu);
3128 ssl_data = (coap_ssl_data *)BIO_get_data(SSL_get_rbio(dtls->ssl));
3129 assert(ssl_data != NULL);
3130 if (ssl_data->pdu_len) {
3131 coap_log_err(
"** %s: Previous data not read %u bytes\n",
3134 ssl_data->session = session;
3135 ssl_data->pdu = data;
3136 ssl_data->pdu_len = (unsigned)data_len;
3137 r = DTLSv1_listen(dtls->ssl, dtls->bio_addr);
3139 int err = SSL_get_error(dtls->ssl, r);
3140 if (err == SSL_ERROR_WANT_READ || err == SSL_ERROR_WANT_WRITE) {
3160 coap_ssl_data *ssl_data;
3161 SSL *ssl = (SSL *)session->
tls;
3164 assert(ssl != NULL);
3166 int in_init = SSL_in_init(ssl);
3168 ssl_data = (coap_ssl_data *)BIO_get_data(SSL_get_rbio(ssl));
3169 assert(ssl_data != NULL);
3171 if (ssl_data->pdu_len) {
3172 coap_log_err(
"** %s: Previous data not read %u bytes\n",
3175 ssl_data->pdu = data;
3176 ssl_data->pdu_len = (unsigned)data_len;
3179 r = SSL_read(ssl, pdu, (
int)
sizeof(pdu));
3184 int err = SSL_get_error(ssl, r);
3185 if (err == SSL_ERROR_WANT_READ || err == SSL_ERROR_WANT_WRITE) {
3186 if (in_init && SSL_is_init_finished(ssl)) {
3194 if (err == SSL_ERROR_ZERO_RETURN)
3196 else if (err == SSL_ERROR_SSL)
3214 if (ssl_data && ssl_data->pdu_len) {
3216 coap_log_debug(
"coap_dtls_receive: ret %d: remaining data %u\n", r, ssl_data->pdu_len);
3217 ssl_data->pdu_len = 0;
3218 ssl_data->pdu = NULL;
3229 unsigned int overhead = 37;
3230 const SSL_CIPHER *s_ciph = NULL;
3231 if (session->
tls != NULL)
3232 s_ciph = SSL_get_current_cipher(session->
tls);
3234 unsigned int ivlen, maclen, blocksize = 1, pad = 0;
3236 const EVP_CIPHER *e_ciph;
3240 e_ciph = EVP_get_cipherbynid(SSL_CIPHER_get_cipher_nid(s_ciph));
3242 switch (EVP_CIPHER_mode(e_ciph)) {
3243 case EVP_CIPH_GCM_MODE:
3244 ivlen = EVP_GCM_TLS_EXPLICIT_IV_LEN;
3245 maclen = EVP_GCM_TLS_TAG_LEN;
3248 case EVP_CIPH_CCM_MODE:
3249 ivlen = EVP_CCM_TLS_EXPLICIT_IV_LEN;
3250 SSL_CIPHER_description(s_ciph, cipher,
sizeof(cipher));
3251 if (strstr(cipher,
"CCM8"))
3257 case EVP_CIPH_CBC_MODE:
3258 e_md = EVP_get_digestbynid(SSL_CIPHER_get_digest_nid(s_ciph));
3259 blocksize = EVP_CIPHER_block_size(e_ciph);
3260 ivlen = EVP_CIPHER_iv_length(e_ciph);
3262 maclen = EVP_MD_size(e_md);
3265 case EVP_CIPH_STREAM_CIPHER:
3272 SSL_CIPHER_description(s_ciph, cipher,
sizeof(cipher));
3279 overhead = DTLS1_RT_HEADER_LENGTH + ivlen + maclen + blocksize - 1 + pad;
3284#if !COAP_DISABLE_TCP
3285#if COAP_CLIENT_SUPPORT
3291 coap_openssl_context_t *context = ((coap_openssl_context_t *)session->
context->
dtls_context);
3292 coap_tls_context_t *tls = &context->tls;
3294 ssl = SSL_new(tls->ctx);
3297 bio = BIO_new(tls->meth);
3300 BIO_set_data(bio, session);
3301 SSL_set_bio(ssl, bio, bio);
3302 SSL_set_app_data(ssl, session);
3304 if (!setup_client_ssl_session(session, ssl))
3307 r = SSL_connect(ssl);
3309 int ret = SSL_get_error(ssl, r);
3310 if (ret != SSL_ERROR_WANT_READ && ret != SSL_ERROR_WANT_WRITE)
3312 if (ret == SSL_ERROR_WANT_READ)
3314 if (ret == SSL_ERROR_WANT_WRITE) {
3316#ifdef COAP_EPOLL_SUPPORT
3330 if (SSL_is_init_finished(ssl)) {
3344#if COAP_SERVER_SUPPORT
3349 coap_tls_context_t *tls = &((coap_openssl_context_t *)session->
context->
dtls_context)->tls;
3353 ssl = SSL_new(tls->ctx);
3356 bio = BIO_new(tls->meth);
3359 BIO_set_data(bio, session);
3360 SSL_set_bio(ssl, bio, bio);
3361 SSL_set_app_data(ssl, session);
3364 if (psk_hint != NULL && psk_hint->
length) {
3365 char *hint = OPENSSL_malloc(psk_hint->
length + 1);
3368 memcpy(hint, psk_hint->
s, psk_hint->
length);
3369 hint[psk_hint->
length] =
'\000';
3370 SSL_use_psk_identity_hint(ssl, hint);
3377 r = SSL_accept(ssl);
3379 int err = SSL_get_error(ssl, r);
3380 if (err != SSL_ERROR_WANT_READ && err != SSL_ERROR_WANT_WRITE)
3382 if (err == SSL_ERROR_WANT_READ)
3384 if (err == SSL_ERROR_WANT_WRITE) {
3386#ifdef COAP_EPOLL_SUPPORT
3400 if (SSL_is_init_finished(ssl)) {
3416 SSL *ssl = (SSL *)session->
tls;
3418 if (!SSL_in_init(ssl) && !(SSL_get_shutdown(ssl) & SSL_SENT_SHUTDOWN)) {
3419 int r = SSL_shutdown(ssl);
3421 r = SSL_shutdown(ssl);
3424 session->
tls = NULL;
3437 SSL *ssl = (SSL *)session->
tls;
3443 in_init = !SSL_is_init_finished(ssl);
3445 r = SSL_write(ssl, data, (
int)data_len);
3448 int err = SSL_get_error(ssl, r);
3449 if (err == SSL_ERROR_WANT_READ || err == SSL_ERROR_WANT_WRITE) {
3450 if (in_init && SSL_is_init_finished(ssl)) {
3456 if (err == SSL_ERROR_WANT_READ)
3458 else if (err == SSL_ERROR_WANT_WRITE) {
3460#ifdef COAP_EPOLL_SUPPORT
3472 if (err == SSL_ERROR_ZERO_RETURN)
3474 else if (err == SSL_ERROR_SSL)
3478 }
else if (in_init && SSL_is_init_finished(ssl)) {
3497 if (r == (ssize_t)data_len)
3514 SSL *ssl = (SSL *)session->
tls;
3522 in_init = !SSL_is_init_finished(ssl);
3524 r = SSL_read(ssl, data, (
int)data_len);
3526 int err = SSL_get_error(ssl, r);
3527 if (err == SSL_ERROR_WANT_READ || err == SSL_ERROR_WANT_WRITE) {
3528 if (in_init && SSL_is_init_finished(ssl)) {
3534 if (err == SSL_ERROR_WANT_READ)
3536 if (err == SSL_ERROR_WANT_WRITE) {
3538#ifdef COAP_EPOLL_SUPPORT
3548 if (err == SSL_ERROR_ZERO_RETURN)
3550 else if (err == SSL_ERROR_SSL)
3554 }
else if (in_init && SSL_is_init_finished(ssl)) {
3580#if COAP_SERVER_SUPPORT
3583 EVP_MD_CTX *digest_ctx = EVP_MD_CTX_new();
3586 EVP_DigestInit_ex(digest_ctx, EVP_sha256(), NULL);
3593 EVP_MD_CTX_free(digest_ctx);
3598 const uint8_t *data,
3600 return EVP_DigestUpdate(digest_ctx, data, data_len);
3607 int ret = EVP_DigestFinal_ex(digest_ctx, (uint8_t *)digest_buffer, &size);
3614#if COAP_WS_SUPPORT || COAP_OSCORE_SUPPORT
3616coap_crypto_output_errors(
const char *prefix) {
3617#if COAP_MAX_LOGGING_LEVEL < _COAP_LOG_WARN
3622 while ((e = ERR_get_error()))
3625 ERR_reason_error_string(e),
3626 ssl_function_definition(e));
3636static struct hash_algs {
3638 const EVP_MD *(*get_hash)(void);
3647static const EVP_MD *
3648get_hash_alg(
cose_alg_t alg,
size_t *length) {
3651 for (idx = 0; idx <
sizeof(hashs) /
sizeof(
struct hash_algs); idx++) {
3652 if (hashs[idx].alg == alg) {
3653 *length = hashs[idx].length;
3654 return hashs[idx].get_hash();
3657 coap_log_debug(
"get_hash_alg: COSE hash %d not supported\n", alg);
3665 unsigned int length;
3666 const EVP_MD *evp_md;
3667 EVP_MD_CTX *evp_ctx = NULL;
3671 if ((evp_md = get_hash_alg(alg, &hash_length)) == NULL) {
3672 coap_log_debug(
"coap_crypto_hash: algorithm %d not supported\n", alg);
3675 evp_ctx = EVP_MD_CTX_new();
3676 if (evp_ctx == NULL)
3678 if (EVP_DigestInit_ex(evp_ctx, evp_md, NULL) == 0)
3681 if (EVP_DigestUpdate(evp_ctx, data->
s, data->
length) == 0)
3687 if (EVP_DigestFinal_ex(evp_ctx,
dummy->s, &length) == 0)
3689 dummy->length = length;
3690 if (hash_length < dummy->length)
3691 dummy->length = hash_length;
3693 EVP_MD_CTX_free(evp_ctx);
3697 coap_crypto_output_errors(
"coap_crypto_hash");
3700 EVP_MD_CTX_free(evp_ctx);
3705#if COAP_OSCORE_SUPPORT
3711#include <openssl/evp.h>
3712#include <openssl/hmac.h>
3719static struct cipher_algs {
3721 const EVP_CIPHER *(*get_cipher)(void);
3726static const EVP_CIPHER *
3730 for (idx = 0; idx <
sizeof(ciphers) /
sizeof(
struct cipher_algs); idx++) {
3731 if (ciphers[idx].alg == alg)
3732 return ciphers[idx].get_cipher();
3734 coap_log_debug(
"get_cipher_alg: COSE cipher %d not supported\n", alg);
3743static struct hmac_algs {
3745 const EVP_MD *(*get_hmac)(void);
3752static const EVP_MD *
3756 for (idx = 0; idx <
sizeof(hmacs) /
sizeof(
struct hmac_algs); idx++) {
3757 if (hmacs[idx].hmac_alg == hmac_alg)
3758 return hmacs[idx].get_hmac();
3760 coap_log_debug(
"get_hmac_alg: COSE HMAC %d not supported\n", hmac_alg);
3766 return get_cipher_alg(alg) != NULL;
3775 return get_hmac_alg(hmac_alg) != NULL;
3779 if (1 != (Func)) { \
3788 size_t *max_result_len) {
3789 const EVP_CIPHER *cipher;
3792 int result_len = (int)(*max_result_len & INT_MAX);
3797 assert(params != NULL);
3798 if (!params || ((cipher = get_cipher_alg(params->
alg)) == NULL)) {
3805 EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
3808 C(EVP_EncryptInit_ex(ctx, cipher, NULL, NULL, NULL));
3809 C(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_CCM_SET_L, (
int)ccm->
l, NULL));
3810 C(EVP_CIPHER_CTX_ctrl(ctx,
3811 EVP_CTRL_AEAD_SET_IVLEN,
3814 C(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, (
int)ccm->
tag_len, NULL));
3815 C(EVP_EncryptInit_ex(ctx, NULL, NULL, ccm->
key.
s, ccm->
nonce));
3818 C(EVP_EncryptUpdate(ctx, NULL, &result_len, NULL, (
int)data->
length));
3819 if (aad && aad->
s && (aad->
length > 0)) {
3820 C(EVP_EncryptUpdate(ctx, NULL, &result_len, aad->
s, (
int)aad->
length));
3822 C(EVP_EncryptUpdate(ctx, result, &result_len, data->
s, (
int)data->
length));
3825 C(EVP_EncryptFinal_ex(ctx, result + result_len, &tmp));
3829 C(EVP_CIPHER_CTX_ctrl(ctx,
3830 EVP_CTRL_CCM_GET_TAG,
3832 result + result_len));
3834 *max_result_len = result_len + ccm->
tag_len;
3835 EVP_CIPHER_CTX_free(ctx);
3839 coap_crypto_output_errors(
"coap_crypto_aead_encrypt");
3848 size_t *max_result_len) {
3849 const EVP_CIPHER *cipher;
3859 assert(params != NULL);
3860 if (!params || ((cipher = get_cipher_alg(params->
alg)) == NULL)) {
3872 memcpy(&rwtag, &tag,
sizeof(rwtag));
3875 EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
3877 C(EVP_DecryptInit_ex(ctx, cipher, NULL, NULL, NULL));
3878 C(EVP_CIPHER_CTX_ctrl(ctx,
3879 EVP_CTRL_AEAD_SET_IVLEN,
3882 C(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, (
int)ccm->
tag_len, rwtag));
3883 C(EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_CCM_SET_L, (
int)ccm->
l, NULL));
3885 C(EVP_DecryptInit_ex(ctx, NULL, NULL, ccm->
key.
s, ccm->
nonce));
3887 C(EVP_DecryptUpdate(ctx, NULL, &len, NULL, (
int)data->
length));
3888 if (aad && aad->
s && (aad->
length > 0)) {
3889 C(EVP_DecryptUpdate(ctx, NULL, &len, aad->
s, (
int)aad->
length));
3891 tmp = EVP_DecryptUpdate(ctx, result, &len, data->
s, (
int)data->
length);
3892 EVP_CIPHER_CTX_free(ctx);
3894 *max_result_len = 0;
3897 *max_result_len = len;
3901 coap_crypto_output_errors(
"coap_crypto_aead_decrypt");
3910 unsigned int result_len;
3911 const EVP_MD *evp_md;
3918 if ((evp_md = get_hmac_alg(hmac_alg)) == 0) {
3919 coap_log_debug(
"coap_crypto_hmac: algorithm %d not supported\n", hmac_alg);
3925 result_len = (
unsigned int)
dummy->length;
3933 dummy->length = result_len;
3938 coap_crypto_output_errors(
"coap_crypto_hmac");
3950#pragma GCC diagnostic ignored "-Wunused-function"
Pulls together all the internal only header files.
#define COAP_RXBUFFER_SIZE
#define COAP_SOCKET_WANT_READ
non blocking socket is waiting for reading
#define COAP_SOCKET_WANT_WRITE
non blocking socket is waiting for writing
void coap_epoll_ctl_mod(coap_socket_t *sock, uint32_t events, const char *func)
Epoll specific function to modify the state of events that epoll is tracking on the appropriate file ...
void * coap_malloc_type(coap_memory_tag_t type, size_t size)
Allocates a chunk of size bytes and returns a pointer to the newly allocated memory.
void coap_free_type(coap_memory_tag_t type, void *p)
Releases the memory that was allocated by coap_malloc_type().
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)
static coap_log_t dtls_log_level
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.
coap_tick_t coap_ticks_from_rt_us(uint64_t t)
Helper function that converts POSIX wallclock time in us to coap ticks.
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_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.
int coap_handle_event(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_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.
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.
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.
const coap_bin_const_t * coap_get_session_server_psk_key(const coap_session_t *coap_session)
Get the current server's PSK key.
const coap_bin_const_t * coap_get_session_server_psk_hint(const coap_session_t *coap_session)
Get the current server's PSK identity hint.
#define COAP_DTLS_HINT_LENGTH
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_DTLS_ROLE_SERVER
Internal function invoked for server.
@ COAP_DTLS_ROLE_CLIENT
Internal function invoked for client.
@ COAP_PKI_KEY_PKCS11
The PKI key type is PKCS11 (DER)
@ COAP_PKI_KEY_PEM_BUF
The PKI key type is PEM buffer.
@ COAP_PKI_KEY_PEM
The PKI key type is PEM file.
@ COAP_PKI_KEY_ASN1
The PKI key type is ASN.1 (DER) buffer.
@ COAP_ASN1_PKEY_DH
DH type.
@ COAP_ASN1_PKEY_NONE
NONE.
@ COAP_ASN1_PKEY_TLS1_PRF
TLS1_PRF type.
@ COAP_ASN1_PKEY_RSA2
RSA2 type.
@ COAP_ASN1_PKEY_DSA
DSA type.
@ COAP_ASN1_PKEY_DHX
DHX type.
@ COAP_ASN1_PKEY_DSA4
DSA4 type.
@ COAP_ASN1_PKEY_DSA2
DSA2 type.
@ COAP_ASN1_PKEY_RSA
RSA type.
@ COAP_ASN1_PKEY_DSA1
DSA1 type.
@ COAP_ASN1_PKEY_HKDF
HKDF type.
@ COAP_ASN1_PKEY_EC
EC type.
@ COAP_ASN1_PKEY_DSA3
DSA3 type.
@ COAP_ASN1_PKEY_HMAC
HMAC type.
@ COAP_ASN1_PKEY_CMAC
CMAC type.
@ COAP_TLS_LIBRARY_OPENSSL
Using OpenSSL library.
@ COAP_EVENT_DTLS_CLOSED
Triggerred when (D)TLS session closed.
@ COAP_EVENT_DTLS_CONNECTED
Triggered when (D)TLS session connected.
@ COAP_EVENT_DTLS_RENEGOTIATE
Triggered when (D)TLS session renegotiated.
@ COAP_EVENT_DTLS_ERROR
Triggered when (D)TLS error occurs.
#define coap_log_debug(...)
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(level,...)
Logging function.
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_64
@ 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.
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).
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(coap_session_t *session, coap_nack_reason_t reason)
Notify session that it has failed.
@ COAP_SESSION_STATE_HANDSHAKE
coap_binary_t * coap_new_binary(size_t size)
Returns a new binary object with at least size bytes storage allocated.
void coap_delete_binary(coap_binary_t *s)
Deletes the given coap_binary_t object and releases any memory allocated.
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 that holds the Client PSK information.
coap_bin_const_t identity
The structure used for defining the Client PSK setup data to be used.
void * ih_call_back_arg
Passed in to the Identity Hint callback function.
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_pem_t pem
for PEM file keys
coap_pki_key_pkcs11_t pkcs11
for PKCS11 keys
union coap_dtls_key_t::@3 key
coap_pki_key_pem_buf_t pem_buf
for PEM memory keys
coap_pki_key_t key_type
key format type
coap_pki_key_asn1_t asn1
for ASN.1 (DER) memory keys
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 cert_chain_validation
1 if to check cert_chain_verify_depth
uint8_t check_cert_revocation
1 if revocation checks wanted
coap_dtls_pki_sni_callback_t validate_sni_call_back
SNI check callback function.
uint8_t cert_chain_verify_depth
recommended depth is 3
coap_dtls_security_setup_t additional_tls_setup_call_back
Additional Security callback handler that is invoked when libcoap has done the standard,...
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.
char * client_sni
If not NULL, SNI to use in client TLS setup.
uint8_t allow_self_signed
1 if self-signed certs are allowed.
void * sni_call_back_arg
Passed in to the sni callback function.
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
coap_dtls_key_t pki_key
PKI key definition.
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_dtls_spsk_info_t psk_info
Server PSK definition.
coap_layer_write_t l_write
coap_layer_establish_t l_establish
const uint8_t * private_key
ASN1 (DER) Private Key.
coap_asn1_privatekey_type_t private_key_type
Private Key Type.
size_t public_cert_len
ASN1 Public Cert length.
size_t private_key_len
ASN1 Private Key length.
const uint8_t * ca_cert
ASN1 (DER) Common CA Cert.
size_t ca_cert_len
ASN1 CA Cert length.
const uint8_t * public_cert
ASN1 (DER) Public Cert, or Public Key if RPK.
size_t ca_cert_len
PEM buffer CA Cert length.
const uint8_t * ca_cert
PEM buffer Common CA Cert.
size_t private_key_len
PEM buffer Private Key length.
const uint8_t * private_key
PEM buffer Private Key If RPK and 'EC PRIVATE KEY' this can be used for both the public_cert and priv...
size_t public_cert_len
PEM buffer Public Cert length.
const uint8_t * public_cert
PEM buffer Public Cert, or Public Key if RPK.
const char * ca_file
File location of Common CA in PEM format.
const char * public_cert
File location of Public Cert.
const char * private_key
File location of Private Key in PEM format.
const char * private_key
pkcs11: URI for Private Key
const char * ca
pkcs11: URI for Common CA Certificate
const char * user_pin
User pin to access PKCS11.
const char * public_cert
pkcs11: URI for Public Cert
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_bin_const_t * psk_key
If client, this field contains the current pre-shared key for server; When this field is NULL,...
coap_socket_t sock
socket object for the session, if any
coap_session_state_t state
current state of relationship with peer
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
CoAP string data definition with const data.
const uint8_t * s
read-only string data
size_t length
length of string
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