react-native-quick-crypto 1.0.7 → 1.0.8

package/cpp/ecdh/HybridECDH.cpp

@@ -0,0 +1,306 @@
+#include "HybridECDH.hpp"
+#include "QuickCryptoUtils.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <openssl/bn.h>
+#include <openssl/ec.h>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <openssl/obj_mac.h>
+#include <stdexcept>
+
+namespace margelo::nitro::crypto {
+
+// Smart pointer type aliases for RAII
+using EVP_PKEY_CTX_ptr = std::unique_ptr<EVP_PKEY_CTX, decltype(&EVP_PKEY_CTX_free)>;
+using EC_KEY_ptr = std::unique_ptr<EC_KEY, decltype(&EC_KEY_free)>;
+using EC_POINT_ptr = std::unique_ptr<EC_POINT, decltype(&EC_POINT_free)>;
+using BN_ptr = std::unique_ptr<BIGNUM, decltype(&BN_free)>;
+
+// Suppress deprecation warnings for EC_KEY_* functions
+// These APIs work but are deprecated in OpenSSL 3.x
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+
+void HybridECDH::init(const std::string& curveName) {
+  int nid = getCurveNid(curveName);
+  if (nid == NID_undef) {
+    throw std::runtime_error("ECDH: unknown curve name: " + curveName);
+  }
+
+  EC_GROUP_ptr group(EC_GROUP_new_by_curve_name(nid), EC_GROUP_free);
+  if (!group) {
+    throw std::runtime_error("ECDH: failed to create EC group for curve: " + curveName);
+  }
+
+  _curveName = curveName;
+  _curveNid = nid;
+  _group = std::move(group);
+  _pkey.reset();
+}
+
+std::shared_ptr<ArrayBuffer> HybridECDH::generateKeys() {
+  ensureInitialized();
+
+  EVP_PKEY_CTX_ptr ctx(EVP_PKEY_CTX_new_id(EVP_PKEY_EC, nullptr), EVP_PKEY_CTX_free);
+  if (!ctx) {
+    throw std::runtime_error("ECDH: failed to create keygen context");
+  }
+
+  if (EVP_PKEY_keygen_init(ctx.get()) <= 0) {
+    throw std::runtime_error("ECDH: failed to initialize key generation");
+  }
+
+  if (EVP_PKEY_CTX_set_ec_paramgen_curve_nid(ctx.get(), _curveNid) <= 0) {
+    throw std::runtime_error("ECDH: failed to set curve");
+  }
+
+  EVP_PKEY* pkey = nullptr;
+  if (EVP_PKEY_keygen(ctx.get(), &pkey) <= 0) {
+    throw std::runtime_error("ECDH: failed to generate key pair");
+  }
+
+  _pkey.reset(pkey);
+
+  return getPublicKey();
+}
+
+std::shared_ptr<ArrayBuffer> HybridECDH::computeSecret(const std::shared_ptr<ArrayBuffer>& otherPublicKey) {
+  ensureInitialized();
+  if (!_pkey) {
+    throw std::runtime_error("ECDH: private key not set");
+  }
+
+  // Create EC_POINT from the peer's public key bytes
+  EC_POINT_ptr point(EC_POINT_new(_group.get()), EC_POINT_free);
+  if (!point) {
+    throw std::runtime_error("ECDH: failed to create EC point");
+  }
+
+  if (EC_POINT_oct2point(_group.get(), point.get(), otherPublicKey->data(), otherPublicKey->size(), nullptr) != 1) {
+    throw std::runtime_error("ECDH: failed to decode peer public key");
+  }
+
+  // Create EC_KEY for the peer
+  EC_KEY_ptr ecKey(EC_KEY_new(), EC_KEY_free);
+  if (!ecKey) {
+    throw std::runtime_error("ECDH: failed to create EC_KEY");
+  }
+
+  if (EC_KEY_set_group(ecKey.get(), _group.get()) != 1) {
+    throw std::runtime_error("ECDH: failed to set EC group");
+  }
+
+  if (EC_KEY_set_public_key(ecKey.get(), point.get()) != 1) {
+    throw std::runtime_error("ECDH: failed to set peer public key");
+  }
+
+  // Create EVP_PKEY for the peer
+  EVP_PKEY_ptr peerPkey(EVP_PKEY_new(), EVP_PKEY_free);
+  if (!peerPkey) {
+    throw std::runtime_error("ECDH: failed to create peer EVP_PKEY");
+  }
+
+  // EVP_PKEY_assign_EC_KEY takes ownership of ecKey on success
+  if (EVP_PKEY_assign_EC_KEY(peerPkey.get(), ecKey.get()) != 1) {
+    throw std::runtime_error("ECDH: failed to assign EC_KEY to EVP_PKEY");
+  }
+  ecKey.release(); // EVP_PKEY now owns the EC_KEY
+
+  // Derive shared secret using EVP API
+  EVP_PKEY_CTX_ptr ctx(EVP_PKEY_CTX_new(_pkey.get(), nullptr), EVP_PKEY_CTX_free);
+  if (!ctx) {
+    throw std::runtime_error("ECDH: failed to create derive context");
+  }
+
+  if (EVP_PKEY_derive_init(ctx.get()) <= 0) {
+    throw std::runtime_error("ECDH: failed to initialize key derivation");
+  }
+
+  if (EVP_PKEY_derive_set_peer(ctx.get(), peerPkey.get()) <= 0) {
+    throw std::runtime_error("ECDH: failed to set peer key for derivation");
+  }
+
+  // Get required buffer size
+  size_t secretLen = 0;
+  if (EVP_PKEY_derive(ctx.get(), nullptr, &secretLen) <= 0) {
+    throw std::runtime_error("ECDH: failed to get shared secret length");
+  }
+
+  // Derive the shared secret
+  std::vector<uint8_t> secret(secretLen);
+  if (EVP_PKEY_derive(ctx.get(), secret.data(), &secretLen) <= 0) {
+    throw std::runtime_error("ECDH: failed to derive shared secret");
+  }
+
+  secret.resize(secretLen);
+
+  return ToNativeArrayBuffer(secret);
+}
+
+std::shared_ptr<ArrayBuffer> HybridECDH::getPrivateKey() {
+  if (!_pkey) {
+    throw std::runtime_error("ECDH: no key set");
+  }
+
+  const EC_KEY* ec = EVP_PKEY_get0_EC_KEY(_pkey.get());
+  if (!ec) {
+    throw std::runtime_error("ECDH: key is not an EC key");
+  }
+
+  const BIGNUM* priv = EC_KEY_get0_private_key(ec);
+  if (!priv) {
+    throw std::runtime_error("ECDH: no private key available");
+  }
+
+  int len = BN_num_bytes(priv);
+  std::vector<uint8_t> buf(len);
+  BN_bn2bin(priv, buf.data());
+
+  return ToNativeArrayBuffer(buf);
+}
+
+void HybridECDH::setPrivateKey(const std::shared_ptr<ArrayBuffer>& privateKey) {
+  ensureInitialized();
+
+  // Create new EC_KEY
+  EC_KEY_ptr ecKey(EC_KEY_new(), EC_KEY_free);
+  if (!ecKey) {
+    throw std::runtime_error("ECDH: failed to create EC_KEY");
+  }
+
+  if (EC_KEY_set_group(ecKey.get(), _group.get()) != 1) {
+    throw std::runtime_error("ECDH: failed to set EC group");
+  }
+
+  // Convert private key bytes to BIGNUM
+  BN_ptr privBn(BN_bin2bn(privateKey->data(), static_cast<int>(privateKey->size()), nullptr), BN_free);
+  if (!privBn) {
+    throw std::runtime_error("ECDH: failed to convert private key");
+  }
+
+  // Calculate public key from private key
+  EC_POINT_ptr pubPoint(EC_POINT_new(_group.get()), EC_POINT_free);
+  if (!pubPoint) {
+    throw std::runtime_error("ECDH: failed to create EC point");
+  }
+
+  if (EC_POINT_mul(_group.get(), pubPoint.get(), privBn.get(), nullptr, nullptr, nullptr) != 1) {
+    throw std::runtime_error("ECDH: failed to compute public key from private key");
+  }
+
+  // Set keys on EC_KEY (these functions copy the values, so we still own privBn and pubPoint)
+  if (EC_KEY_set_private_key(ecKey.get(), privBn.get()) != 1) {
+    throw std::runtime_error("ECDH: failed to set private key");
+  }
+
+  if (EC_KEY_set_public_key(ecKey.get(), pubPoint.get()) != 1) {
+    throw std::runtime_error("ECDH: failed to set public key");
+  }
+
+  // Create new EVP_PKEY
+  EVP_PKEY_ptr pkey(EVP_PKEY_new(), EVP_PKEY_free);
+  if (!pkey) {
+    throw std::runtime_error("ECDH: failed to create EVP_PKEY");
+  }
+
+  // EVP_PKEY_assign_EC_KEY takes ownership of ecKey on success
+  if (EVP_PKEY_assign_EC_KEY(pkey.get(), ecKey.get()) != 1) {
+    throw std::runtime_error("ECDH: failed to assign EC_KEY to EVP_PKEY");
+  }
+  ecKey.release(); // EVP_PKEY now owns the EC_KEY
+
+  _pkey = std::move(pkey);
+}
+
+std::shared_ptr<ArrayBuffer> HybridECDH::getPublicKey() {
+  if (!_pkey) {
+    throw std::runtime_error("ECDH: no key set");
+  }
+
+  const EC_KEY* ec = EVP_PKEY_get0_EC_KEY(_pkey.get());
+  if (!ec) {
+    throw std::runtime_error("ECDH: key is not an EC key");
+  }
+
+  const EC_POINT* point = EC_KEY_get0_public_key(ec);
+  const EC_GROUP* group = EC_KEY_get0_group(ec);
+  if (!point || !group) {
+    throw std::runtime_error("ECDH: incomplete key");
+  }
+
+  // Get uncompressed public key size
+  size_t len = EC_POINT_point2oct(group, point, POINT_CONVERSION_UNCOMPRESSED, nullptr, 0, nullptr);
+  if (len == 0) {
+    throw std::runtime_error("ECDH: failed to get public key length");
+  }
+
+  std::vector<uint8_t> buf(len);
+  if (EC_POINT_point2oct(group, point, POINT_CONVERSION_UNCOMPRESSED, buf.data(), len, nullptr) == 0) {
+    throw std::runtime_error("ECDH: failed to encode public key");
+  }
+
+  return ToNativeArrayBuffer(buf);
+}
+
+void HybridECDH::setPublicKey(const std::shared_ptr<ArrayBuffer>& publicKey) {
+  ensureInitialized();
+
+  // Create EC_POINT from the public key bytes
+  EC_POINT_ptr point(EC_POINT_new(_group.get()), EC_POINT_free);
+  if (!point) {
+    throw std::runtime_error("ECDH: failed to create EC point");
+  }
+
+  if (EC_POINT_oct2point(_group.get(), point.get(), publicKey->data(), publicKey->size(), nullptr) != 1) {
+    throw std::runtime_error("ECDH: invalid public key");
+  }
+
+  // Create new EC_KEY
+  EC_KEY_ptr ecKey(EC_KEY_new(), EC_KEY_free);
+  if (!ecKey) {
+    throw std::runtime_error("ECDH: failed to create EC_KEY");
+  }
+
+  if (EC_KEY_set_group(ecKey.get(), _group.get()) != 1) {
+    throw std::runtime_error("ECDH: failed to set EC group");
+  }
+
+  if (EC_KEY_set_public_key(ecKey.get(), point.get()) != 1) {
+    throw std::runtime_error("ECDH: failed to set public key");
+  }
+
+  // Create new EVP_PKEY
+  EVP_PKEY_ptr pkey(EVP_PKEY_new(), EVP_PKEY_free);
+  if (!pkey) {
+    throw std::runtime_error("ECDH: failed to create EVP_PKEY");
+  }
+
+  // EVP_PKEY_assign_EC_KEY takes ownership of ecKey on success
+  if (EVP_PKEY_assign_EC_KEY(pkey.get(), ecKey.get()) != 1) {
+    throw std::runtime_error("ECDH: failed to assign EC_KEY to EVP_PKEY");
+  }
+  ecKey.release(); // EVP_PKEY now owns the EC_KEY
+
+  _pkey = std::move(pkey);
+}
+
+void HybridECDH::ensureInitialized() const {
+  if (_curveNid == 0 || !_group) {
+    throw std::runtime_error("ECDH: not initialized");
+  }
+}
+
+int HybridECDH::getCurveNid(const std::string& name) {
+  int nid = OBJ_txt2nid(name.c_str());
+  if (nid == NID_undef) {
+    nid = OBJ_sn2nid(name.c_str());
+  }
+  if (nid == NID_undef) {
+    nid = OBJ_ln2nid(name.c_str());
+  }
+  return nid;
+}
+
+#pragma clang diagnostic pop
+
+} // namespace margelo::nitro::crypto

package/cpp/ecdh/HybridECDH.hpp

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <memory>
+#include <openssl/ec.h>
+#include <openssl/evp.h>
+#include <string>
+#include <vector>
+
+#include "HybridECDHSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+using namespace facebook;
+using margelo::nitro::ArrayBuffer;
+
+using EVP_PKEY_ptr = std::unique_ptr<EVP_PKEY, decltype(&EVP_PKEY_free)>;
+using EC_GROUP_ptr = std::unique_ptr<EC_GROUP, decltype(&EC_GROUP_free)>;
+
+class HybridECDH : public HybridECDHSpec {
+ public:
+  HybridECDH() : HybridObject("ECDH"), _pkey(nullptr, EVP_PKEY_free), _group(nullptr, EC_GROUP_free) {}
+  virtual ~HybridECDH() = default;
+
+  void init(const std::string& curveName) override;
+  std::shared_ptr<ArrayBuffer> generateKeys() override;
+  std::shared_ptr<ArrayBuffer> computeSecret(const std::shared_ptr<ArrayBuffer>& otherPublicKey) override;
+  std::shared_ptr<ArrayBuffer> getPrivateKey() override;
+  void setPrivateKey(const std::shared_ptr<ArrayBuffer>& privateKey) override;
+  std::shared_ptr<ArrayBuffer> getPublicKey() override;
+  void setPublicKey(const std::shared_ptr<ArrayBuffer>& publicKey) override;
+
+ private:
+  EVP_PKEY_ptr _pkey;
+  EC_GROUP_ptr _group;
+  std::string _curveName;
+  int _curveNid = 0;
+
+  void ensureInitialized() const;
+  static int getCurveNid(const std::string& name);
+};
+
+} // namespace margelo::nitro::crypto

package/cpp/utils/QuickCryptoUtils.hpp

@@ -5,6 +5,7 @@
 #include <limits>
 #include <openssl/err.h>
 #include <string>
+#include <vector>
 
 #include "Macros.hpp"
 #include <NitroModules/ArrayBuffer.hpp>
@@ -44,6 +45,19 @@ inline std::shared_ptr<margelo::nitro::NativeArrayBuffer> ToNativeArrayBuffer(st
   return std::make_shared<margelo::nitro::NativeArrayBuffer>(data, size, [=]() { delete[] data; });
 }
 
+inline std::shared_ptr<margelo::nitro::NativeArrayBuffer> ToNativeArrayBuffer(const std::vector<uint8_t>& vec) {
+  size_t size = vec.size();
+  uint8_t* data = new uint8_t[size];
+  memcpy(data, vec.data(), size);
+  return std::make_shared<margelo::nitro::NativeArrayBuffer>(data, size, [=]() { delete[] data; });
+}
+
+inline std::shared_ptr<margelo::nitro::NativeArrayBuffer> ToNativeArrayBuffer(const uint8_t* ptr, size_t size) {
+  uint8_t* data = new uint8_t[size];
+  memcpy(data, ptr, size);
+  return std::make_shared<margelo::nitro::NativeArrayBuffer>(data, size, [=]() { delete[] data; });
+}
+
 inline bool CheckIsUint32(double value) {
   return (value >= std::numeric_limits<uint32_t>::lowest() && value <= std::numeric_limits<uint32_t>::max());
 }

package/lib/commonjs/dh-groups.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DH_GROUPS = void 0;
+const DH_GROUPS = exports.DH_GROUPS = {
+  modp14: {
+    prime: 'ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aacaa68ffffffffffffffff',
+    generator: '02'
+  },
+  modp15: {
+    prime: 'ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a93ad2caffffffffffffffff',
+    generator: '02'
+  },
+  modp16: {
+    prime: 'ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c934063199ffffffffffffffff',
+    generator: '02'
+  },
+  modp17: {
+    prime: 'ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c93402849236c3fab4d27c7026c1d4dcb2602646dec9751e763dba37bdf8ff9406ad9e530ee5db382f413001aeb06a53ed9027d831179727b0865a8918da3edbebcf9b14ed44ce6cbaced4bb1bdb7f1447e6cc254b332051512bd7af426fb8f401378cd2bf5983ca01c64b92ecf032ea15d1721d03f482d7ce6e74fef6d55e702f46980c82b5a84031900b1c9e59e7c97fbec7e8f323a97a7e36cc88be0f1d45b7ff585ac54bd407b22b4154aacc8f6d7ebf48e1d814cc5ed20f8037e0a79715eef29be32806a1d58bb7c5da76f550aa3d8a1fbff0eb19ccb1a313d55cda56c9ec2ef29632387fe8d76e3c0468043e8f663f4860ee12bf2d5b0b7474d6e694f91e6dcc4024ffffffffffffffff',
+    generator: '02'
+  },
+  modp18: {
+    prime: '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',
+    generator: '02'
+  }
+};
+//# sourceMappingURL=dh-groups.js.map

package/lib/commonjs/dh-groups.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DH_GROUPS","exports","modp14","prime","generator","modp15","modp16","modp17","modp18"],"sourceRoot":"../../src","sources":["dh-groups.ts"],"mappings":";;;;;;AAAO,MAAMA,SAA+D,GAAAC,OAAA,CAAAD,SAAA,GAAG;EAC7EE,MAAM,EAAE;IACNC,KAAK,EACH,kgBAAkgB;IACpgBC,SAAS,EAAE;EACb,CAAC;EACDC,MAAM,EAAE;IACNF,KAAK,EACH,kwBAAkwB;IACpwBC,SAAS,EAAE;EACb,CAAC;EACDE,MAAM,EAAE;IACNH,KAAK,EACH,kgCAAkgC;IACpgCC,SAAS,EAAE;EACb,CAAC;EACDG,MAAM,EAAE;IACNJ,KAAK,EACH,kgDAAkgD;IACpgDC,SAAS,EAAE;EACb,CAAC;EACDI,MAAM,EAAE;IACNL,KAAK,EACH,kgEAAkgE;IACpgEC,SAAS,EAAE;EACb;AACF,CAAC","ignoreList":[]}

package/lib/commonjs/diffie-hellman.js

@@ -0,0 +1,147 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DiffieHellman = void 0;
+exports.createDiffieHellman = createDiffieHellman;
+exports.getDiffieHellman = getDiffieHellman;
+var _reactNativeNitroModules = require("react-native-nitro-modules");
+var _reactNativeBuffer = require("@craftzdog/react-native-buffer");
+var _dhGroups = require("./dh-groups");
+class DiffieHellman {
+  constructor(sizeOrPrime, generator, encoding) {
+    this._hybrid = _reactNativeNitroModules.NitroModules.createHybridObject('DiffieHellman');
+    if (typeof sizeOrPrime === 'number') {
+      const gen = typeof generator === 'number' ? generator : 2;
+      this._hybrid.initWithSize(sizeOrPrime, gen);
+    } else {
+      let primeBuf;
+      if (_reactNativeBuffer.Buffer.isBuffer(sizeOrPrime)) {
+        primeBuf = sizeOrPrime;
+      } else {
+        primeBuf = _reactNativeBuffer.Buffer.from(sizeOrPrime, encoding);
+      }
+      let genBuf;
+      if (generator === undefined) {
+        genBuf = _reactNativeBuffer.Buffer.from([2]);
+      } else if (typeof generator === 'number') {
+        genBuf = _reactNativeBuffer.Buffer.from([generator]);
+      } else if (_reactNativeBuffer.Buffer.isBuffer(generator)) {
+        genBuf = generator;
+      } else {
+        genBuf = _reactNativeBuffer.Buffer.from(generator, encoding);
+      }
+      this._hybrid.init(primeBuf.buffer, genBuf.buffer);
+    }
+  }
+  generateKeys(encoding) {
+    const keys = _reactNativeBuffer.Buffer.from(this._hybrid.generateKeys());
+    if (encoding) return keys.toString(encoding);
+    return keys;
+  }
+  computeSecret(otherPublicKey, inputEncoding, outputEncoding) {
+    let keyBuf;
+    if (_reactNativeBuffer.Buffer.isBuffer(otherPublicKey)) {
+      keyBuf = otherPublicKey;
+    } else {
+      keyBuf = _reactNativeBuffer.Buffer.from(otherPublicKey, inputEncoding);
+    }
+    const secret = _reactNativeBuffer.Buffer.from(this._hybrid.computeSecret(keyBuf.buffer));
+    if (outputEncoding) return secret.toString(outputEncoding);
+    return secret;
+  }
+  getPrime(encoding) {
+    const p = _reactNativeBuffer.Buffer.from(this._hybrid.getPrime());
+    if (encoding) return p.toString(encoding);
+    return p;
+  }
+  getGenerator(encoding) {
+    const g = _reactNativeBuffer.Buffer.from(this._hybrid.getGenerator());
+    if (encoding) return g.toString(encoding);
+    return g;
+  }
+  getPublicKey(encoding) {
+    const p = _reactNativeBuffer.Buffer.from(this._hybrid.getPublicKey());
+    if (encoding) return p.toString(encoding);
+    return p;
+  }
+  getPrivateKey(encoding) {
+    const p = _reactNativeBuffer.Buffer.from(this._hybrid.getPrivateKey());
+    if (encoding) return p.toString(encoding);
+    return p;
+  }
+  setPublicKey(publicKey, encoding) {
+    let keyBuf;
+    if (_reactNativeBuffer.Buffer.isBuffer(publicKey)) {
+      keyBuf = publicKey;
+    } else {
+      keyBuf = _reactNativeBuffer.Buffer.from(publicKey, encoding);
+    }
+    this._hybrid.setPublicKey(keyBuf.buffer);
+  }
+  setPrivateKey(privateKey, encoding) {
+    let keyBuf;
+    if (_reactNativeBuffer.Buffer.isBuffer(privateKey)) {
+      keyBuf = privateKey;
+    } else {
+      keyBuf = _reactNativeBuffer.Buffer.from(privateKey, encoding);
+    }
+    this._hybrid.setPrivateKey(keyBuf.buffer);
+  }
+}
+exports.DiffieHellman = DiffieHellman;
+function createDiffieHellman(primeOrSize, primeEncodingOrGenerator, generator, _generatorEncoding) {
+  if (typeof primeOrSize === 'number') {
+    const gen = typeof primeEncodingOrGenerator === 'number' ? primeEncodingOrGenerator : 2;
+    return new DiffieHellman(primeOrSize, gen);
+  }
+
+  // Standardize arguments for String/Buffer prime
+  // createDiffieHellman(prime, [encoding], [generator], [encoding])
+
+  let prime;
+  let generatorVal;
+  if (_reactNativeBuffer.Buffer.isBuffer(primeOrSize)) {
+    prime = primeOrSize;
+    // 2nd arg is generator if not string (encoding)
+    if (primeEncodingOrGenerator !== undefined && typeof primeEncodingOrGenerator !== 'string') {
+      generatorVal = primeEncodingOrGenerator;
+    } else if (generator !== undefined) {
+      generatorVal = generator;
+    } else {
+      generatorVal = 2;
+    }
+  } else {
+    // String prime
+    const encoding = typeof primeEncodingOrGenerator === 'string' ? primeEncodingOrGenerator : 'utf8'; // Defaulting to utf8 or hex? Node default is 'binary' usually but utf8 safer for TS. Node docs say: "If no encoding is specified, 'binary' is used."
+    // We'll trust user passed encoding if it's a string, otherwise handle it.
+    prime = _reactNativeBuffer.Buffer.from(primeOrSize, encoding);
+
+    // Generator handling in this case
+    if (generator !== undefined) {
+      generatorVal = generator;
+      if (typeof generator === 'string' && _generatorEncoding) {
+        generatorVal = _reactNativeBuffer.Buffer.from(generator, _generatorEncoding);
+      } else if (typeof generator === 'string') {
+        // string with no encoding, assume same as prime? or utf8?
+        generatorVal = _reactNativeBuffer.Buffer.from(generator, encoding);
+      }
+    } else if (typeof primeEncodingOrGenerator !== 'string' && primeEncodingOrGenerator !== undefined) {
+      // 2nd arg was generator
+      generatorVal = primeEncodingOrGenerator;
+    } else {
+      generatorVal = 2;
+    }
+  }
+  return new DiffieHellman(prime, generatorVal);
+}
+function getDiffieHellman(groupName) {
+  const group = _dhGroups.DH_GROUPS[groupName];
+  if (!group) {
+    throw new Error(`Unknown group: ${groupName}`);
+  }
+  // group.prime and group.generator are hex strings
+  return new DiffieHellman(group.prime, group.generator, 'hex');
+}
+//# sourceMappingURL=diffie-hellman.js.map

package/lib/commonjs/diffie-hellman.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNativeNitroModules","require","_reactNativeBuffer","_dhGroups","DiffieHellman","constructor","sizeOrPrime","generator","encoding","_hybrid","NitroModules","createHybridObject","gen","initWithSize","primeBuf","Buffer","isBuffer","from","genBuf","undefined","init","buffer","generateKeys","keys","toString","computeSecret","otherPublicKey","inputEncoding","outputEncoding","keyBuf","secret","getPrime","p","getGenerator","g","getPublicKey","getPrivateKey","setPublicKey","publicKey","setPrivateKey","privateKey","exports","createDiffieHellman","primeOrSize","primeEncodingOrGenerator","_generatorEncoding","prime","generatorVal","getDiffieHellman","groupName","group","DH_GROUPS","Error"],"sourceRoot":"../../src","sources":["diffie-hellman.ts"],"mappings":"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","ignoreList":[]}