edhoc 1.2.3 → 1.3.1

package/src/Utils.cpp

@@ -4,42 +4,10 @@
 #include <cstring>
 #include <mutex>
 #include <thread>
+#include <iostream>
 
-static constexpr const char* kStringThen = "then";
 static constexpr const char* kErrorInputValueMustBeANumberOrABuffer = "Input value must be a number or a buffer";
 
-void Utils::InvokeJSFunctionWithPromiseHandling(Napi::Env env,
-                                                Napi::Object jsObject,
-                                                Napi::Function jsCallback,
-                                                const std::vector<napi_value>& args,
-                                                SuccessHandler successLambda,
-                                                ErrorHandler errorLambda) {
-  auto deferred = Napi::Promise::Deferred::New(env);
-
-  Napi::Value result = jsCallback.Call(jsObject, args);
-
-  if (env.IsExceptionPending()) {
-    deferred.Reject(env.GetAndClearPendingException().Value());
-  } else {
-    deferred.Resolve(result);
-  }
-
-  auto thenCallback = Napi::Function::New(env, [successLambda, errorLambda](const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    Napi::HandleScope scope(env);
-    successLambda(env, info[0].As<Napi::Value>());
-  });
-
-  auto catchCallback = Napi::Function::New(env, [errorLambda](const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    Napi::HandleScope scope(env);
-    errorLambda(env, info[0].As<Napi::Error>());
-  });
-
-  Napi::Promise promise = deferred.Promise();
-  promise.Get(kStringThen).As<Napi::Function>().Call(promise, {thenCallback, catchCallback});
-}
-
 void Utils::EncodeInt64ToBuffer(int64_t value, uint8_t* buffer, size_t* length) {
   size_t idx = 0;
   if (value == 0) {
@@ -71,7 +39,7 @@ struct edhoc_connection_id Utils::ConvertJsValueToEdhocCid(Napi::Value value) {
     cid.bstr_length = buffer.Length();
     memcpy(cid.bstr_value, buffer.Data(), cid.bstr_length);
   } else {
-    Napi::TypeError::New(value.Env(), kErrorInputValueMustBeANumberOrABuffer).ThrowAsJavaScriptException();
+    throw Napi::TypeError::New(value.Env(), kErrorInputValueMustBeANumberOrABuffer);
   }
   return cid;
 }

package/test/basic.test.ts

@@ -1,15 +1,40 @@
-import { EDHOC, X509CertificateCredentialManager, DefaultEdhocCryptoManager, EdhocMethod, EdhocSuite } from '../dist/index'
+import { randomBytes } from 'crypto';
+import { EDHOC, X509CertificateCredentialManager, DefaultEdhocCryptoManager, EdhocMethod, EdhocSuite, EdhocKeyType } from '../dist/index'
 
 describe('EDHOC Handshake', () => {
     // Test setup variables
     const trustedCA = Buffer.from('308201323081DAA003020102021478408C6EC18A1D452DAE70C726CB0192A6116DBB300A06082A8648CE3D040302301A3118301606035504030C0F5468697320697320434120526F6F74301E170D3234313031393138333635335A170D3235313031393138333635335A301A3118301606035504030C0F5468697320697320434120526F6F743059301306072A8648CE3D020106082A8648CE3D03010703420004B9348A8A267EF52CFDC30109A29008A2D99F6B8F78BA9EAF5D51578C06134E78CB90A073EDC2488A14174B4E2997C840C5DE7F8E35EB54A0DB6977E894D1B2CB300A06082A8648CE3D040302034700304402203B92BFEC770B0FA4E17F8F02A13CD945D914ED8123AC85C37C8C7BAA2BE3E0F102202CB2DC2EC295B5F4B7BB631ED751179C145D6B6E081559AEA38CE215369E9C31', 'hex');
     let initiator: EDHOC;
     let responder: EDHOC;
+    
+    let staticDhKeyInitiator: Buffer;
+    let staticDhKeyResponder: Buffer;
+    
+    let initiatorCredentialManager: X509CertificateCredentialManager;
+    let responderCredentialManager: X509CertificateCredentialManager;
+
+    class StaticCryptoManager extends DefaultEdhocCryptoManager {
+
+        async importKey(edhoc: EDHOC, keyType: EdhocKeyType, key: Buffer) {
+            if (keyType === EdhocKeyType.MakeKeyPair && key && edhoc.connectionID === 10) {
+                key = staticDhKeyInitiator
+            }
+            if (keyType === EdhocKeyType.MakeKeyPair && key && edhoc.connectionID === 20) {
+                key = staticDhKeyResponder
+            }
+            return super.importKey(edhoc, keyType, key);
+        }
+    }
+
+    beforeAll(() => {
+        staticDhKeyInitiator = randomBytes(32);
+        staticDhKeyResponder = randomBytes(32);
+    })
 
     beforeEach(() => {
         // Initialize credentials and crypto managers for both parties
         const initiatorKeyID = Buffer.from('00000001', 'hex');
-        const initiatorCredentialManager = new X509CertificateCredentialManager(
+        initiatorCredentialManager = new X509CertificateCredentialManager(
             [Buffer.from('3082012E3081D4A003020102021453423D5145C767CDC29895C3DB590192A611EA50300A06082A8648CE3D040302301A3118301606035504030C0F5468697320697320434120526F6F74301E170D3234313031393138333732345A170D3235313031393138333732345A30143112301006035504030C09696E69746961746F723059301306072A8648CE3D020106082A8648CE3D03010703420004EB0EF585F3992A1653CF310BF0F0F8035267CDAB6989C8B02E7228FBD759EF6B56263259AADF087F9849E7B7651F74C3B4F144CCCF86BB6FE2FF0EF3AA5FB5DC300A06082A8648CE3D0403020349003046022100D8C3AA7C98A730B3D4862EDAB4C1474FCD9A17A9CA3FB078914A10978FE95CC40221009F5877DD4E2C635A04ED1F6F1854C87B58521BDDFF533B1076F53D456739764C', 'hex')],
             initiatorKeyID
         );
@@ -19,7 +44,7 @@ describe('EDHOC Handshake', () => {
         initiatorCryptoManager.addKey(initiatorKeyID, Buffer.from('DC1FBB05B6B08360CE5B9EEA08EBFBFC6766A21340641863D4C8A3F68F096337', 'hex'));
 
         const responderKeyID = Buffer.from('00000002', 'hex');
-        const responderCredentialManager = new X509CertificateCredentialManager(
+        responderCredentialManager = new X509CertificateCredentialManager(
             [Buffer.from('3082012E3081D4A00302010202146648869E2608FC2E16D945C10E1F0192A6125CC0300A06082A8648CE3D040302301A3118301606035504030C0F5468697320697320434120526F6F74301E170D3234313031393138333735345A170D3235313031393138333735345A30143112301006035504030C09726573706F6E6465723059301306072A8648CE3D020106082A8648CE3D03010703420004161F76A7A106C9B79B7F651156B5B095E63A6101A39020F4E86DDACE61FB395E8AEF6CD9C444EE9A43DBD62DAD44FF50FE4146247D3AFD28F60DBC01FBFC573C300A06082A8648CE3D0403020349003046022100E8AD0926518CDB61E84D171700C7158FD0E72D03A117D40133ECD10F8B9F42CE022100E7E69B4C79100B3F0792F010AE11EE5DD2859C29EFC4DBCEFD41FA5CD4D3C3C9', 'hex')],
             responderKeyID
         );
@@ -61,4 +86,33 @@ describe('EDHOC Handshake', () => {
         const responderKey = await responder.exportKey(40001, 32);
         expect(initiatorKey).toEqual(responderKey);
     });
+
+    test('should fail to generate message 1 twice', async () => {
+        await initiator.composeMessage1();
+        await expect(initiator.composeMessage1()).rejects.toThrow();
+    });
+
+    describe('should NOT fail to generate message 1 twice', () => {
+
+        it('messages should be different', async () => {
+            const message_a = await responder.composeMessage1();
+            await responder.reset();
+            const message_b = await responder.composeMessage1();
+            expect(message_a).not.toEqual(message_b);
+        });
+
+        it('messages should be the same', async () => {
+            const initiatorCryptoManager = new StaticCryptoManager();
+            const responderCryptoManager = new StaticCryptoManager();
+            
+            initiator = new EDHOC(10, [EdhocMethod.Method1], [EdhocSuite.Suite2], initiatorCredentialManager, initiatorCryptoManager);
+            responder = new EDHOC(20, [EdhocMethod.Method2, EdhocMethod.Method0, EdhocMethod.Method1], [EdhocSuite.Suite2], responderCredentialManager, responderCryptoManager);
+
+            const message_a = await responder.composeMessage1();
+            await responder.reset();
+            const message_b = await responder.composeMessage1();
+
+            expect(message_a).toEqual(message_b);
+        });
+    });
 });

package/include/UserContext.h

@@ -1,78 +0,0 @@
-#ifndef USER_CONTEXT_H
-#define USER_CONTEXT_H
-
-#include <napi.h>
-
-#include <memory>
-
-#include "EdhocCredentialManager.h"
-#include "EdhocCryptoManager.h"
-#include "EdhocEadManager.h"
-
-/**
- * @class UserContext
- * @brief Represents the user context for the Edhoc protocol.
- *
- * The UserContext class encapsulates the necessary components for the Edhoc
- * protocol, including the crypto manager, EAD manager, and credential manager.
- * It also provides access to a logger and a parent object reference.
- */
-class UserContext {
- public:
-  /**
-   * @brief Constructs a UserContext object with the specified components.
-   *
-   * @param cryptoManager The shared pointer to the EdhocCryptoManager.
-   * @param eadManager The shared pointer to the EdhocEadManager.
-   * @param credentialManager The shared pointer to the EdhocCredentialManager.
-   */
-  UserContext(std::shared_ptr<EdhocCryptoManager> cryptoManager,
-              std::shared_ptr<EdhocEadManager> eadManager,
-              std::shared_ptr<EdhocCredentialManager> credentialManager)
-      : cryptoManager(std::move(cryptoManager)),
-        eadManager(std::move(eadManager)),
-        credentialManager(std::move(credentialManager)) {}
-
-  /**
-   * @brief Destroys the UserContext object.
-   *
-   * If a logger is present, it will be released.
-   */
-  virtual ~UserContext() {
-    if (logger) {
-      logger.Release();
-    }
-  }
-
-  /**
-   * @brief Gets the crypto manager associated with the UserContext.
-   *
-   * @return A pointer to the EdhocCryptoManager.
-   */
-  EdhocCryptoManager* GetCryptoManager() const { return cryptoManager.get(); }
-
-  /**
-   * @brief Gets the EAD manager associated with the UserContext.
-   *
-   * @return A pointer to the EdhocEadManager.
-   */
-  EdhocEadManager* GetEadManager() const { return eadManager.get(); }
-
-  /**
-   * @brief Gets the credential manager associated with the UserContext.
-   *
-   * @return A pointer to the EdhocCredentialManager.
-   */
-  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::Error error;                ///< The last error 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
-};
-
-#endif  // USER_CONTEXT_H

package/src/LibEDHOC.cpp

@@ -1,418 +0,0 @@
-#include "LibEDHOC.h"
-
-#include <iostream>
-#include <thread>
-
-#include "EdhocComposeAsyncWorker.h"
-#include "EdhocExportOscoreAsyncWorker.h"
-#include "EdhocKeyExporterAsyncWorker.h"
-#include "EdhocKeyUpdateAsyncWorker.h"
-#include "EdhocProcessAsyncWorker.h"
-#include "Suites.h"
-#include "Utils.h"
-
-static constexpr const char* kErrorFailedToInitializeEdhocContext = "Failed to initialize EDHOC context.";
-static constexpr const char* kErrorFailedToSetEdhocConnectionId = "Failed to set EDHOC Connection ID.";
-static constexpr const char* kErrorFailedToSetEdhocMethod = "Failed to set EDHOC Method.";
-static constexpr const char* kErrorArraySuiteIndexesExpected = "Array of suite indexes expected";
-static constexpr const char* kErrorArrayMethodIndexesExpected = "Array of method indexes expected";
-static constexpr const char* kErrorInvalidCipherSuiteIndex = "Invalid cipher suite index";
-static constexpr const char* kErrorFailedToSetCipherSuites = "Failed to set cipher suites";
-static constexpr const char* kErrorExpectedFirstArgumentToBeBuffer = "Expected first argument to be a Buffer";
-static constexpr const char* kErrorExpectedArgumentToBeNumber = "Expected argument to be a number";
-static constexpr const char* kErrorExpectedAFunction = "Expected a function";
-static constexpr const char* kClassNameLibEDHOC = "EDHOC";
-static constexpr const char* kMethodComposeMessage1 = "composeMessage1";
-static constexpr const char* kMethodProcessMessage1 = "processMessage1";
-static constexpr const char* kMethodComposeMessage2 = "composeMessage2";
-static constexpr const char* kMethodProcessMessage2 = "processMessage2";
-static constexpr const char* kMethodComposeMessage3 = "composeMessage3";
-static constexpr const char* kMethodProcessMessage3 = "processMessage3";
-static constexpr const char* kMethodComposeMessage4 = "composeMessage4";
-static constexpr const char* kMethodProcessMessage4 = "processMessage4";
-static constexpr const char* kMethodExportOSCORE = "exportOSCORE";
-static constexpr const char* kMethodExportKey = "exportKey";
-static constexpr const char* kMethodKeyUpdate = "keyUpdate";
-static constexpr const char* kJsPropertyConnectionID = "connectionID";
-static constexpr const char* kJsPropertyPeerConnectionID = "peerConnectionID";
-static constexpr const char* kJsPropertyMethods = "methods";
-static constexpr const char* kJsPropertySelectedMethod = "selectedMethod";
-static constexpr const char* kJsPropertyCipherSuites = "cipherSuites";
-static constexpr const char* kJsPropertySelectedCipherSuite = "selectedSuite";
-static constexpr const char* kJsPropertyLogger = "logger";
-static constexpr const char* kLogggerFunctionName = "Logger";
-
-LibEDHOC::LibEDHOC(const Napi::CallbackInfo& info) : Napi::ObjectWrap<LibEDHOC>(info) {
-  Napi::Env env = info.Env();
-  Napi::HandleScope scope(env);
-
-  // Initialize EDHOC context
-  context = {};
-  if (edhoc_context_init(&context) != EDHOC_SUCCESS) {
-    Napi::TypeError::New(env, kErrorFailedToInitializeEdhocContext).ThrowAsJavaScriptException();
-  }
-
-  // Connection ID, Methods, and Suites
-  SetCID(info, info[0]);
-  SetMethods(info, info[1]);
-  SetCipherSuites(info, info[2]);
-
-  // Crypto Manager
-  Napi::Object jsCryptoManager = info[4].As<Napi::Object>();
-  auto cryptoManager = std::make_shared<EdhocCryptoManager>(jsCryptoManager);
-
-  // Credentials
-  Napi::Object jsCredentialManager = info[3].As<Napi::Object>();
-  auto credentialManager = std::make_shared<EdhocCredentialManager>(jsCredentialManager);
-  // EAD
-  auto eadManager = std::make_shared<EdhocEadManager>();
-
-  // Bind all managers
-  if (edhoc_bind_keys(&context, &cryptoManager->keys) != EDHOC_SUCCESS ||
-      edhoc_bind_crypto(&context, &cryptoManager->crypto) != EDHOC_SUCCESS ||
-      edhoc_bind_credentials(&context, &credentialManager->credentials) != EDHOC_SUCCESS ||
-      edhoc_bind_ead(&context, &eadManager->ead) != EDHOC_SUCCESS) {
-    Napi::TypeError::New(env, kErrorFailedToInitializeEdhocContext).ThrowAsJavaScriptException();
-  }
-
-  // Logger
-  context.logger = LibEDHOC::Logger;
-
-  // User Context
-  userContext = std::make_shared<UserContext>(cryptoManager, eadManager, credentialManager);
-  userContext->parent = Reference<Napi::Object>::New(info.This().As<Napi::Object>());
-
-  if (edhoc_set_user_context(&context, static_cast<void*>(userContext.get())) != EDHOC_SUCCESS) {
-    Napi::TypeError::New(env, kErrorFailedToInitializeEdhocContext).ThrowAsJavaScriptException();
-  }
-}
-
-LibEDHOC::~LibEDHOC() {
-  userContext.reset();
-  context = {};
-}
-
-Napi::Value LibEDHOC::GetCID(const Napi::CallbackInfo& info) {
-  return Utils::CreateJsValueFromEdhocCid(info.Env(), cid);
-}
-
-void LibEDHOC::SetCID(const Napi::CallbackInfo& info, const Napi::Value& value) {
-  cid = Utils::ConvertJsValueToEdhocCid(value);
-  int result = edhoc_set_connection_id(&context, &cid);
-  if (result != EDHOC_SUCCESS) {
-    Napi::TypeError::New(info.Env(), kErrorFailedToSetEdhocConnectionId).ThrowAsJavaScriptException();
-  }
-}
-
-Napi::Value LibEDHOC::GetPeerCID(const Napi::CallbackInfo& info) {
-  return Utils::CreateJsValueFromEdhocCid(info.Env(), context.EDHOC_PRIVATE(peer_cid));
-}
-
-Napi::Value LibEDHOC::GetMethods(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  Napi::Array result = Napi::Array::New(env, context.EDHOC_PRIVATE(method_len));
-  for (size_t i = 0; i < context.EDHOC_PRIVATE(method_len); i++) {
-    result.Set(i, Napi::Number::New(env, context.EDHOC_PRIVATE(method)[i]));
-  }
-  return result;
-}
-
-void LibEDHOC::SetMethods(const Napi::CallbackInfo& info, const Napi::Value& value) {
-  Napi::Env env = info.Env();
-
-  if (!value.IsArray()) {
-    Napi::TypeError::New(env, kErrorArrayMethodIndexesExpected).ThrowAsJavaScriptException();
-  }
-
-  const auto jsArray = value.As<Napi::Array>();
-  std::vector<edhoc_method> methods;
-  methods.reserve(jsArray.Length());
-
-  for (uint32_t i = 0; i < jsArray.Length(); i++) {
-    methods.push_back(static_cast<edhoc_method>(jsArray.Get(i).As<Napi::Number>().Int32Value()));
-  }
-
-  if (edhoc_set_methods(&context, methods.data(), methods.size()) != EDHOC_SUCCESS) {
-    Napi::TypeError::New(env, kErrorFailedToSetEdhocMethod).ThrowAsJavaScriptException();
-  }
-}
-
-Napi::Value LibEDHOC::GetSelectedMethod(const Napi::CallbackInfo& info) {
-  return Napi::Number::New(info.Env(), context.EDHOC_PRIVATE(chosen_method));
-}
-
-void LibEDHOC::SetCipherSuites(const Napi::CallbackInfo& info, const Napi::Value& value) {
-  Napi::Env env = info.Env();
-
-  if (!value.IsArray()) {
-    Napi::TypeError::New(env, kErrorArraySuiteIndexesExpected).ThrowAsJavaScriptException();
-  }
-
-  const auto jsArray = value.As<Napi::Array>();
-  std::vector<edhoc_cipher_suite> selected_suites;
-  selected_suites.reserve(jsArray.Length());
-
-  for (uint32_t i = 0; i < jsArray.Length(); i++) {
-    const uint32_t index = jsArray.Get(i).As<Napi::Number>().Uint32Value();
-
-    if (index >= suite_pointers_count || suite_pointers[index] == nullptr) {
-      Napi::RangeError::New(env, kErrorInvalidCipherSuiteIndex).ThrowAsJavaScriptException();
-    }
-
-    selected_suites.push_back(*suite_pointers[index]);
-  }
-
-  if (edhoc_set_cipher_suites(&context, selected_suites.data(), selected_suites.size()) != 0) {
-    Napi::TypeError::New(env, kErrorFailedToSetCipherSuites).ThrowAsJavaScriptException();
-  }
-}
-
-Napi::Value LibEDHOC::GetCipherSuites(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  Napi::Array result = Napi::Array::New(env, context.EDHOC_PRIVATE(csuite_len));
-  for (size_t i = 0; i < context.EDHOC_PRIVATE(csuite_len); i++) {
-    result.Set(i, Napi::Number::New(env, context.EDHOC_PRIVATE(csuite)[i].value));
-  }
-  return result;
-}
-
-Napi::Value LibEDHOC::GetSelectedCipherSuite(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  Napi::Number suite =
-      Napi::Number::New(env, context.EDHOC_PRIVATE(csuite)[context.EDHOC_PRIVATE(chosen_csuite_idx)].value);
-  return suite;
-}
-
-Napi::Value LibEDHOC::GetLogger(const Napi::CallbackInfo& info) {
-  return logger.Value();
-}
-
-void LibEDHOC::SetLogger(const Napi::CallbackInfo& info, const Napi::Value& value) {
-  if (!info[0].IsFunction()) {
-    Napi::TypeError::New(info.Env(), kErrorExpectedAFunction).ThrowAsJavaScriptException();
-  }
-  Napi::Function jsCallback = info[0].As<Napi::Function>();
-  logger = Napi::Persistent(jsCallback);
-  userContext->logger = Napi::ThreadSafeFunction::New(info.Env(), jsCallback, kLogggerFunctionName, 0, 1);
-}
-
-void LibEDHOC::Logger(void* usercontext, const char* name, const uint8_t* buffer, size_t buffer_length) {
-  auto* context = static_cast<UserContext*>(usercontext);
-  if (!context || !context->logger) {
-    return;
-  }
-
-  const std::vector<uint8_t> bufferCopy(buffer, buffer + buffer_length);
-
-  context->logger.NonBlockingCall([name = std::string(name), bufferCopy](Napi::Env env, Napi::Function jsCallback) {
-    jsCallback.Call(
-        {Napi::String::New(env, name), Napi::Buffer<uint8_t>::Copy(env, bufferCopy.data(), bufferCopy.size())});
-  });
-}
-
-Napi::Value LibEDHOC::ComposeMessage(const Napi::CallbackInfo& info, enum edhoc_message messageNumber) {
-  Napi::Env env = info.Env();
-  Napi::HandleScope scope(env);
-
-  if (info[0].IsArray()) {
-    userContext->GetEadManager()->StoreEad(messageNumber, info[0].As<Napi::Array>());
-  }
-
-  userContext->GetCredentialManager()->SetupAsyncFunctions();
-  userContext->GetCryptoManager()->SetupAsyncFunctions();
-
-  EdhocComposeAsyncWorker::CallbackType callback = [this, messageNumber](Napi::Env& env) {
-    userContext->GetEadManager()->ClearEadByMessage(messageNumber);
-    userContext->GetCredentialManager()->CleanupAsyncFunctions();
-    userContext->GetCryptoManager()->CleanupAsyncFunctions();
-    if (!userContext->error.IsEmpty()) {
-      userContext->error.ThrowAsJavaScriptException();
-    }
-  };
-
-  EdhocComposeAsyncWorker* worker = new EdhocComposeAsyncWorker(env, context, messageNumber, callback);
-  worker->Queue();
-
-  return worker->GetPromise();
-}
-
-Napi::Value LibEDHOC::ProcessMessage(const Napi::CallbackInfo& info, enum edhoc_message messageNumber) {
-  Napi::Env env = info.Env();
-  Napi::HandleScope scope(env);
-
-  if (info.Length() < 1 || !info[0].IsBuffer()) {
-    Napi::TypeError::New(env, kErrorExpectedFirstArgumentToBeBuffer).ThrowAsJavaScriptException();
-    return env.Null();
-  }
-  Napi::Buffer<uint8_t> inputBuffer = info[0].As<Napi::Buffer<uint8_t>>();
-
-  userContext->GetCredentialManager()->SetupAsyncFunctions();
-  userContext->GetCryptoManager()->SetupAsyncFunctions();
-
-  EdhocProcessAsyncWorker::CallbackType callback = [this, messageNumber](Napi::Env& env) {
-    Napi::Array EADs = userContext->GetEadManager()->GetEadByMessage(env, messageNumber);
-    userContext->GetEadManager()->ClearEadByMessage(messageNumber);
-    userContext->GetCredentialManager()->CleanupAsyncFunctions();
-    userContext->GetCryptoManager()->CleanupAsyncFunctions();
-    if (!userContext->error.IsEmpty()) {
-      userContext->error.ThrowAsJavaScriptException();
-    }
-    return EADs;
-  };
-
-  EdhocProcessAsyncWorker* worker = new EdhocProcessAsyncWorker(env, context, messageNumber, inputBuffer, callback);
-  worker->Queue();
-
-  return worker->GetPromise();
-}
-
-Napi::Value LibEDHOC::ComposeMessage1(const Napi::CallbackInfo& info) {
-  return ComposeMessage(info, EDHOC_MSG_1);
-}
-
-Napi::Value LibEDHOC::ProcessMessage1(const Napi::CallbackInfo& info) {
-  return ProcessMessage(info, EDHOC_MSG_1);
-}
-
-Napi::Value LibEDHOC::ComposeMessage2(const Napi::CallbackInfo& info) {
-  return ComposeMessage(info, EDHOC_MSG_2);
-}
-
-Napi::Value LibEDHOC::ProcessMessage2(const Napi::CallbackInfo& info) {
-  return ProcessMessage(info, EDHOC_MSG_2);
-}
-
-Napi::Value LibEDHOC::ComposeMessage3(const Napi::CallbackInfo& info) {
-  return ComposeMessage(info, EDHOC_MSG_3);
-}
-
-Napi::Value LibEDHOC::ProcessMessage3(const Napi::CallbackInfo& info) {
-  return ProcessMessage(info, EDHOC_MSG_3);
-}
-
-Napi::Value LibEDHOC::ComposeMessage4(const Napi::CallbackInfo& info) {
-  return ComposeMessage(info, EDHOC_MSG_4);
-}
-
-Napi::Value LibEDHOC::ProcessMessage4(const Napi::CallbackInfo& info) {
-  return ProcessMessage(info, EDHOC_MSG_4);
-}
-
-Napi::Value LibEDHOC::ExportOSCORE(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  Napi::HandleScope scope(env);
-
-  userContext->GetCredentialManager()->SetupAsyncFunctions();
-  userContext->GetCryptoManager()->SetupAsyncFunctions();
-
-  EdhocExportOscoreAsyncWorker::CallbackType callback = [this](Napi::Env& env) {
-    userContext->GetCredentialManager()->CleanupAsyncFunctions();
-    userContext->GetCryptoManager()->CleanupAsyncFunctions();
-    if (!userContext->error.IsEmpty()) {
-      userContext->error.ThrowAsJavaScriptException();
-    }
-  };
-
-  EdhocExportOscoreAsyncWorker* worker = new EdhocExportOscoreAsyncWorker(env, context, callback);
-  worker->Queue();
-
-  return worker->GetPromise();
-}
-
-Napi::Value LibEDHOC::ExportKey(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  Napi::HandleScope scope(env);
-
-  if (info.Length() < 1 || !info[0].IsNumber()) {
-    Napi::TypeError::New(env, kErrorExpectedArgumentToBeNumber).ThrowAsJavaScriptException();
-    return env.Null();
-  }
-
-  if (info.Length() < 2 || !info[1].IsNumber()) {
-    Napi::TypeError::New(env, kErrorExpectedArgumentToBeNumber).ThrowAsJavaScriptException();
-    return env.Null();
-  }
-
-  uint16_t label = (uint16_t)info[0].As<Napi::Number>().Uint32Value();
-  uint8_t desiredLength = (uint8_t)info[1].As<Napi::Number>().Uint32Value();
-
-  userContext->GetCredentialManager()->SetupAsyncFunctions();
-  userContext->GetCryptoManager()->SetupAsyncFunctions();
-
-  EdhocKeyExporterAsyncWorker::CallbackType callback = [this](Napi::Env& env) {
-    userContext->GetCredentialManager()->CleanupAsyncFunctions();
-    userContext->GetCryptoManager()->CleanupAsyncFunctions();
-    if (!userContext->error.IsEmpty()) {
-      userContext->error.ThrowAsJavaScriptException();
-    }
-  };
-
-  EdhocKeyExporterAsyncWorker* worker = new EdhocKeyExporterAsyncWorker(env, context, label, desiredLength, callback);
-  worker->Queue();
-
-  return worker->GetPromise();
-}
-
-Napi::Value LibEDHOC::KeyUpdate(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  Napi::HandleScope scope(env);
-
-  if (info.Length() < 1 || !info[0].IsBuffer()) {
-    Napi::TypeError::New(env, kErrorExpectedFirstArgumentToBeBuffer).ThrowAsJavaScriptException();
-    return env.Null();
-  }
-
-  Napi::Buffer<uint8_t> contextBuffer = info[0].As<Napi::Buffer<uint8_t>>();
-  std::vector<uint8_t> contextBufferVector(contextBuffer.Data(), contextBuffer.Data() + contextBuffer.Length());
-
-  userContext->GetCredentialManager()->SetupAsyncFunctions();
-  userContext->GetCryptoManager()->SetupAsyncFunctions();
-
-  EdhocKeyUpdateAsyncWorker::CallbackType callback = [this](Napi::Env& env) {
-    userContext->GetCredentialManager()->CleanupAsyncFunctions();
-    userContext->GetCryptoManager()->CleanupAsyncFunctions();
-    if (!userContext->error.IsEmpty()) {
-      userContext->error.ThrowAsJavaScriptException();
-    }
-  };
-
-  EdhocKeyUpdateAsyncWorker* worker = new EdhocKeyUpdateAsyncWorker(env, context, contextBufferVector, callback);
-  worker->Queue();
-
-  return worker->GetPromise();
-}
-
-Napi::Object LibEDHOC::Init(Napi::Env env, Napi::Object exports) {
-  Napi::HandleScope scope(env);
-  Napi::Function func =
-      DefineClass(env, kClassNameLibEDHOC,
-                  {
-                      InstanceAccessor(kJsPropertyConnectionID, &LibEDHOC::GetCID, &LibEDHOC::SetCID),
-                      InstanceAccessor<&LibEDHOC::GetPeerCID>(kJsPropertyPeerConnectionID),
-                      InstanceAccessor(kJsPropertyMethods, &LibEDHOC::GetMethods, &LibEDHOC::SetMethods),
-                      InstanceAccessor<&LibEDHOC::GetSelectedMethod>(kJsPropertySelectedMethod),
-                      InstanceAccessor(kJsPropertyCipherSuites, &LibEDHOC::GetCipherSuites, &LibEDHOC::SetCipherSuites),
-                      InstanceAccessor<&LibEDHOC::GetSelectedCipherSuite>(kJsPropertySelectedCipherSuite),
-                      InstanceAccessor(kJsPropertyLogger, &LibEDHOC::GetLogger, &LibEDHOC::SetLogger),
-                      InstanceMethod(kMethodComposeMessage1, &LibEDHOC::ComposeMessage1),
-                      InstanceMethod(kMethodProcessMessage1, &LibEDHOC::ProcessMessage1),
-                      InstanceMethod(kMethodComposeMessage2, &LibEDHOC::ComposeMessage2),
-                      InstanceMethod(kMethodProcessMessage2, &LibEDHOC::ProcessMessage2),
-                      InstanceMethod(kMethodComposeMessage3, &LibEDHOC::ComposeMessage3),
-                      InstanceMethod(kMethodProcessMessage3, &LibEDHOC::ProcessMessage3),
-                      InstanceMethod(kMethodComposeMessage4, &LibEDHOC::ComposeMessage4),
-                      InstanceMethod(kMethodProcessMessage4, &LibEDHOC::ProcessMessage4),
-                      InstanceMethod(kMethodExportOSCORE, &LibEDHOC::ExportOSCORE),
-                      InstanceMethod(kMethodExportKey, &LibEDHOC::ExportKey),
-                      InstanceMethod(kMethodKeyUpdate, &LibEDHOC::KeyUpdate),
-                  });
-
-  Napi::FunctionReference* constructor = new Napi::FunctionReference();
-  *constructor = Napi::Persistent(func);
-  env.SetInstanceData(constructor);
-
-  exports.Set(kClassNameLibEDHOC, func);
-  return exports;
-}
-
-NODE_API_NAMED_ADDON(addon, LibEDHOC);