edhoc 1.0.1 → 1.0.3

package/external/libedhoc/include/edhoc_crypto.h

@@ -0,0 +1,331 @@
+/**
+ * \file    edhoc_crypto.h
+ * \author  Kamil Kielbasa
+ * \brief   EDHOC cryptographic interface.
+ * \version 0.4
+ * \date    2024-01-01
+ * 
+ * \copyright Copyright (c) 2024
+ * 
+ */
+
+/* Header guard ------------------------------------------------------------ */
+#ifndef EDHOC_CRYPTO_H
+#define EDHOC_CRYPTO_H
+
+/* Include files ----------------------------------------------------------- */
+#include <stdint.h>
+#include <stddef.h>
+
+/* Defines ----------------------------------------------------------------- */
+/* Types and type definitions ---------------------------------------------- */
+
+/** \defgroup edhoc-interface-crypto-keys EDHOC interface for cryptographics keys
+ * @{
+ */
+
+/**
+ * \brief EDHOC key types for cryptographic keys interface.
+ */
+enum edhoc_key_type {
+	/** Key type for generation of ephemeral Diffie-Hellman key pair. */
+	EDHOC_KT_MAKE_KEY_PAIR,
+	/** Key type for Diffie-Hellman keys agreement. */
+	EDHOC_KT_KEY_AGREEMENT,
+
+	/** Key type for signing. */
+	EDHOC_KT_SIGNATURE,
+	/** Key type for signature verification. */
+	EDHOC_KT_VERIFY,
+
+	/** Key type for HKDF extract. */
+	EDHOC_KT_EXTRACT,
+	/** Key type for HKDF expand. */
+	EDHOC_KT_EXPAND,
+
+	/** Key type for symmetric authenticated encryption. */
+	EDHOC_KT_ENCRYPT,
+	/** Key type for symmetric authenticated decryption. */
+	EDHOC_KT_DECRYPT,
+};
+
+/**
+ * \brief Cryptographic function for key identifier generation.
+ *
+ * \param[in] user_context		User context.
+ * \param key_type                      Requested key type.
+ * \param[in] raw_key                   Key material in binary format.
+ * \param raw_key_length                Size of the \p raw_key buffer in bytes.
+ * \param[out] key_id                   Key identifier.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+typedef int (*edhoc_generate_key_t)(void *user_context,
+				    enum edhoc_key_type key_type,
+				    const uint8_t *raw_key,
+				    size_t raw_key_length, void *key_id);
+
+/**
+ * \brief Cryptographic function for key identifier destroying.
+ *
+ * \param[in] user_context		User context.
+ * \param[in] key_id                    Key identifier.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+typedef int (*edhoc_destroy_key_t)(void *user_context, void *key_id);
+
+/**
+ * \brief Bind structure for cryptographic key identifiers.
+ */
+struct edhoc_keys {
+	/** Generate cryptographic key callback. */
+	edhoc_generate_key_t generate_key;
+	/** Destroy cryptographic key callback. */
+	edhoc_destroy_key_t destroy_key;
+};
+
+/**@}*/
+
+/** \defgroup edhoc-interface-crypto-operations EDHOC interface for cryptographics operations
+ * @{
+ */
+
+/**
+ * \brief Structure for cipher suite value and related algorithms lengths in bytes.
+ */
+struct edhoc_cipher_suite {
+	/** Cipher suite IANA registery value. */
+	int32_t value;
+
+	/** EDHOC AEAD algorithm key length in bytes. */
+	size_t aead_key_length;
+	/** EDHOC AEAD algorithm tag length in bytes. */
+	size_t aead_tag_length;
+	/** EDHOC AEAD algorithm iv length in bytes. */
+	size_t aead_iv_length;
+
+	/** EDHOC hash algorithm: hash length in bytes. */
+	size_t hash_length;
+
+	/** EDHOC MAC length in bytes. */
+	size_t mac_length;
+
+	/** EDHOC ECC algorithm: key length in bytes. */
+	size_t ecc_key_length;
+	/** EDHOC ECC algorithm: signature length in bytes. */
+	size_t ecc_sign_length;
+};
+
+/**
+ * \brief Cryptographic function for generating ephemeral ECDH key pair.
+ *
+ * \param[in] user_context		User context.
+ * \param[in] key_id                    Key identifier.
+ * \param[out] private_key              Private ephemeral ECDH key.
+ * \param private_key_size              Size of the \p private_key buffer in bytes.
+ * \param[out] private_key_length       On success, the number of bytes that make up the ECDH private key.
+ * \param[out] public_key               Public ephemeral ECDH key.
+ * \param public_key_size               Size of the \p public_key buffer in bytes.
+ * \param[out] public_key_length        On success, the number of bytes that make up the ECDH private key.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+typedef int (*edhoc_make_key_pair_t)(
+	void *user_context, const void *key_id, uint8_t *private_key,
+	size_t private_key_size, size_t *private_key_length,
+	uint8_t *public_key, size_t public_key_size, size_t *public_key_length);
+
+/**
+ * \brief Cryptographic function for computing ECDH key agreement.
+ *
+ * \param[in] user_context		User context.
+ * \param[in] key_id                    Key identifier.
+ * \param[in] peer_public_key           Peer public ECDH key.
+ * \param peer_public_key_length        Size of the \p peer_public_key buffer in bytes.
+ * \param[out] shared_secret            ECDH shared secret.
+ * \param shared_secret_size            Size of the \p shared_secret buffer in bytes.
+ * \param[out] shared_secret_length     On success, the number of bytes that make up the ECDH shared secret.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+typedef int (*edhoc_key_agreement_t)(void *user_context, const void *key_id,
+				     const uint8_t *peer_public_key,
+				     size_t peer_public_key_length,
+				     uint8_t *shared_secret,
+				     size_t shared_secret_size,
+				     size_t *shared_secret_length);
+
+/**
+ * \brief Cryptographic function for generating ECDSA sign.
+ *
+ * \param[in] user_context		User context.
+ * \param[in] key_id                    Key identifier.
+ * \param[in] input                     Input message to sign.
+ * \param input_length                  Size of the \p input buffer in bytes.
+ * \param[out] signature                Buffer where the signature is to be written.
+ * \param signature_size                Size of the \p signature buffer in bytes.
+ * \param[out] signature_length         On success, the number of bytes that make up the signature.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+typedef int (*edhoc_signature_t)(void *user_context, const void *key_id,
+				 const uint8_t *input, size_t input_length,
+				 uint8_t *signature, size_t signature_size,
+				 size_t *signature_length);
+
+/**
+ * \brief Cryptographic function for ECDSA signature verification.
+ *
+ * \param[in] user_context		User context.
+ * \param[in] key_id                    Key identifier.
+ * \param[in] input                     Input message to verify.
+ * \param input_length                  Size of the \p input buffer in bytes.
+ * \param[in] signature                 Buffer where the signature is to be written.
+ * \param signature_length              Size of the \p signature buffer in bytes.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+typedef int (*edhoc_verify_t)(void *user_context, const void *key_id,
+			      const uint8_t *input, size_t input_length,
+			      const uint8_t *signature,
+			      size_t signature_length);
+
+/**
+ * \brief Cryptographic function for HKDF extracting.
+ *
+ * \param[in] user_context		User context.
+ * \param[in] key_id                    Key identifier.
+ * \param[in] salt                      Salt for extract.
+ * \param salt_len                      Size of the \p salt buffer in bytes.
+ * \param[out] psuedo_random_key        Buffer where the psuedo random key is to be written.
+ * \param psuedo_random_key_size        Size of the \p psuedo_random_key buffer in bytes.
+ * \param[out] psuedo_random_key_length On success, the number of bytes that make up the psuedo random key.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+typedef int (*edhoc_extract_t)(void *user_context, const void *key_id,
+			       const uint8_t *salt, size_t salt_len,
+			       uint8_t *psuedo_random_key,
+			       size_t psuedo_random_key_size,
+			       size_t *psuedo_random_key_length);
+
+/**
+ * \brief Cryptographic function for HKDF expanding.
+ *
+ * \param[in] user_context		User context.
+ * \param[in] key_id                    Key identifier.
+ * \param[in] info                      Information context.
+ * \param info_length                   Size of the \p info buffer in bytes.
+ * \param[out] output_keying_material   Buffer where the output keying material is to be written.
+ * \param output_keying_material_length Size of the \p output_keying_material buffer in bytes.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+typedef int (*edhoc_expand_t)(void *user_context, const void *key_id,
+			      const uint8_t *info, size_t info_length,
+			      uint8_t *output_keying_material,
+			      size_t output_keying_material_length);
+
+/**
+ * \brief Cryptographic function for AEAD encryption.
+ *
+ * \param[in] user_context		User context.
+ * \param[in] key_id                    Key identifier.
+ * \param[in] nonce                     Nonce or IV to use.
+ * \param nonce_length                  Size of the \p nonce buffer in bytes.
+ * \param[in] additional_data           Additional data that will be authenticated but not encrypted.
+ * \param additional_data_length        Size of the \p additional_data buffer in bytes.
+ * \param[in] plaintext                 Data that will be authenticated and encrypted.
+ * \param plaintext_length              Size of the \p plaintext buffer in bytes.
+ * \param[out] ciphertext               Buffer where the authenticated and encrypted data is to be written.
+ * \param ciphertext_size               Size of the \p ciphertext buffer in bytes.
+ * \param[out] ciphertext_length        On success, the number of bytes that make up the ciphertext.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+typedef int (*edhoc_encrypt_t)(void *user_context, const void *key_id,
+			       const uint8_t *nonce, size_t nonce_length,
+			       const uint8_t *additional_data,
+			       size_t additional_data_length,
+			       const uint8_t *plaintext,
+			       size_t plaintext_length, uint8_t *ciphertext,
+			       size_t ciphertext_size,
+			       size_t *ciphertext_length);
+
+/**
+ * \brief Cryptographic function for AEAD decryption.
+ *
+ * \param[in] user_context		User context.
+ * \param[in] key_id                    Key identifier.
+ * \param[in] nonce                     Nonce or IV to use.
+ * \param nonce_length                  Size of the \p nonce buffer in bytes.
+ * \param[in] additional_data           Additional data that will be authenticated but not encrypted.
+ * \param additional_data_length        Size of the \p additional_data buffer in bytes.
+ * \param[in] ciphertext                Buffer where the data that has been authenticated and encrypted.
+ * \param ciphertext_length             Size of the \p ciphertext buffer in bytes.
+ * \param[out] plaintext                Buffer where the decrypted data is to be written.
+ * \param plaintext_size                Size of the \p plaintext buffer in bytes.
+ * \param[out] plaintext_length         On success, the number of bytes that make up the plaintext.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+typedef int (*edhoc_decrypt_t)(void *user_context, const void *key_id,
+			       const uint8_t *nonce, size_t nonce_length,
+			       const uint8_t *additional_data,
+			       size_t additional_data_length,
+			       const uint8_t *ciphertext,
+			       size_t ciphertext_length, uint8_t *plaintext,
+			       size_t plaintext_size, size_t *plaintext_length);
+
+/**
+ * \brief Cryptographic function for hash computing.
+ *
+ * \param[in] user_context		User context.
+ * \param[in] input                     Input message to hash.
+ * \param input_length                  Size of the \p input buffer in bytes.
+ * \param[in] hash                      Buffer where the hash is to be written.
+ * \param hash_size                     Size of the \p hash buffer in bytes.
+ * \param[out] hash_length              On success, the number of bytes that make up the hash.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+typedef int (*edhoc_hash_t)(void *user_context, const uint8_t *input,
+			    size_t input_length, uint8_t *hash,
+			    size_t hash_size, size_t *hash_length);
+
+/**
+ * \brief Bind structure for cryptographics operations.
+ */
+struct edhoc_crypto {
+	/** Cryptographic function callback for generate ephemeral Diffie-Hellman key pair. */
+	edhoc_make_key_pair_t make_key_pair;
+	/** Cryptographic function callback for Diffie-Helmann key agreement callback. */
+	edhoc_key_agreement_t key_agreement;
+
+	/** Cryptographic function callback for signing. */
+	edhoc_signature_t signature;
+	/** Cryptographic function callback for signature verification. */
+	edhoc_verify_t verify;
+
+	/** Cryptographic function callback for HKDF extract. */
+	edhoc_extract_t extract;
+	/** Cryptographic function callback for HKDF expand. */
+	edhoc_expand_t expand;
+
+	/** Cryptographic function callback for symmetric authenticated encryption. */
+	edhoc_encrypt_t encrypt;
+	/** Cryptographic function callback for symmetric authenticated decryption. */
+	edhoc_decrypt_t decrypt;
+
+	/** Cryptographic function callback for hash computing. */
+	edhoc_hash_t hash;
+};
+
+/**@}*/
+
+/* Module interface variables and constants -------------------------------- */
+/* Extern variables and constant declarations ------------------------------ */
+/* Module interface function declarations ---------------------------------- */
+
+#endif /* EDHOC_CRYPTO_H */

package/external/libedhoc/include/edhoc_ead.h

@@ -0,0 +1,99 @@
+/**
+ * \file    edhoc_ead.h
+ * \author  Kamil Kielbasa
+ * \brief   EDHOC External Authorization Data (EAD) interface.
+ * \version 0.4
+ * \date    2024-01-01
+ * 
+ * \copyright Copyright (c) 2024
+ * 
+ */
+
+/* Header guard ------------------------------------------------------------ */
+#ifndef EDHOC_EAD_H
+#define EDHOC_EAD_H
+
+/* Include files ----------------------------------------------------------- */
+#include <stdint.h>
+#include <stddef.h>
+
+/* Defines ----------------------------------------------------------------- */
+/* Types and type definitions ---------------------------------------------- */
+
+/** \defgroup edhoc-interface-ead EDHOC interface EAD
+ * @{
+ */
+
+/**
+ * \brief Helper type for recognition of EDHOC message in EAD callback.
+ */
+enum edhoc_message {
+	/** EDHOC message 1. */
+	EDHOC_MSG_1,
+	/** EDHOC message 2. */
+	EDHOC_MSG_2,
+	/** EDHOC message 3. */
+	EDHOC_MSG_3,
+	/** EDHOC message 4. */
+	EDHOC_MSG_4,
+};
+
+/**
+ * \brief RFC 9528: 3.8. External Authorization Data (EAD).
+ */
+struct edhoc_ead_token {
+	/** EAD label value. */
+	int32_t label;
+
+	/** EAD buffer. */
+	const uint8_t *value;
+	/** Size of the \p value buffer in bytes. */
+	size_t value_len;
+};
+
+/** 
+ * \brief Callback for external authorization data (EAD) composing.
+ *
+ * \param[in] user_context      User context.
+ * \param message               Message number for context information. (EAD_1, EAD_2, EAD_3 or EAD_4)
+ * \param[in,out] ead_token     Buffer where the generated EAD tokens is to be written.
+ * \param ead_token_size        Number of the \p ead_token.
+ * \param[out] ead_token_len    On success, the number of written EAD tokens.
+ *
+ * \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);
+
+/** 
+ * \brief Callback for external authorization data (EAD) processing.
+ *
+ * \param[in] user_context      User context.
+ * \param message               Message number for context information. (EAD_1, EAD_2, EAD_3 or EAD_4)
+ * \param[in] ead_token         Buffer containing the EAD tokens.
+ * \param ead_token_size        Number of the received EAD tokens in \p ead_token.
+ *
+ * \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);
+
+/**
+ * \brief Bind structure for EAD operations.
+ */
+struct edhoc_ead {
+	/** External authorization data compose callback. */
+	edhoc_ead_compose compose;
+	/** External authorization data process callback. */
+	edhoc_ead_process process;
+};
+
+/**@}*/
+
+/* Module interface variables and constants -------------------------------- */
+/* Extern variables and constant declarations ------------------------------ */
+/* Module interface function declarations ---------------------------------- */
+
+#endif /* EDHOC_EAD_H */

package/external/libedhoc/include/edhoc_macros.h

@@ -0,0 +1,51 @@
+/**
+ * \file    edhoc_macros.h
+ * \author  Kamil Kielbasa
+ * \brief   EDHOC macros and functionlike macros.
+ * \version 0.4
+ * \date    2024-01-01
+ * 
+ * \copyright Copyright (c) 2024
+ * 
+ */
+
+/* Header guard ------------------------------------------------------------ */
+#ifndef EDHOC_MACROS_H
+#define EDHOC_MACROS_H
+
+/* Include files ----------------------------------------------------------- */
+/* Defines ----------------------------------------------------------------- */
+/* Types and type definitions ---------------------------------------------- */
+
+#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
+#else
+    #define ALLOCATE_ARRAY(type, name, size) \
+        type name[size]
+    #define ALLOCATE_ARRAY_SIZEOF(name) sizeof(name)
+#endif
+
+/**
+ * \brief Macro for calculating arrays length.
+ */
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
+#define ARRAY_SIZE_VLA(x) (ALLOCATE_ARRAY_SIZEOF(x) / sizeof(x[0]))
+
+/**
+ * \brief Macro which allows for private access into structure members.
+ */
+#ifndef EDHOC_ALLOW_PRIVATE_ACCESS
+#define EDHOC_PRIVATE(member) private_##member
+#else
+#define EDHOC_PRIVATE(member) member
+#endif
+
+/* Module interface variables and constants -------------------------------- */
+/* Extern variables and constant declarations ------------------------------ */
+/* Module interface function declarations ---------------------------------- */
+
+#endif /* EDHOC_MACROS_H */

package/external/libedhoc/include/edhoc_values.h

@@ -0,0 +1,181 @@
+/**
+ * \file    edhoc_values.h
+ * \author  Kamil Kielbasa
+ * \brief   EDHOC values and error codes.
+ * \version 0.4
+ * \date    2024-01-01
+ * 
+ * \copyright Copyright (c) 2024
+ * 
+ */
+
+/* Header guard ------------------------------------------------------------ */
+#ifndef EDHOC_VALUES_H
+#define EDHOC_VALUES_H
+
+/* Include files ----------------------------------------------------------- */
+#include <stdint.h>
+#include <stddef.h>
+
+/* Defines ----------------------------------------------------------------- */
+/* Types and type definitions ---------------------------------------------- */
+
+/** \defgroup edhoc-error-codes EDHOC error codes
+ * @{
+ */
+
+/** The action was completed successfully. */
+#define EDHOC_SUCCESS ((int)0)
+
+/** An error occurred that does not correspond to any defined failure cause. */
+#define EDHOC_ERROR_GENERIC_ERROR ((int)-100)
+
+/** The requested operation or a parameter is not supported by this implementation. */
+#define EDHOC_ERROR_NOT_SUPPORTED ((int)-101)
+
+/** The requested action is denied by a EDHOC specification. */
+#define EDHOC_ERROR_NOT_PERMITTED ((int)-102)
+
+/** An output buffer is too small. */
+#define EDHOC_ERROR_BUFFER_TOO_SMALL ((int)-103)
+
+/** The requested action cannot be performed in the current state. */
+#define EDHOC_ERROR_BAD_STATE ((int)-104)
+
+/** The parameters passed to the function are invalid. */
+#define EDHOC_ERROR_INVALID_ARGUMENT ((int)-105)
+
+/** There was a CBOR failure inside implementation. */
+#define EDHOC_ERROR_CBOR_FAILURE ((int)-110)
+
+/** There was a cryptographic operation failure inside implementation. */
+#define EDHOC_ERROR_CRYPTO_FAILURE ((int)-111)
+
+/** There was a credentials failure inside implementation. */
+#define EDHOC_ERROR_CREDENTIALS_FAILURE ((int)-112)
+
+/** External authorization data compose failed. */
+#define EDHOC_ERROR_EAD_COMPOSE_FAILURE ((int)-120)
+
+/** External authorization data process failed. */
+#define EDHOC_ERROR_EAD_PROCESS_FAILURE ((int)-121)
+
+/** EDHOC processing of message 1 failure was detected. */
+#define EDHOC_ERROR_MSG_1_PROCESS_FAILURE ((int)-130)
+
+/** EDHOC processing of message 2 failure was detected. */
+#define EDHOC_ERROR_MSG_2_PROCESS_FAILURE ((int)-131)
+
+/** EDHOC processing of message 3 failure was detected. */
+#define EDHOC_ERROR_MSG_3_PROCESS_FAILURE ((int)-132)
+
+/** EDHOC processing of message 4 failure was detected. */
+#define EDHOC_ERROR_MSG_4_PROCESS_FAILURE ((int)-133)
+
+/** EDHOC ephemeral Diffie-Hellman key agreement failure was detected. */
+#define EDHOC_ERROR_EPHEMERAL_DIFFIE_HELLMAN_FAILURE ((int)-134)
+
+/** EDHOC computing of transcript hash failure was detected. */
+#define EDHOC_ERROR_TRANSCRIPT_HASH_FAILURE ((int)-135)
+
+/** EDHOC computing of pseudorandom key failure was detected. */
+#define EDHOC_ERROR_PSEUDORANDOM_KEY_FAILURE ((int)-136)
+
+/** EDHOC MAC_2 is incorrect. */
+#define EDHOC_ERROR_INVALID_MAC_2 ((int)-137)
+
+/** EDHOC Signature_2 or MAC_2 is incorrect. */
+#define EDHOC_ERROR_INVALID_SIGN_OR_MAC_2 ((int)-138)
+
+/** EDHOC MAC_3 is incorrect. */
+#define EDHOC_ERROR_INVALID_MAC_3 ((int)-139)
+
+/** EDHOC Signature_3 or MAC_3 is incorrect. */
+#define EDHOC_ERROR_INVALID_SIGN_OR_MAC_3 ((int)-140)
+
+/**@}*/
+
+/** \defgroup edhoc-values-cbor-one-byte EDHOC CBOR one byte
+ *
+ * \note It must follow the RFC 9528: 3.3.2. Representation of Byte String Identifiers.
+ *
+ * @{
+ */
+
+/** Minimum value for CBOR one byte integer. */
+#define ONE_BYTE_CBOR_INT_MIN_VALUE ((int32_t)-24)
+
+/** Maximum value for CBOR one byte integer. */
+#define ONE_BYTE_CBOR_INT_MAX_VALUE ((int32_t)23)
+
+/**@}*/
+
+/** \defgroup edhoc-values-extract EDHOC extract labels
+ * @{
+ */
+
+/** KEYSTREAM_2 from RFC 9528: 4.1.2. EDHOC_Expand and EDHOC_KDF. */
+#define EDHOC_EXTRACT_PRK_INFO_LABEL_KEYSTERAM_2 ((size_t)0)
+
+/** SALT_3e2m from RFC 9528: 4.1.2. EDHOC_Expand and EDHOC_KDF. */
+#define EDHOC_EXTRACT_PRK_INFO_LABEL_SALT_3E2M ((size_t)1)
+
+/** MAC_2 from RFC 9528: 4.1.2. EDHOC_Expand and EDHOC_KDF. */
+#define EDHOC_EXTRACT_PRK_INFO_LABEL_MAC_2 ((size_t)2)
+
+/** K_3 from RFC 9528: 4.1.2. EDHOC_Expand and EDHOC_KDF. */
+#define EDHOC_EXTRACT_PRK_INFO_LABEL_K_3 ((size_t)3)
+
+/** IV_3 from RFC 9528: 4.1.2. EDHOC_Expand and EDHOC_KDF. */
+#define EDHOC_EXTRACT_PRK_INFO_LABEL_IV_3 ((size_t)4)
+
+/** SALT_4e3m from RFC 9528: 4.1.2. EDHOC_Expand and EDHOC_KDF. */
+#define EDHOC_EXTRACT_PRK_INFO_LABEL_SALT_4E3M ((size_t)5)
+
+/** MAC_3 from RFC 9528: 4.1.2. EDHOC_Expand and EDHOC_KDF. */
+#define EDHOC_EXTRACT_PRK_INFO_LABEL_MAC_3 ((size_t)6)
+
+/** PRK_out from RFC 9528: 4.1.2. EDHOC_Expand and EDHOC_KDF. */
+#define EDHOC_EXTRACT_PRK_INFO_LABEL_PRK_OUT ((size_t)7)
+
+/** K_4 from RFC 9528: 4.1.2. EDHOC_Expand and EDHOC_KDF. */
+#define EDHOC_EXTRACT_PRK_INFO_LABEL_K_4 ((size_t)8)
+
+/** IV_4 from RFC 9528: 4.1.2. EDHOC_Expand and EDHOC_KDF. */
+#define EDHOC_EXTRACT_PRK_INFO_LABEL_IV_4 ((size_t)9)
+
+/** PRK_Exporter from RFC 9528: 4.2.1. EDHOC_Exporter. */
+#define EDHOC_EXTRACT_PRK_INFO_LABEL_PRK_EXPORTER ((size_t)10)
+
+/** PRK_out from RFC 9528: 4.1.3. PRK_out. */
+#define EDHOC_EXTRACT_PRK_INFO_LABEL_NEW_PRK_OUT ((size_t)11)
+
+/**
+ * \brief RFC 9528: A.1. Deriving the OSCORE Security Context
+ */
+
+/** EDHOC exporter label for OSCORE Master Secret from
+ * RFC 9528: A.1. Deriving the OSCORE Security Context. */
+#define OSCORE_EXTRACT_LABEL_MASTER_SECRET ((size_t)0)
+
+/** EDHOC exporter label for OSCORE Master Salt from
+ * RFC 9528: A.1. Deriving the OSCORE Security Context. */
+#define OSCORE_EXTRACT_LABEL_MASTER_SALT ((size_t)1)
+
+/**
+ * \brief RFC 9528: 10.1. EDHOC Exporter Label Registry
+ */
+
+/** Minimum value for EDHOC exporter label for private usage. */
+#define EDHOC_PRK_EXPORTER_PRIVATE_LABEL_MINIMUM ((size_t)32768)
+
+/** Maximum value for EDHOC exporter label for private usage. */
+#define EDHOC_PRK_EXPORTER_PRIVATE_LABEL_MAXIMUM ((size_t)65535)
+
+/* Module interface variables and constants -------------------------------- */
+/* Extern variables and constant declarations ------------------------------ */
+/* Module interface function declarations ---------------------------------- */
+
+/**@}*/
+
+#endif /* EDHOC_VALUES_H */