edhoc 1.2.2 → 1.2.3

package/src/EdhocKeyUpdateAsyncWorker.cpp

@@ -11,29 +11,37 @@ EdhocKeyUpdateAsyncWorker::EdhocKeyUpdateAsyncWorker(Napi::Env& env,
       callback(std::move(callback)) {}
 
 void EdhocKeyUpdateAsyncWorker::Execute() {
-  try {
-    int ret = edhoc_export_key_update(&context, contextBuffer.data(), contextBuffer.size());
-
-    if (ret != EDHOC_SUCCESS) {
-      SetError("Failed to update key.");
-    }
-  } catch (const std::exception& e) {
-    SetError(e.what());
+  int ret = edhoc_export_key_update(&context, contextBuffer.data(), contextBuffer.size());
+
+  if (ret != EDHOC_SUCCESS) {
+    SetError("Failed to update key.");
   }
 }
 
 void EdhocKeyUpdateAsyncWorker::OnOK() {
   Napi::Env env = Env();
   Napi::HandleScope scope(env);
-  deferred.Resolve(env.Undefined());
+
   callback(env);
+
+  if (env.IsExceptionPending()) {
+    deferred.Reject(env.GetAndClearPendingException().Value());
+  } else {
+    deferred.Resolve(env.Undefined());
+  }
 }
 
 void EdhocKeyUpdateAsyncWorker::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 EdhocKeyUpdateAsyncWorker::GetPromise() {

package/src/EdhocProcessAsyncWorker.cpp

@@ -1,5 +1,6 @@
 #include "EdhocProcessAsyncWorker.h"
 
+#include <iostream>
 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 =
@@ -20,81 +21,76 @@ EdhocProcessAsyncWorker::EdhocProcessAsyncWorker(Napi::Env& env,
       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(&context, message, message_length);
-        break;
-      case EDHOC_MSG_2:
-        ret = edhoc_message_2_process(&context, message, message_length);
-        break;
-      case EDHOC_MSG_3:
-        ret = edhoc_message_3_process(&context, message, message_length);
-        break;
-      case EDHOC_MSG_4:
-        ret = edhoc_message_4_process(&context, message, message_length);
-        break;
-      default:
-        SetError(kErrorInvalidMessageNumber);
-        return;
-    }
+  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(&context, message, message_length);
+      break;
+    case EDHOC_MSG_2:
+      ret = edhoc_message_2_process(&context, message, message_length);
+      break;
+    case EDHOC_MSG_3:
+      ret = edhoc_message_3_process(&context, message, message_length);
+      break;
+    case EDHOC_MSG_4:
+      ret = edhoc_message_4_process(&context, 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(&context, &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(&context, 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 += ", ";
-              }
+  if (ret != EDHOC_SUCCESS) {
+    enum edhoc_error_code error_code = EDHOC_ERROR_CODE_SUCCESS;
+    ret = edhoc_error_get_code(&context, &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(&context, 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 += ", ";
-              }
+          }
+          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 += "*]";
+          }
+          peer_suites_str += "*]";
 
-            peerCipherSuites.assign(peer_csuites, peer_csuites + peer_csuites_len);
+          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;
+          char errorMessage[kErrorBufferSize];
+          std::snprintf(errorMessage, kErrorBufferSize, kErrorWrongSelectedCipherSuiteFormat, suites_str.c_str(),
+                        peer_suites_str.c_str());
+          SetError(errorMessage);
+          return;
         }
-        default:
-          break;
+        break;
       }
-
-      char errorMessage[kErrorBufferSize];
-      std::snprintf(errorMessage, kErrorBufferSize, kErrorMessageFormat, messageNumber + 1, error_code);
-      SetError(errorMessage);
+      default:
+        break;
     }
 
-  } catch (const std::exception& e) {
-    SetError(e.what());
+    char errorMessage[kErrorBufferSize];
+    std::snprintf(errorMessage, kErrorBufferSize, kErrorMessageFormat, messageNumber + 1, error_code);
+    SetError(errorMessage);
   }
 }
 
@@ -102,8 +98,14 @@ void EdhocProcessAsyncWorker::OnOK() {
   Napi::Env env = Env();
   Napi::HandleScope scope(env);
   Napi::Array result = callback(env);
-  deferred.Resolve(result);
+
   callback(env);
+
+  if (env.IsExceptionPending()) {
+    deferred.Reject(env.GetAndClearPendingException().Value());
+  } else {
+    deferred.Resolve(result);
+  }
 }
 
 void EdhocProcessAsyncWorker::OnError(const Napi::Error& error) {
@@ -118,8 +120,13 @@ void EdhocProcessAsyncWorker::OnError(const Napi::Error& error) {
     error.Set("peerCipherSuites", result);
   }
 
-  deferred.Reject(error.Value());
   callback(env);
+
+  if (env.IsExceptionPending()) {
+    deferred.Reject(env.GetAndClearPendingException().Value());
+  } else {
+    deferred.Reject(error.Value());
+  }
 }
 
 Napi::Promise EdhocProcessAsyncWorker::GetPromise() {

package/src/LibEDHOC.cpp

@@ -49,7 +49,7 @@ LibEDHOC::LibEDHOC(const Napi::CallbackInfo& info) : Napi::ObjectWrap<LibEDHOC>(
   // Initialize EDHOC context
   context = {};
   if (edhoc_context_init(&context) != EDHOC_SUCCESS) {
-    throw Napi::TypeError::New(env, kErrorFailedToInitializeEdhocContext);
+    Napi::TypeError::New(env, kErrorFailedToInitializeEdhocContext).ThrowAsJavaScriptException();
   }
 
   // Connection ID, Methods, and Suites
@@ -72,7 +72,7 @@ LibEDHOC::LibEDHOC(const Napi::CallbackInfo& info) : Napi::ObjectWrap<LibEDHOC>(
       edhoc_bind_crypto(&context, &cryptoManager->crypto) != EDHOC_SUCCESS ||
       edhoc_bind_credentials(&context, &credentialManager->credentials) != EDHOC_SUCCESS ||
       edhoc_bind_ead(&context, &eadManager->ead) != EDHOC_SUCCESS) {
-    throw Napi::TypeError::New(env, kErrorFailedToInitializeEdhocContext);
+    Napi::TypeError::New(env, kErrorFailedToInitializeEdhocContext).ThrowAsJavaScriptException();
   }
 
   // Logger
@@ -83,7 +83,7 @@ LibEDHOC::LibEDHOC(const Napi::CallbackInfo& info) : Napi::ObjectWrap<LibEDHOC>(
   userContext->parent = Reference<Napi::Object>::New(info.This().As<Napi::Object>());
 
   if (edhoc_set_user_context(&context, static_cast<void*>(userContext.get())) != EDHOC_SUCCESS) {
-    throw Napi::TypeError::New(env, kErrorFailedToInitializeEdhocContext);
+    Napi::TypeError::New(env, kErrorFailedToInitializeEdhocContext).ThrowAsJavaScriptException();
   }
 }
 
@@ -121,7 +121,7 @@ void LibEDHOC::SetMethods(const Napi::CallbackInfo& info, const Napi::Value& val
   Napi::Env env = info.Env();
 
   if (!value.IsArray()) {
-    throw Napi::TypeError::New(env, kErrorArrayMethodIndexesExpected);
+    Napi::TypeError::New(env, kErrorArrayMethodIndexesExpected).ThrowAsJavaScriptException();
   }
 
   const auto jsArray = value.As<Napi::Array>();
@@ -133,7 +133,7 @@ void LibEDHOC::SetMethods(const Napi::CallbackInfo& info, const Napi::Value& val
   }
 
   if (edhoc_set_methods(&context, methods.data(), methods.size()) != EDHOC_SUCCESS) {
-    throw Napi::TypeError::New(env, kErrorFailedToSetEdhocMethod);
+    Napi::TypeError::New(env, kErrorFailedToSetEdhocMethod).ThrowAsJavaScriptException();
   }
 }
 
@@ -145,7 +145,7 @@ void LibEDHOC::SetCipherSuites(const Napi::CallbackInfo& info, const Napi::Value
   Napi::Env env = info.Env();
 
   if (!value.IsArray()) {
-    throw Napi::TypeError::New(env, kErrorArraySuiteIndexesExpected);
+    Napi::TypeError::New(env, kErrorArraySuiteIndexesExpected).ThrowAsJavaScriptException();
   }
 
   const auto jsArray = value.As<Napi::Array>();
@@ -156,14 +156,14 @@ void LibEDHOC::SetCipherSuites(const Napi::CallbackInfo& info, const Napi::Value
     const uint32_t index = jsArray.Get(i).As<Napi::Number>().Uint32Value();
 
     if (index >= suite_pointers_count || suite_pointers[index] == nullptr) {
-      throw Napi::RangeError::New(env, kErrorInvalidCipherSuiteIndex);
+      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) {
-    throw Napi::TypeError::New(env, kErrorFailedToSetCipherSuites);
+    Napi::TypeError::New(env, kErrorFailedToSetCipherSuites).ThrowAsJavaScriptException();
   }
 }
 
@@ -215,12 +215,7 @@ Napi::Value LibEDHOC::ComposeMessage(const Napi::CallbackInfo& info, enum edhoc_
   Napi::HandleScope scope(env);
 
   if (info[0].IsArray()) {
-    try {
-      userContext->GetEadManager()->StoreEad(messageNumber, info[0].As<Napi::Array>());
-    } catch (const Napi::Error& e) {
-      e.ThrowAsJavaScriptException();
-      return env.Null();
-    }
+    userContext->GetEadManager()->StoreEad(messageNumber, info[0].As<Napi::Array>());
   }
 
   userContext->GetCredentialManager()->SetupAsyncFunctions();
@@ -230,6 +225,9 @@ Napi::Value LibEDHOC::ComposeMessage(const Napi::CallbackInfo& info, enum edhoc_
     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);
@@ -256,6 +254,9 @@ Napi::Value LibEDHOC::ProcessMessage(const Napi::CallbackInfo& info, enum edhoc_
     userContext->GetEadManager()->ClearEadByMessage(messageNumber);
     userContext->GetCredentialManager()->CleanupAsyncFunctions();
     userContext->GetCryptoManager()->CleanupAsyncFunctions();
+    if (!userContext->error.IsEmpty()) {
+      userContext->error.ThrowAsJavaScriptException();
+    }
     return EADs;
   };
 
@@ -307,6 +308,9 @@ Napi::Value LibEDHOC::ExportOSCORE(const Napi::CallbackInfo& info) {
   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);
@@ -338,6 +342,9 @@ Napi::Value LibEDHOC::ExportKey(const Napi::CallbackInfo& info) {
   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);
@@ -364,6 +371,9 @@ Napi::Value LibEDHOC::KeyUpdate(const Napi::CallbackInfo& info) {
   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);

package/src/Utils.cpp

@@ -6,7 +6,6 @@
 #include <thread>
 
 static constexpr const char* kStringThen = "then";
-static constexpr const char* kStringCatch = "catch";
 static constexpr const char* kErrorInputValueMustBeANumberOrABuffer = "Input value must be a number or a buffer";
 
 void Utils::InvokeJSFunctionWithPromiseHandling(Napi::Env env,
@@ -17,21 +16,18 @@ void Utils::InvokeJSFunctionWithPromiseHandling(Napi::Env env,
                                                 ErrorHandler errorLambda) {
   auto deferred = Napi::Promise::Deferred::New(env);
 
-  try {
-    Napi::Value result = jsCallback.Call(jsObject, args);
+  Napi::Value result = jsCallback.Call(jsObject, args);
+
+  if (env.IsExceptionPending()) {
+    deferred.Reject(env.GetAndClearPendingException().Value());
+  } else {
     deferred.Resolve(result);
-  } catch (const Napi::Error& e) {
-    deferred.Reject(e.Value());
   }
 
   auto thenCallback = Napi::Function::New(env, [successLambda, errorLambda](const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
     Napi::HandleScope scope(env);
-    try {
-      successLambda(env, info[0].As<Napi::Value>());
-    } catch (const std::exception& e) {
-      errorLambda(env, Napi::Error::New(env, e.what()));
-    }
+    successLambda(env, info[0].As<Napi::Value>());
   });
 
   auto catchCallback = Napi::Function::New(env, [errorLambda](const Napi::CallbackInfo& info) {
@@ -41,8 +37,7 @@ void Utils::InvokeJSFunctionWithPromiseHandling(Napi::Env env,
   });
 
   Napi::Promise promise = deferred.Promise();
-  promise.Get(kStringCatch).As<Napi::Function>().Call(promise, {catchCallback});
-  promise.Get(kStringThen).As<Napi::Function>().Call(promise, {thenCallback});
+  promise.Get(kStringThen).As<Napi::Function>().Call(promise, {thenCallback, catchCallback});
 }
 
 void Utils::EncodeInt64ToBuffer(int64_t value, uint8_t* buffer, size_t* length) {
@@ -76,7 +71,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 {
-    throw Napi::TypeError::New(value.Env(), kErrorInputValueMustBeANumberOrABuffer);
+    Napi::TypeError::New(value.Env(), kErrorInputValueMustBeANumberOrABuffer).ThrowAsJavaScriptException();
   }
   return cid;
 }

package/test/errors.test.ts

@@ -0,0 +1,129 @@
+import { EDHOC, X509CertificateCredentialManager, DefaultEdhocCryptoManager, EdhocMethod, EdhocSuite } from '../dist/index'
+
+describe('EDHOC Handshake', () => {
+    
+    const trustedCA = Buffer.from('308201323081DAA003020102021478408C6EC18A1D452DAE70C726CB0192A6116DBB300A06082A8648CE3D040302301A3118301606035504030C0F5468697320697320434120526F6F74301E170D3234313031393138333635335A170D3235313031393138333635335A301A3118301606035504030C0F5468697320697320434120526F6F743059301306072A8648CE3D020106082A8648CE3D03010703420004B9348A8A267EF52CFDC30109A29008A2D99F6B8F78BA9EAF5D51578C06134E78CB90A073EDC2488A14174B4E2997C840C5DE7F8E35EB54A0DB6977E894D1B2CB300A06082A8648CE3D040302034700304402203B92BFEC770B0FA4E17F8F02A13CD945D914ED8123AC85C37C8C7BAA2BE3E0F102202CB2DC2EC295B5F4B7BB631ED751179C145D6B6E081559AEA38CE215369E9C31', 'hex');
+    
+    let initiator: EDHOC;
+    let responder: EDHOC;
+    let uncaughtException: jest.Mock;
+    let initiatorCryptoManager: DefaultEdhocCryptoManager;
+    let responderCryptoManager: DefaultEdhocCryptoManager;
+
+    let initiatorCredentialManager: X509CertificateCredentialManager;
+    let responderCredentialManager: X509CertificateCredentialManager;
+
+    const testError = new Error('Test error');
+    
+    beforeEach(() => {
+        const initiatorKeyID = Buffer.from('00000001', 'hex');
+        initiatorCredentialManager = new X509CertificateCredentialManager(
+            [Buffer.from('3082012E3081D4A003020102021453423D5145C767CDC29895C3DB590192A611EA50300A06082A8648CE3D040302301A3118301606035504030C0F5468697320697320434120526F6F74301E170D3234313031393138333732345A170D3235313031393138333732345A30143112301006035504030C09696E69746961746F723059301306072A8648CE3D020106082A8648CE3D03010703420004EB0EF585F3992A1653CF310BF0F0F8035267CDAB6989C8B02E7228FBD759EF6B56263259AADF087F9849E7B7651F74C3B4F144CCCF86BB6FE2FF0EF3AA5FB5DC300A06082A8648CE3D0403020349003046022100D8C3AA7C98A730B3D4862EDAB4C1474FCD9A17A9CA3FB078914A10978FE95CC40221009F5877DD4E2C635A04ED1F6F1854C87B58521BDDFF533B1076F53D456739764C', 'hex')],
+            initiatorKeyID
+        );
+        initiatorCredentialManager.addTrustedCA(trustedCA);
+
+        initiatorCryptoManager = new DefaultEdhocCryptoManager();
+        initiatorCryptoManager.addKey(initiatorKeyID, Buffer.from('DC1FBB05B6B08360CE5B9EEA08EBFBFC6766A21340641863D4C8A3F68F096337', 'hex'));
+
+        const responderKeyID = Buffer.from('00000002', 'hex');
+        responderCredentialManager = new X509CertificateCredentialManager(
+            [Buffer.from('3082012E3081D4A00302010202146648869E2608FC2E16D945C10E1F0192A6125CC0300A06082A8648CE3D040302301A3118301606035504030C0F5468697320697320434120526F6F74301E170D3234313031393138333735345A170D3235313031393138333735345A30143112301006035504030C09726573706F6E6465723059301306072A8648CE3D020106082A8648CE3D03010703420004161F76A7A106C9B79B7F651156B5B095E63A6101A39020F4E86DDACE61FB395E8AEF6CD9C444EE9A43DBD62DAD44FF50FE4146247D3AFD28F60DBC01FBFC573C300A06082A8648CE3D0403020349003046022100E8AD0926518CDB61E84D171700C7158FD0E72D03A117D40133ECD10F8B9F42CE022100E7E69B4C79100B3F0792F010AE11EE5DD2859C29EFC4DBCEFD41FA5CD4D3C3C9', 'hex')],
+            responderKeyID
+        );
+        responderCredentialManager.addTrustedCA(trustedCA);
+
+        responderCryptoManager = new DefaultEdhocCryptoManager();
+        responderCryptoManager.addKey(responderKeyID, Buffer.from('EE6287116FE27CDC539629DC87E12BF8EAA2229E7773AA67BC4C0FBA96E7FBB2', 'hex'));
+        
+        initiator = new EDHOC(10, [EdhocMethod.Method1], [EdhocSuite.Suite2], initiatorCredentialManager, initiatorCryptoManager);
+        responder = new EDHOC(20, [EdhocMethod.Method2, EdhocMethod.Method0, EdhocMethod.Method1], [EdhocSuite.Suite2], responderCredentialManager, responderCryptoManager);
+    });
+
+    beforeEach(() => {
+        uncaughtException = jest.fn();
+        process.on('uncaughtException', err => uncaughtException(err))
+    });
+
+    afterEach(() => {
+        process.removeAllListeners('uncaughtException');
+    });
+
+    test('should throw uncaughtException', async () => {
+        const error = new Error('Test error');
+        process.emit('uncaughtException', error);
+        expect(uncaughtException).toHaveBeenCalledWith(error);
+    });
+
+    test('should throw from crypto manager hash', async () => {
+
+        responderCryptoManager.hash = jest.fn().mockImplementation(() => { throw testError });
+        
+        try {
+            
+            const message1 = await initiator.composeMessage1([{ label: 1, value: Buffer.from('Hello') }]);
+            await responder.processMessage1(message1);
+
+        } catch (error) {
+            expect(error).toBe(testError);
+        }
+
+        expect(uncaughtException).not.toHaveBeenCalled();
+    });
+
+    test('should throw from credential manager fetch', async () => {
+        
+        responderCredentialManager.fetch = jest.fn().mockImplementation(() => { throw testError });
+        const catchHandler = jest.fn();
+
+        try {
+            const message1 = await initiator.composeMessage1();
+            await responder.processMessage1(message1);
+            await responder.composeMessage2();
+        } catch (error) {
+            catchHandler(error);
+        }
+
+        expect(catchHandler).toHaveBeenCalledWith(testError);
+        expect(uncaughtException).not.toHaveBeenCalled();
+    });
+
+    test('should throw from crypto manager importKey', async () => {
+        
+        initiatorCryptoManager.importKey = jest.fn().mockImplementation(() => { throw testError });
+        const catchHandler = jest.fn();
+
+        try {
+            const message1 = await initiator.composeMessage1([{ label: 1, value: Buffer.from('Hello') }]);
+            await responder.processMessage1(message1);
+            await responder.composeMessage2();
+        } catch (error) {
+            catchHandler(error);
+        }
+
+        expect(catchHandler).toHaveBeenCalled();
+        expect(uncaughtException).not.toHaveBeenCalled();
+    });
+
+    test('should throw from crypto manager encrypt', async () => {
+        
+        initiatorCryptoManager.encrypt = jest.fn().mockImplementation(() => { throw testError });
+        const catchHandler = jest.fn();
+
+        try {
+            const message1 = await initiator.composeMessage1([{ label: 1, value: Buffer.from('Hello') }]);
+            await responder.processMessage1(message1);
+            
+            const message2 = await responder.composeMessage2();
+            await initiator.processMessage2(message2);
+            
+            const message3 = await initiator.composeMessage3();
+            await responder.processMessage3(message3);
+        } catch (error) {
+            catchHandler(error);
+        }
+
+        expect(catchHandler).toHaveBeenCalled();
+        expect(uncaughtException).not.toHaveBeenCalled();
+    });
+});