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

package/src/keys/classes.ts

@@ -0,0 +1,317 @@
+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 {
+  keyObject: KeyObject;
+  keyAlgorithm: SubtleAlgorithm;
+  keyUsages: KeyUsage[];
+  keyExtractable: boolean;
+
+  constructor(
+    keyObject: KeyObject,
+    keyAlgorithm: SubtleAlgorithm,
+    keyUsages: KeyUsage[],
+    keyExtractable: boolean,
+  ) {
+    this.keyObject = keyObject;
+    this.keyAlgorithm = keyAlgorithm;
+    this.keyUsages = keyUsages;
+    this.keyExtractable = keyExtractable;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  inspect(_depth: number, _options: unknown): unknown {
+    throw new Error('CryptoKey.inspect is not implemented');
+    // if (depth < 0) return this;
+
+    // const opts = {
+    //   ...options,
+    //   depth: options.depth == null ? null : options.depth - 1,
+    // };
+
+    // return `CryptoKey ${inspect(
+    //   {
+    //     type: this.type,
+    //     extractable: this.extractable,
+    //     algorithm: this.algorithm,
+    //     usages: this.usages,
+    //   },
+    //   opts
+    // )}`;
+  }
+
+  get type() {
+    // if (!(this instanceof CryptoKey)) throw new Error('Invalid CryptoKey');
+    return this.keyObject.type;
+  }
+
+  get extractable() {
+    return this.keyExtractable;
+  }
+
+  get algorithm() {
+    return this.keyAlgorithm;
+  }
+
+  get usages() {
+    return this.keyUsages;
+  }
+}
+
+export class KeyObject {
+  handle: KeyObjectHandle;
+  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): 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, key: ArrayBuffer);
+  constructor(type: string, handleOrKey: KeyObjectHandle | ArrayBuffer) {
+    if (type !== 'secret' && type !== 'public' && type !== 'private')
+      throw new Error(`invalid KeyObject type: ${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))
+  //     throw new ERR_INVALID_ARG_TYPE('key', 'CryptoKey', key);
+  //   return key[kKeyObject];
+  // }
+
+  static createKeyObject(
+    type: string,
+    key: ArrayBuffer,
+    format?: 'der' | 'pem',
+    encoding?: 'pkcs8' | 'spki' | 'sec1',
+  ): 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 and encoding are explicitly provided, use them
+    if (
+      format &&
+      encoding &&
+      (keyType === KeyType.PUBLIC || keyType === KeyType.PRIVATE)
+    ) {
+      const kFormat = format === 'der' ? KFormatType.DER : KFormatType.PEM;
+      const kEncoding =
+        encoding === 'spki'
+          ? KeyEncoding.SPKI
+          : encoding === 'pkcs8'
+            ? KeyEncoding.PKCS8
+            : encoding === 'sec1'
+              ? KeyEncoding.SEC1
+              : 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(): undefined {
+    return undefined;
+  }
+
+  getAsymmetricKeyDetails(): undefined {
+    return undefined;
+  }
+}
+
+export class SecretKeyObject extends KeyObject {
+  constructor(handle: KeyObjectHandle) {
+    super('secret', handle);
+  }
+
+  // get symmetricKeySize() {
+  //   return this.handle.getSymmetricKeySize();
+  // }
+
+  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`,
+      );
+    }
+    const key = this.handle.exportKey();
+    return Buffer.from(key);
+  }
+}
+
+// const kAsymmetricKeyType = Symbol('kAsymmetricKeyType');
+// const kAsymmetricKeyDetails = Symbol('kAsymmetricKeyDetails');
+
+// function normalizeKeyDetails(details = {}) {
+//   if (details.publicExponent !== undefined) {
+//     return {
+//       ...details,
+//       publicExponent: bigIntArrayToUnsignedBigInt(
+//         new Uint8Array(details.publicExponent)
+//       ),
+//     };
+//   }
+//   return details;
+// }
+
+export class AsymmetricKeyObject extends KeyObject {
+  constructor(type: string, handle: KeyObjectHandle) {
+    super(type, handle);
+  }
+
+  private _asymmetricKeyType?: AsymmetricKeyType;
+
+  get asymmetricKeyType(): AsymmetricKeyType {
+    if (!this._asymmetricKeyType) {
+      this._asymmetricKeyType = this.handle.getAsymmetricKeyType();
+    }
+    return this._asymmetricKeyType;
+  }
+
+  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 {
+  constructor(handle: KeyObjectHandle) {
+    super('public', handle);
+  }
+
+  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');
+    }
+    const { format, type } = parsePublicKeyEncoding(
+      options,
+      this.asymmetricKeyType,
+    );
+    const key = this.handle.exportKey(format, type);
+    const buffer = Buffer.from(key);
+    if (options?.format === 'pem') {
+      return buffer.toString('utf-8');
+    }
+    return buffer;
+  }
+}
+
+export class PrivateKeyObject extends AsymmetricKeyObject {
+  constructor(handle: KeyObjectHandle) {
+    super('private', handle);
+  }
+
+  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');
+    }
+    const { format, type, cipher, passphrase } = parsePrivateKeyEncoding(
+      options,
+      this.asymmetricKeyType,
+    );
+    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

@@ -0,0 +1,145 @@
+import { ed_generateKeyPair } from '../ed';
+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,
+  };
+}
+
+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 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];
+}

package/src/keys/index.ts

@@ -0,0 +1,52 @@
+import {
+  AsymmetricKeyObject,
+  CryptoKey,
+  KeyObject,
+  SecretKeyObject,
+  PublicKeyObject,
+  PrivateKeyObject,
+} from './classes';
+import { generateKeyPair, generateKeyPairSync } from './generateKeyPair';
+// import { sign, verify } from './signVerify';
+import {
+  isCryptoKey,
+  parseKeyEncoding,
+  parsePrivateKeyEncoding,
+  parsePublicKeyEncoding,
+} from './utils';
+import type { BinaryLike } from '../utils';
+import { binaryLikeToArrayBuffer as toAB } from '../utils';
+
+function createSecretKey(key: BinaryLike): SecretKeyObject {
+  const keyBuffer = toAB(key);
+  return KeyObject.createKeyObject('secret', keyBuffer) as SecretKeyObject;
+}
+
+export {
+  // Node Public API
+  createSecretKey,
+  // createPublicKey,
+  // createPrivateKey,
+  CryptoKey,
+  generateKeyPair,
+  generateKeyPairSync,
+  AsymmetricKeyObject,
+  KeyObject,
+  // InternalCryptoKey,
+  // sign,
+  // verify,
+
+  // Node Internal API
+  parsePublicKeyEncoding,
+  parsePrivateKeyEncoding,
+  parseKeyEncoding,
+  // preparePrivateKey,
+  // preparePublicOrPrivateKey,
+  // prepareSecretKey,
+  SecretKeyObject,
+  PublicKeyObject,
+  PrivateKeyObject,
+  // isKeyObject,
+  isCryptoKey,
+  // importGenericSecretKey,
+};

package/src/keys/signVerify.ts

@@ -0,0 +1,39 @@
+// import { KeyObject, PublicKeyObject, PrivateKeyObject } from '.';
+// import { ed25519 } from '../ed25519';
+// import type {
+//   BinaryLike,
+//   BinaryLikeNode,
+//   SignCallback,
+//   VerifyCallback,
+// } from '../utils';
+
+// export function sign(
+//   algorithm: string | null | undefined,
+//   data: BinaryLike,
+//   key: BinaryLikeNode | KeyObject,
+//   callback: SignCallback,
+// ): ArrayBuffer {
+//   console.log('sign  ', algorithm, data, key, callback);
+//   return new ArrayBuffer(32);
+// }
+
+// export function verify(
+//   algorithm: string | null | undefined,
+//   data: BinaryLike,
+//   key: BinaryLikeNode | KeyObject,
+//   signature: ArrayBuffer,
+//   callback: VerifyCallback,
+// ): boolean {
+//   if (!algorithm) {
+//     if (key instanceof PublicKeyObject) {
+//       switch (key.asymmetricKeyType) {
+//         case 'ed25519':
+//         case 'ed448':
+//         case 'x25519':
+//         case 'x448': {
+//           return ed25519.verify(signature, data, key);
+//         }
+//     }
+//   }
+//   throw new Error('Verify not implemented', algorithm, data, key, signature, callback);
+// }