edhoc 1.0.1 → 1.0.3

package/external/libedhoc/externals/zcbor/tests/unit/test3_float16/src/main.c

@@ -0,0 +1,202 @@
+/*
+ * Copyright (c) 2022 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifdef ZCBOR_VERBOSE
+
+#include <zephyr/ztest.h>
+
+ZTEST(zcbor_unit_tests3, test_skip)
+{
+	printk("Skip on VERBOSE builds because of print output volume.\n");
+}
+
+#else /* ZCBOR_VERBOSE */
+
+#include <zephyr/ztest.h>
+#include "zcbor_decode.h"
+#include "zcbor_encode.h"
+#include "zcbor_debug.h"
+
+#include <math.h>
+
+__attribute__((used))
+static uint16_t switch_bytes(uint16_t in)
+{
+	return (in >> 8) | (in << 8);
+}
+
+/* These are created by
+ * ld -r -b binary -o fp_bytes_decode.o fp_bytes_decode.bin */
+extern uint8_t _binary_fp_bytes_decode_bin_start[];
+extern uint8_t _binary_fp_bytes_decode_bin_end[];
+extern uint8_t _binary_fp_bytes_decode_bin_size[];
+
+ZTEST(zcbor_unit_tests3, test_float16_decode)
+{
+#ifdef ZCBOR_BIG_ENDIAN
+	float *fps = ((float *)_binary_fp_bytes_decode_bin_start) + 0x10000;
+#else
+	float *fps = (float *)_binary_fp_bytes_decode_bin_start;
+#endif
+	uint8_t payload[3] = {0xf9, 0, 0};
+
+	zassert_equal((size_t)&_binary_fp_bytes_decode_bin_size, 0x10000 * sizeof(float) * 2, "0x%x != 0x%x", (size_t)&_binary_fp_bytes_decode_bin_size, 0x10000 * sizeof(float));
+
+	for (int i = 0; i <= 0xFFFF; i++) {
+		uint16_t i_be = i;
+#ifndef ZCBOR_BIG_ENDIAN
+		i_be = switch_bytes(i);
+#endif
+		*(uint16_t *)&payload[1] = i_be;
+
+		float out;
+		ZCBOR_STATE_D(state_d, 0, payload, sizeof(payload), 1);
+
+		zassert_true(zcbor_float16_decode(state_d, &out), NULL);
+		if (isnan(fps[i])) {
+			zassert_true(isnan(out), "Expected NaN (i = %d)\n", i);
+		} else {
+			zassert_equal(out, fps[i], "Failed i 0x%x (0x%x != 0x%x)\n", i, *(uint32_t *)&out, *(uint32_t *)&fps[i]);
+		}
+
+		ZCBOR_STATE_E(state_e, 0, payload, sizeof(payload), 0);
+
+		zassert_true(zcbor_float16_put(state_e, out));
+		zassert_equal(*(uint16_t *)&payload[1], i_be, NULL);
+	}
+}
+
+
+/* These are created by
+ * ld -r -b binary -o fp_bytes_encode.o fp_bytes_encode.bin */
+extern uint8_t _binary_fp_bytes_encode_bin_start[];
+extern uint8_t _binary_fp_bytes_encode_bin_end[];
+extern uint8_t _binary_fp_bytes_encode_bin_size[];
+
+/**
+ * fp_bytes_encode.bin contains results from conversion from float32 to float16.
+ * As an optimization, fp_bytes_encode.bin contains only values for the positive
+ * nonzero_finite part.
+
+ * positive:
+ * zero:           0x00000000 0x33000000
+ * nonzero finite: 0x33000001 0x477fefff
+ * infinite:       0x477ff000 0x7f800000
+ * nan:            0x7f800001 0x7fffffff
+ *
+ * negative:
+ * zero:           0x80000000 0xb3000000
+ * nonzero finite: 0xb3000001 0xc77fefff
+ * infinite:       0xc77ff000 0xff800000
+ * nan:            0xff800001 0xffffffff
+*/
+#define START_ZERO           0x00000000
+#define START_NONZERO_FINITE 0x33000001
+#define START_INFINITE       0x477ff000
+#define START_NAN            0x7f800001
+
+/* Return float16 results from fp_bytes_encode.bin */
+static uint16_t get_fp_bytes()
+{
+#ifdef CONFIG_BIG_ENDIAN
+	uint32_t *fps = ((uint32_t *)_binary_fp_bytes_encode_bin_start) + 31742;
+#else
+	uint32_t *fps = (uint32_t *)_binary_fp_bytes_encode_bin_start;
+#endif
+	static uint16_t retval = 0;
+	static uint32_t i = 0;
+
+	if (i++ == fps[retval]) {
+		retval++;
+	}
+
+	return retval + 1;
+}
+
+
+/* Test a single value, and its negative counterpart. */
+static void do_test(uint32_t i, uint16_t exp_value)
+{
+	uint8_t payload[6];
+
+	ZCBOR_STATE_E(state_e, 0, payload, sizeof(payload), 0);
+	uint32_t i2 = i + 0x80000000; /* Negative i */
+
+	/* Reinterpret as floats. */
+	float in = *(float *)&i;
+	float in2 = *(float *)&i2;
+
+	zassert_true(zcbor_float16_put(state_e, in), NULL); /* Encode positive i */
+	zassert_true(zcbor_float16_put(state_e, in2), NULL); /* Encode negative i (i2). */
+
+#ifndef ZCBOR_BIG_ENDIAN
+	*(uint16_t*)&payload[1] = switch_bytes(*(uint16_t*)&payload[1]);
+	*(uint16_t*)&payload[4] = switch_bytes(*(uint16_t*)&payload[4]);
+#endif
+
+	if ((i % 0x800000) == 0) {
+		static const uint8_t move_cursor_up[] = {0x1b, 0x5b, 0x41, 0};
+		printk("%s", move_cursor_up);
+		printk("\r%d%%\n", (int)((double)(i) / 0x80000000 * 100));
+	}
+
+	/* Check positive and negative. */
+	zassert_true((*(uint16_t*)&payload[1] == exp_value)
+				&& (*(uint16_t*)&payload[4] == exp_value + 0x8000),
+			"Failed i 0x%x (0x%x != 0x%x) or (0x%x != 0x%x)\n", i,
+			*(uint16_t*)&payload[1], exp_value,
+			*(uint16_t*)&payload[4], exp_value + 0x8000);
+}
+
+
+static void do_test_nan(uint32_t i)
+{
+	uint8_t payload[6];
+	ZCBOR_STATE_E(state_e, 0, payload, sizeof(payload), 0);
+	ZCBOR_STATE_D(state_d, 0, payload, sizeof(payload), 2);
+	float in = *(float *)&i;
+	uint32_t i2 = i + 0x80000000;
+	float in2 = *(float *)&i2;
+	float out;
+	float out2;
+
+	if (((i + 1) % 0x800000) == 0) {
+		static const uint8_t move_cursor_up[] = {0x1b, 0x5b, 0x41, 0};
+		printk("%s", move_cursor_up);
+		printk("\r%d%%\n", (int)((double)(i + 1) / 0x80000000 * 100));
+	}
+
+	zassert_true(zcbor_float16_put(state_e, in), NULL);
+	zassert_true(zcbor_float16_put(state_e, in2), NULL);
+	zassert_true(zcbor_float16_decode(state_d, &out), NULL);
+	zassert_true(zcbor_float16_decode(state_d, &out2), NULL);
+	zassert_true(isnan(out), "Expected NaN: 0x%x (i = 0x%x)\n", switch_bytes(*(uint16_t *)&payload[1]), i);
+	zassert_true(isnan(out2), "Expected NaN: 0x%x (i = 0x%x)\n", switch_bytes(*(uint16_t *)&payload[4]), i2);
+}
+
+
+ZTEST(zcbor_unit_tests3, test_float16_encode)
+{
+	zassert_equal((size_t)&_binary_fp_bytes_encode_bin_size, 31742 * 4 * 2, NULL);
+	printk("\n");
+
+	for (uint32_t i = START_ZERO; i < START_NONZERO_FINITE; i++) {
+		do_test(i, 0);
+	}
+	for (uint32_t i = START_NONZERO_FINITE; i < START_INFINITE; i++) {
+		do_test(i, get_fp_bytes());
+	}
+	for (uint32_t i = START_INFINITE; i < START_NAN; i++) {
+		do_test(i, 0x7c00);
+	}
+	for (uint32_t i = START_NAN; i < 0x80000000; i++) {
+		do_test_nan(i);
+	}
+}
+
+#endif /* ZCBOR_VERBOSE */
+
+ZTEST_SUITE(zcbor_unit_tests3, NULL, NULL, NULL, NULL, NULL);

package/external/libedhoc/include/edhoc.h

@@ -0,0 +1,393 @@
+/**
+ * \file    edhoc.h
+ * \author  Kamil Kielbasa
+ * \brief   EDHOC API.
+ * \version 0.4
+ * \date    2024-01-01
+ * 
+ * \copyright Copyright (c) 2024
+ * 
+ */
+
+/* Header guard ------------------------------------------------------------ */
+#ifndef EDHOC_H
+#define EDHOC_H
+
+/* Include files ----------------------------------------------------------- */
+
+/* Standard library headers: */
+#include <stdint.h>
+#include <stddef.h>
+
+/* EDHOC headers: */
+#include "edhoc_context.h"
+#include "edhoc_credentials.h"
+#include "edhoc_crypto.h"
+#include "edhoc_ead.h"
+#include "edhoc_macros.h"
+#include "edhoc_values.h"
+
+/* Defines ----------------------------------------------------------------- */
+
+/** \defgroup edhoc-api-version EDHOC API version
+ * @{
+ */
+
+/** The major version of this implementation of the EDHOC API. */
+#define EDHOC_API_VERSION_MAJOR 1
+
+/** The minor version of this implementation of the EDHOC API. */
+#define EDHOC_API_VERSION_MINOR 0
+
+/**@}*/
+
+/* Types and type definitions ---------------------------------------------- */
+/* Module interface variables and constants -------------------------------- */
+/* Extern variables and constant declarations ------------------------------ */
+/* Module interface function declarations ---------------------------------- */
+
+/** \defgroup edhoc-api-setters EDHOC API setters
+ * @{
+ */
+
+/** 
+ * \brief Initialize EDHOC context.
+ *
+ * \param[in,out] edhoc_context         EDHOC context.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+int edhoc_context_init(struct edhoc_context *edhoc_context);
+
+/** 
+ * \brief Deinitialize EDHOC context.
+ *
+ * \param[in,out] edhoc_context         EDHOC context.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+int edhoc_context_deinit(struct edhoc_context *edhoc_context);
+
+/** 
+ * \brief Set EDHOC method.
+ *
+ * \param[in,out] edhoc_context         EDHOC context.
+ * \param method                        EDHOC method.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+int edhoc_set_method(struct edhoc_context *edhoc_context,
+		     enum edhoc_method method);
+
+/** 
+ * \brief Set EDHOC supproted cipher suites.
+ *
+ * \param[in,out] edhoc_context         EDHOC context.
+ * \param[in] cipher_suite              EDHOC cipher suites.
+ * \param cipher_suite_length           Number of the \p cipher_suite.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+int edhoc_set_cipher_suites(struct edhoc_context *edhoc_context,
+			    const struct edhoc_cipher_suite *cipher_suite,
+			    size_t cipher_suite_length);
+
+/** 
+ * \brief Set EDHOC connection identifier.
+ *
+ * \param[in,out] edhoc_context         EDHOC context.
+ * \param[in] connection_id             EDHOC connection identifier.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+int edhoc_set_connection_id(struct edhoc_context *edhoc_context,
+			    struct edhoc_connection_id connection_id);
+
+/** 
+ * \brief Set user context.
+ *
+ * \param[in,out] edhoc_context         EDHOC context.
+ * \param[in] user_context              User context.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+int edhoc_set_user_context(struct edhoc_context *edhoc_context,
+			   void *user_context);
+
+/** 
+ * \brief Bind EDHOC external authorization data (EAD) callbacks.
+ *
+ * \param[in,out] edhoc_context         EDHOC context.
+ * \param ead                           EDHOC EAD structure with callbacks.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+int edhoc_bind_ead(struct edhoc_context *edhoc_context, struct edhoc_ead ead);
+
+/** 
+ * \brief Bind EDHOC cryptographic keys callbacks.
+ *
+ * \param[in,out] edhoc_context         EDHOC context.
+ * \param keys                          EDHOC cryptographic keys structure with callbacks.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+int edhoc_bind_keys(struct edhoc_context *edhoc_context,
+		    struct edhoc_keys keys);
+
+/** 
+ * \brief Bind EDHOC cryptographic operations callbacks.
+ *
+ * \param[in,out] edhoc_context         EDHOC context.
+ * \param crypto                        EDHOC cryptographic operations structure with callbacks.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+int edhoc_bind_crypto(struct edhoc_context *edhoc_context,
+		      struct edhoc_crypto crypto);
+
+/** 
+ * \brief Bind EDHOC authentication credentials callbacks.
+ *
+ * \param[in,out] edhoc_context         EDHOC context.
+ * \param credentials                   EDHOC authentication credentials structure with callbacks.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+int edhoc_bind_credentials(struct edhoc_context *edhoc_context,
+			   struct edhoc_credentials credentials);
+
+/**@}*/
+
+/** \defgroup edhoc-api-messages EDHOC messages API
+ * @{
+ */
+
+/** 
+ * \brief Compose EDHOC message 1.
+ *
+ * \param[in,out] edhoc_context         EDHOC context.
+ * \param[out] message_1                Buffer where the generated message 1 is to be written.
+ * \param message_1_size                Size of the \p message_1 buffer in bytes.
+ * \param[out] message_1_length         On success, the number of bytes that make up the message 1.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+int edhoc_message_1_compose(struct edhoc_context *edhoc_context,
+			    uint8_t *message_1, size_t message_1_size,
+			    size_t *message_1_length);
+
+/**
+ * \brief Process EDHOC message 1.
+ *
+ * \param[in,out] edhoc_context         EDHOC context.
+ * \param[in] message_1                 Buffer containing the message 1.
+ * \param message_1_length              Size of the \p message_1 buffer in bytes.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+int edhoc_message_1_process(struct edhoc_context *edhoc_context,
+			    const uint8_t *message_1, size_t message_1_length);
+
+/**
+ * \brief Compose EDHOC message 2.
+ *
+ * \param[in,out] edhoc_context         EDHOC context.
+ * \param[out] message_2                Buffer where the generated message 2 is to be written.
+ * \param message_2_size                Size of the \p message_2 buffer in bytes.
+ * \param[out] message_2_length         On success, the number of bytes that make up the message 2.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+int edhoc_message_2_compose(struct edhoc_context *edhoc_context,
+			    uint8_t *message_2, size_t message_2_size,
+			    size_t *message_2_length);
+
+/**
+ * \brief Process EDHOC message 2.
+ *
+ * \param[in,out] edhoc_context         EDHOC context.
+ * \param[in] message_2                 Buffer containing the message 2.
+ * \param message_2_length              Size of the \p message_2 buffer in bytes.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+int edhoc_message_2_process(struct edhoc_context *edhoc_context,
+			    const uint8_t *message_2, size_t message_2_length);
+
+/**
+ * \brief Compose EDHOC message 3.
+ *
+ * \param[in,out] edhoc_context         EDHOC context.
+ * \param[out] message_3                Buffer where the generated message 3 is to be written.
+ * \param message_3_size                Size of the \p message_3 buffer in bytes.
+ * \param[out] message_3_length         On success, the number of bytes that make up the message 3.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+int edhoc_message_3_compose(struct edhoc_context *edhoc_context,
+			    uint8_t *message_3, size_t message_3_size,
+			    size_t *message_3_length);
+
+/**
+ * \brief Process EDHOC message 3.
+ *
+ * \param[in,out] edhoc_context         EDHOC context.
+ * \param[in] message_3                 Buffer containing the message 3.
+ * \param message_3_length              Size of the \p message_3 buffer in bytes.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+int edhoc_message_3_process(struct edhoc_context *edhoc_context,
+			    const uint8_t *message_3, size_t message_3_length);
+
+/**
+ * \brief Compose EDHOC message 4.
+ *
+ * \param[in,out] edhoc_context         EDHOC context.
+ * \param[out] message_4                Buffer where the generated message 4 is to be written.
+ * \param message_4_size                Size of the \p message_4 buffer in bytes.
+ * \param[out] message_4_length         On success, the number of bytes that make up the message 4.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+int edhoc_message_4_compose(struct edhoc_context *edhoc_context,
+			    uint8_t *message_4, size_t message_4_size,
+			    size_t *message_4_length);
+
+/**
+ * \brief Process EDHOC message 4.
+ *
+ * \param[in,out] edhoc_context         EDHOC context.
+ * \param[in] message_4                 Buffer containing the message 4.
+ * \param message_4_length              Size of the \p message_4 buffer in bytes.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+int edhoc_message_4_process(struct edhoc_context *edhoc_context,
+			    const uint8_t *message_4, size_t message_4_length);
+
+/**
+ * \brief Compose EDHOC message error.
+ *
+ * \param[out] message_error            Buffer where the generated message error is to be written.
+ * \param message_error_size            Size of the \p message_error buffer in bytes.
+ * \param[out] message_error_length     On success, the number of bytes that make up the message error.
+ * \param error_code                    EDHOC error code.
+ * \param[in] error_info                EDHOC error information.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+int edhoc_message_error_compose(uint8_t *message_error,
+				size_t message_error_size,
+				size_t *message_error_length,
+				enum edhoc_error_code error_code,
+				const struct edhoc_error_info *error_info);
+
+/**
+ * \brief Process EDHOC message error.
+ *
+ * \param[in] message_error             Buffer containing the message error.
+ * \param message_error_length          Size of the \p message_error buffer in bytes.
+ * \param[out] error_code               EDHOC error code.
+ * \param[out] error_info               EDHOC error information.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+int edhoc_message_error_process(const uint8_t *message_error,
+				size_t message_error_length,
+				enum edhoc_error_code *error_code,
+				struct edhoc_error_info *error_info);
+
+/**@}*/
+
+/** \defgroup edhoc-api-exporters EDHOC exporters API
+ * @{
+ */
+
+/**
+ * \brief Psuedorandom key exporter for derivation keying material.
+ * 
+ * \param[in,out] edhoc_context         EDHOC context.
+ * \param label                         PRK exporter label.
+ * \param[out] secret                   Buffer where the generated secret is to be written.
+ * \param secret_length                 Size of the \p secret buffer in bytes.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure. 
+ */
+int edhoc_export_prk_exporter(struct edhoc_context *edhoc_context, size_t label,
+			      uint8_t *secret, size_t secret_length);
+
+/**
+ * \brief Export key update for the new OSCORE security session.
+ *
+ * \param[in,out] edhoc_context         EDHOC context.
+ * \param[in] entropy                   Buffer containing the entropy for key update.
+ * \param entropy_length                Size of the \p entropy buffer in bytes.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+int edhoc_export_key_update(struct edhoc_context *edhoc_context,
+			    const uint8_t *entropy, size_t entropy_length);
+
+/**
+ * \brief Export the OSCORE security session.
+ *
+ * \param[in,out] edhoc_context         EDHOC context.
+ * \param[out] master_secret            Buffer where the exported master secret is to be written.
+ * \param master_secret_length          Size of the \p master_secret buffer in bytes.
+ * \param[out] master_salt              Buffer where the exported master salt is to be written.
+ * \param master_salt_length            Size of the \p master_salt buffer in bytes.
+ * \param[out] sender_id                Buffer where the exported sender id is to be written.
+ * \param sender_id_size                Size of the \p sender_id buffer in bytes.
+ * \param[out] sender_id_length         On success, the number of bytes that make up the sender id.
+ * \param[out] recipient_id             Buffer where the exported recipient id is to be written.
+ * \param recipient_id_size             Size of the \p recipient_id buffer in bytes.
+ * \param[out] recipient_id_length      On success, the number of bytes that make up the recipient id.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+int edhoc_export_oscore_session(struct edhoc_context *edhoc_context,
+				uint8_t *master_secret,
+				size_t master_secret_length,
+				uint8_t *master_salt, size_t master_salt_length,
+				uint8_t *sender_id, size_t sender_id_size,
+				size_t *sender_id_length, uint8_t *recipient_id,
+				size_t recipient_id_size,
+				size_t *recipient_id_length);
+
+/**@}*/
+
+/** \defgroup edhoc-api-error EDHOC errors API
+ * @{
+ */
+
+/**
+ * \brief EDHOC error getter.
+ * 
+ * \param[in] edhoc_context             EDHOC context. 
+ * \param[out] error_code               EDHOC error code.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+int edhoc_error_get_code(const struct edhoc_context *edhoc_context,
+			 enum edhoc_error_code *error_code);
+
+/**
+ * \brief EDHOC cipher suites getter in case of \p EDHOC_ERROR_CODE_WRONG_SELECTED_CIPHER_SUITE.
+ * 
+ * \param[in] edhoc_context             EDHOC context. 
+ * \param[out] cipher_suites            Buffer where the cipher suites values is to be written.
+ * \param cipher_suites_size            Size of the \p cipher_suites buffer in entries.
+ * \param[out] cipher_suites_length     On success, the number of entires that make up the cipher suites.
+ *
+ * \return EDHOC_SUCCESS on success, otherwise failure.
+ */
+int edhoc_error_get_cipher_suites(const struct edhoc_context *edhoc_context,
+				  int32_t *cipher_suites,
+				  size_t cipher_suites_size,
+				  size_t *cipher_suites_length);
+
+/**@}*/
+
+#endif /* EDHOC_H */