react-native-quick-crypto 1.0.0-beta.8 → 1.0.0

package/lib/commonjs/keys/generateKeyPair.js

@@ -1,148 +1,145 @@
-// 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 _rsa = require("../rsa");
+var _ec = require("../ec");
+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);
+    case 'rsa':
+    case 'rsa-pss':
+    case 'dsa':
+    case 'ec':
+      break;
+    default:
+      {
+        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];
+      }
+  }
+  if (isAsync) {
+    const impl = async () => {
+      try {
+        let result;
+        if (type === 'rsa' || type === 'rsa-pss') {
+          result = await (0, _rsa.rsa_generateKeyPairNode)(type, options, encoding);
+        } else if (type === 'ec') {
+          result = await (0, _ec.ec_generateKeyPairNode)(options, encoding);
+        } else {
+          throw new Error(`Unsupported key type: ${type}`);
+        }
+        return [undefined, result.publicKey, result.privateKey];
+      } catch (error) {
+        return [error, undefined, undefined];
+      }
+    };
+    impl().then(result => {
+      const [err, publicKey, privateKey] = result;
+      callback(err, publicKey, privateKey);
+    });
+    return;
+  }
+  try {
+    let result;
+    if (type === 'rsa' || type === 'rsa-pss') {
+      result = (0, _rsa.rsa_generateKeyPairNodeSync)(type, options, encoding);
+    } else if (type === 'ec') {
+      result = (0, _ec.ec_generateKeyPairNodeSync)(options, encoding);
+    } else {
+      throw new Error(`Unsupported key type: ${type}`);
+    }
+    return [undefined, result.publicKey, result.privateKey];
+  } catch (error) {
+    return [error, 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","_rsa","_ec","_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","impl","result","rsa_generateKeyPairNode","ec_generateKeyPairNode","error","then","rsa_generateKeyPairNodeSync","ec_generateKeyPairNodeSync"],"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,47 @@ Object.defineProperty(exports, "SecretKeyObject", {
     return _classes.SecretKeyObject;
   }
 });
+Object.defineProperty(exports, "Sign", {
+  enumerable: true,
+  get: function () {
+    return _signVerify.Sign;
+  }
+});
+Object.defineProperty(exports, "Verify", {
+  enumerable: true,
+  get: function () {
+    return _signVerify.Verify;
+  }
+});
+exports.createPrivateKey = createPrivateKey;
+exports.createPublicKey = createPublicKey;
+exports.createSecretKey = createSecretKey;
+Object.defineProperty(exports, "createSign", {
+  enumerable: true,
+  get: function () {
+    return _signVerify.createSign;
+  }
+});
+Object.defineProperty(exports, "createVerify", {
+  enumerable: true,
+  get: function () {
+    return _signVerify.createVerify;
+  }
+});
+exports.generateKey = generateKey;
+Object.defineProperty(exports, "generateKeyPair", {
+  enumerable: true,
+  get: function () {
+    return _generateKeyPair.generateKeyPair;
+  }
+});
+Object.defineProperty(exports, "generateKeyPairSync", {
+  enumerable: true,
+  get: function () {
+    return _generateKeyPair.generateKeyPairSync;
+  }
+});
+exports.generateKeySync = generateKeySync;
 Object.defineProperty(exports, "isCryptoKey", {
   enumerable: true,
   get: function () {
@@ -57,6 +104,188 @@ Object.defineProperty(exports, "parsePublicKeyEncoding", {
     return _utils.parsePublicKeyEncoding;
   }
 });
+Object.defineProperty(exports, "privateDecrypt", {
+  enumerable: true,
+  get: function () {
+    return _publicCipher.privateDecrypt;
+  }
+});
+Object.defineProperty(exports, "privateEncrypt", {
+  enumerable: true,
+  get: function () {
+    return _publicCipher.privateEncrypt;
+  }
+});
+Object.defineProperty(exports, "publicDecrypt", {
+  enumerable: true,
+  get: function () {
+    return _publicCipher.publicDecrypt;
+  }
+});
+Object.defineProperty(exports, "publicEncrypt", {
+  enumerable: true,
+  get: function () {
+    return _publicCipher.publicEncrypt;
+  }
+});
 var _classes = require("./classes");
+var _generateKeyPair = require("./generateKeyPair");
+var _signVerify = require("./signVerify");
+var _publicCipher = require("./publicCipher");
 var _utils = require("./utils");
+var _utils2 = require("../utils");
+var _random = require("../random");
+function createSecretKey(key) {
+  const keyBuffer = (0, _utils2.binaryLikeToArrayBuffer)(key);
+  return _classes.KeyObject.createKeyObject('secret', keyBuffer);
+}
+function prepareAsymmetricKey(key, isPublic) {
+  if (key instanceof _classes.KeyObject) {
+    if (isPublic) {
+      // createPublicKey can accept either a public key or extract public from private
+      if (key.type === 'secret') {
+        throw new Error('Cannot create public key from secret key');
+      }
+      // Export as SPKI (public key format) - works for both public and private keys
+      const exported = key.handle.exportKey(_utils2.KFormatType.DER, _utils2.KeyEncoding.SPKI);
+      return {
+        data: exported,
+        format: 'der',
+        type: 'spki'
+      };
+    } else {
+      // createPrivateKey requires a private key
+      if (key.type !== 'private') {
+        throw new Error('Key must be a private key');
+      }
+      const exported = key.handle.exportKey(_utils2.KFormatType.DER, _utils2.KeyEncoding.PKCS8);
+      return {
+        data: exported,
+        format: 'der',
+        type: 'pkcs8'
+      };
+    }
+  }
+  if ((0, _utils.isCryptoKey)(key)) {
+    const cryptoKey = key;
+    return prepareAsymmetricKey(cryptoKey.keyObject, isPublic);
+  }
+  if ((0, _utils2.isStringOrBuffer)(key)) {
+    // Detect PEM format from string content
+    const isPem = typeof key === 'string' && key.includes('-----BEGIN');
+    return {
+      data: (0, _utils2.binaryLikeToArrayBuffer)(key),
+      format: isPem ? 'pem' : undefined
+    };
+  }
+  if (typeof key === 'object' && 'key' in key) {
+    const keyObj = key;
+    const {
+      key: data,
+      format,
+      type
+    } = keyObj;
+    if (data instanceof _classes.KeyObject) {
+      return prepareAsymmetricKey(data, isPublic);
+    }
+    if ((0, _utils.isCryptoKey)(data)) {
+      return prepareAsymmetricKey(data.keyObject, isPublic);
+    }
+    if (!(0, _utils2.isStringOrBuffer)(data)) {
+      throw new Error('Invalid key data type');
+    }
+
+    // For PEM format with string data, convert to ArrayBuffer
+    if ((format === 'pem' || typeof data === 'string' && data.includes('-----BEGIN')) && typeof data === 'string') {
+      return {
+        data: (0, _utils2.binaryLikeToArrayBuffer)(data),
+        format: 'pem',
+        type
+      };
+    }
+
+    // Filter out 'jwk' format - only 'pem' and 'der' are supported here
+    const filteredFormat = format === 'jwk' ? undefined : format;
+    return {
+      data: (0, _utils2.binaryLikeToArrayBuffer)(data),
+      format: filteredFormat,
+      type
+    };
+  }
+  throw new Error('Invalid key input');
+}
+function createPublicKey(key) {
+  const {
+    data,
+    format,
+    type
+  } = prepareAsymmetricKey(key, true);
+
+  // Map format string to KFormatType enum
+  let kFormat;
+  if (format === 'pem') kFormat = _utils2.KFormatType.PEM;else if (format === 'der') kFormat = _utils2.KFormatType.DER;
+
+  // Map type string to KeyEncoding enum
+  let kType;
+  if (type === 'spki') kType = _utils2.KeyEncoding.SPKI;else if (type === 'pkcs1') kType = _utils2.KeyEncoding.PKCS1;
+  return _classes.KeyObject.createKeyObject('public', data, kFormat, kType);
+}
+function createPrivateKey(key) {
+  const {
+    data,
+    format,
+    type
+  } = prepareAsymmetricKey(key, false);
+
+  // Map format string to KFormatType enum
+  let kFormat;
+  if (format === 'pem') kFormat = _utils2.KFormatType.PEM;else if (format === 'der') kFormat = _utils2.KFormatType.DER;
+
+  // Map type string to KeyEncoding enum
+  let kType;
+  if (type === 'pkcs8') kType = _utils2.KeyEncoding.PKCS8;else if (type === 'pkcs1') kType = _utils2.KeyEncoding.PKCS1;else if (type === 'sec1') kType = _utils2.KeyEncoding.SEC1;
+  return _classes.KeyObject.createKeyObject('private', data, kFormat, kType);
+}
+function generateKeySync(type, options) {
+  if (typeof type !== 'string') {
+    throw new TypeError('The "type" argument must be a string');
+  }
+  if (typeof options !== 'object' || options === null) {
+    throw new TypeError('The "options" argument must be an object');
+  }
+  const {
+    length
+  } = options;
+  if (typeof length !== 'number' || !Number.isInteger(length)) {
+    throw new TypeError('The "options.length" property must be an integer');
+  }
+  switch (type) {
+    case 'hmac':
+      if (length < 8 || length > 2 ** 31 - 1) {
+        throw new RangeError('The "options.length" property must be >= 8 and <= 2147483647');
+      }
+      break;
+    case 'aes':
+      if (length !== 128 && length !== 192 && length !== 256) {
+        throw new RangeError('The "options.length" property must be 128, 192, or 256');
+      }
+      break;
+    default:
+      throw new TypeError(`The "type" argument must be 'aes' or 'hmac'. Received '${type}'`);
+  }
+  const keyBytes = length / 8;
+  const keyMaterial = (0, _random.randomBytes)(keyBytes);
+  return createSecretKey(keyMaterial);
+}
+function generateKey(type, options, callback) {
+  if (typeof callback !== 'function') {
+    throw new TypeError('The "callback" argument must be a function');
+  }
+  try {
+    const key = generateKeySync(type, options);
+    process.nextTick(callback, null, key);
+  } catch (err) {
+    process.nextTick(callback, err);
+  }
+}
 //# 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","_signVerify","_publicCipher","_utils","_utils2","_random","createSecretKey","key","keyBuffer","toAB","KeyObject","createKeyObject","prepareAsymmetricKey","isPublic","type","Error","exported","handle","exportKey","KFormatType","DER","KeyEncoding","SPKI","data","format","PKCS8","isCryptoKey","cryptoKey","keyObject","isStringOrBuffer","isPem","includes","undefined","keyObj","filteredFormat","createPublicKey","kFormat","PEM","kType","PKCS1","createPrivateKey","SEC1","generateKeySync","options","TypeError","length","Number","isInteger","RangeError","keyBytes","keyMaterial","randomBytes","generateKey","callback","process","nextTick","err"],"sourceRoot":"../../../src","sources":["keys/index.ts"],"mappings":"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","ignoreList":[]}