edhoc 1.0.5 → 1.1.1

package/external/libedhoc/library/edhoc_message_4.c

@@ -2,8 +2,8 @@
  * \file    edhoc_message_4.c
  * \author  Kamil Kielbasa
  * \brief   EDHOC message 4 compose & process.
- * \version 0.4
- * \date    2024-01-01
+ * \version 0.6
+ * \date    2024-08-05
  * 
  * \copyright Copyright (c) 2024
  * 
@@ -286,32 +286,30 @@ static int prepare_plaintext_4(const struct edhoc_context *ctx, uint8_t *ptxt,
 
 	int ret = EDHOC_ERROR_GENERIC_ERROR;
 
-	struct plaintext_4_EAD_4 ead_4 = { 0 };
+	struct plaintext_4 ead_4 = { .plaintext_4_present = false };
 
-	if (ARRAY_SIZE(ead_4._plaintext_4_EAD_4._ead_x) < ctx->nr_of_ead_tokens)
+	if (ARRAY_SIZE(ead_4.plaintext_4.EAD_4) < ctx->nr_of_ead_tokens)
 		return EDHOC_ERROR_BUFFER_TOO_SMALL;
 
 	if (0 != ctx->nr_of_ead_tokens) {
-		ead_4._plaintext_4_EAD_4_present = true;
-		ead_4._plaintext_4_EAD_4._ead_x_count = ctx->nr_of_ead_tokens;
+		ead_4.plaintext_4_present = true;
+		ead_4.plaintext_4.EAD_4_count = ctx->nr_of_ead_tokens;
 
 		for (size_t i = 0; i < ctx->nr_of_ead_tokens; ++i) {
-			ead_4._plaintext_4_EAD_4._ead_x[i]._ead_x_ead_label =
+			ead_4.plaintext_4.EAD_4[i].ead_y_ead_label =
 				ctx->ead_token[i].label;
-			ead_4._plaintext_4_EAD_4._ead_x[i]
-				._ead_x_ead_value.value =
+			ead_4.plaintext_4.EAD_4[i].ead_y_ead_value.value =
 				ctx->ead_token[i].value;
-			ead_4._plaintext_4_EAD_4._ead_x[i]._ead_x_ead_value.len =
+			ead_4.plaintext_4.EAD_4[i].ead_y_ead_value.len =
 				ctx->ead_token[i].value_len;
-			ead_4._plaintext_4_EAD_4._ead_x[i]
-				._ead_x_ead_value_present =
+			ead_4.plaintext_4.EAD_4[i].ead_y_ead_value_present =
 				(NULL != ctx->ead_token[i].value);
 		}
 	} else {
-		ead_4._plaintext_4_EAD_4_present = false;
+		ead_4.plaintext_4_present = false;
 	}
 
-	ret = cbor_encode_plaintext_4_EAD_4(ptxt, ptxt_size, &ead_4, ptxt_len);
+	ret = cbor_encode_plaintext_4(ptxt, ptxt_size, &ead_4, ptxt_len);
 
 	if (EDHOC_SUCCESS != ret)
 		return EDHOC_ERROR_CBOR_FAILURE;
@@ -347,7 +345,7 @@ static int compute_key_iv_aad(const struct edhoc_context *ctx, uint8_t *key,
 	const struct edhoc_cipher_suite csuite =
 		ctx->csuite[ctx->chosen_csuite_idx];
 
-	uint8_t key_id[EDHOC_KID_LEN] = { 0 };
+	uint8_t key_id[CONFIG_LIBEDHOC_KEY_ID_LEN] = { 0 };
 	struct info input_info = { 0 };
 
 	/* Calculate struct info cbor overhead. */
@@ -356,26 +354,26 @@ static int compute_key_iv_aad(const struct edhoc_context *ctx, uint8_t *key,
 	len += ctx->th_len + cbor_bstr_overhead(ctx->th_len);
 	len += cbor_int_mem_req((int32_t)csuite.aead_key_length);
 
-	ALLOCATE_ARRAY(uint8_t, info, len);
-	memset(info, 0, ALLOCATE_ARRAY_SIZEOF(info));
+	VLA_ALLOC(uint8_t, info, len);
+	memset(info, 0, VLA_SIZEOF(info));
 
 	/* Generate K_3. */
 	input_info = (struct info){
-		._info_label = EDHOC_EXTRACT_PRK_INFO_LABEL_K_4,
-		._info_context.value = ctx->th,
-		._info_context.len = ctx->th_len,
-		._info_length = (uint32_t)csuite.aead_key_length,
+		.info_label = EDHOC_EXTRACT_PRK_INFO_LABEL_K_4,
+		.info_context.value = ctx->th,
+		.info_context.len = ctx->th_len,
+		.info_length = (uint32_t)csuite.aead_key_length,
 	};
 
-	memset(info, 0, ALLOCATE_ARRAY_SIZEOF(info));
+	memset(info, 0, VLA_SIZEOF(info));
 	len = 0;
-	ret = cbor_encode_info(info, ARRAY_SIZE_VLA(info), &input_info, &len);
+	ret = cbor_encode_info(info, VLA_SIZE(info), &input_info, &len);
 
 	if (ZCBOR_SUCCESS != ret)
 		return EDHOC_ERROR_CBOR_FAILURE;
 
-	ret = ctx->keys.generate_key(ctx->user_ctx, EDHOC_KT_EXPAND, ctx->prk,
-				     ctx->prk_len, key_id);
+	ret = ctx->keys.import_key(ctx->user_ctx, EDHOC_KT_EXPAND, ctx->prk,
+				   ctx->prk_len, key_id);
 
 	if (EDHOC_SUCCESS != ret)
 		return EDHOC_ERROR_CRYPTO_FAILURE;
@@ -390,21 +388,21 @@ static int compute_key_iv_aad(const struct edhoc_context *ctx, uint8_t *key,
 
 	/* Generate IV_3. */
 	input_info = (struct info){
-		._info_label = EDHOC_EXTRACT_PRK_INFO_LABEL_IV_4,
-		._info_context.value = ctx->th,
-		._info_context.len = ctx->th_len,
-		._info_length = (uint32_t)csuite.aead_iv_length,
+		.info_label = EDHOC_EXTRACT_PRK_INFO_LABEL_IV_4,
+		.info_context.value = ctx->th,
+		.info_context.len = ctx->th_len,
+		.info_length = (uint32_t)csuite.aead_iv_length,
 	};
 
-	memset(info, 0, sizeof(info));
+	memset(info, 0, VLA_SIZEOF(info));
 	len = 0;
-	ret = cbor_encode_info(info, ARRAY_SIZE_VLA(info), &input_info, &len);
+	ret = cbor_encode_info(info, VLA_SIZE(info), &input_info, &len);
 
 	if (ZCBOR_SUCCESS != ret)
 		return EDHOC_ERROR_CBOR_FAILURE;
 
-	ret = ctx->keys.generate_key(ctx->user_ctx, EDHOC_KT_EXPAND, ctx->prk,
-				     ctx->prk_len, key_id);
+	ret = ctx->keys.import_key(ctx->user_ctx, EDHOC_KT_EXPAND, ctx->prk,
+				   ctx->prk_len, key_id);
 
 	if (EDHOC_SUCCESS != ret)
 		return EDHOC_ERROR_CRYPTO_FAILURE;
@@ -418,10 +416,10 @@ static int compute_key_iv_aad(const struct edhoc_context *ctx, uint8_t *key,
 
 	/* Generate AAD_3. */
 	struct enc_structure cose_enc_0 = {
-		._enc_structure_protected.value = NULL,
-		._enc_structure_protected.len = 0,
-		._enc_structure_external_aad.value = ctx->th,
-		._enc_structure_external_aad.len = ctx->th_len,
+		.enc_structure_protected.value = NULL,
+		.enc_structure_protected.len = 0,
+		.enc_structure_external_aad.value = ctx->th,
+		.enc_structure_external_aad.len = ctx->th_len,
 	};
 
 	len = 0;
@@ -442,9 +440,9 @@ static int compute_ciphertext(const struct edhoc_context *ctx,
 {
 	int ret = EDHOC_ERROR_GENERIC_ERROR;
 
-	uint8_t key_id[EDHOC_KID_LEN] = { 0 };
-	ret = ctx->keys.generate_key(ctx->user_ctx, EDHOC_KT_ENCRYPT, key,
-				     key_len, key_id);
+	uint8_t key_id[CONFIG_LIBEDHOC_KEY_ID_LEN] = { 0 };
+	ret = ctx->keys.import_key(ctx->user_ctx, EDHOC_KT_ENCRYPT, key,
+				   key_len, key_id);
 
 	if (EDHOC_SUCCESS != ret)
 		return EDHOC_ERROR_CRYPTO_FAILURE;
@@ -516,9 +514,9 @@ static int decrypt_ciphertext(const struct edhoc_context *ctx,
 {
 	int ret = EDHOC_ERROR_GENERIC_ERROR;
 
-	uint8_t key_id[EDHOC_KID_LEN] = { 0 };
-	ret = ctx->keys.generate_key(ctx->user_ctx, EDHOC_KT_DECRYPT, key,
-				     key_len, key_id);
+	uint8_t key_id[CONFIG_LIBEDHOC_KEY_ID_LEN] = { 0 };
+	ret = ctx->keys.import_key(ctx->user_ctx, EDHOC_KT_DECRYPT, key,
+				   key_len, key_id);
 
 	if (EDHOC_SUCCESS != ret)
 		return EDHOC_ERROR_CRYPTO_FAILURE;
@@ -545,20 +543,20 @@ static int parse_plaintext(struct edhoc_context *ctx, const uint8_t *ptxt,
 	int ret = EDHOC_ERROR_GENERIC_ERROR;
 
 	size_t len = 0;
-	struct plaintext_4_EAD_4 ead_4 = { 0 };
-	ret = cbor_decode_plaintext_4_EAD_4(ptxt, ptxt_len, &ead_4, &len);
+	struct plaintext_4 ead_4 = { 0 };
+	ret = cbor_decode_plaintext_4(ptxt, ptxt_len, &ead_4, &len);
 
 	if (ZCBOR_SUCCESS != ret)
 		return EDHOC_ERROR_CBOR_FAILURE;
 
-	ctx->nr_of_ead_tokens = ead_4._plaintext_4_EAD_4._ead_x_count;
-	for (size_t i = 0; i < ead_4._plaintext_4_EAD_4._ead_x_count; ++i) {
+	ctx->nr_of_ead_tokens = ead_4.plaintext_4.EAD_4_count;
+	for (size_t i = 0; i < ead_4.plaintext_4.EAD_4_count; ++i) {
 		ctx->ead_token[i].label =
-			ead_4._plaintext_4_EAD_4._ead_x[i]._ead_x_ead_label;
-		ctx->ead_token[i].value = ead_4._plaintext_4_EAD_4._ead_x[i]
-						  ._ead_x_ead_value.value;
+			ead_4.plaintext_4.EAD_4[i].ead_y_ead_label;
+		ctx->ead_token[i].value =
+			ead_4.plaintext_4.EAD_4[i].ead_y_ead_value.value;
 		ctx->ead_token[i].value_len =
-			ead_4._plaintext_4_EAD_4._ead_x[i]._ead_x_ead_value.len;
+			ead_4.plaintext_4.EAD_4[i].ead_y_ead_value.len;
 	}
 
 	return EDHOC_SUCCESS;
@@ -590,6 +588,8 @@ int edhoc_message_4_compose(struct edhoc_context *ctx, uint8_t *msg_4,
 
 	ctx->status = EDHOC_SM_ABORTED;
 	ctx->error_code = EDHOC_ERROR_CODE_UNSPECIFIED_ERROR;
+	ctx->message = EDHOC_MSG_4;
+	ctx->role = EDHOC_RESPONDER;
 
 	int ret = EDHOC_ERROR_GENERIC_ERROR;
 
@@ -599,7 +599,7 @@ int edhoc_message_4_compose(struct edhoc_context *ctx, uint8_t *msg_4,
 
 	/* 2. Compose EAD_4 if present. */
 	if (NULL != ctx->ead.compose && 0 != ARRAY_SIZE(ctx->ead_token) - 1) {
-		ret = ctx->ead.compose(ctx->user_ctx, EDHOC_MSG_4,
+		ret = ctx->ead.compose(ctx->user_ctx, ctx->message,
 				       ctx->ead_token,
 				       ARRAY_SIZE(ctx->ead_token) - 1,
 				       &ctx->nr_of_ead_tokens);
@@ -633,11 +633,11 @@ int edhoc_message_4_compose(struct edhoc_context *ctx, uint8_t *msg_4,
 	if (EDHOC_SUCCESS != ret)
 		return EDHOC_ERROR_INVALID_ARGUMENT;
 
-	ALLOCATE_ARRAY(uint8_t, plaintext, plaintext_len);
-	memset(plaintext, 0, ALLOCATE_ARRAY_SIZEOF(plaintext));
+	VLA_ALLOC(uint8_t, plaintext, plaintext_len);
+	memset(plaintext, 0, VLA_SIZEOF(plaintext));
 
 	/* 3b. Prepare plaintext (PLAINTEXT_4). */
-	ret = prepare_plaintext_4(ctx, plaintext, ARRAY_SIZE_VLA(plaintext),
+	ret = prepare_plaintext_4(ctx, plaintext, VLA_SIZE(plaintext),
 				  &plaintext_len);
 
 	if (EDHOC_SUCCESS != ret)
@@ -648,36 +648,37 @@ int edhoc_message_4_compose(struct edhoc_context *ctx, uint8_t *msg_4,
 			    plaintext_len);
 
 	/* 4. Compute K_4, IV_4 and AAD_4. */
-	ALLOCATE_ARRAY(uint8_t, key, csuite.aead_key_length);
-	memset(key, 0, ALLOCATE_ARRAY_SIZEOF(key));
+	VLA_ALLOC(uint8_t, key, csuite.aead_key_length);
+	memset(key, 0, VLA_SIZEOF(key));
 
-	ALLOCATE_ARRAY(uint8_t, iv, csuite.aead_iv_length);
-	memset(iv, 0, ALLOCATE_ARRAY_SIZEOF(iv));
+	VLA_ALLOC(uint8_t, iv, csuite.aead_iv_length);
+	memset(iv, 0, VLA_SIZEOF(iv));
 
 	const size_t aad_len = compute_aad_4_len(ctx);
-	ALLOCATE_ARRAY(uint8_t, aad, aad_len);
-	memset(aad, 0, ALLOCATE_ARRAY_SIZEOF(aad));
+	VLA_ALLOC(uint8_t, aad, aad_len);
+	memset(aad, 0, VLA_SIZEOF(aad));
 
-	ret = compute_key_iv_aad(ctx, key, ARRAY_SIZE_VLA(key), iv, ARRAY_SIZE_VLA(iv),
-				 aad, ARRAY_SIZE_VLA(aad));
+	ret = compute_key_iv_aad(ctx, key, VLA_SIZE(key), iv, VLA_SIZE(iv), aad,
+				 VLA_SIZE(aad));
 
 	if (EDHOC_SUCCESS != ret)
 		return EDHOC_ERROR_CRYPTO_FAILURE;
 
 	if (NULL != ctx->logger) {
-		ctx->logger(ctx->user_ctx, "K_4", key, ARRAY_SIZE_VLA(key));
-		ctx->logger(ctx->user_ctx, "IV_4", iv, ARRAY_SIZE_VLA(iv));
-		ctx->logger(ctx->user_ctx, "AAD_4", aad, ARRAY_SIZE_VLA(aad));
+		ctx->logger(ctx->user_ctx, "K_4", key, VLA_SIZE(key));
+		ctx->logger(ctx->user_ctx, "IV_4", iv, VLA_SIZE(iv));
+		ctx->logger(ctx->user_ctx, "AAD_4", aad, VLA_SIZE(aad));
 	}
 
 	/* 5. Compute ciphertext. */
 	size_t ciphertext_len = 0;
-	ALLOCATE_ARRAY(uint8_t, ciphertext, ARRAY_SIZE_VLA(plaintext) + csuite.aead_tag_length);
-	memset(ciphertext, 0, ALLOCATE_ARRAY_SIZEOF(ciphertext));
+	VLA_ALLOC(uint8_t, ciphertext,
+		  VLA_SIZE(plaintext) + csuite.aead_tag_length);
+	memset(ciphertext, 0, VLA_SIZEOF(ciphertext));
 
-	ret = compute_ciphertext(ctx, key, ARRAY_SIZE_VLA(key), iv, ARRAY_SIZE_VLA(iv),
-				 aad, ARRAY_SIZE_VLA(aad), plaintext, plaintext_len,
-				 ciphertext, ARRAY_SIZE_VLA(ciphertext),
+	ret = compute_ciphertext(ctx, key, VLA_SIZE(key), iv, VLA_SIZE(iv), aad,
+				 VLA_SIZE(aad), plaintext, plaintext_len,
+				 ciphertext, VLA_SIZE(ciphertext),
 				 &ciphertext_len);
 
 	if (EDHOC_SUCCESS != ret)
@@ -727,6 +728,8 @@ int edhoc_message_4_process(struct edhoc_context *ctx, const uint8_t *msg_4,
 
 	ctx->status = EDHOC_SM_ABORTED;
 	ctx->error_code = EDHOC_ERROR_CODE_UNSPECIFIED_ERROR;
+	ctx->message = EDHOC_MSG_4;
+	ctx->role = EDHOC_INITIATOR;
 
 	int ret = EDHOC_ERROR_GENERIC_ERROR;
 
@@ -747,45 +750,44 @@ int edhoc_message_4_process(struct edhoc_context *ctx, const uint8_t *msg_4,
 		ctx->logger(ctx->user_ctx, "CIPHERTEXT_4", ctxt, ctxt_len);
 
 	/* 3. Compute K_4, IV_4 and AAD_4. */
-	ALLOCATE_ARRAY(uint8_t, key, csuite.aead_key_length);
-	memset(key, 0, ALLOCATE_ARRAY_SIZEOF(key));
+	VLA_ALLOC(uint8_t, key, csuite.aead_key_length);
+	memset(key, 0, VLA_SIZEOF(key));
 
-	ALLOCATE_ARRAY(uint8_t, iv, csuite.aead_iv_length);
-	memset(iv, 0, ALLOCATE_ARRAY_SIZEOF(iv));
+	VLA_ALLOC(uint8_t, iv, csuite.aead_iv_length);
+	memset(iv, 0, VLA_SIZEOF(iv));
 
 	const size_t aad_len = compute_aad_4_len(ctx);
-	ALLOCATE_ARRAY(uint8_t, aad, aad_len);
-	memset(aad, 0, ALLOCATE_ARRAY_SIZEOF(aad));
+	VLA_ALLOC(uint8_t, aad, aad_len);
+	memset(aad, 0, VLA_SIZEOF(aad));
 
-	ret = compute_key_iv_aad(ctx, key, ARRAY_SIZE_VLA(key), iv, ARRAY_SIZE_VLA(iv),
-				 aad, ARRAY_SIZE_VLA(aad));
+	ret = compute_key_iv_aad(ctx, key, VLA_SIZE(key), iv, VLA_SIZE(iv), aad,
+				 VLA_SIZE(aad));
 
 	if (EDHOC_SUCCESS != ret)
 		return EDHOC_ERROR_CRYPTO_FAILURE;
 
 	if (NULL != ctx->logger) {
-		ctx->logger(ctx->user_ctx, "K_4", key, ARRAY_SIZE_VLA(key));
-		ctx->logger(ctx->user_ctx, "IV_4", iv, ARRAY_SIZE_VLA(iv));
-		ctx->logger(ctx->user_ctx, "AAD_4", aad, ARRAY_SIZE_VLA(aad));
+		ctx->logger(ctx->user_ctx, "K_4", key, VLA_SIZE(key));
+		ctx->logger(ctx->user_ctx, "IV_4", iv, VLA_SIZE(iv));
+		ctx->logger(ctx->user_ctx, "AAD_4", aad, VLA_SIZE(aad));
 	}
 
 	/* 4. Decrypt ciphertext. */
-	ALLOCATE_ARRAY(uint8_t, ptxt, ctxt_len - csuite.aead_tag_length);
-	memset(ptxt, 0, ALLOCATE_ARRAY_SIZEOF(ptxt));
+	VLA_ALLOC(uint8_t, ptxt, ctxt_len - csuite.aead_tag_length);
+	memset(ptxt, 0, VLA_SIZEOF(ptxt));
 
-	ret = decrypt_ciphertext(ctx, key, ARRAY_SIZE_VLA(key), iv, ARRAY_SIZE_VLA(iv),
-				 aad, ARRAY_SIZE_VLA(aad), ctxt, ctxt_len, ptxt,
-				 ARRAY_SIZE_VLA(ptxt));
+	ret = decrypt_ciphertext(ctx, key, VLA_SIZE(key), iv, VLA_SIZE(iv), aad,
+				 VLA_SIZE(aad), ctxt, ctxt_len, ptxt,
+				 VLA_SIZE(ptxt));
 
 	if (EDHOC_SUCCESS != ret)
 		return EDHOC_ERROR_CRYPTO_FAILURE;
 
 	if (NULL != ctx->logger)
-		ctx->logger(ctx->user_ctx, "PLAINTEXT_4", ptxt,
-			    ARRAY_SIZE_VLA(ptxt));
+		ctx->logger(ctx->user_ctx, "PLAINTEXT_4", ptxt, VLA_SIZE(ptxt));
 
 	/* 5. Parse CBOR plaintext (PLAINTEXT_4). */
-	ret = parse_plaintext(ctx, ptxt, ARRAY_SIZE_VLA(ptxt));
+	ret = parse_plaintext(ctx, ptxt, VLA_SIZE(ptxt));
 
 	if (EDHOC_SUCCESS != ret)
 		return EDHOC_ERROR_CBOR_FAILURE;
@@ -793,7 +795,7 @@ int edhoc_message_4_process(struct edhoc_context *ctx, const uint8_t *msg_4,
 	/* 6. Process EAD_4 if present. */
 	if (NULL != ctx->ead.process && 0 != ARRAY_SIZE(ctx->ead_token) - 1 &&
 	    0 != ctx->nr_of_ead_tokens) {
-		ret = ctx->ead.process(ctx->user_ctx, EDHOC_MSG_4,
+		ret = ctx->ead.process(ctx->user_ctx, ctx->message,
 				       ctx->ead_token, ctx->nr_of_ead_tokens);
 
 		if (EDHOC_SUCCESS != ret)

package/external/libedhoc/library/edhoc_message_error.c

@@ -2,8 +2,8 @@
  * \file    edhoc_message_error.c
  * \author  Kamil Kielbasa
  * \brief   EDHOC message error.
- * \version 0.4
- * \date    2024-01-01
+ * \version 0.6
+ * \date    2024-08-05
  * 
  * \copyright Copyright (c) 2024
  * 
@@ -57,12 +57,12 @@ int edhoc_message_error_compose(uint8_t *msg_err, size_t msg_err_size,
 		return EDHOC_ERROR_BAD_STATE;
 
 	int ret = EDHOC_ERROR_GENERIC_ERROR;
-	struct message_error input = { ._message_error_ERR_CODE =
+	struct message_error input = { .message_error_ERR_CODE =
 					       (int32_t)code };
 
 	switch (code) {
 	case EDHOC_ERROR_CODE_SUCCESS: {
-		input._message_error_ERR_INFO_present = false;
+		input.message_error_ERR_INFO_present = false;
 		break;
 	}
 
@@ -74,20 +74,20 @@ int edhoc_message_error_compose(uint8_t *msg_err, size_t msg_err_size,
 		if (info->written_entries > info->total_entries)
 			return EDHOC_ERROR_INVALID_ARGUMENT;
 
-		input._message_error_ERR_INFO_present = true;
-		input._message_error_ERR_INFO._message_error_ERR_INFO_choice =
-			_message_error_ERR_INFO_tstr;
-		input._message_error_ERR_INFO._message_error_ERR_INFO_tstr
-			.value = (const uint8_t *)info->text_string;
-		input._message_error_ERR_INFO._message_error_ERR_INFO_tstr.len =
+		input.message_error_ERR_INFO_present = true;
+		input.message_error_ERR_INFO.message_error_ERR_INFO_choice =
+			message_error_ERR_INFO_tstr_c;
+		input.message_error_ERR_INFO.message_error_ERR_INFO_tstr.value =
+			(const uint8_t *)info->text_string;
+		input.message_error_ERR_INFO.message_error_ERR_INFO_tstr.len =
 			info->written_entries;
 		break;
 	}
 
 	case EDHOC_ERROR_CODE_WRONG_SELECTED_CIPHER_SUITE: {
-		input._message_error_ERR_INFO_present = true;
-		input._message_error_ERR_INFO._message_error_ERR_INFO_choice =
-			_message_error_ERR_INFO__suites;
+		input.message_error_ERR_INFO_present = true;
+		input.message_error_ERR_INFO.message_error_ERR_INFO_choice =
+			message_error_ERR_INFO_suites_m_c;
 
 		if (NULL == info || NULL == info->cipher_suites ||
 		    0 == info->total_entries || 0 == info->written_entries)
@@ -96,21 +96,21 @@ int edhoc_message_error_compose(uint8_t *msg_err, size_t msg_err_size,
 		if (info->written_entries > info->total_entries)
 			return EDHOC_ERROR_INVALID_ARGUMENT;
 
-		struct suites_ *suites =
-			&input._message_error_ERR_INFO
-				 ._message_error_ERR_INFO__suites;
+		struct suites_r *suites =
+			&input.message_error_ERR_INFO
+				 .message_error_ERR_INFO_suites_m;
 
 		if (1 == info->written_entries) {
-			suites->_suites_choice = _suites_int;
-			suites->_suites_int = *info->cipher_suites;
+			suites->suites_choice = suites_int_c;
+			suites->suites_int = *info->cipher_suites;
 		} else {
-			if (ARRAY_SIZE(suites->_suites__int_int) <
+			if (ARRAY_SIZE(suites->suites_int_l_int) <
 			    info->written_entries)
 				return EDHOC_ERROR_BUFFER_TOO_SMALL;
 
-			suites->_suites_choice = _suites__int;
-			suites->_suites__int_int_count = info->written_entries;
-			memcpy(suites->_suites__int_int, info->cipher_suites,
+			suites->suites_choice = suites_int_l_c;
+			suites->suites_int_l_int_count = info->written_entries;
+			memcpy(suites->suites_int_l_int, info->cipher_suites,
 			       sizeof(*info->cipher_suites) *
 				       info->written_entries);
 		}
@@ -119,9 +119,9 @@ int edhoc_message_error_compose(uint8_t *msg_err, size_t msg_err_size,
 	}
 
 	case EDHOC_ERROR_CODE_UNKNOWN_CREDENTIAL_REFERENCED: {
-		input._message_error_ERR_INFO_present = true;
-		input._message_error_ERR_INFO._message_error_ERR_INFO_choice =
-			_message_error_ERR_INFO_bool;
+		input.message_error_ERR_INFO_present = true;
+		input.message_error_ERR_INFO.message_error_ERR_INFO_choice =
+			message_error_ERR_INFO_bool_c;
 		break;
 	}
 
@@ -154,7 +154,7 @@ int edhoc_message_error_process(const uint8_t *msg_err, size_t msg_err_len,
 	if (ZCBOR_SUCCESS != ret)
 		return EDHOC_ERROR_CBOR_FAILURE;
 
-	switch (result._message_error_ERR_CODE) {
+	switch (result.message_error_ERR_CODE) {
 	case EDHOC_ERROR_CODE_SUCCESS: {
 		*code = EDHOC_ERROR_CODE_SUCCESS;
 		break;
@@ -167,10 +167,10 @@ int edhoc_message_error_process(const uint8_t *msg_err, size_t msg_err_len,
 		    0 == info->total_entries)
 			break;
 
-		if (true == result._message_error_ERR_INFO_present) {
+		if (true == result.message_error_ERR_INFO_present) {
 			const struct zcbor_string *tstr =
-				&result._message_error_ERR_INFO
-					 ._message_error_ERR_INFO_tstr;
+				&result.message_error_ERR_INFO
+					 .message_error_ERR_INFO_tstr;
 
 			if (tstr->len > info->total_entries)
 				return EDHOC_ERROR_BUFFER_TOO_SMALL;
@@ -190,29 +190,29 @@ int edhoc_message_error_process(const uint8_t *msg_err, size_t msg_err_len,
 		    0 == info->total_entries)
 			break;
 
-		if (true == result._message_error_ERR_INFO_present) {
-			const struct suites_ *suites =
-				&result._message_error_ERR_INFO
-					 ._message_error_ERR_INFO__suites;
+		if (true == result.message_error_ERR_INFO_present) {
+			const struct suites_r *suites =
+				&result.message_error_ERR_INFO
+					 .message_error_ERR_INFO_suites_m;
 
-			switch (suites->_suites_choice) {
-			case _suites_int: {
+			switch (suites->suites_choice) {
+			case suites_int_c: {
 				info->written_entries = 1;
-				*info->cipher_suites = suites->_suites_int;
+				*info->cipher_suites = suites->suites_int;
 				break;
 			}
 
-			case _suites__int: {
-				if (suites->_suites__int_int_count >
+			case suites_int_l_c: {
+				if (suites->suites_int_l_int_count >
 				    info->total_entries)
 					return EDHOC_ERROR_BUFFER_TOO_SMALL;
 
 				info->written_entries =
-					suites->_suites__int_int_count;
+					suites->suites_int_l_int_count;
 				memcpy(info->cipher_suites,
-				       suites->_suites__int_int,
+				       suites->suites_int_l_int,
 				       sizeof(*info->cipher_suites) *
-					       suites->_suites__int_int_count);
+					       suites->suites_int_l_int_count);
 				break;
 			}