asherah 1.3.23 → 1.3.25

package/.asherah-version

@@ -1 +1 @@
-ASHERAH_VERSION=v0.4.26
+ASHERAH_VERSION=v0.4.27

package/binding.gyp

@@ -19,6 +19,7 @@
       'defines': [ 'NAPI_CPP_EXCEPTIONS', 'NODE_API_SWALLOW_UNTHROWABLE_EXCEPTIONS', 'NODE_ADDON_API_DISABLE_DEPRECATED', 'NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED' ],
       'sources': [
         'lib/libasherah.h',
+        'src/asherah.h',
         'src/asherah.cc',
         'src/logging.cc',
         'src/logging.h',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "asherah",
-  "version": "1.3.23",
+  "version": "1.3.25",
   "description": "Asherah envelope encryption and key rotation library",
   "exports": {
     "node-addons": "./dist/asherah.node"
@@ -22,6 +22,7 @@
   "license": "MIT",
   "files": [
     "binding.gyp",
+    "src/asherah.h",
     "src/asherah.cc",
     "src/hints.h",
     "src/logging.h",

package/src/asherah.cc

@@ -1,3 +1,4 @@
+#include "asherah.h"
 #include "../lib/libasherah.h"
 #include "cobhan_napi_interop.h"
 #include "hints.h"
@@ -6,40 +7,539 @@
 #include <mutex>
 #include <napi.h>
 
-size_t est_intermediate_key_overhead;
-size_t maximum_stack_alloc_size = 2048;
-
-int32_t setup_state = 0;
-std::mutex asherah_lock;
-
-__attribute__((always_inline)) inline size_t
-estimate_asherah_output_size_bytes(size_t data_byte_len,
-                                   size_t partition_byte_len) {
-  const size_t est_encryption_overhead = 48;
-  const size_t est_envelope_overhead = 185;
-  const double base64_overhead = 1.34;
-
-  // Add one rather than using std::ceil to round up
-  double est_data_byte_len =
-      (double(data_byte_len + est_encryption_overhead) * base64_overhead) + 1;
-
-  size_t asherah_output_size_bytes =
-      size_t(est_envelope_overhead + est_intermediate_key_overhead +
-             partition_byte_len + est_data_byte_len);
-  if (unlikely(verbose_flag)) {
-    std::string log_msg =
-        "estimate_asherah_output_size(" + std::to_string(data_byte_len) + ", " +
-        std::to_string(partition_byte_len) +
-        ") est_data_byte_len: " + std::to_string(est_data_byte_len) +
-        " asherah_output_size_bytes: " +
-        std::to_string(asherah_output_size_bytes);
-    debug_log(__func__, log_msg);
+class Asherah : public Napi::Addon<Asherah> {
+public:
+  Asherah(Napi::Env env, Napi::Object exports) {
+    DefineAddon(exports,
+                {InstanceMethod("setup", &Asherah::SetupAsherah),
+                 InstanceMethod("encrypt", &Asherah::Encrypt),
+                 InstanceMethod("encrypt_string", &Asherah::EncryptString),
+                 InstanceMethod("decrypt", &Asherah::Decrypt),
+                 InstanceMethod("decrypt_string", &Asherah::DecryptString),
+                 InstanceMethod("shutdown", &Asherah::ShutdownAsherah),
+                 InstanceMethod("set_max_stack_alloc_item_size",
+                                &Asherah::SetMaxStackAllocItemSize),
+                 InstanceMethod("set_safety_padding_overhead",
+                                &Asherah::SetSafetyPaddingOverhead)});
+  }
+
+private:
+  size_t est_intermediate_key_overhead;
+  size_t maximum_stack_alloc_size = 2048;
+
+  int32_t setup_state = 0;
+  std::mutex asherah_lock;
+
+  void SetupAsherah(const Napi::CallbackInfo &info) {
+    std::lock_guard<std::mutex> lock(asherah_lock);
+
+    if (unlikely(verbose_flag)) {
+      debug_log(__func__, "called");
+    }
+
+    if (unlikely(setup_state == 1)) {
+      log_error_and_throw(__func__, "setup called twice");
+    }
+
+    if (unlikely(info.Length() < 1)) {
+      log_error_and_throw(__func__, "Wrong number of arguments");
+    }
+
+    Napi::String config;
+    Napi::Object config_json;
+    Napi::Env env = info.Env();
+    Napi::Object json = env.Global().Get("JSON").As<Napi::Object>();
+    if (likely(info[0].IsObject())) {
+      config_json = info[0].As<Napi::Object>();
+      Napi::Function stringify = json.Get("stringify").As<Napi::Function>();
+      config = stringify.Call(json, {config_json}).As<Napi::String>();
+    } else if (likely(info[0].IsString())) {
+      config = info[0].As<Napi::String>();
+      Napi::Function parse = json.Get("parse").As<Napi::Function>();
+      config_json = parse.Call(json, {config}).As<Napi::Object>();
+    } else {
+      log_error_and_throw(__func__, "Wrong argument type");
+    }
+
+    Napi::String product_id = config_json.Get("ProductID").As<Napi::String>();
+    Napi::String service_name =
+        config_json.Get("ServiceName").As<Napi::String>();
+
+    est_intermediate_key_overhead =
+        product_id.Utf8Value().length() + service_name.Utf8Value().length();
+
+    Napi::Value verbose = config_json.Get("Verbose");
+    if (likely(verbose.IsBoolean())) {
+      verbose_flag = verbose.As<Napi::Boolean>().Value();
+      debug_log(__func__, "verbose_flag: " + std::to_string(verbose_flag));
+    } else {
+      verbose_flag = 0;
+      debug_log(__func__, "verbose_flag: defaulting to false");
+    }
+
+    char *config_cobhan_buffer;
+    size_t config_copied_bytes;
+    NAPI_STRING_TO_CBUFFER(env, config, config_cobhan_buffer,
+                           config_copied_bytes, maximum_stack_alloc_size,
+                           __func__);
+
+    char *config_canary_ptr = get_canary_ptr(config_cobhan_buffer);
+    if (unlikely(!check_canary_ptr(config_canary_ptr))) {
+      log_error_and_throw(
+          __func__, "Failed initial canary check for config_cobhan_buffer");
+    }
+
+    // extern GoInt32 SetupJson(void* configJson);
+    GoInt32 result = SetupJson(config_cobhan_buffer);
+
+    if (unlikely(verbose_flag)) {
+      debug_log(__func__, "Returned from asherah-cobhan SetupJson");
+    }
+
+    if (unlikely(!check_canary_ptr(config_canary_ptr))) {
+      log_error_and_throw(
+          __func__, "Failed post-call canary check for config_cobhan_buffer");
+    }
+
+    if (unlikely(result < 0)) {
+      log_error_and_throw(__func__, AsherahCobhanErrorToString(result));
+    }
+    setup_state = 1;
+  }
+
+  Napi::Value Encrypt(const Napi::CallbackInfo &info) {
+    std::lock_guard<std::mutex> lock(asherah_lock);
+
+    if (unlikely(verbose_flag)) {
+      debug_log(__func__, "called");
+    }
+
+    if (unlikely(setup_state == 0)) {
+      log_error_and_throw(__func__, "setup() not called");
+    }
+
+    if (unlikely(info.Length() < 2)) {
+      log_error_and_throw(__func__, "Wrong number of arguments");
+    }
+
+    if (unlikely(!info[0].IsString() || !info[1].IsBuffer())) {
+      log_error_and_throw(__func__, "Wrong argument types");
+    }
+
+    Napi::Env env = info.Env();
+
+    Napi::String partition_id = info[0].As<Napi::String>();
+    char *partition_id_cobhan_buffer;
+    size_t partition_id_copied_bytes;
+    NAPI_STRING_TO_CBUFFER(env, partition_id, partition_id_cobhan_buffer,
+                           partition_id_copied_bytes, maximum_stack_alloc_size,
+                           __func__);
+
+    Napi::Buffer<unsigned char> input_napi_buffer =
+        info[1].As<Napi::Buffer<unsigned char>>();
+    char *input_cobhan_buffer;
+    size_t input_copied_bytes;
+    NAPI_BUFFER_TO_CBUFFER(env, input_napi_buffer, input_cobhan_buffer,
+                           input_copied_bytes, maximum_stack_alloc_size,
+                           __func__);
+
+    Napi::String output = EncryptCobhanBufferToJson(
+        env, partition_id_copied_bytes, input_copied_bytes,
+        partition_id_cobhan_buffer, input_cobhan_buffer);
+
+    if (unlikely(verbose_flag)) {
+      debug_log(__func__, "finished");
+    }
+
+    return output;
+  }
+
+  Napi::Value EncryptString(const Napi::CallbackInfo &info) {
+    std::lock_guard<std::mutex> lock(asherah_lock);
+
+    if (unlikely(verbose_flag)) {
+      debug_log(__func__, "called");
+    }
+
+    if (unlikely(setup_state == 0)) {
+      log_error_and_throw(__func__, "setup() not called");
+    }
+
+    if (unlikely(info.Length() < 2)) {
+      log_error_and_throw(__func__, "Wrong number of arguments");
+    }
+
+    if (unlikely(!info[0].IsString() || !info[1].IsString())) {
+      log_error_and_throw(__func__, "Wrong argument types");
+    }
+
+    Napi::Env env = info.Env();
+
+    Napi::String partition_id = info[0].As<Napi::String>();
+    char *partition_id_cobhan_buffer;
+    size_t partition_id_copied_bytes;
+    NAPI_STRING_TO_CBUFFER(env, partition_id, partition_id_cobhan_buffer,
+                           partition_id_copied_bytes, maximum_stack_alloc_size,
+                           __func__);
+
+    Napi::String input = info[1].As<Napi::String>();
+    char *input_cobhan_buffer;
+    size_t input_copied_bytes;
+    NAPI_STRING_TO_CBUFFER(env, input, input_cobhan_buffer, input_copied_bytes,
+                           maximum_stack_alloc_size, __func__);
+
+    Napi::String output = EncryptCobhanBufferToJson(
+        env, partition_id_copied_bytes, input_copied_bytes,
+        partition_id_cobhan_buffer, input_cobhan_buffer);
+
+    if (unlikely(verbose_flag)) {
+      debug_log(__func__, "finished");
+    }
+
+    return output;
+  }
+
+  Napi::String EncryptCobhanBufferToJson(Napi::Env &env, size_t partition_bytes,
+                                         size_t data_bytes,
+                                         char *partition_id_cobhan_buffer,
+                                         char *input_cobhan_buffer) {
+
+    size_t asherah_output_size_bytes =
+        EstimateAsherahOutputSize(data_bytes, partition_bytes);
+
+    if (unlikely(verbose_flag)) {
+      debug_log(__func__, " asherah_output_size_bytes " +
+                              std::to_string(asherah_output_size_bytes));
+    }
+
+    char *output_cobhan_buffer;
+    ALLOCATE_CBUFFER(output_cobhan_buffer, asherah_output_size_bytes,
+                     maximum_stack_alloc_size, __func__);
+
+    char *partition_id_canary_ptr = get_canary_ptr(partition_id_cobhan_buffer);
+    if (unlikely(!check_canary_ptr(partition_id_canary_ptr))) {
+      log_error_and_throw(
+          __func__,
+          "Failed initial canary check for partition_id_cobhan_buffer");
+    }
+    char *input_canary_ptr = get_canary_ptr(input_cobhan_buffer);
+    if (unlikely(!check_canary_ptr(input_canary_ptr))) {
+      log_error_and_throw(
+          __func__, "Failed initial canary check for input_cobhan_buffer");
+    }
+    char *output_canary_ptr = get_canary_ptr(output_cobhan_buffer);
+    if (unlikely(!check_canary_ptr(output_canary_ptr))) {
+      log_error_and_throw(
+          __func__, "Failed initial canary check for output_cobhan_buffer");
+    }
+
+    if (unlikely(verbose_flag)) {
+      debug_log(__func__, "Calling asherah-cobhan EncryptToJson");
+    }
+
+    // extern GoInt32 EncryptToJson(void* partitionIdPtr, void* dataPtr, void*
+    // jsonPtr);
+    GoInt32 result = EncryptToJson(partition_id_cobhan_buffer,
+                                   input_cobhan_buffer, output_cobhan_buffer);
+
+    if (unlikely(verbose_flag)) {
+      debug_log(__func__, "Returning from asherah-cobhan EncryptToJson");
+    }
+
+    if (unlikely(!check_canary_ptr(partition_id_canary_ptr))) {
+      log_error_and_throw(
+          __func__,
+          "Failed post-call canary check for partition_id_cobhan_buffer");
+    }
+    if (unlikely(!check_canary_ptr(input_canary_ptr))) {
+      log_error_and_throw(
+          __func__, "Failed post-call canary check for input_cobhan_buffer");
+    }
+    if (unlikely(!check_canary_ptr(output_canary_ptr))) {
+      log_error_and_throw(
+          __func__, "Failed post-call canary check for output_cobhan_buffer");
+    }
+
+    if (unlikely(result < 0)) {
+      log_error_and_throw(__func__, AsherahCobhanErrorToString(result));
+    }
+
+    Napi::String output = cbuffer_to_nstring(env, output_cobhan_buffer);
+    return output;
+  }
+
+  Napi::Value Decrypt(const Napi::CallbackInfo &info) {
+    std::lock_guard<std::mutex> lock(asherah_lock);
+
+    if (unlikely(verbose_flag)) {
+      debug_log(__func__, "called");
+    }
+
+    if (unlikely(setup_state == 0)) {
+      log_error_and_throw(__func__, "setup() not called");
+    }
+
+    if (unlikely(info.Length() < 2)) {
+      log_error_and_throw(__func__, "Wrong number of arguments");
+    }
+
+    if (unlikely(!info[0].IsString() || !info[1].IsString())) {
+      log_error_and_throw(__func__, "Wrong argument types");
+    }
+
+    Napi::Env env = info.Env();
+
+    Napi::String partition_id = info[0].As<Napi::String>();
+    char *partition_id_cobhan_buffer;
+    size_t partition_id_copied_bytes;
+    NAPI_STRING_TO_CBUFFER(env, partition_id, partition_id_cobhan_buffer,
+                           partition_id_copied_bytes, maximum_stack_alloc_size,
+                           __func__);
+
+    Napi::String input = info[1].As<Napi::String>();
+    char *input_cobhan_buffer;
+    size_t input_copied_bytes;
+    NAPI_STRING_TO_CBUFFER(env, input, input_cobhan_buffer, input_copied_bytes,
+                           maximum_stack_alloc_size, __func__);
+
+    char *output_cobhan_buffer;
+    ALLOCATE_CBUFFER(output_cobhan_buffer, input_copied_bytes,
+                     maximum_stack_alloc_size, __func__);
+
+    char *partition_id_canary_ptr = get_canary_ptr(partition_id_cobhan_buffer);
+    if (unlikely(!check_canary_ptr(partition_id_canary_ptr))) {
+      log_error_and_throw(
+          __func__,
+          "Failed initial canary check for partition_id_cobhan_buffer");
+    }
+    char *input_canary_ptr = get_canary_ptr(input_cobhan_buffer);
+    if (unlikely(!check_canary_ptr(input_canary_ptr))) {
+      log_error_and_throw(
+          __func__, "Failed initial canary check for input_cobhan_buffer");
+    }
+    char *output_canary_ptr = get_canary_ptr(output_cobhan_buffer);
+    if (unlikely(!check_canary_ptr(output_canary_ptr))) {
+      log_error_and_throw(
+          __func__, "Failed initial canary check for output_cobhan_buffer");
+    }
+
+    if (unlikely(verbose_flag)) {
+      debug_log(__func__, "Calling asherah-cobhan DecryptFromJson");
+    }
+
+    // extern GoInt32 DecryptFromJson(void* partitionIdPtr, void* jsonPtr, void*
+    // dataPtr);
+    GoInt32 result = DecryptFromJson(partition_id_cobhan_buffer,
+                                     input_cobhan_buffer, output_cobhan_buffer);
+
+    if (unlikely(verbose_flag)) {
+      debug_log(__func__, "Returned from asherah-cobhan DecryptFromJson");
+    }
+
+    if (unlikely(!check_canary_ptr(partition_id_canary_ptr))) {
+      log_error_and_throw(
+          __func__,
+          "Failed post-call canary check for partition_id_cobhan_buffer");
+    }
+    if (unlikely(!check_canary_ptr(input_canary_ptr))) {
+      log_error_and_throw(
+          __func__, "Failed post-call canary check for input_cobhan_buffer");
+    }
+    if (unlikely(!check_canary_ptr(output_canary_ptr))) {
+      log_error_and_throw(
+          __func__, "Failed post-call canary check for output_cobhan_buffer");
+    }
+
+    if (unlikely(result < 0)) {
+      log_error_and_throw(__func__, AsherahCobhanErrorToString(result));
+    }
+
+    Napi::Buffer<unsigned char> output =
+        cbuffer_to_nbuffer(env, output_cobhan_buffer);
+
+    if (unlikely(verbose_flag)) {
+      debug_log(__func__, "finished");
+    }
+
+    return output;
+  }
+
+  Napi::Value DecryptString(const Napi::CallbackInfo &info) {
+    std::lock_guard<std::mutex> lock(asherah_lock);
+
+    if (unlikely(verbose_flag)) {
+      debug_log(__func__, "called");
+    }
+
+    if (unlikely(setup_state == 0)) {
+      log_error_and_throw(__func__, "setup() not called");
+    }
+
+    if (unlikely(info.Length() < 2)) {
+      log_error_and_throw(__func__, "Wrong number of arguments");
+    }
+
+    if (unlikely(!info[0].IsString() || !info[1].IsString())) {
+      log_error_and_throw(__func__, "Wrong argument types");
+    }
+
+    Napi::Env env = info.Env();
+
+    Napi::String partition_id = info[0].As<Napi::String>();
+    char *partition_id_cobhan_buffer;
+    size_t partition_id_copied_bytes;
+    NAPI_STRING_TO_CBUFFER(env, partition_id, partition_id_cobhan_buffer,
+                           partition_id_copied_bytes, maximum_stack_alloc_size,
+                           __func__);
+
+    Napi::String input = info[1].As<Napi::String>();
+    char *input_cobhan_buffer;
+    size_t input_copied_bytes;
+    NAPI_STRING_TO_CBUFFER(env, input, input_cobhan_buffer, input_copied_bytes,
+                           maximum_stack_alloc_size, __func__);
+
+    char *output_cobhan_buffer;
+    ALLOCATE_CBUFFER(output_cobhan_buffer, input_copied_bytes,
+                     maximum_stack_alloc_size, __func__);
+
+    char *partition_id_canary_ptr = get_canary_ptr(partition_id_cobhan_buffer);
+    if (unlikely(!check_canary_ptr(partition_id_canary_ptr))) {
+      log_error_and_throw(
+          __func__,
+          "Failed initial canary check for partition_id_cobhan_buffer");
+    }
+    char *input_canary_ptr = get_canary_ptr(input_cobhan_buffer);
+    if (unlikely(!check_canary_ptr(input_canary_ptr))) {
+      log_error_and_throw(
+          __func__, "Failed initial canary check for input_cobhan_buffer");
+    }
+    char *output_canary_ptr = get_canary_ptr(output_cobhan_buffer);
+    if (unlikely(!check_canary_ptr(output_canary_ptr))) {
+      log_error_and_throw(
+          __func__, "Failed initial canary check for output_cobhan_buffer");
+    }
+
+    if (unlikely(verbose_flag)) {
+      debug_log(__func__, "Calling asherah-cobhan DecryptFromJson");
+    }
+
+    // extern GoInt32 DecryptFromJson(void* partitionIdPtr, void* jsonPtr, void*
+    // dataPtr);
+    GoInt32 result = DecryptFromJson(partition_id_cobhan_buffer,
+                                     input_cobhan_buffer, output_cobhan_buffer);
+
+    if (unlikely(verbose_flag)) {
+      debug_log(__func__, "Returned from asherah-cobhan DecryptFromJson");
+    }
+
+    if (unlikely(!check_canary_ptr(partition_id_canary_ptr))) {
+      log_error_and_throw(
+          __func__,
+          "Failed post-call canary check for partition_id_cobhan_buffer");
+    }
+    if (unlikely(!check_canary_ptr(input_canary_ptr))) {
+      log_error_and_throw(
+          __func__, "Failed post-call canary check for input_cobhan_buffer");
+    }
+    if (unlikely(!check_canary_ptr(output_canary_ptr))) {
+      log_error_and_throw(
+          __func__, "Failed post-call canary check for output_cobhan_buffer");
+    }
+
+    if (unlikely(result < 0)) {
+      log_error_and_throw(__func__, AsherahCobhanErrorToString(result));
+    }
+
+    Napi::String output = cbuffer_to_nstring(env, output_cobhan_buffer);
+
+    if (unlikely(verbose_flag)) {
+      debug_log(__func__, "finished");
+    }
+
+    return output;
   }
-  return asherah_output_size_bytes;
-}
 
-__attribute__((always_inline)) inline const char* asherah_cobhan_error_to_string(int32_t error) {
-  switch(error) {
+  void ShutdownAsherah(const Napi::CallbackInfo &info) {
+    std::lock_guard<std::mutex> lock(asherah_lock);
+
+    if (unlikely(verbose_flag)) {
+      debug_log(__func__, "called");
+    }
+
+    setup_state = 0;
+
+    if (unlikely(verbose_flag)) {
+      debug_log(__func__, "Calling asherah-cobhan Shutdown");
+    }
+
+    // extern void Shutdown();
+    Shutdown();
+
+    if (unlikely(verbose_flag)) {
+      debug_log(__func__, "Returned from asherah-cobhan Shutdown");
+    }
+  }
+
+  void SetMaxStackAllocItemSize(const Napi::CallbackInfo &info) {
+    std::lock_guard<std::mutex> lock(asherah_lock);
+
+    if (unlikely(verbose_flag)) {
+      debug_log(__func__, "called");
+    }
+
+    if (unlikely(info.Length() < 1)) {
+      log_error_and_throw(__func__, "Wrong number of arguments");
+    }
+
+    Napi::Number item_size = info[0].ToNumber();
+
+    maximum_stack_alloc_size = (size_t)item_size.Int32Value();
+  }
+
+  void SetSafetyPaddingOverhead(const Napi::CallbackInfo &info) {
+    std::lock_guard<std::mutex> lock(asherah_lock);
+
+    if (unlikely(verbose_flag)) {
+      debug_log(__func__, "called");
+    }
+
+    if (unlikely(info.Length() < 1)) {
+      log_error_and_throw(__func__, "Wrong number of arguments");
+    }
+
+    Napi::Number safety_padding_number = info[0].ToNumber();
+
+    set_safety_padding_bytes((size_t)safety_padding_number.Int32Value());
+  }
+
+  __attribute__((always_inline)) inline size_t
+  EstimateAsherahOutputSize(size_t data_byte_len, size_t partition_byte_len) {
+    const size_t est_encryption_overhead = 48;
+    const size_t est_envelope_overhead = 185;
+    const double base64_overhead = 1.34;
+
+    // Add one rather than using std::ceil to round up
+    double est_data_byte_len =
+        (double(data_byte_len + est_encryption_overhead) * base64_overhead) + 1;
+
+    size_t asherah_output_size_bytes =
+        size_t(est_envelope_overhead + est_intermediate_key_overhead +
+               partition_byte_len + est_data_byte_len);
+    if (unlikely(verbose_flag)) {
+      std::string log_msg =
+          __func__ + ("(" + std::to_string(data_byte_len)) + ", " +
+          std::to_string(partition_byte_len) +
+          ") est_data_byte_len: " + std::to_string(est_data_byte_len) +
+          " asherah_output_size_bytes: " +
+          std::to_string(asherah_output_size_bytes);
+      debug_log(__func__, log_msg);
+    }
+    return asherah_output_size_bytes;
+  }
+
+  __attribute__((always_inline)) inline const char *
+  AsherahCobhanErrorToString(int32_t error) {
+    switch (error) {
     case 0:
       return "Success";
     case -1:
@@ -74,505 +574,8 @@ __attribute__((always_inline)) inline const char* asherah_cobhan_error_to_string
       return "Asherah error: Invalid configuration";
     default:
       return "Unknown error";
+    }
   }
-}
-
-void setup(const Napi::CallbackInfo &info) {
-  std::lock_guard<std::mutex> lock(asherah_lock);
-
-  if (unlikely(verbose_flag)) {
-    debug_log(__func__, "called");
-  }
-
-  if (unlikely(setup_state == 1)) {
-    log_error_and_throw(__func__, "setup called twice");
-  }
-
-  if (unlikely(info.Length() < 1)) {
-    log_error_and_throw(__func__, "Wrong number of arguments");
-  }
-
-  Napi::String config;
-  Napi::Object config_json;
-  Napi::Env env = info.Env();
-  Napi::Object json = env.Global().Get("JSON").As<Napi::Object>();
-  if (likely(info[0].IsObject())) {
-    config_json = info[0].As<Napi::Object>();
-    Napi::Function stringify = json.Get("stringify").As<Napi::Function>();
-    config = stringify.Call(json, {config_json}).As<Napi::String>();
-  } else if (likely(info[0].IsString())) {
-    config = info[0].As<Napi::String>();
-    Napi::Function parse = json.Get("parse").As<Napi::Function>();
-    config_json = parse.Call(json, {config}).As<Napi::Object>();
-  } else {
-    log_error_and_throw(__func__, "Wrong argument type");
-  }
-
-  Napi::String product_id = config_json.Get("ProductID").As<Napi::String>();
-  Napi::String service_name = config_json.Get("ServiceName").As<Napi::String>();
-
-  est_intermediate_key_overhead =
-      product_id.Utf8Value().length() + service_name.Utf8Value().length();
-
-  Napi::Value verbose = config_json.Get("Verbose");
-  if (likely(verbose.IsBoolean())) {
-    verbose_flag = verbose.As<Napi::Boolean>().Value();
-    debug_log(__func__, "verbose_flag: " + std::to_string(verbose_flag));
-  } else {
-    verbose_flag = 0;
-    debug_log(__func__, "verbose_flag: defaulting to false");
-  }
-
-  char *config_cobhan_buffer;
-  size_t config_copied_bytes;
-  NAPI_STRING_TO_CBUFFER(env, config, config_cobhan_buffer, config_copied_bytes,
-                         maximum_stack_alloc_size, __func__);
-
-  char *config_canary_ptr = get_canary_ptr(config_cobhan_buffer);
-  if (unlikely(!check_canary_ptr(config_canary_ptr))) {
-    log_error_and_throw(__func__,
-                        "Failed initial canary check for config_cobhan_buffer");
-  }
-
-  // extern GoInt32 SetupJson(void* configJson);
-  GoInt32 result = SetupJson(config_cobhan_buffer);
-
-  if (unlikely(verbose_flag)) {
-    debug_log(__func__, "Returned from asherah-cobhan SetupJson");
-  }
-
-  if (unlikely(!check_canary_ptr(config_canary_ptr))) {
-    log_error_and_throw(
-        __func__,
-        "Failed post-call canary check for config_cobhan_buffer");
-  }
-
-  if (unlikely(result < 0)) {
-    log_error_and_throw(__func__, asherah_cobhan_error_to_string(result));
-  }
-  setup_state = 1;
-}
-
-Napi::String encrypt_to_json(Napi::Env &env, size_t partition_bytes,
-                             size_t data_bytes,
-                             char *partition_id_cobhan_buffer,
-                             char *input_cobhan_buffer) {
-
-  size_t asherah_output_size_bytes =
-      estimate_asherah_output_size_bytes(data_bytes, partition_bytes);
-
-  if (unlikely(verbose_flag)) {
-    debug_log(__func__, " asherah_output_size_bytes " +
-                                     std::to_string(asherah_output_size_bytes));
-  }
-
-  char *output_cobhan_buffer;
-  ALLOCATE_CBUFFER(output_cobhan_buffer, asherah_output_size_bytes,
-                   maximum_stack_alloc_size, __func__);
-
-  char *partition_id_canary_ptr = get_canary_ptr(partition_id_cobhan_buffer);
-  if (unlikely(!check_canary_ptr(partition_id_canary_ptr))) {
-    log_error_and_throw(__func__,
-        "Failed initial canary check for partition_id_cobhan_buffer");
-  }
-  char *input_canary_ptr = get_canary_ptr(input_cobhan_buffer);
-  if (unlikely(!check_canary_ptr(input_canary_ptr))) {
-    log_error_and_throw(__func__,
-                        "Failed initial canary check for input_cobhan_buffer");
-  }
-  char *output_canary_ptr = get_canary_ptr(output_cobhan_buffer);
-  if (unlikely(!check_canary_ptr(output_canary_ptr))) {
-    log_error_and_throw(__func__,
-                        "Failed initial canary check for output_cobhan_buffer");
-  }
-
-  if (unlikely(verbose_flag)) {
-    debug_log(__func__, "Calling asherah-cobhan EncryptToJson");
-  }
-
-  // extern GoInt32 EncryptToJson(void* partitionIdPtr, void* dataPtr, void*
-  // jsonPtr);
-  GoInt32 result = EncryptToJson(partition_id_cobhan_buffer,
-                                 input_cobhan_buffer, output_cobhan_buffer);
-
-  if (unlikely(verbose_flag)) {
-    debug_log(__func__, "Returning from asherah-cobhan EncryptToJson");
-  }
-
-  if (unlikely(!check_canary_ptr(partition_id_canary_ptr))) {
-    log_error_and_throw(__func__,
-        "Failed post-call canary check for partition_id_cobhan_buffer");
-  }
-  if (unlikely(!check_canary_ptr(input_canary_ptr))) {
-    log_error_and_throw(__func__,
-        "Failed post-call canary check for input_cobhan_buffer");
-  }
-  if (unlikely(!check_canary_ptr(output_canary_ptr))) {
-    log_error_and_throw(__func__,
-        "Failed post-call canary check for output_cobhan_buffer");
-  }
-
-  if (unlikely(result < 0)) {
-    log_error_and_throw(__func__, asherah_cobhan_error_to_string(result));
-  }
-
-  Napi::String output = cbuffer_to_nstring(env, output_cobhan_buffer);
-  return output;
-}
-
-Napi::String encrypt(const Napi::CallbackInfo &info) {
-  std::lock_guard<std::mutex> lock(asherah_lock);
-
-  if (unlikely(verbose_flag)) {
-    debug_log(__func__, "called");
-  }
-
-  if (unlikely(setup_state == 0)) {
-    log_error_and_throw(__func__, "setup() not called");
-  }
-
-  if (unlikely(info.Length() < 2)) {
-    log_error_and_throw(__func__, "Wrong number of arguments");
-  }
-
-  if (unlikely(!info[0].IsString() || !info[1].IsBuffer())) {
-    log_error_and_throw(__func__, "Wrong argument types");
-  }
-
-  Napi::Env env = info.Env();
-
-  Napi::String partition_id = info[0].As<Napi::String>();
-  char *partition_id_cobhan_buffer;
-  size_t partition_id_copied_bytes;
-  NAPI_STRING_TO_CBUFFER(env, partition_id, partition_id_cobhan_buffer,
-                         partition_id_copied_bytes, maximum_stack_alloc_size,
-                         __func__);
-
-  Napi::Buffer<unsigned char> input_napi_buffer =
-      info[1].As<Napi::Buffer<unsigned char>>();
-  char *input_cobhan_buffer;
-  size_t input_copied_bytes;
-  NAPI_BUFFER_TO_CBUFFER(env, input_napi_buffer, input_cobhan_buffer,
-                         input_copied_bytes, maximum_stack_alloc_size,
-                         __func__);
-
-  Napi::String output =
-      encrypt_to_json(env, partition_id_copied_bytes, input_copied_bytes,
-                      partition_id_cobhan_buffer, input_cobhan_buffer);
-
-  if (unlikely(verbose_flag)) {
-    debug_log(__func__, "finished");
-  }
-
-  return output;
-}
-
-Napi::String encrypt_string(const Napi::CallbackInfo &info) {
-  std::lock_guard<std::mutex> lock(asherah_lock);
-
-  if (unlikely(verbose_flag)) {
-    debug_log(__func__, "called");
-  }
-
-  if (unlikely(setup_state == 0)) {
-    log_error_and_throw(__func__, "setup() not called");
-  }
-
-  if (unlikely(info.Length() < 2)) {
-    log_error_and_throw(__func__, "Wrong number of arguments");
-  }
-
-  if (unlikely(!info[0].IsString() || !info[1].IsString())) {
-    log_error_and_throw(__func__, "Wrong argument types");
-  }
-
-  Napi::Env env = info.Env();
-
-  Napi::String partition_id = info[0].As<Napi::String>();
-  char *partition_id_cobhan_buffer;
-  size_t partition_id_copied_bytes;
-  NAPI_STRING_TO_CBUFFER(env, partition_id, partition_id_cobhan_buffer,
-                         partition_id_copied_bytes, maximum_stack_alloc_size,
-                         __func__);
-
-  Napi::String input = info[1].As<Napi::String>();
-  char *input_cobhan_buffer;
-  size_t input_copied_bytes;
-  NAPI_STRING_TO_CBUFFER(env, input, input_cobhan_buffer, input_copied_bytes,
-                         maximum_stack_alloc_size, __func__);
-
-  Napi::String output =
-      encrypt_to_json(env, partition_id_copied_bytes, input_copied_bytes,
-                      partition_id_cobhan_buffer, input_cobhan_buffer);
-
-  if (unlikely(verbose_flag)) {
-    debug_log(__func__, "finished");
-  }
-
-  return output;
-}
-
-Napi::Buffer<unsigned char> decrypt(const Napi::CallbackInfo &info) {
-  std::lock_guard<std::mutex> lock(asherah_lock);
-
-  if (unlikely(verbose_flag)) {
-    debug_log(__func__, "called");
-  }
-
-  if (unlikely(setup_state == 0)) {
-    log_error_and_throw(__func__, "setup() not called");
-  }
-
-  if (unlikely(info.Length() < 2)) {
-    log_error_and_throw(__func__, "Wrong number of arguments");
-  }
-
-  if (unlikely(!info[0].IsString() || !info[1].IsString())) {
-    log_error_and_throw(__func__, "Wrong argument types");
-  }
-
-  Napi::Env env = info.Env();
-
-  Napi::String partition_id = info[0].As<Napi::String>();
-  char *partition_id_cobhan_buffer;
-  size_t partition_id_copied_bytes;
-  NAPI_STRING_TO_CBUFFER(env, partition_id, partition_id_cobhan_buffer,
-                         partition_id_copied_bytes, maximum_stack_alloc_size,
-                         __func__);
-
-  Napi::String input = info[1].As<Napi::String>();
-  char *input_cobhan_buffer;
-  size_t input_copied_bytes;
-  NAPI_STRING_TO_CBUFFER(env, input, input_cobhan_buffer, input_copied_bytes,
-                         maximum_stack_alloc_size, __func__);
-
-  char *output_cobhan_buffer;
-  ALLOCATE_CBUFFER(output_cobhan_buffer, input_copied_bytes,
-                   maximum_stack_alloc_size, __func__);
-
-  char *partition_id_canary_ptr = get_canary_ptr(partition_id_cobhan_buffer);
-  if (unlikely(!check_canary_ptr(partition_id_canary_ptr))) {
-    log_error_and_throw(
-        __func__,
-        "Failed initial canary check for partition_id_cobhan_buffer");
-  }
-  char *input_canary_ptr = get_canary_ptr(input_cobhan_buffer);
-  if (unlikely(!check_canary_ptr(input_canary_ptr))) {
-    log_error_and_throw(__func__,
-                        "Failed initial canary check for input_cobhan_buffer");
-  }
-  char *output_canary_ptr = get_canary_ptr(output_cobhan_buffer);
-  if (unlikely(!check_canary_ptr(output_canary_ptr))) {
-    log_error_and_throw(__func__,
-                        "Failed initial canary check for output_cobhan_buffer");
-  }
-
-  if (unlikely(verbose_flag)) {
-    debug_log(__func__, "Calling asherah-cobhan DecryptFromJson");
-  }
-
-  // extern GoInt32 DecryptFromJson(void* partitionIdPtr, void* jsonPtr, void*
-  // dataPtr);
-  GoInt32 result = DecryptFromJson(partition_id_cobhan_buffer,
-                                   input_cobhan_buffer, output_cobhan_buffer);
-
-  if (unlikely(verbose_flag)) {
-    debug_log(__func__, "Returned from asherah-cobhan DecryptFromJson");
-  }
-
-  if (unlikely(!check_canary_ptr(partition_id_canary_ptr))) {
-    log_error_and_throw(__func__,
-        "Failed post-call canary check for partition_id_cobhan_buffer");
-  }
-  if (unlikely(!check_canary_ptr(input_canary_ptr))) {
-    log_error_and_throw(__func__,
-        "Failed post-call canary check for input_cobhan_buffer");
-  }
-  if (unlikely(!check_canary_ptr(output_canary_ptr))) {
-    log_error_and_throw(__func__,
-        "Failed post-call canary check for output_cobhan_buffer");
-  }
-
-  if (unlikely(result < 0)) {
-    log_error_and_throw(__func__, asherah_cobhan_error_to_string(result));
-  }
-
-  Napi::Buffer<unsigned char> output =
-      cbuffer_to_nbuffer(env, output_cobhan_buffer);
-
-  if (unlikely(verbose_flag)) {
-    debug_log(__func__, "finished");
-  }
-
-  return output;
-}
-
-Napi::String decrypt_string(const Napi::CallbackInfo &info) {
-  std::lock_guard<std::mutex> lock(asherah_lock);
-
-  if (unlikely(verbose_flag)) {
-    debug_log(__func__, "called");
-  }
-
-  if (unlikely(setup_state == 0)) {
-    log_error_and_throw(__func__, "setup() not called");
-  }
-
-  if (unlikely(info.Length() < 2)) {
-    log_error_and_throw(__func__, "Wrong number of arguments");
-  }
-
-  if (unlikely(!info[0].IsString() || !info[1].IsString())) {
-    log_error_and_throw(__func__, "Wrong argument types");
-  }
-
-  Napi::Env env = info.Env();
-
-  Napi::String partition_id = info[0].As<Napi::String>();
-  char *partition_id_cobhan_buffer;
-  size_t partition_id_copied_bytes;
-  NAPI_STRING_TO_CBUFFER(env, partition_id, partition_id_cobhan_buffer,
-                         partition_id_copied_bytes, maximum_stack_alloc_size,
-                         __func__);
-
-  Napi::String input = info[1].As<Napi::String>();
-  char *input_cobhan_buffer;
-  size_t input_copied_bytes;
-  NAPI_STRING_TO_CBUFFER(env, input, input_cobhan_buffer, input_copied_bytes,
-                         maximum_stack_alloc_size, __func__);
-
-  char *output_cobhan_buffer;
-  ALLOCATE_CBUFFER(output_cobhan_buffer, input_copied_bytes,
-                   maximum_stack_alloc_size, __func__);
-
-  char *partition_id_canary_ptr = get_canary_ptr(partition_id_cobhan_buffer);
-  if (unlikely(!check_canary_ptr(partition_id_canary_ptr))) {
-    log_error_and_throw(
-        __func__,
-        "Failed initial canary check for partition_id_cobhan_buffer");
-  }
-  char *input_canary_ptr = get_canary_ptr(input_cobhan_buffer);
-  if (unlikely(!check_canary_ptr(input_canary_ptr))) {
-    log_error_and_throw(__func__,
-                        "Failed initial canary check for input_cobhan_buffer");
-  }
-  char *output_canary_ptr = get_canary_ptr(output_cobhan_buffer);
-  if (unlikely(!check_canary_ptr(output_canary_ptr))) {
-    log_error_and_throw(__func__,
-                        "Failed initial canary check for output_cobhan_buffer");
-  }
-
-  if (unlikely(verbose_flag)) {
-    debug_log(__func__, "Calling asherah-cobhan DecryptFromJson");
-  }
-
-  // extern GoInt32 DecryptFromJson(void* partitionIdPtr, void* jsonPtr, void*
-  // dataPtr);
-  GoInt32 result = DecryptFromJson(partition_id_cobhan_buffer,
-                                   input_cobhan_buffer, output_cobhan_buffer);
-
-  if (unlikely(verbose_flag)) {
-    debug_log(__func__, "Returned from asherah-cobhan DecryptFromJson");
-  }
-
-  if (unlikely(!check_canary_ptr(partition_id_canary_ptr))) {
-    log_error_and_throw(__func__,
-        "Failed post-call canary check for partition_id_cobhan_buffer");
-  }
-  if (unlikely(!check_canary_ptr(input_canary_ptr))) {
-    log_error_and_throw(__func__,
-        "Failed post-call canary check for input_cobhan_buffer");
-  }
-  if (unlikely(!check_canary_ptr(output_canary_ptr))) {
-    log_error_and_throw(__func__,
-        "Failed post-call canary check for output_cobhan_buffer");
-  }
-
-  if (unlikely(result < 0)) {
-    log_error_and_throw(__func__, asherah_cobhan_error_to_string(result));
-  }
-
-  Napi::String output = cbuffer_to_nstring(env, output_cobhan_buffer);
-
-  if (unlikely(verbose_flag)) {
-    debug_log(__func__, "finished");
-  }
-
-  return output;
-}
-
-void shutdown(const Napi::CallbackInfo &info) {
-  std::lock_guard<std::mutex> lock(asherah_lock);
-
-  if (unlikely(verbose_flag)) {
-    debug_log(__func__, "called");
-  }
-
-  setup_state = 0;
-
-  if (unlikely(verbose_flag)) {
-    debug_log(__func__, "Calling asherah-cobhan Shutdown");
-  }
-
-  // extern void Shutdown();
-  Shutdown();
-
-  if (unlikely(verbose_flag)) {
-    debug_log(__func__, "Returned from asherah-cobhan Shutdown");
-  }
-}
-
-void set_max_stack_alloc_item_size(const Napi::CallbackInfo &info) {
-  std::lock_guard<std::mutex> lock(asherah_lock);
-
-  if (unlikely(verbose_flag)) {
-    debug_log(__func__, "called");
-  }
-
-  if (unlikely(info.Length() < 1)) {
-    log_error_and_throw(__func__,
-                        "Wrong number of arguments");
-  }
-
-  Napi::Number item_size = info[0].ToNumber();
-
-  maximum_stack_alloc_size = (size_t)item_size.Int32Value();
-}
-
-void set_safety_padding_overhead(const Napi::CallbackInfo &info) {
-  std::lock_guard<std::mutex> lock(asherah_lock);
-
-  if (unlikely(verbose_flag)) {
-    debug_log(__func__, "called");
-  }
-
-  if (unlikely(info.Length() < 1)) {
-    log_error_and_throw(__func__,
-                        "Wrong number of arguments");
-  }
+};
 
-  Napi::Number safety_padding_number = info[0].ToNumber();
-
-  set_safety_padding_bytes((size_t)safety_padding_number.Int32Value());
-}
-
-Napi::Object Init(Napi::Env env, Napi::Object exports) {
-  exports.Set(Napi::String::New(env, "setup"), Napi::Function::New(env, setup));
-  exports.Set(Napi::String::New(env, "encrypt"),
-              Napi::Function::New(env, encrypt));
-  exports.Set(Napi::String::New(env, "encrypt_string"),
-              Napi::Function::New(env, encrypt_string));
-  exports.Set(Napi::String::New(env, "decrypt"),
-              Napi::Function::New(env, decrypt));
-  exports.Set(Napi::String::New(env, "decrypt_string"),
-              Napi::Function::New(env, decrypt_string));
-  exports.Set(Napi::String::New(env, "set_safety_padding_overhead"),
-              Napi::Function::New(env, set_safety_padding_overhead));
-  exports.Set(Napi::String::New(env, "set_max_stack_alloc_item_size"),
-              Napi::Function::New(env, set_max_stack_alloc_item_size));
-  exports.Set(Napi::String::New(env, "shutdown"),
-              Napi::Function::New(env, shutdown));
-  return exports;
-}
-
-NODE_API_MODULE(asherah, Init)
+NODE_API_NAMED_ADDON('asherah', Asherah)

package/src/asherah.h

@@ -0,0 +1,14 @@
+#ifndef ASHERAH_H
+#define ASHERAH_H
+#include <cstdint>
+#include <napi.h>
+#include <stddef.h>
+
+size_t estimate_asherah_output_size_bytes(size_t data_byte_len,
+                                          size_t partition_byte_len);
+const char *asherah_cobhan_error_to_string(int32_t error);
+Napi::String encrypt_to_json(Napi::Env &env, size_t partition_bytes,
+                             size_t data_bytes,
+                             char *partition_id_cobhan_buffer,
+                             char *input_cobhan_buffer);
+#endif

package/src/cobhan.h

@@ -37,9 +37,8 @@ calculate_cobhan_buffer_allocation_size(size_t data_len_bytes) {
 __attribute__((always_inline)) inline void
 configure_cbuffer(char *cobhan_buffer, size_t length) {
   if (unlikely(verbose_flag)) {
-    debug_log(__func__, "configure_cbuffer(" +
-                                       format_ptr(cobhan_buffer) + ", " +
-                                       std::to_string(length) + ")");
+    debug_log(__func__, "configure_cbuffer(" + format_ptr(cobhan_buffer) +
+                            ", " + std::to_string(length) + ")");
   }
 
   *((int32_t *)cobhan_buffer) = length;
@@ -87,8 +86,7 @@ heap_allocate_cbuffer(const char *variable_name, size_t size_bytes) {
       calculate_cobhan_buffer_allocation_size(size_bytes);
 
   if (unlikely(verbose_flag)) {
-    debug_log_new(__func__, variable_name,
-                  cobhan_buffer_allocation_size);
+    debug_log_new(__func__, variable_name, cobhan_buffer_allocation_size);
   }
 
   char *cobhan_buffer = new (std::nothrow) char[cobhan_buffer_allocation_size];

package/src/cobhan_napi_interop.h

@@ -6,56 +6,7 @@
 #include <napi.h>
 #include <string>
 
-std::string napi_status_to_string(napi_status status) {
-  switch (status) {
-  case napi_ok:
-    return "napi_ok";
-  case napi_invalid_arg:
-    return "napi_invalid_arg";
-  case napi_object_expected:
-    return "napi_object_expected";
-  case napi_string_expected:
-    return "napi_string_expected";
-  case napi_name_expected:
-    return "napi_name_expected";
-  case napi_function_expected:
-    return "napi_function_expected";
-  case napi_number_expected:
-    return "napi_number_expected";
-  case napi_boolean_expected:
-    return "napi_boolean_expected";
-  case napi_array_expected:
-    return "napi_array_expected";
-  case napi_generic_failure:
-    return "napi_generic_failure";
-  case napi_pending_exception:
-    return "napi_pending_exception";
-  case napi_cancelled:
-    return "napi_cancelled";
-  case napi_escape_called_twice:
-    return "napi_escape_called_twice";
-  case napi_handle_scope_mismatch:
-    return "napi_handle_scope_mismatch";
-  case napi_callback_scope_mismatch:
-    return "napi_callback_scope_mismatch";
-  case napi_queue_full:
-    return "napi_queue_full";
-  case napi_closing:
-    return "napi_closing";
-  case napi_bigint_expected:
-    return "napi_bigint_expected";
-  case napi_date_expected:
-    return "napi_date_expected";
-  case napi_arraybuffer_expected:
-    return "napi_arraybuffer_expected";
-  case napi_detachable_arraybuffer_expected:
-    return "napi_detachable_arraybuffer_expected";
-  case napi_would_deadlock:
-    return "napi_would_deadlock";
-  default:
-    return "Unknown napi_status";
-  }
-}
+std::string napi_status_to_string(napi_status status);
 
 __attribute__((always_inline)) inline size_t
 nstring_utf8_byte_length(Napi::Env &env, Napi::String &str) {
@@ -64,9 +15,8 @@ nstring_utf8_byte_length(Napi::Env &env, Napi::String &str) {
 
   status = napi_get_value_string_utf8(env, str, nullptr, 0, &utf8_length);
   if (unlikely(status != napi_ok)) {
-    error_log(__func__,
-              "napi_get_value_string_utf8 length check failed: " +
-                  napi_status_to_string(status));
+    error_log(__func__, "napi_get_value_string_utf8 length check failed: " +
+                            napi_status_to_string(status));
     return (size_t)(-1);
   }
 
@@ -105,17 +55,15 @@ copy_nstring_to_cbuffer(Napi::Env &env, Napi::String &str,
   status = napi_get_value_string_utf8(env, str, cbuffer_data_ptr(cobhan_buffer),
                                       str_utf8_byte_length + 1, &copied_bytes);
   if (unlikely(status != napi_ok)) {
-    error_log(__func__,
-              "Napi utf8 string conversion failure: " +
-                  napi_status_to_string(status));
+    error_log(__func__, "Napi utf8 string conversion failure: " +
+                            napi_status_to_string(status));
     return nullptr;
   }
 
   if (unlikely(copied_bytes != str_utf8_byte_length)) {
-    error_log(__func__,
-              "Did not copy expected number of bytes " +
-                  std::to_string(str_utf8_byte_length) + " copied " +
-                  std::to_string(copied_bytes));
+    error_log(__func__, "Did not copy expected number of bytes " +
+                            std::to_string(str_utf8_byte_length) + " copied " +
+                            std::to_string(copied_bytes));
     return nullptr;
   }
 
@@ -131,8 +79,7 @@ cbuffer_to_nstring(Napi::Env &env, char *cobhan_buffer) {
 
   int32_t cobhan_buffer_size_bytes = cbuffer_byte_length(cobhan_buffer);
   if (cobhan_buffer_size_bytes <= 0) {
-    log_error_and_throw(__func__,
-                        "Invalid cobhan buffer byte length");
+    log_error_and_throw(__func__, "Invalid cobhan buffer byte length");
   }
 
   // Using C function because it allows length delimited input
@@ -140,9 +87,8 @@ cbuffer_to_nstring(Napi::Env &env, char *cobhan_buffer) {
       env, cbuffer_data_ptr(cobhan_buffer), cobhan_buffer_size_bytes, &output);
 
   if (unlikely(status != napi_ok)) {
-    log_error_and_throw(__func__,
-                        "napi_create_string_utf8 failed: " +
-                            napi_status_to_string(status));
+    log_error_and_throw(__func__, "napi_create_string_utf8 failed: " +
+                                      napi_status_to_string(status));
   }
 
   return Napi::String(env, output);
@@ -152,8 +98,7 @@ __attribute__((always_inline)) inline Napi::Buffer<unsigned char>
 cbuffer_to_nbuffer(Napi::Env &env, char *cobhan_buffer) {
   int32_t cobhan_buffer_byte_length = cbuffer_byte_length(cobhan_buffer);
   if (unlikely(cobhan_buffer_byte_length <= 0)) {
-    log_error_and_throw(__func__,
-                        "Invalid cobhan buffer byte length");
+    log_error_and_throw(__func__, "Invalid cobhan buffer byte length");
   }
 
   Napi::Buffer<unsigned char> nbuffer = Napi::Buffer<unsigned char>::Copy(
@@ -189,8 +134,8 @@ copy_nbuffer_to_cbuffer(Napi::Env &env, Napi::Buffer<unsigned char> &nbuffer,
     debug_log(__func__,
               "Copying " + std::to_string(nbuffer_byte_length) + " bytes to " +
                   format_ptr(cbuffer_data_ptr(cobhan_buffer)) + " - " +
-                  format_ptr((cbuffer_data_ptr(cobhan_buffer) +
-                              nbuffer_byte_length)));
+                  format_ptr(
+                      (cbuffer_data_ptr(cobhan_buffer) + nbuffer_byte_length)));
   }
 
   memcpy(cbuffer_data_ptr(cobhan_buffer), nbuffer.Data(), nbuffer_byte_length);
@@ -250,4 +195,55 @@ copy_nbuffer_to_cbuffer(Napi::Env &env, Napi::Buffer<unsigned char> &nbuffer,
     bytes_copied = napi_buffer##_byte_length;                                  \
   } while (0);
 
+std::string napi_status_to_string(napi_status status) {
+  switch (status) {
+  case napi_ok:
+    return "napi_ok";
+  case napi_invalid_arg:
+    return "napi_invalid_arg";
+  case napi_object_expected:
+    return "napi_object_expected";
+  case napi_string_expected:
+    return "napi_string_expected";
+  case napi_name_expected:
+    return "napi_name_expected";
+  case napi_function_expected:
+    return "napi_function_expected";
+  case napi_number_expected:
+    return "napi_number_expected";
+  case napi_boolean_expected:
+    return "napi_boolean_expected";
+  case napi_array_expected:
+    return "napi_array_expected";
+  case napi_generic_failure:
+    return "napi_generic_failure";
+  case napi_pending_exception:
+    return "napi_pending_exception";
+  case napi_cancelled:
+    return "napi_cancelled";
+  case napi_escape_called_twice:
+    return "napi_escape_called_twice";
+  case napi_handle_scope_mismatch:
+    return "napi_handle_scope_mismatch";
+  case napi_callback_scope_mismatch:
+    return "napi_callback_scope_mismatch";
+  case napi_queue_full:
+    return "napi_queue_full";
+  case napi_closing:
+    return "napi_closing";
+  case napi_bigint_expected:
+    return "napi_bigint_expected";
+  case napi_date_expected:
+    return "napi_date_expected";
+  case napi_arraybuffer_expected:
+    return "napi_arraybuffer_expected";
+  case napi_detachable_arraybuffer_expected:
+    return "napi_detachable_arraybuffer_expected";
+  case napi_would_deadlock:
+    return "napi_would_deadlock";
+  default:
+    return "Unknown napi_status";
+  }
+}
+
 #endif