edhoc 1.0.4 → 1.1.0

package/include/EdhocComposeAsyncWorker.h

@@ -2,6 +2,7 @@
 #define EDHOC_COMPOSE_ASYNC_WORKER_H
 
 #include <napi.h>
+
 #include <vector>
 
 extern "C" {
@@ -22,16 +23,11 @@ class EdhocComposeAsyncWorker : public Napi::AsyncWorker {
   /**
    * @brief Constructor for EdhocComposeAsyncWorker.
    * @param env The Napi::Env object.
-   * @param deferred The deferred promise object.
    * @param context The EDHOC context.
    * @param messageNumber The message number.
    * @param callback The callback function.
    */
-  EdhocComposeAsyncWorker(Napi::Env& env,
-                          Napi::Promise::Deferred deferred,
-                          struct edhoc_context& context,
-                          int messageNumber,
-                          CallbackType callback);
+  EdhocComposeAsyncWorker(Napi::Env& env, struct edhoc_context& context, int messageNumber, CallbackType callback);
 
   /**
    * @brief Executes the asynchronous worker task.
@@ -50,6 +46,12 @@ class EdhocComposeAsyncWorker : public Napi::AsyncWorker {
    */
   void OnError(const Napi::Error& error) override;
 
+  /**
+   * @brief Returns the promise object.
+   * @return The promise object.
+   */
+  Napi::Promise GetPromise();
+
  private:
   Napi::Promise::Deferred deferred;      ///< The deferred promise object.
   struct edhoc_context& context;         ///< The EDHOC context.

package/include/EdhocCredentialManager.h

@@ -39,8 +39,7 @@ class EdhocCredentialManager {
    * fetched credentials.
    * @return EDHOC_SUCCESS if successful, otherwise an error code.
    */
-  static int FetchCredentials(void* user_context,
-                              struct edhoc_auth_creds* credentials);
+  static int FetchCredentials(void* user_context, struct edhoc_auth_creds* credentials);
 
   /**
    * @brief Static function to verify the credentials.
@@ -63,8 +62,7 @@ class EdhocCredentialManager {
    * fetched credentials.
    * @return EDHOC_SUCCESS if successful, otherwise an error code.
    */
-  int callFetchCredentials(const void* user_context,
-                           struct edhoc_auth_creds* credentials);
+  int callFetchCredentials(const void* user_context, struct edhoc_auth_creds* credentials);
 
   /**
    * @brief Calls the VerifyCredentials function.
@@ -80,14 +78,21 @@ class EdhocCredentialManager {
                             const uint8_t** public_key_reference,
                             size_t* public_key_length);
 
+  /**
+   * @brief Sets up the async functions.
+   */
+  void SetupAsyncFunctions();
+
+  /**
+   * @brief Releases the async functions.
+   */
+  void CleanupAsyncFunctions();
+
  private:
-  std::vector<Napi::Reference<Napi::Object>>
-      credentialReferences;                    ///< References to the JS objects
-  Napi::ObjectReference credentialManagerRef;  ///< Reference to the JS object
-  Napi::ThreadSafeFunction
-      fetchTsfn;  ///< Thread-safe function for FetchCredentials
-  Napi::ThreadSafeFunction
-      verifyTsfn;  ///< Thread-safe function for VerifyCredentials
+  std::vector<Napi::Reference<Napi::Object>> credentialReferences;  ///< References to the JS objects
+  Napi::ObjectReference credentialManagerRef;                       ///< Reference to the JS object
+  Napi::ThreadSafeFunction fetchTsfn;                               ///< Thread-safe function for FetchCredentials
+  Napi::ThreadSafeFunction verifyTsfn;                              ///< Thread-safe function for VerifyCredentials
 
   /**
    * @brief Assosciates the thread-safe function with the JS object function.

package/include/EdhocCryptoManager.h

@@ -43,20 +43,20 @@ class EdhocCryptoManager {
   ~EdhocCryptoManager();
 
   /**
-   * @brief Generate a key.
+   * @brief Import a key.
    *
    * @param user_context The user context.
-   * @param key_type The type of the key to generate.
+   * @param key_type The type of the key to import.
    * @param raw_key The raw key data.
    * @param raw_key_length The length of the raw key data.
-   * @param key_id The generated key ID.
+   * @param key_id The imported key ID.
    * @return int The result code.
    */
-  static int GenerateKey(void* user_context,
-                         enum edhoc_key_type key_type,
-                         const uint8_t* raw_key,
-                         size_t raw_key_length,
-                         void* key_id);
+  static int ImportKey(void* user_context,
+                       enum edhoc_key_type key_type,
+                       const uint8_t* raw_key,
+                       size_t raw_key_length,
+                       void* key_id);
 
   /**
    * @brief Destroy a key.
@@ -263,20 +263,20 @@ class EdhocCryptoManager {
                   size_t* hash_length);
 
   /**
-   * @brief Calls the GenerateKey function.
+   * @brief Calls the ImportKey function.
    *
    * @param user_context The user context.
-   * @param key_type The type of the key to generate.
+   * @param key_type The type of the key to import.
    * @param raw_key The raw key data.
    * @param raw_key_length The length of the raw key data.
-   * @param key_id The generated key ID.
+   * @param key_id The imported key ID.
    * @return int The result code.
    */
-  int callGenerateKey(const void* user_context,
-                      enum edhoc_key_type key_type,
-                      const uint8_t* raw_key,
-                      size_t raw_key_length,
-                      void* key_id);
+  int callImportKey(const void* user_context,
+                    enum edhoc_key_type key_type,
+                    const uint8_t* raw_key,
+                    size_t raw_key_length,
+                    void* key_id);
 
   /**
    * @brief Calls the DestroyKey function.
@@ -481,17 +481,24 @@ class EdhocCryptoManager {
                uint8_t* hash,
                size_t hash_size,
                size_t* hash_length);
+  /**
+   * @brief Sets up the async functions.
+   */
+  void SetupAsyncFunctions();
+
+  /**
+   * @brief Releases the async functions.
+   */
+  void CleanupAsyncFunctions();
 
  private:
   Napi::ObjectReference cryptoManagerRef;  ///< Reference to the JS object
 
-  std::vector<Napi::Reference<Napi::Buffer<uint8_t>>>
-      bufferReferences;  ///< References to the JS buffers
+  std::vector<Napi::Reference<Napi::Buffer<uint8_t>>> bufferReferences;  ///< References to the JS buffers
 
   /* Thread-safe functions */
-  Napi::ThreadSafeFunction generateTsfn, destroyTsfn, makeKeyPairTsfn,
-      keyAgreementTsfn, signTsfn, verifyTsfn, extractTsfn, expandTsfn,
-      encryptTsfn, decryptTsfn, hashTsfn;
+  Napi::ThreadSafeFunction importTsfn, destroyTsfn, makeKeyPairTsfn, keyAgreementTsfn, signTsfn, verifyTsfn,
+      extractTsfn, expandTsfn, encryptTsfn, decryptTsfn, hashTsfn;
 
   /**
    * @brief Assosciates the thread-safe function with the JS object function.

package/include/EdhocEadManager.h

@@ -2,6 +2,7 @@
 #define EDHOC_EAD_MANAGER_H
 
 #include <napi.h>
+
 #include <map>
 #include <vector>
 
@@ -50,9 +51,7 @@ class EdhocEadManager {
    * @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);
+  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.
@@ -143,9 +142,7 @@ class EdhocEadManager {
    * @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);
+  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 → EdhocExportOscoreAsyncWorker.h}

@@ -1,7 +1,8 @@
-#ifndef EDHOC_EXPORT_ASYNC_WORKER_H
-#define EDHOC_EXPORT_ASYNC_WORKER_H
+#ifndef EDHOC_EXPORT_OSCORE_ASYNC_WORKER_H
+#define EDHOC_EXPORT_OSCORE_ASYNC_WORKER_H
 
 #include <napi.h>
+
 #include <functional>
 #include <vector>
 
@@ -10,36 +11,32 @@ extern "C" {
 }
 
 /**
- * @class EdhocExportAsyncWorker
+ * @class EdhocExportOscoreAsyncWorker
  * @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 {
+class EdhocExportOscoreAsyncWorker : public Napi::AsyncWorker {
  public:
   /**
    * @brief The type definition for the callback function.
    */
-  using CallbackType = std::function<void(Napi::Env)>;
+  using CallbackType = std::function<void(Napi::Env&)>;
 
   /**
-   * @brief Constructs a new EdhocExportAsyncWorker object.
+   * @brief Constructs a new EdhocExportOscoreAsyncWorker 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);
+  EdhocExportOscoreAsyncWorker(Napi::Env& env, struct edhoc_context& context, CallbackType callback);
 
   /**
-   * @brief Destroys the EdhocExportAsyncWorker object.
+   * @brief Destroys the EdhocExportOscoreAsyncWorker object.
    */
-  ~EdhocExportAsyncWorker() override;
+  ~EdhocExportOscoreAsyncWorker() override;
 
   /**
    * @brief Executes the asynchronous worker task.
@@ -58,14 +55,20 @@ class EdhocExportAsyncWorker : public Napi::AsyncWorker {
    */
   void OnError(const Napi::Error& error) override;
 
+  /**
+   * @brief Returns the promise object.
+   * @return The promise object.
+   */
+  Napi::Promise GetPromise();
+
  private:
-  Napi::Promise::Deferred deferred;  ///< The deferred promise object.
-  struct edhoc_context&
-      context;  ///< The reference to the edhoc_context structure.
+  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.
+  CallbackType callback;              ///< The callback function to be executed.
 };
 
-#endif  // EDHOC_EXPORT_ASYNC_WORKER_H
+#endif  // EDHOC_EXPORT_OSCORE_ASYNC_WORKER_H

package/include/EdhocKeyExporterAsyncWorker.h

@@ -0,0 +1,76 @@
+#ifndef EDHOC_KEY_EXPORTER_ASYNC_WORKER_H
+#define EDHOC_KEY_EXPORTER_ASYNC_WORKER_H
+
+#include <napi.h>
+
+#include <vector>
+
+extern "C" {
+#include "edhoc.h"
+}
+
+/**
+ * @class EdhocKeyExporterAsyncWorker
+ * @brief A class that represents an asynchronous worker for exporting PRKs.
+ *
+ * This class inherits from the Napi::AsyncWorker class and is used to perform
+ * PRK export in a separate thread. It takes an Edhoc context, a label, a
+ * desired length, and a callback function as input parameters. The export 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 EdhocKeyExporterAsyncWorker : public Napi::AsyncWorker {
+ public:
+  /**
+   * @brief The type definition for the callback function.
+   */
+  using CallbackType = std::function<void(Napi::Env&)>;
+
+  /**
+   * @brief Constructs a new EdhocKeyExporterAsyncWorker object.
+   *
+   * @param env The Napi::Env object representing the current environment.
+   * @param context The reference to the edhoc_context structure.
+   * @param label The label of the key to export.
+   * @param desiredLength The desired length of the key to export.
+   * @param callback The callback function to be called after the export.
+   */
+  EdhocKeyExporterAsyncWorker(Napi::Env& env,
+                              struct edhoc_context& context,
+                              uint16_t label,
+                              uint8_t desiredLength,
+                              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;
+
+  /**
+   * @brief Returns the promise object.
+   * @return The promise object.
+   */
+  Napi::Promise GetPromise();
+
+ private:
+  Napi::Promise::Deferred deferred;
+  struct edhoc_context& context;
+  uint16_t label;
+  uint8_t desiredLength;
+  std::vector<uint8_t> output;
+  CallbackType callback;
+};
+
+#endif  // EDHOC_KEY_EXPORTER_ASYNC_WORKER_H

package/include/EdhocKeyUpdateAsyncWorker.h

@@ -0,0 +1,72 @@
+#ifndef EDHOC_KEY_UPDATE_ASYNC_WORKER_H
+#define EDHOC_KEY_UPDATE_ASYNC_WORKER_H
+
+#include <napi.h>
+
+#include <vector>
+
+extern "C" {
+#include "edhoc.h"
+}
+
+/**
+ * @class EdhocKeyUpdateAsyncWorker
+ * @brief A class that represents an asynchronous worker for key update.
+ *
+ * This class inherits from the Napi::AsyncWorker class and is used to perform
+ * key update in a separate thread. It takes an Edhoc context, a context buffer,
+ * and a callback function as input parameters. The key update 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 EdhocKeyUpdateAsyncWorker : public Napi::AsyncWorker {
+ public:
+  /**
+   * @brief The type definition for the callback function.
+   */
+  using CallbackType = std::function<void(Napi::Env&)>;
+
+  /**
+   * @brief Constructs a new EdhocKeyUpdateAsyncWorker object.
+   *
+   * @param env The Napi::Env object representing the current environment.
+   * @param context The reference to the edhoc_context structure.
+   * @param contextBuffer The context buffer.
+   * @param callback The callback function to be called after the key update.
+   */
+  EdhocKeyUpdateAsyncWorker(Napi::Env& env,
+                            struct edhoc_context& context,
+                            std::vector<uint8_t> contextBuffer,
+                            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;
+
+  /**
+   * @brief Returns the promise object.
+   * @return The promise object.
+   */
+  Napi::Promise GetPromise();
+
+ private:
+  Napi::Promise::Deferred deferred;
+  struct edhoc_context& context;
+  std::vector<uint8_t> contextBuffer;
+  CallbackType callback;
+};
+
+#endif  // EDHOC_KEY_UPDATE_ASYNC_WORKER_H

package/include/EdhocProcessAsyncWorker.h

@@ -2,6 +2,7 @@
 #define EDHOC_PROCESS_ASYNC_WORKER_H
 
 #include <napi.h>
+
 #include <vector>
 
 extern "C" {
@@ -31,7 +32,6 @@ class EdhocProcessAsyncWorker : public Napi::AsyncWorker {
    * @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
@@ -39,7 +39,6 @@ class EdhocProcessAsyncWorker : public Napi::AsyncWorker {
    * @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,
@@ -62,15 +61,20 @@ class EdhocProcessAsyncWorker : public Napi::AsyncWorker {
    */
   void OnError(const Napi::Error& error) override;
 
+  /**
+   * @brief Returns the promise object.
+   * @return The promise object.
+   */
+  Napi::Promise GetPromise();
+
  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.
+  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.
+  std::vector<uint8_t> peerCipherSuites;  ///< The peer cipher suites.
 };
 
 #endif  // EDHOC_PROCESS_ASYNC_WORKER_H

package/include/LibEDHOC.h

@@ -2,6 +2,7 @@
 #define LIB_EDHOC_H
 
 #include <napi.h>
+
 #include "UserContext.h"
 
 extern "C" {
@@ -88,20 +89,30 @@ class LibEDHOC : public Napi::ObjectWrap<LibEDHOC> {
    * associated with the LibEDHOC object.
    *
    * @param info The Napi::CallbackInfo representing the callback information.
-   * @return Napi::Value The Method used in EDHOC.
+   * @return Napi::Value The supported methods used in EDHOC.
    */
-  Napi::Value GetMethod(const Napi::CallbackInfo& info);
+  Napi::Value GetMethods(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.
+   * This method sets the supported methods (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.
+   * @param value The Napi::Value representing the supported methods used in EDHOC.
    */
-  void SetMethod(const Napi::CallbackInfo& info, const Napi::Value& value);
+  void SetMethods(const Napi::CallbackInfo& info, const Napi::Value& value);
+
+  /**
+   * @brief Gets the selected method.
+   *
+   * This method returns the selected method associated with the LibEDHOC object.
+   *
+   * @param info The Napi::CallbackInfo representing the callback information.
+   * @return Napi::Value The selected method.
+   */
+  Napi::Value GetSelectedMethod(const Napi::CallbackInfo& info);
 
   /**
    * @brief Sets the cipher suites.
@@ -111,8 +122,7 @@ class LibEDHOC : public Napi::ObjectWrap<LibEDHOC> {
    * @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);
+  void SetCipherSuites(const Napi::CallbackInfo& info, const Napi::Value& value);
 
   /**
    * @brief Gets the cipher suites.
@@ -247,13 +257,32 @@ class LibEDHOC : public Napi::ObjectWrap<LibEDHOC> {
    */
   Napi::Value ExportOSCORE(const Napi::CallbackInfo& info);
 
+  /**
+   * @brief Exports keying material using the EDHOC_Exporter interface.
+   *
+   * This method derives keying material using the EDHOC_Exporter, which
+   * utilizes an `exporter_label`, `context`, and `length` to generate the
+   * key.
+   *
+   * @param info The Napi::CallbackInfo representing the callback information.
+   * @return Napi::Value The derived keying material.
+   */
+  Napi::Value ExportKey(const Napi::CallbackInfo& info);
+
+  /**
+   * @brief Performs a key update.
+   *
+   * This method performs a key update for the LibEDHOC object.
+   *
+   * @param info The Napi::CallbackInfo representing the callback information.
+   * @return Napi::Value void.
+   */
+  Napi::Value KeyUpdate(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.
+  struct edhoc_connection_id cid;  ///< RFC 9528: 3.3.2. Representation of Byte String Identifiers.
 
   Napi::FunctionReference logger;  ///< N-API reference to the logger function
 
@@ -271,10 +300,7 @@ class LibEDHOC : public Napi::ObjectWrap<LibEDHOC> {
    * @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);
+  static void Logger(void* user_context, const char* name, const uint8_t* buffer, size_t buffer_length);
 
   /**
    * @brief Composes an EDHOC message.
@@ -285,8 +311,7 @@ class LibEDHOC : public Napi::ObjectWrap<LibEDHOC> {
    * @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);
+  Napi::Value ComposeMessage(const Napi::CallbackInfo& info, enum edhoc_message message);
 
   /**
    * @brief Processes an EDHOC message.
@@ -297,8 +322,7 @@ class LibEDHOC : public Napi::ObjectWrap<LibEDHOC> {
    * @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);
+  Napi::Value ProcessMessage(const Napi::CallbackInfo& info, enum edhoc_message message);
 };
 
 #endif  // LIB_EDHOC_H

package/include/UserContext.h

@@ -2,7 +2,9 @@
 #define USER_CONTEXT_H
 
 #include <napi.h>
+
 #include <memory>
+
 #include "EdhocCredentialManager.h"
 #include "EdhocCryptoManager.h"
 #include "EdhocEadManager.h"
@@ -61,19 +63,15 @@ class UserContext {
    *
    * @return A pointer to the EdhocCredentialManager.
    */
-  EdhocCredentialManager* GetCredentialManager() const {
-    return credentialManager.get();
-  }
+  EdhocCredentialManager* GetCredentialManager() const { return credentialManager.get(); }
 
   Napi::ThreadSafeFunction logger;  ///< The logger for the UserContext
-  Napi::ObjectReference
-      parent;  ///< The parent object reference for the UserContext
+  Napi::ObjectReference parent;     ///< The parent object reference for the UserContext
 
  protected:
-  std::shared_ptr<EdhocCryptoManager> cryptoManager;  ///< The crypto manager
-  std::shared_ptr<EdhocEadManager> eadManager;        ///< The EAD manager
-  std::shared_ptr<EdhocCredentialManager>
-      credentialManager;  ///< The credential manager
+  std::shared_ptr<EdhocCryptoManager> cryptoManager;          ///< The crypto manager
+  std::shared_ptr<EdhocEadManager> eadManager;                ///< The EAD manager
+  std::shared_ptr<EdhocCredentialManager> credentialManager;  ///< The credential manager
 };
 
 #endif  // USER_CONTEXT_H