asherah 1.3.12 → 1.3.14

package/binding.gyp

@@ -18,7 +18,12 @@
       'defines': [ 'NAPI_CPP_EXCEPTIONS', 'NODE_API_SWALLOW_UNTHROWABLE_EXCEPTIONS' ],
       'sources': [
         'lib/libasherah.h',
-        'src/asherah.cc'
+        'src/asherah.cc',
+        'src/logging.cc',
+        'src/logging.h',
+        'src/cobhan_napi_interop.cc',
+        'src/cobhan_napi_interop.h',
+        'src/hints.h'
       ],
       'libraries': [ '../lib/libasherah.a' ]
     }

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "asherah",
-  "version": "1.3.12",
+  "version": "1.3.14",
   "description": "Asherah envelope encryption and key rotation library",
   "exports": {
     "node-addons": "./dist/asherah.node"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/jgowdy/asherah-cobhan.git"
+    "url": "https://github.com/godaddy/asherah-node.git"
   },
   "scripts": {
     "preinstall": "scripts/download-libraries.sh",
-    "install": "node-gyp configure && node-gyp build && mkdir -p dist/ && cp build/Release/asherah.node dist/asherah.node && cp src/asherah.d.ts dist/asherah.d.ts",
+    "install": "scripts/build.sh",
     "test:mocha": "mocha",
     "test": "nyc npm run test:mocha",
     "posttest": "npm run lint",
@@ -23,6 +23,11 @@
   "files": [
     "binding.gyp",
     "src/asherah.cc",
+    "src/hints.h",
+    "src/logging.h",
+    "src/logging.cc",
+    "src/cobhan_napi_interop.h",
+    "src/cobhan_napi_interop.cc",
     "src/asherah.d.ts",
     "scripts/download-libraries.sh",
     "SHA256SUMS",

package/src/asherah.cc

@@ -1,242 +1,13 @@
 #include "../lib/libasherah.h"
 #include <iostream>
 #define NODE_ADDON_API_DISABLE_DEPRECATED
+#include "cobhan_napi_interop.h"
+#include "hints.h"
+#include "logging.h"
 #include <napi.h>
 
-#define unlikely(expr) __builtin_expect(!!(expr), 0)
-#define likely(expr) __builtin_expect(!!(expr), 1)
-
-const size_t cobhan_header_size_bytes = 64 / 8;
-const size_t est_encryption_overhead = 48;
-const size_t est_envelope_overhead = 185;
-const double base64_overhead = 1.34;
-
-size_t est_intermediate_key_overhead = 0;
-size_t safety_padding_bytes = 0;
 size_t max_stack_alloc_size = 2048;
-
 int32_t setup_state = 0;
-int32_t verbose_flag = 0;
-
-__attribute__((always_inline)) inline void debug_log(const char *function_name,
-                                                     std::string message) {
-  if (unlikely(verbose_flag)) {
-    std::cerr << "asherah-node: [DEBUG] " << function_name << ": " << message
-              << std::endl
-              << std::flush;
-  }
-}
-
-__attribute__((always_inline)) inline void
-debug_log_alloca(const char *function_name, const char *variable_name,
-                 size_t length) {
-  if (unlikely(verbose_flag)) {
-    std::cerr << "asherah-node: [DEBUG] " << function_name
-              << ": Calling alloca(" << length << ") (stack) for "
-              << variable_name << std::endl
-              << std::flush;
-  }
-}
-
-__attribute__((always_inline)) inline void error_log(const char *function_name,
-                                                     std::string message) {
-  if (unlikely(verbose_flag)) {
-    std::cerr << "asherah-node: [ERROR] " << function_name << ": " << message
-              << std::endl
-              << std::flush;
-  }
-}
-
-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";
-  }
-}
-
-__attribute__((always_inline)) inline Napi::Value
-LogErrorAndThrow(Napi::Env &env, const char *function_name,
-                 std::string error_msg) {
-  error_log(function_name, error_msg);
-  Napi::Error::New(env, function_name + (": " + error_msg))
-      .ThrowAsJavaScriptException();
-  return env.Null();
-}
-
-__attribute__((always_inline)) inline size_t
-calculate_cobhan_buffer_size_bytes(size_t data_len_bytes) {
-  return data_len_bytes + cobhan_header_size_bytes + safety_padding_bytes +
-         1; // Add one for possible NULL delimiter due to Node string functions
-}
-
-__attribute__((always_inline)) inline size_t
-estimate_asherah_output_size_bytes(size_t data_byte_len,
-                                   size_t partition_byte_len) {
-  // 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 + safety_padding_bytes);
-  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("estimate_asherah_output_size", log_msg);
-  }
-  return asherah_output_size_bytes;
-}
-
-__attribute__((always_inline)) inline void configure_cbuffer(char *buffer,
-                                                             size_t length) {
-  *((int32_t *)buffer) = length;
-  // Reserved for future use
-  *((int32_t *)(buffer + sizeof(int32_t))) = 0;
-}
-
-__attribute__((always_inline)) inline std::unique_ptr<char[]>
-heap_allocate_cbuffer(const char *variable_name, size_t size_bytes) {
-  size_t cobhan_buffer_size_bytes =
-      calculate_cobhan_buffer_size_bytes(size_bytes);
-  if (unlikely(verbose_flag)) {
-    std::string log_msg =
-        "heap_allocate_cbuffer(" + std::to_string(size_bytes) +
-        ") (heap) cobhan_buffer_size_bytes: " +
-        std::to_string(cobhan_buffer_size_bytes) + " for " + variable_name;
-    debug_log("allocate_cbuffer", log_msg);
-  }
-
-  char *cobhan_buffer = new (std::nothrow) char[cobhan_buffer_size_bytes];
-  if (unlikely(cobhan_buffer == nullptr)) {
-    std::string error_msg =
-        "new[" + std::to_string(cobhan_buffer_size_bytes) + " returned null";
-    error_log("allocate_cbuffer", error_msg);
-    return nullptr;
-  }
-  std::unique_ptr<char[]> cobhan_buffer_unique_ptr(cobhan_buffer);
-  configure_cbuffer(cobhan_buffer, size_bytes + safety_padding_bytes);
-  return cobhan_buffer_unique_ptr;
-}
-
-__attribute__((always_inline)) inline Napi::Value
-cbuffer_to_nstring(Napi::Env &env, char *cobhan_buffer) {
-  napi_value output;
-
-  // Using C function because it allows length delimited input
-  napi_status status = napi_create_string_utf8(
-      env, ((const char *)cobhan_buffer) + cobhan_header_size_bytes,
-      *((int *)cobhan_buffer), &output);
-
-  if (unlikely(status != napi_ok)) {
-    return LogErrorAndThrow(env, "cbuffer_to_nstring",
-                            "napi_create_string_utf8 failed: " +
-                                napi_status_to_string(status));
-  }
-
-  return Napi::String(env, output);
-}
-
-__attribute__((always_inline)) inline size_t
-nstring_utf8_byte_length(Napi::Env &env, Napi::String &str) {
-  napi_status status;
-  size_t utf8_length;
-
-  status = napi_get_value_string_utf8(env, str, nullptr, 0, &utf8_length);
-  if (unlikely(status != napi_ok)) {
-    LogErrorAndThrow(env, "nstring_utf8_length",
-                     "napi_get_value_string_utf8 length check failed: " +
-                         napi_status_to_string(status));
-    return (size_t)(-1);
-  }
-
-  return utf8_length;
-}
-
-__attribute__((always_inline)) inline char *
-copy_nstring_to_cbuffer(Napi::Env &env, Napi::String &str,
-                        size_t utf8_byte_length, char *cobhan_buffer,
-                        size_t *byte_length = nullptr) {
-  napi_status status;
-  size_t copied_bytes;
-  status = napi_get_value_string_utf8(env, str,
-                                      cobhan_buffer + cobhan_header_size_bytes,
-                                      utf8_byte_length + 1, &copied_bytes);
-  if (unlikely(status != napi_ok)) {
-    LogErrorAndThrow(env, "copy_nstring_to_cbuffer",
-                     "Napi utf8 string conversion failure: " +
-                         napi_status_to_string(status));
-    return nullptr;
-  }
-
-  if (unlikely(copied_bytes != utf8_byte_length)) {
-    LogErrorAndThrow(env, "copy_nstring_to_cbuffer",
-                     "Did not copy expected number of bytes " +
-                         std::to_string(utf8_byte_length) + " copied " +
-                         std::to_string(copied_bytes));
-    return nullptr;
-  }
-
-  configure_cbuffer(cobhan_buffer, copied_bytes);
-
-  if (byte_length != nullptr)
-    *byte_length = copied_bytes;
-  return cobhan_buffer;
-}
-
-__attribute__((always_inline)) inline Napi::Buffer<unsigned char>
-cbuffer_to_nbuffer(Napi::Env &env, char *cobhan_buffer) {
-  return Napi::Buffer<unsigned char>::Copy(
-      env, ((unsigned char *)cobhan_buffer) + cobhan_header_size_bytes,
-      *((int *)cobhan_buffer));
-}
 
 void setup(const Napi::CallbackInfo &info) {
   Napi::Env env = info.Env();
@@ -246,12 +17,12 @@ void setup(const Napi::CallbackInfo &info) {
   }
 
   if (unlikely(setup_state == 1)) {
-    LogErrorAndThrow(env, "setup", "setup called twice");
+    log_error_and_throw(env, "setup", "setup called twice");
     return;
   }
 
   if (unlikely(info.Length() < 1)) {
-    LogErrorAndThrow(env, "setup", "Wrong number of arguments");
+    log_error_and_throw(env, "setup", "Wrong number of arguments");
     return;
   }
 
@@ -267,7 +38,7 @@ void setup(const Napi::CallbackInfo &info) {
     Napi::Function parse = json.Get("parse").As<Napi::Function>();
     config_json = parse.Call(json, {config}).As<Napi::Object>();
   } else {
-    LogErrorAndThrow(env, "setup", "Wrong argument type");
+    log_error_and_throw(env, "setup", "Wrong argument type");
     return;
   }
 
@@ -290,7 +61,7 @@ void setup(const Napi::CallbackInfo &info) {
   size_t config_utf8_byte_length;
   config_utf8_byte_length = nstring_utf8_byte_length(env, config);
   if (unlikely(config_utf8_byte_length == (size_t)(-1))) {
-    LogErrorAndThrow(env, "setup", "Failed to get config utf8 length");
+    log_error_and_throw(env, "setup", "Failed to get config utf8 length");
     return;
   }
 
@@ -301,8 +72,10 @@ void setup(const Napi::CallbackInfo &info) {
     // If the buffer is small enough, allocate it on the stack
     size_t config_cobhan_buffer_size_bytes =
         calculate_cobhan_buffer_size_bytes(config_utf8_byte_length);
-    debug_log_alloca("setup", "config_cobhan_buffer", config_cobhan_buffer_size_bytes);
+    debug_log_alloca("setup", "config_cobhan_buffer",
+                     config_cobhan_buffer_size_bytes);
     config_cobhan_buffer = (char *)alloca(config_cobhan_buffer_size_bytes);
+    configure_cbuffer(config_cobhan_buffer, config_utf8_byte_length);
   } else {
     // Otherwise, allocate it on the heap
     config_cobhan_buffer_unique_ptr =
@@ -310,7 +83,8 @@ void setup(const Napi::CallbackInfo &info) {
     config_cobhan_buffer = config_cobhan_buffer_unique_ptr.get();
   }
   if (unlikely(config_cobhan_buffer == nullptr)) {
-    LogErrorAndThrow(env, "setup", "Failed to allocate config cobhan buffer");
+    log_error_and_throw(env, "setup",
+                        "Failed to allocate config cobhan buffer");
     return;
   }
 
@@ -320,7 +94,7 @@ void setup(const Napi::CallbackInfo &info) {
       copy_nstring_to_cbuffer(env, config, config_utf8_byte_length,
                               config_cobhan_buffer, &config_copied_bytes);
   if (unlikely(config_cobhan_buffer == nullptr)) {
-    LogErrorAndThrow(env, "setup", "Failed to copy config to cobhan buffer");
+    log_error_and_throw(env, "setup", "Failed to copy config to cobhan buffer");
     return;
   }
 
@@ -337,7 +111,7 @@ void setup(const Napi::CallbackInfo &info) {
 
   if (unlikely(result < 0)) {
     // TODO: Convert this to a proper error message
-    LogErrorAndThrow(env, "setup", std::to_string(result));
+    log_error_and_throw(env, "setup", std::to_string(result));
     return;
   }
   setup_state = 1;
@@ -364,8 +138,7 @@ Napi::Value encrypt_to_json(Napi::Env &env, size_t partition_bytes,
     debug_log_alloca("encrypt_to_json", "output_cobhan_buffer",
                      output_cobhan_buffer_size_bytes);
     output_cobhan_buffer = (char *)alloca(output_cobhan_buffer_size_bytes);
-    configure_cbuffer(output_cobhan_buffer,
-                      asherah_output_size_bytes + safety_padding_bytes);
+    configure_cbuffer(output_cobhan_buffer, asherah_output_size_bytes);
   } else {
     // Otherwise, allocate it on the heap
     output_cobhan_buffer_unique_ptr = heap_allocate_cbuffer(
@@ -373,8 +146,8 @@ Napi::Value encrypt_to_json(Napi::Env &env, size_t partition_bytes,
     output_cobhan_buffer = output_cobhan_buffer_unique_ptr.get();
   }
   if (unlikely(output_cobhan_buffer == nullptr)) {
-    return LogErrorAndThrow(env, "encrypt_to_json",
-                            "Failed to allocate cobhan output buffer");
+    return log_error_and_throw(env, "encrypt_to_json",
+                               "Failed to allocate cobhan output buffer");
   }
 
   if (unlikely(verbose_flag)) {
@@ -392,7 +165,7 @@ Napi::Value encrypt_to_json(Napi::Env &env, size_t partition_bytes,
 
   if (unlikely(result < 0)) {
     // TODO: Convert this to a proper error message
-    return LogErrorAndThrow(env, "encrypt_to_json", std::to_string(result));
+    return log_error_and_throw(env, "encrypt_to_json", std::to_string(result));
   }
 
   Napi::Value output = cbuffer_to_nstring(env, output_cobhan_buffer);
@@ -407,15 +180,15 @@ Napi::Value encrypt(const Napi::CallbackInfo &info) {
   }
 
   if (unlikely(setup_state == 0)) {
-    return LogErrorAndThrow(env, "encrypt", "setup() not called");
+    return log_error_and_throw(env, "encrypt", "setup() not called");
   }
 
   if (unlikely(info.Length() < 2)) {
-    return LogErrorAndThrow(env, "encrypt", "Wrong number of arguments");
+    return log_error_and_throw(env, "encrypt", "Wrong number of arguments");
   }
 
   if (unlikely(!info[0].IsString() || !info[1].IsBuffer())) {
-    return LogErrorAndThrow(env, "encrypt", "Wrong argument types");
+    return log_error_and_throw(env, "encrypt", "Wrong argument types");
   }
 
   // Determine size
@@ -423,11 +196,11 @@ Napi::Value encrypt(const Napi::CallbackInfo &info) {
   Napi::String partition_id = info[0].As<Napi::String>();
   partition_utf8_byte_length = nstring_utf8_byte_length(env, partition_id);
   if (unlikely(partition_utf8_byte_length == (size_t)(-1))) {
-    return LogErrorAndThrow(env, "encrypt",
-                            "Failed to get partition_id utf8 length");
+    return log_error_and_throw(env, "encrypt",
+                               "Failed to get partition_id utf8 length");
   }
   if (unlikely(partition_utf8_byte_length == 0)) {
-    return LogErrorAndThrow(env, "encrypt", "partition_id is empty");
+    return log_error_and_throw(env, "encrypt", "partition_id is empty");
   }
 
   // Allocate
@@ -437,8 +210,11 @@ Napi::Value encrypt(const Napi::CallbackInfo &info) {
     // If the buffer is small enough, allocate it on the stack
     size_t partition_id_cobhan_buffer_size_bytes =
         calculate_cobhan_buffer_size_bytes(partition_utf8_byte_length);
-    debug_log_alloca("encrypt", "partition_id_cobhan_buffer", partition_id_cobhan_buffer_size_bytes);
-    partition_id_cobhan_buffer = (char *)alloca(partition_id_cobhan_buffer_size_bytes);
+    debug_log_alloca("encrypt", "partition_id_cobhan_buffer",
+                     partition_id_cobhan_buffer_size_bytes);
+    partition_id_cobhan_buffer =
+        (char *)alloca(partition_id_cobhan_buffer_size_bytes);
+    configure_cbuffer(partition_id_cobhan_buffer, partition_utf8_byte_length);
   } else {
     // Otherwise, allocate it on the heap
     partition_id_cobhan_buffer_unique_ptr = heap_allocate_cbuffer(
@@ -446,8 +222,8 @@ Napi::Value encrypt(const Napi::CallbackInfo &info) {
     partition_id_cobhan_buffer = partition_id_cobhan_buffer_unique_ptr.get();
   }
   if (unlikely(partition_id_cobhan_buffer == nullptr)) {
-    return LogErrorAndThrow(env, "encrypt",
-                            "Failed to allocate partitionId cobhan buffer");
+    return log_error_and_throw(env, "encrypt",
+                               "Failed to allocate partitionId cobhan buffer");
   }
 
   // Copy
@@ -456,8 +232,8 @@ Napi::Value encrypt(const Napi::CallbackInfo &info) {
       env, partition_id, partition_utf8_byte_length, partition_id_cobhan_buffer,
       &partition_copied_bytes);
   if (unlikely(partition_id_cobhan_buffer == nullptr)) {
-    return LogErrorAndThrow(env, "encrypt",
-                            "Failed to copy partitionId to cobhan buffer");
+    return log_error_and_throw(env, "encrypt",
+                               "Failed to copy partitionId to cobhan buffer");
   }
 
   // Determine size
@@ -465,7 +241,7 @@ Napi::Value encrypt(const Napi::CallbackInfo &info) {
       info[1].As<Napi::Buffer<unsigned char>>();
   size_t input_byte_length = input_napi_buffer.ByteLength();
   if (unlikely(input_byte_length == 0)) {
-    return LogErrorAndThrow(env, "encrypt", "input is empty");
+    return log_error_and_throw(env, "encrypt", "input is empty");
   }
 
   // Allocate
@@ -478,6 +254,7 @@ Napi::Value encrypt(const Napi::CallbackInfo &info) {
     debug_log_alloca("encrypt", "input_cobhan_buffer",
                      input_cobhan_buffer_size_bytes);
     input_cobhan_buffer = (char *)alloca(input_cobhan_buffer_size_bytes);
+    configure_cbuffer(input_cobhan_buffer, input_byte_length);
   } else {
     // Otherwise, allocate it on the heap
     input_buffer_unique_ptr =
@@ -485,17 +262,27 @@ Napi::Value encrypt(const Napi::CallbackInfo &info) {
     input_cobhan_buffer = input_buffer_unique_ptr.get();
   }
   if (unlikely(input_cobhan_buffer == nullptr)) {
-    return LogErrorAndThrow(
+    return log_error_and_throw(
         env, "encrypt", "Failed to allocate cobhan buffer for input buffer");
   }
 
   // Copy
-  memcpy(input_cobhan_buffer + cobhan_header_size_bytes,
-         input_napi_buffer.Data(), input_byte_length);
-  configure_cbuffer(input_cobhan_buffer, input_byte_length);
+  input_cobhan_buffer =
+      copy_nbuffer_to_cbuffer(env, input_napi_buffer, input_cobhan_buffer);
+  if (unlikely(input_cobhan_buffer == nullptr)) {
+    return log_error_and_throw(env, "encrypt",
+                               "Failed to copy input buffer to cobhan buffer");
+  }
+
+  Napi::Value output =
+      encrypt_to_json(env, partition_copied_bytes, input_byte_length,
+                      partition_id_cobhan_buffer, input_cobhan_buffer);
+
+  if (unlikely(verbose_flag)) {
+    debug_log("encrypt", "finished");
+  }
 
-  return encrypt_to_json(env, partition_copied_bytes, input_byte_length,
-                         partition_id_cobhan_buffer, input_cobhan_buffer);
+  return output;
 }
 
 Napi::Value encrypt_string(const Napi::CallbackInfo &info) {
@@ -506,15 +293,16 @@ Napi::Value encrypt_string(const Napi::CallbackInfo &info) {
   }
 
   if (unlikely(setup_state == 0)) {
-    return LogErrorAndThrow(env, "encrypt_string", "setup() not called");
+    return log_error_and_throw(env, "encrypt_string", "setup() not called");
   }
 
   if (unlikely(info.Length() < 2)) {
-    return LogErrorAndThrow(env, "encrypt_string", "Wrong number of arguments");
+    return log_error_and_throw(env, "encrypt_string",
+                               "Wrong number of arguments");
   }
 
   if (unlikely(!info[0].IsString() || !info[1].IsString())) {
-    return LogErrorAndThrow(env, "encrypt_string", "Wrong argument types");
+    return log_error_and_throw(env, "encrypt_string", "Wrong argument types");
   }
 
   // Determine size
@@ -522,11 +310,11 @@ Napi::Value encrypt_string(const Napi::CallbackInfo &info) {
   Napi::String partition_id = info[0].As<Napi::String>();
   partition_utf8_byte_length = nstring_utf8_byte_length(env, partition_id);
   if (unlikely(partition_utf8_byte_length == (size_t)(-1))) {
-    return LogErrorAndThrow(env, "encrypt_string",
-                            "Failed to get partition_id utf8 length");
+    return log_error_and_throw(env, "encrypt_string",
+                               "Failed to get partition_id utf8 length");
   }
   if (unlikely(partition_utf8_byte_length == 0)) {
-    return LogErrorAndThrow(env, "encrypt_string", "partition_id is empty");
+    return log_error_and_throw(env, "encrypt_string", "partition_id is empty");
   }
 
   // Allocate
@@ -538,7 +326,9 @@ Napi::Value encrypt_string(const Napi::CallbackInfo &info) {
         calculate_cobhan_buffer_size_bytes(partition_utf8_byte_length);
     debug_log_alloca("encrypt_string", "partition_id_cobhan_buffer",
                      partition_id_cobhan_buffer_size_bytes);
-    partition_id_cobhan_buffer = (char *)alloca(partition_id_cobhan_buffer_size_bytes);
+    partition_id_cobhan_buffer =
+        (char *)alloca(partition_id_cobhan_buffer_size_bytes);
+    configure_cbuffer(partition_id_cobhan_buffer, partition_utf8_byte_length);
   } else {
     // Otherwise, allocate it on the heap
     partition_id_cobhan_buffer_unique_ptr = heap_allocate_cbuffer(
@@ -546,8 +336,8 @@ Napi::Value encrypt_string(const Napi::CallbackInfo &info) {
     partition_id_cobhan_buffer = partition_id_cobhan_buffer_unique_ptr.get();
   }
   if (unlikely(partition_id_cobhan_buffer == nullptr)) {
-    return LogErrorAndThrow(env, "encrypt_string",
-                            "Failed to allocate partitionId cobhan buffer");
+    return log_error_and_throw(env, "encrypt_string",
+                               "Failed to allocate partitionId cobhan buffer");
   }
 
   // Copy
@@ -556,8 +346,8 @@ Napi::Value encrypt_string(const Napi::CallbackInfo &info) {
       env, partition_id, partition_utf8_byte_length, partition_id_cobhan_buffer,
       &partition_copied_bytes);
   if (unlikely(partition_id_cobhan_buffer == nullptr)) {
-    return LogErrorAndThrow(env, "encrypt_string",
-                            "Failed to copy partitionId to cobhan buffer");
+    return log_error_and_throw(env, "encrypt_string",
+                               "Failed to copy partitionId to cobhan buffer");
   }
 
   // Determine size
@@ -565,11 +355,11 @@ Napi::Value encrypt_string(const Napi::CallbackInfo &info) {
   Napi::String input = info[1].As<Napi::String>();
   input_utf8_byte_length = nstring_utf8_byte_length(env, input);
   if (unlikely(input_utf8_byte_length == (size_t)(-1))) {
-    return LogErrorAndThrow(env, "encrypt_string",
-                            "Failed to get input utf8 length");
+    return log_error_and_throw(env, "encrypt_string",
+                               "Failed to get input utf8 length");
   }
   if (unlikely(input_utf8_byte_length == 0)) {
-    return LogErrorAndThrow(env, "encrypt_string", "input is empty");
+    return log_error_and_throw(env, "encrypt_string", "input is empty");
   }
 
   // Allocate
@@ -579,8 +369,10 @@ Napi::Value encrypt_string(const Napi::CallbackInfo &info) {
     // If the buffer is small enough, allocate it on the stack
     size_t input_cobhan_buffer_size_bytes =
         calculate_cobhan_buffer_size_bytes(input_utf8_byte_length);
-    debug_log_alloca("encrypt_string", "input_cobhan_buffer", input_cobhan_buffer_size_bytes);
+    debug_log_alloca("encrypt_string", "input_cobhan_buffer",
+                     input_cobhan_buffer_size_bytes);
     input_cobhan_buffer = (char *)alloca(input_cobhan_buffer_size_bytes);
+    configure_cbuffer(input_cobhan_buffer, input_utf8_byte_length);
   } else {
     // Otherwise, allocate it on the heap
     input_cobhan_buffer_unique_ptr =
@@ -588,8 +380,8 @@ Napi::Value encrypt_string(const Napi::CallbackInfo &info) {
     input_cobhan_buffer = input_cobhan_buffer_unique_ptr.get();
   }
   if (unlikely(input_cobhan_buffer == nullptr)) {
-    return LogErrorAndThrow(env, "encrypt_string",
-                            "Failed to allocate input cobhan buffer");
+    return log_error_and_throw(env, "encrypt_string",
+                               "Failed to allocate input cobhan buffer");
   }
 
   // Copy
@@ -598,12 +390,19 @@ Napi::Value encrypt_string(const Napi::CallbackInfo &info) {
       copy_nstring_to_cbuffer(env, input, input_utf8_byte_length,
                               input_cobhan_buffer, &input_copied_bytes);
   if (unlikely(input_cobhan_buffer == nullptr)) {
-    return LogErrorAndThrow(env, "encrypt_string",
-                            "Failed to copy input to cobhan buffer");
+    return log_error_and_throw(env, "encrypt_string",
+                               "Failed to copy input to cobhan buffer");
   }
 
-  return encrypt_to_json(env, partition_copied_bytes, input_utf8_byte_length,
-                         partition_id_cobhan_buffer, input_cobhan_buffer);
+  Napi::Value output =
+      encrypt_to_json(env, partition_copied_bytes, input_utf8_byte_length,
+                      partition_id_cobhan_buffer, input_cobhan_buffer);
+
+  if (unlikely(verbose_flag)) {
+    debug_log("encrypt_string", "finished");
+  }
+
+  return output;
 }
 
 Napi::Value decrypt(const Napi::CallbackInfo &info) {
@@ -614,15 +413,15 @@ Napi::Value decrypt(const Napi::CallbackInfo &info) {
   }
 
   if (unlikely(setup_state == 0)) {
-    return LogErrorAndThrow(env, "decrypt", "setup() not called");
+    return log_error_and_throw(env, "decrypt", "setup() not called");
   }
 
   if (unlikely(info.Length() < 2)) {
-    return LogErrorAndThrow(env, "decrypt", "Wrong number of arguments");
+    return log_error_and_throw(env, "decrypt", "Wrong number of arguments");
   }
 
   if (unlikely(!info[0].IsString() || !info[1].IsString())) {
-    return LogErrorAndThrow(env, "decrypt", "Wrong argument types");
+    return log_error_and_throw(env, "decrypt", "Wrong argument types");
   }
 
   // Determine size
@@ -630,11 +429,11 @@ Napi::Value decrypt(const Napi::CallbackInfo &info) {
   Napi::String partition_id = info[0].As<Napi::String>();
   partition_utf8_byte_length = nstring_utf8_byte_length(env, partition_id);
   if (unlikely(partition_utf8_byte_length == (size_t)(-1))) {
-    return LogErrorAndThrow(env, "decrypt",
-                            "Failed to get partition_id utf8 length");
+    return log_error_and_throw(env, "decrypt",
+                               "Failed to get partition_id utf8 length");
   }
   if (unlikely(partition_utf8_byte_length == 0)) {
-    return LogErrorAndThrow(env, "decrypt", "partition_id is empty");
+    return log_error_and_throw(env, "decrypt", "partition_id is empty");
   }
 
   // Allocate
@@ -648,6 +447,7 @@ Napi::Value decrypt(const Napi::CallbackInfo &info) {
                      partition_id_cobhan_buffer_size_bytes);
     partition_id_cobhan_buffer =
         (char *)alloca(partition_id_cobhan_buffer_size_bytes);
+    configure_cbuffer(partition_id_cobhan_buffer, partition_utf8_byte_length);
   } else {
     // Otherwise, allocate it on the heap
     partition_id_cobhan_buffer_unique_ptr = heap_allocate_cbuffer(
@@ -655,8 +455,8 @@ Napi::Value decrypt(const Napi::CallbackInfo &info) {
     partition_id_cobhan_buffer = partition_id_cobhan_buffer_unique_ptr.get();
   }
   if (unlikely(partition_id_cobhan_buffer == nullptr)) {
-    return LogErrorAndThrow(env, "decrypt",
-                            "Failed to allocate partition_id cobhan buffer");
+    return log_error_and_throw(env, "decrypt",
+                               "Failed to allocate partition_id cobhan buffer");
   }
 
   // Copy
@@ -664,8 +464,8 @@ Napi::Value decrypt(const Napi::CallbackInfo &info) {
       env, partition_id, partition_utf8_byte_length, partition_id_cobhan_buffer,
       &partition_copied_bytes);
   if (unlikely(partition_id_cobhan_buffer == nullptr)) {
-    return LogErrorAndThrow(env, "decrypt",
-                            "Failed to copy partition_id to cobhan buffer");
+    return log_error_and_throw(env, "decrypt",
+                               "Failed to copy partition_id to cobhan buffer");
   }
 
   // Determine size
@@ -673,10 +473,11 @@ Napi::Value decrypt(const Napi::CallbackInfo &info) {
   Napi::String input = info[1].As<Napi::String>();
   input_utf8_byte_length = nstring_utf8_byte_length(env, input);
   if (unlikely(input_utf8_byte_length == (size_t)(-1))) {
-    return LogErrorAndThrow(env, "decrypt", "Failed to get input utf8 length");
+    return log_error_and_throw(env, "decrypt",
+                               "Failed to get input utf8 length");
   }
   if (unlikely(input_utf8_byte_length == 0)) {
-    return LogErrorAndThrow(env, "decrypt", "input is empty");
+    return log_error_and_throw(env, "decrypt", "input is empty");
   }
 
   if (unlikely(verbose_flag)) {
@@ -694,6 +495,7 @@ Napi::Value decrypt(const Napi::CallbackInfo &info) {
     debug_log_alloca("decrypt", "input_cobhan_buffer",
                      input_cobhan_buffer_size_bytes);
     input_cobhan_buffer = (char *)alloca(input_cobhan_buffer_size_bytes);
+    configure_cbuffer(input_cobhan_buffer, input_utf8_byte_length);
   } else {
     // Otherwise, allocate it on the heap
     input_cobhan_buffer_unique_ptr =
@@ -701,8 +503,8 @@ Napi::Value decrypt(const Napi::CallbackInfo &info) {
     input_cobhan_buffer = input_cobhan_buffer_unique_ptr.get();
   }
   if (unlikely(input_cobhan_buffer == nullptr)) {
-    return LogErrorAndThrow(env, "decrypt",
-                            "Failed to allocate input cobhan buffer");
+    return log_error_and_throw(env, "decrypt",
+                               "Failed to allocate input cobhan buffer");
   }
 
   // Copy
@@ -711,8 +513,8 @@ Napi::Value decrypt(const Napi::CallbackInfo &info) {
       copy_nstring_to_cbuffer(env, input, input_utf8_byte_length,
                               input_cobhan_buffer, &input_copied_bytes);
   if (unlikely(input_cobhan_buffer == nullptr)) {
-    return LogErrorAndThrow(env, "decrypt",
-                            "Failed to copy input to cobhan buffer");
+    return log_error_and_throw(env, "decrypt",
+                               "Failed to copy input to cobhan buffer");
   }
 
   char *output_cobhan_buffer;
@@ -732,8 +534,8 @@ Napi::Value decrypt(const Napi::CallbackInfo &info) {
     output_cobhan_buffer = output_cobhan_buffer_unique_ptr.get();
   }
   if (unlikely(output_cobhan_buffer == nullptr)) {
-    return LogErrorAndThrow(env, "decrypt",
-                            "Failed to allocate cobhan output buffer");
+    return log_error_and_throw(env, "decrypt",
+                               "Failed to allocate cobhan output buffer");
   }
 
   if (unlikely(verbose_flag)) {
@@ -751,10 +553,16 @@ Napi::Value decrypt(const Napi::CallbackInfo &info) {
 
   if (unlikely(result < 0)) {
     // TODO: Convert this to a proper error message
-    return LogErrorAndThrow(env, "decrypt", std::to_string(result));
+    return log_error_and_throw(env, "decrypt", std::to_string(result));
   }
 
-  return cbuffer_to_nbuffer(env, output_cobhan_buffer);
+  Napi::Value output = cbuffer_to_nbuffer(env, output_cobhan_buffer);
+
+  if (unlikely(verbose_flag)) {
+    debug_log("decrypt", "finished");
+  }
+
+  return output;
 }
 
 Napi::Value decrypt_string(const Napi::CallbackInfo &info) {
@@ -765,15 +573,16 @@ Napi::Value decrypt_string(const Napi::CallbackInfo &info) {
   }
 
   if (unlikely(setup_state == 0)) {
-    return LogErrorAndThrow(env, "decrypt_string", "setup() not called");
+    return log_error_and_throw(env, "decrypt_string", "setup() not called");
   }
 
   if (unlikely(info.Length() < 2)) {
-    return LogErrorAndThrow(env, "decrypt_string", "Wrong number of arguments");
+    return log_error_and_throw(env, "decrypt_string",
+                               "Wrong number of arguments");
   }
 
   if (unlikely(!info[0].IsString() || !info[1].IsString())) {
-    return LogErrorAndThrow(env, "decrypt_string", "Wrong argument types");
+    return log_error_and_throw(env, "decrypt_string", "Wrong argument types");
   }
 
   // Determine size
@@ -781,11 +590,11 @@ Napi::Value decrypt_string(const Napi::CallbackInfo &info) {
   Napi::String partition_id = info[0].As<Napi::String>();
   partition_utf8_byte_length = nstring_utf8_byte_length(env, partition_id);
   if (unlikely(partition_utf8_byte_length == (size_t)(-1))) {
-    return LogErrorAndThrow(env, "decrypt_string",
-                            "Failed to get partition_id utf8 length");
+    return log_error_and_throw(env, "decrypt_string",
+                               "Failed to get partition_id utf8 length");
   }
   if (unlikely(partition_utf8_byte_length == 0)) {
-    return LogErrorAndThrow(env, "decrypt_string", "partition_id is empty");
+    return log_error_and_throw(env, "decrypt_string", "partition_id is empty");
   }
 
   // Allocate
@@ -799,6 +608,7 @@ Napi::Value decrypt_string(const Napi::CallbackInfo &info) {
                      partition_id_cobhan_buffer_size_bytes);
     partition_id_cobhan_buffer =
         (char *)alloca(partition_id_cobhan_buffer_size_bytes);
+    configure_cbuffer(partition_id_cobhan_buffer, partition_utf8_byte_length);
   } else {
     // Otherwise, allocate it on the heap
     partition_id_cobhan_buffer_unique_ptr = heap_allocate_cbuffer(
@@ -806,8 +616,8 @@ Napi::Value decrypt_string(const Napi::CallbackInfo &info) {
     partition_id_cobhan_buffer = partition_id_cobhan_buffer_unique_ptr.get();
   }
   if (unlikely(partition_id_cobhan_buffer == nullptr)) {
-    return LogErrorAndThrow(env, "decrypt_string",
-                            "Failed to allocate partitionId cobhan buffer");
+    return log_error_and_throw(env, "decrypt_string",
+                               "Failed to allocate partitionId cobhan buffer");
   }
 
   // Copy
@@ -816,8 +626,8 @@ Napi::Value decrypt_string(const Napi::CallbackInfo &info) {
       env, partition_id, partition_utf8_byte_length, partition_id_cobhan_buffer,
       &partition_copied_bytes);
   if (unlikely(partition_id_cobhan_buffer == nullptr)) {
-    return LogErrorAndThrow(env, "decrypt_string",
-                            "Failed to copy partitionId to cobhan buffer");
+    return log_error_and_throw(env, "decrypt_string",
+                               "Failed to copy partitionId to cobhan buffer");
   }
 
   // Determine size
@@ -825,11 +635,11 @@ Napi::Value decrypt_string(const Napi::CallbackInfo &info) {
   Napi::String input = info[1].As<Napi::String>();
   input_utf8_byte_length = nstring_utf8_byte_length(env, input);
   if (unlikely(input_utf8_byte_length == (size_t)(-1))) {
-    return LogErrorAndThrow(env, "decrypt_string",
-                            "Failed to get input utf8 length");
+    return log_error_and_throw(env, "decrypt_string",
+                               "Failed to get input utf8 length");
   }
   if (unlikely(input_utf8_byte_length == 0)) {
-    return LogErrorAndThrow(env, "decrypt_string", "input is empty");
+    return log_error_and_throw(env, "decrypt_string", "input is empty");
   }
 
   // Allocate
@@ -842,6 +652,7 @@ Napi::Value decrypt_string(const Napi::CallbackInfo &info) {
     debug_log_alloca("decrypt_string", "input_cobhan_buffer",
                      input_cobhan_buffer_size_bytes);
     input_cobhan_buffer = (char *)alloca(input_cobhan_buffer_size_bytes);
+    configure_cbuffer(input_cobhan_buffer, input_utf8_byte_length);
   } else {
     // Otherwise, allocate it on the heap
     input_cobhan_buffer_unique_ptr =
@@ -849,8 +660,8 @@ Napi::Value decrypt_string(const Napi::CallbackInfo &info) {
     input_cobhan_buffer = input_cobhan_buffer_unique_ptr.get();
   }
   if (unlikely(input_cobhan_buffer == nullptr)) {
-    return LogErrorAndThrow(env, "decrypt_string",
-                            "Failed to allocate input cobhan buffer");
+    return log_error_and_throw(env, "decrypt_string",
+                               "Failed to allocate input cobhan buffer");
   }
 
   // Copy
@@ -859,8 +670,8 @@ Napi::Value decrypt_string(const Napi::CallbackInfo &info) {
       copy_nstring_to_cbuffer(env, input, input_utf8_byte_length,
                               input_cobhan_buffer, &input_copied_bytes);
   if (unlikely(input_cobhan_buffer == nullptr)) {
-    return LogErrorAndThrow(env, "decrypt_string",
-                            "Failed to copy input to cobhan buffer");
+    return log_error_and_throw(env, "decrypt_string",
+                               "Failed to copy input to cobhan buffer");
   }
 
   char *output_cobhan_buffer;
@@ -880,8 +691,8 @@ Napi::Value decrypt_string(const Napi::CallbackInfo &info) {
     output_cobhan_buffer = output_cobhan_buffer_unique_ptr.get();
   }
   if (unlikely(output_cobhan_buffer == nullptr)) {
-    return LogErrorAndThrow(env, "decrypt_string",
-                            "Failed to allocate cobhan output buffer");
+    return log_error_and_throw(env, "decrypt_string",
+                               "Failed to allocate cobhan output buffer");
   }
 
   if (unlikely(verbose_flag)) {
@@ -899,10 +710,15 @@ Napi::Value decrypt_string(const Napi::CallbackInfo &info) {
 
   if (unlikely(result < 0)) {
     // TODO: Convert this to a proper error message
-    return LogErrorAndThrow(env, "decrypt_string", std::to_string(result));
+    return log_error_and_throw(env, "decrypt_string", std::to_string(result));
   }
 
   Napi::Value output = cbuffer_to_nstring(env, output_cobhan_buffer);
+
+  if (unlikely(verbose_flag)) {
+    debug_log("decrypt_string", "finished");
+  }
+
   return output;
 }
 
@@ -933,8 +749,8 @@ void set_max_stack_alloc_item_size(const Napi::CallbackInfo &info) {
   }
 
   if (unlikely(info.Length() < 1)) {
-    LogErrorAndThrow(env, "set_max_stack_alloc_item_size",
-                     "Wrong number of arguments");
+    log_error_and_throw(env, "set_max_stack_alloc_item_size",
+                        "Wrong number of arguments");
     return;
   }
 
@@ -951,8 +767,8 @@ void set_safety_padding_overhead(const Napi::CallbackInfo &info) {
   }
 
   if (unlikely(info.Length() < 1)) {
-    LogErrorAndThrow(env, "set_safety_padding_overhead",
-                     "Wrong number of arguments");
+    log_error_and_throw(env, "set_safety_padding_overhead",
+                        "Wrong number of arguments");
     return;
   }
 

package/src/cobhan_napi_interop.cc

@@ -0,0 +1,3 @@
+#include <stddef.h>
+size_t est_intermediate_key_overhead = 0;
+size_t safety_padding_bytes = 0;

package/src/cobhan_napi_interop.h

@@ -0,0 +1,285 @@
+#ifndef COBHAN_NAPI_INTEROP_H
+#define COBHAN_NAPI_INTEROP_H
+#include <string>
+#define NODE_ADDON_API_DISABLE_DEPRECATED
+#include "hints.h"
+#include "logging.h"
+#include <napi.h>
+
+extern size_t est_intermediate_key_overhead;
+extern size_t safety_padding_bytes;
+
+const size_t est_encryption_overhead = 48;
+const size_t est_envelope_overhead = 185;
+const double base64_overhead = 1.34;
+
+const size_t cobhan_header_size_bytes = 64 / 8;
+
+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";
+  }
+}
+
+__attribute__((always_inline)) inline int32_t
+cbuffer_byte_length(char *cobhan_buffer) {
+  return *((int32_t *)cobhan_buffer);
+}
+
+__attribute__((always_inline)) inline Napi::Value
+log_error_and_throw(Napi::Env &env, const char *function_name,
+                    std::string error_msg) {
+  error_log(function_name, error_msg);
+  Napi::Error::New(env, function_name + (": " + error_msg))
+      .ThrowAsJavaScriptException();
+  return env.Null();
+}
+
+__attribute__((always_inline)) inline size_t
+calculate_cobhan_buffer_size_bytes(size_t data_len_bytes) {
+  return data_len_bytes + cobhan_header_size_bytes + safety_padding_bytes +
+         1; // Add one for possible NULL delimiter due to Node string functions
+}
+
+__attribute__((always_inline)) inline size_t
+estimate_asherah_output_size_bytes(size_t data_byte_len,
+                                   size_t partition_byte_len) {
+  // 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 + safety_padding_bytes);
+  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("estimate_asherah_output_size", log_msg);
+  }
+  return asherah_output_size_bytes;
+}
+
+__attribute__((always_inline)) inline void configure_cbuffer(char *buffer,
+                                                             size_t length) {
+  *((int32_t *)buffer) = length;
+  // Reserved for future use
+  *((int32_t *)(buffer + sizeof(int32_t))) = 0;
+}
+
+__attribute__((always_inline)) inline std::unique_ptr<char[]>
+heap_allocate_cbuffer(const char *variable_name, size_t size_bytes) {
+  size_t cobhan_buffer_size_bytes =
+      calculate_cobhan_buffer_size_bytes(size_bytes);
+  if (unlikely(verbose_flag)) {
+    std::string log_msg =
+        "heap_allocate_cbuffer(" + std::to_string(size_bytes) +
+        ") (heap) cobhan_buffer_size_bytes: " +
+        std::to_string(cobhan_buffer_size_bytes) + " for " + variable_name;
+    debug_log("allocate_cbuffer", log_msg);
+  }
+
+  char *cobhan_buffer = new (std::nothrow) char[cobhan_buffer_size_bytes];
+  if (unlikely(cobhan_buffer == nullptr)) {
+    std::string error_msg =
+        "new[" + std::to_string(cobhan_buffer_size_bytes) + " returned null";
+    error_log("allocate_cbuffer", error_msg);
+    return nullptr;
+  }
+  std::unique_ptr<char[]> cobhan_buffer_unique_ptr(cobhan_buffer);
+  configure_cbuffer(cobhan_buffer, size_bytes + safety_padding_bytes);
+  return cobhan_buffer_unique_ptr;
+}
+
+__attribute__((always_inline)) inline Napi::Value
+cbuffer_to_nstring(Napi::Env &env, char *cobhan_buffer) {
+  napi_value output;
+
+  int32_t cobhan_buffer_size_bytes = cbuffer_byte_length(cobhan_buffer);
+  if (cobhan_buffer_size_bytes <= 0) {
+    return log_error_and_throw(env, "cbuffer_to_nstring",
+                               "Invalid cobhan buffer byte length");
+  }
+
+  // Using C function because it allows length delimited input
+  napi_status status = napi_create_string_utf8(
+      env, ((const char *)cobhan_buffer) + cobhan_header_size_bytes,
+      cobhan_buffer_size_bytes, &output);
+
+  if (unlikely(status != napi_ok)) {
+    return log_error_and_throw(env, "cbuffer_to_nstring",
+                               "napi_create_string_utf8 failed: " +
+                                   napi_status_to_string(status));
+  }
+
+  return Napi::String(env, output);
+}
+
+__attribute__((always_inline)) inline size_t
+nstring_utf8_byte_length(Napi::Env &env, Napi::String &str) {
+  napi_status status;
+  size_t utf8_length;
+
+  status = napi_get_value_string_utf8(env, str, nullptr, 0, &utf8_length);
+  if (unlikely(status != napi_ok)) {
+    log_error_and_throw(env, "nstring_utf8_length",
+                        "napi_get_value_string_utf8 length check failed: " +
+                            napi_status_to_string(status));
+    return (size_t)(-1);
+  }
+
+  return utf8_length;
+}
+
+__attribute__((always_inline)) inline char *
+copy_nstring_to_cbuffer(Napi::Env &env, Napi::String &str,
+                        size_t str_utf8_byte_length, char *cobhan_buffer,
+                        size_t *byte_length = nullptr) {
+
+  size_t cobhan_buffer_size_bytes = cbuffer_byte_length(cobhan_buffer);
+  if (unlikely(cobhan_buffer_size_bytes <= 0)) {
+    log_error_and_throw(env, "copy_nstring_to_cbuffer",
+                        "Invalid cobhan buffer byte length");
+    return nullptr;
+  }
+
+  if (cobhan_buffer_size_bytes < str_utf8_byte_length) {
+    log_error_and_throw(env, "copy_nstring_to_cbuffer",
+                        "String too large for cobhan buffer");
+    return nullptr;
+  }
+
+  napi_status status;
+  size_t copied_bytes;
+  // NOTE: This implementation relies on the additional byte that is reserved
+  // upon allocation for a NULL delimiter as methods like
+  // napi_get_value_string_utf8 append a NULL delimiter
+  status = napi_get_value_string_utf8(env, str,
+                                      cobhan_buffer + cobhan_header_size_bytes,
+                                      str_utf8_byte_length + 1, &copied_bytes);
+  if (unlikely(status != napi_ok)) {
+    log_error_and_throw(env, "copy_nstring_to_cbuffer",
+                        "Napi utf8 string conversion failure: " +
+                            napi_status_to_string(status));
+    return nullptr;
+  }
+
+  if (unlikely(copied_bytes != str_utf8_byte_length)) {
+    log_error_and_throw(env, "copy_nstring_to_cbuffer",
+                        "Did not copy expected number of bytes " +
+                            std::to_string(str_utf8_byte_length) + " copied " +
+                            std::to_string(copied_bytes));
+    return nullptr;
+  }
+
+  configure_cbuffer(cobhan_buffer, copied_bytes);
+
+  if (byte_length != nullptr)
+    *byte_length = copied_bytes;
+  return cobhan_buffer;
+}
+
+__attribute__((always_inline)) inline char *
+copy_nbuffer_to_cbuffer(Napi::Env &env, Napi::Buffer<unsigned char> &nbuffer,
+                        char *cobhan_buffer) {
+
+  int32_t cobhan_buffer_size_bytes = cbuffer_byte_length(cobhan_buffer);
+  if (unlikely(cobhan_buffer_size_bytes <= 0)) {
+    log_error_and_throw(env, "copy_nbuffer_to_cbuffer",
+                        "Invalid cobhan buffer byte length");
+    return nullptr;
+  }
+
+  size_t nbuffer_byte_length = nbuffer.ByteLength();
+  if (nbuffer_byte_length > INT32_MAX ||
+      cobhan_buffer_size_bytes < (int32_t)nbuffer_byte_length) {
+    log_error_and_throw(env, "copy_nbuffer_to_cbuffer",
+                        "Buffer too large for cobhan buffer");
+    return nullptr;
+  }
+  memcpy(cobhan_buffer + cobhan_header_size_bytes, nbuffer.Data(),
+         nbuffer_byte_length);
+  configure_cbuffer(cobhan_buffer, nbuffer_byte_length);
+  return cobhan_buffer;
+}
+
+__attribute__((always_inline)) inline Napi::Value
+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)) {
+    return log_error_and_throw(env, "cbuffer_to_nbuffer",
+                               "Invalid cobhan buffer byte length");
+  }
+
+  if (unlikely(verbose_flag)) {
+    debug_log("cbuffer_to_nbuffer",
+              "cbuffer_byte_length: " +
+                  std::to_string(cobhan_buffer_byte_length));
+  }
+
+  if (unlikely(cobhan_buffer_byte_length <= 0)) {
+    log_error_and_throw(env, "cbuffer_to_nbuffer",
+                        "Invalid cobhan buffer byte length");
+  }
+
+  Napi::Buffer nbuffer = Napi::Buffer<unsigned char>::Copy(
+      env, ((unsigned char *)cobhan_buffer) + cobhan_header_size_bytes,
+      cobhan_buffer_byte_length);
+
+  if (unlikely(verbose_flag)) {
+    debug_log("cbuffer_to_nbuffer",
+              "nbuffer.ByteLength(): " + std::to_string(nbuffer.ByteLength()));
+  }
+
+  return nbuffer;
+}
+
+#endif

package/src/hints.h

@@ -0,0 +1,7 @@
+#ifndef HINTS_H
+#define HINTS_H
+
+#define unlikely(expr) __builtin_expect(!!(expr), 0)
+#define likely(expr) __builtin_expect(!!(expr), 1)
+
+#endif

package/src/logging.cc

@@ -0,0 +1,2 @@
+#include <cstdint>
+int32_t verbose_flag = 0;

package/src/logging.h

@@ -0,0 +1,38 @@
+#ifndef LOGGING_H
+#define LOGGING_H
+#include "hints.h"
+#include <cstdint>
+#include <string>
+
+extern int32_t verbose_flag;
+
+__attribute__((always_inline)) inline void debug_log(const char *function_name,
+                                                     std::string message) {
+  if (unlikely(verbose_flag)) {
+    std::cerr << "asherah-node: [DEBUG] " << function_name << ": " << message
+              << std::endl
+              << std::flush;
+  }
+}
+
+__attribute__((always_inline)) inline void
+debug_log_alloca(const char *function_name, const char *variable_name,
+                 size_t length) {
+  if (unlikely(verbose_flag)) {
+    std::cerr << "asherah-node: [DEBUG] " << function_name
+              << ": Calling alloca(" << length << ") (stack) for "
+              << variable_name << std::endl
+              << std::flush;
+  }
+}
+
+__attribute__((always_inline)) inline void error_log(const char *function_name,
+                                                     std::string message) {
+  if (unlikely(verbose_flag)) {
+    std::cerr << "asherah-node: [ERROR] " << function_name << ": " << message
+              << std::endl
+              << std::flush;
+  }
+}
+
+#endif