edhoc 1.0.4 → 1.1.0

package/external/libedhoc/include/edhoc_ead.h

@@ -2,8 +2,8 @@
  * \file    edhoc_ead.h
  * \author  Kamil Kielbasa
  * \brief   EDHOC External Authorization Data (EAD) interface.
- * \version 0.4
- * \date    2024-01-01
+ * \version 0.6
+ * \date    2024-08-05
  * 
  * \copyright Copyright (c) 2024
  * 
@@ -62,9 +62,11 @@ struct edhoc_ead_token {
  *
  * \return EDHOC_SUCCESS on success, otherwise failure.
  */
-typedef int (*edhoc_ead_compose)(void *user_context, enum edhoc_message message,
-				 struct edhoc_ead_token *ead_token,
-				 size_t ead_token_size, size_t *ead_token_len);
+typedef int (*edhoc_ead_compose_t)(void *user_context,
+				   enum edhoc_message message,
+				   struct edhoc_ead_token *ead_token,
+				   size_t ead_token_size,
+				   size_t *ead_token_len);
 
 /** 
  * \brief Callback for external authorization data (EAD) processing.
@@ -76,18 +78,19 @@ typedef int (*edhoc_ead_compose)(void *user_context, enum edhoc_message message,
  *
  * \return EDHOC_SUCCESS on success, otherwise failure.
  */
-typedef int (*edhoc_ead_process)(void *user_context, enum edhoc_message message,
-				 const struct edhoc_ead_token *ead_token,
-				 size_t ead_token_size);
+typedef int (*edhoc_ead_process_t)(void *user_context,
+				   enum edhoc_message message,
+				   const struct edhoc_ead_token *ead_token,
+				   size_t ead_token_size);
 
 /**
  * \brief Bind structure for EAD operations.
  */
 struct edhoc_ead {
 	/** External authorization data compose callback. */
-	edhoc_ead_compose compose;
+	edhoc_ead_compose_t compose;
 	/** External authorization data process callback. */
-	edhoc_ead_process process;
+	edhoc_ead_process_t process;
 };
 
 /**@}*/

package/external/libedhoc/include/edhoc_macros.h

@@ -2,8 +2,8 @@
  * \file    edhoc_macros.h
  * \author  Kamil Kielbasa
  * \brief   EDHOC macros and functionlike macros.
- * \version 0.4
- * \date    2024-01-01
+ * \version 0.6
+ * \date    2024-08-05
  * 
  * \copyright Copyright (c) 2024
  * 
@@ -14,26 +14,35 @@
 #define EDHOC_MACROS_H
 
 /* Include files ----------------------------------------------------------- */
+#include <stddef.h>
+
 /* Defines ----------------------------------------------------------------- */
 /* Types and type definitions ---------------------------------------------- */
 
+/**
+ * \brief Macros for hiding dynamic stack allocations:
+ *        - GCC and Clang support C99 feature VLA. (Variable Length Array)
+ *        - MSVC supports only alloca. Lack of VLA.
+ */
 #if defined(_WIN32) || defined(_MSC_VER)
-    #include <malloc.h>
-    #define ALLOCATE_ARRAY(type, name, size) \
-        type *name = (type*)_alloca(size * sizeof(type)); \
-        size_t name##_size = size * sizeof(type)
-    #define ALLOCATE_ARRAY_SIZEOF(name) name##_size
+#include <malloc.h>
+#define VLA_ALLOC(type, name, size)                \
+	type *name = _alloca(size * sizeof(type)); \
+	const size_t name##_size = size * sizeof(type)
+#define VLA_SIZEOF(name) name##_size
 #else
-    #define ALLOCATE_ARRAY(type, name, size) \
-        type name[size]
-    #define ALLOCATE_ARRAY_SIZEOF(name) sizeof(name)
+#define VLA_ALLOC(type, name, size) type name[size]
+#define VLA_SIZEOF(name) sizeof(name)
 #endif
 
+#define VLA_SIZE(x) (VLA_SIZEOF(x) / sizeof(x[0]))
+
 /**
  * \brief Macro for calculating arrays length.
  */
+#ifndef ARRAY_SIZE
 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
-#define ARRAY_SIZE_VLA(x) (ALLOCATE_ARRAY_SIZEOF(x) / sizeof(x[0]))
+#endif
 
 /**
  * \brief Macro which allows for private access into structure members.

package/external/libedhoc/include/edhoc_values.h

@@ -2,8 +2,8 @@
  * \file    edhoc_values.h
  * \author  Kamil Kielbasa
  * \brief   EDHOC values and error codes.
- * \version 0.4
- * \date    2024-01-01
+ * \version 0.6
+ * \date    2024-08-05
  * 
  * \copyright Copyright (c) 2024
  * 

package/external/libedhoc/library/edhoc.c

@@ -2,8 +2,8 @@
  * \file    edhoc.c
  * \author  Kamil Kielbasa
  * \brief   EDHOC context.
- * \version 0.4
- * \date    2024-01-01
+ * \version 0.6
+ * \date    2024-08-05
  * 
  * \copyright Copyright (c) 2024
  * 
@@ -52,15 +52,18 @@ int edhoc_context_deinit(struct edhoc_context *ctx)
 	return EDHOC_SUCCESS;
 }
 
-int edhoc_set_method(struct edhoc_context *ctx, enum edhoc_method method)
+int edhoc_set_methods(struct edhoc_context *ctx,
+		      const enum edhoc_method *method, size_t method_len)
 {
-	if (NULL == ctx)
+	if (NULL == ctx || NULL == method || 0 == method_len ||
+	    EDHOC_METHOD_MAX < method_len)
 		return EDHOC_ERROR_INVALID_ARGUMENT;
 
 	if (!ctx->is_init)
 		return EDHOC_ERROR_BAD_STATE;
 
-	ctx->method = method;
+	ctx->method_len = method_len;
+	memcpy(ctx->method, method, sizeof(*method) * method_len);
 
 	return EDHOC_SUCCESS;
 }
@@ -69,14 +72,14 @@ int edhoc_set_cipher_suites(struct edhoc_context *ctx,
 			    const struct edhoc_cipher_suite *csuite,
 			    size_t csuite_len)
 {
-	if (NULL == ctx)
+	if (NULL == ctx || NULL == csuite || 0 == csuite_len)
 		return EDHOC_ERROR_INVALID_ARGUMENT;
 
 	if (!ctx->is_init)
 		return EDHOC_ERROR_BAD_STATE;
 
-	if (0 == csuite_len || ARRAY_SIZE(ctx->csuite) < csuite_len)
-		return EDHOC_ERROR_INVALID_ARGUMENT;
+	if (ARRAY_SIZE(ctx->csuite) < csuite_len)
+		return EDHOC_ERROR_BAD_STATE;
 
 	ctx->csuite_len = csuite_len;
 	memcpy(ctx->csuite, csuite, sizeof(*csuite) * csuite_len);
@@ -85,34 +88,34 @@ int edhoc_set_cipher_suites(struct edhoc_context *ctx,
 }
 
 int edhoc_set_connection_id(struct edhoc_context *ctx,
-			    struct edhoc_connection_id cid)
+			    const struct edhoc_connection_id *cid)
 {
-	if (NULL == ctx)
+	if (NULL == ctx || NULL == cid)
 		return EDHOC_ERROR_INVALID_ARGUMENT;
 
 	if (!ctx->is_init)
 		return EDHOC_ERROR_BAD_STATE;
 
-	switch (cid.encode_type) {
+	switch (cid->encode_type) {
 	case EDHOC_CID_TYPE_ONE_BYTE_INTEGER:
-		if (ONE_BYTE_CBOR_INT_MIN_VALUE > cid.int_value ||
-		    ONE_BYTE_CBOR_INT_MAX_VALUE < cid.int_value)
-			return EDHOC_ERROR_INVALID_ARGUMENT;
+		if (ONE_BYTE_CBOR_INT_MIN_VALUE > cid->int_value ||
+		    ONE_BYTE_CBOR_INT_MAX_VALUE < cid->int_value)
+			return EDHOC_ERROR_BAD_STATE;
 		break;
 
 	case EDHOC_CID_TYPE_BYTE_STRING:
-		if (0 == cid.bstr_length)
-			return EDHOC_ERROR_INVALID_ARGUMENT;
+		if (0 == cid->bstr_length)
+			return EDHOC_ERROR_BAD_STATE;
 
-		if (EDHOC_MAX_CID_LEN < cid.bstr_length)
-			return EDHOC_ERROR_INVALID_ARGUMENT;
+		if (CONFIG_LIBEDHOC_MAX_LEN_OF_CONN_ID < cid->bstr_length)
+			return EDHOC_ERROR_BAD_STATE;
 		break;
 
 	default:
 		return EDHOC_ERROR_BAD_STATE;
 	}
 
-	ctx->cid = cid;
+	ctx->cid = *cid;
 
 	return EDHOC_SUCCESS;
 }
@@ -130,58 +133,72 @@ int edhoc_set_user_context(struct edhoc_context *ctx, void *user_ctx)
 	return EDHOC_SUCCESS;
 }
 
-int edhoc_bind_ead(struct edhoc_context *ctx, struct edhoc_ead ead)
+int edhoc_bind_ead(struct edhoc_context *ctx, const struct edhoc_ead *ead)
 {
-	if (NULL == ctx)
+	if (NULL == ctx || NULL == ead)
 		return EDHOC_ERROR_INVALID_ARGUMENT;
 
 	if (!ctx->is_init)
 		return EDHOC_ERROR_BAD_STATE;
 
-	if (NULL == ead.compose && NULL == ead.process)
-		return EDHOC_ERROR_INVALID_ARGUMENT;
+	if (NULL == ead->compose && NULL == ead->process)
+		return EDHOC_ERROR_BAD_STATE;
 
-	ctx->ead = ead;
+	ctx->ead = *ead;
 
 	return EDHOC_SUCCESS;
 }
 
-int edhoc_bind_keys(struct edhoc_context *ctx, struct edhoc_keys keys)
+int edhoc_bind_keys(struct edhoc_context *ctx, const struct edhoc_keys *keys)
 {
-	if (NULL == ctx)
+	if (NULL == ctx || NULL == keys)
 		return EDHOC_ERROR_INVALID_ARGUMENT;
 
 	if (!ctx->is_init)
 		return EDHOC_ERROR_BAD_STATE;
 
-	ctx->keys = keys;
+	if (NULL == keys->import_key || NULL == keys->destroy_key)
+		return EDHOC_ERROR_BAD_STATE;
+
+	ctx->keys = *keys;
 
 	return EDHOC_SUCCESS;
 }
 
-int edhoc_bind_crypto(struct edhoc_context *ctx, struct edhoc_crypto crypto)
+int edhoc_bind_crypto(struct edhoc_context *ctx,
+		      const struct edhoc_crypto *crypto)
 {
-	if (NULL == ctx)
+	if (NULL == ctx || NULL == crypto)
 		return EDHOC_ERROR_INVALID_ARGUMENT;
 
 	if (!ctx->is_init)
 		return EDHOC_ERROR_BAD_STATE;
 
-	ctx->crypto = crypto;
+	if (NULL == crypto->make_key_pair || NULL == crypto->key_agreement ||
+	    NULL == crypto->signature || NULL == crypto->verify ||
+	    NULL == crypto->extract || NULL == crypto->expand ||
+	    NULL == crypto->encrypt || NULL == crypto->decrypt ||
+	    NULL == crypto->hash)
+		return EDHOC_ERROR_BAD_STATE;
+
+	ctx->crypto = *crypto;
 
 	return EDHOC_SUCCESS;
 }
 
 int edhoc_bind_credentials(struct edhoc_context *ctx,
-			   struct edhoc_credentials cred)
+			   const struct edhoc_credentials *cred)
 {
-	if (NULL == ctx)
+	if (NULL == ctx || NULL == cred)
 		return EDHOC_ERROR_INVALID_ARGUMENT;
 
 	if (!ctx->is_init)
 		return EDHOC_ERROR_BAD_STATE;
 
-	ctx->cred = cred;
+	if (NULL == cred->fetch || NULL == cred->verify)
+		return EDHOC_ERROR_BAD_STATE;
+
+	ctx->cred = *cred;
 
 	return EDHOC_SUCCESS;
 }
@@ -192,22 +209,31 @@ int edhoc_error_get_code(const struct edhoc_context *ctx,
 	if (NULL == ctx || NULL == code)
 		return EDHOC_ERROR_INVALID_ARGUMENT;
 
+	if (!ctx->is_init)
+		return EDHOC_ERROR_BAD_STATE;
+
 	*code = ctx->error_code;
 	return EDHOC_SUCCESS;
 }
 
 int edhoc_error_get_cipher_suites(const struct edhoc_context *ctx,
 				  int32_t *csuites, size_t csuites_size,
-				  size_t *csuites_len)
+				  size_t *csuites_len, int32_t *peer_csuites,
+				  size_t peer_csuites_size,
+				  size_t *peer_csuites_len)
 {
 	if (NULL == ctx || NULL == csuites || 0 == csuites_size ||
-	    NULL == csuites_len)
+	    NULL == csuites_len || NULL == peer_csuites ||
+	    0 == peer_csuites_size || NULL == peer_csuites_len)
 		return EDHOC_ERROR_INVALID_ARGUMENT;
 
+	if (!ctx->is_init)
+		return EDHOC_ERROR_BAD_STATE;
+
 	if (EDHOC_ERROR_CODE_WRONG_SELECTED_CIPHER_SUITE != ctx->error_code)
 		return EDHOC_ERROR_BAD_STATE;
 
-	if (ctx->csuite_len < csuites_size)
+	if (csuites_size < ctx->csuite_len)
 		return EDHOC_ERROR_BUFFER_TOO_SMALL;
 
 	*csuites_len = ctx->csuite_len;
@@ -215,5 +241,13 @@ int edhoc_error_get_cipher_suites(const struct edhoc_context *ctx,
 	for (size_t i = 0; i < ctx->csuite_len; ++i)
 		csuites[i] = ctx->csuite[i].value;
 
+	if (peer_csuites_size < ctx->peer_csuite_len)
+		return EDHOC_ERROR_BUFFER_TOO_SMALL;
+
+	*peer_csuites_len = ctx->peer_csuite_len;
+
+	for (size_t i = 0; i < ctx->peer_csuite_len; ++i)
+		peer_csuites[i] = ctx->peer_csuite[i].value;
+
 	return EDHOC_SUCCESS;
 }