react-native-quick-crypto 1.0.6 → 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/ed25519/HybridEdKeyPair.hpp

@@ -4,7 +4,7 @@
 #include <string>
 
 #include "HybridEdKeyPairSpec.hpp"
-#include "Utils.hpp"
+#include "QuickCryptoUtils.hpp"
 
 namespace margelo::nitro::crypto {
 

package/cpp/hash/HybridHash.cpp

@@ -7,7 +7,7 @@
 #include <vector>
 
 #include "HybridHash.hpp"
-#include "Utils.hpp"
+#include "QuickCryptoUtils.hpp"
 
 namespace margelo::nitro::crypto {
 

package/cpp/hkdf/HybridHkdf.cpp

@@ -8,7 +8,7 @@
 #include <vector>
 
 #include "HybridHkdf.hpp"
-#include "Utils.hpp"
+#include "QuickCryptoUtils.hpp"
 
 namespace margelo::nitro::crypto {
 

package/cpp/keys/HybridKeyObjectHandle.cpp

@@ -3,7 +3,7 @@
 
 #include "../utils/base64.h"
 #include "HybridKeyObjectHandle.hpp"
-#include "Utils.hpp"
+#include "QuickCryptoUtils.hpp"
 #include <openssl/bn.h>
 #include <openssl/ec.h>
 #include <openssl/evp.h>

package/cpp/keys/KeyObjectData.cpp

@@ -1,5 +1,5 @@
 #include "KeyObjectData.hpp"
-#include "Utils.hpp"
+#include "QuickCryptoUtils.hpp"
 #include <cstdio>
 #include <optional>
 

package/cpp/keys/KeyObjectData.hpp

@@ -5,7 +5,7 @@
 #include "KFormatType.hpp"
 #include "KeyEncoding.hpp"
 #include "KeyType.hpp"
-#include "Utils.hpp"
+#include "QuickCryptoUtils.hpp"
 #include <ncrypto.h>
 
 namespace margelo::nitro::crypto {

package/cpp/mldsa/HybridMlDsaKeyPair.cpp

@@ -5,7 +5,7 @@
 #include <openssl/err.h>
 #include <openssl/pem.h>
 
-#include "Utils.hpp"
+#include "QuickCryptoUtils.hpp"
 
 #if OPENSSL_VERSION_NUMBER >= 0x30500000L
 #define RNQC_HAS_ML_DSA 1

package/cpp/pbkdf2/HybridPbkdf2.cpp

@@ -1,5 +1,5 @@
 #include "HybridPbkdf2.hpp"
-#include "Utils.hpp"
+#include "QuickCryptoUtils.hpp"
 
 namespace margelo::nitro::crypto {
 

package/cpp/random/HybridRandom.cpp

@@ -2,7 +2,7 @@
 #include <openssl/rand.h>
 
 #include "HybridRandom.hpp"
-#include "Utils.hpp"
+#include "QuickCryptoUtils.hpp"
 
 namespace margelo::nitro::crypto {
 

package/cpp/rsa/HybridRsaKeyPair.cpp

@@ -11,7 +11,7 @@
 #include <string>
 
 #include "HybridRsaKeyPair.hpp"
-#include "Utils.hpp"
+#include "QuickCryptoUtils.hpp"
 
 namespace margelo::nitro::crypto {
 

package/cpp/scrypt/HybridScrypt.cpp

@@ -6,7 +6,7 @@
 #include <vector>
 
 #include "HybridScrypt.hpp"
-#include "Utils.hpp"
+#include "QuickCryptoUtils.hpp"
 
 namespace margelo::nitro::crypto {
 

package/cpp/sign/HybridSignHandle.cpp

@@ -1,8 +1,8 @@
 #include "HybridSignHandle.hpp"
 
 #include "../keys/HybridKeyObjectHandle.hpp"
+#include "QuickCryptoUtils.hpp"
 #include "SignUtils.hpp"
-#include "Utils.hpp"
 
 #include <cstring>
 #include <openssl/err.h>

package/cpp/sign/HybridVerifyHandle.cpp

@@ -1,8 +1,8 @@
 #include "HybridVerifyHandle.hpp"
 
 #include "../keys/HybridKeyObjectHandle.hpp"
+#include "QuickCryptoUtils.hpp"
 #include "SignUtils.hpp"
-#include "Utils.hpp"
 
 #include <cstring>
 #include <openssl/err.h>

package/cpp/utils/{Utils.hpp → 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":[]}