react-native-quick-crypto 1.0.0-beta.20 → 1.0.0-beta.22

package/lib/commonjs/keys/classes.js

@@ -4,7 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.SecretKeyObject = exports.PublicKeyObject = exports.PrivateKeyObject = exports.KeyObject = exports.CryptoKey = exports.AsymmetricKeyObject = void 0;
-var _utils = require("./utils");
+var _buffer = require("buffer");
+var _reactNativeNitroModules = require("react-native-nitro-modules");
+var _utils = require("../utils");
+var _utils2 = require("./utils");
 class CryptoKey {
   constructor(keyObject, keyAlgorithm, keyUsages, keyExtractable) {
     this.keyObject = keyObject;
@@ -48,41 +51,99 @@ class CryptoKey {
 }
 exports.CryptoKey = CryptoKey;
 class KeyObject {
-  type = 'unknown';
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   export(_options) {
-    return new ArrayBuffer(0);
+    // This is a placeholder and should be overridden by subclasses.
+    throw new Error('export() must be implemented by subclasses');
   }
-  constructor(type, handle) {
+  constructor(type, handleOrKey) {
     if (type !== 'secret' && type !== 'public' && type !== 'private') throw new Error(`invalid KeyObject type: ${type}`);
-    this.handle = handle;
+    if (handleOrKey instanceof ArrayBuffer) {
+      this.handle = _reactNativeNitroModules.NitroModules.createHybridObject('KeyObjectHandle');
+      let keyType;
+      switch (type) {
+        case 'public':
+          keyType = _utils.KeyType.PUBLIC;
+          break;
+        case 'private':
+          keyType = _utils.KeyType.PRIVATE;
+          break;
+        case 'secret':
+          keyType = _utils.KeyType.SECRET;
+          break;
+        default:
+          // Should not happen
+          throw new Error('invalid key type');
+      }
+      this.handle.init(keyType, handleOrKey);
+    } else {
+      this.handle = handleOrKey;
+    }
     this.type = type;
   }
 
-  // get type(): string {
-  //   return this.type;
-  // }
-
   // static from(key) {
   //   if (!isCryptoKey(key))
   //     throw new ERR_INVALID_ARG_TYPE('key', 'CryptoKey', key);
   //   return key[kKeyObject];
   // }
 
-  // equals(otherKeyObject) {
-  //   if (!isKeyObject(otherKeyObject)) {
-  //     throw new ERR_INVALID_ARG_TYPE(
-  //       'otherKeyObject',
-  //       'KeyObject',
-  //       otherKeyObject
-  //     );
-  //   }
+  static createKeyObject(type, key, format, encoding) {
+    if (type !== 'secret' && type !== 'public' && type !== 'private') throw new Error(`invalid KeyObject type: ${type}`);
+    const handle = _reactNativeNitroModules.NitroModules.createHybridObject('KeyObjectHandle');
+    let keyType;
+    switch (type) {
+      case 'public':
+        keyType = _utils.KeyType.PUBLIC;
+        break;
+      case 'private':
+        keyType = _utils.KeyType.PRIVATE;
+        break;
+      case 'secret':
+        keyType = _utils.KeyType.SECRET;
+        break;
+      default:
+        throw new Error('invalid key type');
+    }
 
-  //   return (
-  //     otherKeyObject.type === this.type &&
-  //     this[kHandle].equals(otherKeyObject[kHandle])
-  //   );
-  // }
+    // If format and encoding are explicitly provided, use them
+    if (format && encoding && (keyType === _utils.KeyType.PUBLIC || keyType === _utils.KeyType.PRIVATE)) {
+      const kFormat = format === 'der' ? _utils.KFormatType.DER : _utils.KFormatType.PEM;
+      const kEncoding = encoding === 'spki' ? _utils.KeyEncoding.SPKI : encoding === 'pkcs8' ? _utils.KeyEncoding.PKCS8 : encoding === 'sec1' ? _utils.KeyEncoding.SEC1 : _utils.KeyEncoding.SEC1;
+      handle.init(keyType, key, kFormat, kEncoding);
+    } else {
+      handle.init(keyType, key);
+    }
+
+    // For asymmetric keys, return the appropriate subclass
+    if (type === 'public' || type === 'private') {
+      try {
+        handle.getAsymmetricKeyType();
+        // If we get here, it's an asymmetric key - return the appropriate subclass
+        if (type === 'public') {
+          return new PublicKeyObject(handle);
+        } else {
+          return new PrivateKeyObject(handle);
+        }
+      } catch {
+        // Not an asymmetric key, fall through to regular KeyObject
+      }
+    }
+
+    // For secret keys, return SecretKeyObject
+    if (type === 'secret') {
+      return new SecretKeyObject(handle);
+    }
+
+    // Return regular KeyObject for symmetric keys or if asymmetric detection failed
+    return new KeyObject(type, handle);
+  }
+  getAsymmetricKeyType() {
+    return undefined;
+  }
+  getAsymmetricKeyDetails() {
+    return undefined;
+  }
 }
 exports.KeyObject = KeyObject;
 class SecretKeyObject extends KeyObject {
@@ -91,17 +152,15 @@ class SecretKeyObject extends KeyObject {
   }
 
   // get symmetricKeySize() {
-  //   return this[kHandle].getSymmetricKeySize();
+  //   return this.handle.getSymmetricKeySize();
   // }
 
   export(options) {
-    if (options !== undefined) {
-      if (options.format === 'jwk') {
-        throw new Error('SecretKey export for jwk is not implemented');
-        // return this.handle.exportJwk({}, false);
-      }
+    if (options?.format === 'pem' || options?.format === 'jwk') {
+      throw new Error(`SecretKey export for ${options.format} is not supported`);
     }
-    return this.handle.exportKey();
+    const key = this.handle.exportKey();
+    return _buffer.Buffer.from(key);
   }
 }
 
@@ -130,23 +189,15 @@ class AsymmetricKeyObject extends KeyObject {
     }
     return this._asymmetricKeyType;
   }
-
-  // get asymmetricKeyDetails() {
-  //   switch (this._asymmetricKeyType) {
-  //     case 'rsa':
-  //     case 'rsa-pss':
-  //     case 'dsa':
-  //     case 'ec':
-  //       return (
-  //         this[kAsymmetricKeyDetails] ||
-  //         (this[kAsymmetricKeyDetails] = normalizeKeyDetails(
-  //           this[kHandle].keyDetail({})
-  //         ))
-  //       );
-  //     default:
-  //       return {};
-  //   }
-  // }
+  get asymmetricKeyDetails() {
+    if (!this._asymmetricKeyDetails) {
+      this._asymmetricKeyDetails = this.handle.keyDetail();
+    }
+    return this._asymmetricKeyDetails;
+  }
+  get namedCurve() {
+    return this.asymmetricKeyDetails?.namedCurve;
+  }
 }
 exports.AsymmetricKeyObject = AsymmetricKeyObject;
 class PublicKeyObject extends AsymmetricKeyObject {
@@ -156,13 +207,17 @@ class PublicKeyObject extends AsymmetricKeyObject {
   export(options) {
     if (options?.format === 'jwk') {
       throw new Error('PublicKey export for jwk is not implemented');
-      // return this.handle.exportJwk({}, false);
     }
     const {
       format,
       type
-    } = (0, _utils.parsePublicKeyEncoding)(options, this.asymmetricKeyType);
-    return this.handle.exportKey(format, type);
+    } = (0, _utils2.parsePublicKeyEncoding)(options, this.asymmetricKeyType);
+    const key = this.handle.exportKey(format, type);
+    const buffer = _buffer.Buffer.from(key);
+    if (options?.format === 'pem') {
+      return buffer.toString('utf-8');
+    }
+    return buffer;
   }
 }
 exports.PublicKeyObject = PublicKeyObject;
@@ -176,15 +231,19 @@ class PrivateKeyObject extends AsymmetricKeyObject {
         throw new Error('jwk does not support encryption');
       }
       throw new Error('PrivateKey export for jwk is not implemented');
-      // return this.handle.exportJwk({}, false);
     }
     const {
       format,
       type,
       cipher,
       passphrase
-    } = (0, _utils.parsePrivateKeyEncoding)(options, this.asymmetricKeyType);
-    return this.handle.exportKey(format, type, cipher, passphrase);
+    } = (0, _utils2.parsePrivateKeyEncoding)(options, this.asymmetricKeyType);
+    const key = this.handle.exportKey(format, type, cipher, passphrase);
+    const buffer = _buffer.Buffer.from(key);
+    if (options?.format === 'pem') {
+      return buffer.toString('utf-8');
+    }
+    return buffer;
   }
 }
 exports.PrivateKeyObject = PrivateKeyObject;

package/lib/commonjs/keys/classes.js.map

@@ -1 +1 @@
-{"version":3,"names":["_utils","require","CryptoKey","constructor","keyObject","keyAlgorithm","keyUsages","keyExtractable","inspect","_depth","_options","Error","type","extractable","algorithm","usages","exports","KeyObject","export","ArrayBuffer","handle","SecretKeyObject","options","undefined","format","exportKey","AsymmetricKeyObject","asymmetricKeyType","_asymmetricKeyType","getAsymmetricKeyType","PublicKeyObject","parsePublicKeyEncoding","PrivateKeyObject","passphrase","cipher","parsePrivateKeyEncoding"],"sourceRoot":"../../../src","sources":["keys/classes.ts"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["_buffer","require","_reactNativeNitroModules","_utils","_utils2","CryptoKey","constructor","keyObject","keyAlgorithm","keyUsages","keyExtractable","inspect","_depth","_options","Error","type","extractable","algorithm","usages","exports","KeyObject","export","handleOrKey","ArrayBuffer","handle","NitroModules","createHybridObject","keyType","KeyType","PUBLIC","PRIVATE","SECRET","init","createKeyObject","key","format","encoding","kFormat","KFormatType","DER","PEM","kEncoding","KeyEncoding","SPKI","PKCS8","SEC1","getAsymmetricKeyType","PublicKeyObject","PrivateKeyObject","SecretKeyObject","undefined","getAsymmetricKeyDetails","options","exportKey","Buffer","from","AsymmetricKeyObject","asymmetricKeyType","_asymmetricKeyType","asymmetricKeyDetails","_asymmetricKeyDetails","keyDetail","namedCurve","parsePublicKeyEncoding","buffer","toString","passphrase","cipher","parsePrivateKeyEncoding"],"sourceRoot":"../../../src","sources":["keys/classes.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/keys/generateKeyPair.js

@@ -1,148 +1,102 @@
-// import { ed25519 } from '../ed25519';
-// import {
-//   kEmptyObject,
-//   validateFunction,
-//   type CryptoKeyPair,
-//   type GenerateKeyPairCallback,
-//   type GenerateKeyPairOptions,
-//   type GenerateKeyPairPromiseReturn,
-//   type GenerateKeyPairReturn,
-//   type KeyPairGenConfig,
-//   type KeyPairType,
-// } from '../utils';
-// import { parsePrivateKeyEncoding, parsePublicKeyEncoding } from './utils';
-
-// export const generateKeyPair = (
-//   type: KeyPairType,
-//   options: GenerateKeyPairOptions,
-//   callback: GenerateKeyPairCallback,
-// ): void => {
-//   validateFunction(callback);
-//   internalGenerateKeyPair(true, type, options, callback);
-// };
-
-// // Promisify generateKeyPair
-// // (attempted to use util.promisify, to no avail)
-// export const generateKeyPairPromise = (
-//   type: KeyPairType,
-//   options: GenerateKeyPairOptions,
-// ): Promise<GenerateKeyPairPromiseReturn> => {
-//   return new Promise((resolve, reject) => {
-//     generateKeyPair(type, options, (err, publicKey, privateKey) => {
-//       if (err) {
-//         reject([err, undefined]);
-//       } else {
-//         resolve([undefined, { publicKey, privateKey }]);
-//       }
-//     });
-//   });
-// };
-
-// // generateKeyPairSync
-// export function generateKeyPairSync(type: KeyPairType): CryptoKeyPair;
-// export function generateKeyPairSync(
-//   type: KeyPairType,
-//   options: GenerateKeyPairOptions,
-// ): CryptoKeyPair;
-// export function generateKeyPairSync(
-//   type: KeyPairType,
-//   options?: GenerateKeyPairOptions,
-// ): CryptoKeyPair {
-//   const [err, publicKey, privateKey] = internalGenerateKeyPair(
-//     false,
-//     type,
-//     options,
-//     undefined,
-//   )!;
-
-//   if (err) {
-//     throw err;
-//   }
-
-//   return {
-//     publicKey,
-//     privateKey,
-//   };
-// }
-
-// function parseKeyPairEncoding(
-//   keyType: string,
-//   options: GenerateKeyPairOptions = kEmptyObject,
-// ): KeyPairGenConfig {
-//   const { publicKeyEncoding, privateKeyEncoding } = options;
-
-//   let publicFormat, publicType;
-//   if (publicKeyEncoding == null) {
-//     publicFormat = publicType = -1;
-//   } else if (typeof publicKeyEncoding === 'object') {
-//     ({ format: publicFormat, type: publicType } = parsePublicKeyEncoding(
-//       publicKeyEncoding,
-//       keyType,
-//       'publicKeyEncoding',
-//     ));
-//   } else {
-//     throw new Error(
-//       'Invalid argument options.publicKeyEncoding',
-//       publicKeyEncoding,
-//     );
-//   }
-
-//   let privateFormat, privateType, cipher, passphrase;
-//   if (privateKeyEncoding == null) {
-//     privateFormat = privateType = -1;
-//   } else if (typeof privateKeyEncoding === 'object') {
-//     ({
-//       format: privateFormat,
-//       type: privateType,
-//       cipher,
-//       passphrase,
-//     } = parsePrivateKeyEncoding(
-//       privateKeyEncoding,
-//       keyType,
-//       'privateKeyEncoding',
-//     ));
-//   } else {
-//     throw new Error(
-//       'Invalid argument options.privateKeyEncoding',
-//       publicKeyEncoding as ErrorOptions,
-//     );
-//   }
-
-//   return {
-//     publicFormat,
-//     publicType,
-//     privateFormat,
-//     privateType,
-//     cipher,
-//     passphrase,
-//   };
-// }
+"use strict";
 
-// function internalGenerateKeyPair(
-//   isAsync: boolean,
-//   type: KeyPairType,
-//   options: GenerateKeyPairOptions | undefined,
-//   callback: GenerateKeyPairCallback | undefined,
-// ): GenerateKeyPairReturn | void {
-//   const encoding = parseKeyPairEncoding(type, options);
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateKeyPairPromise = exports.generateKeyPair = void 0;
+exports.generateKeyPairSync = generateKeyPairSync;
+var _ed = require("../ed");
+var _utils = require("../utils");
+var _utils2 = require("./utils");
+const generateKeyPair = (type, options, callback) => {
+  (0, _utils.validateFunction)(callback);
+  internalGenerateKeyPair(true, type, options, callback);
+};
 
-//   switch (type) {
-//     case 'ed25519':
-//     case 'ed448':
-//     case 'x25519':
-//     case 'x448': {
-//       return ed25519.utils.generateKeyPair(isAsync, type, encoding, callback);
-//     }
-//     default:
-//     // Fall through
-//   }
+// Promisify generateKeyPair
+// (attempted to use util.promisify, to no avail)
+exports.generateKeyPair = generateKeyPair;
+const generateKeyPairPromise = (type, options) => {
+  return new Promise((resolve, reject) => {
+    generateKeyPair(type, options, (err, publicKey, privateKey) => {
+      if (err) {
+        reject([err, undefined]);
+      } else {
+        resolve([undefined, {
+          publicKey,
+          privateKey
+        }]);
+      }
+    });
+  });
+};
 
-//   const err = new Error(`
-//     Invalid Argument options: '${type}' scheme not supported for
-//     generateKeyPair(). Currently not all encryption methods are supported in
-//     this library.  Check docs/implementation_coverage.md for status.
-//   `);
-//   return [err, undefined, undefined];
-// }
-"use strict";
+// generateKeyPairSync
+exports.generateKeyPairPromise = generateKeyPairPromise;
+function generateKeyPairSync(type, options) {
+  const [err, publicKey, privateKey] = internalGenerateKeyPair(false, type, options, undefined);
+  if (err) {
+    throw err;
+  }
+  return {
+    publicKey,
+    privateKey
+  };
+}
+function parseKeyPairEncoding(keyType, options = _utils.kEmptyObject) {
+  const {
+    publicKeyEncoding,
+    privateKeyEncoding
+  } = options;
+  let publicFormat, publicType;
+  if (publicKeyEncoding == null) {
+    publicFormat = publicType = -1;
+  } else if (typeof publicKeyEncoding === 'object') {
+    ({
+      format: publicFormat,
+      type: publicType
+    } = (0, _utils2.parsePublicKeyEncoding)(publicKeyEncoding, keyType, 'publicKeyEncoding'));
+  } else {
+    throw new Error('Invalid argument options.publicKeyEncoding', publicKeyEncoding);
+  }
+  let privateFormat, privateType, cipher, passphrase;
+  if (privateKeyEncoding == null) {
+    privateFormat = privateType = -1;
+  } else if (typeof privateKeyEncoding === 'object') {
+    ({
+      format: privateFormat,
+      type: privateType,
+      cipher,
+      passphrase
+    } = (0, _utils2.parsePrivateKeyEncoding)(privateKeyEncoding, keyType, 'privateKeyEncoding'));
+  } else {
+    throw new Error('Invalid argument options.privateKeyEncoding', publicKeyEncoding);
+  }
+  return {
+    publicFormat,
+    publicType,
+    privateFormat,
+    privateType,
+    cipher,
+    passphrase
+  };
+}
+function internalGenerateKeyPair(isAsync, type, options, callback) {
+  const encoding = parseKeyPairEncoding(type, options);
+  switch (type) {
+    case 'ed25519':
+    case 'ed448':
+    case 'x25519':
+    case 'x448':
+      return (0, _ed.ed_generateKeyPair)(isAsync, type, encoding, callback);
+    default:
+    // fall through
+  }
+  const err = new Error(`
+    Invalid Argument options: '${type}' scheme not supported for
+    generateKeyPair(). Currently not all encryption methods are supported in
+    this library.  Check docs/implementation_coverage.md for status.
+  `);
+  return [err, undefined, undefined];
+}
 //# sourceMappingURL=generateKeyPair.js.map

package/lib/commonjs/keys/generateKeyPair.js.map

@@ -1 +1 @@
-{"version":3,"names":[],"sourceRoot":"../../../src","sources":["keys/generateKeyPair.ts"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA","ignoreList":[]}
+{"version":3,"names":["_ed","require","_utils","_utils2","generateKeyPair","type","options","callback","validateFunction","internalGenerateKeyPair","exports","generateKeyPairPromise","Promise","resolve","reject","err","publicKey","privateKey","undefined","generateKeyPairSync","parseKeyPairEncoding","keyType","kEmptyObject","publicKeyEncoding","privateKeyEncoding","publicFormat","publicType","format","parsePublicKeyEncoding","Error","privateFormat","privateType","cipher","passphrase","parsePrivateKeyEncoding","isAsync","encoding","ed_generateKeyPair"],"sourceRoot":"../../../src","sources":["keys/generateKeyPair.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/keys/index.js

@@ -3,6 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+Object.defineProperty(exports, "AsymmetricKeyObject", {
+  enumerable: true,
+  get: function () {
+    return _classes.AsymmetricKeyObject;
+  }
+});
 Object.defineProperty(exports, "CryptoKey", {
   enumerable: true,
   get: function () {
@@ -33,6 +39,19 @@ Object.defineProperty(exports, "SecretKeyObject", {
     return _classes.SecretKeyObject;
   }
 });
+exports.createSecretKey = createSecretKey;
+Object.defineProperty(exports, "generateKeyPair", {
+  enumerable: true,
+  get: function () {
+    return _generateKeyPair.generateKeyPair;
+  }
+});
+Object.defineProperty(exports, "generateKeyPairSync", {
+  enumerable: true,
+  get: function () {
+    return _generateKeyPair.generateKeyPairSync;
+  }
+});
 Object.defineProperty(exports, "isCryptoKey", {
   enumerable: true,
   get: function () {
@@ -58,5 +77,13 @@ Object.defineProperty(exports, "parsePublicKeyEncoding", {
   }
 });
 var _classes = require("./classes");
+var _generateKeyPair = require("./generateKeyPair");
 var _utils = require("./utils");
+var _utils2 = require("../utils");
+// import { sign, verify } from './signVerify';
+
+function createSecretKey(key) {
+  const keyBuffer = (0, _utils2.binaryLikeToArrayBuffer)(key);
+  return _classes.KeyObject.createKeyObject('secret', keyBuffer);
+}
 //# sourceMappingURL=index.js.map

package/lib/commonjs/keys/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_classes","require","_utils"],"sourceRoot":"../../../src","sources":["keys/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,QAAA,GAAAC,OAAA;AASA,IAAAC,MAAA,GAAAD,OAAA","ignoreList":[]}
+{"version":3,"names":["_classes","require","_generateKeyPair","_utils","_utils2","createSecretKey","key","keyBuffer","toAB","KeyObject","createKeyObject"],"sourceRoot":"../../../src","sources":["keys/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,QAAA,GAAAC,OAAA;AAQA,IAAAC,gBAAA,GAAAD,OAAA;AAEA,IAAAE,MAAA,GAAAF,OAAA;AAOA,IAAAG,OAAA,GAAAH,OAAA;AARA;;AAUA,SAASI,eAAeA,CAACC,GAAe,EAAmB;EACzD,MAAMC,SAAS,GAAG,IAAAC,+BAAI,EAACF,GAAG,CAAC;EAC3B,OAAOG,kBAAS,CAACC,eAAe,CAAC,QAAQ,EAAEH,SAAS,CAAC;AACvD","ignoreList":[]}