react-native-quick-crypto 0.3.1 → 0.4.1

package/cpp/Sig/MGLSignHostObjects.h

@@ -0,0 +1,88 @@
+#ifndef MGLSignHostObjects_h
+#define MGLSignHostObjects_h
+
+#include <jsi/jsi.h>
+#include <openssl/evp.h>
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
+
+#include "MGLKeys.h"
+#ifdef ANDROID
+#include "JSIUtils/MGLSmartHostObject.h"
+#include "Utils/MGLUtils.h"
+#else
+#include "MGLSmartHostObject.h"
+#include "MGLUtils.h"
+#endif
+
+namespace margelo {
+
+namespace jsi = facebook::jsi;
+
+static const unsigned int kNoDsaSignature = static_cast<unsigned int>(-1);
+
+enum mode { kModeSign, kModeVerify };
+
+enum DSASigEnc {
+  kSigEncDER,
+  kSigEncP1363,
+};
+
+class SignBase : public MGLSmartHostObject {
+ public:
+  SignBase(std::shared_ptr<react::CallInvoker> jsCallInvoker,
+           std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue);
+
+  typedef enum {
+    kSignOk,
+    kSignUnknownDigest,
+    kSignInit,
+    kSignNotInitialised,
+    kSignUpdate,
+    kSignPrivateKey,
+    kSignPublicKey,
+    kSignMalformedSignature
+  } Error;
+
+  struct SignResult {
+    Error error;
+    std::optional<jsi::Value> signature;
+
+    explicit SignResult(Error err, std::optional<jsi::Value> sig = std::nullopt)
+        : error(err), signature(std::move(sig)) {}
+  };
+
+  void InstallMethods(mode);
+
+  SignResult SignFinal(jsi::Runtime& runtime, const ManagedEVPPKey& pkey,
+                       int padding, std::optional<int>& salt_len,
+                       DSASigEnc dsa_sig_enc);
+
+  Error VerifyFinal(const ManagedEVPPKey& pkey, const ByteSource& sig,
+                    int padding, std::optional<int>& saltlen,
+                    bool* verify_result);
+
+ protected:
+  EVPMDPointer mdctx_;
+};
+
+class MGLSignHostObject : public SignBase {
+ public:
+  explicit MGLSignHostObject(
+      std::shared_ptr<react::CallInvoker> jsCallInvoker,
+      std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue);
+};
+
+class MGLVerifyHostObject : public SignBase {
+ public:
+  explicit MGLVerifyHostObject(
+      std::shared_ptr<react::CallInvoker> jsCallInvoker,
+      std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue);
+};
+
+}  // namespace margelo
+
+#endif /* MGLSignHostObjects_h */

package/cpp/Sig/MGLSignInstaller.cpp

@@ -0,0 +1,24 @@
+#include "MGLSignInstaller.h"
+
+#include "MGLSignHostObjects.h"
+#ifdef ANDROID
+#include "JSIUtils/MGLJSIMacros.h"
+#else
+#include "MGLJSIMacros.h"
+#include "logs.h"
+#endif
+
+namespace margelo {
+
+FieldDefinition getSignFieldDefinition(
+    std::shared_ptr<react::CallInvoker> jsCallInvoker,
+    std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue) {
+  return buildPair(
+      "createSign", JSIF([=]) {
+        auto hostObject =
+            std::make_shared<MGLSignHostObject>(jsCallInvoker, workerQueue);
+        return jsi::Object::createFromHostObject(runtime, hostObject);
+      });
+}
+
+}  // namespace margelo

package/cpp/Sig/MGLSignInstaller.h

@@ -0,0 +1,29 @@
+//
+//  MGLSignInstaller.hpp
+//  DoubleConversion
+//
+//  Created by Oscar on 30.06.22.
+//
+
+#ifndef MGLSignInstaller_h
+#define MGLSignInstaller_h
+
+#include <jsi/jsi.h>
+
+#include <memory>
+
+#ifdef ANDROID
+#include "JSIUtils/MGLSmartHostObject.h"
+#else
+#include "MGLSmartHostObject.h"
+#endif
+
+namespace margelo {
+namespace jsi = facebook::jsi;
+
+FieldDefinition getSignFieldDefinition(
+    std::shared_ptr<react::CallInvoker> jsCallInvoker,
+    std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue);
+}  // namespace margelo
+
+#endif /* MGLSignInstaller_h */

package/cpp/Sig/MGLVerifyInstaller.cpp

@@ -0,0 +1,24 @@
+#include "MGLVerifyInstaller.h"
+
+#include "MGLSignHostObjects.h"
+#ifdef ANDROID
+#include "JSIUtils/MGLJSIMacros.h"
+#else
+#include "MGLJSIMacros.h"
+#include "logs.h"
+#endif
+
+namespace margelo {
+
+FieldDefinition getVerifyFieldDefinition(
+    std::shared_ptr<react::CallInvoker> jsCallInvoker,
+    std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue) {
+  return buildPair(
+      "createVerify", JSIF([=]) {
+        auto hostObject =
+            std::make_shared<MGLVerifyHostObject>(jsCallInvoker, workerQueue);
+        return jsi::Object::createFromHostObject(runtime, hostObject);
+      });
+}
+
+}  // namespace margelo

package/cpp/Sig/MGLVerifyInstaller.h

@@ -0,0 +1,22 @@
+#ifndef MGLVerifyInstaller_h
+#define MGLVerifyInstaller_h
+
+#include <jsi/jsi.h>
+
+#include <memory>
+
+#ifdef ANDROID
+#include "JSIUtils/MGLSmartHostObject.h"
+#else
+#include "MGLSmartHostObject.h"
+#endif
+
+namespace margelo {
+namespace jsi = facebook::jsi;
+
+FieldDefinition getVerifyFieldDefinition(
+    std::shared_ptr<react::CallInvoker> jsCallInvoker,
+    std::shared_ptr<DispatchQueue::dispatch_queue> workerQueue);
+}  // namespace margelo
+
+#endif /* MGLVerifyInstaller_h */

package/cpp/Utils/MGLUtils.cpp

@@ -1,18 +1,46 @@
-//
-//  MGLUtils.cpp
-//  react-native-quick-crypto
-//
-//  Created by Oscar on 21.06.22.
-//
-
 #include "MGLUtils.h"
 
 #include <jsi/jsi.h>
 
+#include <string>
+
+#ifdef ANDROID
+#include "JSIUtils/MGLJSIMacros.h"
+#else
+#include "MGLJSIMacros.h"
+#endif
+
 namespace margelo {
 
 namespace jsi = facebook::jsi;
 
+ByteSource ArrayBufferToByteSource(jsi::Runtime& runtime,
+                                   const jsi::ArrayBuffer& buffer) {
+  if (buffer.size(runtime) == 0) return ByteSource();
+  char* buf = MallocOpenSSL<char>(buffer.size(runtime));
+  CHECK_NOT_NULL(buf);
+  // const cast artificially removes the const qualifier, but you cannot still
+  // modify the data in this case, this is safe because we are just memcopying
+  // to the buffer
+  memcpy(buf, const_cast<jsi::ArrayBuffer&>(buffer).data(runtime),
+         buffer.size(runtime));
+  return ByteSource::Allocated(buf, buffer.size(runtime));
+}
+
+ByteSource ArrayBufferToNTCByteSource(jsi::Runtime& runtime,
+                                      const jsi::ArrayBuffer& buffer) {
+  if (buffer.size(runtime) == 0) return ByteSource();
+  char* buf = MallocOpenSSL<char>(buffer.size(runtime) + 1);
+  CHECK_NOT_NULL(buf);
+  buf[buffer.size(runtime)] = 0;
+  // const cast artificially removes the const qualifier, but you cannot still
+  // modify the data in this case, this is safe because we are just memcopying
+  // to the buffer
+  memcpy(buf, const_cast<jsi::ArrayBuffer&>(buffer).data(runtime),
+         buffer.size(runtime));
+  return ByteSource::Allocated(buf, buffer.size(runtime));
+}
+
 ByteSource::ByteSource(ByteSource&& other) noexcept
     : data_(other.data_),
       allocated_data_(other.allocated_data_),
@@ -95,28 +123,38 @@ ByteSource& ByteSource::operator=(ByteSource&& other) noexcept {
 //   return out;
 // }
 //
-// ByteSource ByteSource::FromStringOrBuffer(Environment* env,
-//                                           Local<Value> value) {
-//   return IsAnyByteSource(value) ? FromBuffer(value)
-//   : FromString(env, value.As<String>());
-// }
-//
-// ByteSource ByteSource::FromString(Environment* env, Local<String> str,
-//                                   bool ntc) {
-//   CHECK(str->IsString());
-//   size_t size = str->Utf8Length(env->isolate());
-//   size_t alloc_size = ntc ? size + 1 : size;
-//   ByteSource::Builder out(alloc_size);
-//   int opts = String::NO_OPTIONS;
-//   if (!ntc) opts |= String::NO_NULL_TERMINATION;
-//   str->WriteUtf8(env->isolate(), out.data<char>(), alloc_size, nullptr,
-//   opts); return std::move(out).release();
-// }
-//
-// ByteSource ByteSource::FromBuffer(Local<Value> buffer, bool ntc) {
-//   ArrayBufferOrViewContents<char> buf(buffer);
-//   return ntc ? buf.ToNullTerminatedCopy() : buf.ToByteSource();
-// }
+ByteSource ByteSource::FromStringOrBuffer(jsi::Runtime& runtime,
+                                          const jsi::Value& value) {
+  return value.isString()
+             ? FromString(value.asString(runtime).utf8(runtime))
+             : FromBuffer(runtime,
+                          value.asObject(runtime).getArrayBuffer(runtime));
+}
+
+// ntc = null terminated copy
+ByteSource ByteSource::FromString(std::string str, bool ntc) {
+  //   CHECK(str->IsString());
+  size_t size = str.size();
+  size_t alloc_size = ntc ? size + 1 : size;
+  ByteSource::Builder out(alloc_size);
+  //   int opts = String::NO_OPTIONS;
+  //   if (!ntc) opts |= String::NO_NULL_TERMINATION;
+  //   str->WriteUtf8(env->isolate(), out.data<char>(), alloc_size, nullptr,
+  //   opts);
+  if (ntc) {
+    strcpy(out.data<char>(), str.data());
+  } else {
+    strncpy(out.data<char>(), str.data(), alloc_size);
+  }
+
+  return std::move(out).release();
+}
+
+ByteSource ByteSource::FromBuffer(jsi::Runtime& runtime,
+                                  const jsi::ArrayBuffer& buffer, bool ntc) {
+  return ntc ? ArrayBufferToNTCByteSource(runtime, buffer)
+             : ArrayBufferToByteSource(runtime, buffer);
+}
 //
 // ByteSource ByteSource::FromSecretKeyBytes(
 //                                           Environment* env,

package/cpp/Utils/MGLUtils.h

@@ -1,10 +1,3 @@
-//
-//  MGLUtils.h
-//  Pods
-//
-//  Created by Oscar on 20.06.22.
-//
-
 #ifndef MGLUtils_h
 #define MGLUtils_h
 
@@ -53,6 +46,8 @@ using EVPKeyCtxPointer = DeleteFnPtr<EVP_PKEY_CTX, EVP_PKEY_CTX_free>;
 using EVPKeyPointer = DeleteFnPtr<EVP_PKEY, EVP_PKEY_free>;
 using BignumPointer = DeleteFnPtr<BIGNUM, BN_free>;
 using RSAPointer = DeleteFnPtr<RSA, RSA_free>;
+using EVPMDPointer = DeleteFnPtr<EVP_MD_CTX, EVP_MD_CTX_free>;
+using ECDSASigPointer = DeleteFnPtr<ECDSA_SIG, ECDSA_SIG_free>;
 
 template <typename T>
 class NonCopyableMaybe {
@@ -183,15 +178,14 @@ class ByteSource {
   //                                      v8::Local<v8::String> value,
   //                                      enum encoding enc = BASE64);
   //
-  //  static ByteSource FromStringOrBuffer(Environment* env,
-  //                                       v8::Local<v8::Value> value);
-  //
-  //  static ByteSource FromString(Environment* env,
-  //                               v8::Local<v8::String> str,
-  //                               bool ntc = false);
+  static ByteSource FromStringOrBuffer(jsi::Runtime& runtime,
+                                       const jsi::Value& value);
 
-  //  static ByteSource FromBuffer(v8::Local<v8::Value> buffer,
-  //                               bool ntc = false);
+  static ByteSource FromString(std::string str, bool ntc = false);
+
+  static ByteSource FromBuffer(jsi::Runtime& runtime,
+                               const jsi::ArrayBuffer& buffer,
+                               bool ntc = false);
 
   //  static ByteSource FromBIO(const BIOPointer& bio);
   //
@@ -214,6 +208,12 @@ class ByteSource {
       : data_(data), allocated_data_(allocated_data), size_(size) {}
 };
 
+ByteSource ArrayBufferToByteSource(jsi::Runtime& runtime,
+                                   const jsi::ArrayBuffer& buffer);
+
+ByteSource ArrayBufferToNTCByteSource(jsi::Runtime& runtime,
+                                      const jsi::ArrayBuffer& buffer);
+
 // Originally part of the ArrayBufferContentOrView class
 inline ByteSource ToNullTerminatedByteSource(jsi::Runtime& runtime,
                                              jsi::ArrayBuffer& buffer) {
@@ -225,7 +225,7 @@ inline ByteSource ToNullTerminatedByteSource(jsi::Runtime& runtime,
   return ByteSource::Allocated(buf, buffer.size(runtime));
 }
 
-int PasswordCallback(char* buf, int size, int rwflag, void* u) {
+inline int PasswordCallback(char* buf, int size, int rwflag, void* u) {
   const ByteSource* passphrase = *static_cast<const ByteSource**>(u);
   if (passphrase != nullptr) {
     size_t buflen = static_cast<size_t>(size);
@@ -238,7 +238,7 @@ int PasswordCallback(char* buf, int size, int rwflag, void* u) {
   return -1;
 }
 
-void CheckEntropy() {
+inline void CheckEntropy() {
   for (;;) {
     int status = RAND_status();
     //    CHECK_GE(status, 0);  // Cannot fail.

package/lib/commonjs/@types/crypto-browserify.d.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=crypto-browserify.d.js.map

package/lib/commonjs/@types/crypto-browserify.d.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[]}

package/lib/commonjs/NativeQuickCrypto/NativeQuickCrypto.js.map

@@ -1 +1 @@
-{"version":3,"sources":["NativeQuickCrypto.ts"],"names":["global","__QuickCryptoProxy","QuickCryptoModule","NativeModules","QuickCrypto","message","Platform","OS","ExpoConstants","NativeUnimoduleProxy","modulesConstants","ExponentConstants","appOwnership","Error","nativeCallSyncHook","install","result","proxy","NativeQuickCrypto"],"mappings":";;;;;;;AAAA;;AAkCA;AACA,IAAIA,MAAM,CAACC,kBAAP,IAA6B,IAAjC,EAAuC;AACrC;AACA,QAAMC,iBAAiB,GAAGC,2BAAcC,WAAxC;;AACA,MAAIF,iBAAiB,IAAI,IAAzB,EAA+B;AAAA;;AAC7B,QAAIG,OAAO,GACT,kGADF;AAEAA,IAAAA,OAAO,IACL,2GADF;;AAEA,QAAIC,sBAASC,EAAT,KAAgB,KAAhB,IAAyBD,sBAASC,EAAT,KAAgB,OAA7C,EAAsD;AACpDF,MAAAA,OAAO,IAAI,4DAAX;AACD;;AACD,QAAIC,sBAASC,EAAT,KAAgB,SAApB,EAA+B;AAC7BF,MAAAA,OAAO,IAAI,iCAAX;AACD,KAV4B,CAW7B;;;AACA,UAAMG,aAAa,4BACjBL,2BAAcM,oBADG,oFACjB,sBAAoCC,gBADnB,2DACjB,uBAAsDC,iBADxD;;AAEA,QAAIH,aAAa,IAAI,IAArB,EAA2B;AACzB,UAAIA,aAAa,CAACI,YAAd,KAA+B,MAAnC,EAA2C;AACzC;AACA,cAAM,IAAIC,KAAJ,CACJ,uHADI,CAAN;AAGD,OALD,MAKO;AACL;AACAR,QAAAA,OAAO,IAAI,wCAAX;AACD;AACF;;AAEDA,IAAAA,OAAO,IAAI,oCAAX;AACA,UAAM,IAAIQ,KAAJ,CAAUR,OAAV,CAAN;AACD,GA/BoC,CAiCrC;;;AACA,MAAIL,MAAM,CAACc,kBAAP,IAA6B,IAA7B,IAAqCZ,iBAAiB,CAACa,OAAlB,IAA6B,IAAtE,EAA4E;AAC1E,UAAM,IAAIF,KAAJ,CACJ,oRADI,CAAN;AAGD,GAtCoC,CAwCrC;;;AACA,QAAMG,MAAM,GAAGd,iBAAiB,CAACa,OAAlB,EAAf;AACA,MAAIC,MAAM,KAAK,IAAf,EACE,MAAM,IAAIH,KAAJ,CACH,oKAAmKG,MAAO,EADvK,CAAN,CA3CmC,CA+CrC;;AACA,MAAIhB,MAAM,CAACC,kBAAP,IAA6B,IAAjC,EACE,MAAM,IAAIY,KAAJ,CACJ,4JADI,CAAN;AAGH;;AAED,MAAMI,KAAK,GAAGjB,MAAM,CAACC,kBAArB;AACO,MAAMiB,iBAAiB,GAAGD,KAA1B","sourcesContent":["import { NativeModules, Platform } from 'react-native';\nimport type { CreateHmacMethod } from './hmac';\nimport type { CreateHashMethod } from './hash';\nimport type { Pbkdf2Object } from './pbkdf2';\nimport type { RandomObject } from './random';\nimport type {\n  CreateCipherMethod,\n  CreateDecipherMethod,\n  PublicEncryptMethod,\n  PrivateDecryptMethod,\n  GenerateKeyPairMethod,\n  GenerateKeyPairSyncMethod,\n} from './Cipher';\n\ninterface NativeQuickCryptoSpec {\n  createHmac: CreateHmacMethod;\n  pbkdf2: Pbkdf2Object;\n  random: RandomObject;\n  createHash: CreateHashMethod;\n  createCipher: CreateCipherMethod;\n  createDecipher: CreateDecipherMethod;\n  publicEncrypt: PublicEncryptMethod;\n  publicDecrypt: PublicEncryptMethod;\n  privateDecrypt: PrivateDecryptMethod;\n  generateKeyPair: GenerateKeyPairMethod;\n  generateKeyPairSync: GenerateKeyPairSyncMethod;\n}\n\n// global func declaration for JSI functions\ndeclare global {\n  function nativeCallSyncHook(): unknown;\n  var __QuickCryptoProxy: object | undefined;\n}\n\n// Check if the constructor exists. If not, try installing the JSI bindings.\nif (global.__QuickCryptoProxy == null) {\n  // Get the native QuickCrypto ReactModule\n  const QuickCryptoModule = NativeModules.QuickCrypto;\n  if (QuickCryptoModule == null) {\n    let message =\n      'Failed to install react-native-quick-crypto: The native `QuickCrypto` Module could not be found.';\n    message +=\n      '\\n* Make sure react-native-quick-crypto is correctly autolinked (run `npx react-native config` to verify)';\n    if (Platform.OS === 'ios' || Platform.OS === 'macos') {\n      message += '\\n* Make sure you ran `pod install` in the ios/ directory.';\n    }\n    if (Platform.OS === 'android') {\n      message += '\\n* Make sure gradle is synced.';\n    }\n    // check if Expo\n    const ExpoConstants =\n      NativeModules.NativeUnimoduleProxy?.modulesConstants?.ExponentConstants;\n    if (ExpoConstants != null) {\n      if (ExpoConstants.appOwnership === 'expo') {\n        // We're running Expo Go\n        throw new Error(\n          'react-native-quick-crypto is not supported in Expo Go! Use EAS (`expo prebuild`) or eject to a bare workflow instead.'\n        );\n      } else {\n        // We're running Expo bare / standalone\n        message += '\\n* Make sure you ran `expo prebuild`.';\n      }\n    }\n\n    message += '\\n* Make sure you rebuilt the app.';\n    throw new Error(message);\n  }\n\n  // Check if we are running on-device (JSI)\n  if (global.nativeCallSyncHook == null || QuickCryptoModule.install == null) {\n    throw new Error(\n      'Failed to install react-native-quick-crypto: React Native is not running on-device. QuickCrypto can only be used when synchronous method invocations (JSI) are possible. If you are using a remote debugger (e.g. Chrome), switch to an on-device debugger (e.g. Flipper) instead.'\n    );\n  }\n\n  // Call the synchronous blocking install() function\n  const result = QuickCryptoModule.install();\n  if (result !== true)\n    throw new Error(\n      `Failed to install react-native-quick-crypto: The native QuickCrypto Module could not be installed! Looks like something went wrong when installing JSI bindings: ${result}`\n    );\n\n  // Check again if the constructor now exists. If not, throw an error.\n  if (global.__QuickCryptoProxy == null)\n    throw new Error(\n      'Failed to install react-native-quick-crypto, the native initializer function does not exist. Are you trying to use QuickCrypto from different JS Runtimes?'\n    );\n}\n\nconst proxy = global.__QuickCryptoProxy;\nexport const NativeQuickCrypto = proxy as any as NativeQuickCryptoSpec;\n"]}
+{"version":3,"sources":["NativeQuickCrypto.ts"],"names":["global","__QuickCryptoProxy","QuickCryptoModule","NativeModules","QuickCrypto","message","Platform","OS","ExpoConstants","NativeUnimoduleProxy","modulesConstants","ExponentConstants","appOwnership","Error","nativeCallSyncHook","install","result","proxy","NativeQuickCrypto"],"mappings":";;;;;;;AAAA;;AAqCA;AACA,IAAIA,MAAM,CAACC,kBAAP,IAA6B,IAAjC,EAAuC;AACrC;AACA,QAAMC,iBAAiB,GAAGC,2BAAcC,WAAxC;;AACA,MAAIF,iBAAiB,IAAI,IAAzB,EAA+B;AAAA;;AAC7B,QAAIG,OAAO,GACT,kGADF;AAEAA,IAAAA,OAAO,IACL,2GADF;;AAEA,QAAIC,sBAASC,EAAT,KAAgB,KAAhB,IAAyBD,sBAASC,EAAT,KAAgB,OAA7C,EAAsD;AACpDF,MAAAA,OAAO,IAAI,4DAAX;AACD;;AACD,QAAIC,sBAASC,EAAT,KAAgB,SAApB,EAA+B;AAC7BF,MAAAA,OAAO,IAAI,iCAAX;AACD,KAV4B,CAW7B;;;AACA,UAAMG,aAAa,4BACjBL,2BAAcM,oBADG,oFACjB,sBAAoCC,gBADnB,2DACjB,uBAAsDC,iBADxD;;AAEA,QAAIH,aAAa,IAAI,IAArB,EAA2B;AACzB,UAAIA,aAAa,CAACI,YAAd,KAA+B,MAAnC,EAA2C;AACzC;AACA,cAAM,IAAIC,KAAJ,CACJ,uHADI,CAAN;AAGD,OALD,MAKO;AACL;AACAR,QAAAA,OAAO,IAAI,wCAAX;AACD;AACF;;AAEDA,IAAAA,OAAO,IAAI,oCAAX;AACA,UAAM,IAAIQ,KAAJ,CAAUR,OAAV,CAAN;AACD,GA/BoC,CAiCrC;;;AACA,MAAIL,MAAM,CAACc,kBAAP,IAA6B,IAA7B,IAAqCZ,iBAAiB,CAACa,OAAlB,IAA6B,IAAtE,EAA4E;AAC1E,UAAM,IAAIF,KAAJ,CACJ,oRADI,CAAN;AAGD,GAtCoC,CAwCrC;;;AACA,QAAMG,MAAM,GAAGd,iBAAiB,CAACa,OAAlB,EAAf;AACA,MAAIC,MAAM,KAAK,IAAf,EACE,MAAM,IAAIH,KAAJ,CACH,oKAAmKG,MAAO,EADvK,CAAN,CA3CmC,CA+CrC;;AACA,MAAIhB,MAAM,CAACC,kBAAP,IAA6B,IAAjC,EACE,MAAM,IAAIY,KAAJ,CACJ,4JADI,CAAN;AAGH;;AAED,MAAMI,KAAK,GAAGjB,MAAM,CAACC,kBAArB;AACO,MAAMiB,iBAAiB,GAAGD,KAA1B","sourcesContent":["import { NativeModules, Platform } from 'react-native';\nimport type { CreateHmacMethod } from './hmac';\nimport type { CreateHashMethod } from './hash';\nimport type { Pbkdf2Object } from './pbkdf2';\nimport type { RandomObject } from './random';\nimport type {\n  CreateCipherMethod,\n  CreateDecipherMethod,\n  PublicEncryptMethod,\n  PrivateDecryptMethod,\n  GenerateKeyPairMethod,\n  GenerateKeyPairSyncMethod,\n} from './Cipher';\nimport type { CreateSignMethod, CreateVerifyMethod } from './sig';\n\ninterface NativeQuickCryptoSpec {\n  createHmac: CreateHmacMethod;\n  pbkdf2: Pbkdf2Object;\n  random: RandomObject;\n  createHash: CreateHashMethod;\n  createCipher: CreateCipherMethod;\n  createDecipher: CreateDecipherMethod;\n  publicEncrypt: PublicEncryptMethod;\n  publicDecrypt: PublicEncryptMethod;\n  privateDecrypt: PrivateDecryptMethod;\n  generateKeyPair: GenerateKeyPairMethod;\n  generateKeyPairSync: GenerateKeyPairSyncMethod;\n  createSign: CreateSignMethod;\n  createVerify: CreateVerifyMethod;\n}\n\n// global func declaration for JSI functions\ndeclare global {\n  function nativeCallSyncHook(): unknown;\n  var __QuickCryptoProxy: object | undefined;\n}\n\n// Check if the constructor exists. If not, try installing the JSI bindings.\nif (global.__QuickCryptoProxy == null) {\n  // Get the native QuickCrypto ReactModule\n  const QuickCryptoModule = NativeModules.QuickCrypto;\n  if (QuickCryptoModule == null) {\n    let message =\n      'Failed to install react-native-quick-crypto: The native `QuickCrypto` Module could not be found.';\n    message +=\n      '\\n* Make sure react-native-quick-crypto is correctly autolinked (run `npx react-native config` to verify)';\n    if (Platform.OS === 'ios' || Platform.OS === 'macos') {\n      message += '\\n* Make sure you ran `pod install` in the ios/ directory.';\n    }\n    if (Platform.OS === 'android') {\n      message += '\\n* Make sure gradle is synced.';\n    }\n    // check if Expo\n    const ExpoConstants =\n      NativeModules.NativeUnimoduleProxy?.modulesConstants?.ExponentConstants;\n    if (ExpoConstants != null) {\n      if (ExpoConstants.appOwnership === 'expo') {\n        // We're running Expo Go\n        throw new Error(\n          'react-native-quick-crypto is not supported in Expo Go! Use EAS (`expo prebuild`) or eject to a bare workflow instead.'\n        );\n      } else {\n        // We're running Expo bare / standalone\n        message += '\\n* Make sure you ran `expo prebuild`.';\n      }\n    }\n\n    message += '\\n* Make sure you rebuilt the app.';\n    throw new Error(message);\n  }\n\n  // Check if we are running on-device (JSI)\n  if (global.nativeCallSyncHook == null || QuickCryptoModule.install == null) {\n    throw new Error(\n      'Failed to install react-native-quick-crypto: React Native is not running on-device. QuickCrypto can only be used when synchronous method invocations (JSI) are possible. If you are using a remote debugger (e.g. Chrome), switch to an on-device debugger (e.g. Flipper) instead.'\n    );\n  }\n\n  // Call the synchronous blocking install() function\n  const result = QuickCryptoModule.install();\n  if (result !== true)\n    throw new Error(\n      `Failed to install react-native-quick-crypto: The native QuickCrypto Module could not be installed! Looks like something went wrong when installing JSI bindings: ${result}`\n    );\n\n  // Check again if the constructor now exists. If not, throw an error.\n  if (global.__QuickCryptoProxy == null)\n    throw new Error(\n      'Failed to install react-native-quick-crypto, the native initializer function does not exist. Are you trying to use QuickCrypto from different JS Runtimes?'\n    );\n}\n\nconst proxy = global.__QuickCryptoProxy;\nexport const NativeQuickCrypto = proxy as any as NativeQuickCryptoSpec;\n"]}

package/lib/commonjs/NativeQuickCrypto/sig.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=sig.js.map

package/lib/commonjs/NativeQuickCrypto/sig.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[]}

package/lib/commonjs/QuickCrypto.js

@@ -11,6 +11,8 @@ var random = _interopRequireWildcard(require("./random"));
 
 var _Cipher = require("./Cipher");
 
+var _sig = require("./sig");
+
 var _Hmac = require("./Hmac");
 
 var _Hash = require("./Hash");
@@ -35,6 +37,8 @@ const QuickCrypto = {
   privateDecrypt: _Cipher.privateDecrypt,
   generateKeyPair: _Cipher.generateKeyPair,
   generateKeyPairSync: _Cipher.generateKeyPairSync,
+  createSign: _sig.createSign,
+  createVerify: _sig.createVerify,
   constants: _constants.constants,
   ...pbkdf2,
   ...random

package/lib/commonjs/QuickCrypto.js.map

@@ -1 +1 @@
-{"version":3,"sources":["QuickCrypto.ts"],"names":["QuickCrypto","createHmac","Hmac","Hash","createHash","createCipher","createCipheriv","createDecipher","createDecipheriv","publicEncrypt","publicDecrypt","privateDecrypt","generateKeyPair","generateKeyPairSync","constants","pbkdf2","random"],"mappings":";;;;;;;AAAA;;AACA;;AACA;;AAWA;;AACA;;AACA;;;;;;AAEO,MAAMA,WAAW,GAAG;AACzBC,EAAAA,UAAU,EAAVA,gBADyB;AAEzBC,EAAAA,IAAI,EAAED,gBAFmB;AAGzBE,EAAAA,IAAI,EAAEC,gBAHmB;AAIzBA,EAAAA,UAAU,EAAVA,gBAJyB;AAKzBC,EAAAA,YAAY,EAAZA,oBALyB;AAMzBC,EAAAA,cAAc,EAAdA,sBANyB;AAOzBC,EAAAA,cAAc,EAAdA,sBAPyB;AAQzBC,EAAAA,gBAAgB,EAAhBA,wBARyB;AASzBC,EAAAA,aAAa,EAAbA,qBATyB;AAUzBC,EAAAA,aAAa,EAAbA,qBAVyB;AAWzBC,EAAAA,cAAc,EAAdA,sBAXyB;AAYzBC,EAAAA,eAAe,EAAfA,uBAZyB;AAazBC,EAAAA,mBAAmB,EAAnBA,2BAbyB;AAczBC,EAAAA,SAAS,EAATA,oBAdyB;AAezB,KAAGC,MAfsB;AAgBzB,KAAGC;AAhBsB,CAApB","sourcesContent":["import * as pbkdf2 from './pbkdf2';\nimport * as random from './random';\nimport {\n  createCipher,\n  createCipheriv,\n  createDecipher,\n  createDecipheriv,\n  publicEncrypt,\n  publicDecrypt,\n  privateDecrypt,\n  generateKeyPair,\n  generateKeyPairSync,\n} from './Cipher';\nimport { createHmac } from './Hmac';\nimport { createHash } from './Hash';\nimport { constants } from './constants';\n\nexport const QuickCrypto = {\n  createHmac,\n  Hmac: createHmac,\n  Hash: createHash,\n  createHash,\n  createCipher,\n  createCipheriv,\n  createDecipher,\n  createDecipheriv,\n  publicEncrypt,\n  publicDecrypt,\n  privateDecrypt,\n  generateKeyPair,\n  generateKeyPairSync,\n  constants,\n  ...pbkdf2,\n  ...random,\n};\n"]}
+{"version":3,"sources":["QuickCrypto.ts"],"names":["QuickCrypto","createHmac","Hmac","Hash","createHash","createCipher","createCipheriv","createDecipher","createDecipheriv","publicEncrypt","publicDecrypt","privateDecrypt","generateKeyPair","generateKeyPairSync","createSign","createVerify","constants","pbkdf2","random"],"mappings":";;;;;;;AAAA;;AACA;;AACA;;AAWA;;AACA;;AACA;;AACA;;;;;;AAEO,MAAMA,WAAW,GAAG;AACzBC,EAAAA,UAAU,EAAVA,gBADyB;AAEzBC,EAAAA,IAAI,EAAED,gBAFmB;AAGzBE,EAAAA,IAAI,EAAEC,gBAHmB;AAIzBA,EAAAA,UAAU,EAAVA,gBAJyB;AAKzBC,EAAAA,YAAY,EAAZA,oBALyB;AAMzBC,EAAAA,cAAc,EAAdA,sBANyB;AAOzBC,EAAAA,cAAc,EAAdA,sBAPyB;AAQzBC,EAAAA,gBAAgB,EAAhBA,wBARyB;AASzBC,EAAAA,aAAa,EAAbA,qBATyB;AAUzBC,EAAAA,aAAa,EAAbA,qBAVyB;AAWzBC,EAAAA,cAAc,EAAdA,sBAXyB;AAYzBC,EAAAA,eAAe,EAAfA,uBAZyB;AAazBC,EAAAA,mBAAmB,EAAnBA,2BAbyB;AAczBC,EAAAA,UAAU,EAAVA,eAdyB;AAezBC,EAAAA,YAAY,EAAZA,iBAfyB;AAgBzBC,EAAAA,SAAS,EAATA,oBAhByB;AAiBzB,KAAGC,MAjBsB;AAkBzB,KAAGC;AAlBsB,CAApB","sourcesContent":["import * as pbkdf2 from './pbkdf2';\nimport * as random from './random';\nimport {\n  createCipher,\n  createCipheriv,\n  createDecipher,\n  createDecipheriv,\n  publicEncrypt,\n  publicDecrypt,\n  privateDecrypt,\n  generateKeyPair,\n  generateKeyPairSync,\n} from './Cipher';\nimport { createSign, createVerify } from './sig';\nimport { createHmac } from './Hmac';\nimport { createHash } from './Hash';\nimport { constants } from './constants';\n\nexport const QuickCrypto = {\n  createHmac,\n  Hmac: createHmac,\n  Hash: createHash,\n  createHash,\n  createCipher,\n  createCipheriv,\n  createDecipher,\n  createDecipheriv,\n  publicEncrypt,\n  publicDecrypt,\n  privateDecrypt,\n  generateKeyPair,\n  generateKeyPairSync,\n  createSign,\n  createVerify,\n  constants,\n  ...pbkdf2,\n  ...random,\n};\n"]}

package/lib/commonjs/index.js

@@ -9,16 +9,16 @@ var _reactNativeBuffer = require("@craftzdog/react-native-buffer");
 
 var _QuickCrypto = require("./QuickCrypto");
 
-// @ts-expect-error
-global.Buffer = _reactNativeBuffer.Buffer; // @ts-expect-error
+var _cryptoBrowserify = _interopRequireDefault(require("crypto-browserify"));
 
-global.crypto = _QuickCrypto.QuickCrypto; // for randombytes https://github.com/crypto-browserify/randombytes/blob/master/browser.js#L16
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-const fallbackCrypto = require('crypto-browserify');
-
-const crypto = { ...fallbackCrypto,
+// @ts-expect-error Buffer does not match exact same type definition.
+global.Buffer = _reactNativeBuffer.Buffer;
+const crypto = { ..._cryptoBrowserify.default,
   ..._QuickCrypto.QuickCrypto
-}; // Maybe use proxy to not load everything?
+}; // for randombytes https://github.com/crypto-browserify/randombytes/blob/master/browser.js#L16
+// @ts-expect-error QuickCrypto is missing `subtle` and `randomUUID`
 
 global.crypto = crypto;
 module.exports = crypto;

package/lib/commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["index.ts"],"names":["global","Buffer","crypto","QuickCrypto","fallbackCrypto","require","module","exports"],"mappings":";;;;;;;AAAA;;AACA;;AAEA;AACAA,MAAM,CAACC,MAAP,GAAgBA,yBAAhB,C,CACA;;AACAD,MAAM,CAACE,MAAP,GAAgBC,wBAAhB,C,CAA6B;;AAE7B,MAAMC,cAAc,GAAGC,OAAO,CAAC,mBAAD,CAA9B;;AACA,MAAMH,MAAM,GAAG,EAAE,GAAGE,cAAL;AAAqB,KAAGD;AAAxB,CAAf,C,CAAsD;;AACtDH,MAAM,CAACE,MAAP,GAAgBA,MAAhB;AAEAI,MAAM,CAACC,OAAP,GAAiBL,MAAjB;eACeA,M","sourcesContent":["import { Buffer } from '@craftzdog/react-native-buffer';\nimport { QuickCrypto } from './QuickCrypto';\n\n// @ts-expect-error\nglobal.Buffer = Buffer;\n// @ts-expect-error\nglobal.crypto = QuickCrypto; // for randombytes https://github.com/crypto-browserify/randombytes/blob/master/browser.js#L16\n\nconst fallbackCrypto = require('crypto-browserify');\nconst crypto = { ...fallbackCrypto, ...QuickCrypto }; // Maybe use proxy to not load everything?\nglobal.crypto = crypto;\n\nmodule.exports = crypto;\nexport default crypto;\n"]}
+{"version":3,"sources":["index.ts"],"names":["global","Buffer","crypto","FallbackCrypto","QuickCrypto","module","exports"],"mappings":";;;;;;;AAAA;;AACA;;AACA;;;;AAEA;AACAA,MAAM,CAACC,MAAP,GAAgBA,yBAAhB;AAEA,MAAMC,MAAM,GAAG,EAAE,GAAGC,yBAAL;AAAqB,KAAGC;AAAxB,CAAf,C,CAEA;AACA;;AACAJ,MAAM,CAACE,MAAP,GAAgBA,MAAhB;AAEAG,MAAM,CAACC,OAAP,GAAiBJ,MAAjB;eACeA,M","sourcesContent":["import { Buffer } from '@craftzdog/react-native-buffer';\nimport { QuickCrypto } from './QuickCrypto';\nimport FallbackCrypto from 'crypto-browserify';\n\n// @ts-expect-error Buffer does not match exact same type definition.\nglobal.Buffer = Buffer;\n\nconst crypto = { ...FallbackCrypto, ...QuickCrypto };\n\n// for randombytes https://github.com/crypto-browserify/randombytes/blob/master/browser.js#L16\n// @ts-expect-error QuickCrypto is missing `subtle` and `randomUUID`\nglobal.crypto = crypto;\n\nmodule.exports = crypto;\nexport default crypto;\n"]}

package/lib/commonjs/keys.js

@@ -59,10 +59,7 @@ function parseKeyType(typeStr, required, keyType, isPublic, optionName) {
     return undefined;
   } else if (typeStr === 'pkcs1') {
     if (keyType !== undefined && keyType !== 'rsa') {
-      throw new Error(`Crypto incompatible key options: ${typeStr} can only be used for RSA keys`); // throw new ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS(
-      //   typeStr,
-      //   'can only be used for RSA keys'
-      // );
+      throw new Error(`Crypto incompatible key options: ${typeStr} can only be used for RSA keys`);
     }
 
     return KeyEncoding.kKeyEncodingPKCS1;

package/lib/commonjs/keys.js.map

@@ -1 +1 @@
-{"version":3,"sources":["keys.ts"],"names":["KFormatType","KeyInputContext","KeyEncoding","encodingNames","kKeyEncodingPKCS1","kKeyEncodingPKCS8","kKeyEncodingSPKI","kKeyEncodingSEC1","option","name","objName","undefined","parseKeyFormat","formatStr","defaultFormat","optionName","kKeyFormatPEM","kKeyFormatDER","kKeyFormatJWK","Error","parseKeyType","typeStr","required","keyType","isPublic","parseKeyFormatAndType","enc","format","type","isInput","isRequired","parseKeyEncoding","cipher","passphrase","encoding","prepareAsymmetricKey","key","ctx","data","kConsumePrivate","kCreatePrivate","preparePrivateKey","preparePublicOrPrivateKey","kConsumePublic","parsePublicKeyEncoding","parsePrivateKeyEncoding"],"mappings":"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","sourcesContent":["import { BinaryLike, binaryLikeToArrayBuffer, isStringOrBuffer } from './Utils';\n\n// On node this value is defined on the native side, for now I'm just creating it here in JS\n// TODO(osp) move this into native side to make sure they always match\nenum KFormatType {\n  kKeyFormatDER,\n  kKeyFormatPEM,\n  kKeyFormatJWK,\n}\n\nenum KeyInputContext {\n  kConsumePublic,\n  kConsumePrivate,\n  kCreatePublic,\n  kCreatePrivate,\n}\n\nenum KeyEncoding {\n  kKeyEncodingPKCS1,\n  kKeyEncodingPKCS8,\n  kKeyEncodingSPKI,\n  kKeyEncodingSEC1,\n}\n\nconst encodingNames = {\n  [KeyEncoding.kKeyEncodingPKCS1]: 'pkcs1',\n  [KeyEncoding.kKeyEncodingPKCS8]: 'pkcs8',\n  [KeyEncoding.kKeyEncodingSPKI]: 'spki',\n  [KeyEncoding.kKeyEncodingSEC1]: 'sec1',\n};\n\nfunction option(name: string, objName: string | undefined) {\n  return objName === undefined\n    ? `options.${name}`\n    : `options.${objName}.${name}`;\n}\n\nfunction parseKeyFormat(\n  formatStr: string,\n  defaultFormat: KFormatType | undefined,\n  optionName?: string\n) {\n  if (formatStr === undefined && defaultFormat !== undefined)\n    return defaultFormat;\n  else if (formatStr === 'pem') return KFormatType.kKeyFormatPEM;\n  else if (formatStr === 'der') return KFormatType.kKeyFormatDER;\n  else if (formatStr === 'jwk') return KFormatType.kKeyFormatJWK;\n  throw new Error(`Invalid key format str: ${optionName}`);\n  // throw new ERR_INVALID_ARG_VALUE(optionName, formatStr);\n}\n\nfunction parseKeyType(\n  typeStr: string,\n  required: boolean,\n  keyType: string,\n  isPublic: boolean,\n  optionName: string\n) {\n  if (typeStr === undefined && !required) {\n    return undefined;\n  } else if (typeStr === 'pkcs1') {\n    if (keyType !== undefined && keyType !== 'rsa') {\n      throw new Error(\n        `Crypto incompatible key options: ${typeStr} can only be used for RSA keys`\n      );\n      // throw new ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS(\n      //   typeStr,\n      //   'can only be used for RSA keys'\n      // );\n    }\n    return KeyEncoding.kKeyEncodingPKCS1;\n  } else if (typeStr === 'spki' && isPublic !== false) {\n    return KeyEncoding.kKeyEncodingSPKI;\n  } else if (typeStr === 'pkcs8' && isPublic !== true) {\n    return KeyEncoding.kKeyEncodingPKCS8;\n  } else if (typeStr === 'sec1' && isPublic !== true) {\n    if (keyType !== undefined && keyType !== 'ec') {\n      throw new Error(\n        `Incompatible key options ${typeStr} can only be used for EC keys`\n      );\n    }\n    return KeyEncoding.kKeyEncodingSEC1;\n  }\n\n  throw new Error(`Invalid option ${optionName} - ${typeStr}`);\n}\n\nfunction parseKeyFormatAndType(\n  enc: any,\n  keyType: any,\n  isPublic: any,\n  objName: any\n) {\n  const { format: formatStr, type: typeStr } = enc;\n\n  const isInput = keyType === undefined;\n  const format = parseKeyFormat(\n    formatStr,\n    isInput ? KFormatType.kKeyFormatPEM : undefined,\n    option('format', objName)\n  );\n\n  const isRequired =\n    (!isInput || format === KFormatType.kKeyFormatDER) &&\n    format !== KFormatType.kKeyFormatJWK;\n  const type = parseKeyType(\n    typeStr,\n    isRequired,\n    keyType,\n    isPublic,\n    option('type', objName)\n  );\n  return { format, type };\n}\n\nfunction parseKeyEncoding(\n  enc: {\n    key: any;\n    encoding?: string;\n    format?: string;\n    cipher?: string;\n    passphrase?: string;\n  },\n  keyType: string | undefined,\n  isPublic: boolean | undefined,\n  objName?: string\n) {\n  // validateObject(enc, 'options');\n\n  const isInput = keyType === undefined;\n\n  const { format, type } = parseKeyFormatAndType(\n    enc,\n    keyType,\n    isPublic,\n    objName\n  );\n\n  let cipher, passphrase, encoding;\n  if (isPublic !== true) {\n    ({ cipher, passphrase, encoding } = enc);\n\n    if (!isInput) {\n      if (cipher != null) {\n        if (typeof cipher !== 'string')\n          throw new Error(\n            `Invalid argument ${option('cipher', objName)}: ${cipher}`\n          );\n        if (\n          format === KFormatType.kKeyFormatDER &&\n          (type === KeyEncoding.kKeyEncodingPKCS1 ||\n            type === KeyEncoding.kKeyEncodingSEC1)\n        ) {\n          throw new Error(\n            `Incompatible key options ${encodingNames[type]} does not support encryption`\n          );\n        }\n      } else if (passphrase !== undefined) {\n        throw new Error(\n          `invalid argument ${option('cipher', objName)}: ${cipher}`\n        );\n      }\n    }\n\n    if (\n      (isInput && passphrase !== undefined && !isStringOrBuffer(passphrase)) ||\n      (!isInput && cipher != null && !isStringOrBuffer(passphrase))\n    ) {\n      throw new Error(\n        `Invalid argument value ${option('passphrase', objName)}: ${passphrase}`\n      );\n    }\n  }\n\n  if (passphrase !== undefined)\n    passphrase = binaryLikeToArrayBuffer(passphrase, encoding);\n\n  return { format, type, cipher, passphrase };\n}\n\nfunction prepareAsymmetricKey(\n  key:\n    | BinaryLike\n    | { key: any; encoding?: string; format?: any; passphrase?: string },\n  ctx: KeyInputContext\n): {\n  format: KFormatType;\n  data: ArrayBuffer;\n  type?: any;\n  passphrase?: any;\n} {\n  // TODO(osp) check, KeyObject some node object\n  // if (isKeyObject(key)) {\n  //   // Best case: A key object, as simple as that.\n  //   return { data: getKeyObjectHandle(key, ctx) };\n  // } else\n  // if (isCryptoKey(key)) {\n  //   return { data: getKeyObjectHandle(key[kKeyObject], ctx) };\n  // } else\n  if (isStringOrBuffer(key)) {\n    // Expect PEM by default, mostly for backward compatibility.\n    return {\n      format: KFormatType.kKeyFormatPEM,\n      data: binaryLikeToArrayBuffer(key),\n    };\n  } else if (typeof key === 'object') {\n    const {\n      key: data,\n      encoding,\n      // format\n    } = key;\n    // // The 'key' property can be a KeyObject as well to allow specifying\n    // // additional options such as padding along with the key.\n    // if (isKeyObject(data)) return { data: getKeyObjectHandle(data, ctx) };\n    // else if (isCryptoKey(data))\n    //   return { data: getKeyObjectHandle(data[kKeyObject], ctx) };\n    // else if (isJwk(data) && format === 'jwk')\n    //   return { data: getKeyObjectHandleFromJwk(data, ctx), format: 'jwk' };\n    // Either PEM or DER using PKCS#1 or SPKI.\n    if (!isStringOrBuffer(data)) {\n      throw new Error(\n        'prepareAsymmetricKey: key is not a string or ArrayBuffer'\n      );\n    }\n\n    const isPublic =\n      ctx === KeyInputContext.kConsumePrivate ||\n      ctx === KeyInputContext.kCreatePrivate\n        ? false\n        : undefined;\n\n    return {\n      data: binaryLikeToArrayBuffer(data, encoding),\n      ...parseKeyEncoding(key, undefined, isPublic),\n    };\n  }\n\n  throw new Error('[prepareAsymetricKey] Invalid argument key: ${key}');\n}\n\n// TODO(osp) any here is a node KeyObject\nexport function preparePrivateKey(\n  key:\n    | BinaryLike\n    | {\n        key: any;\n        encoding?: string;\n        format?: any;\n        padding?: number;\n        passphrase?: string;\n      }\n) {\n  return prepareAsymmetricKey(key, KeyInputContext.kConsumePrivate);\n}\n\n// TODO(osp) any here is a node KeyObject\nexport function preparePublicOrPrivateKey(\n  key:\n    | BinaryLike\n    | { key: any; encoding?: string; format?: any; padding?: number }\n) {\n  return prepareAsymmetricKey(key, KeyInputContext.kConsumePublic);\n}\n\n// Parses the public key encoding based on an object. keyType must be undefined\n// when this is used to parse an input encoding and must be a valid key type if\n// used to parse an output encoding.\nexport function parsePublicKeyEncoding(\n  enc: {\n    key: any;\n    encoding?: string;\n    format?: string;\n    cipher?: string;\n    passphrase?: string;\n  },\n  keyType: string | undefined,\n  objName?: string\n) {\n  return parseKeyEncoding(enc, keyType, keyType ? true : undefined, objName);\n}\n\n// Parses the private key encoding based on an object. keyType must be undefined\n// when this is used to parse an input encoding and must be a valid key type if\n// used to parse an output encoding.\nexport function parsePrivateKeyEncoding(\n  enc: {\n    key: any;\n    encoding?: string;\n    format?: string;\n    cipher?: string;\n    passphrase?: string;\n  },\n  keyType: string | undefined,\n  objName?: string\n) {\n  return parseKeyEncoding(enc, keyType, false, objName);\n}\n"]}
+{"version":3,"sources":["keys.ts"],"names":["KFormatType","KeyInputContext","KeyEncoding","encodingNames","kKeyEncodingPKCS1","kKeyEncodingPKCS8","kKeyEncodingSPKI","kKeyEncodingSEC1","option","name","objName","undefined","parseKeyFormat","formatStr","defaultFormat","optionName","kKeyFormatPEM","kKeyFormatDER","kKeyFormatJWK","Error","parseKeyType","typeStr","required","keyType","isPublic","parseKeyFormatAndType","enc","format","type","isInput","isRequired","parseKeyEncoding","cipher","passphrase","encoding","prepareAsymmetricKey","key","ctx","data","kConsumePrivate","kCreatePrivate","preparePrivateKey","preparePublicOrPrivateKey","kConsumePublic","parsePublicKeyEncoding","parsePrivateKeyEncoding"],"mappings":"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","sourcesContent":["import { BinaryLike, binaryLikeToArrayBuffer, isStringOrBuffer } from './Utils';\n\n// On node this value is defined on the native side, for now I'm just creating it here in JS\n// TODO(osp) move this into native side to make sure they always match\nenum KFormatType {\n  kKeyFormatDER,\n  kKeyFormatPEM,\n  kKeyFormatJWK,\n}\n\nenum KeyInputContext {\n  kConsumePublic,\n  kConsumePrivate,\n  kCreatePublic,\n  kCreatePrivate,\n}\n\nenum KeyEncoding {\n  kKeyEncodingPKCS1,\n  kKeyEncodingPKCS8,\n  kKeyEncodingSPKI,\n  kKeyEncodingSEC1,\n}\n\nconst encodingNames = {\n  [KeyEncoding.kKeyEncodingPKCS1]: 'pkcs1',\n  [KeyEncoding.kKeyEncodingPKCS8]: 'pkcs8',\n  [KeyEncoding.kKeyEncodingSPKI]: 'spki',\n  [KeyEncoding.kKeyEncodingSEC1]: 'sec1',\n};\n\nfunction option(name: string, objName: string | undefined) {\n  return objName === undefined\n    ? `options.${name}`\n    : `options.${objName}.${name}`;\n}\n\nfunction parseKeyFormat(\n  formatStr: string | undefined,\n  defaultFormat: KFormatType | undefined,\n  optionName?: string\n) {\n  if (formatStr === undefined && defaultFormat !== undefined)\n    return defaultFormat;\n  else if (formatStr === 'pem') return KFormatType.kKeyFormatPEM;\n  else if (formatStr === 'der') return KFormatType.kKeyFormatDER;\n  else if (formatStr === 'jwk') return KFormatType.kKeyFormatJWK;\n  throw new Error(`Invalid key format str: ${optionName}`);\n  // throw new ERR_INVALID_ARG_VALUE(optionName, formatStr);\n}\n\nfunction parseKeyType(\n  typeStr: string | undefined,\n  required: boolean,\n  keyType: string | undefined,\n  isPublic: boolean | undefined,\n  optionName: string\n) {\n  if (typeStr === undefined && !required) {\n    return undefined;\n  } else if (typeStr === 'pkcs1') {\n    if (keyType !== undefined && keyType !== 'rsa') {\n      throw new Error(\n        `Crypto incompatible key options: ${typeStr} can only be used for RSA keys`\n      );\n    }\n    return KeyEncoding.kKeyEncodingPKCS1;\n  } else if (typeStr === 'spki' && isPublic !== false) {\n    return KeyEncoding.kKeyEncodingSPKI;\n  } else if (typeStr === 'pkcs8' && isPublic !== true) {\n    return KeyEncoding.kKeyEncodingPKCS8;\n  } else if (typeStr === 'sec1' && isPublic !== true) {\n    if (keyType !== undefined && keyType !== 'ec') {\n      throw new Error(\n        `Incompatible key options ${typeStr} can only be used for EC keys`\n      );\n    }\n    return KeyEncoding.kKeyEncodingSEC1;\n  }\n\n  throw new Error(`Invalid option ${optionName} - ${typeStr}`);\n}\n\nfunction parseKeyFormatAndType(\n  enc: {\n    key: any;\n    type?: string;\n    encoding?: string;\n    format?: string;\n    cipher?: string;\n    passphrase?: string;\n  },\n  keyType: string | undefined,\n  isPublic: boolean | undefined,\n  objName: string | undefined\n) {\n  const { format: formatStr, type: typeStr } = enc;\n\n  const isInput = keyType === undefined;\n  const format = parseKeyFormat(\n    formatStr,\n    isInput ? KFormatType.kKeyFormatPEM : undefined,\n    option('format', objName)\n  );\n\n  const isRequired =\n    (!isInput || format === KFormatType.kKeyFormatDER) &&\n    format !== KFormatType.kKeyFormatJWK;\n\n  const type = parseKeyType(\n    typeStr,\n    isRequired,\n    keyType,\n    isPublic,\n    option('type', objName)\n  );\n  return { format, type };\n}\n\nfunction parseKeyEncoding(\n  enc: {\n    key: any;\n    type?: string;\n    encoding?: string;\n    format?: string;\n    cipher?: string;\n    passphrase?: string;\n  },\n  keyType: string | undefined,\n  isPublic: boolean | undefined,\n  objName?: string | undefined\n) {\n  // validateObject(enc, 'options');\n\n  const isInput = keyType === undefined;\n\n  const { format, type } = parseKeyFormatAndType(\n    enc,\n    keyType,\n    isPublic,\n    objName\n  );\n\n  let cipher, passphrase, encoding;\n  if (isPublic !== true) {\n    ({ cipher, passphrase, encoding } = enc);\n\n    if (!isInput) {\n      if (cipher != null) {\n        if (typeof cipher !== 'string')\n          throw new Error(\n            `Invalid argument ${option('cipher', objName)}: ${cipher}`\n          );\n        if (\n          format === KFormatType.kKeyFormatDER &&\n          (type === KeyEncoding.kKeyEncodingPKCS1 ||\n            type === KeyEncoding.kKeyEncodingSEC1)\n        ) {\n          throw new Error(\n            `Incompatible key options ${encodingNames[type]} does not support encryption`\n          );\n        }\n      } else if (passphrase !== undefined) {\n        throw new Error(\n          `invalid argument ${option('cipher', objName)}: ${cipher}`\n        );\n      }\n    }\n\n    if (\n      (isInput && passphrase !== undefined && !isStringOrBuffer(passphrase)) ||\n      (!isInput && cipher != null && !isStringOrBuffer(passphrase))\n    ) {\n      throw new Error(\n        `Invalid argument value ${option('passphrase', objName)}: ${passphrase}`\n      );\n    }\n  }\n\n  if (passphrase !== undefined)\n    passphrase = binaryLikeToArrayBuffer(passphrase, encoding);\n\n  return { format, type, cipher, passphrase };\n}\n\nfunction prepareAsymmetricKey(\n  key:\n    | BinaryLike\n    | { key: any; encoding?: string; format?: any; passphrase?: string },\n  ctx: KeyInputContext\n): {\n  format: KFormatType;\n  data: ArrayBuffer;\n  type?: any;\n  passphrase?: any;\n} {\n  // TODO(osp) check, KeyObject some node object\n  // if (isKeyObject(key)) {\n  //   // Best case: A key object, as simple as that.\n  //   return { data: getKeyObjectHandle(key, ctx) };\n  // } else\n  // if (isCryptoKey(key)) {\n  //   return { data: getKeyObjectHandle(key[kKeyObject], ctx) };\n  // } else\n  if (isStringOrBuffer(key)) {\n    // Expect PEM by default, mostly for backward compatibility.\n    return {\n      format: KFormatType.kKeyFormatPEM,\n      data: binaryLikeToArrayBuffer(key),\n    };\n  } else if (typeof key === 'object') {\n    const {\n      key: data,\n      encoding,\n      // format\n    } = key;\n    // // The 'key' property can be a KeyObject as well to allow specifying\n    // // additional options such as padding along with the key.\n    // if (isKeyObject(data)) return { data: getKeyObjectHandle(data, ctx) };\n    // else if (isCryptoKey(data))\n    //   return { data: getKeyObjectHandle(data[kKeyObject], ctx) };\n    // else if (isJwk(data) && format === 'jwk')\n    //   return { data: getKeyObjectHandleFromJwk(data, ctx), format: 'jwk' };\n    // Either PEM or DER using PKCS#1 or SPKI.\n    if (!isStringOrBuffer(data)) {\n      throw new Error(\n        'prepareAsymmetricKey: key is not a string or ArrayBuffer'\n      );\n    }\n\n    const isPublic =\n      ctx === KeyInputContext.kConsumePrivate ||\n      ctx === KeyInputContext.kCreatePrivate\n        ? false\n        : undefined;\n\n    return {\n      data: binaryLikeToArrayBuffer(data, encoding),\n      ...parseKeyEncoding(key, undefined, isPublic),\n    };\n  }\n\n  throw new Error('[prepareAsymetricKey] Invalid argument key: ${key}');\n}\n\n// TODO(osp) any here is a node KeyObject\nexport function preparePrivateKey(\n  key:\n    | BinaryLike\n    | {\n        key: any;\n        encoding?: string;\n        format?: any;\n        padding?: number;\n        passphrase?: string;\n      }\n) {\n  return prepareAsymmetricKey(key, KeyInputContext.kConsumePrivate);\n}\n\n// TODO(osp) any here is a node KeyObject\nexport function preparePublicOrPrivateKey(\n  key:\n    | BinaryLike\n    | { key: any; encoding?: string; format?: any; padding?: number }\n) {\n  return prepareAsymmetricKey(key, KeyInputContext.kConsumePublic);\n}\n\n// Parses the public key encoding based on an object. keyType must be undefined\n// when this is used to parse an input encoding and must be a valid key type if\n// used to parse an output encoding.\nexport function parsePublicKeyEncoding(\n  enc: {\n    key: any;\n    encoding?: string;\n    format?: string;\n    cipher?: string;\n    passphrase?: string;\n  },\n  keyType: string | undefined,\n  objName?: string\n) {\n  return parseKeyEncoding(enc, keyType, keyType ? true : undefined, objName);\n}\n\n// Parses the private key encoding based on an object. keyType must be undefined\n// when this is used to parse an input encoding and must be a valid key type if\n// used to parse an output encoding.\nexport function parsePrivateKeyEncoding(\n  enc: {\n    key: any;\n    encoding?: string;\n    format?: string;\n    cipher?: string;\n    passphrase?: string;\n  },\n  keyType: string | undefined,\n  objName?: string\n) {\n  return parseKeyEncoding(enc, keyType, false, objName);\n}\n"]}