asherah 1.3.23 → 1.3.24

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.24",
   "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"
@@ -12,71 +13,6 @@ 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);
-  }
-  return asherah_output_size_bytes;
-}
-
-__attribute__((always_inline)) inline const char* asherah_cobhan_error_to_string(int32_t error) {
-  switch(error) {
-    case 0:
-      return "Success";
-    case -1:
-      return "Cobhan error: NULL pointer";
-    case -2:
-      return "Cobhan error: Buffer too large";
-    case -3:
-      return "Cobhan error: Buffer too small";
-    case -4:
-      return "Cobhan error: Copy failed";
-    case -5:
-      return "Cobhan error: JSON decode failed";
-    case -6:
-      return "Cobhan error: JSON encode failed";
-    case -7:
-      return "Cobhan error: Invalid UTF-8";
-    case -8:
-      return "Cobhan error: Read temp file failed";
-    case -9:
-      return "Cobhan error: Write temp file failed";
-    case -100:
-      return "Asherah error: Not initialized";
-    case -101:
-      return "Asherah error: Already initialized";
-    case -102:
-      return "Asherah error: Failed to get session";
-    case -103:
-      return "Asherah error: Encrypt operation failed";
-    case -104:
-      return "Asherah error: Decrypt operation failed";
-    case -105:
-      return "Asherah error: Invalid configuration";
-    default:
-      return "Unknown error";
-  }
-}
-
 void setup(const Napi::CallbackInfo &info) {
   std::lock_guard<std::mutex> lock(asherah_lock);
 
@@ -143,8 +79,7 @@ void setup(const Napi::CallbackInfo &info) {
 
   if (unlikely(!check_canary_ptr(config_canary_ptr))) {
     log_error_and_throw(
-        __func__,
-        "Failed post-call canary check for config_cobhan_buffer");
+        __func__, "Failed post-call canary check for config_cobhan_buffer");
   }
 
   if (unlikely(result < 0)) {
@@ -153,73 +88,6 @@ void setup(const Napi::CallbackInfo &info) {
   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);
 
@@ -312,6 +180,74 @@ Napi::String encrypt_string(const Napi::CallbackInfo &info) {
   return output;
 }
 
+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::Buffer<unsigned char> decrypt(const Napi::CallbackInfo &info) {
   std::lock_guard<std::mutex> lock(asherah_lock);
 
@@ -353,8 +289,7 @@ Napi::Buffer<unsigned char> decrypt(const Napi::CallbackInfo &info) {
   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");
+        __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))) {
@@ -381,16 +316,17 @@ Napi::Buffer<unsigned char> decrypt(const Napi::CallbackInfo &info) {
   }
 
   if (unlikely(!check_canary_ptr(partition_id_canary_ptr))) {
-    log_error_and_throw(__func__,
+    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");
+    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");
+    log_error_and_throw(
+        __func__, "Failed post-call canary check for output_cobhan_buffer");
   }
 
   if (unlikely(result < 0)) {
@@ -448,8 +384,7 @@ Napi::String decrypt_string(const Napi::CallbackInfo &info) {
   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");
+        __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))) {
@@ -476,16 +411,17 @@ Napi::String decrypt_string(const Napi::CallbackInfo &info) {
   }
 
   if (unlikely(!check_canary_ptr(partition_id_canary_ptr))) {
-    log_error_and_throw(__func__,
+    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");
+    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");
+    log_error_and_throw(
+        __func__, "Failed post-call canary check for output_cobhan_buffer");
   }
 
   if (unlikely(result < 0)) {
@@ -530,8 +466,7 @@ void set_max_stack_alloc_item_size(const Napi::CallbackInfo &info) {
   }
 
   if (unlikely(info.Length() < 1)) {
-    log_error_and_throw(__func__,
-                        "Wrong number of arguments");
+    log_error_and_throw(__func__, "Wrong number of arguments");
   }
 
   Napi::Number item_size = info[0].ToNumber();
@@ -547,8 +482,7 @@ void set_safety_padding_overhead(const Napi::CallbackInfo &info) {
   }
 
   if (unlikely(info.Length() < 1)) {
-    log_error_and_throw(__func__,
-                        "Wrong number of arguments");
+    log_error_and_throw(__func__, "Wrong number of arguments");
   }
 
   Napi::Number safety_padding_number = info[0].ToNumber();
@@ -556,6 +490,72 @@ void set_safety_padding_overhead(const Napi::CallbackInfo &info) {
   set_safety_padding_bytes((size_t)safety_padding_number.Int32Value());
 }
 
+__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);
+  }
+  return asherah_output_size_bytes;
+}
+
+__attribute__((always_inline)) inline const char *
+asherah_cobhan_error_to_string(int32_t error) {
+  switch (error) {
+  case 0:
+    return "Success";
+  case -1:
+    return "Cobhan error: NULL pointer";
+  case -2:
+    return "Cobhan error: Buffer too large";
+  case -3:
+    return "Cobhan error: Buffer too small";
+  case -4:
+    return "Cobhan error: Copy failed";
+  case -5:
+    return "Cobhan error: JSON decode failed";
+  case -6:
+    return "Cobhan error: JSON encode failed";
+  case -7:
+    return "Cobhan error: Invalid UTF-8";
+  case -8:
+    return "Cobhan error: Read temp file failed";
+  case -9:
+    return "Cobhan error: Write temp file failed";
+  case -100:
+    return "Asherah error: Not initialized";
+  case -101:
+    return "Asherah error: Already initialized";
+  case -102:
+    return "Asherah error: Failed to get session";
+  case -103:
+    return "Asherah error: Encrypt operation failed";
+  case -104:
+    return "Asherah error: Decrypt operation failed";
+  case -105:
+    return "Asherah error: Invalid configuration";
+  default:
+    return "Unknown error";
+  }
+}
+
 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"),

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