edhoc 1.4.0 → 2.0.0

package/src/EdhocEadManager.cpp

@@ -1,148 +0,0 @@
-#include "EdhocEadManager.h"
-
-#include <exception>
-#include <future>
-#include <iostream>
-#include <stdexcept>
-
-#include "RunningContext.h"
-#include "Utils.h"
-
-static constexpr const char* kErrorExpectedObject = "Expected an object as element in the input array";
-static constexpr const char* kErrorExpectedLabelNumberAndValueBuffer =
-    "Expected 'label' to be a number and 'value' to be a buffer in the input "
-    "array";
-static constexpr const char* kPropLabel = "label";
-static constexpr const char* kPropValue = "value";
-
-EdhocEadManager::EdhocEadManager() {
-  ead.compose = ComposeEad;
-  ead.process = ProcessEad;
-}
-
-EdhocEadManager::~EdhocEadManager() {
-  eadBuffers_.clear();
-}
-
-void EdhocEadManager::StoreEad(enum edhoc_message message, int label, const std::vector<uint8_t>& ead) {
-  auto& vecOfMaps = eadBuffers_[message];
-  EadMap newMap;
-  newMap[label] = ead;
-  vecOfMaps.push_back(std::move(newMap));
-}
-
-void EdhocEadManager::StoreEad(enum edhoc_message message, const Napi::Array& eadArray) {
-  Napi::Env env = eadArray.Env();
-  for (size_t i = 0; i < eadArray.Length(); i++) {
-    Napi::Value element = eadArray.Get(i);
-    if (!element.IsObject()) {
-      throw Napi::TypeError::New(env, kErrorExpectedObject);
-    }
-
-    Napi::Object obj = element.As<Napi::Object>();
-    Napi::Value labelValue = obj.Get(kPropLabel);
-    Napi::Value bufferValue = obj.Get(kPropValue);
-
-    if (!labelValue.IsNumber() || !bufferValue.IsBuffer()) {
-      throw Napi::TypeError::New(env, kErrorExpectedLabelNumberAndValueBuffer);
-    }
-
-    int label = labelValue.As<Napi::Number>().Int32Value();
-    Napi::Buffer<uint8_t> buffer = bufferValue.As<Napi::Buffer<uint8_t>>();
-
-    std::vector<uint8_t> eadVector(buffer.Data(), buffer.Data() + buffer.Length());
-    StoreEad(message, label, eadVector);
-  }
-}
-
-const EadMapVector* EdhocEadManager::GetEadByMessage(enum edhoc_message message) const {
-  auto it = eadBuffers_.find(message);
-  return it != eadBuffers_.end() ? &it->second : nullptr;
-}
-
-Napi::Array EdhocEadManager::GetEadByMessage(Napi::Env& env, enum edhoc_message message) const {
-  const EadMapVector* buffers = GetEadByMessage(message);
-  if (!buffers) {
-    return Napi::Array::New(env);
-  }
-
-  Napi::Array result = Napi::Array::New(env, buffers->size());
-  size_t i = 0;
-  for (auto const& map : *buffers) {
-    Napi::Object obj = Napi::Object::New(env);
-    for (auto const& [label, buffer] : map) {
-      obj.Set(kPropLabel, Napi::Number::New(env, label));
-      obj.Set(kPropValue, Napi::Buffer<uint8_t>::Copy(env, buffer.data(), buffer.size()));
-    }
-    result.Set(i++, obj);
-  }
-
-  return result;
-}
-
-void EdhocEadManager::ClearEadByMessage(enum edhoc_message message) {
-  eadBuffers_.erase(message);
-}
-
-int EdhocEadManager::ComposeEad(void* user_context,
-                                enum edhoc_message message,
-                                struct edhoc_ead_token* ead_token,
-                                size_t ead_token_size,
-                                size_t* ead_token_len) {
-  RunningContext* context = static_cast<RunningContext*>(const_cast<void*>(user_context));
-  EdhocEadManager* manager = context->GetEadManager();
-  return manager->callComposeEad(message, ead_token, ead_token_size, ead_token_len);
-}
-
-int EdhocEadManager::ProcessEad(void* user_context,
-                                enum edhoc_message message,
-                                const struct edhoc_ead_token* ead_token,
-                                size_t ead_token_size) {
-  RunningContext* context = static_cast<RunningContext*>(const_cast<void*>(user_context));
-  EdhocEadManager* manager = context->GetEadManager();
-  return manager->callProcessEad(message, ead_token, ead_token_size);
-}
-
-int EdhocEadManager::callComposeEad(enum edhoc_message message,
-                                    struct edhoc_ead_token* ead_token,
-                                    size_t ead_token_size,
-                                    size_t* ead_token_len) {
-  const EadMapVector* eadBuffers_ = GetEadByMessage(message);
-  if (!eadBuffers_) {
-    *ead_token_len = 0;
-    return EDHOC_SUCCESS;
-  }
-
-  size_t count = 0;
-
-  for (const auto& map : *eadBuffers_) {
-    for (const auto& [label, buffer] : map) {
-      if (count >= ead_token_size) {
-        break;
-      }
-      ead_token[count].label = label;
-      ead_token[count].value = buffer.data();
-      ead_token[count].value_len = buffer.size();
-      count++;
-    }
-    if (count >= ead_token_size) {
-      break;
-    }
-  }
-
-  *ead_token_len = count;
-  return EDHOC_SUCCESS;
-}
-
-int EdhocEadManager::callProcessEad(enum edhoc_message message,
-                                    const struct edhoc_ead_token* ead_token,
-                                    size_t ead_token_size) {
-  for (size_t i = 0; i < ead_token_size; ++i) {
-    const edhoc_ead_token& token = ead_token[i];
-    std::vector<uint8_t> eadBuffer(token.value, token.value + token.value_len);
-
-    StoreEad(message, token.label, eadBuffer);
-  }
-
-  return EDHOC_SUCCESS;
-}

package/src/EdhocExportOscoreAsyncWorker.cpp

@@ -1,67 +0,0 @@
-#include "EdhocExportOscoreAsyncWorker.h"
-
-static constexpr const char* kErrorMessageFormat = "Failed to export OSCORE. Error code: %d.";
-static constexpr const char* kPropMasterSecret = "masterSecret";
-static constexpr const char* kPropMasterSalt = "masterSalt";
-static constexpr const char* kPropSenderId = "senderId";
-static constexpr const char* kPropRecipientId = "recipientId";
-static constexpr size_t kErrorBufferSize = 100;
-static constexpr size_t kMasterSecrectSize = 16;
-static constexpr size_t kMasterSaltSize = 8;
-static constexpr size_t kConnectionIdSize = 7;
-
-EdhocExportOscoreAsyncWorker::EdhocExportOscoreAsyncWorker(RunningContext* runningContext)
-    : Napi::AsyncWorker(runningContext->GetEnv()),
-      runningContext_(runningContext),
-      masterSecret_(kMasterSecrectSize),
-      masterSalt_(kMasterSaltSize),
-      senderId_(kConnectionIdSize),
-      recipientId_(kConnectionIdSize) {}
-
-EdhocExportOscoreAsyncWorker::~EdhocExportOscoreAsyncWorker() {}
-
-void EdhocExportOscoreAsyncWorker::Execute() {
-  try {
-    size_t sender_id_length, recipient_id_length;
-
-    int ret = edhoc_export_oscore_session(runningContext_->GetEdhocContext(), masterSecret_.data(), masterSecret_.size(), masterSalt_.data(),
-                                          masterSalt_.size(), senderId_.data(), senderId_.size(), &sender_id_length,
-                                          recipientId_.data(), recipientId_.size(), &recipient_id_length);
-
-    if (ret != EDHOC_SUCCESS) {
-      char errorMessage[kErrorBufferSize];
-      std::snprintf(errorMessage, kErrorBufferSize, kErrorMessageFormat, ret);
-      SetError(errorMessage);
-    } else {
-      senderId_.resize(sender_id_length);
-      recipientId_.resize(recipient_id_length);
-    }
-
-  } catch (const std::exception& e) {
-    SetError(e.what());
-  }
-}
-
-void EdhocExportOscoreAsyncWorker::OnOK() {
-  Napi::Env env = Env();
-  Napi::HandleScope scope(env);
-
-  auto masterSecretBuffer = Napi::Buffer<uint8_t>::Copy(env, masterSecret_.data(), masterSecret_.size());
-  auto masterSaltBuffer = Napi::Buffer<uint8_t>::Copy(env, masterSalt_.data(), masterSalt_.size());
-  auto senderIdBuffer = Napi::Buffer<uint8_t>::Copy(env, senderId_.data(), senderId_.size());
-  auto recipientIdBuffer = Napi::Buffer<uint8_t>::Copy(env, recipientId_.data(), recipientId_.size());
-
-  Napi::Object resultObj = Napi::Object::New(env);
-  resultObj.Set(kPropMasterSecret, masterSecretBuffer);
-  resultObj.Set(kPropMasterSalt, masterSaltBuffer);
-  resultObj.Set(kPropSenderId, senderIdBuffer);
-  resultObj.Set(kPropRecipientId, recipientIdBuffer);
-
-  runningContext_->Resolve(resultObj);
-}
-
-void EdhocExportOscoreAsyncWorker::OnError(const Napi::Error& error) {
-  Napi::Env env = Env();
-  Napi::HandleScope scope(env);
-  runningContext_->Reject(error.Value());
-}

package/src/EdhocKeyExporterAsyncWorker.cpp

@@ -1,39 +0,0 @@
-#include "EdhocKeyExporterAsyncWorker.h"
-
-static constexpr const char* kErrorMessageFormat = "Failed to export the key. Error code: %d.";
-static constexpr size_t kErrorBufferSize = 100;
-
-EdhocKeyExporterAsyncWorker::EdhocKeyExporterAsyncWorker(RunningContext* runningContext,
-                                                         uint16_t label,
-                                                         uint8_t desiredLength)
-    : Napi::AsyncWorker(runningContext->GetEnv()),
-      runningContext_(runningContext),
-      label_(label),
-      desiredLength_(desiredLength),
-      output_(desiredLength) {}
-
-void EdhocKeyExporterAsyncWorker::Execute() {
-  try {
-    int ret = edhoc_export_prk_exporter(runningContext_->GetEdhocContext(), label_, output_.data(), desiredLength_);
-    if (ret != EDHOC_SUCCESS) {
-      char errorMessage[kErrorBufferSize];
-      std::snprintf(errorMessage, kErrorBufferSize, kErrorMessageFormat, ret);
-      SetError(errorMessage);
-    }
-  } catch (const std::exception& e) {
-    SetError(e.what());
-  }
-}
-
-void EdhocKeyExporterAsyncWorker::OnOK() {
-  Napi::Env env = Env();
-  Napi::HandleScope scope(env);
-  auto outputBuffer = Napi::Buffer<uint8_t>::Copy(env, output_.data(), output_.size());
-  runningContext_->Resolve(outputBuffer);
-}
-
-void EdhocKeyExporterAsyncWorker::OnError(const Napi::Error& error) {
-  Napi::Env env = Env();
-  Napi::HandleScope scope(env);
-  runningContext_->Reject(error.Value());
-}

package/src/EdhocKeyUpdateAsyncWorker.cpp

@@ -1,31 +0,0 @@
-#include "EdhocKeyUpdateAsyncWorker.h"
-
-EdhocKeyUpdateAsyncWorker::EdhocKeyUpdateAsyncWorker(RunningContext* runningContext,
-                                                     std::vector<uint8_t> contextBuffer)
-    : Napi::AsyncWorker(runningContext->GetEnv()),
-      runningContext_(runningContext),
-      contextBuffer_(contextBuffer) {}
-
-void EdhocKeyUpdateAsyncWorker::Execute() {
-  try {
-    int ret = edhoc_export_key_update(runningContext_->GetEdhocContext(), contextBuffer_.data(), contextBuffer_.size());
-
-    if (ret != EDHOC_SUCCESS) {
-      SetError("Failed to update key.");
-    }
-  } catch (const std::exception& e) {
-    SetError(e.what());
-  }
-}
-
-void EdhocKeyUpdateAsyncWorker::OnOK() {
-  Napi::Env env = Env();
-  Napi::HandleScope scope(env);
-  runningContext_->Resolve(env.Undefined());
-}
-
-void EdhocKeyUpdateAsyncWorker::OnError(const Napi::Error& error) {
-  Napi::Env env = Env();
-  Napi::HandleScope scope(env);
-  runningContext_->Reject(error.Value());
-}

package/src/EdhocProcessAsyncWorker.cpp

@@ -1,120 +0,0 @@
-#include "EdhocProcessAsyncWorker.h"
-
-static constexpr const char* kErrorInvalidMessageNumber = "Invalid message number";
-static constexpr const char* kErrorMessageFormat = "Failed to process EDHOC message %d. Error code: %d";
-static constexpr const char* kErrorWrongSelectedCipherSuiteFormat =
-    "Wrong selected cipher suite. Supported: %s, Received: %s";
-static constexpr size_t kErrorBufferSize = 100;
-
-EdhocProcessAsyncWorker::EdhocProcessAsyncWorker(RunningContext* runningContext,
-                                                 int messageNumber,
-                                                 Napi::Buffer<uint8_t> buffer)
-    : Napi::AsyncWorker(runningContext->GetEnv()),
-      runningContext_(runningContext),
-      messageNumber_(messageNumber),
-      messageBuffer_(buffer.Data(), buffer.Data() + buffer.Length()),
-      peerCipherSuites_() {}
-
-void EdhocProcessAsyncWorker::Execute() {
-  try {
-    uint8_t* message = messageBuffer_.data();
-    size_t message_length = messageBuffer_.size();
-
-    int ret = EDHOC_ERROR_GENERIC_ERROR;
-    switch (messageNumber_) {
-      case EDHOC_MSG_1:
-        ret = edhoc_message_1_process(runningContext_->GetEdhocContext(), message, message_length);
-        break;
-      case EDHOC_MSG_2:
-        ret = edhoc_message_2_process(runningContext_->GetEdhocContext(), message, message_length);
-        break;
-      case EDHOC_MSG_3:
-        ret = edhoc_message_3_process(runningContext_->GetEdhocContext(), message, message_length);
-        break;
-      case EDHOC_MSG_4:
-        ret = edhoc_message_4_process(runningContext_->GetEdhocContext(), message, message_length);
-        break;
-      default:
-        SetError(kErrorInvalidMessageNumber);
-        return;
-    }
-
-    if (ret != EDHOC_SUCCESS) {
-      enum edhoc_error_code error_code = EDHOC_ERROR_CODE_SUCCESS;
-      ret = edhoc_error_get_code(runningContext_->GetEdhocContext(), &error_code);
-      switch (error_code) {
-        case EDHOC_ERROR_CODE_WRONG_SELECTED_CIPHER_SUITE: {
-          size_t csuites_len = 0;
-          int32_t csuites[10] = {0};
-          size_t peer_csuites_len = 0;
-          int32_t peer_csuites[10] = {0};
-
-          ret = edhoc_error_get_cipher_suites(runningContext_->GetEdhocContext(), csuites, ARRAY_SIZE(csuites), &csuites_len, peer_csuites,
-                                              ARRAY_SIZE(peer_csuites), &peer_csuites_len);
-          if (ret == EDHOC_SUCCESS) {
-            std::string suites_str = "[";
-            for (size_t i = 0; i < csuites_len; i++) {
-              suites_str += std::to_string(csuites[i]);
-              if (i < csuites_len - 1) {
-                suites_str += ", ";
-              }
-            }
-            suites_str += "*]";
-
-            std::string peer_suites_str = "[";
-            for (size_t i = 0; i < peer_csuites_len; i++) {
-              peer_suites_str += std::to_string(peer_csuites[i]);
-              if (i < peer_csuites_len - 1) {
-                peer_suites_str += ", ";
-              }
-            }
-            peer_suites_str += "*]";
-
-            peerCipherSuites_.assign(peer_csuites, peer_csuites + peer_csuites_len);
-
-            char errorMessage[kErrorBufferSize];
-            std::snprintf(errorMessage, kErrorBufferSize, kErrorWrongSelectedCipherSuiteFormat, suites_str.c_str(),
-                          peer_suites_str.c_str());
-            SetError(errorMessage);
-            return;
-          }
-          break;
-        }
-        default:
-          break;
-      }
-
-      char errorMessage[kErrorBufferSize];
-      std::snprintf(errorMessage, kErrorBufferSize, kErrorMessageFormat, messageNumber_ + 1, error_code);
-      SetError(errorMessage);
-    }
-
-  } catch (const std::exception& e) {
-    SetError(e.what());
-  }
-}
-
-void EdhocProcessAsyncWorker::OnOK() {
-  Napi::Env env = Env();
-  Napi::HandleScope scope(env);
-  
-  Napi::Array EADs = runningContext_->GetEadManager()->GetEadByMessage(env, static_cast<enum edhoc_message>(messageNumber_));
-  runningContext_->GetEadManager()->ClearEadByMessage(static_cast<enum edhoc_message>(messageNumber_));
-
-  runningContext_->Resolve(EADs);
-}
-
-void EdhocProcessAsyncWorker::OnError(const Napi::Error& error) {
-  Napi::Env env = Env();
-  Napi::HandleScope scope(env);
-
-  if (peerCipherSuites_.size() > 0) {
-    Napi::Array result = Napi::Array::New(env, peerCipherSuites_.size());
-    for (size_t i = 0; i < peerCipherSuites_.size(); i++) {
-      result.Set(i, Napi::Number::New(env, peerCipherSuites_[i]));
-    }
-    error.Set("peerCipherSuites", result);
-  }
-
-  runningContext_->Reject(error.Value());
-}

package/src/RunningContext.cpp

@@ -1,95 +0,0 @@
-#include "RunningContext.h"
-#include <iostream>
-RunningContext::RunningContext(Napi::Env env, 
-                 struct edhoc_context* edhoc_context,
-                 EdhocCryptoManager* cryptoManager,
-                 EdhocEadManager* eadManager,
-                 EdhocCredentialManager* credentialManager,
-                 const Napi::Function& logger) 
-    : edhoc_context_(edhoc_context)
-    , cryptoManager_(cryptoManager)
-    , eadManager_(eadManager)
-    , credentialManager_(credentialManager)
-    , tsfn_()
-    , deferred_(Napi::Promise::Deferred::New(env))
-    , loggerRef_(Napi::Weak(logger))
-    , isResolved_(false)
-{
-    Napi::Function jsCallback = Napi::Function::New(env, [](const Napi::CallbackInfo& info) { return Napi::Value(); });
-    this->tsfn_ = Napi::ThreadSafeFunction::New(env, jsCallback, "jsCallback", 0, 1, this);
-}
-
-int RunningContext::ThreadSafeBlockingCall(
-    Napi::ObjectReference& jsObjectRef,
-    const std::string& jsFunctionName,
-    ArgumentsHandler argumentsHandler,
-    CompletionHandler completionHandler)
-{
-  std::promise<int> promise;
-  std::future<int> future = promise.get_future();
-
-  this->tsfn_.BlockingCall(&promise, [this, &jsObjectRef, jsFunctionName, argumentsHandler, completionHandler](Napi::Env env, Napi::Function jsCallback, std::promise<int>* promise) {
-    Napi::HandleScope scope(env);
-    auto deferred = Napi::Promise::Deferred::New(env);
-    try {
-      const std::vector<napi_value> arguments = argumentsHandler(env);
-      Napi::Function jsFunction = jsObjectRef.Value().Get(jsFunctionName).As<Napi::Function>();
-      Napi::Value result = jsFunction.Call(jsObjectRef.Value(), arguments);
-      deferred.Resolve(result);
-    } catch (const Napi::Error& e) {
-      deferred.Reject(e.Value());
-    } catch (const std::exception& e) {
-      deferred.Reject(Napi::Error::New(env, e.what()).Value());
-    }
-
-    auto thenCallback = Napi::Function::New(env, [this, promise, completionHandler](const Napi::CallbackInfo& info) {
-      Napi::Env env = info.Env();
-      Napi::HandleScope scope(env);
-      try {
-        int result = completionHandler(env, info[0].As<Napi::Value>());
-        promise->set_value(result);
-      } catch (const Napi::Error& e) {
-        this->Reject(info[0].As<Napi::Error>().Value());
-        promise->set_value(EDHOC_ERROR_GENERIC_ERROR);
-      } catch (const std::exception& e) {
-        this->Reject(Napi::Error::New(env, e.what()).Value());
-        promise->set_value(EDHOC_ERROR_GENERIC_ERROR);
-      }
-    });
-
-    auto catchCallback = Napi::Function::New(env, [this, promise](const Napi::CallbackInfo& info) {
-      Napi::Env env = info.Env();
-      Napi::HandleScope scope(env);
-      this->Reject(info[0].As<Napi::Error>().Value());
-      promise->set_value(EDHOC_ERROR_GENERIC_ERROR);
-    });
-
-    Napi::Promise promise_ = deferred.Promise();
-    promise_.Get("then").As<Napi::Function>().Call(promise_, { thenCallback, catchCallback });
-  });  
-
-  future.wait();
-  return future.get();
-}
-
-void RunningContext::Resolve(Napi::Value value) {
-    if (isResolved_) {
-        return;
-    }
-    deferred_.Resolve(value);
-    tsfn_.Release();
-    isResolved_ = true;
-}
-
-void RunningContext::Reject(Napi::Value value) {
-  if (isResolved_) {
-    return;
-  }
-  deferred_.Reject(value);
-  tsfn_.Release();
-  isResolved_ = true;
-}
-
-Napi::Promise RunningContext::GetPromise() const {
-    return deferred_.Promise();
-} 

package/src/Suites.cpp

@@ -1,120 +0,0 @@
-#include "Suites.h"
-
-// Cipher Suite 0
-static const struct edhoc_cipher_suite edhoc_cipher_suite_0 = {
-    .value = 0,             // Suite identifier 0
-    .aead_key_length = 16,  // Key length for AES-CCM-16-64-128 (16 bytes)
-    .aead_tag_length = 8,   // Authentication tag length for AES-CCM (8 bytes)
-    .aead_iv_length = 13,   // Initialization vector length for AES-CCM (13 bytes)
-    .hash_length = 32,      // Output length for SHA-256 (32 bytes)
-    .mac_length = 8,        // MAC length (8 bytes)
-    .ecc_key_length = 32,   // Elliptic curve key length for X25519 (32 bytes)
-    .ecc_sign_length = 64,  // Signature length for EdDSA using X25519 (64 bytes)
-};
-
-// Cipher Suite 1
-static const struct edhoc_cipher_suite edhoc_cipher_suite_1 = {
-    .value = 1,             // Suite identifier 1
-    .aead_key_length = 16,  // Key length for AES-CCM-16-128-128 (16 bytes)
-    .aead_tag_length = 16,  // Authentication tag length for AES-CCM (16 bytes)
-    .aead_iv_length = 13,   // Initialization vector length for AES-CCM (13 bytes)
-    .hash_length = 32,      // Output length for SHA-256 (32 bytes)
-    .mac_length = 16,       // MAC length (16 bytes)
-    .ecc_key_length = 32,   // Elliptic curve key length for X25519 (32 bytes)
-    .ecc_sign_length = 64,  // Signature length for EdDSA using X25519 (64 bytes)
-};
-
-// Cipher Suite 2
-static const struct edhoc_cipher_suite edhoc_cipher_suite_2 = {
-    .value = 2,             // Suite identifier 2
-    .aead_key_length = 16,  // Key length for AES-CCM-16-64-128 (16 bytes)
-    .aead_tag_length = 8,   // Authentication tag length for AES-CCM (8 bytes)
-    .aead_iv_length = 13,   // Initialization vector length for AES-CCM (13 bytes)
-    .hash_length = 32,      // Output length for SHA-256 (32 bytes)
-    .mac_length = 8,        // MAC length (8 bytes)
-    .ecc_key_length = 32,   // Elliptic curve key length for P-256 (32 bytes)
-    .ecc_sign_length = 64,  // Signature length for ES256 using P-256 (64 bytes)
-};
-
-// Cipher Suite 3
-static const struct edhoc_cipher_suite edhoc_cipher_suite_3 = {
-    .value = 3,             // Suite identifier 3
-    .aead_key_length = 16,  // Key length for AES-CCM-16-128-128 (16 bytes)
-    .aead_tag_length = 16,  // Authentication tag length for AES-CCM (16 bytes)
-    .aead_iv_length = 13,   // Initialization vector length for AES-CCM (13 bytes)
-    .hash_length = 32,      // Output length for SHA-256 (32 bytes)
-    .mac_length = 16,       // MAC length (16 bytes)
-    .ecc_key_length = 32,   // Elliptic curve key length for P-256 (32 bytes)
-    .ecc_sign_length = 64,  // Signature length for ES256 using P-256 (64 bytes)
-};
-
-// Cipher Suite 4
-static const struct edhoc_cipher_suite edhoc_cipher_suite_4 = {
-    .value = 4,             // Suite identifier 4
-    .aead_key_length = 32,  // Key length for ChaCha20 (32 bytes)
-    .aead_tag_length = 16,  // Authentication tag length for Poly1305 (16 bytes)
-    .aead_iv_length = 12,   // Nonce length for ChaCha20 (12 bytes)
-    .hash_length = 32,      // Output length for SHA-256 (32 bytes)
-    .mac_length = 16,       // MAC length (16 bytes)
-    .ecc_key_length = 32,   // Elliptic curve key length for X25519 (32 bytes)
-    .ecc_sign_length = 64,  // Signature length for EdDSA using X25519 (64 bytes)
-};
-
-// Cipher Suite 5
-static const struct edhoc_cipher_suite edhoc_cipher_suite_5 = {
-    .value = 5,             // Suite identifier 5
-    .aead_key_length = 32,  // Key length for ChaCha20 (32 bytes)
-    .aead_tag_length = 16,  // Authentication tag length for Poly1305 (16 bytes)
-    .aead_iv_length = 12,   // Nonce length for ChaCha20 (12 bytes)
-    .hash_length = 32,      // Output length for SHA-256 (32 bytes)
-    .mac_length = 16,       // MAC length (16 bytes)
-    .ecc_key_length = 32,   // Elliptic curve key length for P-256 (32 bytes)
-    .ecc_sign_length = 64,  // Signature length for ES256 using P-256 (64 bytes)
-};
-
-// Cipher Suite 6
-static const struct edhoc_cipher_suite edhoc_cipher_suite_6 = {
-    .value = 6,             // Suite identifier 6
-    .aead_key_length = 16,  // Key length for A128GCM (16 bytes)
-    .aead_tag_length = 16,  // Authentication tag length for A128GCM (16 bytes)
-    .aead_iv_length = 12,   // Initialization vector length for A128GCM (12 bytes)
-    .hash_length = 32,      // Output length for SHA-256 (32 bytes)
-    .mac_length = 16,       // MAC length (16 bytes)
-    .ecc_key_length = 32,   // Elliptic curve key length for X25519 (32 bytes)
-    .ecc_sign_length = 64,  // Signature length for ES256 using X25519 (64 bytes)
-};
-
-// Cipher Suite 24
-static const struct edhoc_cipher_suite edhoc_cipher_suite_24 = {
-    .value = 24,            // Suite identifier 24
-    .aead_key_length = 32,  // Key length for A256GCM (32 bytes)
-    .aead_tag_length = 16,  // Authentication tag length for A256GCM (16 bytes)
-    .aead_iv_length = 12,   // Initialization vector length for A256GCM (12 bytes)
-    .hash_length = 48,      // Output length for SHA-384 (48 bytes)
-    .mac_length = 16,       // MAC length (16 bytes)
-    .ecc_key_length = 48,   // Elliptic curve key length for P-384 (48 bytes)
-    .ecc_sign_length = 96,  // Signature length for ES384 using P-384 (96 bytes)
-};
-
-// Cipher Suite 25
-static const struct edhoc_cipher_suite edhoc_cipher_suite_25 = {
-    .value = 25,             // Suite identifier 25
-    .aead_key_length = 32,   // Key length for ChaCha20 (32 bytes)
-    .aead_tag_length = 16,   // Authentication tag length for Poly1305 (16 bytes)
-    .aead_iv_length = 12,    // Nonce length for ChaCha20 (12 bytes)
-    .hash_length = 64,       // Output length for SHAKE256 (64 bytes)
-    .mac_length = 16,        // MAC length (16 bytes)
-    .ecc_key_length = 56,    // Elliptic curve key length for X448 (56 bytes)
-    .ecc_sign_length = 114,  // Signature length for EdDSA using X448 (114 bytes)
-};
-
-const struct edhoc_cipher_suite* suite_pointers[] = {
-    &edhoc_cipher_suite_0, &edhoc_cipher_suite_1, &edhoc_cipher_suite_2, &edhoc_cipher_suite_3, &edhoc_cipher_suite_4,
-    &edhoc_cipher_suite_5, &edhoc_cipher_suite_6,
-    // 7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23
-    nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
-    nullptr, nullptr, nullptr, nullptr,
-    // 24, 25
-    &edhoc_cipher_suite_24, &edhoc_cipher_suite_25};
-
-const size_t suite_pointers_count = sizeof(suite_pointers) / sizeof(suite_pointers[0]);

package/src/Utils.cpp

@@ -1,54 +0,0 @@
-#include "Utils.h"
-
-#include <condition_variable>
-#include <cstring>
-#include <mutex>
-#include <thread>
-#include <iostream>
-
-static constexpr const char* kErrorInputValueMustBeANumberOrABuffer = "Input value must be a number or a buffer";
-
-void Utils::EncodeInt64ToBuffer(int64_t value, uint8_t* buffer, size_t* length) {
-  size_t idx = 0;
-  if (value == 0) {
-    buffer[idx++] = 0;
-  } else {
-    while (value != 0) {
-      buffer[idx++] = value & 0xFF;
-      value >>= 8;
-    }
-  }
-  *length = idx;
-}
-
-struct edhoc_connection_id Utils::ConvertJsValueToEdhocCid(Napi::Value value) {
-  struct edhoc_connection_id cid = {};
-  if (value.IsNumber()) {
-    int64_t numeric = value.As<Napi::Number>().Int64Value();
-    if (numeric >= ONE_BYTE_CBOR_INT_MIN_VALUE && numeric <= ONE_BYTE_CBOR_INT_MAX_VALUE) {
-      cid = {.encode_type = EDHOC_CID_TYPE_ONE_BYTE_INTEGER, .int_value = (int8_t)numeric};
-    } else {
-      size_t length = 0;
-      Utils::EncodeInt64ToBuffer(numeric, cid.bstr_value, &length);
-      cid.encode_type = EDHOC_CID_TYPE_BYTE_STRING;
-      cid.bstr_length = length;
-    }
-  } else if (value.IsBuffer()) {
-    Napi::Buffer<uint8_t> buffer = value.As<Napi::Buffer<uint8_t>>();
-    cid.encode_type = EDHOC_CID_TYPE_BYTE_STRING;
-    cid.bstr_length = buffer.Length();
-    memcpy(cid.bstr_value, buffer.Data(), cid.bstr_length);
-  } else {
-    throw Napi::TypeError::New(value.Env(), kErrorInputValueMustBeANumberOrABuffer);
-  }
-  return cid;
-}
-
-Napi::Value Utils::CreateJsValueFromEdhocCid(Napi::Env env, struct edhoc_connection_id value) {
-  if (value.encode_type == EDHOC_CID_TYPE_ONE_BYTE_INTEGER) {
-    return Napi::Number::New(env, value.int_value);
-  } else if (value.encode_type == EDHOC_CID_TYPE_BYTE_STRING) {
-    return Napi::Buffer<char>::Copy(env, (const char*)value.bstr_value, value.bstr_length);
-  }
-  return env.Null();
-}