asherah 1.3.20 → 1.3.22

package/binding.gyp

@@ -3,8 +3,8 @@
       {
       'target_name': 'asherah',
       'include_dirs': ["<!(node -p \"require('node-addon-api').include_dir\")"],
-      "cflags": ["-fexceptions", "-g", "-O3"],
-      "cflags_cc": ["-fexceptions", "-g", "-O3"],
+      "cflags": ["-fexceptions", "-g", "-O3", "-std=c++17"],
+      "cflags_cc": ["-fexceptions", "-g", "-O3", "-std=c++17"],
       "cflags!": [ "-fno-exceptions"],
       "cflags_cc!": [ "-fno-exceptions" ],
       'xcode_settings': {
@@ -12,7 +12,8 @@
         'OTHER_CFLAGS': [
           '-fexceptions',
           '-g',
-          '-O3'
+          '-O3',
+          '-std=c++17'
         ],
       },
       'defines': [ 'NAPI_CPP_EXCEPTIONS', 'NODE_API_SWALLOW_UNTHROWABLE_EXCEPTIONS', 'NODE_ADDON_API_DISABLE_DEPRECATED', 'NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED' ],
@@ -23,6 +24,8 @@
         'src/logging.h',
         'src/cobhan_napi_interop.cc',
         'src/cobhan_napi_interop.h',
+        'src/cobhan.h',
+        'src/cobhan.cc',
         'src/hints.h'
       ],
       'libraries': [ '../lib/libasherah.a' ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "asherah",
-  "version": "1.3.20",
+  "version": "1.3.22",
   "description": "Asherah envelope encryption and key rotation library",
   "exports": {
     "node-addons": "./dist/asherah.node"
@@ -28,6 +28,8 @@
     "src/logging.cc",
     "src/cobhan_napi_interop.h",
     "src/cobhan_napi_interop.cc",
+    "src/cobhan.h",
+    "src/cobhan.cc",
     "src/asherah.d.ts",
     "scripts/download-libraries.sh",
     "scripts/build.sh",

package/src/asherah.cc

@@ -3,28 +3,31 @@
 #include "hints.h"
 #include "logging.h"
 #include <iostream>
+#include <mutex>
 #include <napi.h>
 
 size_t max_stack_alloc_size = 2048;
 int32_t setup_state = 0;
+std::mutex asherah_lock;
 
 void setup(const Napi::CallbackInfo &info) {
-  Napi::Env env = info.Env();
+  std::lock_guard<std::mutex> lock(asherah_lock);
 
   if (unlikely(verbose_flag)) {
     debug_log("setup", "called");
   }
 
   if (unlikely(setup_state == 1)) {
-    log_error_and_throw(env, "setup", "setup called twice");
+    log_error_and_throw("setup", "setup called twice");
   }
 
   if (unlikely(info.Length() < 1)) {
-    log_error_and_throw(env, "setup", "Wrong number of arguments");
+    log_error_and_throw("setup", "Wrong number of arguments");
   }
 
   Napi::String config;
   Napi::Object config_json;
+  Napi::Env env = info.Env();
   Napi::Object json = env.Global().Get("JSON").As<Napi::Object>();
   if (likely(info[0].IsObject())) {
     config_json = info[0].As<Napi::Object>();
@@ -35,13 +38,13 @@ 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 {
-    log_error_and_throw(env, "setup", "Wrong argument type");
+    log_error_and_throw("setup", "Wrong argument type");
   }
 
   Napi::String product_id = config_json.Get("ProductID").As<Napi::String>();
   Napi::String service_name = config_json.Get("ServiceName").As<Napi::String>();
 
-  *est_intermediate_key_overhead_ptr =
+  est_intermediate_key_overhead =
       product_id.Utf8Value().length() + service_name.Utf8Value().length();
 
   Napi::Value verbose = config_json.Get("Verbose");
@@ -54,13 +57,13 @@ void setup(const Napi::CallbackInfo &info) {
   }
 
   char *config_cobhan_buffer;
-  size_t config_copied_bytes = 0;
-  NAPI_STRING_TO_CBUFFER(config, config_cobhan_buffer, config_copied_bytes,
+  size_t config_copied_bytes;
+  NAPI_STRING_TO_CBUFFER(env, config, config_cobhan_buffer, config_copied_bytes,
                          "setup");
 
   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",
+    log_error_and_throw("encrypt_to_json",
                         "Failed initial canary check for config_cobhan_buffer");
   }
 
@@ -73,13 +76,13 @@ void setup(const Napi::CallbackInfo &info) {
 
   if (unlikely(!check_canary_ptr(config_canary_ptr))) {
     log_error_and_throw(
-        env, "encrypt_to_json",
+        "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));
+    log_error_and_throw("setup", std::to_string(result));
   }
   setup_state = 1;
 }
@@ -98,23 +101,23 @@ Napi::String encrypt_to_json(Napi::Env &env, size_t partition_bytes,
   }
 
   char *output_cobhan_buffer;
-  ALLOCATE_OUTPUT_CBUFFER(output_cobhan_buffer, asherah_output_size_bytes,
-                          "encrypt_to_json");
+  ALLOCATE_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",
+        "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",
+    log_error_and_throw("encrypt_to_json",
                         "Failed initial canary check for input_cobhan_buffer");
   }
   char *output_canary_ptr = get_canary_ptr(output_cobhan_buffer);
   if (unlikely(!check_canary_ptr(output_canary_ptr))) {
-    log_error_and_throw(env, "encrypt_to_json",
+    log_error_and_throw("encrypt_to_json",
                         "Failed initial canary check for output_cobhan_buffer");
   }
 
@@ -133,23 +136,23 @@ Napi::String encrypt_to_json(Napi::Env &env, size_t partition_bytes,
 
   if (unlikely(!check_canary_ptr(partition_id_canary_ptr))) {
     log_error_and_throw(
-        env, "encrypt_to_json",
+        "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",
+        "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",
+        "encrypt_to_json",
         "Failed post-call canary check for output_cobhan_buffer");
   }
 
   if (unlikely(result < 0)) {
     // TODO: Convert this to a proper error message
-    log_error_and_throw(env, "encrypt_to_json", std::to_string(result));
+    log_error_and_throw("encrypt_to_json", std::to_string(result));
   }
 
   Napi::String output = cbuffer_to_nstring(env, output_cobhan_buffer);
@@ -157,35 +160,37 @@ Napi::String encrypt_to_json(Napi::Env &env, size_t partition_bytes,
 }
 
 Napi::String encrypt(const Napi::CallbackInfo &info) {
-  Napi::Env env = info.Env();
+  std::lock_guard<std::mutex> lock(asherah_lock);
 
   if (unlikely(verbose_flag)) {
     debug_log("encrypt", "called");
   }
 
   if (unlikely(setup_state == 0)) {
-    log_error_and_throw(env, "encrypt", "setup() not called");
+    log_error_and_throw("encrypt", "setup() not called");
   }
 
   if (unlikely(info.Length() < 2)) {
-    log_error_and_throw(env, "encrypt", "Wrong number of arguments");
+    log_error_and_throw("encrypt", "Wrong number of arguments");
   }
 
   if (unlikely(!info[0].IsString() || !info[1].IsBuffer())) {
-    log_error_and_throw(env, "encrypt", "Wrong argument types");
+    log_error_and_throw("encrypt", "Wrong argument types");
   }
 
+  Napi::Env env = info.Env();
+
   Napi::String partition_id = info[0].As<Napi::String>();
   char *partition_id_cobhan_buffer;
-  size_t partition_id_copied_bytes = 0;
-  NAPI_STRING_TO_CBUFFER(partition_id, partition_id_cobhan_buffer,
+  size_t partition_id_copied_bytes;
+  NAPI_STRING_TO_CBUFFER(env, partition_id, partition_id_cobhan_buffer,
                          partition_id_copied_bytes, "encrypt");
 
   Napi::Buffer<unsigned char> input_napi_buffer =
       info[1].As<Napi::Buffer<unsigned char>>();
   char *input_cobhan_buffer;
-  size_t input_copied_bytes = 0;
-  NAPI_BUFFER_TO_CBUFFER(input_napi_buffer, input_cobhan_buffer,
+  size_t input_copied_bytes;
+  NAPI_BUFFER_TO_CBUFFER(env, input_napi_buffer, input_cobhan_buffer,
                          input_copied_bytes, "encrypt");
 
   Napi::String output =
@@ -200,34 +205,36 @@ Napi::String encrypt(const Napi::CallbackInfo &info) {
 }
 
 Napi::String encrypt_string(const Napi::CallbackInfo &info) {
-  Napi::Env env = info.Env();
+  std::lock_guard<std::mutex> lock(asherah_lock);
 
   if (unlikely(verbose_flag)) {
     debug_log("encrypt_string", "called");
   }
 
   if (unlikely(setup_state == 0)) {
-    log_error_and_throw(env, "encrypt_string", "setup() not called");
+    log_error_and_throw("encrypt_string", "setup() not called");
   }
 
   if (unlikely(info.Length() < 2)) {
-    log_error_and_throw(env, "encrypt_string", "Wrong number of arguments");
+    log_error_and_throw("encrypt_string", "Wrong number of arguments");
   }
 
   if (unlikely(!info[0].IsString() || !info[1].IsString())) {
-    log_error_and_throw(env, "encrypt_string", "Wrong argument types");
+    log_error_and_throw("encrypt_string", "Wrong argument types");
   }
 
+  Napi::Env env = info.Env();
+
   Napi::String partition_id = info[0].As<Napi::String>();
   char *partition_id_cobhan_buffer;
-  size_t partition_id_copied_bytes = 0;
-  NAPI_STRING_TO_CBUFFER(partition_id, partition_id_cobhan_buffer,
+  size_t partition_id_copied_bytes;
+  NAPI_STRING_TO_CBUFFER(env, partition_id, partition_id_cobhan_buffer,
                          partition_id_copied_bytes, "encrypt_string");
 
   Napi::String input = info[1].As<Napi::String>();
   char *input_cobhan_buffer;
-  size_t input_copied_bytes = 0;
-  NAPI_STRING_TO_CBUFFER(input, input_cobhan_buffer, input_copied_bytes,
+  size_t input_copied_bytes;
+  NAPI_STRING_TO_CBUFFER(env, input, input_cobhan_buffer, input_copied_bytes,
                          "encrypt_string");
 
   Napi::String output =
@@ -242,53 +249,55 @@ Napi::String encrypt_string(const Napi::CallbackInfo &info) {
 }
 
 Napi::Buffer<unsigned char> decrypt(const Napi::CallbackInfo &info) {
-  Napi::Env env = info.Env();
+  std::lock_guard<std::mutex> lock(asherah_lock);
 
   if (unlikely(verbose_flag)) {
     debug_log("decrypt", "called");
   }
 
   if (unlikely(setup_state == 0)) {
-    log_error_and_throw(env, "decrypt", "setup() not called");
+    log_error_and_throw("decrypt", "setup() not called");
   }
 
   if (unlikely(info.Length() < 2)) {
-    log_error_and_throw(env, "decrypt", "Wrong number of arguments");
+    log_error_and_throw("decrypt", "Wrong number of arguments");
   }
 
   if (unlikely(!info[0].IsString() || !info[1].IsString())) {
-    log_error_and_throw(env, "decrypt", "Wrong argument types");
+    log_error_and_throw("decrypt", "Wrong argument types");
   }
 
+  Napi::Env env = info.Env();
+
   Napi::String partition_id = info[0].As<Napi::String>();
   char *partition_id_cobhan_buffer;
-  size_t partition_id_copied_bytes = 0;
-  NAPI_STRING_TO_CBUFFER(partition_id, partition_id_cobhan_buffer,
+  size_t partition_id_copied_bytes;
+  NAPI_STRING_TO_CBUFFER(env, partition_id, partition_id_cobhan_buffer,
                          partition_id_copied_bytes, "decrypt");
 
   Napi::String input = info[1].As<Napi::String>();
   char *input_cobhan_buffer;
-  size_t input_copied_bytes = 0;
-  NAPI_STRING_TO_CBUFFER(input, input_cobhan_buffer, input_copied_bytes,
+  size_t input_copied_bytes;
+  NAPI_STRING_TO_CBUFFER(env, input, input_cobhan_buffer, input_copied_bytes,
                          "decrypt");
 
   char *output_cobhan_buffer;
-  ALLOCATE_OUTPUT_CBUFFER(output_cobhan_buffer, input_copied_bytes, "decrypt");
+  ALLOCATE_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",
+        "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",
+    log_error_and_throw("encrypt_to_json",
                         "Failed initial canary check for input_cobhan_buffer");
   }
   char *output_canary_ptr = get_canary_ptr(output_cobhan_buffer);
   if (unlikely(!check_canary_ptr(output_canary_ptr))) {
-    log_error_and_throw(env, "encrypt_to_json",
+    log_error_and_throw("encrypt_to_json",
                         "Failed initial canary check for output_cobhan_buffer");
   }
 
@@ -307,23 +316,23 @@ Napi::Buffer<unsigned char> decrypt(const Napi::CallbackInfo &info) {
 
   if (unlikely(!check_canary_ptr(partition_id_canary_ptr))) {
     log_error_and_throw(
-        env, "encrypt_to_json",
+        "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",
+        "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",
+        "encrypt_to_json",
         "Failed post-call canary check for output_cobhan_buffer");
   }
 
   if (unlikely(result < 0)) {
     // TODO: Convert this to a proper error message
-    log_error_and_throw(env, "decrypt", std::to_string(result));
+    log_error_and_throw("decrypt", std::to_string(result));
   }
 
   Napi::Buffer<unsigned char> output =
@@ -337,54 +346,55 @@ Napi::Buffer<unsigned char> decrypt(const Napi::CallbackInfo &info) {
 }
 
 Napi::String decrypt_string(const Napi::CallbackInfo &info) {
-  Napi::Env env = info.Env();
+  std::lock_guard<std::mutex> lock(asherah_lock);
 
   if (unlikely(verbose_flag)) {
     debug_log("decrypt_string", "called");
   }
 
   if (unlikely(setup_state == 0)) {
-    log_error_and_throw(env, "decrypt_string", "setup() not called");
+    log_error_and_throw("decrypt_string", "setup() not called");
   }
 
   if (unlikely(info.Length() < 2)) {
-    log_error_and_throw(env, "decrypt_string", "Wrong number of arguments");
+    log_error_and_throw("decrypt_string", "Wrong number of arguments");
   }
 
   if (unlikely(!info[0].IsString() || !info[1].IsString())) {
-    log_error_and_throw(env, "decrypt_string", "Wrong argument types");
+    log_error_and_throw("decrypt_string", "Wrong argument types");
   }
 
+  Napi::Env env = info.Env();
+
   Napi::String partition_id = info[0].As<Napi::String>();
   char *partition_id_cobhan_buffer;
-  size_t partition_id_copied_bytes = 0;
-  NAPI_STRING_TO_CBUFFER(partition_id, partition_id_cobhan_buffer,
+  size_t partition_id_copied_bytes;
+  NAPI_STRING_TO_CBUFFER(env, partition_id, partition_id_cobhan_buffer,
                          partition_id_copied_bytes, "decrypt_string");
 
   Napi::String input = info[1].As<Napi::String>();
   char *input_cobhan_buffer;
-  size_t input_copied_bytes = 0;
-  NAPI_STRING_TO_CBUFFER(input, input_cobhan_buffer, input_copied_bytes,
+  size_t input_copied_bytes;
+  NAPI_STRING_TO_CBUFFER(env, input, input_cobhan_buffer, input_copied_bytes,
                          "decrypt_string");
 
   char *output_cobhan_buffer;
-  ALLOCATE_OUTPUT_CBUFFER(output_cobhan_buffer, input_copied_bytes,
-                          "decrypt_string");
+  ALLOCATE_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",
+        "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",
+    log_error_and_throw("encrypt_to_json",
                         "Failed initial canary check for input_cobhan_buffer");
   }
   char *output_canary_ptr = get_canary_ptr(output_cobhan_buffer);
   if (unlikely(!check_canary_ptr(output_canary_ptr))) {
-    log_error_and_throw(env, "encrypt_to_json",
+    log_error_and_throw("encrypt_to_json",
                         "Failed initial canary check for output_cobhan_buffer");
   }
 
@@ -403,23 +413,23 @@ Napi::String decrypt_string(const Napi::CallbackInfo &info) {
 
   if (unlikely(!check_canary_ptr(partition_id_canary_ptr))) {
     log_error_and_throw(
-        env, "encrypt_to_json",
+        "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",
+        "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",
+        "encrypt_to_json",
         "Failed post-call canary check for output_cobhan_buffer");
   }
 
   if (unlikely(result < 0)) {
     // TODO: Convert this to a proper error message
-    log_error_and_throw(env, "decrypt_string", std::to_string(result));
+    log_error_and_throw("decrypt_string", std::to_string(result));
   }
 
   Napi::String output = cbuffer_to_nstring(env, output_cobhan_buffer);
@@ -432,6 +442,8 @@ Napi::String decrypt_string(const Napi::CallbackInfo &info) {
 }
 
 void shutdown(const Napi::CallbackInfo &info) {
+  std::lock_guard<std::mutex> lock(asherah_lock);
+
   if (unlikely(verbose_flag)) {
     debug_log("shutdown", "called");
   }
@@ -451,14 +463,14 @@ void shutdown(const Napi::CallbackInfo &info) {
 }
 
 void set_max_stack_alloc_item_size(const Napi::CallbackInfo &info) {
-  Napi::Env env = info.Env();
+  std::lock_guard<std::mutex> lock(asherah_lock);
 
   if (unlikely(verbose_flag)) {
     debug_log("set_max_stack_alloc_item_size", "called");
   }
 
   if (unlikely(info.Length() < 1)) {
-    log_error_and_throw(env, "set_max_stack_alloc_item_size",
+    log_error_and_throw("set_max_stack_alloc_item_size",
                         "Wrong number of arguments");
   }
 
@@ -468,20 +480,20 @@ void set_max_stack_alloc_item_size(const Napi::CallbackInfo &info) {
 }
 
 void set_safety_padding_overhead(const Napi::CallbackInfo &info) {
-  Napi::Env env = info.Env();
+  std::lock_guard<std::mutex> lock(asherah_lock);
 
   if (unlikely(verbose_flag)) {
     debug_log("set_safety_padding_overhead", "called");
   }
 
   if (unlikely(info.Length() < 1)) {
-    log_error_and_throw(env, "set_safety_padding_overhead",
+    log_error_and_throw("set_safety_padding_overhead",
                         "Wrong number of arguments");
   }
 
   Napi::Number safety_padding_number = info[0].ToNumber();
 
-  *safety_padding_bytes_ptr = (size_t)safety_padding_number.Int32Value();
+  set_safety_padding_bytes((size_t)safety_padding_number.Int32Value());
 }
 
 Napi::Object Init(Napi::Env env, Napi::Object exports) {

package/src/cobhan.cc

@@ -0,0 +1,2 @@
+#include <stddef.h>
+__attribute__((used)) size_t safety_padding_bytes = 0;

package/src/cobhan.h

@@ -0,0 +1,150 @@
+#ifndef COBHAN_H
+#define COBHAN_H
+#include "logging.h"
+#include <cstdint>
+#include <stddef.h>
+#include <string>
+
+extern size_t safety_padding_bytes;
+
+const size_t cobhan_header_size_bytes = 64 / 8;
+const size_t canary_size = sizeof(int32_t) * 2;
+const int32_t canary_constant = 0xdeadbeef;
+
+__attribute__((always_inline)) inline void
+set_safety_padding_bytes(size_t new_safety_padding_bytes) {
+  safety_padding_bytes = new_safety_padding_bytes;
+}
+
+__attribute__((always_inline)) inline int32_t
+cbuffer_byte_length(char *cobhan_buffer) {
+  return *((int32_t *)cobhan_buffer);
+}
+
+__attribute__((always_inline)) inline char *
+cbuffer_data_ptr(char *cobhan_buffer) {
+  return cobhan_buffer + cobhan_header_size_bytes;
+}
+
+__attribute__((always_inline)) inline size_t
+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; // Add safety padding if configured
+}
+
+__attribute__((always_inline)) inline void
+configure_cbuffer(char *cobhan_buffer, size_t length) {
+  if (unlikely(verbose_flag)) {
+    debug_log("configure_cbuffer", "configure_cbuffer(" +
+                                       format_ptr(cobhan_buffer) + ", " +
+                                       std::to_string(length) + ")");
+  }
+
+  *((int32_t *)cobhan_buffer) = length;
+  // Reserved for future use
+  *((int32_t *)(cobhan_buffer + sizeof(int32_t))) = 0;
+
+  // Write canary values
+  char *data_ptr = cbuffer_data_ptr(cobhan_buffer);
+#ifdef LOG_CANARY_WRITES
+  if (unlikely(verbose_flag)) {
+    debug_log("configure_cbuffer",
+              "Writing first canary at " + format_ptr(data_ptr + length + 1));
+  }
+#endif
+
+  // First canary value is a int32_t 0 which gives us four NULLs
+  *((int32_t *)(data_ptr + length + 1)) = 0;
+#ifdef LOG_CANARY_WRITES
+  if (unlikely(verbose_flag)) {
+    debug_log("configure_cbuffer",
+              "Writing second canary at " +
+                  format_ptr(data_ptr + length + 1 + sizeof(int32_t)));
+  }
+#endif
+
+  // 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_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_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_allocation_size];
+  if (unlikely(cobhan_buffer == nullptr)) {
+    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);
+  return cobhan_buffer_unique_ptr;
+}
+
+#define ALLOCATE_CBUFFER_UNIQUE_PTR(cobhan_buffer, buffer_size, unique_ptr,    \
+                                    function_name)                             \
+  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 */                                 \
+      unique_ptr = heap_allocate_cbuffer(#cobhan_buffer, buffer_size);         \
+      cobhan_buffer = unique_ptr.get();                                        \
+    }                                                                          \
+    if (unlikely(cobhan_buffer == nullptr)) {                                  \
+      log_error_and_throw(function_name,                                       \
+                          "Failed to allocate " #cobhan_buffer);               \
+    }                                                                          \
+  } while (0);
+
+#define ALLOCATE_CBUFFER(cobhan_buffer, buffer_size, function_name)            \
+  std::unique_ptr<char[]> cobhan_buffer##_unique_ptr;                          \
+  ALLOCATE_CBUFFER_UNIQUE_PTR(cobhan_buffer, buffer_size,                      \
+                              cobhan_buffer##_unique_ptr, function_name);
+
+#endif

package/src/cobhan_napi_interop.cc

@@ -1,11 +1,2 @@
 #include <stddef.h>
-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;
-}
+__attribute__((used)) size_t est_intermediate_key_overhead = 0;

package/src/cobhan_napi_interop.h

@@ -1,26 +1,17 @@
 #ifndef COBHAN_NAPI_INTEROP_H
 #define COBHAN_NAPI_INTEROP_H
+#include "cobhan.h"
 #include "hints.h"
 #include "logging.h"
 #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();
-
-size_t *est_intermediate_key_overhead_ptr =
-    get_est_intermediate_key_overhead_ptr();
-size_t *safety_padding_bytes_ptr = get_safety_padding_bytes_ptr();
+extern size_t est_intermediate_key_overhead;
 
 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) {
   case napi_ok:
@@ -72,27 +63,6 @@ std::string napi_status_to_string(napi_status status) {
   }
 }
 
-__attribute__((always_inline)) inline int32_t
-cbuffer_byte_length(char *cobhan_buffer) {
-  return *((int32_t *)cobhan_buffer);
-}
-
-__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();
-}
-
-__attribute__((always_inline)) inline size_t
-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
 estimate_asherah_output_size_bytes(size_t data_byte_len,
                                    size_t partition_byte_len) {
@@ -100,9 +70,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_ptr +
-      partition_byte_len + est_data_byte_len + *safety_padding_bytes_ptr);
+  size_t asherah_output_size_bytes =
+      size_t(est_envelope_overhead + est_intermediate_key_overhead +
+             partition_byte_len + est_data_byte_len);
   if (unlikely(verbose_flag)) {
     std::string log_msg =
         "estimate_asherah_output_size(" + std::to_string(data_byte_len) + ", " +
@@ -115,118 +85,6 @@ 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_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_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_allocation_size];
-  if (unlikely(cobhan_buffer == nullptr)) {
-    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_ptr);
-  return cobhan_buffer_unique_ptr;
-}
-
-__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) {
-    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, cbuffer_data_ptr(cobhan_buffer), cobhan_buffer_size_bytes, &output);
-
-  if (unlikely(status != napi_ok)) {
-    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;
@@ -234,9 +92,9 @@ nstring_utf8_byte_length(Napi::Env &env, Napi::String &str) {
 
   status = napi_get_value_string_utf8(env, str, nullptr, 0, &utf8_length);
   if (unlikely(status != napi_ok)) {
-    log_error_and_throw(env, "nstring_utf8_length",
-                        "napi_get_value_string_utf8 length check failed: " +
-                            napi_status_to_string(status));
+    error_log("nstring_utf8_length",
+              "napi_get_value_string_utf8 length check failed: " +
+                  napi_status_to_string(status));
     return (size_t)(-1);
   }
 
@@ -250,24 +108,21 @@ copy_nstring_to_cbuffer(Napi::Env &env, Napi::String &str,
 
   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");
+    error_log("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");
+    error_log("copy_nstring_to_cbuffer", "String too large for cobhan buffer");
     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)));
+                  format_ptr(cbuffer_data_ptr(cobhan_buffer)) + " - " +
+                  format_ptr((cbuffer_data_ptr(cobhan_buffer) +
+                              str_utf8_byte_length)));
   }
 
   napi_status status;
@@ -278,17 +133,17 @@ copy_nstring_to_cbuffer(Napi::Env &env, Napi::String &str,
   status = napi_get_value_string_utf8(env, str, cbuffer_data_ptr(cobhan_buffer),
                                       str_utf8_byte_length + 1, &copied_bytes);
   if (unlikely(status != napi_ok)) {
-    log_error_and_throw(env, "copy_nstring_to_cbuffer",
-                        "Napi utf8 string conversion failure: " +
-                            napi_status_to_string(status));
+    error_log("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));
+    error_log("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;
   }
 
@@ -299,34 +154,34 @@ copy_nstring_to_cbuffer(Napi::Env &env, Napi::String &str,
   return cobhan_buffer;
 }
 
-__attribute__((always_inline)) inline char *
-copy_nbuffer_to_cbuffer(Napi::Env &env, Napi::Buffer<unsigned char> &nbuffer,
-                        char *cobhan_buffer) {
+__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 (unlikely(cobhan_buffer_size_bytes <= 0)) {
-    log_error_and_throw(env, "copy_nbuffer_to_cbuffer",
+  if (cobhan_buffer_size_bytes <= 0) {
+    log_error_and_throw("cbuffer_to_nstring",
                         "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;
+  // Using C function because it allows length delimited input
+  napi_status status = napi_create_string_utf8(
+      env, cbuffer_data_ptr(cobhan_buffer), cobhan_buffer_size_bytes, &output);
+
+  if (unlikely(status != napi_ok)) {
+    log_error_and_throw("cbuffer_to_nstring",
+                        "napi_create_string_utf8 failed: " +
+                            napi_status_to_string(status));
   }
-  memcpy(cbuffer_data_ptr(cobhan_buffer), nbuffer.Data(), nbuffer_byte_length);
-  configure_cbuffer(cobhan_buffer, nbuffer_byte_length);
-  return cobhan_buffer;
+
+  return Napi::String(env, output);
 }
 
 __attribute__((always_inline)) inline Napi::Buffer<unsigned char>
 cbuffer_to_nbuffer(Napi::Env &env, char *cobhan_buffer) {
   int32_t cobhan_buffer_byte_length = cbuffer_byte_length(cobhan_buffer);
   if (unlikely(cobhan_buffer_byte_length <= 0)) {
-    log_error_and_throw(env, "cbuffer_to_nbuffer",
+    log_error_and_throw("cbuffer_to_nbuffer",
                         "Invalid cobhan buffer byte length");
   }
 
@@ -337,7 +192,7 @@ cbuffer_to_nbuffer(Napi::Env &env, char *cobhan_buffer) {
   }
 
   if (unlikely(cobhan_buffer_byte_length <= 0)) {
-    log_error_and_throw(env, "cbuffer_to_nbuffer",
+    log_error_and_throw("cbuffer_to_nbuffer",
                         "Invalid cobhan buffer byte length");
   }
 
@@ -353,115 +208,75 @@ cbuffer_to_nbuffer(Napi::Env &env, char *cobhan_buffer) {
   return nbuffer;
 }
 
+__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)) {
+    error_log("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) {
+    error_log("copy_nbuffer_to_cbuffer", "Buffer too large for cobhan buffer");
+    return nullptr;
+  }
+  memcpy(cbuffer_data_ptr(cobhan_buffer), nbuffer.Data(), nbuffer_byte_length);
+  configure_cbuffer(cobhan_buffer, nbuffer_byte_length);
+  return cobhan_buffer;
+}
+
 // These are macros due to the use of alloca()
 
-#define NAPI_STRING_TO_CBUFFER(napi_string, cobhan_buffer, bytes_copied,       \
+#define NAPI_STRING_TO_CBUFFER(env, napi_string, cobhan_buffer, bytes_copied,  \
                                function_name)                                  \
-  std::unique_ptr<char[]> napi_string##_cobhan_buffer_unique_ptr;              \
+  std::unique_ptr<char[]> napi_string##_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,                                  \
+      log_error_and_throw(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");       \
+      log_error_and_throw(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");                                   \
-    }                                                                          \
+    ALLOCATE_CBUFFER_UNIQUE_PTR(cobhan_buffer, napi_string##_utf8_byte_length, \
+                                napi_string##_unique_ptr, function_name);      \
     /* 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,                                  \
+      log_error_and_throw(function_name,                                       \
                           "Failed to copy " #napi_string " to cobhan buffer"); \
     }                                                                          \
   } while (0);
 
-#define NAPI_BUFFER_TO_CBUFFER(napi_buffer, cobhan_buffer, bytes_copied,       \
+#define NAPI_BUFFER_TO_CBUFFER(env, 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");       \
+      log_error_and_throw(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);               \
-    }                                                                          \
+    ALLOCATE_CBUFFER_UNIQUE_PTR(cobhan_buffer, napi_buffer##_byte_length,      \
+                                napi_buffer##_unique_ptr, function_name);      \
     /* Copy */                                                                 \
     cobhan_buffer = copy_nbuffer_to_cbuffer(env, napi_buffer, cobhan_buffer);  \
     if (unlikely(cobhan_buffer == nullptr)) {                                  \
-      log_error_and_throw(env, function_name,                                  \
+      log_error_and_throw(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

package/src/logging.cc

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

package/src/logging.h

@@ -2,11 +2,22 @@
 #define LOGGING_H
 #include "hints.h"
 #include <cstdint>
-#include <string>
+#include <iomanip>
 #include <iostream>
+#include <sstream>
+#include <string>
 
 extern int32_t verbose_flag;
 
+__attribute__((always_inline)) inline void debug_log(const char *function_name,
+                                                     const char *message) {
+  if (unlikely(verbose_flag)) {
+    std::cerr << "asherah-node: [DEBUG] " << function_name << ": " << message
+              << std::endl
+              << std::flush;
+  }
+}
+
 __attribute__((always_inline)) inline void debug_log(const char *function_name,
                                                      std::string message) {
   if (unlikely(verbose_flag)) {
@@ -27,6 +38,15 @@ debug_log_alloca(const char *function_name, const char *variable_name,
   }
 }
 
+__attribute__((always_inline)) inline void error_log(const char *function_name,
+                                                     const char *message) {
+  if (unlikely(verbose_flag)) {
+    std::cerr << "asherah-node: [ERROR] " << function_name << ": " << message
+              << std::endl
+              << std::flush;
+  }
+}
+
 __attribute__((always_inline)) inline void error_log(const char *function_name,
                                                      std::string message) {
   if (unlikely(verbose_flag)) {
@@ -36,4 +56,16 @@ __attribute__((always_inline)) inline void error_log(const char *function_name,
   }
 }
 
+__attribute__((always_inline)) inline std::string format_ptr(char *ptr) {
+  std::ostringstream ss;
+  ss << "0x" << std::hex << (intptr_t)ptr;
+  return ss.str();
+}
+
+__attribute__((always_inline, noreturn)) inline void
+log_error_and_throw(const char *function_name, std::string error_msg) {
+  error_log(function_name, error_msg);
+  throw new std::runtime_error(function_name + (": " + error_msg));
+}
+
 #endif