edhoc 1.0.4 → 1.1.0

package/external/libedhoc/library/edhoc_exporter.c

@@ -2,8 +2,8 @@
  * \file    edhoc_exporter.c
  * \author  Kamil Kielbasa
  * \brief   EDHOC exporter for PRK exporter, key update or OSCORE session.
- * \version 0.4
- * \date    2024-01-01
+ * \version 0.6
+ * \date    2024-08-05
  *
  * \copyright Copyright (c) 2024
  *
@@ -139,26 +139,26 @@ static int compute_prk_out(struct edhoc_context *ctx)
 	len += ctx->th_len + cbor_bstr_overhead(ctx->th_len);
 	len += cbor_int_mem_req((int32_t)csuite.hash_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 PRK_out. */
 	struct info input_info = {
-		._info_label = EDHOC_EXTRACT_PRK_INFO_LABEL_PRK_OUT,
-		._info_context.value = ctx->th,
-		._info_context.len = ctx->th_len,
-		._info_length = (uint32_t)csuite.hash_length,
+		.info_label = EDHOC_EXTRACT_PRK_INFO_LABEL_PRK_OUT,
+		.info_context.value = ctx->th,
+		.info_context.len = ctx->th_len,
+		.info_length = (uint32_t)csuite.hash_length,
 	};
 
 	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;
 
-	uint8_t key_id[EDHOC_KID_LEN] = { 0 };
-	ret = ctx->keys.generate_key(ctx->user_ctx, EDHOC_KT_EXPAND, ctx->prk,
-				     ctx->prk_len, key_id);
+	uint8_t key_id[CONFIG_LIBEDHOC_KEY_ID_LEN] = { 0 };
+	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;
@@ -198,26 +198,26 @@ static int compute_new_prk_out(struct edhoc_context *ctx,
 	len += entropy_len + cbor_bstr_overhead(entropy_len);
 	len += cbor_int_mem_req((int32_t)csuite.hash_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 PRK_out. */
 	struct info input_info = {
-		._info_label = EDHOC_EXTRACT_PRK_INFO_LABEL_NEW_PRK_OUT,
-		._info_context.value = entropy,
-		._info_context.len = entropy_len,
-		._info_length = (uint32_t)csuite.hash_length,
+		.info_label = EDHOC_EXTRACT_PRK_INFO_LABEL_NEW_PRK_OUT,
+		.info_context.value = entropy,
+		.info_context.len = entropy_len,
+		.info_length = (uint32_t)csuite.hash_length,
 	};
 
 	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;
 
-	uint8_t key_id[EDHOC_KID_LEN] = { 0 };
-	ret = ctx->keys.generate_key(ctx->user_ctx, EDHOC_KT_EXPAND, ctx->prk,
-				     ctx->prk_len, key_id);
+	uint8_t key_id[CONFIG_LIBEDHOC_KEY_ID_LEN] = { 0 };
+	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;
@@ -253,26 +253,26 @@ static int compute_prk_exporter(const struct edhoc_context *ctx,
 	len += 1 + cbor_bstr_overhead(0); /* cbor empty byte string. */
 	len += cbor_int_mem_req((int32_t)csuite.hash_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));
 
 	struct info input_info = {
-		._info_label =
+		.info_label =
 			(int32_t)EDHOC_EXTRACT_PRK_INFO_LABEL_PRK_EXPORTER,
-		._info_context.value = NULL,
-		._info_context.len = 0,
-		._info_length = (uint32_t)csuite.hash_length,
+		.info_context.value = NULL,
+		.info_context.len = 0,
+		.info_length = (uint32_t)csuite.hash_length,
 	};
 
 	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;
 
-	uint8_t key_id[EDHOC_KID_LEN] = { 0 };
-	ret = ctx->keys.generate_key(ctx->user_ctx, EDHOC_KT_EXPAND, ctx->prk,
-				     ctx->prk_len, key_id);
+	uint8_t key_id[CONFIG_LIBEDHOC_KEY_ID_LEN] = { 0 };
+	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;
@@ -333,10 +333,10 @@ int edhoc_export_prk_exporter(struct edhoc_context *ctx, size_t label,
 		ctx->csuite[ctx->chosen_csuite_idx];
 
 	/* 3. Compute pseudo random key exporter (PRK_exporter). */
-	ALLOCATE_ARRAY(uint8_t, prk_exporter, csuite.hash_length);
-	memset(prk_exporter, 0, ALLOCATE_ARRAY_SIZEOF(prk_exporter));
+	VLA_ALLOC(uint8_t, prk_exporter, csuite.hash_length);
+	memset(prk_exporter, 0, VLA_SIZEOF(prk_exporter));
 
-	ret = compute_prk_exporter(ctx, prk_exporter, ARRAY_SIZE_VLA(prk_exporter));
+	ret = compute_prk_exporter(ctx, prk_exporter, VLA_SIZE(prk_exporter));
 
 	if (EDHOC_SUCCESS != ret)
 		return EDHOC_ERROR_PSEUDORANDOM_KEY_FAILURE;
@@ -347,26 +347,25 @@ int edhoc_export_prk_exporter(struct edhoc_context *ctx, size_t label,
 	len += 1 + cbor_bstr_overhead(0); /* cbor empty byte string. */
 	len += cbor_int_mem_req((int32_t)csuite.hash_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));
 
 	const struct info input_info = (struct info){
-		._info_label = (int32_t)label,
-		._info_context.value = NULL,
-		._info_context.len = 0,
-		._info_length = (uint32_t)secret_len,
+		.info_label = (int32_t)label,
+		.info_context.value = NULL,
+		.info_context.len = 0,
+		.info_length = (uint32_t)secret_len,
 	};
 
 	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;
 
-	uint8_t key_id[EDHOC_KID_LEN] = { 0 };
-	ret = ctx->keys.generate_key(ctx->user_ctx, EDHOC_KT_EXPAND,
-				     prk_exporter, ARRAY_SIZE_VLA(prk_exporter),
-				     key_id);
+	uint8_t key_id[CONFIG_LIBEDHOC_KEY_ID_LEN] = { 0 };
+	ret = ctx->keys.import_key(ctx->user_ctx, EDHOC_KT_EXPAND, prk_exporter,
+				   VLA_SIZE(prk_exporter), key_id);
 
 	if (EDHOC_SUCCESS != ret)
 		return EDHOC_ERROR_CRYPTO_FAILURE;

package/external/libedhoc/library/edhoc_message_1.c

@@ -2,8 +2,8 @@
  * \file    edhoc_message_1.c
  * \author  Kamil Kielbasa
  * \brief   EDHOC message 1.
- * \version 0.4
- * \date    2024-01-01
+ * \version 0.6
+ * \date    2024-08-05
  * 
  * \copyright Copyright (c) 2024
  * 
@@ -48,7 +48,8 @@
 
 /*
  * Steps for composition of message 1:
- *      1.  Choose most preferred cipher suite.
+ *      1a. Choose most preferred cipher suite.
+ *      1b. Choose most preferred method.
  *      2.  Generate ephemeral Diffie-Hellmann key pair.
  *      3a. Fill CBOR structure for message 1 - method.
  *      3b. Fill CBOR structure for message 1 - cipher suite.
@@ -74,33 +75,37 @@ int edhoc_message_1_compose(struct edhoc_context *ctx, uint8_t *msg_1,
 
 	ctx->status = EDHOC_SM_ABORTED;
 	ctx->error_code = EDHOC_ERROR_CODE_UNSPECIFIED_ERROR;
+	ctx->message = EDHOC_MSG_1;
+	ctx->role = EDHOC_INITIATOR;
 
-	/* 1. Choose most preferred cipher suite. */
+	/* 1a. Choose most preferred cipher suite. */
 	if (0 == ctx->csuite_len)
-		return EDHOC_ERROR_INVALID_ARGUMENT;
+		return EDHOC_ERROR_BAD_STATE;
 
 	ctx->chosen_csuite_idx = ctx->csuite_len - 1;
 	const struct edhoc_cipher_suite csuite =
 		ctx->csuite[ctx->chosen_csuite_idx];
 
+	/* 1b. Choose most preferred method. */
+	ctx->chosen_method = ctx->method[0];
+
 	/* 2. Generate ephemeral Diffie-Hellmann key pair. */
-	uint8_t key_id[EDHOC_KID_LEN] = { 0 };
-	ret = ctx->keys.generate_key(ctx->user_ctx, EDHOC_KT_MAKE_KEY_PAIR,
-				     NULL, 0, key_id);
+	uint8_t key_id[CONFIG_LIBEDHOC_KEY_ID_LEN] = { 0 };
+	ret = ctx->keys.import_key(ctx->user_ctx, EDHOC_KT_MAKE_KEY_PAIR, NULL,
+				   0, key_id);
 
 	if (EDHOC_SUCCESS != ret)
 		return EDHOC_ERROR_EPHEMERAL_DIFFIE_HELLMAN_FAILURE;
 
-	ALLOCATE_ARRAY(uint8_t, dh_pub_key, csuite.ecc_key_length);
-	memset(dh_pub_key, 0, ALLOCATE_ARRAY_SIZEOF(dh_pub_key));
+	VLA_ALLOC(uint8_t, dh_pub_key, csuite.ecc_key_length);
+	memset(dh_pub_key, 0, VLA_SIZEOF(dh_pub_key));
 
 	size_t dh_priv_key_len = 0;
 	size_t dh_pub_key_len = 0;
 	ret = ctx->crypto.make_key_pair(ctx->user_ctx, key_id, ctx->dh_priv_key,
 					ARRAY_SIZE(ctx->dh_priv_key),
 					&dh_priv_key_len, dh_pub_key,
-					ARRAY_SIZE_VLA(dh_pub_key),
-					&dh_pub_key_len);
+					VLA_SIZE(dh_pub_key), &dh_pub_key_len);
 	ctx->keys.destroy_key(ctx->user_ctx, key_id);
 
 	if (EDHOC_SUCCESS != ret || csuite.ecc_key_length != dh_priv_key_len ||
@@ -118,44 +123,44 @@ int edhoc_message_1_compose(struct edhoc_context *ctx, uint8_t *msg_1,
 	struct message_1 cbor_enc_msg_1 = { 0 };
 
 	/* 3a. Fill CBOR structure for message 1 - method. */
-	cbor_enc_msg_1._message_1_METHOD = (int32_t)ctx->method;
+	cbor_enc_msg_1.message_1_METHOD = (int32_t)ctx->chosen_method;
 
 	/* 3b. Fill CBOR structure for message 1 - cipher suite. */
 	if (1UL == ctx->csuite_len) {
-		cbor_enc_msg_1._message_1_SUITES_I._suites_choice = _suites_int;
-		cbor_enc_msg_1._message_1_SUITES_I._suites_int = csuite.value;
+		cbor_enc_msg_1.message_1_SUITES_I.suites_choice = suites_int_c;
+		cbor_enc_msg_1.message_1_SUITES_I.suites_int = csuite.value;
 	} else {
-		cbor_enc_msg_1._message_1_SUITES_I._suites_choice =
-			_suites__int;
-		cbor_enc_msg_1._message_1_SUITES_I._suites__int_int_count =
+		cbor_enc_msg_1.message_1_SUITES_I.suites_choice =
+			suites_int_l_c;
+		cbor_enc_msg_1.message_1_SUITES_I.suites_int_l_int_count =
 			ctx->csuite_len;
 
-		if (ARRAY_SIZE(cbor_enc_msg_1._message_1_SUITES_I
-				       ._suites__int_int) < ctx->csuite_len) {
+		if (ARRAY_SIZE(cbor_enc_msg_1.message_1_SUITES_I
+				       .suites_int_l_int) < ctx->csuite_len) {
 			return EDHOC_ERROR_BUFFER_TOO_SMALL;
 		}
 
 		for (size_t i = 0; i < ctx->csuite_len; ++i) {
-			cbor_enc_msg_1._message_1_SUITES_I._suites__int_int[i] =
+			cbor_enc_msg_1.message_1_SUITES_I.suites_int_l_int[i] =
 				ctx->csuite[i].value;
 		}
 	}
 
 	/* 3c. Fill CBOR structure for message 1 - ephemeral public key. */
-	cbor_enc_msg_1._message_1_G_X.value = dh_pub_key;
-	cbor_enc_msg_1._message_1_G_X.len = ARRAY_SIZE_VLA(dh_pub_key);
+	cbor_enc_msg_1.message_1_G_X.value = dh_pub_key;
+	cbor_enc_msg_1.message_1_G_X.len = VLA_SIZE(dh_pub_key);
 
 	/* 3d. Fill CBOR structure for message 1 - connection identifier. */
 	switch (ctx->cid.encode_type) {
 	case EDHOC_CID_TYPE_ONE_BYTE_INTEGER:
-		cbor_enc_msg_1._message_1_C_I_choice = _message_1_C_I_int;
-		cbor_enc_msg_1._message_1_C_I_int = ctx->cid.int_value;
+		cbor_enc_msg_1.message_1_C_I_choice = message_1_C_I_int_c;
+		cbor_enc_msg_1.message_1_C_I_int = ctx->cid.int_value;
 		break;
 
 	case EDHOC_CID_TYPE_BYTE_STRING:
-		cbor_enc_msg_1._message_1_C_I_choice = _message_1_C_I_bstr;
-		cbor_enc_msg_1._message_1_C_I_bstr.value = ctx->cid.bstr_value;
-		cbor_enc_msg_1._message_1_C_I_bstr.len = ctx->cid.bstr_length;
+		cbor_enc_msg_1.message_1_C_I_choice = message_1_C_I_bstr_c;
+		cbor_enc_msg_1.message_1_C_I_bstr.value = ctx->cid.bstr_value;
+		cbor_enc_msg_1.message_1_C_I_bstr.len = ctx->cid.bstr_length;
 		break;
 
 	default:
@@ -164,7 +169,7 @@ int edhoc_message_1_compose(struct edhoc_context *ctx, uint8_t *msg_1,
 
 	/* 3e. Fill CBOR structure for message 1 - external authorization data if present. */
 	if (NULL != ctx->ead.compose && 0 != ARRAY_SIZE(ctx->ead_token) - 1) {
-		ret = ctx->ead.compose(ctx->user_ctx, EDHOC_MSG_1,
+		ret = ctx->ead.compose(ctx->user_ctx, ctx->message,
 				       ctx->ead_token,
 				       ARRAY_SIZE(ctx->ead_token) - 1,
 				       &ctx->nr_of_ead_tokens);
@@ -192,23 +197,25 @@ int edhoc_message_1_compose(struct edhoc_context *ctx, uint8_t *msg_1,
 	}
 
 	if (0 != ctx->nr_of_ead_tokens) {
-		cbor_enc_msg_1._message_1_EAD_1_present = true;
-		cbor_enc_msg_1._message_1_EAD_1._ead_count =
+		cbor_enc_msg_1.message_1_EAD_1_m_present = true;
+		cbor_enc_msg_1.message_1_EAD_1_m.EAD_1_count =
 			ctx->nr_of_ead_tokens;
 
 		for (size_t i = 0; i < ctx->nr_of_ead_tokens; ++i) {
-			cbor_enc_msg_1._message_1_EAD_1._ead[i]
-				._ead_value_present = true;
-			cbor_enc_msg_1._message_1_EAD_1._ead[i]._ead_label =
-				ctx->ead_token[i].label;
-			cbor_enc_msg_1._message_1_EAD_1._ead[i]
-				._ead_value.value = ctx->ead_token[i].value;
-			cbor_enc_msg_1._message_1_EAD_1._ead[i]._ead_value.len =
+			cbor_enc_msg_1.message_1_EAD_1_m.EAD_1[i]
+				.ead_x_ead_value_present = true;
+			cbor_enc_msg_1.message_1_EAD_1_m.EAD_1[i]
+				.ead_x_ead_label = ctx->ead_token[i].label;
+			cbor_enc_msg_1.message_1_EAD_1_m.EAD_1[i]
+				.ead_x_ead_value.value =
+				ctx->ead_token[i].value;
+			cbor_enc_msg_1.message_1_EAD_1_m.EAD_1[i]
+				.ead_x_ead_value.len =
 				ctx->ead_token[i].value_len;
 		}
 	} else {
-		cbor_enc_msg_1._message_1_EAD_1_present = false;
-		cbor_enc_msg_1._message_1_EAD_1._ead_count = 0;
+		cbor_enc_msg_1.message_1_EAD_1_m_present = false;
+		cbor_enc_msg_1.message_1_EAD_1_m.EAD_1_count = 0;
 	}
 
 	/* 4. Encode cbor sequence of message 1. */
@@ -263,6 +270,8 @@ int edhoc_message_1_process(struct edhoc_context *ctx, const uint8_t *msg_1,
 
 	ctx->status = EDHOC_SM_ABORTED;
 	ctx->error_code = EDHOC_ERROR_CODE_UNSPECIFIED_ERROR;
+	ctx->message = EDHOC_MSG_1;
+	ctx->role = EDHOC_RESPONDER;
 
 	int ret = EDHOC_ERROR_GENERIC_ERROR;
 
@@ -276,33 +285,59 @@ int edhoc_message_1_process(struct edhoc_context *ctx, const uint8_t *msg_1,
 
 	/* 2. Choose most preferred cipher suite. */
 	if (0 == ctx->csuite_len)
-		return EDHOC_ERROR_INVALID_ARGUMENT;
+		return EDHOC_ERROR_BAD_STATE;
 
 	ctx->chosen_csuite_idx = ctx->csuite_len - 1;
 	const struct edhoc_cipher_suite csuite =
 		ctx->csuite[ctx->chosen_csuite_idx];
 
 	/* 3a. Verify method. */
-	if ((int32_t)ctx->method != cbor_dec_msg_1._message_1_METHOD)
+	bool method_match = false;
+	for (size_t i = 0; i < ctx->method_len; ++i) {
+		if ((int32_t)ctx->method[i] ==
+		    cbor_dec_msg_1.message_1_METHOD) {
+			ctx->chosen_method = ctx->method[i];
+			method_match = true;
+			break;
+		}
+	}
+
+	if (false == method_match)
 		return EDHOC_ERROR_MSG_1_PROCESS_FAILURE;
 
 	/* 3b. Verify cipher suite. */
-	switch (cbor_dec_msg_1._message_1_SUITES_I._suites_choice) {
-	case _suites_int: {
+	switch (cbor_dec_msg_1.message_1_SUITES_I.suites_choice) {
+	case suites_int_c: {
+		ctx->peer_csuite[ctx->peer_csuite_len].value =
+			cbor_dec_msg_1.message_1_SUITES_I.suites_int;
+		ctx->peer_csuite_len = 1;
+
 		if (csuite.value !=
-		    cbor_dec_msg_1._message_1_SUITES_I._suites_int) {
+		    cbor_dec_msg_1.message_1_SUITES_I.suites_int) {
 			ctx->error_code =
 				EDHOC_ERROR_CODE_WRONG_SELECTED_CIPHER_SUITE;
 			return EDHOC_ERROR_MSG_1_PROCESS_FAILURE;
 		}
+
 		break;
 	}
 
-	case _suites__int: {
+	case suites_int_l_c: {
+		if (ARRAY_SIZE(ctx->peer_csuite) <
+		    cbor_dec_msg_1.message_1_SUITES_I.suites_int_l_int_count)
+			return EDHOC_ERROR_BUFFER_TOO_SMALL;
+
+		ctx->peer_csuite_len =
+			cbor_dec_msg_1.message_1_SUITES_I.suites_int_l_int_count;
+		for (size_t i = 0; i < ctx->peer_csuite_len; ++i)
+			ctx->peer_csuite[i].value =
+				cbor_dec_msg_1.message_1_SUITES_I
+					.suites_int_l_int[i];
+
 		if (csuite.value !=
-		    cbor_dec_msg_1._message_1_SUITES_I
-			    ._suites__int_int[cbor_dec_msg_1._message_1_SUITES_I
-						      ._suites__int_int_count -
+		    cbor_dec_msg_1.message_1_SUITES_I
+			    .suites_int_l_int[cbor_dec_msg_1.message_1_SUITES_I
+						      .suites_int_l_int_count -
 					      1]) {
 			ctx->error_code =
 				EDHOC_ERROR_CODE_WRONG_SELECTED_CIPHER_SUITE;
@@ -317,39 +352,39 @@ int edhoc_message_1_process(struct edhoc_context *ctx, const uint8_t *msg_1,
 	}
 
 	/* 3c. Verify ephemeral public key. */
-	if (cbor_dec_msg_1._message_1_G_X.len != csuite.ecc_key_length)
+	if (cbor_dec_msg_1.message_1_G_X.len != csuite.ecc_key_length)
 		return EDHOC_ERROR_MSG_1_PROCESS_FAILURE;
 
-	ctx->dh_peer_pub_key_len = cbor_dec_msg_1._message_1_G_X.len;
-	memcpy(ctx->dh_peer_pub_key, cbor_dec_msg_1._message_1_G_X.value,
+	ctx->dh_peer_pub_key_len = cbor_dec_msg_1.message_1_G_X.len;
+	memcpy(ctx->dh_peer_pub_key, cbor_dec_msg_1.message_1_G_X.value,
 	       csuite.ecc_key_length);
 
 	/* 3d. Verify connection identifier. */
-	switch (cbor_dec_msg_1._message_1_C_I_choice) {
-	case _message_1_C_I_int: {
+	switch (cbor_dec_msg_1.message_1_C_I_choice) {
+	case message_1_C_I_int_c: {
 		if (ONE_BYTE_CBOR_INT_MIN_VALUE >
-			    cbor_dec_msg_1._message_1_C_I_int ||
+			    cbor_dec_msg_1.message_1_C_I_int ||
 		    ONE_BYTE_CBOR_INT_MAX_VALUE <
-			    cbor_dec_msg_1._message_1_C_I_int)
+			    cbor_dec_msg_1.message_1_C_I_int)
 			return EDHOC_ERROR_MSG_1_PROCESS_FAILURE;
 
 		ctx->peer_cid.encode_type = EDHOC_CID_TYPE_ONE_BYTE_INTEGER;
 		ctx->peer_cid.int_value =
-			(int8_t)cbor_dec_msg_1._message_1_C_I_int;
+			(int8_t)cbor_dec_msg_1.message_1_C_I_int;
 		break;
 	}
 
-	case _message_1_C_I_bstr: {
+	case message_1_C_I_bstr_c: {
 		if (ARRAY_SIZE(ctx->peer_cid.bstr_value) <
-		    cbor_dec_msg_1._message_1_C_I_bstr.len)
+		    cbor_dec_msg_1.message_1_C_I_bstr.len)
 			return EDHOC_ERROR_MSG_1_PROCESS_FAILURE;
 
 		ctx->peer_cid.encode_type = EDHOC_CID_TYPE_BYTE_STRING;
 		ctx->peer_cid.bstr_length =
-			cbor_dec_msg_1._message_1_C_I_bstr.len;
+			cbor_dec_msg_1.message_1_C_I_bstr.len;
 		memcpy(ctx->peer_cid.bstr_value,
-		       cbor_dec_msg_1._message_1_C_I_bstr.value,
-		       cbor_dec_msg_1._message_1_C_I_bstr.len);
+		       cbor_dec_msg_1.message_1_C_I_bstr.value,
+		       cbor_dec_msg_1.message_1_C_I_bstr.len);
 		break;
 	}
 
@@ -376,27 +411,27 @@ int edhoc_message_1_process(struct edhoc_context *ctx, const uint8_t *msg_1,
 	}
 
 	/* 4. Process EAD if present. */
-	if (true == cbor_dec_msg_1._message_1_EAD_1_present &&
+	if (true == cbor_dec_msg_1.message_1_EAD_1_m_present &&
 	    NULL != ctx->ead.process) {
 		if (ARRAY_SIZE(ctx->ead_token) - 1 <
-		    cbor_dec_msg_1._message_1_EAD_1._ead_count)
+		    cbor_dec_msg_1.message_1_EAD_1_m.EAD_1_count)
 			return EDHOC_ERROR_BUFFER_TOO_SMALL;
 
 		ctx->nr_of_ead_tokens =
-			cbor_dec_msg_1._message_1_EAD_1._ead_count;
+			cbor_dec_msg_1.message_1_EAD_1_m.EAD_1_count;
 		for (size_t i = 0; i < ctx->nr_of_ead_tokens; ++i) {
 			ctx->ead_token[i].label =
-				cbor_dec_msg_1._message_1_EAD_1._ead[i]
-					._ead_label;
+				cbor_dec_msg_1.message_1_EAD_1_m.EAD_1[i]
+					.ead_x_ead_label;
 			ctx->ead_token[i].value =
-				cbor_dec_msg_1._message_1_EAD_1._ead[i]
-					._ead_value.value;
+				cbor_dec_msg_1.message_1_EAD_1_m.EAD_1[i]
+					.ead_x_ead_value.value;
 			ctx->ead_token[i].value_len =
-				cbor_dec_msg_1._message_1_EAD_1._ead[i]
-					._ead_value.len;
+				cbor_dec_msg_1.message_1_EAD_1_m.EAD_1[i]
+					.ead_x_ead_value.len;
 		}
 
-		ret = ctx->ead.process(ctx->user_ctx, EDHOC_MSG_1,
+		ret = ctx->ead.process(ctx->user_ctx, ctx->message,
 				       ctx->ead_token, ctx->nr_of_ead_tokens);
 
 		if (EDHOC_SUCCESS == ret && NULL != ctx->logger) {