react-native-quick-crypto 1.0.10 → 1.0.12

package/cpp/prime/HybridPrime.cpp

@@ -0,0 +1,81 @@
+#include "HybridPrime.hpp"
+#include "QuickCryptoUtils.hpp"
+#include <ncrypto.h>
+
+namespace margelo::nitro::crypto {
+
+using namespace ncrypto;
+
+static BignumPointer toBignum(const std::optional<std::shared_ptr<ArrayBuffer>>& buf) {
+  if (!buf.has_value() || buf.value()->size() == 0) {
+    return BignumPointer();
+  }
+  return BignumPointer(buf.value()->data(), buf.value()->size());
+}
+
+static std::shared_ptr<ArrayBuffer> generatePrimeImpl(double size, bool safe, const std::optional<std::shared_ptr<ArrayBuffer>>& add,
+                                                      const std::optional<std::shared_ptr<ArrayBuffer>>& rem) {
+  int bits = static_cast<int>(size);
+
+  auto addBn = toBignum(add);
+  auto remBn = toBignum(rem);
+
+  BignumPointer::PrimeConfig config{bits, safe, addBn, remBn};
+  auto prime = BignumPointer::NewPrime(config);
+  if (!prime) {
+    throw std::runtime_error("Failed to generate prime");
+  }
+
+  auto encoded = prime.encode();
+  if (!encoded) {
+    throw std::runtime_error("Failed to encode prime");
+  }
+
+  return ToNativeArrayBuffer(encoded.get<uint8_t>(), encoded.size());
+}
+
+std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> HybridPrime::generatePrime(double size, bool safe,
+                                                                                  const std::optional<std::shared_ptr<ArrayBuffer>>& add,
+                                                                                  const std::optional<std::shared_ptr<ArrayBuffer>>& rem) {
+  auto addCopy = add.has_value() ? std::make_optional(ToNativeArrayBuffer(add.value())) : std::nullopt;
+  auto remCopy = rem.has_value() ? std::make_optional(ToNativeArrayBuffer(rem.value())) : std::nullopt;
+
+  return Promise<std::shared_ptr<ArrayBuffer>>::async([size, safe, addCopy = std::move(addCopy), remCopy = std::move(remCopy)]() {
+    return generatePrimeImpl(size, safe, addCopy, remCopy);
+  });
+}
+
+std::shared_ptr<ArrayBuffer> HybridPrime::generatePrimeSync(double size, bool safe, const std::optional<std::shared_ptr<ArrayBuffer>>& add,
+                                                            const std::optional<std::shared_ptr<ArrayBuffer>>& rem) {
+  return generatePrimeImpl(size, safe, add, rem);
+}
+
+bool HybridPrime::checkPrimeSync(const std::shared_ptr<ArrayBuffer>& candidate, double checks) {
+  BignumPointer bn(candidate->data(), candidate->size());
+  if (!bn) {
+    throw std::runtime_error("Invalid candidate");
+  }
+
+  int result = bn.isPrime(static_cast<int>(checks));
+  if (result == -1) {
+    throw std::runtime_error("Prime check failed");
+  }
+  return result == 1;
+}
+
+std::shared_ptr<Promise<bool>> HybridPrime::checkPrime(const std::shared_ptr<ArrayBuffer>& candidate, double checks) {
+  auto candidateCopy = ToNativeArrayBuffer(candidate);
+  return Promise<bool>::async([candidateCopy, checks]() {
+    BignumPointer bn(candidateCopy->data(), candidateCopy->size());
+    if (!bn) {
+      throw std::runtime_error("Invalid candidate");
+    }
+    int result = bn.isPrime(static_cast<int>(checks));
+    if (result == -1) {
+      throw std::runtime_error("Prime check failed");
+    }
+    return result == 1;
+  });
+}
+
+} // namespace margelo::nitro::crypto

package/cpp/prime/HybridPrime.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "HybridPrimeSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+class HybridPrime : public HybridPrimeSpec {
+ public:
+  HybridPrime() : HybridObject(TAG) {}
+
+  std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> generatePrime(double size, bool safe,
+                                                                       const std::optional<std::shared_ptr<ArrayBuffer>>& add,
+                                                                       const std::optional<std::shared_ptr<ArrayBuffer>>& rem) override;
+  std::shared_ptr<ArrayBuffer> generatePrimeSync(double size, bool safe, const std::optional<std::shared_ptr<ArrayBuffer>>& add,
+                                                 const std::optional<std::shared_ptr<ArrayBuffer>>& rem) override;
+  std::shared_ptr<Promise<bool>> checkPrime(const std::shared_ptr<ArrayBuffer>& candidate, double checks) override;
+  bool checkPrimeSync(const std::shared_ptr<ArrayBuffer>& candidate, double checks) override;
+};
+
+} // namespace margelo::nitro::crypto

package/cpp/sign/SignUtils.hpp

@@ -2,12 +2,16 @@
 
 #include <cstring>
 #include <memory>
+#include <openssl/bn.h>
+#include <openssl/core_names.h>
 #include <openssl/dsa.h>
 #include <openssl/ec.h>
 #include <openssl/ecdsa.h>
 #include <openssl/evp.h>
 #include <string>
 
+#include "../utils/QuickCryptoUtils.hpp"
+
 namespace margelo::nitro::crypto {
 
 enum DSASigEnc {
@@ -15,29 +19,6 @@ enum DSASigEnc {
   kSigEncP1363 = 1,
 };
 
-inline const EVP_MD* getDigestByName(const std::string& algorithm) {
-  if (algorithm == "SHA1" || algorithm == "sha1" || algorithm == "SHA-1" || algorithm == "sha-1") {
-    return EVP_sha1();
-  } else if (algorithm == "SHA224" || algorithm == "sha224" || algorithm == "SHA-224" || algorithm == "sha-224") {
-    return EVP_sha224();
-  } else if (algorithm == "SHA256" || algorithm == "sha256" || algorithm == "SHA-256" || algorithm == "sha-256") {
-    return EVP_sha256();
-  } else if (algorithm == "SHA384" || algorithm == "sha384" || algorithm == "SHA-384" || algorithm == "sha-384") {
-    return EVP_sha384();
-  } else if (algorithm == "SHA512" || algorithm == "sha512" || algorithm == "SHA-512" || algorithm == "sha-512") {
-    return EVP_sha512();
-  } else if (algorithm == "SHA3-224" || algorithm == "sha3-224") {
-    return EVP_sha3_224();
-  } else if (algorithm == "SHA3-256" || algorithm == "sha3-256") {
-    return EVP_sha3_256();
-  } else if (algorithm == "SHA3-384" || algorithm == "sha3-384") {
-    return EVP_sha3_384();
-  } else if (algorithm == "SHA3-512" || algorithm == "sha3-512") {
-    return EVP_sha3_512();
-  }
-  throw std::runtime_error("Unsupported hash algorithm: " + algorithm);
-}
-
 inline unsigned int getBytesOfRS(EVP_PKEY* pkey) {
   int bits;
   int base_id = EVP_PKEY_base_id(pkey);
@@ -46,9 +27,11 @@ inline unsigned int getBytesOfRS(EVP_PKEY* pkey) {
     const DSA* dsa_key = EVP_PKEY_get0_DSA(pkey);
     bits = BN_num_bits(DSA_get0_q(dsa_key));
   } else if (base_id == EVP_PKEY_EC) {
-    const EC_KEY* ec_key = EVP_PKEY_get0_EC_KEY(pkey);
-    const EC_GROUP* ec_group = EC_KEY_get0_group(ec_key);
-    bits = EC_GROUP_order_bits(ec_group);
+    BIGNUM* order = nullptr;
+    if (EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_EC_ORDER, &order) != 1 || !order)
+      return 0;
+    bits = BN_num_bits(order);
+    BN_free(order);
   } else {
     return 0;
   }

package/cpp/utils/QuickCryptoUtils.cpp

@@ -0,0 +1,44 @@
+#include "QuickCryptoUtils.hpp"
+#include <openssl/bn.h>
+#include <openssl/core_names.h>
+#include <openssl/evp.h>
+#include <openssl/param_build.h>
+#include <stdexcept>
+
+namespace margelo::nitro::crypto {
+
+EVP_PKEY* createEcEvpPkey(const char* group_name, const uint8_t* pub_oct, size_t pub_len, const BIGNUM* priv_bn) {
+  OSSL_PARAM_BLD* bld = OSSL_PARAM_BLD_new();
+  if (!bld)
+    throw std::runtime_error("Failed to create OSSL_PARAM_BLD");
+
+  OSSL_PARAM_BLD_push_utf8_string(bld, OSSL_PKEY_PARAM_GROUP_NAME, group_name, 0);
+  OSSL_PARAM_BLD_push_octet_string(bld, OSSL_PKEY_PARAM_PUB_KEY, pub_oct, pub_len);
+  if (priv_bn)
+    OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PRIV_KEY, priv_bn);
+
+  OSSL_PARAM* params = OSSL_PARAM_BLD_to_param(bld);
+  OSSL_PARAM_BLD_free(bld);
+  if (!params)
+    throw std::runtime_error("Failed to build EC parameters");
+
+  EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new_from_name(nullptr, "EC", nullptr);
+  if (!ctx) {
+    OSSL_PARAM_free(params);
+    throw std::runtime_error("Failed to create EVP_PKEY_CTX for EC");
+  }
+
+  int selection = priv_bn ? EVP_PKEY_KEYPAIR : EVP_PKEY_PUBLIC_KEY;
+  EVP_PKEY* pkey = nullptr;
+  if (EVP_PKEY_fromdata_init(ctx) <= 0 || EVP_PKEY_fromdata(ctx, &pkey, selection, params) <= 0) {
+    EVP_PKEY_CTX_free(ctx);
+    OSSL_PARAM_free(params);
+    throw std::runtime_error("Failed to create EVP_PKEY from EC parameters");
+  }
+
+  EVP_PKEY_CTX_free(ctx);
+  OSSL_PARAM_free(params);
+  return pkey;
+}
+
+} // namespace margelo::nitro::crypto

package/cpp/utils/QuickCryptoUtils.hpp

@@ -3,7 +3,9 @@
 #include <algorithm>
 #include <cctype>
 #include <limits>
+#include <openssl/bn.h>
 #include <openssl/err.h>
+#include <openssl/evp.h>
 #include <string>
 #include <vector>
 
@@ -72,4 +74,41 @@ inline std::string toLower(std::string s) {
   return s;
 }
 
+inline const EVP_MD* getDigestByName(const std::string& algorithm) {
+  std::string algo = toLower(algorithm);
+
+  // Strip legacy RSA- prefix (e.g. rsa-sha256 -> sha256) for Node.js compat
+  if (algo.size() > 4 && algo.compare(0, 4, "rsa-") == 0) {
+    algo = algo.substr(4);
+  }
+
+  if (algo == "sha1" || algo == "sha-1") {
+    return EVP_sha1();
+  } else if (algo == "sha224" || algo == "sha-224") {
+    return EVP_sha224();
+  } else if (algo == "sha256" || algo == "sha-256") {
+    return EVP_sha256();
+  } else if (algo == "sha384" || algo == "sha-384") {
+    return EVP_sha384();
+  } else if (algo == "sha512" || algo == "sha-512") {
+    return EVP_sha512();
+  } else if (algo == "sha3-224") {
+    return EVP_sha3_224();
+  } else if (algo == "sha3-256") {
+    return EVP_sha3_256();
+  } else if (algo == "sha3-384") {
+    return EVP_sha3_384();
+  } else if (algo == "sha3-512") {
+    return EVP_sha3_512();
+  } else if (algo == "ripemd160" || algo == "ripemd-160") {
+    return EVP_ripemd160();
+  }
+  throw std::runtime_error("Unsupported hash algorithm: " + algorithm);
+}
+
+// Build an EVP_PKEY from EC curve name + public key octets + optional private key BIGNUM.
+// Uses OSSL_PARAM_BLD + EVP_PKEY_fromdata (OpenSSL 3.x, no deprecated EC_KEY APIs).
+// Caller owns the returned EVP_PKEY*.
+EVP_PKEY* createEcEvpPkey(const char* group_name, const uint8_t* pub_oct, size_t pub_len, const BIGNUM* priv_bn = nullptr);
+
 } // namespace margelo::nitro::crypto

package/cpp/x509/HybridX509Certificate.cpp

@@ -0,0 +1,174 @@
+#include "HybridX509Certificate.hpp"
+#include "../keys/HybridKeyObjectHandle.hpp"
+#include "../keys/KeyObjectData.hpp"
+#include "QuickCryptoUtils.hpp"
+#include <ncrypto.h>
+
+namespace margelo::nitro::crypto {
+
+std::string HybridX509Certificate::bioToString(ncrypto::BIOPointer bio) const {
+  if (!bio)
+    return "";
+  BUF_MEM* mem = bio;
+  if (!mem || mem->length == 0)
+    return "";
+  return std::string(mem->data, mem->length);
+}
+
+void HybridX509Certificate::init(const std::shared_ptr<ArrayBuffer>& buffer) {
+  ncrypto::Buffer<const unsigned char> buf{.data = reinterpret_cast<const unsigned char*>(buffer->data()), .len = buffer->size()};
+  auto result = ncrypto::X509Pointer::Parse(buf);
+  if (!result) {
+    throw std::runtime_error("Failed to parse X509 certificate");
+  }
+  cert_ = std::move(result.value);
+}
+
+std::string HybridX509Certificate::subject() {
+  return bioToString(cert_.view().getSubject());
+}
+
+std::string HybridX509Certificate::subjectAltName() {
+  return bioToString(cert_.view().getSubjectAltName());
+}
+
+std::string HybridX509Certificate::issuer() {
+  return bioToString(cert_.view().getIssuer());
+}
+
+std::string HybridX509Certificate::infoAccess() {
+  return bioToString(cert_.view().getInfoAccess());
+}
+
+std::string HybridX509Certificate::validFrom() {
+  return bioToString(cert_.view().getValidFrom());
+}
+
+std::string HybridX509Certificate::validTo() {
+  return bioToString(cert_.view().getValidTo());
+}
+
+double HybridX509Certificate::validFromDate() {
+  return static_cast<double>(cert_.view().getValidFromTime()) * 1000.0;
+}
+
+double HybridX509Certificate::validToDate() {
+  return static_cast<double>(cert_.view().getValidToTime()) * 1000.0;
+}
+
+std::string HybridX509Certificate::signatureAlgorithm() {
+  auto algo = cert_.view().getSignatureAlgorithm();
+  if (!algo.has_value())
+    return "";
+  return std::string(algo.value());
+}
+
+std::string HybridX509Certificate::signatureAlgorithmOid() {
+  return cert_.view().getSignatureAlgorithmOID().value_or("");
+}
+
+std::string HybridX509Certificate::serialNumber() {
+  auto serial = cert_.view().getSerialNumber();
+  if (!serial)
+    return "";
+  return std::string(static_cast<const char*>(serial.get()), serial.size());
+}
+
+std::string HybridX509Certificate::fingerprint() {
+  return cert_.view().getFingerprint(ncrypto::Digest::SHA1).value_or("");
+}
+
+std::string HybridX509Certificate::fingerprint256() {
+  return cert_.view().getFingerprint(ncrypto::Digest::SHA256).value_or("");
+}
+
+std::string HybridX509Certificate::fingerprint512() {
+  return cert_.view().getFingerprint(ncrypto::Digest::SHA512).value_or("");
+}
+
+std::shared_ptr<ArrayBuffer> HybridX509Certificate::raw() {
+  auto bio = cert_.view().toDER();
+  if (!bio) {
+    throw std::runtime_error("Failed to export certificate as DER");
+  }
+  BUF_MEM* mem = bio;
+  return ToNativeArrayBuffer(reinterpret_cast<const uint8_t*>(mem->data), mem->length);
+}
+
+std::string HybridX509Certificate::pem() {
+  return bioToString(cert_.view().toPEM());
+}
+
+std::shared_ptr<HybridKeyObjectHandleSpec> HybridX509Certificate::publicKey() {
+  auto result = cert_.view().getPublicKey();
+  if (!result) {
+    throw std::runtime_error("Failed to extract public key from certificate");
+  }
+  auto handle = std::make_shared<HybridKeyObjectHandle>();
+  handle->setKeyObjectData(KeyObjectData::CreateAsymmetric(KeyType::PUBLIC, std::move(result.value)));
+  return handle;
+}
+
+std::vector<std::string> HybridX509Certificate::keyUsage() {
+  std::vector<std::string> usages;
+  cert_.view().enumUsages([&](const char* usage) { usages.emplace_back(usage); });
+  return usages;
+}
+
+bool HybridX509Certificate::ca() {
+  return cert_.view().isCA();
+}
+
+bool HybridX509Certificate::checkIssued(const std::shared_ptr<HybridX509CertificateHandleSpec>& other) {
+  auto otherCert = std::dynamic_pointer_cast<HybridX509Certificate>(other);
+  if (!otherCert) {
+    throw std::runtime_error("Invalid X509Certificate");
+  }
+  return cert_.view().isIssuedBy(otherCert->cert_.view());
+}
+
+bool HybridX509Certificate::checkPrivateKey(const std::shared_ptr<HybridKeyObjectHandleSpec>& key) {
+  auto handle = std::dynamic_pointer_cast<HybridKeyObjectHandle>(key);
+  if (!handle) {
+    throw std::runtime_error("Invalid key object");
+  }
+  return cert_.view().checkPrivateKey(handle->getKeyObjectData().GetAsymmetricKey());
+}
+
+bool HybridX509Certificate::verify(const std::shared_ptr<HybridKeyObjectHandleSpec>& key) {
+  auto handle = std::dynamic_pointer_cast<HybridKeyObjectHandle>(key);
+  if (!handle) {
+    throw std::runtime_error("Invalid key object");
+  }
+  return cert_.view().checkPublicKey(handle->getKeyObjectData().GetAsymmetricKey());
+}
+
+std::optional<std::string> HybridX509Certificate::checkHost(const std::string& name, double flags) {
+  ncrypto::DataPointer peername;
+  auto match = cert_.view().checkHost(name, static_cast<int>(flags), &peername);
+  if (match == ncrypto::X509View::CheckMatch::MATCH) {
+    if (peername) {
+      return std::string(static_cast<const char*>(peername.get()), peername.size());
+    }
+    return name;
+  }
+  return std::nullopt;
+}
+
+std::optional<std::string> HybridX509Certificate::checkEmail(const std::string& email, double flags) {
+  auto match = cert_.view().checkEmail(email, static_cast<int>(flags));
+  if (match == ncrypto::X509View::CheckMatch::MATCH) {
+    return email;
+  }
+  return std::nullopt;
+}
+
+std::optional<std::string> HybridX509Certificate::checkIP(const std::string& ip) {
+  auto match = cert_.view().checkIp(ip, 0);
+  if (match == ncrypto::X509View::CheckMatch::MATCH) {
+    return ip;
+  }
+  return std::nullopt;
+}
+
+} // namespace margelo::nitro::crypto

package/cpp/x509/HybridX509Certificate.hpp

@@ -0,0 +1,51 @@
+#pragma once
+
+#include "HybridX509CertificateHandleSpec.hpp"
+#include <ncrypto.h>
+#include <string>
+
+namespace margelo::nitro::crypto {
+
+class HybridX509Certificate : public HybridX509CertificateHandleSpec {
+ public:
+  HybridX509Certificate() : HybridObject(TAG) {}
+
+  void init(const std::shared_ptr<ArrayBuffer>& buffer) override;
+
+  std::string subject() override;
+  std::string subjectAltName() override;
+  std::string issuer() override;
+  std::string infoAccess() override;
+  std::string validFrom() override;
+  std::string validTo() override;
+  double validFromDate() override;
+  double validToDate() override;
+  std::string signatureAlgorithm() override;
+  std::string signatureAlgorithmOid() override;
+  std::string serialNumber() override;
+
+  std::string fingerprint() override;
+  std::string fingerprint256() override;
+  std::string fingerprint512() override;
+
+  std::shared_ptr<ArrayBuffer> raw() override;
+  std::string pem() override;
+
+  std::shared_ptr<HybridKeyObjectHandleSpec> publicKey() override;
+  std::vector<std::string> keyUsage() override;
+
+  bool ca() override;
+  bool checkIssued(const std::shared_ptr<HybridX509CertificateHandleSpec>& other) override;
+  bool checkPrivateKey(const std::shared_ptr<HybridKeyObjectHandleSpec>& key) override;
+  bool verify(const std::shared_ptr<HybridKeyObjectHandleSpec>& key) override;
+
+  std::optional<std::string> checkHost(const std::string& name, double flags) override;
+  std::optional<std::string> checkEmail(const std::string& email, double flags) override;
+  std::optional<std::string> checkIP(const std::string& ip) override;
+
+ private:
+  ncrypto::X509Pointer cert_;
+  std::string bioToString(ncrypto::BIOPointer bio) const;
+};
+
+} // namespace margelo::nitro::crypto

package/lib/commonjs/argon2.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.argon2 = argon2;
+exports.argon2Sync = argon2Sync;
+var _reactNativeBuffer = require("@craftzdog/react-native-buffer");
+var _reactNativeNitroModules = require("react-native-nitro-modules");
+var _utils = require("./utils");
+let native;
+function getNative() {
+  if (native == null) {
+    native = _reactNativeNitroModules.NitroModules.createHybridObject('Argon2');
+  }
+  return native;
+}
+const ARGON2_VERSION = 0x13; // v1.3
+
+function validateAlgorithm(algorithm) {
+  if (algorithm !== 'argon2d' && algorithm !== 'argon2i' && algorithm !== 'argon2id') {
+    throw new TypeError(`Unknown argon2 algorithm: ${algorithm}`);
+  }
+}
+function toAB(value) {
+  return (0, _utils.binaryLikeToArrayBuffer)(value);
+}
+function argon2Sync(algorithm, params) {
+  validateAlgorithm(algorithm);
+  const version = params.version ?? ARGON2_VERSION;
+  const result = getNative().hashSync(algorithm, toAB(params.message), toAB(params.nonce), params.parallelism, params.tagLength, params.memory, params.passes, version, params.secret ? toAB(params.secret) : undefined, params.associatedData ? toAB(params.associatedData) : undefined);
+  return _reactNativeBuffer.Buffer.from(result);
+}
+function argon2(algorithm, params, callback) {
+  validateAlgorithm(algorithm);
+  const version = params.version ?? ARGON2_VERSION;
+  getNative().hash(algorithm, toAB(params.message), toAB(params.nonce), params.parallelism, params.tagLength, params.memory, params.passes, version, params.secret ? toAB(params.secret) : undefined, params.associatedData ? toAB(params.associatedData) : undefined).then(ab => callback(null, _reactNativeBuffer.Buffer.from(ab))).catch(err => callback(err, _reactNativeBuffer.Buffer.alloc(0)));
+}
+//# sourceMappingURL=argon2.js.map

package/lib/commonjs/argon2.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNativeBuffer","require","_reactNativeNitroModules","_utils","native","getNative","NitroModules","createHybridObject","ARGON2_VERSION","validateAlgorithm","algorithm","TypeError","toAB","value","binaryLikeToArrayBuffer","argon2Sync","params","version","result","hashSync","message","nonce","parallelism","tagLength","memory","passes","secret","undefined","associatedData","Buffer","from","argon2","callback","hash","then","ab","catch","err","alloc"],"sourceRoot":"../../src","sources":["argon2.ts"],"mappings":";;;;;;;AAAA,IAAAA,kBAAA,GAAAC,OAAA;AACA,IAAAC,wBAAA,GAAAD,OAAA;AAEA,IAAAE,MAAA,GAAAF,OAAA;AAGA,IAAIG,MAAoB;AACxB,SAASC,SAASA,CAAA,EAAiB;EACjC,IAAID,MAAM,IAAI,IAAI,EAAE;IAClBA,MAAM,GAAGE,qCAAY,CAACC,kBAAkB,CAAe,QAAQ,CAAC;EAClE;EACA,OAAOH,MAAM;AACf;AAcA,MAAMI,cAAc,GAAG,IAAI,CAAC,CAAC;;AAE7B,SAASC,iBAAiBA,CAACC,SAAiB,EAAQ;EAClD,IACEA,SAAS,KAAK,SAAS,IACvBA,SAAS,KAAK,SAAS,IACvBA,SAAS,KAAK,UAAU,EACxB;IACA,MAAM,IAAIC,SAAS,CAAC,6BAA6BD,SAAS,EAAE,CAAC;EAC/D;AACF;AAEA,SAASE,IAAIA,CAACC,KAAiB,EAAe;EAC5C,OAAO,IAAAC,8BAAuB,EAACD,KAAK,CAAC;AACvC;AAEO,SAASE,UAAUA,CAACL,SAAiB,EAAEM,MAAoB,EAAU;EAC1EP,iBAAiB,CAACC,SAAS,CAAC;EAC5B,MAAMO,OAAO,GAAGD,MAAM,CAACC,OAAO,IAAIT,cAAc;EAChD,MAAMU,MAAM,GAAGb,SAAS,CAAC,CAAC,CAACc,QAAQ,CACjCT,SAAS,EACTE,IAAI,CAACI,MAAM,CAACI,OAAO,CAAC,EACpBR,IAAI,CAACI,MAAM,CAACK,KAAK,CAAC,EAClBL,MAAM,CAACM,WAAW,EAClBN,MAAM,CAACO,SAAS,EAChBP,MAAM,CAACQ,MAAM,EACbR,MAAM,CAACS,MAAM,EACbR,OAAO,EACPD,MAAM,CAACU,MAAM,GAAGd,IAAI,CAACI,MAAM,CAACU,MAAM,CAAC,GAAGC,SAAS,EAC/CX,MAAM,CAACY,cAAc,GAAGhB,IAAI,CAACI,MAAM,CAACY,cAAc,CAAC,GAAGD,SACxD,CAAC;EACD,OAAOE,yBAAM,CAACC,IAAI,CAACZ,MAAM,CAAC;AAC5B;AAEO,SAASa,MAAMA,CACpBrB,SAAiB,EACjBM,MAAoB,EACpBgB,QAAqD,EAC/C;EACNvB,iBAAiB,CAACC,SAAS,CAAC;EAC5B,MAAMO,OAAO,GAAGD,MAAM,CAACC,OAAO,IAAIT,cAAc;EAChDH,SAAS,CAAC,CAAC,CACR4B,IAAI,CACHvB,SAAS,EACTE,IAAI,CAACI,MAAM,CAACI,OAAO,CAAC,EACpBR,IAAI,CAACI,MAAM,CAACK,KAAK,CAAC,EAClBL,MAAM,CAACM,WAAW,EAClBN,MAAM,CAACO,SAAS,EAChBP,MAAM,CAACQ,MAAM,EACbR,MAAM,CAACS,MAAM,EACbR,OAAO,EACPD,MAAM,CAACU,MAAM,GAAGd,IAAI,CAACI,MAAM,CAACU,MAAM,CAAC,GAAGC,SAAS,EAC/CX,MAAM,CAACY,cAAc,GAAGhB,IAAI,CAACI,MAAM,CAACY,cAAc,CAAC,GAAGD,SACxD,CAAC,CACAO,IAAI,CAACC,EAAE,IAAIH,QAAQ,CAAC,IAAI,EAAEH,yBAAM,CAACC,IAAI,CAACK,EAAE,CAAC,CAAC,CAAC,CAC3CC,KAAK,CAAEC,GAAU,IAAKL,QAAQ,CAACK,GAAG,EAAER,yBAAM,CAACS,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AAC1D","ignoreList":[]}

package/lib/commonjs/certificate.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Certificate = void 0;
+var _reactNativeNitroModules = require("react-native-nitro-modules");
+var _reactNativeBuffer = require("@craftzdog/react-native-buffer");
+var _utils = require("./utils");
+let native;
+function getNative() {
+  if (native == null) {
+    native = _reactNativeNitroModules.NitroModules.createHybridObject('Certificate');
+  }
+  return native;
+}
+function toArrayBuffer(spkac, encoding) {
+  if (typeof spkac === 'string') {
+    return (0, _utils.binaryLikeToArrayBuffer)(spkac, encoding || 'utf8');
+  }
+  return (0, _utils.binaryLikeToArrayBuffer)(spkac);
+}
+class Certificate {
+  static exportChallenge(spkac, encoding) {
+    return _reactNativeBuffer.Buffer.from(getNative().exportChallenge(toArrayBuffer(spkac, encoding)));
+  }
+  static exportPublicKey(spkac, encoding) {
+    return _reactNativeBuffer.Buffer.from(getNative().exportPublicKey(toArrayBuffer(spkac, encoding)));
+  }
+  static verifySpkac(spkac, encoding) {
+    return getNative().verifySpkac(toArrayBuffer(spkac, encoding));
+  }
+}
+exports.Certificate = Certificate;
+//# sourceMappingURL=certificate.js.map

package/lib/commonjs/certificate.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNativeNitroModules","require","_reactNativeBuffer","_utils","native","getNative","NitroModules","createHybridObject","toArrayBuffer","spkac","encoding","binaryLikeToArrayBuffer","Certificate","exportChallenge","Buffer","from","exportPublicKey","verifySpkac","exports"],"sourceRoot":"../../src","sources":["certificate.ts"],"mappings":";;;;;;AAAA,IAAAA,wBAAA,GAAAC,OAAA;AACA,IAAAC,kBAAA,GAAAD,OAAA;AAGA,IAAAE,MAAA,GAAAF,OAAA;AAEA,IAAIG,MAAyB;AAC7B,SAASC,SAASA,CAAA,EAAsB;EACtC,IAAID,MAAM,IAAI,IAAI,EAAE;IAClBA,MAAM,GAAGE,qCAAY,CAACC,kBAAkB,CAAoB,aAAa,CAAC;EAC5E;EACA,OAAOH,MAAM;AACf;AAEA,SAASI,aAAaA,CACpBC,KAAiB,EACjBC,QAAyB,EACZ;EACb,IAAI,OAAOD,KAAK,KAAK,QAAQ,EAAE;IAC7B,OAAO,IAAAE,8BAAuB,EAACF,KAAK,EAAEC,QAAQ,IAAI,MAAM,CAAC;EAC3D;EACA,OAAO,IAAAC,8BAAuB,EAACF,KAAK,CAAC;AACvC;AAEO,MAAMG,WAAW,CAAC;EACvB,OAAOC,eAAeA,CAACJ,KAAiB,EAAEC,QAAyB,EAAU;IAC3E,OAAOI,yBAAM,CAACC,IAAI,CAChBV,SAAS,CAAC,CAAC,CAACQ,eAAe,CAACL,aAAa,CAACC,KAAK,EAAEC,QAAQ,CAAC,CAC5D,CAAC;EACH;EAEA,OAAOM,eAAeA,CAACP,KAAiB,EAAEC,QAAyB,EAAU;IAC3E,OAAOI,yBAAM,CAACC,IAAI,CAChBV,SAAS,CAAC,CAAC,CAACW,eAAe,CAACR,aAAa,CAACC,KAAK,EAAEC,QAAQ,CAAC,CAC5D,CAAC;EACH;EAEA,OAAOO,WAAWA,CAACR,KAAiB,EAAEC,QAAyB,EAAW;IACxE,OAAOL,SAAS,CAAC,CAAC,CAACY,WAAW,CAACT,aAAa,CAACC,KAAK,EAAEC,QAAQ,CAAC,CAAC;EAChE;AACF;AAACQ,OAAA,CAAAN,WAAA,GAAAA,WAAA","ignoreList":[]}

package/lib/commonjs/cipher.js

@@ -5,10 +5,12 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createCipheriv = createCipheriv;
 exports.createDecipheriv = createDecipheriv;
+exports.getCipherInfo = getCipherInfo;
 exports.getCiphers = getCiphers;
 exports.xsalsa20 = xsalsa20;
 var _reactNativeNitroModules = require("react-native-nitro-modules");
 var _readableStream = _interopRequireDefault(require("readable-stream"));
+var _string_decoder = require("string_decoder");
 var _reactNativeBuffer = require("@craftzdog/react-native-buffer");
 var _utils = require("./utils");
 var _cipher = require("./utils/cipher");
@@ -20,11 +22,20 @@ class CipherUtils {
   static getSupportedCiphers() {
     return this.native.getSupportedCiphers();
   }
+  static getCipherInfo(name, keyLength, ivLength) {
+    return this.native.getCipherInfo(name, keyLength, ivLength);
+  }
 }
 function getCiphers() {
   return CipherUtils.getSupportedCiphers();
 }
+function getCipherInfo(name, options) {
+  if (typeof name !== 'string' || name.length === 0) return undefined;
+  return CipherUtils.getCipherInfo(name, options?.keyLength, options?.ivLength);
+}
 class CipherCommon extends _readableStream.default.Transform {
+  _decoder = null;
+  _decoderEncoding = undefined;
   constructor({
     isCipher,
     cipherType,
@@ -59,6 +70,16 @@ class CipherCommon extends _readableStream.default.Transform {
       authTagLen
     });
   }
+  getDecoder(encoding) {
+    const normalized = (0, _cipher.normalizeEncoding)(encoding);
+    if (!this._decoder) {
+      this._decoder = new _string_decoder.StringDecoder(encoding);
+      this._decoderEncoding = normalized;
+    } else if (this._decoderEncoding !== normalized) {
+      throw new Error('Cannot change encoding');
+    }
+    return this._decoder;
+  }
   update(data, inputEncoding, outputEncoding) {
     const defaultEncoding = (0, _cipher.getDefaultEncoding)();
     inputEncoding = inputEncoding ?? defaultEncoding;
@@ -70,14 +91,14 @@ class CipherCommon extends _readableStream.default.Transform {
     }
     const ret = this.native.update((0, _utils.binaryLikeToArrayBuffer)(data, inputEncoding));
     if (outputEncoding && outputEncoding !== 'buffer') {
-      return (0, _utils.ab2str)(ret, outputEncoding);
+      return this.getDecoder(outputEncoding).write(_reactNativeBuffer.Buffer.from(ret));
     }
     return _reactNativeBuffer.Buffer.from(ret);
   }
   final(outputEncoding) {
     const ret = this.native.final();
     if (outputEncoding && outputEncoding !== 'buffer') {
-      return (0, _utils.ab2str)(ret, outputEncoding);
+      return this.getDecoder(outputEncoding).end(_reactNativeBuffer.Buffer.from(ret));
     }
     return _reactNativeBuffer.Buffer.from(ret);
   }