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

package/src/keys/classes.ts

@@ -1,10 +1,14 @@
-import type { KeyObjectHandle } from '../specs/keyObjectHandle.nitro';
+import { Buffer } from 'buffer';
+import { NitroModules } from 'react-native-nitro-modules';
 import type {
   AsymmetricKeyType,
   EncodingOptions,
+  KeyDetail,
+  KeyObjectHandle,
   KeyUsage,
   SubtleAlgorithm,
 } from '../utils';
+import { KeyType, KFormatType, KeyEncoding } from '../utils';
 import { parsePrivateKeyEncoding, parsePublicKeyEncoding } from './utils';
 
 export class CryptoKey {
@@ -65,22 +69,46 @@ export class CryptoKey {
 
 export class KeyObject {
   handle: KeyObjectHandle;
-  type: 'public' | 'secret' | 'private' | 'unknown' = 'unknown';
+  type: 'public' | 'secret' | 'private';
+  export(options: { format: 'pem' } & EncodingOptions): string | Buffer;
+  export(options?: { format: 'der' } & EncodingOptions): Buffer;
+  export(options?: { format: 'jwk' } & EncodingOptions): never;
+  export(options?: EncodingOptions): string | Buffer;
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  export(_options?: EncodingOptions): ArrayBuffer {
-    return new ArrayBuffer(0);
+  export(_options?: EncodingOptions): string | Buffer {
+    // This is a placeholder and should be overridden by subclasses.
+    throw new Error('export() must be implemented by subclasses');
   }
 
-  constructor(type: string, handle: KeyObjectHandle) {
+  constructor(type: string, handle: KeyObjectHandle);
+  constructor(type: string, key: ArrayBuffer);
+  constructor(type: string, handleOrKey: KeyObjectHandle | ArrayBuffer) {
     if (type !== 'secret' && type !== 'public' && type !== 'private')
       throw new Error(`invalid KeyObject type: ${type}`);
-    this.handle = handle;
-    this.type = type;
-  }
 
-  // get type(): string {
-  //   return this.type;
-  // }
+    if (handleOrKey instanceof ArrayBuffer) {
+      this.handle = NitroModules.createHybridObject('KeyObjectHandle');
+      let keyType: KeyType;
+      switch (type) {
+        case 'public':
+          keyType = KeyType.PUBLIC;
+          break;
+        case 'private':
+          keyType = KeyType.PRIVATE;
+          break;
+        case 'secret':
+          keyType = 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 as 'public' | 'secret' | 'private';
+  }
 
   // static from(key) {
   //   if (!isCryptoKey(key))
@@ -88,20 +116,71 @@ export class KeyObject {
   //   return key[kKeyObject];
   // }
 
-  // equals(otherKeyObject) {
-  //   if (!isKeyObject(otherKeyObject)) {
-  //     throw new ERR_INVALID_ARG_TYPE(
-  //       'otherKeyObject',
-  //       'KeyObject',
-  //       otherKeyObject
-  //     );
-  //   }
-
-  //   return (
-  //     otherKeyObject.type === this.type &&
-  //     this[kHandle].equals(otherKeyObject[kHandle])
-  //   );
-  // }
+  static createKeyObject(
+    type: string,
+    key: ArrayBuffer,
+    format?: KFormatType,
+    encoding?: KeyEncoding,
+  ): KeyObject {
+    if (type !== 'secret' && type !== 'public' && type !== 'private')
+      throw new Error(`invalid KeyObject type: ${type}`);
+
+    const handle = NitroModules.createHybridObject(
+      'KeyObjectHandle',
+    ) as KeyObjectHandle;
+    let keyType: KeyType;
+    switch (type) {
+      case 'public':
+        keyType = KeyType.PUBLIC;
+        break;
+      case 'private':
+        keyType = KeyType.PRIVATE;
+        break;
+      case 'secret':
+        keyType = KeyType.SECRET;
+        break;
+      default:
+        throw new Error('invalid key type');
+    }
+
+    // If format is provided, use it (encoding is optional)
+    if (format !== undefined) {
+      handle.init(keyType, key, format, encoding);
+    } 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(): undefined {
+    return undefined;
+  }
+
+  getAsymmetricKeyDetails(): undefined {
+    return undefined;
+  }
 }
 
 export class SecretKeyObject extends KeyObject {
@@ -110,17 +189,21 @@ export class SecretKeyObject extends KeyObject {
   }
 
   // get symmetricKeySize() {
-  //   return this[kHandle].getSymmetricKeySize();
+  //   return this.handle.getSymmetricKeySize();
   // }
 
-  export(options?: EncodingOptions) {
-    if (options !== undefined) {
-      if (options.format === 'jwk') {
-        throw new Error('SecretKey export for jwk is not implemented');
-        // return this.handle.exportJwk({}, false);
-      }
+  export(options: { format: 'pem' } & EncodingOptions): never;
+  export(options: { format: 'der' } & EncodingOptions): Buffer;
+  export(options: { format: 'jwk' } & EncodingOptions): never;
+  export(options?: EncodingOptions): Buffer;
+  export(options?: EncodingOptions): Buffer {
+    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.from(key);
   }
 }
 
@@ -153,22 +236,18 @@ export 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 {};
-  //   }
-  // }
+  private _asymmetricKeyDetails?: KeyDetail;
+
+  get asymmetricKeyDetails() {
+    if (!this._asymmetricKeyDetails) {
+      this._asymmetricKeyDetails = this.handle.keyDetail();
+    }
+    return this._asymmetricKeyDetails;
+  }
+
+  get namedCurve(): string | undefined {
+    return this.asymmetricKeyDetails?.namedCurve;
+  }
 }
 
 export class PublicKeyObject extends AsymmetricKeyObject {
@@ -176,16 +255,23 @@ export class PublicKeyObject extends AsymmetricKeyObject {
     super('public', handle);
   }
 
-  export(options: EncodingOptions) {
+  export(options: { format: 'pem' } & EncodingOptions): string;
+  export(options: { format: 'der' } & EncodingOptions): Buffer;
+  export(options: { format: 'jwk' } & EncodingOptions): never;
+  export(options: EncodingOptions): string | Buffer {
     if (options?.format === 'jwk') {
       throw new Error('PublicKey export for jwk is not implemented');
-      // return this.handle.exportJwk({}, false);
     }
     const { format, type } = parsePublicKeyEncoding(
       options,
       this.asymmetricKeyType,
     );
-    return this.handle.exportKey(format, type);
+    const key = this.handle.exportKey(format, type);
+    const buffer = Buffer.from(key);
+    if (options?.format === 'pem') {
+      return buffer.toString('utf-8');
+    }
+    return buffer;
   }
 }
 
@@ -194,18 +280,25 @@ export class PrivateKeyObject extends AsymmetricKeyObject {
     super('private', handle);
   }
 
-  export(options: EncodingOptions) {
+  export(options: { format: 'pem' } & EncodingOptions): string;
+  export(options: { format: 'der' } & EncodingOptions): Buffer;
+  export(options: { format: 'jwk' } & EncodingOptions): never;
+  export(options: EncodingOptions): string | Buffer {
     if (options?.format === 'jwk') {
       if (options.passphrase !== undefined) {
         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 } = parsePrivateKeyEncoding(
       options,
       this.asymmetricKeyType,
     );
-    return this.handle.exportKey(format, type, cipher, passphrase);
+    const key = this.handle.exportKey(format, type, cipher, passphrase);
+    const buffer = Buffer.from(key);
+    if (options?.format === 'pem') {
+      return buffer.toString('utf-8');
+    }
+    return buffer;
   }
 }

package/src/keys/generateKeyPair.ts

@@ -1,146 +1,189 @@
-// 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';
+import { ed_generateKeyPair } from '../ed';
+import { rsa_generateKeyPairNode, rsa_generateKeyPairNodeSync } from '../rsa';
+import { ec_generateKeyPairNode, ec_generateKeyPairNodeSync } from '../ec';
+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);
-// };
+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 }]);
-//       }
-//     });
-//   });
-// };
+// 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,
-//   )!;
+// 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;
-//   }
+  if (err) {
+    throw err;
+  }
 
-//   return {
-//     publicKey,
-//     privateKey,
-//   };
-// }
+  return {
+    publicKey,
+    privateKey,
+  };
+}
 
-// function parseKeyPairEncoding(
-//   keyType: string,
-//   options: GenerateKeyPairOptions = kEmptyObject,
-// ): KeyPairGenConfig {
-//   const { publicKeyEncoding, privateKeyEncoding } = options;
+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 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,
-//     );
-//   }
+  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,
-//   };
-// }
+  return {
+    publicFormat,
+    publicType,
+    privateFormat,
+    privateType,
+    cipher,
+    passphrase,
+  };
+}
 
-// function internalGenerateKeyPair(
-//   isAsync: boolean,
-//   type: KeyPairType,
-//   options: GenerateKeyPairOptions | undefined,
-//   callback: GenerateKeyPairCallback | undefined,
-// ): GenerateKeyPairReturn | void {
-//   const encoding = parseKeyPairEncoding(type, options);
+function internalGenerateKeyPair(
+  isAsync: boolean,
+  type: KeyPairType,
+  options: GenerateKeyPairOptions | undefined,
+  callback: GenerateKeyPairCallback | undefined,
+): GenerateKeyPairReturn | void {
+  const encoding = parseKeyPairEncoding(type, options);
 
-//   switch (type) {
-//     case 'ed25519':
-//     case 'ed448':
-//     case 'x25519':
-//     case 'x448': {
-//       return ed25519.utils.generateKeyPair(isAsync, type, encoding, callback);
-//     }
-//     default:
-//     // Fall through
-//   }
+  switch (type) {
+    case 'ed25519':
+    case 'ed448':
+    case 'x25519':
+    case 'x448':
+      return 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];
+    }
+  }
 
-//   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 (): Promise<GenerateKeyPairReturn> => {
+      try {
+        let result;
+        if (type === 'rsa' || type === 'rsa-pss') {
+          result = await rsa_generateKeyPairNode(type, options, encoding);
+        } else if (type === 'ec') {
+          result = await ec_generateKeyPairNode(options, encoding);
+        } else {
+          throw new Error(`Unsupported key type: ${type}`);
+        }
+        return [undefined, result.publicKey, result.privateKey];
+      } catch (error) {
+        return [error as 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 = rsa_generateKeyPairNodeSync(type, options, encoding);
+    } else if (type === 'ec') {
+      result = ec_generateKeyPairNodeSync(options, encoding);
+    } else {
+      throw new Error(`Unsupported key type: ${type}`);
+    }
+    return [undefined, result.publicKey, result.privateKey];
+  } catch (error) {
+    return [error as Error, undefined, undefined];
+  }
+}