asherah 3.0.16 → 4.0.0-beta.2

package/src/asherah.d.ts

@@ -1,65 +0,0 @@
-// noinspection JSUnusedGlobalSymbols,DuplicatedCode
-
-/// <reference types="node" />
-export type AsherahConfig = {
-    /** The name of this service (Required) */
-    ServiceName: string;
-    /** The name of the product that owns this service (Required) */
-    ProductID: string;
-    /** The amount of time a key is considered valid */
-    ExpireAfter: number | null;
-    /** The amount of time before cached keys are considered stale */
-    CheckInterval: number | null;
-    /** Determines the type of metastore to use for persisting keys (Required) { "rdbms", "dynamodb", "memory" } */
-    Metastore: string;
-    /** The database connection string (Required if metastore=rdbms) */
-    ConnectionString: string | null;
-    /** Required for Aurora sessions using write forwarding { "eventual", "global", "session" } */
-    ReplicaReadConsistency: string | null;
-    /** An optional endpoint URL (hostname only or fully qualified URI) (only supported by metastore=dynamodb) */
-    DynamoDBEndpoint: string | null;
-    /** The AWS region for DynamoDB requests (defaults to globally configured region) (only supported by metastore=dynamodb) */
-    DynamoDBRegion: string | null;
-    /** The table name for DynamoDB (only supported by metastore=dynamodb) */
-    DynamoDBTableName: string | null;
-    /** Define the maximum number of sessions to cache (Default 1000) */
-    SessionCacheMaxSize: number | null;
-    /** The amount of time a session will remain cached (Default 2h) */
-    SessionCacheDuration: number | null;
-    /** Configures the master key management service (Default kms) { "aws", "static" } */
-    KMS: string | null;
-    /** Dictionary of REGION: ARN (required if kms=aws) */
-    RegionMap: {
-        [name: string]: string;
-    } | null;
-    /** The preferred AWS region (required if kms=aws) */
-    PreferredRegion: string | null;
-    /** Configure the metastore to use regional suffixes (only supported by metastore=dynamodb) */
-    EnableRegionSuffix: boolean | null;
-    /** Enable shared session caching */
-    EnableSessionCaching: boolean | null;
-    /** Enable verbose logging output */
-    Verbose: boolean | null;
-    /** Disable the zero-copy optimization for the cobhan buffer protocol */
-    DisableZeroCopy: boolean | null;
-};
-
-type LogHookCallback = (level: number, message: string) => void;
-
-export declare function setup(config: AsherahConfig): void;
-export declare function setup_async(config: AsherahConfig): Promise;
-export declare function shutdown(): void;
-export declare function shutdown_async(): Promise;
-export declare function decrypt(partitionId: string, dataRowRecord: string): Buffer;
-export declare function decrypt_async(partitionId: string, dataRowRecord: string): Promise<Buffer>;
-export declare function encrypt(partitionId: string, data: Buffer): string;
-export declare function encrypt_async(partitionId: string, data: Buffer): Promise<string>;
-export declare function decrypt_string(partitionId: string, dataRowRecord: string): string;
-export declare function decrypt_string_async(partitionId: string, dataRowRecord: string): Promise<string>;
-export declare function encrypt_string(partitionId: string, data: string): string;
-export declare function encrypt_string_async(partitionId: string, data: string): Promise<string>;
-export declare function set_max_stack_alloc_item_size(max_item_size: number): void;
-export declare function set_safety_padding_overhead(safety_padding_overhead: number): void;
-export declare function set_log_hook(logHook: LogHookCallback): void;
-export declare function get_setup_status(): boolean;
-export declare function setenv(environment: string): void;

package/src/asherah_async_worker.h

@@ -1,60 +0,0 @@
-#ifndef ASHERAH_ASYNC_WORKER_H
-#define ASHERAH_ASYNC_WORKER_H
-
-#include <napi.h>
-#include <stdexcept>
-
-class Asherah;
-
-template <typename ResultType>
-class AsherahAsyncWorker : public Napi::AsyncWorker {
-public:
-  Napi::Promise Promise() { return deferred.Promise(); }
-
-  AsherahAsyncWorker(Napi::Env env, Asherah *instance)
-      : Napi::AsyncWorker(env), asherah(instance), deferred(env) {}
-
-protected:
-  Asherah *asherah;
-  ResultType result;
-
-  virtual ResultType ExecuteTask() = 0;
-  virtual Napi::Value OnOKTask(Napi::Env &env) = 0;
-  virtual Napi::Value OnErrorTask(Napi::Env &, Napi::Error const &error) {
-    return error.Value();
-  }
-
-private:
-  Napi::Promise::Deferred deferred;
-
-  void Execute() final {
-    try {
-      result = ExecuteTask();
-    } catch (const std::exception &ex) {
-      SetError(ex.what());
-    }
-  }
-
-  void OnOK() final {
-    Napi::Env env = Env();
-    Napi::HandleScope scope(env);
-    try {
-      auto value = OnOKTask(env);
-      deferred.Resolve(value);
-    } catch (const std::exception &e) {
-      deferred.Reject(Napi::Error::New(Env(), e.what()).Value());
-    }
-  }
-
-  void OnError(Napi::Error const &error) final {
-    Napi::Env env = Env();
-    Napi::HandleScope scope(Env());
-    try {
-      deferred.Reject(OnErrorTask(env, error));
-    } catch (const std::exception &e) {
-      deferred.Reject(Napi::Error::New(Env(), e.what()).Value());
-    }
-  }
-};
-
-#endif // ASHERAH_ASYNC_WORKER_H

package/src/cobhan_buffer.h

@@ -1,260 +0,0 @@
-#ifndef COBHAN_BUFFER_H
-#define COBHAN_BUFFER_H
-
-#include <cstdint>   // for int32_t
-#include <cstring>   // for std::memcpy
-#include <iostream>  // for std::terminate
-#include <limits>    // for std::numeric_limits
-#include <sstream>   // for std::ostringstream
-#include <stdexcept> // for std::runtime_error, std::invalid_argument
-#include <string>    // for std::string
-
-#ifdef _WIN32
-#include <windows.h> // for SecureZeroMemory
-#else
-#include <string.h>  // for explicit_bzero
-#endif
-
-class CobhanBuffer {
-public:
-  // Used for requesting a new heap-based buffer allocation that can handle
-  // data_len_bytes of data
-  explicit CobhanBuffer(size_t data_len_bytes) {
-    if (data_len_bytes > max_int32_size) {
-      throw std::invalid_argument(
-          "Requested data length exceeds maximum allowable size");
-    }
-    allocation_size = DataSizeToAllocationSize(data_len_bytes);
-    cbuffer = new char[allocation_size];
-    ownership = true;
-    initialize(data_len_bytes);
-  }
-
-  // Used for passing a stack-based buffer allocation that hasn't been
-  // initialized yet
-  explicit CobhanBuffer(char *cbuffer, size_t allocation_size)
-      : cbuffer(cbuffer), allocation_size(allocation_size), ownership(false) {
-    if (allocation_size > max_int32_size) {
-      throw std::invalid_argument(
-          "Allocation size exceeds maximum allowable size");
-    }
-    initialize();
-  }
-
-  // Move constructor
-  CobhanBuffer(CobhanBuffer &&other) noexcept { moveFrom(std::move(other)); }
-
-  // Move assignment operator
-  CobhanBuffer &operator=(CobhanBuffer &&other) noexcept {
-    if (this != &other) {
-      cleanup();
-      moveFrom(std::move(other));
-    }
-    return *this;
-  }
-
-  // Implicit cast to void*
-  operator void *() const { // NOLINT(*-explicit-constructor)
-    return static_cast<void *>(cbuffer);
-  }
-
-  [[nodiscard]] char *get_data_ptr() const { return data_ptr; }
-
-  [[nodiscard]] size_t get_data_len_bytes() const { return *data_len_ptr; }
-
-  void secure_wipe_data() {
-    if (data_ptr && get_data_len_bytes() > 0) {
-#ifdef _WIN32
-      // Windows secure zero
-      SecureZeroMemory(data_ptr, get_data_len_bytes());
-#elif defined(__linux__) && defined(__GLIBC__)
-      // Linux with glibc has explicit_bzero
-      explicit_bzero(data_ptr, get_data_len_bytes());
-#else
-      // Fallback - volatile to prevent optimization
-      volatile char *p = data_ptr;
-      size_t len = get_data_len_bytes();
-      while (len--) *p++ = 0;
-#endif
-    }
-  }
-
-  ~CobhanBuffer() {
-    verify_canaries();
-    cleanup();
-  }
-
-  [[nodiscard]] __attribute__((unused)) std::string DebugPrintStdErr() const {
-    auto debug_string = std::string(get_data_ptr(), get_data_len_bytes());
-    std::ostringstream debug_output;
-    debug_output << "CobhanBuffer { " << std::endl
-                 << "data_len_bytes=" << get_data_len_bytes() << std::endl
-                 << ", allocation_size=" << get_allocation_size() << std::endl
-                 << ", data_ptr=" << static_cast<void *>(get_data_ptr())
-                 << std::endl
-                 << ", canary1=" << static_cast<void *>(canary1_ptr)
-                 << std::endl
-                 << ", canary2=" << static_cast<void *>(canary2_ptr)
-                 << std::endl
-                 << ", ownership=" << ownership << std::endl
-                 << ", string=[" << debug_string << "]" << std::endl
-                 << ", string_length=" << debug_string.length() << std::endl
-                 << "}" << std::endl
-                 << std::flush;
-    return debug_output.str();
-  }
-
-  static size_t DataSizeToAllocationSize(size_t data_len_bytes) {
-    size_t allocation =
-        data_len_bytes + cobhan_header_size_bytes +
-        canary_size_bytes       // Add space for canary value
-        + safety_padding_bytes; // Add safety padding if configured
-    if (allocation > max_int32_size) {
-      throw std::invalid_argument(
-          "Calculated allocation size exceeds maximum allowable size");
-    }
-    return allocation;
-  }
-
-  static size_t AllocationSizeToMaxDataSize(size_t allocation_len_bytes) {
-    size_t data_len_bytes = allocation_len_bytes - cobhan_header_size_bytes -
-                            canary_size_bytes - safety_padding_bytes;
-    if (data_len_bytes > max_int32_size) {
-      throw std::invalid_argument(
-          "Calculated data size exceeds maximum allowable size");
-    }
-    return data_len_bytes;
-  }
-
-protected:
-  void verify_canaries() const {
-    if (*canary1_ptr != 0) {
-      std::cerr << "Canary 1 corrupted! Expected: 0, Found: " << *canary1_ptr
-                << std::endl
-                << std::flush;
-      std::cerr << "CobhanBuffer: Memory corruption detected: Canary values "
-                   "are corrupted.  Terminating process."
-                << std::endl
-                << std::flush;
-      std::terminate();
-    }
-    if (*canary2_ptr != canary_constant) {
-      std::cerr << "Canary 2 corrupted! Expected: 0xdeadbeef, Found: "
-                << *canary2_ptr << std::endl
-                << std::flush;
-      std::cerr << "CobhanBuffer: Memory corruption detected: Canary values "
-                   "are corrupted.  Terminating process."
-                << std::endl
-                << std::flush;
-      std::terminate();
-    }
-  }
-
-  [[nodiscard]] size_t get_allocation_size() const { return allocation_size; }
-
-  void set_data_len_bytes(size_t data_len_bytes) {
-    if (data_len_bytes > max_int32_size) {
-      throw std::invalid_argument(
-          "Requested data length exceeds maximum allowable size");
-    }
-    if (data_len_bytes > allocation_size) {
-      throw std::invalid_argument(
-          "Requested data length exceeds allocation size");
-    }
-    *data_len_ptr = static_cast<int32_t>(data_len_bytes);
-  }
-
-private:
-  // Assumes cbuffer and allocation_size are already set
-  void initialize(size_t data_len_bytes = 0) {
-    // Save pointer to data
-    data_ptr = cbuffer + cobhan_header_size_bytes;
-    // First int32_t is the data length
-    data_len_ptr = reinterpret_cast<int32_t *>(cbuffer);
-    // Second int32_t is reserved for future use
-    auto reserved_ptr = reinterpret_cast<int32_t *>(cbuffer + sizeof(int32_t));
-    // First canary value is an int32_t 0 which gives us four NULLs
-    canary1_ptr = reinterpret_cast<int32_t *>(cbuffer + allocation_size -
-                                              canary_size_bytes);
-    // Second canary value is an int32_t 0xdeadbeef
-    canary2_ptr = canary1_ptr + 1;
-
-    // Calculate the data length
-    if (data_len_bytes == 0) {
-      data_len_bytes = AllocationSizeToMaxDataSize(allocation_size);
-    }
-
-    if (data_len_bytes > max_int32_size) {
-      throw std::invalid_argument("Data length exceeds maximum allowable size");
-    }
-
-    // Write Cobhan header values
-    *data_len_ptr = static_cast<int32_t>(data_len_bytes);
-
-    // Reserved for future use
-    *reserved_ptr = 0;
-
-    // Write canary values
-    *canary1_ptr = 0;
-    *canary2_ptr = canary_constant;
-  }
-
-  void moveFrom(CobhanBuffer &&other) {
-    other.verify_canaries();
-
-    if (other.ownership) {
-      // Transfer ownership of the existing buffer
-      cbuffer = other.cbuffer;
-      allocation_size = other.allocation_size;
-      ownership = true;
-      data_ptr = other.data_ptr;
-      data_len_ptr = other.data_len_ptr;
-      canary1_ptr = other.canary1_ptr;
-      canary2_ptr = other.canary2_ptr;
-
-      // Reset the other object to prevent it from deallocating the buffer
-      other.cbuffer = nullptr;
-      other.allocation_size = 0;
-      other.ownership = false;
-    } else {
-      // Allocate a new buffer and copy the contents
-      allocation_size = other.allocation_size;
-      if (allocation_size > max_int32_size) {
-        throw std::invalid_argument(
-            "Allocation size exceeds maximum allowable size");
-      }
-
-      cbuffer = new char[allocation_size];
-      std::memcpy(cbuffer, other.cbuffer, allocation_size);
-      ownership = true;
-      initialize(*other.data_len_ptr);
-    }
-  }
-
-  void cleanup() {
-    if (ownership) {
-      delete[] cbuffer;
-    }
-    cbuffer = nullptr;
-    allocation_size = 0;
-  }
-
-  char *cbuffer = nullptr;
-  size_t allocation_size = 0;
-  bool ownership = false;
-  int32_t *data_len_ptr = nullptr;
-  char *data_ptr = nullptr;
-  int32_t *canary1_ptr = nullptr;
-  int32_t *canary2_ptr = nullptr;
-
-  static constexpr int32_t canary_constant = static_cast<int32_t>(0xdeadbeef);
-  static constexpr size_t cobhan_header_size_bytes =
-      sizeof(int32_t) * 2; // 2x int32_t headers
-  static constexpr size_t canary_size_bytes =
-      sizeof(int32_t) * 2; // Two int32_t canaries
-  static constexpr size_t safety_padding_bytes = 8;
-  static constexpr size_t max_int32_size =
-      static_cast<size_t>(std::numeric_limits<int32_t>::max());
-};
-
-#endif // COBHAN_BUFFER_H

package/src/cobhan_buffer_napi.h

@@ -1,218 +0,0 @@
-#ifndef COBHAN_BUFFER_NAPI_H
-#define COBHAN_BUFFER_NAPI_H
-
-#include "cobhan_buffer.h"
-#include "napi_utils.h"
-#include <napi.h>
-#include <stdexcept>
-
-class CobhanBufferNapi : public CobhanBuffer {
-public:
-  // Constructor from a Napi::String
-  CobhanBufferNapi(const Napi::Env &env, const Napi::String &napiString)
-      : CobhanBuffer(NapiUtils::GetUtf8StringLength(env, napiString) + 1),
-        env(env) { // Add one for possible NULL delimiter due to Node
-                   // string functions
-    copy_from_string(napiString);
-  }
-
-  // Constructor from Napi::Buffer<unsigned char>
-  explicit CobhanBufferNapi(const Napi::Env &env,
-                            const Napi::Buffer<unsigned char> &napiBuffer)
-      : CobhanBuffer(napiBuffer.ByteLength()), env(env) {
-    std::memcpy(get_data_ptr(), napiBuffer.Data(), napiBuffer.ByteLength());
-  }
-
-  // Constructor from Napi::Value
-  explicit CobhanBufferNapi(const Napi::Env &env, const Napi::Value &napiValue)
-      : CobhanBuffer(ValueToDataSize(env, napiValue)), env(env) {
-    if (napiValue.IsString()) {
-      copy_from_string(napiValue.As<Napi::String>());
-    } else if (napiValue.IsBuffer()) {
-      auto napiBuffer = napiValue.As<Napi::Buffer<unsigned char>>();
-      std::memcpy(get_data_ptr(), napiBuffer.Data(), napiBuffer.Length());
-    } else {
-      NapiUtils::ThrowException(
-          env, "Expected a Napi::String or Napi::Buffer<unsigned "
-               "char> as the value.");
-    }
-  }
-
-  // Constructor from a Napi::String to an externally allocated buffer
-  CobhanBufferNapi(const Napi::Env &env,
-                   const Napi::Buffer<unsigned char> &napiBuffer, char *cbuffer,
-                   size_t allocation_size)
-      : CobhanBuffer(cbuffer, allocation_size), env(env) {
-    std::memcpy(get_data_ptr(), napiBuffer.Data(), napiBuffer.Length());
-  }
-
-  // Constructor from a Napi::String to an externally allocated buffer
-  CobhanBufferNapi(const Napi::Env &env, const Napi::String &napiString,
-                   char *cbuffer, size_t allocation_size)
-      : CobhanBuffer(cbuffer, allocation_size), env(env) {
-    copy_from_string(napiString);
-  }
-
-  // Constructor from a Napi::String to an externally allocated buffer
-  CobhanBufferNapi(const Napi::Env &env, const Napi::Value &napiValue,
-                   char *cbuffer, size_t allocation_size)
-      : CobhanBuffer(cbuffer, allocation_size), env(env) {
-    if (napiValue.IsString()) {
-      copy_from_string(napiValue.As<Napi::String>());
-    } else if (napiValue.IsBuffer()) {
-      auto napiBuffer = napiValue.As<Napi::Buffer<unsigned char>>();
-      std::memcpy(get_data_ptr(), napiBuffer.Data(), napiBuffer.Length());
-    } else {
-      NapiUtils::ThrowException(
-          env, "Expected a Napi::String or Napi::Buffer<unsigned "
-               "char> as the value.");
-    }
-  }
-
-  // Constructor from size_t representing data length in bytes (not allocation
-  // size)
-  explicit CobhanBufferNapi(const Napi::Env &env, size_t data_len_bytes)
-      : CobhanBuffer(data_len_bytes), env(env) {}
-
-  // Constructor from externally allocated char* and size_t representing
-  // allocation size in bytes
-  explicit CobhanBufferNapi(const Napi::Env &env, char *cbuffer,
-                            size_t allocation_size)
-      : CobhanBuffer(cbuffer, allocation_size), env(env) {}
-
-  // Move constructor
-  CobhanBufferNapi(CobhanBufferNapi &&other) noexcept
-      : CobhanBuffer(std::move(other)), env(other.env) {}
-
-  // Move assignment operator
-  CobhanBufferNapi &operator=(CobhanBufferNapi &&other) noexcept {
-    if (this != &other) {
-      CobhanBuffer::operator=(std::move(other));
-    }
-    return *this;
-  }
-
-  // Returns a Napi::String from the buffer using napi_create_string_utf8
-  [[nodiscard]] Napi::String ToString() const {
-    napi_value napiStr;
-    napi_status status = napi_create_string_utf8(
-        env, get_data_ptr(), get_data_len_bytes(), &napiStr);
-
-    if (status != napi_ok) {
-      napi_throw_error(env, nullptr,
-                       "Failed to create Napi::String from CobhanBuffer");
-      return {};
-    }
-
-    return {env, napiStr};
-  }
-
-  // Returns a Napi::Buffer<unsigned char> from the buffer
-  [[nodiscard]] Napi::Buffer<unsigned char> ToBuffer() const {
-    auto buffer = Napi::Buffer<unsigned char>::Copy(
-        env, reinterpret_cast<unsigned char *>(get_data_ptr()),
-        get_data_len_bytes());
-    return buffer;
-  }
-
-  // Public method to calculate the required allocation size for a Napi::String
-  static size_t StringToAllocationSize(const Napi::Env &env,
-                                       const Napi::String &napiString) {
-    size_t str_len = NapiUtils::GetUtf8StringLength(env, napiString);
-    return DataSizeToAllocationSize(str_len) +
-           1; // Add one for possible NULL delimiter due to Node string
-              // functions
-  }
-
-  // Public method to calculate the required allocation size for a
-  // Napi::Buffer<unsigned char>
-  static size_t
-  BufferToAllocationSize(const Napi::Env &,
-                         const Napi::Buffer<unsigned char> &napiBuffer) {
-    return DataSizeToAllocationSize(napiBuffer.Length());
-  }
-
-  // Public method to calculate the required allocation size for a Napi::Value
-  // (either Napi::String or Napi::Buffer<unsigned char>)
-  static size_t ValueToAllocationSize(const Napi::Env &env,
-                                      const Napi::Value &value) {
-    if (value.IsString()) {
-      return StringToAllocationSize(env, value.As<Napi::String>());
-    } else if (value.IsBuffer()) {
-      return BufferToAllocationSize(env,
-                                    value.As<Napi::Buffer<unsigned char>>());
-    } else {
-      NapiUtils::ThrowException(
-          env, "Expected a Napi::String or Napi::Buffer<unsigned "
-               "char> as the value.");
-    }
-  }
-
-  static size_t ValueToDataSize(const Napi::Env &env,
-                                const Napi::Value &value) {
-    if (value.IsString()) {
-      return NapiUtils::GetUtf8StringLength(env, value.As<Napi::String>()) + 1;
-    } else if (value.IsBuffer()) {
-      return value.As<Napi::Buffer<unsigned char>>().ByteLength();
-    } else {
-      NapiUtils::ThrowException(
-          env, "Expected a Napi::String or Napi::Buffer<unsigned "
-               "char> as the value.");
-    }
-  }
-
-private:
-  Napi::Env env;
-
-  void copy_from_string(const Napi::String &napiString) {
-    size_t str_len = NapiUtils::GetUtf8StringLength(env, napiString);
-    // Add one for NULL delimiter due to napi_get_value_string_utf8
-    size_t allocation_size =
-        CobhanBuffer::DataSizeToAllocationSize(str_len) + 1;
-
-    if (allocation_size > get_allocation_size()) {
-      NapiUtils::ThrowException(
-          env,
-          "Buffer allocation size is insufficient to hold the Napi::String.");
-    }
-
-    // Bytes written is the number of bytes copied, excluding the NULL
-    size_t bytes_written;
-    napi_status status = napi_get_value_string_utf8(
-        env, napiString, get_data_ptr(), str_len + 1, &bytes_written);
-    if (status != napi_ok || bytes_written != str_len) {
-      NapiUtils::ThrowException(
-          env, "Failed to copy Napi::String into CobhanBuffer. Status: " +
-                   std::to_string(status) +
-                   ", Bytes Written: " + std::to_string(bytes_written));
-    }
-
-    // Update our data length to the actual string length
-    set_data_len_bytes(str_len);
-  }
-};
-
-// Specialized class for buffers containing sensitive data
-class SensitiveCobhanBufferNapi : public CobhanBufferNapi {
-public:
-  using CobhanBufferNapi::CobhanBufferNapi; // Inherit all constructors
-  
-  // Move constructor - needed for async workers
-  SensitiveCobhanBufferNapi(SensitiveCobhanBufferNapi &&other) noexcept
-      : CobhanBufferNapi(std::move(other)) {}
-  
-  // Also allow moving from base class (for async worker initialization)
-  SensitiveCobhanBufferNapi(CobhanBufferNapi &&other) noexcept
-      : CobhanBufferNapi(std::move(other)) {}
-
-  ~SensitiveCobhanBufferNapi() {
-    // TODO: Fix for async operations - currently breaks async tests
-    // because data gets wiped before async operation completes
-    // Only wipe if we still own data (haven't been moved from)
-    // if (get_data_ptr() != nullptr) {
-    //   secure_wipe_data();
-    // }
-  }
-};
-
-#endif // COBHAN_BUFFER_NAPI_H

package/src/hints.h

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

package/src/logging.h

@@ -1,49 +0,0 @@
-#pragma clang diagnostic push
-#pragma ide diagnostic ignored "OCUnusedGlobalDeclarationInspection"
-
-#ifndef LOGGING_H
-#define LOGGING_H
-
-#include <cstddef> // size_t
-#include <cstdint> // int32_t
-#include <sstream> // std::ostringstream
-#include <string>  // std::string
-
-class Logger {
-public:
-    [[maybe_unused]] void set_verbose_flag(int32_t verbose) { verbose_flag = verbose != 0; };
-
-  virtual void debug_log(const char *function_name,
-                         const char *message) const = 0;
-  virtual void debug_log(const char *function_name,
-                         const std::string &message) const = 0;
-  virtual void debug_log_alloca(const char *function_name,
-                                const char *variable_name,
-                                size_t length) const = 0;
-
-  virtual void debug_log_new(const char *function_name,
-                             const char *variable_name,
-                             size_t length) const = 0;
-
-  virtual void error_log(const char *function_name,
-                         const char *message) const = 0;
-  virtual void error_log(const char *function_name,
-                         const std::string &message) const = 0;
-
-  __attribute__((always_inline)) inline static std::string
-  format_ptr(const void *ptr) {
-    std::ostringstream ss;
-    ss << "0x" << std::hex << (intptr_t)ptr;
-    return ss.str();
-  }
-
-protected:
-  bool verbose_flag = false;
-  std::string system_name;
-
-  explicit Logger(std::string system_name) : system_name(std::move(system_name)) {}
-};
-
-#endif // LOGGING_H
-
-#pragma clang diagnostic pop