@ohos-ports/react-native-quick-crypto 0.0.0-stage → 1.1.8-beta.0

package/cpp/ed25519/HybridEdKeyPair.hpp

@@ -0,0 +1,67 @@
+#include <memory>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <string>
+
+#include "HybridEdKeyPairSpec.hpp"
+#include "QuickCryptoUtils.hpp"
+
+namespace margelo::nitro::crypto {
+
+class HybridEdKeyPair : public HybridEdKeyPairSpec {
+ public:
+  HybridEdKeyPair() : HybridObject(TAG) {}
+  ~HybridEdKeyPair() override = default;
+
+ public:
+  // Methods
+  std::shared_ptr<ArrayBuffer> diffieHellman(const std::shared_ptr<ArrayBuffer>& privateKey,
+                                             const std::shared_ptr<ArrayBuffer>& publicKey) override;
+
+  std::shared_ptr<Promise<void>> generateKeyPair(double publicFormat, double publicType, double privateFormat, double privateType,
+                                                 const std::optional<std::string>& cipher,
+                                                 const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) override;
+
+  void generateKeyPairSync(double publicFormat, double publicType, double privateFormat, double privateType,
+                           const std::optional<std::string>& cipher,
+                           const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) override;
+
+  std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> sign(const std::shared_ptr<ArrayBuffer>& message,
+                                                              const std::optional<std::shared_ptr<ArrayBuffer>>& key) override;
+
+  std::shared_ptr<ArrayBuffer> signSync(const std::shared_ptr<ArrayBuffer>& message,
+                                        const std::optional<std::shared_ptr<ArrayBuffer>>& key) override;
+
+  std::shared_ptr<Promise<bool>> verify(const std::shared_ptr<ArrayBuffer>& signature, const std::shared_ptr<ArrayBuffer>& message,
+                                        const std::optional<std::shared_ptr<ArrayBuffer>>& key) override;
+
+  bool verifySync(const std::shared_ptr<ArrayBuffer>& signature, const std::shared_ptr<ArrayBuffer>& message,
+                  const std::optional<std::shared_ptr<ArrayBuffer>>& key) override;
+
+ protected:
+  std::shared_ptr<ArrayBuffer> getPublicKey() override;
+
+  std::shared_ptr<ArrayBuffer> getPrivateKey() override;
+
+  void checkKeyPair();
+
+  void setCurve(const std::string& curve) override;
+
+ private:
+  std::string curve;
+  using EVP_PKEY_ptr = std::unique_ptr<EVP_PKEY, decltype(&EVP_PKEY_free)>;
+  EVP_PKEY_ptr pkey_{nullptr, EVP_PKEY_free};
+
+  // Encoding configuration for key export
+  // Format: -1 = default (raw), 0 = DER, 1 = PEM
+  // Type: 0 = PKCS1, 1 = PKCS8, 2 = SPKI, 3 = SEC1
+  int publicFormat_ = -1;
+  int publicType_ = -1;
+  int privateFormat_ = -1;
+  int privateType_ = -1;
+
+  EVP_PKEY_ptr importPublicKey(const std::optional<std::shared_ptr<ArrayBuffer>>& key);
+  EVP_PKEY_ptr importPrivateKey(const std::optional<std::shared_ptr<ArrayBuffer>>& key);
+};
+
+} // namespace margelo::nitro::crypto

package/cpp/hash/HybridHash.cpp

@@ -0,0 +1,190 @@
+#include <NitroModules/ArrayBuffer.hpp>
+#include <memory>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "HybridHash.hpp"
+#include "QuickCryptoUtils.hpp"
+
+namespace margelo::nitro::crypto {
+
+HybridHash::~HybridHash() {
+  if (ctx) {
+    EVP_MD_CTX_free(ctx);
+    ctx = nullptr;
+  }
+  if (md && md_fetched) {
+    EVP_MD_free(md);
+    md = nullptr;
+  }
+}
+
+void HybridHash::createHash(const std::string& hashAlgorithmArg, const std::optional<double> outputLengthArg) {
+  // Clear any previous OpenSSL errors to prevent pollution
+  clearOpenSSLErrors();
+
+  // Clean up existing resources before creating new ones
+  if (ctx) {
+    EVP_MD_CTX_free(ctx);
+    ctx = nullptr;
+  }
+  if (md && md_fetched) {
+    EVP_MD_free(md);
+    md = nullptr;
+    md_fetched = false;
+  }
+
+  algorithm = hashAlgorithmArg;
+  outputLength = outputLengthArg;
+
+  // Create hash context
+  ctx = EVP_MD_CTX_new();
+  if (!ctx) {
+    throw std::runtime_error("Failed to create hash context: " + std::to_string(ERR_get_error()));
+  }
+
+  // Fetch the message digest using modern provider-based API
+  md = EVP_MD_fetch(nullptr, algorithm.c_str(), nullptr);
+  if (!md) {
+    EVP_MD_CTX_free(ctx);
+    ctx = nullptr;
+    throw std::runtime_error("Unknown hash algorithm: " + algorithm);
+  }
+  md_fetched = true;
+
+  // Initialize the digest
+  if (EVP_DigestInit_ex(ctx, md, nullptr) != 1) {
+    EVP_MD_CTX_free(ctx);
+    ctx = nullptr;
+    if (md_fetched) {
+      EVP_MD_free(md);
+      md = nullptr;
+      md_fetched = false;
+    }
+    throw std::runtime_error("Failed to initialize hash digest: " + std::to_string(ERR_get_error()));
+  }
+}
+
+void HybridHash::update(const std::variant<std::shared_ptr<ArrayBuffer>, std::string>& data) {
+  if (!ctx) {
+    throw std::runtime_error("Hash context not initialized");
+  }
+
+  if (std::holds_alternative<std::string>(data)) {
+    const std::string& str = std::get<std::string>(data);
+    if (EVP_DigestUpdate(ctx, reinterpret_cast<const uint8_t*>(str.data()), str.length()) != 1) {
+      throw std::runtime_error("Failed to update hash digest: " + std::to_string(ERR_get_error()));
+    }
+  } else {
+    const std::shared_ptr<ArrayBuffer>& buffer = std::get<std::shared_ptr<ArrayBuffer>>(data);
+    if (EVP_DigestUpdate(ctx, reinterpret_cast<const uint8_t*>(buffer->data()), buffer->size()) != 1) {
+      throw std::runtime_error("Failed to update hash digest: " + std::to_string(ERR_get_error()));
+    }
+  }
+}
+
+std::shared_ptr<ArrayBuffer> HybridHash::digest(const std::optional<std::string>& encoding) {
+  if (!ctx) {
+    throw std::runtime_error("Hash context not initialized");
+  }
+
+  setParams();
+
+  // Get the default digest size
+  const size_t defaultLen = EVP_MD_CTX_size(ctx);
+  const size_t digestSize = (outputLength.has_value()) ? static_cast<int>(*outputLength) : defaultLen;
+
+  if (digestSize < 0) {
+    throw std::runtime_error("Invalid digest size: " + std::to_string(digestSize));
+  }
+
+  auto hashBuffer = std::make_unique<uint8_t[]>(digestSize);
+  size_t hashLength = digestSize;
+
+  int ret;
+  if (digestSize == defaultLen) {
+    ret = EVP_DigestFinal_ex(ctx, hashBuffer.get(), reinterpret_cast<unsigned int*>(&hashLength));
+  } else {
+    ret = EVP_DigestFinalXOF(ctx, hashBuffer.get(), hashLength);
+  }
+
+  if (ret != 1) {
+    throw std::runtime_error("Failed to finalize hash digest: " + std::to_string(ERR_get_error()));
+  }
+
+  uint8_t* raw_ptr = hashBuffer.get();
+  return std::make_shared<NativeArrayBuffer>(hashBuffer.release(), hashLength, [raw_ptr]() { delete[] raw_ptr; });
+}
+
+std::shared_ptr<margelo::nitro::crypto::HybridHashSpec> HybridHash::copy(const std::optional<double> outputLengthArg) {
+  if (!ctx) {
+    throw std::runtime_error("Hash context not initialized");
+  }
+
+  // Create a new context
+  EVP_MD_CTX* newCtx = EVP_MD_CTX_new();
+  if (!newCtx) {
+    throw std::runtime_error("Failed to create new hash context: " + std::to_string(ERR_get_error()));
+  }
+
+  // Copy the existing context to the new one
+  if (EVP_MD_CTX_copy(newCtx, ctx) != 1) {
+    EVP_MD_CTX_free(newCtx);
+    throw std::runtime_error("Failed to copy hash context: " + std::to_string(ERR_get_error()));
+  }
+
+  return std::make_shared<HybridHash>(newCtx, md, algorithm, outputLengthArg, false);
+}
+
+std::vector<std::string> HybridHash::getSupportedHashAlgorithms() {
+  std::vector<std::string> hashAlgorithms;
+
+  EVP_MD_do_all_provided(
+      nullptr,
+      [](EVP_MD* md, void* arg) {
+        auto* algorithms = static_cast<std::vector<std::string>*>(arg);
+        const char* name = EVP_MD_get0_name(md);
+        if (name) {
+          algorithms->push_back(name);
+        }
+      },
+      &hashAlgorithms);
+
+  return hashAlgorithms;
+}
+
+void HybridHash::setParams() {
+  // Handle algorithm parameters (like XOF length for SHAKE)
+  if (outputLength.has_value()) {
+    uint32_t xoflen = outputLength.value();
+
+    // Add a reasonable maximum output length
+    const int MAX_OUTPUT_LENGTH = 16 * 1024 * 1024; // 16MB
+    if (xoflen > MAX_OUTPUT_LENGTH) {
+      throw std::runtime_error("Output length " + std::to_string(xoflen) + " exceeds maximum allowed size of " +
+                               std::to_string(MAX_OUTPUT_LENGTH));
+    }
+
+    OSSL_PARAM params[] = {OSSL_PARAM_construct_uint("xoflen", &xoflen), OSSL_PARAM_END};
+
+    if (EVP_MD_CTX_set_params(ctx, params) != 1) {
+      EVP_MD_CTX_free(ctx);
+      ctx = nullptr;
+      if (md && md_fetched) {
+        EVP_MD_free(md);
+        md = nullptr;
+        md_fetched = false;
+      }
+      throw std::runtime_error("Failed to set XOF length (outputLength) parameter: " + std::to_string(ERR_get_error()));
+    }
+  }
+}
+
+std::string HybridHash::getOpenSSLVersion() {
+  return OpenSSL_version(OPENSSL_VERSION);
+}
+
+} // namespace margelo::nitro::crypto

package/cpp/hash/HybridHash.hpp

@@ -0,0 +1,43 @@
+#include <NitroModules/ArrayBuffer.hpp>
+#include <memory>
+#include <openssl/evp.h>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "HybridHashSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+using namespace facebook;
+
+class HybridHash : public HybridHashSpec {
+ public:
+  HybridHash() : HybridObject(TAG) {}
+  HybridHash(EVP_MD_CTX* ctx, EVP_MD* md, const std::string& algorithm, const std::optional<double> outputLength, bool md_fetched = false)
+      : HybridObject(TAG), ctx(ctx), md(md), md_fetched(md_fetched), algorithm(algorithm), outputLength(outputLength) {}
+  ~HybridHash();
+
+ public:
+  // Methods
+  void createHash(const std::string& algorithm, const std::optional<double> outputLength) override;
+  void update(const std::variant<std::shared_ptr<ArrayBuffer>, std::string>& data) override;
+  std::shared_ptr<ArrayBuffer> digest(const std::optional<std::string>& encoding = std::nullopt) override;
+  std::shared_ptr<margelo::nitro::crypto::HybridHashSpec> copy(const std::optional<double> outputLength) override;
+  std::vector<std::string> getSupportedHashAlgorithms() override;
+  std::string getOpenSSLVersion() override;
+
+ private:
+  // Methods
+  void setParams();
+
+ private:
+  // Properties
+  EVP_MD_CTX* ctx = nullptr;
+  EVP_MD* md = nullptr;
+  bool md_fetched = false;
+  std::string algorithm = "";
+  std::optional<double> outputLength = std::nullopt;
+};
+
+} // namespace margelo::nitro::crypto

package/cpp/hkdf/HybridHkdf.cpp

@@ -0,0 +1,115 @@
+#include <NitroModules/ArrayBuffer.hpp>
+#include <memory>
+#include <openssl/core_names.h>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <openssl/kdf.h>
+#include <string>
+#include <vector>
+
+#include "HybridHkdf.hpp"
+#include "QuickCryptoUtils.hpp"
+
+namespace margelo::nitro::crypto {
+
+std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>
+HybridHkdf::deriveKey(const std::string& algorithm, const std::shared_ptr<ArrayBuffer>& key, const std::shared_ptr<ArrayBuffer>& salt,
+                      const std::shared_ptr<ArrayBuffer>& info, double length, HkdfMode mode) {
+  // get owned NativeArrayBuffers before passing to sync function
+  auto nativeKey = ToNativeArrayBuffer(key);
+  auto nativeSalt = ToNativeArrayBuffer(salt);
+  auto nativeInfo = ToNativeArrayBuffer(info);
+
+  return Promise<std::shared_ptr<ArrayBuffer>>::async([this, algorithm, nativeKey, nativeSalt, nativeInfo, length, mode]() {
+    return this->deriveKeySync(algorithm, nativeKey, nativeSalt, nativeInfo, length, mode);
+  });
+}
+
+std::shared_ptr<ArrayBuffer> HybridHkdf::deriveKeySync(const std::string& algorithm, const std::shared_ptr<ArrayBuffer>& baseKey,
+                                                       const std::shared_ptr<ArrayBuffer>& salt, const std::shared_ptr<ArrayBuffer>& info,
+                                                       double length, HkdfMode mode) {
+  EVP_KDF* kdf = EVP_KDF_fetch(nullptr, "HKDF", nullptr);
+  if (kdf == nullptr) {
+    throw std::runtime_error("Failed to fetch HKDF implementation: " + std::to_string(ERR_get_error()));
+  }
+
+  EVP_KDF_CTX* ctx = EVP_KDF_CTX_new(kdf);
+  EVP_KDF_free(kdf);
+  if (ctx == nullptr) {
+    throw std::runtime_error("Failed to create HKDF context: " + std::to_string(ERR_get_error()));
+  }
+
+  // Set up parameters
+  OSSL_PARAM params[6];
+  size_t paramIndex = 0;
+
+  // HKDF mode (RFC 5869): full extract+expand, extract-only (PRK), or expand-only.
+  int hkdfMode;
+  switch (mode) {
+    case HkdfMode::EXTRACT:
+      hkdfMode = EVP_KDF_HKDF_MODE_EXTRACT_ONLY;
+      break;
+    case HkdfMode::EXPAND:
+      hkdfMode = EVP_KDF_HKDF_MODE_EXPAND_ONLY;
+      break;
+    case HkdfMode::FULL:
+      hkdfMode = EVP_KDF_HKDF_MODE_EXTRACT_AND_EXPAND;
+      break;
+    default:
+      EVP_KDF_CTX_free(ctx);
+      throw std::runtime_error("Unknown HKDF mode");
+  }
+  params[paramIndex++] = OSSL_PARAM_construct_int(OSSL_KDF_PARAM_MODE, &hkdfMode);
+
+  params[paramIndex++] = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_DIGEST, const_cast<char*>(algorithm.c_str()), 0);
+
+  // Key (Input Keying Material)
+  if (baseKey && baseKey->size() > 0) {
+    params[paramIndex++] = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_KEY, baseKey->data(), baseKey->size());
+  } else {
+    // Empty key is allowed in HKDF (defaults to zero string of hashLen) but explicit param usually expected if not null
+    // If we want empty, we can pass generic empty buffer or handle it.
+    // Node.js crypto allows buffer.
+    // Assuming key is effectively required or can be empty.
+    params[paramIndex++] = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_KEY, nullptr, 0);
+  }
+
+  // Salt
+  if (salt && salt->size() > 0) {
+    params[paramIndex++] = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SALT, salt->data(), salt->size());
+  } else {
+    // If salt is not provided, it is set to a string of HashLen zeros.
+    // OpenSSL handles missing salt as default? Or do we need to pass empty?
+    // Usually standard optional.
+  }
+
+  // Info
+  if (info && info->size() > 0) {
+    params[paramIndex++] = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_INFO, info->data(), info->size());
+  }
+
+  params[paramIndex++] = OSSL_PARAM_construct_end();
+
+  // Output buffer
+  size_t outLen = static_cast<size_t>(length);
+  if (outLen == 0) {
+    EVP_KDF_CTX_free(ctx);
+    throw std::runtime_error("HKDF length cannot be zero");
+  }
+
+  auto out_buf = std::make_unique<uint8_t[]>(outLen);
+
+  if (EVP_KDF_derive(ctx, out_buf.get(), outLen, params) <= 0) {
+    EVP_KDF_CTX_free(ctx);
+    // Zero any partially-derived secret bits before unique_ptr frees the buffer.
+    secureZero(out_buf.get(), outLen);
+    throw std::runtime_error("HKDF derivation failed: " + std::to_string(ERR_get_error()));
+  }
+
+  EVP_KDF_CTX_free(ctx);
+
+  uint8_t* raw_ptr = out_buf.get();
+  return std::make_shared<NativeArrayBuffer>(out_buf.release(), outLen, [raw_ptr]() { delete[] raw_ptr; });
+}
+
+} // namespace margelo::nitro::crypto

package/cpp/hkdf/HybridHkdf.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <memory>
+#include <openssl/evp.h>
+#include <string>
+
+#include "HybridHkdfSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+using namespace facebook;
+
+class HybridHkdf : public HybridHkdfSpec {
+ public:
+  HybridHkdf() : HybridObject(TAG) {}
+
+ public:
+  // Methods
+  std::shared_ptr<ArrayBuffer> deriveKeySync(const std::string& algorithm, const std::shared_ptr<ArrayBuffer>& key,
+                                             const std::shared_ptr<ArrayBuffer>& salt, const std::shared_ptr<ArrayBuffer>& info,
+                                             double length, HkdfMode mode) override;
+  std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> deriveKey(const std::string& algorithm, const std::shared_ptr<ArrayBuffer>& key,
+                                                                   const std::shared_ptr<ArrayBuffer>& salt,
+                                                                   const std::shared_ptr<ArrayBuffer>& info, double length,
+                                                                   HkdfMode mode) override;
+};
+
+} // namespace margelo::nitro::crypto

package/cpp/hmac/HybridHmac.cpp

@@ -0,0 +1,102 @@
+#include <NitroModules/ArrayBuffer.hpp>
+#include <memory>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "HybridHmac.hpp"
+
+namespace margelo::nitro::crypto {
+
+HybridHmac::~HybridHmac() {
+  if (ctx) {
+    EVP_MAC_CTX_free(ctx);
+    ctx = nullptr;
+  }
+}
+
+void HybridHmac::createHmac(const std::string& hmacAlgorithm, const std::shared_ptr<ArrayBuffer>& secretKey) {
+  algorithm = hmacAlgorithm;
+
+  // Create and use EVP_MAC locally
+  EVP_MAC* mac = EVP_MAC_fetch(nullptr, "HMAC", nullptr);
+  if (!mac) {
+    throw std::runtime_error("Failed to fetch HMAC implementation: " + std::to_string(ERR_get_error()));
+  }
+
+  // Create HMAC context
+  ctx = EVP_MAC_CTX_new(mac);
+  EVP_MAC_free(mac); // Free immediately after creating the context
+  if (!ctx) {
+    throw std::runtime_error("Failed to create HMAC context: " + std::to_string(ERR_get_error()));
+  }
+
+  // Validate algorithm
+  const EVP_MD* md = EVP_get_digestbyname(algorithm.c_str());
+  if (!md) {
+    throw std::runtime_error("Unknown HMAC algorithm: " + algorithm);
+  }
+
+  // Set up parameters for HMAC
+  OSSL_PARAM params[2];
+  params[0] = OSSL_PARAM_construct_utf8_string("digest", const_cast<char*>(algorithm.c_str()), 0);
+  params[1] = OSSL_PARAM_construct_end();
+
+  const uint8_t* keyData = reinterpret_cast<const uint8_t*>(secretKey->data());
+  size_t keySize = secretKey->size();
+
+  // Handle empty key case by providing a dummy key
+  static const uint8_t dummyKey = 0;
+  if (keySize == 0) {
+    keyData = &dummyKey;
+    keySize = 1;
+  }
+
+  // Initialize HMAC
+  if (EVP_MAC_init(ctx, keyData, keySize, params) != 1) {
+    throw std::runtime_error("Failed to initialize HMAC: " + std::to_string(ERR_get_error()));
+  }
+}
+
+void HybridHmac::update(const std::variant<std::shared_ptr<ArrayBuffer>, std::string>& data) {
+  if (!ctx) {
+    throw std::runtime_error("HMAC context not initialized");
+  }
+
+  if (std::holds_alternative<std::string>(data)) {
+    // Handle string: pass UTF-8 bytes directly to OpenSSL
+    const std::string& str = std::get<std::string>(data);
+    if (EVP_MAC_update(ctx, reinterpret_cast<const uint8_t*>(str.data()), str.length()) != 1) {
+      throw std::runtime_error("Failed to update HMAC: " + std::to_string(ERR_get_error()));
+    }
+  } else {
+    // Handle ArrayBuffer
+    const std::shared_ptr<ArrayBuffer>& buffer = std::get<std::shared_ptr<ArrayBuffer>>(data);
+    if (EVP_MAC_update(ctx, reinterpret_cast<const uint8_t*>(buffer->data()), buffer->size()) != 1) {
+      throw std::runtime_error("Failed to update HMAC: " + std::to_string(ERR_get_error()));
+    }
+  }
+}
+
+std::shared_ptr<ArrayBuffer> HybridHmac::digest() {
+  if (!ctx) {
+    throw std::runtime_error("HMAC context not initialized");
+  }
+
+  // Determine the maximum possible size of the HMAC output
+  const EVP_MD* md = EVP_get_digestbyname(algorithm.c_str());
+  const size_t hmacLength = EVP_MD_get_size(md);
+
+  auto hmacBuffer = std::make_unique<uint8_t[]>(hmacLength);
+
+  if (EVP_MAC_final(ctx, hmacBuffer.get(), nullptr, hmacLength) != 1) {
+    throw std::runtime_error("Failed to finalize HMAC digest: " + std::to_string(ERR_get_error()));
+  }
+
+  uint8_t* raw_ptr = hmacBuffer.get();
+  return std::make_shared<NativeArrayBuffer>(hmacBuffer.release(), hmacLength, [raw_ptr]() { delete[] raw_ptr; });
+}
+
+} // namespace margelo::nitro::crypto

package/cpp/hmac/HybridHmac.hpp

@@ -0,0 +1,32 @@
+#include <NitroModules/ArrayBuffer.hpp>
+#include <memory>
+#include <openssl/evp.h>
+#include <optional>
+#include <string>
+#include <variant>
+#include <vector>
+
+#include "HybridHmacSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+using namespace facebook;
+
+class HybridHmac : public HybridHmacSpec {
+ public:
+  HybridHmac() : HybridObject(TAG) {}
+  ~HybridHmac();
+
+ public:
+  // Methods
+  void createHmac(const std::string& algorithm, const std::shared_ptr<ArrayBuffer>& key) override;
+  void update(const std::variant<std::shared_ptr<ArrayBuffer>, std::string>& data) override;
+  std::shared_ptr<ArrayBuffer> digest() override;
+
+ private:
+  // Properties
+  EVP_MAC_CTX* ctx = nullptr;
+  std::string algorithm = "";
+};
+
+} // namespace margelo::nitro::crypto