edhoc 1.3.3 → 2.0.0

package/src/EdhocCredentialManager.cpp

@@ -1,314 +0,0 @@
-#include "EdhocCredentialManager.h"
-
-#include <exception>
-#include <future>
-#include <iostream>
-#include <stdexcept>
-
-#include "RunningContext.h"
-#include "Utils.h"
-
-static constexpr const char* kFormat = "format";
-static constexpr const char* kPrivateKeyId = "privateKeyID";
-static constexpr const char* kPublicKey = "publicKey";
-static constexpr const char* kKid = "kid";
-static constexpr const char* kIsCBOR = "isCBOR";
-static constexpr const char* kCredentials = "credentials";
-static constexpr const char* kX5chain = "x5chain";
-static constexpr const char* kCertificate = "certificate";
-static constexpr const char* kCertificates = "certificates";
-static constexpr const char* kX5t = "x5t";
-static constexpr const char* kHash = "hash";
-static constexpr const char* kHashAlgorithm = "hashAlgorithm";
-static constexpr const char* kUnsupportedCredentialTypeError = "Unsupported credential type specified";
-static constexpr const char* kInvalidInputCredentialTypeError = "Invalid credentials object specified";
-static constexpr const char* kInvalidInputDataErrorKid = "Invalid input data for Key ID";
-static constexpr const char* kInvalidInputDataErrorX509Chain = "Invalid input data for X.509 chain";
-static constexpr const char* kInvalidInputDataErrorX509Hash = "Invalid input data for X.509 hash";
-static constexpr const char* kErrorObjectExpected = "Object expected";
-
-/*
- * Convert a JavaScript object to an edhoc_auth_cred_key_id
- */
-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);
-  }
-
-  credentials->label = EDHOC_COSE_HEADER_KID;
-
-  if (kidObj.Get(kKid).IsNumber()) {
-    int64_t numeric = kidObj.Get(kKid).As<Napi::Number>().Int64Value();
-    if (numeric >= ONE_BYTE_CBOR_INT_MIN_VALUE && numeric <= ONE_BYTE_CBOR_INT_MAX_VALUE) {
-      credentials->key_id.encode_type = EDHOC_ENCODE_TYPE_INTEGER;
-      credentials->key_id.key_id_int = (int32_t)numeric;
-    } else {
-      size_t length = 0;
-      Utils::EncodeInt64ToBuffer(numeric, credentials->key_id.key_id_bstr, &length);
-      credentials->key_id.encode_type = EDHOC_ENCODE_TYPE_BYTE_STRING;
-      credentials->key_id.key_id_bstr_length = length;
-    }
-  } else if (kidObj.Get(kKid).IsBuffer()) {
-    Napi::Buffer<uint8_t> buffer = kidObj.Get(kKid).As<Napi::Buffer<uint8_t>>();
-    credentials->key_id.encode_type = EDHOC_ENCODE_TYPE_BYTE_STRING;
-    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::Buffer<uint8_t> credBuffer = kidObj.Get(kCredentials).As<Napi::Buffer<uint8_t>>();
-  credentials->key_id.cred = credBuffer.Data();
-  credentials->key_id.cred_len = credBuffer.Length();
-  credentials->key_id.cred_is_cbor = kidObj.Get(kIsCBOR).As<Napi::Boolean>().Value();
-}
-
-/*
- * Convert a JavaScript object to an edhoc_auth_cred_x509_chain
- */
-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);
-  }
-
-  credentials->label = EDHOC_COSE_HEADER_X509_CHAIN;
-
-  Napi::Array certArray = x5chainObj.Get(kCertificates).As<Napi::Array>();
-  size_t nr_of_certs = certArray.Length();
-  credentials->x509_chain.nr_of_certs = nr_of_certs;
-
-  for (size_t i = 0; i < nr_of_certs; ++i) {
-    Napi::Buffer<uint8_t> certBuffer = certArray.Get(i).As<Napi::Buffer<uint8_t>>();
-    credentials->x509_chain.cert[i] = certBuffer.Data();
-    credentials->x509_chain.cert_len[i] = certBuffer.Length();
-  }
-}
-
-/*
- * Convert a JavaScript object to an edhoc_auth_cred_x509_hash
- */
-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);
-  }
-
-  credentials->label = EDHOC_COSE_HEADER_X509_HASH;
-
-  Napi::Buffer<uint8_t> certBuffer = x5tObj.Get(kCertificate).As<Napi::Buffer<uint8_t>>();
-  credentials->x509_hash.cert = certBuffer.Data();
-  credentials->x509_hash.cert_len = certBuffer.Length();
-
-  Napi::Buffer<uint8_t> hashBuffer = x5tObj.Get(kHash).As<Napi::Buffer<uint8_t>>();
-  credentials->x509_hash.cert_fp = hashBuffer.Data();
-  credentials->x509_hash.cert_fp_len = hashBuffer.Length();
-
-  credentials->x509_hash.encode_type = EDHOC_ENCODE_TYPE_INTEGER;
-  credentials->x509_hash.alg_int = x5tObj.Get(kHashAlgorithm).As<Napi::Number>().Int32Value();
-}
-
-/*
- * Convert an edhoc_auth_cred_key_id to a JavaScript object
- */
-Napi::Object convert_edhoc_kid_to_js(const Napi::Env& env, const struct edhoc_auth_cred_key_id& kid) {
-  Napi::Object obj = Napi::Object::New(env);
-  obj.Set(kIsCBOR, Napi::Boolean::New(env, kid.cred_is_cbor));
-
-  if (kid.encode_type == EDHOC_ENCODE_TYPE_INTEGER) {
-    obj.Set(kKid, Napi::Number::New(env, kid.key_id_int));
-  } else {
-    obj.Set(kKid, Napi::Buffer<uint8_t>::Copy(env, kid.key_id_bstr, kid.key_id_bstr_length));
-  }
-
-  obj.Set(kCredentials, Napi::Buffer<uint8_t>::Copy(env, kid.cred, kid.cred_len));
-  return obj;
-}
-
-/*
- * Convert an edhoc_auth_cred_x509_chain to a JavaScript object
- */
-Napi::Object convert_edhoc_x5chain_to_js(const Napi::Env& env, const struct edhoc_auth_cred_x509_chain& x509_chain) {
-  Napi::Object obj = Napi::Object::New(env);
-  Napi::Array certArray = Napi::Array::New(env, x509_chain.nr_of_certs);
-
-  for (size_t i = 0; i < x509_chain.nr_of_certs; ++i) {
-    certArray.Set(i, Napi::Buffer<uint8_t>::Copy(env, x509_chain.cert[i], x509_chain.cert_len[i]));
-  }
-
-  obj.Set(kCertificates, certArray);
-  return obj;
-}
-
-/*
- * Convert an edhoc_auth_cred_x509_hash to a JavaScript object
- */
-Napi::Object convert_edhoc_x5t_to_js(const Napi::Env& env, const struct edhoc_auth_cred_x509_hash& x509_hash) {
-  Napi::Object obj = Napi::Object::New(env);
-  obj.Set(kCertificate, Napi::Buffer<uint8_t>::Copy(env, x509_hash.cert, x509_hash.cert_len));
-  obj.Set(kHash, Napi::Buffer<uint8_t>::Copy(env, x509_hash.cert_fp, x509_hash.cert_fp_len));
-  obj.Set(kHashAlgorithm, Napi::Number::New(env, x509_hash.alg_int));
-  return obj;
-}
-
-/*
- * EdhocCredentialManager constructor
- */
-EdhocCredentialManager::EdhocCredentialManager(Napi::Object& jsCredentialManager, Napi::Object& jsEdhoc) {
-  if (!jsCredentialManager.IsObject() || !jsEdhoc.IsObject()) {
-    Napi::Error::New(jsCredentialManager.Env(), kErrorObjectExpected).ThrowAsJavaScriptException();
-  }
-  credentialManagerRef_ = Napi::Persistent(jsCredentialManager);
-  edhocRef_ = Napi::Weak(jsEdhoc);
-
-  credentials.fetch = FetchCredentials;
-  credentials.verify = VerifyCredentials;
-}
-
-/*
- * EdhocCredentialManager destructor
- */
-EdhocCredentialManager::~EdhocCredentialManager() {
-  credentialManagerRef_.Reset();
-  edhocRef_.Reset();
-  for (auto& ref : credentialReferences_) {
-    ref.Reset();
-  }
-  credentialReferences_.clear();
-}
-
-/*
- * Static method to fetch credentials
- */
-int EdhocCredentialManager::FetchCredentials(void* user_context, struct edhoc_auth_creds* credentials) {
-  RunningContext* context = static_cast<RunningContext*>(const_cast<void*>(user_context));
-  EdhocCredentialManager* manager = context->GetCredentialManager();
-  return manager->callFetchCredentials(context, credentials);
-}
-
-/*
- * Static method to verify credentials
- */
-int EdhocCredentialManager::VerifyCredentials(void* user_context,
-                                              struct edhoc_auth_creds* credentials,
-                                              const uint8_t** public_key_reference,
-                                              size_t* public_key_length) {
-  RunningContext* context = static_cast<RunningContext*>(const_cast<void*>(user_context));
-  EdhocCredentialManager* manager = context->GetCredentialManager();
-  return manager->callVerifyCredentials(context, credentials, public_key_reference, public_key_length);
-}
-
-/*
- * Method to fetch credentials
- */
-int EdhocCredentialManager::callFetchCredentials(RunningContext* runningContext, struct edhoc_auth_creds* credentials) {
-
-  auto successHandler = [this, &credentials](Napi::Env env, Napi::Value result) {
-    Napi::HandleScope scope(env);
-    auto credsObj = result.As<Napi::Object>();
-
-    if (credsObj.IsObject() == false || credsObj.Has(kFormat) == false) {
-      throw std::runtime_error(kInvalidInputCredentialTypeError);
-    }
-
-    credentialReferences_.push_back(Napi::Persistent(credsObj));
-
-    int label = credsObj.Get(kFormat).As<Napi::Number>().Int32Value();
-
-    switch (label) {
-      case EDHOC_COSE_HEADER_KID:
-        convert_js_to_edhoc_kid(credsObj, credentials);
-        break;
-      case EDHOC_COSE_HEADER_X509_CHAIN:
-        convert_js_to_edhoc_x5chain(credsObj, credentials);
-        break;
-      case EDHOC_COSE_HEADER_X509_HASH:
-        convert_js_to_edhoc_x5t(credsObj, credentials);
-        break;
-      case EDHOC_COSE_ANY:
-      default:
-        throw Napi::Error::New(env, kUnsupportedCredentialTypeError);
-    }
-
-    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());
-    }
-
-    return EDHOC_SUCCESS;
-  };
-
-  auto argumentsHandler = [this](Napi::Env env) {
-    return std::vector<napi_value> { this->edhocRef_.Value() };
-  };
-
-  return runningContext->ThreadSafeBlockingCall(credentialManagerRef_, "fetch", argumentsHandler, successHandler);
-}
-
-/*
- * Method to verify credentials
- */
-int EdhocCredentialManager::callVerifyCredentials(RunningContext* runningContext,
-                                                  struct edhoc_auth_creds* credentials,
-                                                  const uint8_t** public_key_reference,
-                                                  size_t* public_key_length) {
-
-  auto successHandler = [this, &credentials, &public_key_reference, &public_key_length](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);
-    }
-
-    int label = credsObj.Get(kFormat).As<Napi::Number>().Int32Value();
-    switch (label) {
-      case EDHOC_COSE_HEADER_KID:
-        convert_js_to_edhoc_kid(credsObj, credentials);
-        break;
-      case EDHOC_COSE_HEADER_X509_CHAIN:
-        convert_js_to_edhoc_x5chain(credsObj, credentials);
-        break;
-      case EDHOC_COSE_HEADER_X509_HASH:
-        convert_js_to_edhoc_x5t(credsObj, credentials);
-        break;
-      default:
-        throw std::runtime_error(kUnsupportedCredentialTypeError);
-    }
-
-    if (credsObj.Has(kPublicKey) && !credsObj.Get(kPublicKey).IsNull()) {
-      Napi::Buffer<uint8_t> publicKeyBuffer = credsObj.Get(kPublicKey).As<Napi::Buffer<uint8_t>>();
-      *public_key_reference = publicKeyBuffer.Data();
-      *public_key_length = publicKeyBuffer.Length();
-    }
-
-    return EDHOC_SUCCESS;
-  };
-
-  auto argumentsHandler = [this, &credentials](Napi::Env env) {
-    Napi::Object resultObject = Napi::Object::New(env);
-    resultObject.Set(kFormat, Napi::Number::New(env, credentials->label));
-
-    switch (credentials->label) {
-      case EDHOC_COSE_HEADER_KID:
-        resultObject.Set(kKid, convert_edhoc_kid_to_js(env, credentials->key_id));
-        break;
-      case EDHOC_COSE_HEADER_X509_CHAIN:
-        resultObject.Set(kX5chain, convert_edhoc_x5chain_to_js(env, credentials->x509_chain));
-        break;
-      case EDHOC_COSE_HEADER_X509_HASH:
-        resultObject.Set(kX5t, convert_edhoc_x5t_to_js(env, credentials->x509_hash));
-        break;
-      default:
-        throw std::runtime_error(kUnsupportedCredentialTypeError);
-    }
-    return std::vector<napi_value> { 
-      this->edhocRef_.Value(), 
-      resultObject
-    };
-  };
-
-  return runningContext->ThreadSafeBlockingCall(credentialManagerRef_, "verify", argumentsHandler, successHandler);
-}