edhoc 1.0.5 → 1.1.1

package/src/EdhocEadManager.cpp

@@ -1,14 +1,14 @@
+#include "EdhocEadManager.h"
+
 #include <exception>
 #include <future>
 #include <iostream>
 #include <stdexcept>
 
-#include "EdhocEadManager.h"
 #include "UserContext.h"
 #include "Utils.h"
 
-static constexpr const char* kErrorExpectedObject =
-    "Expected an object as element in the input array";
+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";
@@ -24,17 +24,14 @@ EdhocEadManager::~EdhocEadManager() {
   eadBuffers.clear();
 }
 
-void EdhocEadManager::StoreEad(enum edhoc_message message,
-                               int label,
-                               const std::vector<uint8_t>& ead) {
+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) {
+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);
@@ -53,20 +50,17 @@ void EdhocEadManager::StoreEad(enum edhoc_message message,
     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());
+    std::vector<uint8_t> eadVector(buffer.Data(), buffer.Data() + buffer.Length());
     StoreEad(message, label, eadVector);
   }
 }
 
-const EadMapVector* EdhocEadManager::GetEadByMessage(
-    enum edhoc_message message) const {
+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 {
+Napi::Array EdhocEadManager::GetEadByMessage(Napi::Env& env, enum edhoc_message message) const {
   const EadMapVector* buffers = GetEadByMessage(message);
   if (!buffers) {
     return Napi::Array::New(env);
@@ -78,8 +72,7 @@ Napi::Array EdhocEadManager::GetEadByMessage(Napi::Env& env,
     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()));
+      obj.Set(kPropValue, Napi::Buffer<uint8_t>::Copy(env, buffer.data(), buffer.size()));
     }
     result.Set(i++, obj);
   }
@@ -98,8 +91,7 @@ int EdhocEadManager::ComposeEad(void* user_context,
                                 size_t* ead_token_len) {
   UserContext* context = static_cast<UserContext*>(user_context);
   EdhocEadManager* manager = context->GetEadManager();
-  return manager->callComposeEad(
-      message, ead_token, ead_token_size, ead_token_len);
+  return manager->callComposeEad(message, ead_token, ead_token_size, ead_token_len);
 }
 
 int EdhocEadManager::ProcessEad(void* user_context,

package/src/EdhocExportOscoreAsyncWorker.cpp

@@ -0,0 +1,77 @@
+#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(Napi::Env& env,
+                                                           struct edhoc_context& context,
+                                                           CallbackType callback)
+    : Napi::AsyncWorker(env),
+      deferred(Napi::Promise::Deferred::New(env)),
+      context(context),
+      masterSecret(kMasterSecrectSize),
+      masterSalt(kMasterSaltSize),
+      senderId(kConnectionIdSize),
+      recipientId(kConnectionIdSize),
+      callback(std::move(callback)) {}
+
+EdhocExportOscoreAsyncWorker::~EdhocExportOscoreAsyncWorker() {}
+
+void EdhocExportOscoreAsyncWorker::Execute() {
+  try {
+    size_t sender_id_length, recipient_id_length;
+
+    int ret = edhoc_export_oscore_session(&context, 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);
+
+  deferred.Resolve(resultObj);
+  callback(env);
+}
+
+void EdhocExportOscoreAsyncWorker::OnError(const Napi::Error& error) {
+  Napi::Env env = Env();
+  Napi::HandleScope scope(env);
+  deferred.Reject(error.Value());
+  callback(env);
+}
+
+Napi::Promise EdhocExportOscoreAsyncWorker::GetPromise() {
+  return deferred.Promise();
+}

package/src/EdhocKeyExporterAsyncWorker.cpp

@@ -0,0 +1,49 @@
+#include "EdhocKeyExporterAsyncWorker.h"
+
+static constexpr const char* kErrorMessageFormat = "Failed to export the key. Error code: %d.";
+static constexpr size_t kErrorBufferSize = 100;
+
+EdhocKeyExporterAsyncWorker::EdhocKeyExporterAsyncWorker(Napi::Env& env,
+                                                         struct edhoc_context& context,
+                                                         uint16_t label,
+                                                         uint8_t desiredLength,
+                                                         CallbackType callback)
+    : Napi::AsyncWorker(env),
+      deferred(Napi::Promise::Deferred::New(env)),
+      context(context),
+      label(label),
+      desiredLength(desiredLength),
+      output(desiredLength),
+      callback(std::move(callback)) {}
+
+void EdhocKeyExporterAsyncWorker::Execute() {
+  try {
+    int ret = edhoc_export_prk_exporter(&context, 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());
+  deferred.Resolve(outputBuffer);
+  callback(env);
+}
+
+void EdhocKeyExporterAsyncWorker::OnError(const Napi::Error& error) {
+  Napi::Env env = Env();
+  Napi::HandleScope scope(env);
+  deferred.Reject(error.Value());
+  callback(env);
+}
+
+Napi::Promise EdhocKeyExporterAsyncWorker::GetPromise() {
+  return deferred.Promise();
+}

package/src/EdhocKeyUpdateAsyncWorker.cpp

@@ -0,0 +1,41 @@
+#include "EdhocKeyUpdateAsyncWorker.h"
+
+EdhocKeyUpdateAsyncWorker::EdhocKeyUpdateAsyncWorker(Napi::Env& env,
+                                                     struct edhoc_context& context,
+                                                     std::vector<uint8_t> contextBuffer,
+                                                     CallbackType callback)
+    : Napi::AsyncWorker(env),
+      deferred(Napi::Promise::Deferred::New(env)),
+      context(context),
+      contextBuffer(contextBuffer),
+      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());
+  }
+}
+
+void EdhocKeyUpdateAsyncWorker::OnOK() {
+  Napi::Env env = Env();
+  Napi::HandleScope scope(env);
+  deferred.Resolve(env.Undefined());
+  callback(env);
+}
+
+void EdhocKeyUpdateAsyncWorker::OnError(const Napi::Error& error) {
+  Napi::Env env = Env();
+  Napi::HandleScope scope(env);
+  deferred.Reject(error.Value());
+  callback(env);
+}
+
+Napi::Promise EdhocKeyUpdateAsyncWorker::GetPromise() {
+  return deferred.Promise();
+}

package/src/EdhocProcessAsyncWorker.cpp

@@ -1,24 +1,23 @@
 #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* 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(
-    Napi::Env& env,
-    Napi::Promise::Deferred deferred,
-    struct edhoc_context& context,
-    int messageNumber,
-    Napi::Buffer<uint8_t> buffer,
-    CallbackType callback)
+EdhocProcessAsyncWorker::EdhocProcessAsyncWorker(Napi::Env& env,
+                                                 struct edhoc_context& context,
+                                                 int messageNumber,
+                                                 Napi::Buffer<uint8_t> buffer,
+                                                 CallbackType callback)
     : Napi::AsyncWorker(env),
-      deferred(deferred),
+      deferred(Napi::Promise::Deferred::New(env)),
       context(context),
       messageNumber(messageNumber),
       messageBuffer(buffer.Data(), buffer.Data() + buffer.Length()),
-      callback(std::move(callback)) {}
+      callback(std::move(callback)),
+      peerCipherSuites() {}
 
 void EdhocProcessAsyncWorker::Execute() {
   try {
@@ -45,12 +44,52 @@ void EdhocProcessAsyncWorker::Execute() {
     }
 
     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 += ", ";
+              }
+            }
+            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,
-                    ret);
+      std::snprintf(errorMessage, kErrorBufferSize, kErrorMessageFormat, messageNumber + 1, error_code);
       SetError(errorMessage);
     }
 
@@ -64,11 +103,25 @@ void EdhocProcessAsyncWorker::OnOK() {
   Napi::HandleScope scope(env);
   Napi::Array result = callback(env);
   deferred.Resolve(result);
+  callback(env);
 }
 
 void EdhocProcessAsyncWorker::OnError(const Napi::Error& error) {
   Napi::Env env = Env();
   Napi::HandleScope scope(env);
-  deferred.Reject(Napi::String::New(env, error.Message()));
+
+  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);
+  }
+
+  deferred.Reject(error.Value());
   callback(env);
 }
+
+Napi::Promise EdhocProcessAsyncWorker::GetPromise() {
+  return deferred.Promise();
+}