react-native-quick-crypto 1.0.0-beta.8 → 1.0.0

package/cpp/keys/HybridKeyObjectHandle.hpp

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <memory>
+#include <optional>
+#include <string>
+
+#include "HybridKeyObjectHandleSpec.hpp"
+#include "JWK.hpp"
+#include "KeyDetail.hpp"
+#include "KeyObjectData.hpp"
+#include "KeyType.hpp"
+#include "NamedCurve.hpp"
+
+namespace margelo::nitro::crypto {
+
+class HybridKeyObjectHandle : public HybridKeyObjectHandleSpec {
+ public:
+  HybridKeyObjectHandle() : HybridObject(TAG) {}
+
+ public:
+  std::shared_ptr<ArrayBuffer> exportKey(std::optional<KFormatType> format, std::optional<KeyEncoding> type,
+                                         const std::optional<std::string>& cipher,
+                                         const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) override;
+
+  JWK exportJwk(const JWK& key, bool handleRsaPss) override;
+
+  AsymmetricKeyType getAsymmetricKeyType() override;
+
+  bool init(KeyType keyType, const std::variant<std::string, std::shared_ptr<ArrayBuffer>>& key, std::optional<KFormatType> format,
+            std::optional<KeyEncoding> type, const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) override;
+
+  bool initECRaw(const std::string& namedCurve, const std::shared_ptr<ArrayBuffer>& keyData) override;
+
+  std::optional<KeyType> initJwk(const JWK& keyData, std::optional<NamedCurve> namedCurve) override;
+
+  KeyDetail keyDetail() override;
+
+  KeyObjectData& getKeyObjectData() {
+    return data_;
+  }
+  const KeyObjectData& getKeyObjectData() const {
+    return data_;
+  }
+
+ private:
+  KeyObjectData data_;
+
+  bool initRawKey(KeyType keyType, std::shared_ptr<ArrayBuffer> keyData);
+};
+
+} // namespace margelo::nitro::crypto

package/cpp/keys/KeyObjectData.cpp

@@ -0,0 +1,268 @@
+#include "KeyObjectData.hpp"
+#include "Utils.hpp"
+#include <cstdio>
+#include <optional>
+
+namespace margelo::nitro::crypto {
+
+ncrypto::EVPKeyPointer::PrivateKeyEncodingConfig GetPrivateKeyEncodingConfig(KFormatType format, KeyEncoding type) {
+  auto pk_format = static_cast<ncrypto::EVPKeyPointer::PKFormatType>(format);
+  auto pk_type = static_cast<ncrypto::EVPKeyPointer::PKEncodingType>(type);
+
+  auto config = ncrypto::EVPKeyPointer::PrivateKeyEncodingConfig(false, pk_format, pk_type);
+  return config;
+}
+
+ncrypto::EVPKeyPointer::PublicKeyEncodingConfig GetPublicKeyEncodingConfig(KFormatType format, KeyEncoding type) {
+  auto pk_format = static_cast<ncrypto::EVPKeyPointer::PKFormatType>(format);
+  auto pk_type = static_cast<ncrypto::EVPKeyPointer::PKEncodingType>(type);
+
+  auto config = ncrypto::EVPKeyPointer::PublicKeyEncodingConfig(false, pk_format, pk_type);
+  return config;
+}
+
+KeyObjectData TryParsePrivateKey(std::shared_ptr<ArrayBuffer> key, std::optional<KFormatType> format, std::optional<KeyEncoding> type,
+                                 const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) {
+  // For PEM format, use PKCS8 as default encoding
+  KeyEncoding actualType = type.value_or(KeyEncoding::PKCS8);
+  auto config = GetPrivateKeyEncodingConfig(format.value(), actualType);
+
+  if (passphrase.has_value()) {
+    auto& passphrase_ptr = passphrase.value();
+    config.passphrase = std::make_optional(ncrypto::DataPointer(passphrase_ptr->data(), passphrase_ptr->size()));
+  }
+
+  auto buffer = ncrypto::Buffer<const unsigned char>{key->data(), key->size()};
+
+  // Clear any existing OpenSSL errors before parsing
+  ERR_clear_error();
+
+  auto res = ncrypto::EVPKeyPointer::TryParsePrivateKey(config, buffer);
+  if (res) {
+    return KeyObjectData::CreateAsymmetric(KeyType::PRIVATE, std::move(res.value));
+  }
+
+  if (res.error.has_value() && res.error.value() == ncrypto::EVPKeyPointer::PKParseError::NEED_PASSPHRASE) {
+    throw std::runtime_error("Passphrase required for encrypted key");
+  } else {
+    // Get OpenSSL error details
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("Failed to read private key: " + std::string(err_buf));
+  }
+}
+
+KeyObjectData::KeyObjectData(std::nullptr_t) : key_type_(KeyType::SECRET) {}
+
+KeyObjectData::KeyObjectData(std::shared_ptr<ArrayBuffer> symmetric_key)
+    : key_type_(KeyType::SECRET), data_(std::make_shared<Data>(std::move(symmetric_key))) {}
+
+KeyObjectData::KeyObjectData(KeyType type, ncrypto::EVPKeyPointer&& pkey)
+    : key_type_(type), data_(std::make_shared<Data>(std::move(pkey))) {}
+
+KeyObjectData KeyObjectData::CreateSecret(std::shared_ptr<ArrayBuffer> key) {
+  return KeyObjectData(std::move(key));
+}
+
+KeyObjectData KeyObjectData::CreateAsymmetric(KeyType key_type, ncrypto::EVPKeyPointer&& pkey) {
+  CHECK(pkey);
+  return KeyObjectData(key_type, std::move(pkey));
+}
+
+KeyType KeyObjectData::GetKeyType() const {
+  if (!data_) {
+    throw std::runtime_error("Invalid key object: no key data available");
+  }
+  return key_type_;
+}
+
+const ncrypto::EVPKeyPointer& KeyObjectData::GetAsymmetricKey() const {
+  if (key_type_ == KeyType::SECRET) {
+    throw std::runtime_error("Cannot get asymmetric key from secret key object");
+  }
+  if (!data_) {
+    throw std::runtime_error("Invalid key object: no key data available");
+  }
+  return data_->asymmetric_key;
+}
+
+std::shared_ptr<ArrayBuffer> KeyObjectData::GetSymmetricKey() const {
+  if (key_type_ != KeyType::SECRET) {
+    throw std::runtime_error("Cannot get symmetric key from asymmetric key object");
+  }
+  if (!data_) {
+    throw std::runtime_error("Invalid key object: no key data available");
+  }
+  return data_->symmetric_key;
+}
+
+size_t KeyObjectData::GetSymmetricKeySize() const {
+  if (key_type_ != KeyType::SECRET) {
+    throw std::runtime_error("Cannot get symmetric key size from asymmetric key object");
+  }
+  if (!data_) {
+    throw std::runtime_error("Invalid key object: no key data available");
+  }
+  return data_->symmetric_key->size();
+}
+
+KeyObjectData KeyObjectData::GetPublicOrPrivateKey(std::shared_ptr<ArrayBuffer> key, std::optional<KFormatType> format,
+                                                   std::optional<KeyEncoding> type,
+                                                   const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) {
+  if (key->size() > static_cast<size_t>(std::numeric_limits<int32_t>::max())) {
+    throw std::runtime_error("key is too big");
+  }
+
+  KFormatType actualFormat = format.value_or(KFormatType::DER);
+
+  if (actualFormat == KFormatType::PEM || actualFormat == KFormatType::DER) {
+    auto buffer = ncrypto::Buffer<const unsigned char>{key->data(), key->size()};
+
+    if (actualFormat == KFormatType::PEM) {
+      if (type.has_value() && type.value() == KeyEncoding::SPKI) {
+        auto res = ncrypto::EVPKeyPointer::TryParsePublicKeyPEM(buffer);
+        if (res) {
+          return CreateAsymmetric(KeyType::PUBLIC, std::move(res.value));
+        }
+        throw std::runtime_error("Failed to read PEM public key: key is not in SPKI format");
+      }
+
+      if (type.has_value() &&
+          (type.value() == KeyEncoding::PKCS8 || type.value() == KeyEncoding::SEC1 || type.value() == KeyEncoding::PKCS1)) {
+        auto config = GetPrivateKeyEncodingConfig(actualFormat, type.value());
+        if (passphrase.has_value()) {
+          auto& passphrase_ptr = passphrase.value();
+          config.passphrase = std::make_optional(ncrypto::DataPointer(passphrase_ptr->data(), passphrase_ptr->size()));
+        }
+        ERR_clear_error();
+        auto private_res = ncrypto::EVPKeyPointer::TryParsePrivateKey(config, buffer);
+        if (private_res) {
+          return CreateAsymmetric(KeyType::PRIVATE, std::move(private_res.value));
+        }
+        unsigned long err = ERR_get_error();
+        char err_buf[256];
+        ERR_error_string_n(err, err_buf, sizeof(err_buf));
+        throw std::runtime_error("Failed to read PEM private key: " + std::string(err_buf));
+      }
+
+      auto res = ncrypto::EVPKeyPointer::TryParsePublicKeyPEM(buffer);
+      if (res) {
+        return CreateAsymmetric(KeyType::PUBLIC, std::move(res.value));
+      }
+
+      KeyEncoding actualType = KeyEncoding::PKCS8;
+      auto config = GetPrivateKeyEncodingConfig(actualFormat, actualType);
+      if (passphrase.has_value()) {
+        auto& passphrase_ptr = passphrase.value();
+        config.passphrase = std::make_optional(ncrypto::DataPointer(passphrase_ptr->data(), passphrase_ptr->size()));
+      }
+
+      ERR_clear_error();
+
+      auto private_res = ncrypto::EVPKeyPointer::TryParsePrivateKey(config, buffer);
+      if (private_res) {
+        return CreateAsymmetric(KeyType::PRIVATE, std::move(private_res.value));
+      }
+
+      unsigned long err = ERR_get_error();
+      char err_buf[256];
+      ERR_error_string_n(err, err_buf, sizeof(err_buf));
+      throw std::runtime_error("Failed to read PEM asymmetric key: " + std::string(err_buf));
+    } else if (actualFormat == KFormatType::DER) {
+      // For DER, try parsing as public key first
+      if (type.has_value() && type.value() == KeyEncoding::SPKI) {
+        auto public_config = GetPublicKeyEncodingConfig(actualFormat, type.value());
+        auto res = ncrypto::EVPKeyPointer::TryParsePublicKey(public_config, buffer);
+        if (res) {
+          return CreateAsymmetric(KeyType::PUBLIC, std::move(res.value));
+        }
+      } else if (type.has_value() && type.value() == KeyEncoding::PKCS8) {
+        auto private_config = GetPrivateKeyEncodingConfig(actualFormat, type.value());
+        if (passphrase.has_value()) {
+          auto& passphrase_ptr = passphrase.value();
+          private_config.passphrase = std::make_optional(ncrypto::DataPointer(passphrase_ptr->data(), passphrase_ptr->size()));
+        }
+        auto res = ncrypto::EVPKeyPointer::TryParsePrivateKey(private_config, buffer);
+        if (res) {
+          return CreateAsymmetric(KeyType::PRIVATE, std::move(res.value));
+        }
+      } else {
+        // If no encoding type specified, try both SPKI and PKCS8
+        auto public_config = GetPublicKeyEncodingConfig(actualFormat, KeyEncoding::SPKI);
+        auto public_res = ncrypto::EVPKeyPointer::TryParsePublicKey(public_config, buffer);
+        if (public_res) {
+          return CreateAsymmetric(KeyType::PUBLIC, std::move(public_res.value));
+        }
+
+        auto private_config = GetPrivateKeyEncodingConfig(actualFormat, KeyEncoding::PKCS8);
+        auto private_res = ncrypto::EVPKeyPointer::TryParsePrivateKey(private_config, buffer);
+        if (private_res) {
+          return CreateAsymmetric(KeyType::PRIVATE, std::move(private_res.value));
+        }
+      }
+      throw std::runtime_error("Failed to read DER asymmetric key");
+    }
+  }
+
+  throw std::runtime_error("Unsupported key format for GetPublicOrPrivateKey. Only PEM and DER are supported.");
+}
+
+KeyObjectData KeyObjectData::GetPrivateKey(std::shared_ptr<ArrayBuffer> key, std::optional<KFormatType> format,
+                                           std::optional<KeyEncoding> type, const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase,
+                                           bool /* isPublic */) {
+  // Check if key size fits in int32_t without using double conversion
+  if (key->size() > static_cast<size_t>(std::numeric_limits<int32_t>::max())) {
+    std::string error_msg = "key is too big (int32): size=" + std::to_string(key->size()) +
+                            ", max_int32=" + std::to_string(std::numeric_limits<int32_t>::max());
+    throw std::runtime_error(error_msg);
+  }
+
+  // If no format is specified, assume DER format for binary data
+  KFormatType actualFormat = format.has_value() ? format.value() : KFormatType::DER;
+
+  if (actualFormat == KFormatType::PEM || actualFormat == KFormatType::DER) {
+    auto buffer = ncrypto::Buffer<const unsigned char>{key->data(), key->size()};
+
+    if (actualFormat == KFormatType::PEM) {
+      return TryParsePrivateKey(key, format, type, passphrase);
+    } else if (actualFormat == KFormatType::DER) {
+      // Try the specified encoding first, or PKCS8 as default
+      KeyEncoding primaryEncoding = type.value_or(KeyEncoding::PKCS8);
+      auto private_config = GetPrivateKeyEncodingConfig(actualFormat, primaryEncoding);
+      if (passphrase.has_value()) {
+        auto& passphrase_ptr = passphrase.value();
+        private_config.passphrase = std::make_optional(ncrypto::DataPointer(passphrase_ptr->data(), passphrase_ptr->size()));
+      }
+
+      // Clear any existing OpenSSL errors before parsing
+      ERR_clear_error();
+
+      auto res = ncrypto::EVPKeyPointer::TryParsePrivateKey(private_config, buffer);
+      if (res) {
+        return CreateAsymmetric(KeyType::PRIVATE, std::move(res.value));
+      }
+
+      // If no specific encoding was provided, try other encodings as fallback
+      if (!type.has_value()) {
+        std::vector<KeyEncoding> fallbackEncodings = {KeyEncoding::SEC1, KeyEncoding::PKCS1};
+        for (auto encoding : fallbackEncodings) {
+          auto config = GetPrivateKeyEncodingConfig(actualFormat, encoding);
+          if (passphrase.has_value()) {
+            auto& passphrase_ptr = passphrase.value();
+            config.passphrase = std::make_optional(ncrypto::DataPointer(passphrase_ptr->data(), passphrase_ptr->size()));
+          }
+          auto fallback_res = ncrypto::EVPKeyPointer::TryParsePrivateKey(config, buffer);
+          if (fallback_res) {
+            return CreateAsymmetric(KeyType::PRIVATE, std::move(fallback_res.value));
+          }
+        }
+      }
+      throw std::runtime_error("Failed to read DER private key");
+    }
+  }
+
+  throw std::runtime_error("Unsupported key format for GetPrivateKey. Only PEM and DER are supported.");
+}
+
+} // namespace margelo::nitro::crypto

package/cpp/keys/KeyObjectData.hpp

@@ -0,0 +1,71 @@
+#include <memory>
+
+#include <NitroModules/ArrayBuffer.hpp>
+
+#include "../../deps/ncrypto/ncrypto.h"
+#include "KFormatType.hpp"
+#include "KeyEncoding.hpp"
+#include "KeyType.hpp"
+#include "Utils.hpp"
+
+namespace margelo::nitro::crypto {
+
+class KeyObjectData final {
+ public:
+  static KeyObjectData CreateSecret(std::shared_ptr<ArrayBuffer> key);
+
+  static KeyObjectData CreateAsymmetric(KeyType type, ncrypto::EVPKeyPointer&& pkey);
+
+  KeyObjectData(std::nullptr_t = nullptr);
+
+  inline operator bool() const {
+    return data_ != nullptr;
+  }
+
+  KeyType GetKeyType() const;
+
+  // These functions allow unprotected access to the raw key material and should
+  // only be used to implement cryptographic operations requiring the key.
+  const ncrypto::EVPKeyPointer& GetAsymmetricKey() const;
+  std::shared_ptr<ArrayBuffer> GetSymmetricKey() const;
+  size_t GetSymmetricKeySize() const;
+
+  static KeyObjectData GetPublicOrPrivateKey(std::shared_ptr<ArrayBuffer> key, std::optional<KFormatType> format,
+                                             std::optional<KeyEncoding> type,
+                                             const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase);
+
+  static KeyObjectData GetPrivateKey(std::shared_ptr<ArrayBuffer> key, std::optional<KFormatType> format, std::optional<KeyEncoding> type,
+                                     const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase, bool isPublic);
+
+  inline KeyObjectData addRef() const {
+    return KeyObjectData(key_type_, data_);
+  }
+
+  inline KeyObjectData addRefWithType(KeyType type) const {
+    return KeyObjectData(type, data_);
+  }
+
+ private:
+  explicit KeyObjectData(std::shared_ptr<ArrayBuffer> symmetric_key);
+  explicit KeyObjectData(KeyType type, ncrypto::EVPKeyPointer&& pkey);
+
+  //   static KeyObjectData GetParsedKey(KeyType type,
+  //     Environment* env,
+  //     ncrypto::EVPKeyPointer&& pkey,
+  //     ParseKeyResult ret,
+  //     const char* default_msg);
+
+  KeyType key_type_;
+
+  struct Data {
+    const std::shared_ptr<ArrayBuffer> symmetric_key;
+    const ncrypto::EVPKeyPointer asymmetric_key;
+    explicit Data(std::shared_ptr<ArrayBuffer> symmetric_key) : symmetric_key(std::move(symmetric_key)) {}
+    explicit Data(ncrypto::EVPKeyPointer asymmetric_key) : asymmetric_key(std::move(asymmetric_key)) {}
+  };
+  std::shared_ptr<Data> data_;
+
+  KeyObjectData(KeyType type, std::shared_ptr<Data> data) : key_type_(type), data_(data) {}
+};
+
+} // namespace margelo::nitro::crypto

package/cpp/keys/node.h

@@ -0,0 +1,5 @@
+#pragma once
+
+// BINARY is a deprecated alias of LATIN1.
+// BASE64URL is not currently exposed to the JavaScript side.
+enum encoding { ASCII, UTF8, BASE64, UCS2, BINARY, HEX, BUFFER, BASE64URL, LATIN1 = BINARY };

package/cpp/pbkdf2/HybridPbkdf2.cpp

@@ -3,70 +3,49 @@
 
 namespace margelo::nitro::crypto {
 
-std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>
-HybridPbkdf2::pbkdf2(
-  const std::shared_ptr<ArrayBuffer>& password,
-  const std::shared_ptr<ArrayBuffer>& salt,
-  double iterations,
-  double keylen,
-  const std::string& digest
-) {
+std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> HybridPbkdf2::pbkdf2(const std::shared_ptr<ArrayBuffer>& password,
+                                                                            const std::shared_ptr<ArrayBuffer>& salt, double iterations,
+                                                                            double keylen, const std::string& digest) {
   // get owned NativeArrayBuffers before passing to sync function
   auto nativePassword = ToNativeArrayBuffer(password);
   auto nativeSalt = ToNativeArrayBuffer(salt);
 
-  return Promise<std::shared_ptr<ArrayBuffer>>::async(
-    [this, nativePassword, nativeSalt, iterations, keylen, digest]() {
-      return this->pbkdf2Sync(nativePassword, nativeSalt, iterations, keylen, digest);
-    }
-  );
+  return Promise<std::shared_ptr<ArrayBuffer>>::async([this, nativePassword, nativeSalt, iterations, keylen, digest]() {
+    return this->pbkdf2Sync(nativePassword, nativeSalt, iterations, keylen, digest);
+  });
 }
 
-std::shared_ptr<ArrayBuffer>
-HybridPbkdf2::pbkdf2Sync(
-  const std::shared_ptr<ArrayBuffer>& password,
-  const std::shared_ptr<ArrayBuffer>& salt,
-  double iterations,
-  double keylen,
-  const std::string& digest
-) {
-    size_t bufferSize = static_cast<size_t>(keylen);
-    uint8_t* data = new uint8_t[bufferSize];
-    auto result = std::make_shared<NativeArrayBuffer>(data, bufferSize, [=]() { delete[] data; });
+std::shared_ptr<ArrayBuffer> HybridPbkdf2::pbkdf2Sync(const std::shared_ptr<ArrayBuffer>& password,
+                                                      const std::shared_ptr<ArrayBuffer>& salt, double iterations, double keylen,
+                                                      const std::string& digest) {
+  size_t bufferSize = static_cast<size_t>(keylen);
+  uint8_t* data = new uint8_t[bufferSize];
+  auto result = std::make_shared<NativeArrayBuffer>(data, bufferSize, [=]() { delete[] data; });
 
-    // use fastpbkdf2 when possible
-    if (digest == "sha1") {
-      fastpbkdf2_hmac_sha1(password.get()->data(), password.get()->size(),
-                           salt.get()->data(), salt.get()->size(),
-                           static_cast<uint32_t>(iterations),
-                           result.get()->data(), result.get()->size());
-    } else if (digest == "sha256") {
-      fastpbkdf2_hmac_sha256(password.get()->data(), password.get()->size(),
-                             salt.get()->data(), salt.get()->size(),
-                             static_cast<uint32_t>(iterations),
-                             result.get()->data(), result.get()->size());
-    } else if (digest == "sha512") {
-      fastpbkdf2_hmac_sha512(password.get()->data(), password.get()->size(),
-                             salt.get()->data(), salt.get()->size(),
-                             static_cast<uint32_t>(iterations),
-                             result.get()->data(), result.get()->size());
-    } else {
-      // fallback to OpenSSL
-      auto *digestByName = EVP_get_digestbyname(digest.c_str());
-      if (digestByName == nullptr) {
-        throw std::runtime_error("Invalid hash-algorithm: " + digest);
-      }
-      char *passAsCharA = reinterpret_cast<char *>(password.get()->data());
-      const unsigned char *saltAsCharA =
-          reinterpret_cast<const unsigned char *>(salt.get()->data());
-      unsigned char *resultAsCharA =
-          reinterpret_cast<unsigned char *>(result.get()->data());
-      PKCS5_PBKDF2_HMAC(passAsCharA, password.get()->size(), saltAsCharA,
-                        salt.get()->size(), static_cast<uint32_t>(iterations),
-                        digestByName, result.get()->size(), resultAsCharA);
+  // use fastpbkdf2 when possible
+  if (digest == "sha1") {
+    fastpbkdf2_hmac_sha1(password.get()->data(), password.get()->size(), salt.get()->data(), salt.get()->size(),
+                         static_cast<uint32_t>(iterations), result.get()->data(), result.get()->size());
+  } else if (digest == "sha256") {
+    fastpbkdf2_hmac_sha256(password.get()->data(), password.get()->size(), salt.get()->data(), salt.get()->size(),
+                           static_cast<uint32_t>(iterations), result.get()->data(), result.get()->size());
+  } else if (digest == "sha512") {
+    fastpbkdf2_hmac_sha512(password.get()->data(), password.get()->size(), salt.get()->data(), salt.get()->size(),
+                           static_cast<uint32_t>(iterations), result.get()->data(), result.get()->size());
+  } else {
+    // fallback to OpenSSL
+    auto* digestByName = EVP_get_digestbyname(digest.c_str());
+    if (digestByName == nullptr) {
+      throw std::runtime_error("Invalid hash-algorithm: " + digest);
     }
+    char* passAsCharA = reinterpret_cast<char*>(password.get()->data());
+    const unsigned char* saltAsCharA = reinterpret_cast<const unsigned char*>(salt.get()->data());
+    unsigned char* resultAsCharA = reinterpret_cast<unsigned char*>(result.get()->data());
+    PKCS5_PBKDF2_HMAC(passAsCharA, password.get()->size(), saltAsCharA, salt.get()->size(), static_cast<uint32_t>(iterations), digestByName,
+                      result.get()->size(), resultAsCharA);
+  }
 
-    return result;
+  return result;
 }
 
 } // namespace margelo::nitro::crypto

package/cpp/pbkdf2/HybridPbkdf2.hpp

@@ -13,23 +13,12 @@ class HybridPbkdf2 : public HybridPbkdf2Spec {
 
  public:
   // Methods
-  std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>
-  pbkdf2(
-    const std::shared_ptr<ArrayBuffer>& password,
-    const std::shared_ptr<ArrayBuffer>& salt,
-    double iterations,
-    double keylen,
-    const std::string& digest
-  ) override;
+  std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> pbkdf2(const std::shared_ptr<ArrayBuffer>& password,
+                                                                const std::shared_ptr<ArrayBuffer>& salt, double iterations, double keylen,
+                                                                const std::string& digest) override;
 
-  std::shared_ptr<ArrayBuffer>
-  pbkdf2Sync(
-    const std::shared_ptr<ArrayBuffer>& password,
-    const std::shared_ptr<ArrayBuffer>& salt,
-    double iterations,
-    double keylen,
-    const std::string& digest
-  ) override;
+  std::shared_ptr<ArrayBuffer> pbkdf2Sync(const std::shared_ptr<ArrayBuffer>& password, const std::shared_ptr<ArrayBuffer>& salt,
+                                          double iterations, double keylen, const std::string& digest) override;
 };
 
 } // namespace margelo::nitro::crypto

package/cpp/random/HybridRandom.cpp

@@ -4,6 +4,7 @@
 #include "HybridRandom.hpp"
 #include "Utils.hpp"
 
+namespace margelo::nitro::crypto {
 
 size_t checkSize(double size) {
   if (!CheckIsUint32(size)) {
@@ -25,33 +26,21 @@ size_t checkOffset(double size, double offset) {
   return static_cast<size_t>(offset);
 }
 
-
-namespace margelo::nitro::crypto {
-
-std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>
-HybridRandom::randomFill(const std::shared_ptr<ArrayBuffer>& buffer,
-                         double dOffset,
-                         double dSize) {
+std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> HybridRandom::randomFill(const std::shared_ptr<ArrayBuffer>& buffer, double dOffset,
+                                                                                double dSize) {
   // get owned NativeArrayBuffer before passing to sync function
   auto nativeBuffer = ToNativeArrayBuffer(buffer);
 
   return Promise<std::shared_ptr<ArrayBuffer>>::async(
-    [this, nativeBuffer, dOffset, dSize]() {
-      return this->randomFillSync(nativeBuffer, dOffset, dSize);
-    }
-  );
+      [this, nativeBuffer, dOffset, dSize]() { return this->randomFillSync(nativeBuffer, dOffset, dSize); });
 };
 
-std::shared_ptr<ArrayBuffer>
-HybridRandom::randomFillSync(const std::shared_ptr<ArrayBuffer>& buffer,
-                             double dOffset,
-                             double dSize) {
+std::shared_ptr<ArrayBuffer> HybridRandom::randomFillSync(const std::shared_ptr<ArrayBuffer>& buffer, double dOffset, double dSize) {
   size_t size = checkSize(dSize);
   size_t offset = checkOffset(dSize, dOffset);
   uint8_t* data = buffer.get()->data();
   if (RAND_bytes(data + offset, (int)size) != 1) {
-    throw std::runtime_error("error calling RAND_bytes" +
-      std::to_string(ERR_get_error()));
+    throw std::runtime_error("error calling RAND_bytes: " + std::to_string(ERR_get_error()));
   }
   return buffer;
 };

package/cpp/random/HybridRandom.hpp

@@ -1,7 +1,7 @@
 #include <cmath>
 #include <future>
-#include <memory>
 #include <iostream>
+#include <memory>
 
 #include "HybridRandomSpec.hpp"
 
@@ -15,17 +15,16 @@ class HybridRandom : public HybridRandomSpec {
 
  public:
   // Methods
-  std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>
-  randomFill(const std::shared_ptr<ArrayBuffer>& buffer, double dOffset, double dSize) override;
+  std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> randomFill(const std::shared_ptr<ArrayBuffer>& buffer, double dOffset,
+                                                                    double dSize) override;
 
-  std::shared_ptr<ArrayBuffer>
-  randomFillSync(const std::shared_ptr<ArrayBuffer>& buffer, double dOffset, double dSize) override;
+  std::shared_ptr<ArrayBuffer> randomFillSync(const std::shared_ptr<ArrayBuffer>& buffer, double dOffset, double dSize) override;
 };
 
 inline void printData(std::string name, uint8_t* data, size_t size) {
   std::cout << "data - " << name << std::endl;
   for (size_t i = 0; i < size; i++) {
-      printf("%u ", data[i]);
+    printf("%u ", data[i]);
   }
   printf("\n");
 }