edhoc 1.0.0 → 1.0.2

package/include/EdhocEadManager.h

@@ -0,0 +1,151 @@
+#ifndef EDHOC_EAD_MANAGER_H
+#define EDHOC_EAD_MANAGER_H
+
+#include <napi.h>
+#include <map>
+#include <vector>
+
+extern "C" {
+#include "edhoc.h"
+}
+
+/**
+ * @brief Type definition for the EAD (External Authorization Data) map.
+ */
+using EadMap = std::map<int, std::vector<uint8_t>>;
+using EadMapVector = std::vector<EadMap>;
+using EadBufferMap = std::map<enum edhoc_message, EadMapVector>;
+
+/**
+ * @class EdhocEadManager
+ * @brief Manages the storage and retrieval of EAD (External Authorization Data)
+ * for different EDHOC messages.
+ *
+ * The EdhocEadManager class provides methods to store, retrieve, and clear EAD
+ * for different EDHOC messages. It also includes static callback functions for
+ * composing and processing EAD tokens.
+ */
+class EdhocEadManager {
+ public:
+  /**
+   * @struct edhoc_ead
+   * @brief Libedhoc's bind structure for EAD operations.
+   */
+  struct edhoc_ead ead;
+
+  /**
+   * @brief Default constructor for the EdhocEadManager class.
+   */
+  EdhocEadManager();
+
+  /**
+   * @brief Destructor for the EdhocEadManager class.
+   */
+  ~EdhocEadManager();
+
+  /**
+   * @brief Stores the EAD for a specific EDHOC message and label.
+   *
+   * @param message The EDHOC message type.
+   * @param label The label associated with the EAD.
+   * @param ead The EAD data to be stored.
+   */
+  void StoreEad(enum edhoc_message message,
+                int label,
+                const std::vector<uint8_t>& ead);
+
+  /**
+   * @brief Stores the EAD for a specific EDHOC message using a Napi::Array.
+   *
+   * @param message The EDHOC message type.
+   * @param eadArray The Napi::Array containing the EAD data to be stored.
+   */
+  void StoreEad(enum edhoc_message message, const Napi::Array& eadArray);
+
+  /**
+   * @brief Retrieves the EAD for a specific EDHOC message.
+   *
+   * @param message The EDHOC message type.
+   * @return A constant pointer to the EadMapVector containing the EAD data for
+   * the specified message.
+   */
+  const EadMapVector* GetEadByMessage(enum edhoc_message message) const;
+
+  /**
+   * @brief Retrieves the EAD for a specific EDHOC message as a Napi::Array.
+   *
+   * @param env The Napi::Env object.
+   * @param message The EDHOC message type.
+   * @return A Napi::Array containing the EAD data for the specified message.
+   */
+  Napi::Array GetEadByMessage(Napi::Env& env, enum edhoc_message message) const;
+
+  /**
+   * @brief Clears the EAD for a specific EDHOC message.
+   *
+   * @param message The EDHOC message type.
+   */
+  void ClearEadByMessage(enum edhoc_message message);
+
+ private:
+  EadBufferMap eadBuffers;  ///< Map to store the EAD buffers for different
+                            ///< EDHOC messages.
+
+  /**
+   * @brief Static callback function for composing an EAD token.
+   *
+   * @param user_context The user context.
+   * @param message The EDHOC message type.
+   * @param ead_token The EAD token structure to be composed.
+   * @param ead_token_size The size of the EAD token structure.
+   * @param ead_token_len The length of the composed EAD token.
+   * @return The status of the compose operation.
+   */
+  static int ComposeEad(void* user_context,
+                        enum edhoc_message message,
+                        struct edhoc_ead_token* ead_token,
+                        size_t ead_token_size,
+                        size_t* ead_token_len);
+
+  /**
+   * @brief Static callback function for processing an EAD token.
+   *
+   * @param user_context The user context.
+   * @param message The EDHOC message type.
+   * @param ead_token The EAD token structure to be processed.
+   * @param ead_token_size The size of the EAD token structure.
+   * @return The status of the process operation.
+   */
+  static int ProcessEad(void* user_context,
+                        enum edhoc_message message,
+                        const struct edhoc_ead_token* ead_token,
+                        size_t ead_token_size);
+
+  /**
+   * @brief Calls the static ComposeEad callback function.
+   *
+   * @param message The EDHOC message type.
+   * @param ead_token The EAD token structure to be composed.
+   * @param ead_token_size The size of the EAD token structure.
+   * @param ead_token_len The length of the composed EAD token.
+   * @return The status of the compose operation.
+   */
+  int callComposeEad(enum edhoc_message message,
+                     struct edhoc_ead_token* ead_token,
+                     size_t ead_token_size,
+                     size_t* ead_token_len);
+
+  /**
+   * @brief Calls the static ProcessEad callback function.
+   *
+   * @param message The EDHOC message type.
+   * @param ead_token The EAD token structure to be processed.
+   * @param ead_token_size The size of the EAD token structure.
+   * @return The status of the process operation.
+   */
+  int callProcessEad(enum edhoc_message message,
+                     const struct edhoc_ead_token* ead_token,
+                     size_t ead_token_size);
+};
+
+#endif  // EDHOC_EAD_MANAGER_H

package/include/EdhocExportAsyncWorker.h

@@ -0,0 +1,71 @@
+#ifndef EDHOC_EXPORT_ASYNC_WORKER_H
+#define EDHOC_EXPORT_ASYNC_WORKER_H
+
+#include <napi.h>
+#include <functional>
+#include <vector>
+
+extern "C" {
+#include "edhoc.h"
+}
+
+/**
+ * @class EdhocExportAsyncWorker
+ * @brief A class that represents an asynchronous worker for exporting Edhoc
+ * context.
+ *
+ * This class inherits from Napi::AsyncWorker and provides methods for executing
+ * the export operation asynchronously and handling the result or error.
+ */
+class EdhocExportAsyncWorker : public Napi::AsyncWorker {
+ public:
+  /**
+   * @brief The type definition for the callback function.
+   */
+  using CallbackType = std::function<void(Napi::Env)>;
+
+  /**
+   * @brief Constructs a new EdhocExportAsyncWorker object.
+   *
+   * @param env The Napi::Env object representing the current environment.
+   * @param deferred The Napi::Promise::Deferred object representing the
+   * deferred promise.
+   * @param context The reference to the edhoc_context structure.
+   */
+  EdhocExportAsyncWorker(Napi::Env& env,
+                         Napi::Promise::Deferred deferred,
+                         struct edhoc_context& context);
+
+  /**
+   * @brief Destroys the EdhocExportAsyncWorker object.
+   */
+  ~EdhocExportAsyncWorker() override;
+
+  /**
+   * @brief Executes the asynchronous worker task.
+   */
+  void Execute() override;
+
+  /**
+   * @brief Executes when the asynchronous worker task is completed
+   * successfully.
+   */
+  void OnOK() override;
+
+  /**
+   * @brief Executes when an error occurs during the asynchronous worker task.
+   * @param error The Napi::Error object.
+   */
+  void OnError(const Napi::Error& error) override;
+
+ private:
+  Napi::Promise::Deferred deferred;  ///< The deferred promise object.
+  struct edhoc_context&
+      context;  ///< The reference to the edhoc_context structure.
+  std::vector<uint8_t> masterSecret;  ///< The master secret.
+  std::vector<uint8_t> masterSalt;    ///< The master salt.
+  std::vector<uint8_t> senderId;      ///< The sender ID.
+  std::vector<uint8_t> recipientId;   ///< The recipient ID.
+};
+
+#endif  // EDHOC_EXPORT_ASYNC_WORKER_H

package/include/EdhocProcessAsyncWorker.h

@@ -0,0 +1,76 @@
+#ifndef EDHOC_PROCESS_ASYNC_WORKER_H
+#define EDHOC_PROCESS_ASYNC_WORKER_H
+
+#include <napi.h>
+#include <vector>
+
+extern "C" {
+#include "edhoc.h"
+}
+
+/**
+ * @class EdhocProcessAsyncWorker
+ * @brief A class that represents an asynchronous worker for processing Edhoc
+ * messages.
+ *
+ * This class inherits from the Napi::AsyncWorker class and is used to perform
+ * Edhoc message processing in a separate thread. It takes an Edhoc context,
+ * message number, message buffer, and a callback function as input parameters.
+ * The processing is performed in the Execute() method, and the result is
+ * returned through the OnOK() method or an error is handled through the
+ * OnError() method.
+ */
+class EdhocProcessAsyncWorker : public Napi::AsyncWorker {
+ public:
+  /**
+   * @brief The type definition for the callback function.
+   */
+  using CallbackType = std::function<Napi::Array(Napi::Env&)>;
+
+  /**
+   * @brief Constructs a new instance of the EdhocProcessAsyncWorker class.
+   *
+   * @param env The Napi::Env object.
+   * @param deferred The Napi::Promise::Deferred object.
+   * @param context The reference to the edhoc_context structure.
+   * @param messageNumber The message number.
+   * @param buffer The Napi::Buffer<uint8_t> object containing the message
+   * buffer.
+   * @param callback The callback function to be called after processing.
+   */
+  EdhocProcessAsyncWorker(Napi::Env& env,
+                          Napi::Promise::Deferred deferred,
+                          struct edhoc_context& context,
+                          int messageNumber,
+                          Napi::Buffer<uint8_t> buffer,
+                          CallbackType callback);
+
+  /**
+   * @brief Executes the asynchronous worker task.
+   */
+  void Execute() override;
+
+  /**
+   * @brief Executes when the asynchronous worker task is completed
+   * successfully.
+   */
+  void OnOK() override;
+
+  /**
+   * @brief Executes when an error occurs during the asynchronous worker task.
+   * @param error The Napi::Error object.
+   */
+  void OnError(const Napi::Error& error) override;
+
+ private:
+  Napi::Promise::Deferred deferred;  ///< The Napi::Promise::Deferred object for
+                                     ///< resolving or rejecting the promise.
+  struct edhoc_context&
+      context;        ///< The reference to the edhoc_context structure.
+  int messageNumber;  ///< The message number.
+  std::vector<uint8_t> messageBuffer;  ///< The message buffer.
+  CallbackType
+      callback;  ///< The callback function to be called after processing.
+};
+
+#endif  // EDHOC_PROCESS_ASYNC_WORKER_H

package/include/LibEDHOC.h

@@ -0,0 +1,304 @@
+#ifndef LIB_EDHOC_H
+#define LIB_EDHOC_H
+
+#include <napi.h>
+#include "UserContext.h"
+
+extern "C" {
+#include "edhoc.h"
+}
+
+/**
+ * @class LibEDHOC
+ * @brief A class that represents the LibEDHOC object.
+ *
+ * The LibEDHOC class is a wrapper around the EDHOC library and provides
+ * an interface for performing EDHOC operations. It allows users to
+ * initialize the EDHOC context, set connection identifiers, set the
+ * method used in EDHOC, set cipher suites, set a logger function, and
+ * compose/process EDHOC messages.
+ */
+class LibEDHOC : public Napi::ObjectWrap<LibEDHOC> {
+ public:
+  /**
+   * @brief Initializes the LibEDHOC object.
+   *
+   * This static method is used to initialize the LibEDHOC object and
+   * bind it to the provided JavaScript environment.
+   *
+   * @param env The Napi::Env representing the JavaScript environment.
+   * @param exports The Napi::Object representing the exports object.
+   * @return Napi::Object The initialized LibEDHOC object.
+   */
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+
+  /**
+   * @brief Constructs a LibEDHOC object.
+   *
+   * @param info The Napi::CallbackInfo representing the callback information.
+   */
+  LibEDHOC(const Napi::CallbackInfo& info);
+
+  /**
+   * @brief Destroys the LibEDHOC object.
+   */
+  ~LibEDHOC();
+
+  /**
+   * @brief Gets the connection identifier (C_I or C_R depending on the role).
+   *
+   * This method returns the connection identifier (C_I or C_R depending on the
+   * role).
+   *
+   * @param info The Napi::CallbackInfo representing the callback information.
+   * @return Napi::Value The connection identifier (C_I or C_R depending on the
+   * role).
+   */
+  Napi::Value GetCID(const Napi::CallbackInfo& info);
+
+  /**
+   * @brief Sets the connection identifier (C_I or C_R depending on the role).
+   *
+   * This method sets the connection identifier (C_I or C_R depending on the
+   * role).
+   *
+   * @param info The Napi::CallbackInfo representing the callback information.
+   * @param value The Napi::Value representing the connection identifier (C_I or
+   * C_R depending on the role).
+   */
+  void SetCID(const Napi::CallbackInfo& info, const Napi::Value& value);
+
+  /**
+   * @brief Gets the peer connection identifier (C_I or C_R depending on the
+   * role).
+   *
+   * This method returns the peer connection identifier (C_I or C_R depending on
+   * the role).
+   *
+   * @param info The Napi::CallbackInfo representing the callback information.
+   * @return Napi::Value The peer connection identifier (C_I or C_R depending on
+   * the role).
+   */
+  Napi::Value GetPeerCID(const Napi::CallbackInfo& info);
+
+  /**
+   * @brief Gets the Method (RFC 9528: 3.2.) used in EDHOC.
+   *
+   * This method returns the Method (RFC 9528: 3.2.) used in EDHOC
+   * associated with the LibEDHOC object.
+   *
+   * @param info The Napi::CallbackInfo representing the callback information.
+   * @return Napi::Value The Method used in EDHOC.
+   */
+  Napi::Value GetMethod(const Napi::CallbackInfo& info);
+
+  /**
+   * @brief Sets the Method (RFC 9528: 3.2.) used in EDHOC.
+   *
+   * This method sets the Method (RFC 9528: 3.2.) used in EDHOC for the LibEDHOC
+   * object.
+   *
+   * @param info The Napi::CallbackInfo representing the callback information.
+   * @param value The Napi::Value representing the Method used in EDHOC.
+   */
+  void SetMethod(const Napi::CallbackInfo& info, const Napi::Value& value);
+
+  /**
+   * @brief Sets the cipher suites.
+   *
+   * This method sets the cipher suites for the LibEDHOC object.
+   *
+   * @param info The Napi::CallbackInfo representing the callback information.
+   * @param value The Napi::Value representing the cipher suites.
+   */
+  void SetCipherSuites(const Napi::CallbackInfo& info,
+                       const Napi::Value& value);
+
+  /**
+   * @brief Gets the cipher suites.
+   *
+   * This method returns the cipher suites associated with the LibEDHOC object.
+   *
+   * @param info The Napi::CallbackInfo representing the callback information.
+   * @return Napi::Value The cipher suites.
+   */
+  Napi::Value GetCipherSuites(const Napi::CallbackInfo& info);
+
+  /**
+   * @brief Gets the selected cipher suite.
+   *
+   * This method returns the selected cipher suite associated with the LibEDHOC
+   * object.
+   *
+   * @param info The Napi::CallbackInfo representing the callback information.
+   * @return Napi::Value The selected cipher suite.
+   */
+  Napi::Value GetSelectedCipherSuite(const Napi::CallbackInfo& info);
+
+  /**
+   * @brief Gets the logger function.
+   *
+   * This method returns the logger function associated with the LibEDHOC
+   * object.
+   *
+   * @param info The Napi::CallbackInfo representing the callback information.
+   * @return Napi::Value The logger function.
+   */
+  Napi::Value GetLogger(const Napi::CallbackInfo& info);
+
+  /**
+   * @brief Sets the logger function.
+   *
+   * This method sets the logger function for the LibEDHOC object.
+   *
+   * @param info The Napi::CallbackInfo representing the callback information.
+   * @param value The Napi::Value representing the logger function.
+   */
+  void SetLogger(const Napi::CallbackInfo& info, const Napi::Value& value);
+
+  /**
+   * @brief Composes EDHOC message 1.
+   *
+   * This method composes EDHOC message 1 for the LibEDHOC object.
+   *
+   * @param info The Napi::CallbackInfo representing the callback information.
+   * @return Napi::Value The composed EDHOC message 1.
+   */
+  Napi::Value ComposeMessage1(const Napi::CallbackInfo& info);
+
+  /**
+   * @brief Processes EDHOC message 1.
+   *
+   * This method processes EDHOC message 1 for the LibEDHOC object.
+   *
+   * @param info The Napi::CallbackInfo representing the callback information.
+   * @return Napi::Value The EAD data from message 1 or Null.
+   */
+  Napi::Value ProcessMessage1(const Napi::CallbackInfo& info);
+
+  /**
+   * @brief Composes EDHOC message 2.
+   *
+   * This method composes EDHOC message 2 for the LibEDHOC object.
+   *
+   * @param info The Napi::CallbackInfo representing the callback information.
+   * @return Napi::Value The composed EDHOC message 2.
+   */
+  Napi::Value ComposeMessage2(const Napi::CallbackInfo& info);
+
+  /**
+   * @brief Processes EDHOC message 2.
+   *
+   * This method processes EDHOC message 2 for the LibEDHOC object.
+   *
+   * @param info The Napi::CallbackInfo representing the callback information.
+   * @return Napi::Value The EAD data from message 2 or Null.
+   */
+  Napi::Value ProcessMessage2(const Napi::CallbackInfo& info);
+
+  /**
+   * @brief Composes EDHOC message 3.
+   *
+   * This method composes EDHOC message 3 for the LibEDHOC object.
+   *
+   * @param info The Napi::CallbackInfo representing the callback information.
+   * @return Napi::Value The composed EDHOC message 3.
+   */
+  Napi::Value ComposeMessage3(const Napi::CallbackInfo& info);
+
+  /**
+   * @brief Processes EDHOC message 3.
+   *
+   * This method processes EDHOC message 3 for the LibEDHOC object.
+   *
+   * @param info The Napi::CallbackInfo representing the callback information.
+   * @return Napi::Value The EAD data from message 3 or Null.
+   */
+  Napi::Value ProcessMessage3(const Napi::CallbackInfo& info);
+
+  /**
+   * @brief Composes EDHOC message 4.
+   *
+   * This method composes EDHOC message 4 for the LibEDHOC object.
+   *
+   * @param info The Napi::CallbackInfo representing the callback information.
+   * @return Napi::Value The composed EDHOC message 4.
+   */
+  Napi::Value ComposeMessage4(const Napi::CallbackInfo& info);
+
+  /**
+   * @brief Processes EDHOC message 4.
+   *
+   * This method processes EDHOC message 4 for the LibEDHOC object.
+   *
+   * @param info The Napi::CallbackInfo representing the callback information.
+   * @return Napi::Value The EAD data from message 4 or Null.
+   */
+  Napi::Value ProcessMessage4(const Napi::CallbackInfo& info);
+
+  /**
+   * @brief Exports OSCORE.
+   *
+   * This method exports an OSCORE context object containing the master key,
+   * salt, recipient ID, and sender ID for the LibEDHOC object.
+   *
+   * @param info The Napi::CallbackInfo representing the callback information.
+   * @return Napi::Value The exported OSCORE context object.
+   */
+  Napi::Value ExportOSCORE(const Napi::CallbackInfo& info);
+
+ private:
+  struct edhoc_context context;  ///< The EDHOC context.
+
+  struct edhoc_connection_id
+      cid;  ///< RFC 9528: 3.3.2. Representation of Byte String Identifiers.
+
+  enum edhoc_method method;  ///< RFC 9528: 3.2. Method.
+
+  Napi::FunctionReference logger;  ///< N-API reference to the logger function
+
+  // Private member variables to hold instances of EDHOC managers for
+  // cryptographic operations, EAD, and credentials
+  std::shared_ptr<UserContext> userContext;
+
+  /**
+   * @brief Logger function for the LibEDHOC object.
+   *
+   * This static method is used to log messages from the EDHOC library.
+   *
+   * @param user_context The user context.
+   * @param name The name of the logger.
+   * @param buffer The buffer containing the log message.
+   * @param buffer_length The length of the log message buffer.
+   */
+  static void Logger(void* user_context,
+                     const char* name,
+                     const uint8_t* buffer,
+                     size_t buffer_length);
+
+  /**
+   * @brief Composes an EDHOC message.
+   *
+   * This method is used to compose an EDHOC message for the LibEDHOC object.
+   *
+   * @param info The Napi::CallbackInfo representing the callback information.
+   * @param message The EDHOC message to compose.
+   * @return Napi::Value The composed EDHOC message.
+   */
+  Napi::Value ComposeMessage(const Napi::CallbackInfo& info,
+                             enum edhoc_message message);
+
+  /**
+   * @brief Processes an EDHOC message.
+   *
+   * This method is used to process an EDHOC message for the LibEDHOC object.
+   *
+   * @param info The Napi::CallbackInfo representing the callback information.
+   * @param message The EDHOC message to process.
+   * @return Napi::Value The EAD data or Null for given EDHOC message.
+   */
+  Napi::Value ProcessMessage(const Napi::CallbackInfo& info,
+                             enum edhoc_message message);
+};
+
+#endif  // LIB_EDHOC_H

package/include/Suites.h

@@ -0,0 +1,27 @@
+#ifndef SUITES_H
+#define SUITES_H
+
+extern "C" {
+#include "edhoc.h"
+}
+
+/**
+ * @brief Array of pointers to EDHOC cipher suites.
+ *
+ * This array contains pointers to the available EDHOC cipher suites.
+ * Each cipher suite is represented by a struct of type `edhoc_cipher_suite`.
+ * The array is declared as `extern` to allow access from other source files.
+ *
+ * @see edhoc_cipher_suite
+ */
+extern const struct edhoc_cipher_suite* suite_pointers[];
+
+/**
+ * @brief Number of EDHOC cipher suites.
+ *
+ * This variable holds the number of available EDHOC cipher suites.
+ * It is declared as `extern` to allow access from other source files.
+ */
+extern const size_t suite_pointers_count;
+
+#endif  // SUITES_H