asherah 3.0.3 → 3.0.5

package/binding.gyp

@@ -14,19 +14,21 @@
           '-g',
           '-O3',
           '-std=c++17',
-          '-fPIC'
+          '-fPIC',
+          '-Wno-unknown-pragmas'
         ],
       },
       'defines': [ 
         'NAPI_CPP_EXCEPTIONS',
         'NODE_API_SWALLOW_UNTHROWABLE_EXCEPTIONS',
         'NODE_ADDON_API_DISABLE_DEPRECATED',
-        'NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED'
+        'NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED',
+        'USE_SCOPED_ALLOCATE_BUFFER',
         ],
       'sources': [
         'src/asherah.cc',
-        'src/logging.cc',
-        'src/logging_napi.cc'
+        'src/logging_napi.cc',
+        'src/logging_stderr.cc'
       ],
       'libraries': [ '../lib/libasherah.a' ]
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "asherah",
-  "version": "3.0.3",
+  "version": "3.0.5",
   "description": "Asherah envelope encryption and key rotation library",
   "exports": {
     "node-addons": "./dist/asherah.node"
@@ -11,7 +11,7 @@
   },
   "scripts": {
     "preinstall": "scripts/download-libraries.sh",
-    "load": "node --max-old-space-size=500 scripts/dumpster-fire.js",
+    "load": "node --max-old-space-size=500 scripts/dumpster-fire-memory.js",
     "install": "scripts/build.sh",
     "test:mocha-debug": "lldb -o run -- node node_modules/mocha/bin/mocha --inspect-brk",
     "test:mocha": "mocha",
@@ -30,10 +30,11 @@
     "src/cobhan_buffer_napi.h",
     "src/cobhan_buffer.h",
     "src/hints.h",
-    "src/logging.cc",
     "src/logging.h",
     "src/logging_napi.cc",
     "src/logging_napi.h",
+    "src/logging_stderr.cc",
+    "src/logging_stderr.h",
     "src/napi_utils.h",
     "src/scoped_allocate.h",
     "src/asherah.d.ts",
@@ -70,6 +71,6 @@
   },
   "types": "dist/asherah.d.ts",
   "dependencies": {
-    "node-addon-api": "7.0.0"
+    "node-addon-api": "^7.0.0"
   }
 }

package/scripts/build.sh

@@ -1,3 +1,16 @@
 #!/bin/bash
 
-node-gyp configure && node-gyp build && mkdir -p dist/ && cp build/Release/asherah.node dist/asherah.node && cp src/asherah.d.ts dist/asherah.d.ts
+set -e
+
+mkdir -p dist/
+
+# Check if USE_CMAKE is set to 1
+if [ "$USE_CMAKE" = "1" ]; then
+    # Run CMake commands
+    (cmake . && make) || exit 1
+else
+    # Run node-gyp commands
+    node-gyp configure && node-gyp build && cp build/Release/asherah.node dist/asherah.node
+fi
+
+cp src/asherah.d.ts dist/asherah.d.ts

package/src/asherah.cc

@@ -1,21 +1,16 @@
+#pragma clang diagnostic push
+#pragma ide diagnostic ignored "readability-convert-member-functions-to-static"
 
-#define USE_SCOPE_ALLOCATE_BUFFER 1
 #include "asherah_async_worker.h"
 #include "cobhan_buffer_napi.h"
 #include "hints.h"
 #include "libasherah.h"
 #include "logging_napi.h"
 #include "napi_utils.h"
-#ifdef USE_SCOPED_ALLOCATE_BUFFER
 #include "scoped_allocate.h"
-#endif
 #include <atomic>
 #include <napi.h>
 
-#ifndef NAPI_CPP_EXCEPTIONS
-#error Support for C++ exceptions is required
-#endif
-
 static volatile std::atomic<int32_t> setup_state{0};
 
 class Asherah : public Napi::Addon<Asherah> {
@@ -71,7 +66,7 @@ private:
       char *config_cbuffer;
       size_t config_cbuffer_size =
           CobhanBufferNapi::StringToAllocationSize(env, config_string);
-      SCOPED_ALLOCATE_BUFFER(logger, config_cbuffer, config_cbuffer_size,
+      SCOPED_ALLOCATE_BUFFER(config_cbuffer, config_cbuffer_size,
                              maximum_stack_alloc_size, __func__);
 
       CobhanBufferNapi config(env, config_string, config_cbuffer,
@@ -82,9 +77,13 @@ private:
 
       // extern GoInt32 SetupJson(void* configJson);
       GoInt32 result = SetupJson(config);
-      EndSetupAsherah(result, product_id_length, service_name_length);
+      EndSetupAsherah(env, result, product_id_length, service_name_length);
+    } catch (Napi::Error &e) {
+      e.ThrowAsJavaScriptException();
+      return;
     } catch (const std::exception &e) {
-      logger.log_error_and_throw(__func__, e.what());
+      Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+      return;
     }
   }
 
@@ -105,8 +104,12 @@ private:
                                            service_name_length);
       worker->Queue();
       return worker->Promise();
+    } catch (Napi::Error &e) {
+      e.ThrowAsJavaScriptException();
+      return env.Undefined();
     } catch (const std::exception &e) {
-      logger.log_error_and_throw(__func__, e.what());
+      Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+      return env.Undefined();
     }
   }
 
@@ -116,9 +119,13 @@ private:
     try {
       BeginShutdownAsherah(env, __func__, info);
       Shutdown();
-      EndShutdownAsherah();
+      EndShutdownAsherah(env);
+    } catch (Napi::Error &e) {
+      e.ThrowAsJavaScriptException();
+      return;
     } catch (const std::exception &e) {
-      logger.log_error_and_throw(__func__, e.what());
+      Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+      return;
     }
   }
 
@@ -130,8 +137,12 @@ private:
       auto worker = new ShutdownAsherahWorker(env, this);
       worker->Queue();
       return worker->Promise();
+    } catch (Napi::Error &e) {
+      e.ThrowAsJavaScriptException();
+      return env.Undefined();
     } catch (const std::exception &e) {
-      logger.log_error_and_throw(__func__, e.what());
+      Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+      return env.Undefined();
     }
   }
 
@@ -150,14 +161,13 @@ private:
       char *partition_id_cbuffer;
       size_t partition_id_cbuffer_size =
           CobhanBufferNapi::StringToAllocationSize(env, partition_id_string);
-      SCOPED_ALLOCATE_BUFFER(logger, partition_id_cbuffer,
-                             partition_id_cbuffer_size,
+      SCOPED_ALLOCATE_BUFFER(partition_id_cbuffer, partition_id_cbuffer_size,
                              maximum_stack_alloc_size, __func__);
 
       char *input_cbuffer;
       size_t input_cbuffer_size =
           CobhanBufferNapi::ValueToAllocationSize(env, input_value);
-      SCOPED_ALLOCATE_BUFFER(logger, input_cbuffer, input_cbuffer_size,
+      SCOPED_ALLOCATE_BUFFER(input_cbuffer, input_cbuffer_size,
                              maximum_stack_alloc_size, __func__);
 
       CobhanBufferNapi partition_id(env, partition_id_string,
@@ -179,19 +189,22 @@ private:
       char *output_cobhan_buffer;
       size_t output_size_bytes =
           CobhanBuffer::DataSizeToAllocationSize(asherah_output_size_bytes);
-      SCOPED_ALLOCATE_BUFFER(logger, output_cobhan_buffer, output_size_bytes,
+      SCOPED_ALLOCATE_BUFFER(output_cobhan_buffer, output_size_bytes,
                              maximum_stack_alloc_size, __func__);
-      CobhanBufferNapi output(output_cobhan_buffer, output_size_bytes);
+      CobhanBufferNapi output(env, output_cobhan_buffer, output_size_bytes);
 #else
-      CobhanBufferNapi output(asherah_output_size_bytes);
+      CobhanBufferNapi output(env, asherah_output_size_bytes);
 #endif
 
       GoInt32 result = EncryptToJson(partition_id, input, output);
 
       EndEncryptToJson(env, output, result, output_string);
-
+    } catch (Napi::Error &e) {
+      e.ThrowAsJavaScriptException();
+      return env.Undefined();
     } catch (const std::exception &e) {
-      logger.log_error_and_throw(__func__, e.what());
+      Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+      return env.Undefined();
     }
 
     return output_string;
@@ -214,14 +227,18 @@ private:
       size_t asherah_output_size_bytes = EstimateAsherahOutputSize(
           input_data_len_bytes, partition_id_data_len_bytes);
 
-      CobhanBufferNapi output(asherah_output_size_bytes);
+      CobhanBufferNapi output(env, asherah_output_size_bytes);
 
       auto worker =
           new EncryptAsherahWorker(env, this, partition_id, input, output);
       worker->Queue();
       return worker->Promise();
+    } catch (Napi::Error &e) {
+      e.ThrowAsJavaScriptException();
+      return env.Undefined();
     } catch (const std::exception &e) {
-      logger.log_error_and_throw(__func__, e.what());
+      Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+      return env.Undefined();
     }
   }
 
@@ -240,14 +257,13 @@ private:
       char *partition_id_cbuffer;
       size_t partition_id_cbuffer_size =
           CobhanBufferNapi::StringToAllocationSize(env, partition_id_string);
-      SCOPED_ALLOCATE_BUFFER(logger, partition_id_cbuffer,
-                             partition_id_cbuffer_size,
+      SCOPED_ALLOCATE_BUFFER(partition_id_cbuffer, partition_id_cbuffer_size,
                              maximum_stack_alloc_size, __func__);
 
       char *input_cbuffer;
       size_t input_cbuffer_size =
           CobhanBufferNapi::ValueToAllocationSize(env, input_value);
-      SCOPED_ALLOCATE_BUFFER(logger, input_cbuffer, input_cbuffer_size,
+      SCOPED_ALLOCATE_BUFFER(input_cbuffer, input_cbuffer_size,
                              maximum_stack_alloc_size, __func__);
 
       CobhanBufferNapi partition_id(env, partition_id_string,
@@ -259,25 +275,30 @@ private:
       char *output_cobhan_buffer;
       size_t output_size_bytes =
           CobhanBuffer::DataSizeToAllocationSize(input.get_data_len_bytes());
-      SCOPED_ALLOCATE_BUFFER(logger, output_cobhan_buffer, output_size_bytes,
+      SCOPED_ALLOCATE_BUFFER(output_cobhan_buffer, output_size_bytes,
                              maximum_stack_alloc_size, __func__);
-      CobhanBufferNapi output(output_cobhan_buffer, output_size_bytes);
+      CobhanBufferNapi output(env, output_cobhan_buffer, output_size_bytes);
 #else
       CobhanBufferNapi partition_id(env, partition_id_string);
       CobhanBufferNapi input(env, input_value);
-      CobhanBufferNapi output(input.get_data_len_bytes());
+      CobhanBufferNapi output(env, input.get_data_len_bytes());
 #endif
 
       // extern GoInt32 DecryptFromJson(void* partitionIdPtr, void* jsonPtr,
       // void* dataPtr);
       GoInt32 result = DecryptFromJson(partition_id, input, output);
 
-      CheckResult(result);
+      CheckResult(env, result);
 
-      output_value = output.ToBuffer(env); // NOLINT(*-slicing)
+      output_value = output.ToBuffer(); // NOLINT(*-slicing)
+    } catch (Napi::Error &e) {
+      e.ThrowAsJavaScriptException();
+      return env.Undefined();
     } catch (const std::exception &e) {
-      logger.log_error_and_throw(__func__, e.what());
+      Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+      return env.Undefined();
     }
+
     return output_value;
   }
 
@@ -293,13 +314,17 @@ private:
       CobhanBufferNapi partition_id(env, partition_id_string);
       CobhanBufferNapi input(env, input_value);
 
-      CobhanBufferNapi output(input.get_data_len_bytes());
+      CobhanBufferNapi output(env, input.get_data_len_bytes());
       auto worker = new DecryptFromJsonWorker<Napi::Buffer<unsigned char>>(
           env, this, partition_id, input, output);
       worker->Queue();
       return worker->Promise();
+    } catch (Napi::Error &e) {
+      e.ThrowAsJavaScriptException();
+      return env.Undefined();
     } catch (const std::exception &e) {
-      logger.log_error_and_throw(__func__, e.what());
+      Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+      return env.Undefined();
     }
   }
 
@@ -310,10 +335,6 @@ private:
     try {
       NapiUtils::RequireParameterCount(info, 2);
 
-      if (unlikely(!info[0].IsString() || !info[1].IsString())) {
-        logger.log_error_and_throw(__func__, "Wrong argument types");
-      }
-
       Napi::String partition_id_string;
       Napi::Value input_value;
       BeginDecryptFromJson(env, __func__, info, partition_id_string,
@@ -323,14 +344,13 @@ private:
       char *partition_id_cbuffer;
       size_t partition_id_cbuffer_size =
           CobhanBufferNapi::StringToAllocationSize(env, partition_id_string);
-      SCOPED_ALLOCATE_BUFFER(logger, partition_id_cbuffer,
-                             partition_id_cbuffer_size,
+      SCOPED_ALLOCATE_BUFFER(partition_id_cbuffer, partition_id_cbuffer_size,
                              maximum_stack_alloc_size, __func__);
 
       char *input_cbuffer;
       size_t input_cbuffer_size =
           CobhanBufferNapi::ValueToAllocationSize(env, input_value);
-      SCOPED_ALLOCATE_BUFFER(logger, input_cbuffer, input_cbuffer_size,
+      SCOPED_ALLOCATE_BUFFER(input_cbuffer, input_cbuffer_size,
                              maximum_stack_alloc_size, __func__);
 
       CobhanBufferNapi partition_id(env, partition_id_string,
@@ -339,18 +359,22 @@ private:
       CobhanBufferNapi input(env, input_value, input_cbuffer,
                              input_cbuffer_size);
 
-      CobhanBufferNapi output(input.get_data_len_bytes());
+      CobhanBufferNapi output(env, input.get_data_len_bytes());
 #else
       CobhanBufferNapi partition_id(env, partition_id_string);
       CobhanBufferNapi input(env, input_value);
-      CobhanBufferNapi output(input.get_data_len_bytes());
+      CobhanBufferNapi output(env, input.get_data_len_bytes());
 #endif
 
       GoInt32 result = DecryptFromJson(partition_id, input, output);
 
       EndDecryptFromJson(env, output, result, output_string);
+    } catch (Napi::Error &e) {
+      e.ThrowAsJavaScriptException();
+      return env.Undefined();
     } catch (const std::exception &e) {
-      logger.log_error_and_throw(__func__, e.what());
+      Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+      return env.Undefined();
     }
     return output_string;
   }
@@ -361,10 +385,6 @@ private:
     try {
       NapiUtils::RequireParameterCount(info, 2);
 
-      if (unlikely(!info[0].IsString() || !info[1].IsString())) {
-        logger.log_error_and_throw(__func__, "Wrong argument types");
-      }
-
       Napi::String partition_id_string;
       Napi::Value input_value;
       BeginDecryptFromJson(env, __func__, info, partition_id_string,
@@ -373,58 +393,103 @@ private:
       CobhanBufferNapi partition_id(env, partition_id_string);
       CobhanBufferNapi input(env, input_value);
 
-      CobhanBufferNapi output(input.get_data_len_bytes());
+      CobhanBufferNapi output(env, input.get_data_len_bytes());
 
       auto worker = new DecryptFromJsonWorker<Napi::String>(
           env, this, partition_id, input, output);
       worker->Queue();
 
       return worker->Promise();
+    } catch (Napi::Error &e) {
+      e.ThrowAsJavaScriptException();
+      return env.Undefined();
     } catch (const std::exception &e) {
-      logger.log_error_and_throw(__func__, e.what());
+      Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+      return env.Undefined();
     }
   }
 
   void SetMaxStackAllocItemSize(const Napi::CallbackInfo &info) {
-    NapiUtils::RequireParameterCount(info, 1);
+    Napi::Env env = info.Env();
+    Napi::HandleScope scope(env);
+    try {
+      NapiUtils::RequireParameterCount(info, 1);
 
-    Napi::Number item_size = info[0].ToNumber();
-    auto new_size = (size_t)item_size.Int32Value();
+      Napi::Number item_size = info[0].ToNumber();
+      auto new_size = (size_t)item_size.Int32Value();
 
-    maximum_stack_alloc_size = new_size;
+      maximum_stack_alloc_size = new_size;
+    } catch (Napi::Error &e) {
+      e.ThrowAsJavaScriptException();
+      return;
+    } catch (const std::exception &e) {
+      Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+      return;
+    }
   }
 
   void SetSafetyPaddingOverhead(const Napi::CallbackInfo &info) {
-    NapiUtils::RequireParameterCount(info, 1);
-
-    // Napi::Number safety_padding_number = info[0].ToNumber();
-    // auto new_safety_padding_bytes = (size_t)
-    // safety_padding_number.Int32Value(); Safety padding size is now fixed -
-    // ignore the input set_safety_padding_bytes(new_safety_padding_bytes);
+    Napi::Env env = info.Env();
+    Napi::HandleScope scope(env);
+    try {
+      NapiUtils::RequireParameterCount(info, 1);
+
+      // Napi::Number safety_padding_number = info[0].ToNumber();
+      // auto new_safety_padding_bytes = (size_t)
+      // safety_padding_number.Int32Value(); Safety padding size is now fixed -
+      // ignore the input set_safety_padding_bytes(new_safety_padding_bytes);
+    } catch (Napi::Error &e) {
+      e.ThrowAsJavaScriptException();
+      return;
+    } catch (const std::exception &e) {
+      Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+      return;
+    }
   }
 
   Napi::Value
   GetSetupStatus(const Napi::CallbackInfo
                      &info) { // NOLINT(*-convert-member-functions-to-static)
-    int32_t setup_status = setup_state.load(std::memory_order_acquire);
-    return Napi::Boolean::New(info.Env(), setup_status != 0);
+    Napi::Env env = info.Env();
+    Napi::HandleScope scope(env);
+    try {
+      int32_t setup_status = setup_state.load(std::memory_order_acquire);
+      return Napi::Boolean::New(info.Env(), setup_status != 0);
+    } catch (Napi::Error &e) {
+      e.ThrowAsJavaScriptException();
+      return env.Undefined();
+    } catch (const std::exception &e) {
+      Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+      return env.Undefined();
+    }
   }
 
   void SetLogHook(const Napi::CallbackInfo &info) {
-    NapiUtils::RequireParameterCount(info, 1);
 
-    if (unlikely(!info[0].IsFunction())) {
-      logger.log_error_and_throw(__func__, "Wrong argument type");
-    }
+    Napi::Env env = info.Env();
+    Napi::HandleScope scope(env);
+    try {
+      NapiUtils::RequireParameterCount(info, 1);
 
-    logger.set_log_hook(info[0].As<Napi::Function>());
+      if (unlikely(!info[0].IsFunction())) {
+        NapiUtils::ThrowException(info.Env(), "Expected a function");
+      }
+
+      logger.set_log_hook(info[0].As<Napi::Function>());
+    } catch (Napi::Error &e) {
+      e.ThrowAsJavaScriptException();
+      return;
+    } catch (const std::exception &e) {
+      Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+      return;
+    }
   }
 
   void BeginSetupAsherah(const Napi::Env &env, const char *func_name,
                          const Napi::CallbackInfo &info,
                          Napi::String &config_string, size_t &product_id_length,
                          size_t &service_name_length) {
-    RequireAsherahNotSetup(func_name);
+    RequireAsherahNotSetup(env, func_name);
 
     NapiUtils::RequireParameterCount(info, 1);
 
@@ -444,22 +509,23 @@ private:
     verbose_flag = verbose;
   }
 
-  void EndSetupAsherah(GoInt32 result, size_t product_id_length,
-                       size_t service_name_length) {
-    CheckResult(result);
+  void EndSetupAsherah(const Napi::Env &env, GoInt32 result,
+                       size_t product_id_length, size_t service_name_length) {
+    CheckResult(env, result);
 
     est_intermediate_key_overhead = product_id_length + service_name_length;
 
     auto old_setup_state = setup_state.exchange(1, std::memory_order_acq_rel);
     if (unlikely(old_setup_state != 0)) {
-      logger.log_error_and_throw(__func__, "lost race to mark setup_state!");
+      NapiUtils::ThrowException(
+          env, "EndSetupAsherah: lost race to mark setup_state?!");
     }
   }
 
   void BeginEncryptToJson(const Napi::Env &env, const char *func_name,
                           const Napi::CallbackInfo &info,
                           Napi::String &partition_id, Napi::Value &input) {
-    RequireAsherahSetup(func_name);
+    RequireAsherahSetup(env, func_name);
 
     NapiUtils::RequireParameterCount(info, 2);
 
@@ -469,22 +535,23 @@ private:
 
   void EndEncryptToJson(Napi::Env env, CobhanBufferNapi &output, GoInt32 result,
                         Napi::String &output_string) {
-    CheckResult(result);
+    CheckResult(env, result);
 
-    output_string = output.ToString(env);
+    output_string = output.ToString();
   }
 
-  void EndEncryptToJson(Napi::Env env, CobhanBufferNapi &output, GoInt32 result,
-                        Napi::Buffer<unsigned char> &output_buffer) {
-    CheckResult(result);
+  [[maybe_unused]] void
+  EndEncryptToJson(Napi::Env env, CobhanBufferNapi &output, GoInt32 result,
+                   Napi::Buffer<unsigned char> &output_buffer) {
+    CheckResult(env, result);
 
-    output_buffer = output.ToBuffer(env);
+    output_buffer = output.ToBuffer();
   }
 
   void BeginDecryptFromJson(const Napi::Env &env, const char *func_name,
                             const Napi::CallbackInfo &info,
                             Napi::String &partition_id, Napi::Value &input) {
-    RequireAsherahSetup(func_name);
+    RequireAsherahSetup(env, func_name);
 
     NapiUtils::RequireParameterCount(info, 2);
 
@@ -495,28 +562,29 @@ private:
   void EndDecryptFromJson(Napi::Env &env, CobhanBufferNapi &output,
                           GoInt32 result,
                           Napi::Buffer<unsigned char> &output_buffer) {
-    CheckResult(result);
+    CheckResult(env, result);
 
-    output_buffer = output.ToBuffer(env);
+    output_buffer = output.ToBuffer();
   }
 
   void EndDecryptFromJson(Napi::Env &env, CobhanBufferNapi &output,
                           GoInt32 result, Napi::String &output_string) {
-    CheckResult(result);
+    CheckResult(env, result);
 
-    output_string = output.ToString(env);
+    output_string = output.ToString();
   }
 
-  void BeginShutdownAsherah(const Napi::Env &, const char *func_name,
+  void BeginShutdownAsherah(const Napi::Env &env, const char *func_name,
                             const Napi::CallbackInfo &info) {
-    RequireAsherahSetup(func_name);
+    RequireAsherahSetup(env, func_name);
     NapiUtils::RequireParameterCount(info, 0);
   }
 
-  void EndShutdownAsherah() {
+  void EndShutdownAsherah(Napi::Env &env) {
     auto old_setup_state = setup_state.exchange(0, std::memory_order_acq_rel);
     if (unlikely(old_setup_state == 0)) {
-      logger.log_error_and_throw(__func__, "lost race to mark setup_state!");
+      NapiUtils::ThrowException(
+          env, "EndSetupAsherah: lost race to mark setup_state?!");
     }
   }
 
@@ -536,7 +604,8 @@ private:
     GoInt32 ExecuteTask() override { return SetupJson(config); }
 
     Napi::Value OnOKTask(Napi::Env &env) override {
-      asherah->EndSetupAsherah(result, product_id_length, service_name_length);
+      asherah->EndSetupAsherah(env, result, product_id_length,
+                               service_name_length);
       return env.Undefined();
     }
 
@@ -590,10 +659,10 @@ private:
     Napi::Value OnOKTask(Napi::Env &env) override {
       T output_result;
       asherah->EndDecryptFromJson(env, output, result, output_result);
-      return output_result;
+      return output_result; // NOLINT(*-slicing)
     }
 
-  protected:
+  private:
     CobhanBufferNapi partition_id;
     CobhanBufferNapi input;
     CobhanBufferNapi output;
@@ -610,7 +679,7 @@ private:
     }
 
     Napi::Value OnOKTask(Napi::Env &env) override {
-      asherah->EndShutdownAsherah();
+      asherah->EndShutdownAsherah(env);
       return env.Undefined();
     }
   };
@@ -619,26 +688,31 @@ private:
 
 #pragma region Helpers
 
-  void CheckResult(GoInt32 result) {
+  void CheckResult(const Napi::Env &env, GoInt32 result) {
     if (unlikely(result < 0)) {
-      logger.log_error_and_throw(__func__, AsherahCobhanErrorToString(result));
+      NapiUtils::ThrowException(env, AsherahCobhanErrorToString(result));
     }
   }
 
-  void RequireAsherahSetup(const char *func_name) {
+  void RequireAsherahSetup(const Napi::Env &env, const char *func_name) {
     if (unlikely(setup_state.load(std::memory_order_acquire) == 0)) {
-      logger.log_error_and_throw(func_name, "setup() not called");
+      NapiUtils::ThrowException(
+          env,
+          std::string(func_name) + ": RequireAsherahSetup: setup() not called");
     }
   }
 
-  void RequireAsherahNotSetup(const char *func_name) {
+  void RequireAsherahNotSetup(const Napi::Env &env, const char *func_name) {
     if (unlikely(setup_state.load(std::memory_order_acquire) != 0)) {
-      logger.log_error_and_throw(func_name, "setup() already called");
+      NapiUtils::ThrowException(
+          env, std::string(func_name) +
+                   ": RequireAsherahNotSetup: setup() already called");
     }
   }
 
-  __attribute__((always_inline)) inline size_t
-  EstimateAsherahOutputSize(size_t data_byte_len, size_t partition_byte_len) {
+  [[nodiscard]] __attribute__((always_inline)) inline size_t
+  EstimateAsherahOutputSize(size_t data_byte_len,
+                            size_t partition_byte_len) const {
     const size_t est_encryption_overhead = 48;
     const size_t est_envelope_overhead = 185;
     const double base64_overhead = 1.34;
@@ -697,3 +771,5 @@ private:
 };
 
 NODE_API_NAMED_ADDON(asherah, Asherah)
+
+#pragma clang diagnostic pop

package/src/asherah.d.ts

@@ -1,3 +1,5 @@
+// noinspection JSUnusedGlobalSymbols,DuplicatedCode
+
 /// <reference types="node" />
 export type AsherahConfig = {
     /** The name of this service (Required) */