edhoc 1.0.4 → 1.1.0

package/external/libedhoc/tests/src/module_test_cipher_suite_2.c

@@ -0,0 +1,392 @@
+/**
+ * \file    module_test_cipher_suite_2.c
+ * \author  Kamil Kielbasa
+ * \brief   Module tests for cipher suite 2.
+ * \version 0.6
+ * \date    2024-08-05
+ * 
+ * \copyright Copyright (c) 2024
+ * 
+ */
+
+/* Include files ----------------------------------------------------------- */
+
+/* Cipher suite 0 header: */
+#include "cipher_suite_2.h"
+
+/* Standard library headers: */
+#include <stdint.h>
+#include <stddef.h>
+#include <string.h>
+
+/* EDHOC headers: */
+#include <edhoc_crypto.h>
+#include <edhoc_values.h>
+#include <edhoc_macros.h>
+
+/* Unity headers: */
+#include <unity.h>
+#include <unity_fixture.h>
+
+/* PSA crypto header: */
+#include <psa/crypto.h>
+
+/* Module defines ---------------------------------------------------------- */
+#define INPUT_TO_SIGN_LEN ((size_t)128)
+
+/* Module types and type definitiones -------------------------------------- */
+/* Module interface variables and constants -------------------------------- */
+/* Static variables and constants ------------------------------------------ */
+static const struct edhoc_keys keys = {
+	.import_key = cipher_suite_2_key_import,
+	.destroy_key = cipher_suite_2_key_destroy,
+};
+
+static const struct edhoc_crypto crypto = {
+	.make_key_pair = cipher_suite_2_make_key_pair,
+	.key_agreement = cipher_suite_2_key_agreement,
+	.signature = cipher_suite_2_signature,
+	.verify = cipher_suite_2_verify,
+	.extract = cipher_suite_2_extract,
+	.expand = cipher_suite_2_expand,
+	.encrypt = cipher_suite_2_encrypt,
+	.decrypt = cipher_suite_2_decrypt,
+	.hash = cipher_suite_2_hash,
+};
+
+static const struct edhoc_keys *edhoc_keys = &keys;
+static const struct edhoc_crypto *edhoc_crypto = &crypto;
+
+static int ret = EDHOC_ERROR_GENERIC_ERROR;
+
+/* Static function declarations -------------------------------------------- */
+/* Static function definitions --------------------------------------------- */
+/* Module interface function definitions ----------------------------------- */
+
+TEST_GROUP(cipher_suite_2);
+
+TEST_SETUP(cipher_suite_2)
+{
+	TEST_ASSERT_EQUAL(PSA_SUCCESS, psa_crypto_init());
+}
+
+TEST_TEAR_DOWN(cipher_suite_2)
+{
+	mbedtls_psa_crypto_free();
+}
+
+TEST(cipher_suite_2, ecdsa)
+{
+	psa_key_id_t key_id = PSA_KEY_HANDLE_INIT;
+
+	const uint8_t priv_key[ECC_COMP_KEY_LEN] = {
+		0xfb, 0x13, 0xad, 0xeb, 0x65, 0x18, 0xce, 0xe5,
+		0xf8, 0x84, 0x17, 0x66, 0x08, 0x41, 0x14, 0x2e,
+		0x83, 0x0a, 0x81, 0xfe, 0x33, 0x43, 0x80, 0xa9,
+		0x53, 0x40, 0x6a, 0x13, 0x05, 0xe8, 0x70, 0x6b,
+	};
+
+	const uint8_t pub_key[ECC_UNCOMP_KEY_LEN] = {
+		0x04,
+
+		0xac, 0x75, 0xe9, 0xec, 0xe3, 0xe5, 0x0b, 0xfc,
+		0x8e, 0xd6, 0x03, 0x99, 0x88, 0x95, 0x22, 0x40,
+		0x5c, 0x47, 0xbf, 0x16, 0xdf, 0x96, 0x66, 0x0a,
+		0x41, 0x29, 0x8c, 0xb4, 0x30, 0x7f, 0x7e, 0xb6,
+
+		0x6e, 0x5d, 0xe6, 0x11, 0x38, 0x8a, 0x4b, 0x8a,
+		0x82, 0x11, 0x33, 0x4a, 0xc7, 0xd3, 0x7e, 0xcb,
+		0x52, 0xa3, 0x87, 0xd2, 0x57, 0xe6, 0xdb, 0x3c,
+		0x2a, 0x93, 0xdf, 0x21, 0xff, 0x3a, 0xff, 0xc8,
+	};
+
+	/* Random input for signature. */
+	uint8_t input[INPUT_TO_SIGN_LEN] = { 0 };
+	ret = psa_generate_random(input, ARRAY_SIZE(input));
+	TEST_ASSERT_EQUAL(PSA_SUCCESS, ret);
+
+	/* Generate signature. */
+	size_t sign_len = 0;
+	uint8_t sign[ECC_ECDSA_SIGN_LEN] = { 0 };
+
+	ret = edhoc_keys->import_key(NULL, EDHOC_KT_SIGNATURE, priv_key,
+				     ARRAY_SIZE(priv_key), &key_id);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+
+	ret = edhoc_crypto->signature(NULL, &key_id, input, ARRAY_SIZE(input),
+				      sign, ARRAY_SIZE(sign), &sign_len);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+
+	ret = edhoc_keys->destroy_key(NULL, &key_id);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+
+	/* Verify signature. */
+	ret = edhoc_keys->import_key(NULL, EDHOC_KT_VERIFY, pub_key,
+				     ARRAY_SIZE(pub_key), &key_id);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+
+	ret = edhoc_crypto->verify(NULL, &key_id, input, ARRAY_SIZE(input),
+				   sign, sign_len);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+
+	ret = edhoc_keys->destroy_key(NULL, &key_id);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+}
+
+TEST(cipher_suite_2, ecdh)
+{
+	psa_key_id_t key_id_a = PSA_KEY_HANDLE_INIT;
+	psa_key_id_t key_id_b = PSA_KEY_HANDLE_INIT;
+
+	/* Alice ECDH public and private keys. */
+	size_t priv_key_len_a = 0;
+	uint8_t priv_key_a[ECC_COMP_KEY_LEN] = { 0 };
+
+	size_t pub_key_len_a = 0;
+	uint8_t pub_key_a[ECC_COMP_KEY_LEN] = { 0 };
+
+	ret = edhoc_keys->import_key(NULL, EDHOC_KT_MAKE_KEY_PAIR, NULL, 0,
+				     &key_id_a);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+
+	ret = edhoc_crypto->make_key_pair(NULL, &key_id_a, priv_key_a,
+					  ARRAY_SIZE(priv_key_a),
+					  &priv_key_len_a, pub_key_a,
+					  ARRAY_SIZE(pub_key_a),
+					  &pub_key_len_a);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+	TEST_ASSERT_EQUAL(ARRAY_SIZE(priv_key_a), priv_key_len_a);
+	TEST_ASSERT_EQUAL(ARRAY_SIZE(pub_key_a), pub_key_len_a);
+
+	ret = edhoc_keys->destroy_key(NULL, &key_id_a);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+
+	/* Bob ECDH public and private keys. */
+	size_t priv_key_len_b = 0;
+	uint8_t priv_key_b[ECC_COMP_KEY_LEN] = { 0 };
+
+	size_t pub_key_len_b = 0;
+	uint8_t pub_key_b[ECC_COMP_KEY_LEN] = { 0 };
+
+	ret = edhoc_keys->import_key(NULL, EDHOC_KT_MAKE_KEY_PAIR, NULL, 0,
+				     &key_id_b);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+
+	ret = edhoc_crypto->make_key_pair(NULL, &key_id_b, priv_key_b,
+					  ARRAY_SIZE(priv_key_b),
+					  &priv_key_len_b, pub_key_b,
+					  ARRAY_SIZE(pub_key_b),
+					  &pub_key_len_b);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+	TEST_ASSERT_EQUAL(ARRAY_SIZE(priv_key_b), priv_key_len_b);
+	TEST_ASSERT_EQUAL(ARRAY_SIZE(pub_key_b), pub_key_len_b);
+
+	ret = edhoc_keys->destroy_key(NULL, &key_id_b);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+
+	/* Shared secret for Alice. */
+	size_t shr_sec_len_a = 0;
+	uint8_t shr_sec_a[ECC_ECDH_KEY_AGREEMENT_LEN] = { 0 };
+
+	ret = edhoc_keys->import_key(NULL, EDHOC_KT_KEY_AGREEMENT, priv_key_a,
+				     priv_key_len_a, &key_id_a);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+
+	ret = edhoc_crypto->key_agreement(NULL, &key_id_a, pub_key_b,
+					  pub_key_len_b, shr_sec_a,
+					  ARRAY_SIZE(shr_sec_a),
+					  &shr_sec_len_a);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+	TEST_ASSERT_EQUAL(ARRAY_SIZE(shr_sec_a), shr_sec_len_a);
+
+	ret = edhoc_keys->destroy_key(NULL, &key_id_a);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+
+	/* Shared secret for Bob. */
+	size_t shr_sec_len_b = 0;
+	uint8_t shr_sec_b[ECC_ECDH_KEY_AGREEMENT_LEN] = { 0 };
+
+	ret = edhoc_keys->import_key(NULL, EDHOC_KT_KEY_AGREEMENT, priv_key_b,
+				     priv_key_len_b, &key_id_b);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+
+	ret = edhoc_crypto->key_agreement(NULL, &key_id_b, pub_key_a,
+					  pub_key_len_a, shr_sec_b,
+					  ARRAY_SIZE(shr_sec_b),
+					  &shr_sec_len_b);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+	TEST_ASSERT_EQUAL(ARRAY_SIZE(shr_sec_b), shr_sec_len_b);
+
+	ret = edhoc_keys->destroy_key(NULL, &key_id_b);
+	TEST_ASSERT_EQUAL(PSA_SUCCESS, ret);
+
+	/* Compare if Alice and Bob has the same shared secrets. */
+	TEST_ASSERT_EQUAL(shr_sec_len_a, shr_sec_len_b);
+	TEST_ASSERT_EQUAL_UINT8_ARRAY(shr_sec_a, shr_sec_b, shr_sec_len_a);
+}
+
+TEST(cipher_suite_2, hkdf)
+{
+	psa_key_id_t key_id = PSA_KEY_HANDLE_INIT;
+
+	/* Test vectors taken from RFC 5869: A.1. Test Case 1. */
+	const uint8_t ikm[] = {
+		0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+		0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+		0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+	};
+
+	const uint8_t salt[] = {
+		0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
+		0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c,
+	};
+
+	const uint8_t info[] = {
+		0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9,
+	};
+
+	const size_t L = 42;
+
+	const uint8_t prk[] = {
+		0x07, 0x77, 0x09, 0x36, 0x2c, 0x2e, 0x32, 0xdf,
+		0x0d, 0xdc, 0x3f, 0x0d, 0xc4, 0x7b, 0xba, 0x63,
+		0x90, 0xb6, 0xc7, 0x3b, 0xb5, 0x0f, 0x9c, 0x31,
+		0x22, 0xec, 0x84, 0x4a, 0xd7, 0xc2, 0xb3, 0xe5,
+	};
+
+	const uint8_t okm[] = {
+		0x3c, 0xb2, 0x5f, 0x25, 0xfa, 0xac, 0xd5, 0x7a, 0x90,
+		0x43, 0x4f, 0x64, 0xd0, 0x36, 0x2f, 0x2a, 0x2d, 0x2d,
+		0x0a, 0x90, 0xcf, 0x1a, 0x5a, 0x4c, 0x5d, 0xb0, 0x2d,
+		0x56, 0xec, 0xc4, 0xc5, 0xbf, 0x34, 0x00, 0x72, 0x08,
+		0xd5, 0xb8, 0x87, 0x18, 0x58, 0x65,
+	};
+
+	/* HDFK extract part. */
+	size_t comp_prk_len = 0;
+	uint8_t comp_prk[32] = { 0 };
+
+	ret = edhoc_keys->import_key(NULL, EDHOC_KT_EXTRACT, ikm,
+				     ARRAY_SIZE(ikm), &key_id);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+
+	ret = edhoc_crypto->extract(NULL, &key_id, salt, ARRAY_SIZE(salt),
+				    comp_prk, ARRAY_SIZE(comp_prk),
+				    &comp_prk_len);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+	TEST_ASSERT_EQUAL(ARRAY_SIZE(comp_prk), comp_prk_len);
+
+	ret = edhoc_keys->destroy_key(NULL, &key_id);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+
+	TEST_ASSERT_EQUAL(ARRAY_SIZE(prk), comp_prk_len);
+	TEST_ASSERT_EQUAL_UINT8_ARRAY(comp_prk, prk, comp_prk_len);
+
+	/* HDFK expand part. */
+	uint8_t comp_okm[L];
+	memset(comp_okm, 0, sizeof(comp_okm));
+
+	ret = edhoc_keys->import_key(NULL, EDHOC_KT_EXPAND, comp_prk,
+				     ARRAY_SIZE(comp_prk), &key_id);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+
+	ret = edhoc_crypto->expand(NULL, &key_id, info, ARRAY_SIZE(info),
+				   comp_okm, ARRAY_SIZE(comp_okm));
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+
+	ret = edhoc_keys->destroy_key(NULL, &key_id);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+
+	TEST_ASSERT_EQUAL_UINT8_ARRAY(comp_okm, okm, ARRAY_SIZE(okm));
+}
+
+TEST(cipher_suite_2, aead)
+{
+	psa_key_id_t key_id = PSA_KEY_HANDLE_INIT;
+
+	/* AEAD key, iv and aad. */
+	const uint8_t key[16] = {
+		0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3,
+	};
+	const uint8_t iv[13] = {
+		0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2,
+	};
+	const uint8_t aad[4] = {
+		0,
+		1,
+		2,
+		3,
+	};
+
+	/* AEAD encryption. */
+	const uint8_t ptxt[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+
+	ret = edhoc_keys->import_key(NULL, EDHOC_KT_ENCRYPT, key,
+				     ARRAY_SIZE(key), &key_id);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+
+	size_t ctxt_len = 0;
+	uint8_t ctxt[18] = { 0 };
+	ret = edhoc_crypto->encrypt(NULL, &key_id, iv, ARRAY_SIZE(iv), aad,
+				    ARRAY_SIZE(aad), ptxt, ARRAY_SIZE(ptxt),
+				    ctxt, ARRAY_SIZE(ctxt), &ctxt_len);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+	TEST_ASSERT_EQUAL(ARRAY_SIZE(ctxt), ctxt_len);
+
+	ret = edhoc_keys->destroy_key(NULL, &key_id);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+
+	/* AEAD decryption. */
+	size_t dec_ctxt_len = 0;
+	uint8_t dec_ctxt[ARRAY_SIZE(ptxt)] = { 0 };
+
+	ret = edhoc_keys->import_key(NULL, EDHOC_KT_DECRYPT, key,
+				     ARRAY_SIZE(key), &key_id);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+
+	ret = edhoc_crypto->decrypt(NULL, &key_id, iv, ARRAY_SIZE(iv), aad,
+				    ARRAY_SIZE(aad), ctxt, ctxt_len, dec_ctxt,
+				    ARRAY_SIZE(dec_ctxt), &dec_ctxt_len);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+	TEST_ASSERT_EQUAL(ARRAY_SIZE(ptxt), dec_ctxt_len);
+
+	ret = edhoc_keys->destroy_key(NULL, &key_id);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+
+	/* Verify if plaintext is equal to decrypted ciphertext. */
+	TEST_ASSERT_EQUAL_UINT8_ARRAY(ptxt, dec_ctxt, ARRAY_SIZE(ptxt));
+}
+
+TEST(cipher_suite_2, hash)
+{
+	/* Input for hash function and expected hash. */
+	const uint8_t input[] = { 'A' };
+
+	const uint8_t exp_hash[32] = {
+		0x55, 0x9a, 0xea, 0xd0, 0x82, 0x64, 0xd5, 0x79,
+		0x5d, 0x39, 0x09, 0x71, 0x8c, 0xdd, 0x05, 0xab,
+		0xd4, 0x95, 0x72, 0xe8, 0x4f, 0xe5, 0x55, 0x90,
+		0xee, 0xf3, 0x1a, 0x88, 0xa0, 0x8f, 0xdf, 0xfd,
+	};
+
+	/* Hashing operation. */
+	size_t hash_len = 0;
+	uint8_t hash[32] = { 0 };
+
+	ret = edhoc_crypto->hash(NULL, input, ARRAY_SIZE(input), hash,
+				 ARRAY_SIZE(hash), &hash_len);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+	TEST_ASSERT_EQUAL(ARRAY_SIZE(hash), hash_len);
+
+	/* Verify if hashes are equals. */
+	TEST_ASSERT_EQUAL_UINT8_ARRAY(hash, exp_hash, ARRAY_SIZE(exp_hash));
+}
+
+TEST_GROUP_RUNNER(cipher_suite_2)
+{
+	RUN_TEST_CASE(cipher_suite_2, ecdsa);
+	RUN_TEST_CASE(cipher_suite_2, ecdh);
+	RUN_TEST_CASE(cipher_suite_2, hkdf);
+	RUN_TEST_CASE(cipher_suite_2, aead);
+	RUN_TEST_CASE(cipher_suite_2, hash);
+}

package/external/libedhoc/tests/src/{error_message/test_edhoc_error_message.c → module_test_error_message.c}

@@ -1,9 +1,9 @@
 /**
- * \file    test_edhoc_error_message.c
+ * \file    module_test_error_message.c
  * \author  Kamil Kielbasa
- * \brief   EDHOC error message unit tests.
- * \version 0.4
- * \date    2024-01-01
+ * \brief   Module tests for EDHOC error message.
+ * \version 0.6
+ * \date    2024-08-05
  * 
  * \copyright Copyright (c) 2024
  * 
@@ -11,37 +11,42 @@
 
 /* Include files ----------------------------------------------------------- */
 
-/* Internal test headers: */
-#include "error_message/test_edhoc_error_message.h"
+/* EDHOC header: */
+#define EDHOC_ALLOW_PRIVATE_ACCESS
+#include <edhoc.h>
 
 /* Standard library headers: */
-#include <stdio.h>
 #include <stdint.h>
 #include <stddef.h>
 #include <string.h>
-#include <assert.h>
 
-/* EDHOC header: */
-#define EDHOC_ALLOW_PRIVATE_ACCESS
-#include "edhoc.h"
+/* Unity headers: */
+#include <unity.h>
+#include <unity_fixture.h>
 
 /* Module defines ---------------------------------------------------------- */
 /* Module types and type definitiones -------------------------------------- */
 /* Module interface variables and constants -------------------------------- */
 /* Static variables and constants ------------------------------------------ */
+
+static int ret = EDHOC_ERROR_GENERIC_ERROR;
+static enum edhoc_error_code recv_error_code = -1;
+
 /* Static function declarations -------------------------------------------- */
 
 /**
  * \brief Helper function for printing arrays.
  */
-static inline void print_array(const char *name, const uint8_t *buffer,
-			       size_t buffer_length);
+static inline void print_array(void *user_context, const char *name,
+			       const uint8_t *buffer, size_t buffer_length);
 
 /* Static function definitions --------------------------------------------- */
 
-static inline void print_array(const char *name, const uint8_t *buffer,
-			       size_t buffer_length)
+static inline void print_array(void *user_context, const char *name,
+			       const uint8_t *buffer, size_t buffer_length)
 {
+	(void)user_context;
+
 	printf("%s:\tLEN( %zu )\n", name, buffer_length);
 
 	for (size_t i = 0; i < buffer_length; ++i) {
@@ -57,32 +62,38 @@ static inline void print_array(const char *name, const uint8_t *buffer,
 
 /* Module interface function definitions ----------------------------------- */
 
-void test_edhoc_error_message_success(void)
+TEST_GROUP(error_message);
+
+TEST_SETUP(error_message)
+{
+}
+
+TEST_TEAR_DOWN(error_message)
 {
-	int ret = EDHOC_ERROR_GENERIC_ERROR;
+}
 
+TEST(error_message, success)
+{
 	size_t buffer_len = 0;
 	uint8_t buffer[100] = { 0 };
 
 	const enum edhoc_error_code error_code = EDHOC_ERROR_CODE_SUCCESS;
-
 	ret = edhoc_message_error_compose(buffer, ARRAY_SIZE(buffer),
 					  &buffer_len, error_code, NULL);
-	assert(EDHOC_SUCCESS == ret);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
 
-	print_array("error msg - success", buffer, buffer_len);
+#if defined(TEST_TRACES)
+	print_array(NULL, "error msg - success", buffer, buffer_len);
+#endif
 
-	enum edhoc_error_code recv_error_code = -1;
 	ret = edhoc_message_error_process(buffer, buffer_len, &recv_error_code,
 					  NULL);
-	assert(EDHOC_SUCCESS == ret);
-	assert(error_code == recv_error_code);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+	TEST_ASSERT_EQUAL(error_code, recv_error_code);
 }
 
-void test_edhoc_error_message_unspecified_error(void)
+TEST(error_message, unspecified_error)
 {
-	int ret = EDHOC_ERROR_GENERIC_ERROR;
-
 	size_t buffer_len = 0;
 	uint8_t buffer[100] = { 0 };
 
@@ -97,32 +108,36 @@ void test_edhoc_error_message_unspecified_error(void)
 
 	ret = edhoc_message_error_compose(buffer, ARRAY_SIZE(buffer),
 					  &buffer_len, error_code, &error_info);
-	assert(EDHOC_SUCCESS == ret);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
 
-	print_array("error msg - unspecified error", buffer, buffer_len);
+#if defined(TEST_TRACES)
+	print_array(NULL, "error msg - unspecified error", buffer, buffer_len);
+#endif
 
-	enum edhoc_error_code recv_error_code = -1;
 	char recv_text_string[100] = { 0 };
 	struct edhoc_error_info recv_error_info = {
 		.text_string = recv_text_string,
 		.total_entries = ARRAY_SIZE(recv_text_string),
 		.written_entries = 0,
 	};
+
 	ret = edhoc_message_error_process(buffer, buffer_len, &recv_error_code,
 					  &recv_error_info);
-	assert(EDHOC_SUCCESS == ret);
-	assert(error_code == recv_error_code);
-	assert(error_info.written_entries == recv_error_info.written_entries);
-	assert(0 == memcmp(error_info.text_string, recv_error_info.text_string,
-			   error_info.written_entries));
-
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+	TEST_ASSERT_EQUAL(error_code, recv_error_code);
+	TEST_ASSERT_EQUAL(error_info.written_entries,
+			  recv_error_info.written_entries);
+	TEST_ASSERT_EQUAL_UINT8_ARRAY(error_info.text_string,
+				      recv_error_info.text_string,
+				      error_info.written_entries);
+
+#if defined(TEST_TRACES)
 	printf("Received message: %s\n\n", error_info.text_string);
+#endif
 }
 
-void test_edhoc_error_message_wrong_selected_cipher_suite_one(void)
+TEST(error_message, wrong_selected_cipher_suite_one)
 {
-	int ret = EDHOC_ERROR_GENERIC_ERROR;
-
 	size_t buffer_len = 0;
 	uint8_t buffer[100] = { 0 };
 
@@ -137,33 +152,33 @@ void test_edhoc_error_message_wrong_selected_cipher_suite_one(void)
 
 	ret = edhoc_message_error_compose(buffer, ARRAY_SIZE(buffer),
 					  &buffer_len, error_code, &error_info);
-	assert(EDHOC_SUCCESS == ret);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
 
-	print_array("error msg - wrong selected cipher suite", buffer,
+#if defined(TEST_TRACES)
+	print_array(NULL, "error msg - wrong selected cipher suite", buffer,
 		    buffer_len);
+#endif
 
-	enum edhoc_error_code recv_error_code = -1;
 	int32_t recv_cipher_suites[10] = { 0 };
 	struct edhoc_error_info recv_error_info = {
 		.cipher_suites = recv_cipher_suites,
 		.total_entries = ARRAY_SIZE(recv_cipher_suites),
 		.written_entries = 0,
 	};
+
 	ret = edhoc_message_error_process(buffer, buffer_len, &recv_error_code,
 					  &recv_error_info);
-	assert(EDHOC_SUCCESS == ret);
-	assert(error_code == recv_error_code);
-	assert(recv_error_info.written_entries == error_info.written_entries);
-	assert(0 == memcmp(error_info.cipher_suites,
-			   recv_error_info.cipher_suites,
-			   error_info.written_entries *
-				   sizeof(*error_info.cipher_suites)));
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+	TEST_ASSERT_EQUAL(error_code, recv_error_code);
+	TEST_ASSERT_EQUAL(recv_error_info.written_entries,
+			  error_info.written_entries);
+	TEST_ASSERT_EQUAL_UINT8_ARRAY(
+		error_info.cipher_suites, recv_error_info.cipher_suites,
+		error_info.written_entries * sizeof(*error_info.cipher_suites));
 }
 
-void test_edhoc_error_message_wrong_selected_cipher_suite_many(void)
+TEST(error_message, wrong_selected_cipher_suite_many)
 {
-	int ret = EDHOC_ERROR_GENERIC_ERROR;
-
 	size_t buffer_len = 0;
 	uint8_t buffer[100] = { 0 };
 
@@ -178,33 +193,33 @@ void test_edhoc_error_message_wrong_selected_cipher_suite_many(void)
 
 	ret = edhoc_message_error_compose(buffer, ARRAY_SIZE(buffer),
 					  &buffer_len, error_code, &error_info);
-	assert(EDHOC_SUCCESS == ret);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
 
-	print_array("error msg - wrong selected cipher suite", buffer,
+#if defined(TEST_TRACES)
+	print_array(NULL, "error msg - wrong selected cipher suite", buffer,
 		    buffer_len);
+#endif
 
-	enum edhoc_error_code recv_error_code = -1;
 	int32_t recv_cipher_suites[10] = { 0 };
 	struct edhoc_error_info recv_error_info = {
 		.cipher_suites = recv_cipher_suites,
 		.total_entries = ARRAY_SIZE(recv_cipher_suites),
 		.written_entries = 0,
 	};
+
 	ret = edhoc_message_error_process(buffer, buffer_len, &recv_error_code,
 					  &recv_error_info);
-	assert(EDHOC_SUCCESS == ret);
-	assert(error_code == recv_error_code);
-	assert(recv_error_info.written_entries == error_info.written_entries);
-	assert(0 == memcmp(recv_error_info.cipher_suites,
-			   error_info.cipher_suites,
-			   error_info.written_entries *
-				   sizeof(*error_info.cipher_suites)));
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+	TEST_ASSERT_EQUAL(error_code, recv_error_code);
+	TEST_ASSERT_EQUAL(recv_error_info.written_entries,
+			  error_info.written_entries);
+	TEST_ASSERT_EQUAL_UINT8_ARRAY(
+		recv_error_info.cipher_suites, error_info.cipher_suites,
+		error_info.written_entries * sizeof(*error_info.cipher_suites));
 }
 
-void test_edhoc_error_message_unknown_credential_referenced(void)
+TEST(error_message, unknown_credential_referenced)
 {
-	int ret = EDHOC_ERROR_GENERIC_ERROR;
-
 	size_t buffer_len = 0;
 	uint8_t buffer[100] = { 0 };
 
@@ -213,14 +228,24 @@ void test_edhoc_error_message_unknown_credential_referenced(void)
 
 	ret = edhoc_message_error_compose(buffer, ARRAY_SIZE(buffer),
 					  &buffer_len, error_code, NULL);
-	assert(EDHOC_SUCCESS == ret);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
 
-	print_array("error msg - wrong selected cipher suite", buffer,
+#if defined(TEST_TRACES)
+	print_array(NULL, "error msg - wrong selected cipher suite", buffer,
 		    buffer_len);
+#endif
 
-	enum edhoc_error_code recv_error_code = -1;
 	ret = edhoc_message_error_process(buffer, buffer_len, &recv_error_code,
 					  NULL);
-	assert(EDHOC_SUCCESS == ret);
-	assert(error_code == recv_error_code);
+	TEST_ASSERT_EQUAL(EDHOC_SUCCESS, ret);
+	TEST_ASSERT_EQUAL(error_code, recv_error_code);
+}
+
+TEST_GROUP_RUNNER(error_message)
+{
+	RUN_TEST_CASE(error_message, success);
+	RUN_TEST_CASE(error_message, unspecified_error);
+	RUN_TEST_CASE(error_message, wrong_selected_cipher_suite_one);
+	RUN_TEST_CASE(error_message, wrong_selected_cipher_suite_many);
+	RUN_TEST_CASE(error_message, unknown_credential_referenced);
 }