edhoc 1.2.2 → 1.2.3

package/binding.gyp

@@ -6,7 +6,7 @@
     {
       "target_name": "bindings",
       'defines': [
-        'NAPI_CPP_EXCEPTIONS=1',
+        'NAPI_DISABLE_CPP_EXCEPTIONS=1',
         'CONFIG_LIBEDHOC_ENABLE=1',
         'CONFIG_LIBEDHOC_MAX_NR_OF_CIPHER_SUITES=9',
         'CONFIG_LIBEDHOC_MAX_LEN_OF_CONN_ID=7',
@@ -38,7 +38,7 @@
       'cflags!': [ '-fno-exceptions', '-std=c99' ],
       'cflags_cc!': [ '-fno-exceptions', '-std=c++20' ],
       'xcode_settings': {
-        'GCC_ENABLE_CPP_EXCEPTIONS': 'YES',
+        'GCC_ENABLE_CPP_EXCEPTIONS': 'NO',
         'CLANG_CXX_LIBRARY': 'libc++',
         'CLANG_CXX_LANGUAGE_STANDARD': 'c++20',
         'MACOSX_DEPLOYMENT_TARGET': '12'

package/include/EdhocCredentialManager.h

@@ -93,7 +93,7 @@ class EdhocCredentialManager {
   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.
    * @param name The name of the function in the JS credential manager object.

package/include/UserContext.h

@@ -67,6 +67,7 @@ class UserContext {
 
   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

package/include/Utils.h

@@ -5,9 +5,9 @@
 
 #include <cstdint>
 #include <future>
+#include <iostream>
 #include <string>
 #include <vector>
-
 extern "C" {
 #include "edhoc.h"
 }
@@ -53,14 +53,15 @@ class Utils {
    * @return A lambda function that sets the exception on the promise.
    */
   template <typename T>
-  static ErrorHandler CreatePromiseErrorHandler(std::promise<T>& promise, T defaultValue) {
-    return [&promise, defaultValue](Napi::Env env, Napi::Error error) {
-      auto exception = std::current_exception();
-      if (exception) {
-        promise.set_exception(exception);
-      } else {
-        promise.set_value(defaultValue);
+  static ErrorHandler CreatePromiseErrorHandler(std::promise<T>& promise, T defaultValue, Napi::Error& lastError) {
+    return [&promise, defaultValue, &lastError](Napi::Env env, Napi::Error error) {
+      if (!error.IsEmpty()) {
+        error.ThrowAsJavaScriptException();
+      }
+      if (env.IsExceptionPending()) {
+        lastError = env.GetAndClearPendingException();
       }
+      promise.set_value(defaultValue);
     };
   }
 
@@ -94,7 +95,7 @@ class Utils {
   template <typename EnumType>
   static EnumType ConvertToEnum(const Napi::Value& value) {
     if (!value.IsNumber()) {
-      throw Napi::TypeError::New(value.Env(), "Input value must be a number");
+      Napi::TypeError::New(value.Env(), "Input value must be a number").ThrowAsJavaScriptException();
     }
     return static_cast<EnumType>(value.As<Napi::Number>().Int32Value());
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "edhoc",
   "description": "A Node.js implementation of EDHOC (Ephemeral Diffie-Hellman Over COSE) protocol for lightweight authenticated key exchange in IoT and other constrained environments.",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "Marek Serafin <marek@serafin.email>",

package/src/EdhocComposeAsyncWorker.cpp

@@ -16,54 +16,61 @@ EdhocComposeAsyncWorker::EdhocComposeAsyncWorker(Napi::Env& env,
       callback(std::move(callback)) {}
 
 void EdhocComposeAsyncWorker::Execute() {
-  try {
-    composedMessage.resize(kInitialBufferSize);
-    size_t composedMessageLength = 0;
+  composedMessage.resize(kInitialBufferSize);
+  size_t composedMessageLength = 0;
 
-    int ret = EDHOC_ERROR_GENERIC_ERROR;
-    switch (messageNumber) {
-      case EDHOC_MSG_1:
-        ret = edhoc_message_1_compose(&context, composedMessage.data(), composedMessage.size(), &composedMessageLength);
-        break;
-      case EDHOC_MSG_2:
-        ret = edhoc_message_2_compose(&context, composedMessage.data(), composedMessage.size(), &composedMessageLength);
-        break;
-      case EDHOC_MSG_3:
-        ret = edhoc_message_3_compose(&context, composedMessage.data(), composedMessage.size(), &composedMessageLength);
-        break;
-      case EDHOC_MSG_4:
-        ret = edhoc_message_4_compose(&context, composedMessage.data(), composedMessage.size(), &composedMessageLength);
-        break;
-      default:
-        SetError(kErrorInvalidMessageNumber);
-        return;
-    }
-
-    composedMessage.resize(composedMessageLength);
+  int ret = EDHOC_ERROR_GENERIC_ERROR;
+  switch (messageNumber) {
+    case EDHOC_MSG_1:
+      ret = edhoc_message_1_compose(&context, composedMessage.data(), composedMessage.size(), &composedMessageLength);
+      break;
+    case EDHOC_MSG_2:
+      ret = edhoc_message_2_compose(&context, composedMessage.data(), composedMessage.size(), &composedMessageLength);
+      break;
+    case EDHOC_MSG_3:
+      ret = edhoc_message_3_compose(&context, composedMessage.data(), composedMessage.size(), &composedMessageLength);
+      break;
+    case EDHOC_MSG_4:
+      ret = edhoc_message_4_compose(&context, composedMessage.data(), composedMessage.size(), &composedMessageLength);
+      break;
+    default:
+      SetError(kErrorInvalidMessageNumber);
+      return;
+  }
 
-    if (ret != EDHOC_SUCCESS) {
-      char errorMessage[kErrorBufferSize];
-      std::snprintf(errorMessage, kErrorBufferSize, kErrorMessageFormat, messageNumber + 1, ret);
-      SetError(errorMessage);
-    }
+  composedMessage.resize(composedMessageLength);
 
-  } catch (const std::exception& e) {
-    SetError(e.what());
+  if (ret != EDHOC_SUCCESS) {
+    char errorMessage[kErrorBufferSize];
+    std::snprintf(errorMessage, kErrorBufferSize, kErrorMessageFormat, messageNumber + 1, ret);
+    SetError(errorMessage);
   }
 }
 
 void EdhocComposeAsyncWorker::OnOK() {
   Napi::Env env = Env();
   Napi::HandleScope scope(env);
-  deferred.Resolve(Napi::Buffer<uint8_t>::Copy(env, composedMessage.data(), composedMessage.size()));
+
   callback(env);
+
+  if (env.IsExceptionPending()) {
+    deferred.Reject(env.GetAndClearPendingException().Value());
+  } else {
+    deferred.Resolve(Napi::Buffer<uint8_t>::Copy(env, composedMessage.data(), composedMessage.size()));
+  }
 }
 
 void EdhocComposeAsyncWorker::OnError(const Napi::Error& error) {
   Napi::Env env = Env();
   Napi::HandleScope scope(env);
-  deferred.Reject(error.Value());
+
   callback(env);
+
+  if (env.IsExceptionPending()) {
+    deferred.Reject(env.GetAndClearPendingException().Value());
+  } else {
+    deferred.Reject(error.Value());
+  }
 }
 
 Napi::Promise EdhocComposeAsyncWorker::GetPromise() {

package/src/EdhocCredentialManager.cpp

@@ -36,7 +36,7 @@ static constexpr const char* kVerify = "verify";
 void convert_js_to_edhoc_kid(const Napi::Object& jsObject, struct edhoc_auth_creds* credentials) {
   Napi::Object kidObj = jsObject.Get(kKid).As<Napi::Object>();
   if (!kidObj.Has(kIsCBOR) || !kidObj.Has(kKid) || !kidObj.Has(kCredentials)) {
-    throw std::runtime_error(kInvalidInputDataErrorKid);
+    Napi::TypeError::New(jsObject.Env(), kInvalidInputDataErrorKid).ThrowAsJavaScriptException();
   }
 
   credentials->label = EDHOC_COSE_HEADER_KID;
@@ -58,7 +58,7 @@ void convert_js_to_edhoc_kid(const Napi::Object& jsObject, struct edhoc_auth_cre
     credentials->key_id.key_id_bstr_length = buffer.Length();
     memcpy(credentials->key_id.key_id_bstr, buffer.Data(), buffer.Length());
   } else {
-    throw std::runtime_error(kInvalidInputDataErrorKid);
+    Napi::TypeError::New(jsObject.Env(), kInvalidInputDataErrorKid).ThrowAsJavaScriptException();
   }
 
   Napi::Buffer<uint8_t> credBuffer = kidObj.Get(kCredentials).As<Napi::Buffer<uint8_t>>();
@@ -73,7 +73,7 @@ void convert_js_to_edhoc_kid(const Napi::Object& jsObject, struct edhoc_auth_cre
 void convert_js_to_edhoc_x5chain(const Napi::Object& jsObject, struct edhoc_auth_creds* credentials) {
   Napi::Object x5chainObj = jsObject.Get(kX5chain).As<Napi::Object>();
   if (!x5chainObj.Has(kCertificates)) {
-    throw std::runtime_error(kInvalidInputDataErrorX509Chain);
+    Napi::TypeError::New(jsObject.Env(), kInvalidInputDataErrorX509Chain).ThrowAsJavaScriptException();
   }
 
   credentials->label = EDHOC_COSE_HEADER_X509_CHAIN;
@@ -95,7 +95,7 @@ void convert_js_to_edhoc_x5chain(const Napi::Object& jsObject, struct edhoc_auth
 void convert_js_to_edhoc_x5t(const Napi::Object& jsObject, struct edhoc_auth_creds* credentials) {
   Napi::Object x5tObj = jsObject.Get(kX5t).As<Napi::Object>();
   if (!x5tObj.Has(kCertificate) || !x5tObj.Has(kHash) || !x5tObj.Has(kHashAlgorithm)) {
-    throw std::runtime_error(kInvalidInputDataErrorX509Hash);
+    Napi::TypeError::New(jsObject.Env(), kInvalidInputDataErrorX509Hash).ThrowAsJavaScriptException();
   }
 
   credentials->label = EDHOC_COSE_HEADER_X509_HASH;
@@ -212,13 +212,15 @@ int EdhocCredentialManager::callFetchCredentials(const void* user_context, struc
   std::promise<int> promise;
   std::future<int> future = promise.get_future();
 
-  auto successHandler = [this, &promise, &credentials](Napi::Env env, Napi::Value result) {
+  UserContext* context = static_cast<UserContext*>(const_cast<void*>(user_context));
+  auto successHandler = [this, &promise, &credentials, &context](Napi::Env env, Napi::Value result) {
     Napi::HandleScope scope(env);
     auto credsObj = result.As<Napi::Object>();
     credentialReferences.push_back(Napi::Persistent(credsObj));
 
     if (credsObj.IsObject() == false || credsObj.Has(kFormat) == false) {
-      throw std::runtime_error(kInvalidInputCredentialTypeError);
+      context->error = Napi::Error::New(env, kInvalidInputCredentialTypeError);
+      return promise.set_value(EDHOC_ERROR_GENERIC_ERROR);
     }
     int label = credsObj.Get(kFormat).As<Napi::Number>().Int32Value();
 
@@ -234,22 +236,27 @@ int EdhocCredentialManager::callFetchCredentials(const void* user_context, struc
         break;
       case EDHOC_COSE_ANY:
       default:
-        throw std::runtime_error(kUnsupportedCredentialTypeError);
+        context->error = Napi::Error::New(env, kUnsupportedCredentialTypeError);
+        return promise.set_value(EDHOC_ERROR_GENERIC_ERROR);
     }
 
     if (credsObj.Has(kPrivateKeyId) && !credsObj.Get(kPrivateKeyId).IsNull()) {
       Napi::Buffer<uint8_t> privKeyIdBuffer = credsObj.Get(kPrivateKeyId).As<Napi::Buffer<uint8_t>>();
       memcpy(credentials->priv_key_id, privKeyIdBuffer.Data(), privKeyIdBuffer.Length());
     }
+    else {
+      context->error = Napi::Error::New(env, kInvalidInputCredentialTypeError);
+      return promise.set_value(EDHOC_ERROR_GENERIC_ERROR);
+    }
 
     promise.set_value(EDHOC_SUCCESS);
   };
 
-  auto blockingCallHandler = [this, &user_context, &successHandler, &promise](Napi::Env env,
+  auto blockingCallHandler = [this, &context, &successHandler, &promise](Napi::Env env,
                                                                               Napi::Function jsCallback) {
     Napi::HandleScope scope(env);
-    std::vector<napi_value> arguments = {static_cast<const UserContext*>(user_context)->parent.Value()};
-    auto errorHandler = Utils::CreatePromiseErrorHandler<int>(promise, EDHOC_ERROR_GENERIC_ERROR);
+    std::vector<napi_value> arguments = {context->parent.Value()};
+    auto errorHandler = Utils::CreatePromiseErrorHandler<int>(promise, EDHOC_ERROR_GENERIC_ERROR, context->error);
     Utils::InvokeJSFunctionWithPromiseHandling(env, credentialManagerRef.Value(), jsCallback, arguments, successHandler,
                                                errorHandler);
   };
@@ -267,13 +274,16 @@ int EdhocCredentialManager::callVerifyCredentials(const void* user_context,
   std::promise<int> promise;
   std::future<int> future = promise.get_future();
 
-  auto successHandler = [this, &promise, &credentials, &public_key_reference, &public_key_length](Napi::Env env,
+  UserContext* context = static_cast<UserContext*>(const_cast<void*>(user_context));
+
+  auto successHandler = [this, &promise, &credentials, &public_key_reference, &public_key_length, &context](Napi::Env env,
                                                                                                   Napi::Value result) {
     Napi::HandleScope scope(env);
     Napi::Object credsObj = result.As<Napi::Object>();
     credentialReferences.push_back(Napi::Persistent(credsObj));
     if (credsObj.IsObject() == false) {
-      throw std::runtime_error(kInvalidInputCredentialTypeError);
+      context->error = Napi::Error::New(env, kInvalidInputCredentialTypeError);
+      return promise.set_value(EDHOC_ERROR_GENERIC_ERROR);
     }
 
     int label = credsObj.Get(kFormat).As<Napi::Number>().Int32Value();
@@ -288,7 +298,8 @@ int EdhocCredentialManager::callVerifyCredentials(const void* user_context,
         convert_js_to_edhoc_x5t(credsObj, credentials);
         break;
       default:
-        throw std::runtime_error(kUnsupportedCredentialTypeError);
+        context->error = Napi::Error::New(env, kUnsupportedCredentialTypeError);
+        return promise.set_value(EDHOC_ERROR_GENERIC_ERROR);
     }
 
     if (credsObj.Has(kPublicKey) && !credsObj.Get(kPublicKey).IsNull()) {
@@ -296,11 +307,15 @@ int EdhocCredentialManager::callVerifyCredentials(const void* user_context,
       *public_key_reference = publicKeyBuffer.Data();
       *public_key_length = publicKeyBuffer.Length();
     }
+    else {
+      context->error = Napi::Error::New(env, kInvalidInputCredentialTypeError);
+      return promise.set_value(EDHOC_ERROR_GENERIC_ERROR);
+    }
 
     promise.set_value(EDHOC_SUCCESS);
   };
 
-  auto blockingCallHandler = [this, &user_context, &credentials, &successHandler, &promise](Napi::Env env,
+  auto blockingCallHandler = [this, &context, &credentials, &successHandler, &promise](Napi::Env env,
                                                                                             Napi::Function jsCallback) {
     Napi::HandleScope scope(env);
     Napi::Object resultObject = Napi::Object::New(env);
@@ -317,11 +332,12 @@ int EdhocCredentialManager::callVerifyCredentials(const void* user_context,
         resultObject.Set(kX5t, convert_edhoc_x5t_to_js(env, credentials->x509_hash));
         break;
       default:
-        throw std::runtime_error(kUnsupportedCredentialTypeError);
+        context->error = Napi::Error::New(env, kUnsupportedCredentialTypeError);
+        return promise.set_value(EDHOC_ERROR_GENERIC_ERROR);
     }
 
-    std::vector<napi_value> arguments = {static_cast<const UserContext*>(user_context)->parent.Value(), resultObject};
-    auto errorHandler = Utils::CreatePromiseErrorHandler<int>(promise, EDHOC_ERROR_GENERIC_ERROR);
+    std::vector<napi_value> arguments = {context->parent.Value(), resultObject};
+    auto errorHandler = Utils::CreatePromiseErrorHandler<int>(promise, EDHOC_ERROR_GENERIC_ERROR, context->error);
     Utils::InvokeJSFunctionWithPromiseHandling(env, credentialManagerRef.Value(), jsCallback, arguments, successHandler,
                                                errorHandler);
   };