asherah 1.3.18 → 1.3.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "asherah",
-  "version": "1.3.18",
+  "version": "1.3.20",
   "description": "Asherah envelope encryption and key rotation library",
   "exports": {
     "node-addons": "./dist/asherah.node"

package/scripts/download-libraries.sh

@@ -4,8 +4,8 @@ echo "Downloading Asherah libraries"
 
 source .asherah-version
 
-rm -rf lib
-mkdir lib
+#rm -rf lib
+mkdir -p lib
 cd lib || exit 1
 
 OS=$(uname)
@@ -51,5 +51,5 @@ curl -s -L --fail -O --retry 999 --retry-max-time 0 "https://github.com/godaddy/
 grep -e "${ARCHIVE}" -e "${HEADER}" "${SUMS}" > ./SHA256SUM
 #shasum -a 256 -c ./SHA256SUM || (echo 'SHA256 mismatch!' ; rm -f ./*.a ./*.h ; exit 1)
 
-mv "${ARCHIVE}" libasherah.a
-mv "${HEADER}" libasherah.h
+mv -f "${ARCHIVE}" libasherah.a
+mv -f "${HEADER}" libasherah.h

package/src/asherah.cc

@@ -17,12 +17,10 @@ void setup(const Napi::CallbackInfo &info) {
 
   if (unlikely(setup_state == 1)) {
     log_error_and_throw(env, "setup", "setup called twice");
-    return;
   }
 
   if (unlikely(info.Length() < 1)) {
     log_error_and_throw(env, "setup", "Wrong number of arguments");
-    return;
   }
 
   Napi::String config;
@@ -38,13 +36,12 @@ void setup(const Napi::CallbackInfo &info) {
     config_json = parse.Call(json, {config}).As<Napi::Object>();
   } else {
     log_error_and_throw(env, "setup", "Wrong argument type");
-    return;
   }
 
   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 =
+  *est_intermediate_key_overhead_ptr =
       product_id.Utf8Value().length() + service_name.Utf8Value().length();
 
   Napi::Value verbose = config_json.Get("Verbose");
@@ -56,49 +53,15 @@ void setup(const Napi::CallbackInfo &info) {
     debug_log("setup", "verbose_flag: defaulting to false");
   }
 
-  // Determine size
-  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))) {
-    log_error_and_throw(env, "setup", "Failed to get config utf8 length");
-    return;
-  }
-
-  // Allocate
   char *config_cobhan_buffer;
-  std::unique_ptr<char[]> config_cobhan_buffer_unique_ptr;
-  if (config_utf8_byte_length < max_stack_alloc_size) {
-    // 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);
-    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 =
-        heap_allocate_cbuffer("config_cobhan_buffer", config_utf8_byte_length);
-    config_cobhan_buffer = config_cobhan_buffer_unique_ptr.get();
-  }
-  if (unlikely(config_cobhan_buffer == nullptr)) {
-    log_error_and_throw(env, "setup",
-                        "Failed to allocate config cobhan buffer");
-    return;
-  }
+  size_t config_copied_bytes = 0;
+  NAPI_STRING_TO_CBUFFER(config, config_cobhan_buffer, config_copied_bytes,
+                         "setup");
 
-  // Copy
-  size_t config_copied_bytes;
-  config_cobhan_buffer =
-      copy_nstring_to_cbuffer(env, config, config_utf8_byte_length,
-                              config_cobhan_buffer, &config_copied_bytes);
-  if (unlikely(config_cobhan_buffer == nullptr)) {
-    log_error_and_throw(env, "setup", "Failed to copy config to cobhan buffer");
-    return;
-  }
-
-  if (unlikely(verbose_flag)) {
-    debug_log("setup", "Calling asherah-cobhan SetupJson");
+  char *config_canary_ptr = get_canary_ptr(config_cobhan_buffer);
+  if (unlikely(!check_canary_ptr(config_canary_ptr))) {
+    log_error_and_throw(env, "encrypt_to_json",
+                        "Failed initial canary check for config_cobhan_buffer");
   }
 
   // extern GoInt32 SetupJson(void* configJson);
@@ -108,17 +71,23 @@ void setup(const Napi::CallbackInfo &info) {
     debug_log("setup", "Returned from asherah-cobhan SetupJson");
   }
 
+  if (unlikely(!check_canary_ptr(config_canary_ptr))) {
+    log_error_and_throw(
+        env, "encrypt_to_json",
+        "Failed post-call canary check for config_cobhan_buffer");
+  }
+
   if (unlikely(result < 0)) {
     // TODO: Convert this to a proper error message
     log_error_and_throw(env, "setup", std::to_string(result));
-    return;
   }
   setup_state = 1;
 }
 
-Napi::Value encrypt_to_json(Napi::Env &env, size_t partition_bytes,
-                            size_t data_bytes, char *partition_id_cobhan_buffer,
-                            char *input_cobhan_buffer) {
+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);
@@ -129,24 +98,24 @@ Napi::Value encrypt_to_json(Napi::Env &env, size_t partition_bytes,
   }
 
   char *output_cobhan_buffer;
-  std::unique_ptr<char[]> output_cobhan_buffer_unique_ptr;
-  if (asherah_output_size_bytes < max_stack_alloc_size) {
-    // If the buffer is small enough, allocate it on the stack
-    size_t output_cobhan_buffer_size_bytes =
-        calculate_cobhan_buffer_size_bytes(asherah_output_size_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);
-  } else {
-    // Otherwise, allocate it on the heap
-    output_cobhan_buffer_unique_ptr = heap_allocate_cbuffer(
-        "output_cobhan_buffer", asherah_output_size_bytes);
-    output_cobhan_buffer = output_cobhan_buffer_unique_ptr.get();
+  ALLOCATE_OUTPUT_CBUFFER(output_cobhan_buffer, asherah_output_size_bytes,
+                          "encrypt_to_json");
+
+  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(
+        env, "encrypt_to_json",
+        "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(env, "encrypt_to_json",
+                        "Failed initial canary check for input_cobhan_buffer");
   }
-  if (unlikely(output_cobhan_buffer == nullptr)) {
-    return log_error_and_throw(env, "encrypt_to_json",
-                               "Failed to allocate cobhan output buffer");
+  char *output_canary_ptr = get_canary_ptr(output_cobhan_buffer);
+  if (unlikely(!check_canary_ptr(output_canary_ptr))) {
+    log_error_and_throw(env, "encrypt_to_json",
+                        "Failed initial canary check for output_cobhan_buffer");
   }
 
   if (unlikely(verbose_flag)) {
@@ -162,16 +131,32 @@ Napi::Value encrypt_to_json(Napi::Env &env, size_t partition_bytes,
     debug_log("encrypt_to_json", "Returning from asherah-cobhan EncryptToJson");
   }
 
+  if (unlikely(!check_canary_ptr(partition_id_canary_ptr))) {
+    log_error_and_throw(
+        env, "encrypt_to_json",
+        "Failed post-call canary check for partition_id_cobhan_buffer");
+  }
+  if (unlikely(!check_canary_ptr(input_canary_ptr))) {
+    log_error_and_throw(
+        env, "encrypt_to_json",
+        "Failed post-call canary check for input_cobhan_buffer");
+  }
+  if (unlikely(!check_canary_ptr(output_canary_ptr))) {
+    log_error_and_throw(
+        env, "encrypt_to_json",
+        "Failed post-call canary check for output_cobhan_buffer");
+  }
+
   if (unlikely(result < 0)) {
     // TODO: Convert this to a proper error message
-    return log_error_and_throw(env, "encrypt_to_json", std::to_string(result));
+    log_error_and_throw(env, "encrypt_to_json", std::to_string(result));
   }
 
-  Napi::Value output = cbuffer_to_nstring(env, output_cobhan_buffer);
+  Napi::String output = cbuffer_to_nstring(env, output_cobhan_buffer);
   return output;
 }
 
-Napi::Value encrypt(const Napi::CallbackInfo &info) {
+Napi::String encrypt(const Napi::CallbackInfo &info) {
   Napi::Env env = info.Env();
 
   if (unlikely(verbose_flag)) {
@@ -179,102 +164,32 @@ Napi::Value encrypt(const Napi::CallbackInfo &info) {
   }
 
   if (unlikely(setup_state == 0)) {
-    return log_error_and_throw(env, "encrypt", "setup() not called");
+    log_error_and_throw(env, "encrypt", "setup() not called");
   }
 
   if (unlikely(info.Length() < 2)) {
-    return log_error_and_throw(env, "encrypt", "Wrong number of arguments");
+    log_error_and_throw(env, "encrypt", "Wrong number of arguments");
   }
 
   if (unlikely(!info[0].IsString() || !info[1].IsBuffer())) {
-    return log_error_and_throw(env, "encrypt", "Wrong argument types");
+    log_error_and_throw(env, "encrypt", "Wrong argument types");
   }
 
-  // Determine size
-  size_t partition_utf8_byte_length;
   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 log_error_and_throw(env, "encrypt",
-                               "Failed to get partition_id utf8 length");
-  }
-  if (unlikely(partition_utf8_byte_length == 0)) {
-    return log_error_and_throw(env, "encrypt", "partition_id is empty");
-  }
-
-  // Allocate
   char *partition_id_cobhan_buffer;
-  std::unique_ptr<char[]> partition_id_cobhan_buffer_unique_ptr;
-  if (partition_utf8_byte_length < max_stack_alloc_size) {
-    // 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);
-    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(
-        "partition_id_cobhan_buffer", partition_utf8_byte_length);
-    partition_id_cobhan_buffer = partition_id_cobhan_buffer_unique_ptr.get();
-  }
-  if (unlikely(partition_id_cobhan_buffer == nullptr)) {
-    return log_error_and_throw(env, "encrypt",
-                               "Failed to allocate partitionId cobhan buffer");
-  }
-
-  // Copy
-  size_t partition_copied_bytes;
-  partition_id_cobhan_buffer = copy_nstring_to_cbuffer(
-      env, partition_id, partition_utf8_byte_length, partition_id_cobhan_buffer,
-      &partition_copied_bytes);
-  if (unlikely(partition_id_cobhan_buffer == nullptr)) {
-    return log_error_and_throw(env, "encrypt",
-                               "Failed to copy partitionId to cobhan buffer");
-  }
+  size_t partition_id_copied_bytes = 0;
+  NAPI_STRING_TO_CBUFFER(partition_id, partition_id_cobhan_buffer,
+                         partition_id_copied_bytes, "encrypt");
 
-  // Determine size
   Napi::Buffer<unsigned char> input_napi_buffer =
       info[1].As<Napi::Buffer<unsigned char>>();
-  size_t input_byte_length = input_napi_buffer.ByteLength();
-  if (unlikely(input_byte_length == 0)) {
-    return log_error_and_throw(env, "encrypt", "input is empty");
-  }
-
-  // Allocate
   char *input_cobhan_buffer;
-  std::unique_ptr<char[]> input_buffer_unique_ptr;
-  if (input_byte_length < max_stack_alloc_size) {
-    // If the buffer is small enough, allocate it on the stack
-    size_t input_cobhan_buffer_size_bytes =
-        calculate_cobhan_buffer_size_bytes(input_byte_length);
-    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 =
-        heap_allocate_cbuffer("input_cobhan_buffer", input_byte_length);
-    input_cobhan_buffer = input_buffer_unique_ptr.get();
-  }
-  if (unlikely(input_cobhan_buffer == nullptr)) {
-    return log_error_and_throw(
-        env, "encrypt", "Failed to allocate cobhan buffer for input buffer");
-  }
-
-  // Copy
-  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");
-  }
+  size_t input_copied_bytes = 0;
+  NAPI_BUFFER_TO_CBUFFER(input_napi_buffer, input_cobhan_buffer,
+                         input_copied_bytes, "encrypt");
 
-  Napi::Value output =
-      encrypt_to_json(env, partition_copied_bytes, input_byte_length,
+  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)) {
@@ -284,7 +199,7 @@ Napi::Value encrypt(const Napi::CallbackInfo &info) {
   return output;
 }
 
-Napi::Value encrypt_string(const Napi::CallbackInfo &info) {
+Napi::String encrypt_string(const Napi::CallbackInfo &info) {
   Napi::Env env = info.Env();
 
   if (unlikely(verbose_flag)) {
@@ -292,109 +207,31 @@ Napi::Value encrypt_string(const Napi::CallbackInfo &info) {
   }
 
   if (unlikely(setup_state == 0)) {
-    return log_error_and_throw(env, "encrypt_string", "setup() not called");
+    log_error_and_throw(env, "encrypt_string", "setup() not called");
   }
 
   if (unlikely(info.Length() < 2)) {
-    return log_error_and_throw(env, "encrypt_string",
-                               "Wrong number of arguments");
+    log_error_and_throw(env, "encrypt_string", "Wrong number of arguments");
   }
 
   if (unlikely(!info[0].IsString() || !info[1].IsString())) {
-    return log_error_and_throw(env, "encrypt_string", "Wrong argument types");
+    log_error_and_throw(env, "encrypt_string", "Wrong argument types");
   }
 
-  // Determine size
-  size_t partition_utf8_byte_length;
   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 log_error_and_throw(env, "encrypt_string",
-                               "Failed to get partition_id utf8 length");
-  }
-  if (unlikely(partition_utf8_byte_length == 0)) {
-    return log_error_and_throw(env, "encrypt_string", "partition_id is empty");
-  }
-
-  // Allocate
   char *partition_id_cobhan_buffer;
-  std::unique_ptr<char[]> partition_id_cobhan_buffer_unique_ptr;
-  if (partition_utf8_byte_length < max_stack_alloc_size) {
-    // 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_string", "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(
-        "partition_id_cobhan_buffer", partition_utf8_byte_length);
-    partition_id_cobhan_buffer = partition_id_cobhan_buffer_unique_ptr.get();
-  }
-  if (unlikely(partition_id_cobhan_buffer == nullptr)) {
-    return log_error_and_throw(env, "encrypt_string",
-                               "Failed to allocate partitionId cobhan buffer");
-  }
-
-  // Copy
-  size_t partition_copied_bytes;
-  partition_id_cobhan_buffer = copy_nstring_to_cbuffer(
-      env, partition_id, partition_utf8_byte_length, partition_id_cobhan_buffer,
-      &partition_copied_bytes);
-  if (unlikely(partition_id_cobhan_buffer == nullptr)) {
-    return log_error_and_throw(env, "encrypt_string",
-                               "Failed to copy partitionId to cobhan buffer");
-  }
+  size_t partition_id_copied_bytes = 0;
+  NAPI_STRING_TO_CBUFFER(partition_id, partition_id_cobhan_buffer,
+                         partition_id_copied_bytes, "encrypt_string");
 
-  // Determine size
-  size_t input_utf8_byte_length;
   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 log_error_and_throw(env, "encrypt_string",
-                               "Failed to get input utf8 length");
-  }
-  if (unlikely(input_utf8_byte_length == 0)) {
-    return log_error_and_throw(env, "encrypt_string", "input is empty");
-  }
-
-  // Allocate
   char *input_cobhan_buffer;
-  std::unique_ptr<char[]> input_cobhan_buffer_unique_ptr;
-  if (input_utf8_byte_length < max_stack_alloc_size) {
-    // 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);
-    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 =
-        heap_allocate_cbuffer("input_cobhan_buffer", input_utf8_byte_length);
-    input_cobhan_buffer = input_cobhan_buffer_unique_ptr.get();
-  }
-  if (unlikely(input_cobhan_buffer == nullptr)) {
-    return log_error_and_throw(env, "encrypt_string",
-                               "Failed to allocate input cobhan buffer");
-  }
+  size_t input_copied_bytes = 0;
+  NAPI_STRING_TO_CBUFFER(input, input_cobhan_buffer, input_copied_bytes,
+                         "encrypt_string");
 
-  // Copy
-  size_t input_copied_bytes;
-  input_cobhan_buffer =
-      copy_nstring_to_cbuffer(env, input, input_utf8_byte_length,
-                              input_cobhan_buffer, &input_copied_bytes);
-  if (unlikely(input_cobhan_buffer == nullptr)) {
-    return log_error_and_throw(env, "encrypt_string",
-                               "Failed to copy input to cobhan buffer");
-  }
-
-  Napi::Value output =
-      encrypt_to_json(env, partition_copied_bytes, input_utf8_byte_length,
+  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)) {
@@ -404,7 +241,7 @@ Napi::Value encrypt_string(const Napi::CallbackInfo &info) {
   return output;
 }
 
-Napi::Value decrypt(const Napi::CallbackInfo &info) {
+Napi::Buffer<unsigned char> decrypt(const Napi::CallbackInfo &info) {
   Napi::Env env = info.Env();
 
   if (unlikely(verbose_flag)) {
@@ -412,129 +249,47 @@ Napi::Value decrypt(const Napi::CallbackInfo &info) {
   }
 
   if (unlikely(setup_state == 0)) {
-    return log_error_and_throw(env, "decrypt", "setup() not called");
+    log_error_and_throw(env, "decrypt", "setup() not called");
   }
 
   if (unlikely(info.Length() < 2)) {
-    return log_error_and_throw(env, "decrypt", "Wrong number of arguments");
+    log_error_and_throw(env, "decrypt", "Wrong number of arguments");
   }
 
   if (unlikely(!info[0].IsString() || !info[1].IsString())) {
-    return log_error_and_throw(env, "decrypt", "Wrong argument types");
+    log_error_and_throw(env, "decrypt", "Wrong argument types");
   }
 
-  // Determine size
-  size_t partition_utf8_byte_length, partition_copied_bytes;
   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 log_error_and_throw(env, "decrypt",
-                               "Failed to get partition_id utf8 length");
-  }
-  if (unlikely(partition_utf8_byte_length == 0)) {
-    return log_error_and_throw(env, "decrypt", "partition_id is empty");
-  }
-
-  // Allocate
   char *partition_id_cobhan_buffer;
-  std::unique_ptr<char[]> partition_id_cobhan_buffer_unique_ptr;
-  if (partition_utf8_byte_length < max_stack_alloc_size) {
-    // 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("decrypt", "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(
-        "partition_id_cobhan_buffer", partition_utf8_byte_length);
-    partition_id_cobhan_buffer = partition_id_cobhan_buffer_unique_ptr.get();
-  }
-  if (unlikely(partition_id_cobhan_buffer == nullptr)) {
-    return log_error_and_throw(env, "decrypt",
-                               "Failed to allocate partition_id cobhan buffer");
-  }
-
-  // Copy
-  partition_id_cobhan_buffer = copy_nstring_to_cbuffer(
-      env, partition_id, partition_utf8_byte_length, partition_id_cobhan_buffer,
-      &partition_copied_bytes);
-  if (unlikely(partition_id_cobhan_buffer == nullptr)) {
-    return log_error_and_throw(env, "decrypt",
-                               "Failed to copy partition_id to cobhan buffer");
-  }
+  size_t partition_id_copied_bytes = 0;
+  NAPI_STRING_TO_CBUFFER(partition_id, partition_id_cobhan_buffer,
+                         partition_id_copied_bytes, "decrypt");
 
-  // Determine size
-  size_t input_utf8_byte_length;
   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 log_error_and_throw(env, "decrypt",
-                               "Failed to get input utf8 length");
-  }
-  if (unlikely(input_utf8_byte_length == 0)) {
-    return log_error_and_throw(env, "decrypt", "input is empty");
-  }
-
-  if (unlikely(verbose_flag)) {
-    debug_log("decrypt",
-              "input size " + std::to_string(input_utf8_byte_length));
-  }
-
-  // Allocate
   char *input_cobhan_buffer;
-  std::unique_ptr<char[]> input_cobhan_buffer_unique_ptr;
-  if (input_utf8_byte_length < max_stack_alloc_size) {
-    // 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("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 =
-        heap_allocate_cbuffer("input_cobhan_buffer", input_utf8_byte_length);
-    input_cobhan_buffer = input_cobhan_buffer_unique_ptr.get();
-  }
-  if (unlikely(input_cobhan_buffer == nullptr)) {
-    return log_error_and_throw(env, "decrypt",
-                               "Failed to allocate input cobhan buffer");
-  }
-
-  // Copy
-  size_t input_copied_bytes;
-  input_cobhan_buffer =
-      copy_nstring_to_cbuffer(env, input, input_utf8_byte_length,
-                              input_cobhan_buffer, &input_copied_bytes);
-  if (unlikely(input_cobhan_buffer == nullptr)) {
-    return log_error_and_throw(env, "decrypt",
-                               "Failed to copy input to cobhan buffer");
-  }
+  size_t input_copied_bytes = 0;
+  NAPI_STRING_TO_CBUFFER(input, input_cobhan_buffer, input_copied_bytes,
+                         "decrypt");
 
   char *output_cobhan_buffer;
-  std::unique_ptr<char[]> output_cobhan_buffer_unique_ptr;
-  if (input_utf8_byte_length < max_stack_alloc_size) {
-    // If the buffer is small enough, allocate it on the stack
-    size_t output_cobhan_buffer_size_bytes =
-        calculate_cobhan_buffer_size_bytes(input_utf8_byte_length);
-    debug_log_alloca("decrypt", "output_cobhan_buffer",
-                     output_cobhan_buffer_size_bytes);
-    output_cobhan_buffer = (char *)alloca(output_cobhan_buffer_size_bytes);
-    configure_cbuffer(output_cobhan_buffer, input_utf8_byte_length);
-  } else {
-    // Otherwise, allocate it on the heap
-    output_cobhan_buffer_unique_ptr =
-        heap_allocate_cbuffer("output_cobhan_buffer", input_utf8_byte_length);
-    output_cobhan_buffer = output_cobhan_buffer_unique_ptr.get();
+  ALLOCATE_OUTPUT_CBUFFER(output_cobhan_buffer, input_copied_bytes, "decrypt");
+
+  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(
+        env, "encrypt_to_json",
+        "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(env, "encrypt_to_json",
+                        "Failed initial canary check for input_cobhan_buffer");
   }
-  if (unlikely(output_cobhan_buffer == nullptr)) {
-    return log_error_and_throw(env, "decrypt",
-                               "Failed to allocate cobhan output buffer");
+  char *output_canary_ptr = get_canary_ptr(output_cobhan_buffer);
+  if (unlikely(!check_canary_ptr(output_canary_ptr))) {
+    log_error_and_throw(env, "encrypt_to_json",
+                        "Failed initial canary check for output_cobhan_buffer");
   }
 
   if (unlikely(verbose_flag)) {
@@ -550,12 +305,29 @@ Napi::Value decrypt(const Napi::CallbackInfo &info) {
     debug_log("decrypt", "Returned from asherah-cobhan DecryptFromJson");
   }
 
+  if (unlikely(!check_canary_ptr(partition_id_canary_ptr))) {
+    log_error_and_throw(
+        env, "encrypt_to_json",
+        "Failed post-call canary check for partition_id_cobhan_buffer");
+  }
+  if (unlikely(!check_canary_ptr(input_canary_ptr))) {
+    log_error_and_throw(
+        env, "encrypt_to_json",
+        "Failed post-call canary check for input_cobhan_buffer");
+  }
+  if (unlikely(!check_canary_ptr(output_canary_ptr))) {
+    log_error_and_throw(
+        env, "encrypt_to_json",
+        "Failed post-call canary check for output_cobhan_buffer");
+  }
+
   if (unlikely(result < 0)) {
     // TODO: Convert this to a proper error message
-    return log_error_and_throw(env, "decrypt", std::to_string(result));
+    log_error_and_throw(env, "decrypt", std::to_string(result));
   }
 
-  Napi::Value output = cbuffer_to_nbuffer(env, output_cobhan_buffer);
+  Napi::Buffer<unsigned char> output =
+      cbuffer_to_nbuffer(env, output_cobhan_buffer);
 
   if (unlikely(verbose_flag)) {
     debug_log("decrypt", "finished");
@@ -564,7 +336,7 @@ Napi::Value decrypt(const Napi::CallbackInfo &info) {
   return output;
 }
 
-Napi::Value decrypt_string(const Napi::CallbackInfo &info) {
+Napi::String decrypt_string(const Napi::CallbackInfo &info) {
   Napi::Env env = info.Env();
 
   if (unlikely(verbose_flag)) {
@@ -572,126 +344,48 @@ Napi::Value decrypt_string(const Napi::CallbackInfo &info) {
   }
 
   if (unlikely(setup_state == 0)) {
-    return log_error_and_throw(env, "decrypt_string", "setup() not called");
+    log_error_and_throw(env, "decrypt_string", "setup() not called");
   }
 
   if (unlikely(info.Length() < 2)) {
-    return log_error_and_throw(env, "decrypt_string",
-                               "Wrong number of arguments");
+    log_error_and_throw(env, "decrypt_string", "Wrong number of arguments");
   }
 
   if (unlikely(!info[0].IsString() || !info[1].IsString())) {
-    return log_error_and_throw(env, "decrypt_string", "Wrong argument types");
+    log_error_and_throw(env, "decrypt_string", "Wrong argument types");
   }
 
-  // Determine size
-  size_t partition_utf8_byte_length;
   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 log_error_and_throw(env, "decrypt_string",
-                               "Failed to get partition_id utf8 length");
-  }
-  if (unlikely(partition_utf8_byte_length == 0)) {
-    return log_error_and_throw(env, "decrypt_string", "partition_id is empty");
-  }
-
-  // Allocate
   char *partition_id_cobhan_buffer;
-  std::unique_ptr<char[]> partition_id_cobhan_buffer_unique_ptr;
-  if (partition_utf8_byte_length < max_stack_alloc_size) {
-    // 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("decrypt_string", "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(
-        "partition_id_cobhan_buffer", partition_utf8_byte_length);
-    partition_id_cobhan_buffer = partition_id_cobhan_buffer_unique_ptr.get();
-  }
-  if (unlikely(partition_id_cobhan_buffer == nullptr)) {
-    return log_error_and_throw(env, "decrypt_string",
-                               "Failed to allocate partitionId cobhan buffer");
-  }
-
-  // Copy
-  size_t partition_copied_bytes;
-  partition_id_cobhan_buffer = copy_nstring_to_cbuffer(
-      env, partition_id, partition_utf8_byte_length, partition_id_cobhan_buffer,
-      &partition_copied_bytes);
-  if (unlikely(partition_id_cobhan_buffer == nullptr)) {
-    return log_error_and_throw(env, "decrypt_string",
-                               "Failed to copy partitionId to cobhan buffer");
-  }
+  size_t partition_id_copied_bytes = 0;
+  NAPI_STRING_TO_CBUFFER(partition_id, partition_id_cobhan_buffer,
+                         partition_id_copied_bytes, "decrypt_string");
 
-  // Determine size
-  size_t input_utf8_byte_length;
   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 log_error_and_throw(env, "decrypt_string",
-                               "Failed to get input utf8 length");
-  }
-  if (unlikely(input_utf8_byte_length == 0)) {
-    return log_error_and_throw(env, "decrypt_string", "input is empty");
-  }
-
-  // Allocate
   char *input_cobhan_buffer;
-  std::unique_ptr<char[]> input_cobhan_buffer_unique_ptr;
-  if (input_utf8_byte_length < max_stack_alloc_size) {
-    // 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("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 =
-        heap_allocate_cbuffer("input_cobhan_buffer", input_utf8_byte_length);
-    input_cobhan_buffer = input_cobhan_buffer_unique_ptr.get();
-  }
-  if (unlikely(input_cobhan_buffer == nullptr)) {
-    return log_error_and_throw(env, "decrypt_string",
-                               "Failed to allocate input cobhan buffer");
-  }
-
-  // Copy
-  size_t input_copied_bytes;
-  input_cobhan_buffer =
-      copy_nstring_to_cbuffer(env, input, input_utf8_byte_length,
-                              input_cobhan_buffer, &input_copied_bytes);
-  if (unlikely(input_cobhan_buffer == nullptr)) {
-    return log_error_and_throw(env, "decrypt_string",
-                               "Failed to copy input to cobhan buffer");
-  }
+  size_t input_copied_bytes = 0;
+  NAPI_STRING_TO_CBUFFER(input, input_cobhan_buffer, input_copied_bytes,
+                         "decrypt_string");
 
   char *output_cobhan_buffer;
-  std::unique_ptr<char[]> output_cobhan_buffer_unique_ptr;
-  if (input_utf8_byte_length < max_stack_alloc_size) {
-    // If the buffer is small enough, allocate it on the stack
-    size_t output_cobhan_buffer_size_bytes =
-        calculate_cobhan_buffer_size_bytes(input_utf8_byte_length);
-    debug_log_alloca("decrypt_string", "output_cobhan_buffer",
-                     output_cobhan_buffer_size_bytes);
-    output_cobhan_buffer = (char *)alloca(output_cobhan_buffer_size_bytes);
-    configure_cbuffer(output_cobhan_buffer, input_utf8_byte_length);
-  } else {
-    // Otherwise, allocate it on the heap
-    output_cobhan_buffer_unique_ptr =
-        heap_allocate_cbuffer("output_cobhan_buffer", input_utf8_byte_length);
-    output_cobhan_buffer = output_cobhan_buffer_unique_ptr.get();
+  ALLOCATE_OUTPUT_CBUFFER(output_cobhan_buffer, input_copied_bytes,
+                          "decrypt_string");
+
+  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(
+        env, "encrypt_to_json",
+        "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(env, "encrypt_to_json",
+                        "Failed initial canary check for input_cobhan_buffer");
   }
-  if (unlikely(output_cobhan_buffer == nullptr)) {
-    return log_error_and_throw(env, "decrypt_string",
-                               "Failed to allocate cobhan output buffer");
+  char *output_canary_ptr = get_canary_ptr(output_cobhan_buffer);
+  if (unlikely(!check_canary_ptr(output_canary_ptr))) {
+    log_error_and_throw(env, "encrypt_to_json",
+                        "Failed initial canary check for output_cobhan_buffer");
   }
 
   if (unlikely(verbose_flag)) {
@@ -707,12 +401,28 @@ Napi::Value decrypt_string(const Napi::CallbackInfo &info) {
     debug_log("decrypt_string", "Returned from asherah-cobhan DecryptFromJson");
   }
 
+  if (unlikely(!check_canary_ptr(partition_id_canary_ptr))) {
+    log_error_and_throw(
+        env, "encrypt_to_json",
+        "Failed post-call canary check for partition_id_cobhan_buffer");
+  }
+  if (unlikely(!check_canary_ptr(input_canary_ptr))) {
+    log_error_and_throw(
+        env, "encrypt_to_json",
+        "Failed post-call canary check for input_cobhan_buffer");
+  }
+  if (unlikely(!check_canary_ptr(output_canary_ptr))) {
+    log_error_and_throw(
+        env, "encrypt_to_json",
+        "Failed post-call canary check for output_cobhan_buffer");
+  }
+
   if (unlikely(result < 0)) {
     // TODO: Convert this to a proper error message
-    return log_error_and_throw(env, "decrypt_string", std::to_string(result));
+    log_error_and_throw(env, "decrypt_string", std::to_string(result));
   }
 
-  Napi::Value output = cbuffer_to_nstring(env, output_cobhan_buffer);
+  Napi::String output = cbuffer_to_nstring(env, output_cobhan_buffer);
 
   if (unlikely(verbose_flag)) {
     debug_log("decrypt_string", "finished");
@@ -750,7 +460,6 @@ void set_max_stack_alloc_item_size(const Napi::CallbackInfo &info) {
   if (unlikely(info.Length() < 1)) {
     log_error_and_throw(env, "set_max_stack_alloc_item_size",
                         "Wrong number of arguments");
-    return;
   }
 
   Napi::Number item_size = info[0].ToNumber();
@@ -768,12 +477,11 @@ void set_safety_padding_overhead(const Napi::CallbackInfo &info) {
   if (unlikely(info.Length() < 1)) {
     log_error_and_throw(env, "set_safety_padding_overhead",
                         "Wrong number of arguments");
-    return;
   }
 
   Napi::Number safety_padding_number = info[0].ToNumber();
 
-  safety_padding_bytes = (size_t)safety_padding_number.Int32Value();
+  *safety_padding_bytes_ptr = (size_t)safety_padding_number.Int32Value();
 }
 
 Napi::Object Init(Napi::Env env, Napi::Object exports) {

package/src/cobhan_napi_interop.cc

@@ -1,3 +1,11 @@
 #include <stddef.h>
-size_t est_intermediate_key_overhead = 0;
-size_t safety_padding_bytes = 0;
+static size_t est_intermediate_key_overhead = 0;
+static size_t safety_padding_bytes = 0;
+
+size_t* get_est_intermediate_key_overhead_ptr() {
+  return &est_intermediate_key_overhead;
+}
+
+size_t* get_safety_padding_bytes_ptr() {
+  return &safety_padding_bytes;
+}

package/src/cobhan_napi_interop.h

@@ -2,17 +2,24 @@
 #define COBHAN_NAPI_INTEROP_H
 #include "hints.h"
 #include "logging.h"
-#include <string>
 #include <napi.h>
+#include <string>
+
+// Stupid hack to get around extern issues
+size_t *get_est_intermediate_key_overhead_ptr();
+size_t *get_safety_padding_bytes_ptr();
 
-extern size_t est_intermediate_key_overhead;
-extern size_t safety_padding_bytes;
+size_t *est_intermediate_key_overhead_ptr =
+    get_est_intermediate_key_overhead_ptr();
+size_t *safety_padding_bytes_ptr = get_safety_padding_bytes_ptr();
 
 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;
+const size_t canary_size = sizeof(int32_t) * 2;
+const int32_t canary_constant = 0xdeadbeef;
 
 std::string napi_status_to_string(napi_status status) {
   switch (status) {
@@ -70,19 +77,20 @@ cbuffer_byte_length(char *cobhan_buffer) {
   return *((int32_t *)cobhan_buffer);
 }
 
-__attribute__((always_inline)) inline Napi::Value
+__attribute__((always_inline)) inline void
 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
+calculate_cobhan_buffer_allocation_size(size_t data_len_bytes) {
+  return data_len_bytes + cobhan_header_size_bytes +
+         1 + // Add one for possible NULL delimiter due to Node string functions
+         canary_size                  // Add space for canary value
+         + *safety_padding_bytes_ptr; // Add safety padding if configured
 }
 
 __attribute__((always_inline)) inline size_t
@@ -92,9 +100,9 @@ estimate_asherah_output_size_bytes(size_t data_byte_len,
   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);
+  size_t asherah_output_size_bytes = size_t(
+      est_envelope_overhead + *est_intermediate_key_overhead_ptr +
+      partition_byte_len + est_data_byte_len + *safety_padding_bytes_ptr);
   if (unlikely(verbose_flag)) {
     std::string log_msg =
         "estimate_asherah_output_size(" + std::to_string(data_byte_len) + ", " +
@@ -107,56 +115,113 @@ estimate_asherah_output_size_bytes(size_t data_byte_len,
   return asherah_output_size_bytes;
 }
 
+__attribute__((always_inline)) inline char *
+cbuffer_data_ptr(char *cobhan_buffer) {
+  return cobhan_buffer + cobhan_header_size_bytes;
+}
+
 __attribute__((always_inline)) inline void configure_cbuffer(char *buffer,
                                                              size_t length) {
+  if (verbose_flag) {
+    debug_log("configure_cbuffer", "configure_cbuffer(" +
+                                       std::to_string((intptr_t)buffer) + ", " +
+                                       std::to_string(length) + ")");
+  }
+
   *((int32_t *)buffer) = length;
   // Reserved for future use
   *((int32_t *)(buffer + sizeof(int32_t))) = 0;
+
+  // Write canary values
+  char *data_ptr = cbuffer_data_ptr(buffer);
+  if (verbose_flag) {
+    debug_log("configure_cbuffer",
+              "Writing first canary at " +
+                  std::to_string((intptr_t)(data_ptr + length + 1)));
+  }
+
+  // First canary value is a int32_t 0 which gives us four NULLs
+  *((int32_t *)(data_ptr + length + 1)) = 0;
+
+  if (verbose_flag) {
+    debug_log("configure_cbuffer",
+              "Writing second canary at " +
+                  std::to_string(
+                      (intptr_t)(data_ptr + length + 1 + sizeof(int32_t))));
+  }
+
+  // Second canary value is a int32_t 0xdeadbeef
+  *((int32_t *)(data_ptr + length + 1 + sizeof(int32_t))) = canary_constant;
+}
+
+__attribute__((always_inline)) inline char *
+get_canary_ptr(char *cobhan_buffer) {
+  int32_t cobhan_buffer_size_bytes = cbuffer_byte_length(cobhan_buffer);
+  return cbuffer_data_ptr(cobhan_buffer) + cobhan_buffer_size_bytes + 1;
+}
+
+__attribute__((always_inline)) inline bool check_canary_ptr(char *canary_ptr) {
+  int32_t zero_value = *((int32_t *)(canary_ptr));
+  if (zero_value != 0) {
+    std::string error_msg =
+        "Canary check failed: " + std::to_string(zero_value) + " != 0";
+    error_log("canary_check_cbuffer", error_msg);
+    return false;
+  }
+  int32_t canary_value = *((int32_t *)(canary_ptr + sizeof(int32_t)));
+  if (canary_value != canary_constant) {
+    std::string error_msg =
+        "Canary check failed: " + std::to_string(canary_value) +
+        " != " + std::to_string(canary_constant);
+    error_log("canary_check_cbuffer", error_msg);
+    return false;
+  }
+  return true;
 }
 
 __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);
+  size_t cobhan_buffer_allocation_size =
+      calculate_cobhan_buffer_allocation_size(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;
+        ") (heap) cobhan_buffer_allocation_size: " +
+        std::to_string(cobhan_buffer_allocation_size) + " for " + variable_name;
     debug_log("allocate_cbuffer", log_msg);
   }
 
-  char *cobhan_buffer = new (std::nothrow) char[cobhan_buffer_size_bytes];
+  char *cobhan_buffer = new (std::nothrow) char[cobhan_buffer_allocation_size];
   if (unlikely(cobhan_buffer == nullptr)) {
-    std::string error_msg =
-        "new[" + std::to_string(cobhan_buffer_size_bytes) + " returned null";
+    std::string error_msg = "new[" +
+                            std::to_string(cobhan_buffer_allocation_size) +
+                            "] 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);
+  configure_cbuffer(cobhan_buffer, size_bytes + *safety_padding_bytes_ptr);
   return cobhan_buffer_unique_ptr;
 }
 
-__attribute__((always_inline)) inline Napi::Value
+__attribute__((always_inline)) inline Napi::String
 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");
+    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);
+      env, cbuffer_data_ptr(cobhan_buffer), 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));
+    log_error_and_throw(env, "cbuffer_to_nstring",
+                        "napi_create_string_utf8 failed: " +
+                            napi_status_to_string(status));
   }
 
   return Napi::String(env, output);
@@ -196,13 +261,21 @@ copy_nstring_to_cbuffer(Napi::Env &env, Napi::String &str,
     return nullptr;
   }
 
+  if (unlikely(verbose_flag)) {
+    debug_log("copy_nstring_to_cbuffer",
+              "Copying " + std::to_string(str_utf8_byte_length) + " bytes to " +
+                  std::to_string((intptr_t)cbuffer_data_ptr(cobhan_buffer)) +
+                  "-" +
+                  std::to_string((intptr_t)(cbuffer_data_ptr(cobhan_buffer) +
+                                            str_utf8_byte_length)));
+  }
+
   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,
+  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)) {
     log_error_and_throw(env, "copy_nstring_to_cbuffer",
@@ -244,18 +317,17 @@ copy_nbuffer_to_cbuffer(Napi::Env &env, Napi::Buffer<unsigned char> &nbuffer,
                         "Buffer too large for cobhan buffer");
     return nullptr;
   }
-  memcpy(cobhan_buffer + cobhan_header_size_bytes, nbuffer.Data(),
-         nbuffer_byte_length);
+  memcpy(cbuffer_data_ptr(cobhan_buffer), nbuffer.Data(), nbuffer_byte_length);
   configure_cbuffer(cobhan_buffer, nbuffer_byte_length);
   return cobhan_buffer;
 }
 
-__attribute__((always_inline)) inline Napi::Value
+__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)) {
-    return log_error_and_throw(env, "cbuffer_to_nbuffer",
-                               "Invalid cobhan buffer byte length");
+    log_error_and_throw(env, "cbuffer_to_nbuffer",
+                        "Invalid cobhan buffer byte length");
   }
 
   if (unlikely(verbose_flag)) {
@@ -269,8 +341,8 @@ cbuffer_to_nbuffer(Napi::Env &env, char *cobhan_buffer) {
                         "Invalid cobhan buffer byte length");
   }
 
-  Napi::Buffer nbuffer = Napi::Buffer<unsigned char>::Copy(
-      env, ((unsigned char *)cobhan_buffer) + cobhan_header_size_bytes,
+  Napi::Buffer<unsigned char> nbuffer = Napi::Buffer<unsigned char>::Copy(
+      env, (const unsigned char *)cbuffer_data_ptr(cobhan_buffer),
       cobhan_buffer_byte_length);
 
   if (unlikely(verbose_flag)) {
@@ -281,4 +353,115 @@ cbuffer_to_nbuffer(Napi::Env &env, char *cobhan_buffer) {
   return nbuffer;
 }
 
+// These are macros due to the use of alloca()
+
+#define NAPI_STRING_TO_CBUFFER(napi_string, cobhan_buffer, bytes_copied,       \
+                               function_name)                                  \
+  std::unique_ptr<char[]> napi_string##_cobhan_buffer_unique_ptr;              \
+  do {                                                                         \
+    /* Determine size */                                                       \
+    size_t napi_string##_utf8_byte_length =                                    \
+        nstring_utf8_byte_length(env, napi_string);                            \
+    if (unlikely(napi_string##_utf8_byte_length == (size_t)(-1))) {            \
+      log_error_and_throw(env, function_name,                                  \
+                          "Failed to get " #napi_string " utf8 length");       \
+    }                                                                          \
+    if (unlikely(napi_string##_utf8_byte_length == 0)) {                       \
+      log_error_and_throw(env, function_name, #napi_string " is empty");       \
+    }                                                                          \
+    /* Allocate */                                                             \
+    if (napi_string##_utf8_byte_length < max_stack_alloc_size) {               \
+      /* If the buffer is small enough, allocate it on the stack  */           \
+      size_t napi_string##_cobhan_buffer_allocation_size =                     \
+          calculate_cobhan_buffer_allocation_size(                             \
+              napi_string##_utf8_byte_length);                                 \
+      debug_log_alloca(function_name, #napi_string "_cobhan_buffer",           \
+                       napi_string##_cobhan_buffer_allocation_size);           \
+      cobhan_buffer =                                                          \
+          (char *)alloca(napi_string##_cobhan_buffer_allocation_size);         \
+      configure_cbuffer(cobhan_buffer, napi_string##_utf8_byte_length);        \
+    } else {                                                                   \
+      /* Otherwise, allocate it on the heap */                                 \
+      napi_string##_cobhan_buffer_unique_ptr = heap_allocate_cbuffer(          \
+          #cobhan_buffer, napi_string##_utf8_byte_length);                     \
+      cobhan_buffer = napi_string##_cobhan_buffer_unique_ptr.get();            \
+    }                                                                          \
+    if (unlikely(cobhan_buffer == nullptr)) {                                  \
+      log_error_and_throw(env, function_name,                                  \
+                          "Failed to allocate " #napi_string                   \
+                          " cobhan buffer");                                   \
+    }                                                                          \
+    /* Copy */                                                                 \
+    cobhan_buffer = copy_nstring_to_cbuffer(env, napi_string,                  \
+                                            napi_string##_utf8_byte_length,    \
+                                            cobhan_buffer, &bytes_copied);     \
+    if (unlikely(cobhan_buffer == nullptr)) {                                  \
+      log_error_and_throw(env, function_name,                                  \
+                          "Failed to copy " #napi_string " to cobhan buffer"); \
+    }                                                                          \
+  } while (0);
+
+#define NAPI_BUFFER_TO_CBUFFER(napi_buffer, cobhan_buffer, bytes_copied,       \
+                               function_name)                                  \
+  std::unique_ptr<char[]> napi_buffer##_unique_ptr;                            \
+  do {                                                                         \
+    /* Determine size */                                                       \
+    size_t napi_buffer##_byte_length = napi_buffer.ByteLength();               \
+    if (unlikely(napi_buffer##_byte_length == 0)) {                            \
+      log_error_and_throw(env, function_name, #napi_buffer " is empty");       \
+    }                                                                          \
+    /* Allocate */                                                             \
+    if (napi_buffer##_byte_length < max_stack_alloc_size) {                    \
+      /* If the buffer is small enough, allocate it on the stack */            \
+      size_t napi_buffer##_cobhan_buffer_allocation_size =                     \
+          calculate_cobhan_buffer_allocation_size(napi_buffer##_byte_length);  \
+      debug_log_alloca(function_name, #cobhan_buffer,                          \
+                       napi_buffer##_cobhan_buffer_allocation_size);           \
+      cobhan_buffer =                                                          \
+          (char *)alloca(napi_buffer##_cobhan_buffer_allocation_size);         \
+      configure_cbuffer(cobhan_buffer, napi_buffer##_byte_length);             \
+    } else {                                                                   \
+      /* Otherwise, allocate it on the heap */                                 \
+      napi_buffer##_unique_ptr =                                               \
+          heap_allocate_cbuffer(#cobhan_buffer, napi_buffer##_byte_length);    \
+      cobhan_buffer = napi_buffer##_unique_ptr.get();                          \
+    }                                                                          \
+    if (unlikely(cobhan_buffer == nullptr)) {                                  \
+      log_error_and_throw(                                                     \
+          env, function_name,                                                  \
+          "Failed to allocate cobhan buffer for " #napi_buffer);               \
+    }                                                                          \
+    /* Copy */                                                                 \
+    cobhan_buffer = copy_nbuffer_to_cbuffer(env, napi_buffer, cobhan_buffer);  \
+    if (unlikely(cobhan_buffer == nullptr)) {                                  \
+      log_error_and_throw(env, function_name,                                  \
+                          "Failed to copy " #napi_buffer " to cobhan buffer"); \
+    }                                                                          \
+    bytes_copied = napi_buffer##_byte_length;                                  \
+  } while (0);
+
+#define ALLOCATE_OUTPUT_CBUFFER(cobhan_buffer, buffer_size, function_name)     \
+  std::unique_ptr<char[]> cobhan_buffer##_unique_ptr;                          \
+  do {                                                                         \
+    if (buffer_size < max_stack_alloc_size) {                                  \
+      /* If the buffer is small enough, allocate it on the stack */            \
+      size_t cobhan_buffer##_cobhan_buffer_allocation_size =                   \
+          calculate_cobhan_buffer_allocation_size(buffer_size);                \
+      debug_log_alloca(function_name, #cobhan_buffer,                          \
+                       cobhan_buffer##_cobhan_buffer_allocation_size);         \
+      cobhan_buffer =                                                          \
+          (char *)alloca(cobhan_buffer##_cobhan_buffer_allocation_size);       \
+      configure_cbuffer(cobhan_buffer, buffer_size);                           \
+    } else {                                                                   \
+      /* Otherwise, allocate it on the heap */                                 \
+      cobhan_buffer##_unique_ptr =                                             \
+          heap_allocate_cbuffer(#cobhan_buffer, buffer_size);                  \
+      cobhan_buffer = output_cobhan_buffer_unique_ptr.get();                   \
+    }                                                                          \
+    if (unlikely(cobhan_buffer == nullptr)) {                                  \
+      log_error_and_throw(env, function_name,                                  \
+                          "Failed to allocate " #cobhan_buffer);               \
+    }                                                                          \
+  } while (0);
+
 #endif