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

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":[]}

package/lib/commonjs/keys/utils.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.getCryptoKeyPair = getCryptoKeyPair;
 exports.isCryptoKey = void 0;
 exports.parseKeyEncoding = parseKeyEncoding;
 exports.parsePrivateKeyEncoding = parsePrivateKeyEncoding;
@@ -12,13 +13,17 @@ var _utils = require("../utils");
 const isCryptoKey = obj => {
   return obj !== null && obj?.keyObject !== undefined;
 };
+exports.isCryptoKey = isCryptoKey;
+function getCryptoKeyPair(key) {
+  if ('publicKey' in key && 'privateKey' in key) return key;
+  throw new Error('Invalid CryptoKeyPair');
+}
 
 /**
  * Parses the public key encoding based on an object. keyType must be undefined
  * when this is used to parse an input encoding and must be a valid key type if
  * used to parse an output encoding.
  */
-exports.isCryptoKey = isCryptoKey;
 function parsePublicKeyEncoding(enc, keyType, objName) {
   return parseKeyEncoding(enc, keyType, keyType ? true : undefined, objName);
 }
@@ -49,7 +54,7 @@ function parseKeyEncoding(enc, keyType, isPublic, objName) {
     if (!isInput) {
       if (cipher != null) {
         if (typeof cipher !== 'string') throw new Error(`Invalid argument ${option('cipher', objName)}: ${cipher}`);
-        if (format === _utils.KFormatType.kKeyFormatDER && (type === _utils.KeyEncoding.kKeyEncodingPKCS1 || type === _utils.KeyEncoding.kKeyEncodingSEC1)) {
+        if (format === _utils.KFormatType.DER && (type === _utils.KeyEncoding.PKCS1 || type === _utils.KeyEncoding.SEC1)) {
           throw new Error(`Incompatible key options ${encodingNames[type]} does not support encryption`);
         }
       } else if (passphrase !== undefined) {
@@ -69,16 +74,16 @@ function parseKeyEncoding(enc, keyType, isPublic, objName) {
   };
 }
 const encodingNames = {
-  [_utils.KeyEncoding.kKeyEncodingPKCS1]: 'pkcs1',
-  [_utils.KeyEncoding.kKeyEncodingPKCS8]: 'pkcs8',
-  [_utils.KeyEncoding.kKeyEncodingSPKI]: 'spki',
-  [_utils.KeyEncoding.kKeyEncodingSEC1]: 'sec1'
+  [_utils.KeyEncoding.PKCS1]: 'pkcs1',
+  [_utils.KeyEncoding.PKCS8]: 'pkcs8',
+  [_utils.KeyEncoding.SPKI]: 'spki',
+  [_utils.KeyEncoding.SEC1]: 'sec1'
 };
 function option(name, objName) {
   return objName === undefined ? `options.${name}` : `options.${objName}.${name}`;
 }
 function parseKeyFormat(formatStr, defaultFormat, optionName) {
-  if (formatStr === undefined && defaultFormat !== undefined) return defaultFormat;else if (formatStr === 'pem') return _utils.KFormatType.kKeyFormatPEM;else if (formatStr === 'der') return _utils.KFormatType.kKeyFormatDER;else if (formatStr === 'jwk') return _utils.KFormatType.kKeyFormatJWK;
+  if (formatStr === undefined && defaultFormat !== undefined) return defaultFormat;else if (formatStr === 'pem') return _utils.KFormatType.PEM;else if (formatStr === 'der') return _utils.KFormatType.DER;else if (formatStr === 'jwk') return _utils.KFormatType.JWK;
   throw new Error(`Invalid key format str: ${optionName}`);
 }
 function parseKeyType(typeStr, required, keyType, isPublic, optionName) {
@@ -88,16 +93,16 @@ function parseKeyType(typeStr, required, keyType, isPublic, optionName) {
     if (keyType !== undefined && keyType !== 'rsa') {
       throw new Error(`Crypto incompatible key options: ${typeStr} can only be used for RSA keys`);
     }
-    return _utils.KeyEncoding.kKeyEncodingPKCS1;
+    return _utils.KeyEncoding.PKCS1;
   } else if (typeStr === 'spki' && isPublic !== false) {
-    return _utils.KeyEncoding.kKeyEncodingSPKI;
+    return _utils.KeyEncoding.SPKI;
   } else if (typeStr === 'pkcs8' && isPublic !== true) {
-    return _utils.KeyEncoding.kKeyEncodingPKCS8;
+    return _utils.KeyEncoding.PKCS8;
   } else if (typeStr === 'sec1' && isPublic !== true) {
     if (keyType !== undefined && keyType !== 'ec') {
       throw new Error(`Incompatible key options ${typeStr} can only be used for EC keys`);
     }
-    return _utils.KeyEncoding.kKeyEncodingSEC1;
+    return _utils.KeyEncoding.SEC1;
   }
   throw new Error(`Invalid option ${optionName} - ${typeStr}`);
 }
@@ -107,8 +112,8 @@ function parseKeyFormatAndType(enc, keyType, isPublic, objName) {
     type: typeStr
   } = enc;
   const isInput = keyType === undefined;
-  const format = parseKeyFormat(formatStr, isInput ? _utils.KFormatType.kKeyFormatPEM : undefined, option('format', objName));
-  const isRequired = (!isInput || format === _utils.KFormatType.kKeyFormatDER) && format !== _utils.KFormatType.kKeyFormatJWK;
+  const format = parseKeyFormat(formatStr, isInput ? _utils.KFormatType.PEM : undefined, option('format', objName));
+  const isRequired = (!isInput || format === _utils.KFormatType.DER) && format !== _utils.KFormatType.JWK;
   const type = parseKeyType(typeStr, isRequired, keyType, isPublic, option('type', objName));
   return {
     format,

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

@@ -1 +1 @@
-{"version":3,"names":["_utils","require","isCryptoKey","obj","keyObject","undefined","exports","parsePublicKeyEncoding","enc","keyType","objName","parseKeyEncoding","parsePrivateKeyEncoding","isPublic","isInput","format","type","parseKeyFormatAndType","cipher","passphrase","encoding","Error","option","KFormatType","kKeyFormatDER","KeyEncoding","kKeyEncodingPKCS1","kKeyEncodingSEC1","encodingNames","isStringOrBuffer","binaryLikeToArrayBuffer","kKeyEncodingPKCS8","kKeyEncodingSPKI","name","parseKeyFormat","formatStr","defaultFormat","optionName","kKeyFormatPEM","kKeyFormatJWK","parseKeyType","typeStr","required","isRequired"],"sourceRoot":"../../../src","sources":["keys/utils.ts"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["_utils","require","isCryptoKey","obj","keyObject","undefined","exports","getCryptoKeyPair","key","Error","parsePublicKeyEncoding","enc","keyType","objName","parseKeyEncoding","parsePrivateKeyEncoding","isPublic","isInput","format","type","parseKeyFormatAndType","cipher","passphrase","encoding","option","KFormatType","DER","KeyEncoding","PKCS1","SEC1","encodingNames","isStringOrBuffer","binaryLikeToArrayBuffer","PKCS8","SPKI","name","parseKeyFormat","formatStr","defaultFormat","optionName","PEM","JWK","parseKeyType","typeStr","required","isRequired"],"sourceRoot":"../../../src","sources":["keys/utils.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/rsa.js

@@ -0,0 +1,129 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Rsa = void 0;
+exports.rsa_generateKeyPair = rsa_generateKeyPair;
+var _reactNativeNitroModules = require("react-native-nitro-modules");
+var _keys = require("./keys");
+var _utils = require("./utils");
+class Rsa {
+  constructor(modulusLength, publicExponent, hashAlgorithm) {
+    this.native = _reactNativeNitroModules.NitroModules.createHybridObject('RsaKeyPair');
+    this.native.setModulusLength(modulusLength);
+    this.native.setPublicExponent(publicExponent.buffer.slice(publicExponent.byteOffset, publicExponent.byteOffset + publicExponent.byteLength));
+    this.native.setHashAlgorithm(hashAlgorithm);
+  }
+  async generateKeyPair() {
+    await this.native.generateKeyPair();
+    return {
+      publicKey: this.native.getPublicKey(),
+      privateKey: this.native.getPrivateKey()
+    };
+  }
+  generateKeyPairSync() {
+    this.native.generateKeyPairSync();
+    return {
+      publicKey: this.native.getPublicKey(),
+      privateKey: this.native.getPrivateKey()
+    };
+  }
+}
+
+// Node API
+exports.Rsa = Rsa;
+async function rsa_generateKeyPair(algorithm, extractable, keyUsages) {
+  const {
+    name,
+    modulusLength,
+    publicExponent,
+    hash
+  } = algorithm;
+
+  // Validate parameters first
+  if (!modulusLength || modulusLength < 256) {
+    throw (0, _utils.lazyDOMException)('Invalid key length', 'OperationError');
+  }
+  if (!publicExponent || publicExponent.length === 0) {
+    throw (0, _utils.lazyDOMException)('Invalid public exponent', 'OperationError');
+  }
+
+  // Validate hash algorithm using existing validation function
+  let hashName;
+  try {
+    const normalizedHash = (0, _utils.normalizeHashName)(hash);
+    hashName = typeof hash === 'string' ? hash : hash?.name || normalizedHash;
+  } catch {
+    throw (0, _utils.lazyDOMException)('Invalid Hash Algorithm', 'NotSupportedError');
+  }
+
+  // Validate usages are not empty
+  if (keyUsages.length === 0) {
+    throw (0, _utils.lazyDOMException)('Usages cannot be empty', 'SyntaxError');
+  }
+
+  // Usage validation based on algorithm type
+  switch (name) {
+    case 'RSASSA-PKCS1-v1_5':
+      if ((0, _utils.hasAnyNotIn)(keyUsages, ['sign', 'verify'])) {
+        throw (0, _utils.lazyDOMException)(`Unsupported key usage for a ${name} key`, 'SyntaxError');
+      }
+      break;
+    case 'RSA-PSS':
+      if ((0, _utils.hasAnyNotIn)(keyUsages, ['sign', 'verify'])) {
+        throw (0, _utils.lazyDOMException)(`Unsupported key usage for a ${name} key`, 'SyntaxError');
+      }
+      break;
+    case 'RSA-OAEP':
+      if ((0, _utils.hasAnyNotIn)(keyUsages, ['encrypt', 'decrypt', 'wrapKey', 'unwrapKey'])) {
+        throw (0, _utils.lazyDOMException)(`Unsupported key usage for a ${name} key`, 'SyntaxError');
+      }
+      break;
+    default:
+      throw (0, _utils.lazyDOMException)('The algorithm is not supported', 'NotSupportedError');
+  }
+
+  // Split usages between public and private keys
+  let publicUsages = [];
+  let privateUsages = [];
+  switch (name) {
+    case 'RSASSA-PKCS1-v1_5':
+    case 'RSA-PSS':
+      publicUsages = (0, _utils.getUsagesUnion)(keyUsages, 'verify');
+      privateUsages = (0, _utils.getUsagesUnion)(keyUsages, 'sign');
+      break;
+    case 'RSA-OAEP':
+      publicUsages = (0, _utils.getUsagesUnion)(keyUsages, 'encrypt', 'wrapKey');
+      privateUsages = (0, _utils.getUsagesUnion)(keyUsages, 'decrypt', 'unwrapKey');
+      break;
+  }
+
+  // Validate that private key has usages for CryptoKeyPair
+  if (privateUsages.length === 0) {
+    throw (0, _utils.lazyDOMException)('Usages cannot be empty', 'SyntaxError');
+  }
+  const rsa = new Rsa(modulusLength, publicExponent, hashName);
+  await rsa.generateKeyPair();
+  const keyAlgorithm = {
+    name,
+    modulusLength,
+    publicExponent,
+    hash: {
+      name: hashName
+    }
+  };
+
+  // Create KeyObject instances using the standard createKeyObject method
+  const publicKeyData = rsa.native.getPublicKey();
+  const pub = _keys.KeyObject.createKeyObject('public', publicKeyData);
+  const publicKey = new _keys.CryptoKey(pub, keyAlgorithm, publicUsages, true);
+  const privateKeyData = rsa.native.getPrivateKey();
+  const priv = _keys.KeyObject.createKeyObject('private', privateKeyData);
+  const privateKey = new _keys.CryptoKey(priv, keyAlgorithm, privateUsages, extractable);
+  return {
+    publicKey,
+    privateKey
+  };
+}
+//# sourceMappingURL=rsa.js.map

package/lib/commonjs/rsa.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNativeNitroModules","require","_keys","_utils","Rsa","constructor","modulusLength","publicExponent","hashAlgorithm","native","NitroModules","createHybridObject","setModulusLength","setPublicExponent","buffer","slice","byteOffset","byteLength","setHashAlgorithm","generateKeyPair","publicKey","getPublicKey","privateKey","getPrivateKey","generateKeyPairSync","exports","rsa_generateKeyPair","algorithm","extractable","keyUsages","name","hash","lazyDOMException","length","hashName","normalizedHash","normalizeHashName","hasAnyNotIn","publicUsages","privateUsages","getUsagesUnion","rsa","keyAlgorithm","publicKeyData","pub","KeyObject","createKeyObject","CryptoKey","privateKeyData","priv"],"sourceRoot":"../../src","sources":["rsa.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/specs/blake3.nitro.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=blake3.nitro.js.map

package/lib/commonjs/specs/blake3.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["specs/blake3.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/commonjs/specs/ecKeyPair.nitro.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=ecKeyPair.nitro.js.map

package/lib/commonjs/specs/ecKeyPair.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["specs/ecKeyPair.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/commonjs/specs/rsaKeyPair.nitro.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=rsaKeyPair.nitro.js.map

package/lib/commonjs/specs/rsaKeyPair.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["specs/rsaKeyPair.nitro.ts"],"mappings":"","ignoreList":[]}