react-native-quick-crypto 1.0.0-beta.1 → 1.0.0-beta.10

package/src/keys/classes.ts

@@ -0,0 +1,211 @@
+import type { KeyObjectHandle } from '../specs/keyObjectHandle.nitro';
+import type {
+  AsymmetricKeyType,
+  EncodingOptions,
+  KeyUsage,
+  SubtleAlgorithm,
+} 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' | 'unknown' = 'unknown';
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  export(_options?: EncodingOptions): ArrayBuffer {
+    return new ArrayBuffer(0);
+  }
+
+  constructor(type: string, handle: KeyObjectHandle) {
+    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;
+  // }
+
+  // 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
+  //     );
+  //   }
+
+  //   return (
+  //     otherKeyObject.type === this.type &&
+  //     this[kHandle].equals(otherKeyObject[kHandle])
+  //   );
+  // }
+}
+
+export class SecretKeyObject extends KeyObject {
+  constructor(handle: KeyObjectHandle) {
+    super('secret', handle);
+  }
+
+  // get symmetricKeySize() {
+  //   return this[kHandle].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);
+      }
+    }
+    return this.handle.exportKey();
+  }
+}
+
+// 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;
+  }
+
+  // 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 {};
+  //   }
+  // }
+}
+
+export class PublicKeyObject extends AsymmetricKeyObject {
+  constructor(handle: KeyObjectHandle) {
+    super('public', handle);
+  }
+
+  export(options: EncodingOptions) {
+    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);
+  }
+}
+
+export class PrivateKeyObject extends AsymmetricKeyObject {
+  constructor(handle: KeyObjectHandle) {
+    super('private', handle);
+  }
+
+  export(options: EncodingOptions) {
+    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);
+  }
+}

package/src/keys/generateKeyPair.ts

@@ -0,0 +1,146 @@
+// 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,
+//   };
+// }
+
+// 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
+//   }
+
+//   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,42 @@
+import {
+  CryptoKey,
+  KeyObject,
+  SecretKeyObject,
+  PublicKeyObject,
+  PrivateKeyObject,
+} from './classes';
+// import { generateKeyPair } from './generateKeyPair';
+// import { sign, verify } from './signVerify';
+import {
+  isCryptoKey,
+  parseKeyEncoding,
+  parsePrivateKeyEncoding,
+  parsePublicKeyEncoding,
+} from './utils';
+
+export {
+  // Node Public API
+  // createSecretKey,
+  // createPublicKey,
+  // createPrivateKey,
+  CryptoKey,
+  // generateKeyPair,
+  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);
+// }

package/src/keys/utils.ts

@@ -0,0 +1,184 @@
+import {
+  binaryLikeToArrayBuffer,
+  isStringOrBuffer,
+  KeyEncoding,
+  KFormatType,
+} from '../utils';
+import type { EncodingOptions } from '../utils';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const isCryptoKey = (obj: any): boolean => {
+  return obj !== null && obj?.keyObject !== undefined;
+};
+
+/**
+ * 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.
+ */
+export function parsePublicKeyEncoding(
+  enc: EncodingOptions,
+  keyType: string | undefined,
+  objName?: string,
+) {
+  return parseKeyEncoding(enc, keyType, keyType ? true : undefined, objName);
+}
+
+/**
+ * Parses the private 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.
+ */
+export function parsePrivateKeyEncoding(
+  enc: EncodingOptions,
+  keyType: string | undefined,
+  objName?: string,
+) {
+  return parseKeyEncoding(enc, keyType, false, objName);
+}
+
+export function parseKeyEncoding(
+  enc: EncodingOptions,
+  keyType?: string,
+  isPublic?: boolean,
+  objName?: string,
+) {
+  // validateObject(enc, 'options');
+
+  const isInput = keyType === undefined;
+
+  const { format, type } = parseKeyFormatAndType(
+    enc,
+    keyType,
+    isPublic,
+    objName,
+  );
+
+  let cipher, passphrase, encoding;
+  if (isPublic !== true) {
+    ({ cipher, passphrase, encoding } = enc);
+
+    if (!isInput) {
+      if (cipher != null) {
+        if (typeof cipher !== 'string')
+          throw new Error(
+            `Invalid argument ${option('cipher', objName)}: ${cipher}`,
+          );
+        if (
+          format === KFormatType.kKeyFormatDER &&
+          (type === KeyEncoding.kKeyEncodingPKCS1 ||
+            type === KeyEncoding.kKeyEncodingSEC1)
+        ) {
+          throw new Error(
+            `Incompatible key options ${encodingNames[type]} does not support encryption`,
+          );
+        }
+      } else if (passphrase !== undefined) {
+        throw new Error(
+          `invalid argument ${option('cipher', objName)}: ${cipher}`,
+        );
+      }
+    }
+
+    if (
+      (isInput && passphrase !== undefined && !isStringOrBuffer(passphrase)) ||
+      (!isInput && cipher != null && !isStringOrBuffer(passphrase))
+    ) {
+      throw new Error(
+        `Invalid argument value ${option('passphrase', objName)}: ${passphrase}`,
+      );
+    }
+  }
+
+  if (passphrase !== undefined)
+    passphrase = binaryLikeToArrayBuffer(passphrase, encoding);
+
+  return { format, type, cipher, passphrase };
+}
+
+const encodingNames = {
+  [KeyEncoding.kKeyEncodingPKCS1]: 'pkcs1',
+  [KeyEncoding.kKeyEncodingPKCS8]: 'pkcs8',
+  [KeyEncoding.kKeyEncodingSPKI]: 'spki',
+  [KeyEncoding.kKeyEncodingSEC1]: 'sec1',
+};
+
+function option(name: string, objName?: string) {
+  return objName === undefined
+    ? `options.${name}`
+    : `options.${objName}.${name}`;
+}
+
+function parseKeyFormat(
+  formatStr?: string,
+  defaultFormat?: KFormatType,
+  optionName?: string,
+) {
+  if (formatStr === undefined && defaultFormat !== undefined)
+    return defaultFormat;
+  else if (formatStr === 'pem') return KFormatType.kKeyFormatPEM;
+  else if (formatStr === 'der') return KFormatType.kKeyFormatDER;
+  else if (formatStr === 'jwk') return KFormatType.kKeyFormatJWK;
+  throw new Error(`Invalid key format str: ${optionName}`);
+}
+
+function parseKeyType(
+  typeStr: string | undefined,
+  required: boolean,
+  keyType: string | undefined,
+  isPublic: boolean | undefined,
+  optionName: string,
+): KeyEncoding | undefined {
+  if (typeStr === undefined && !required) {
+    return undefined;
+  } else if (typeStr === 'pkcs1') {
+    if (keyType !== undefined && keyType !== 'rsa') {
+      throw new Error(
+        `Crypto incompatible key options: ${typeStr} can only be used for RSA keys`,
+      );
+    }
+    return KeyEncoding.kKeyEncodingPKCS1;
+  } else if (typeStr === 'spki' && isPublic !== false) {
+    return KeyEncoding.kKeyEncodingSPKI;
+  } else if (typeStr === 'pkcs8' && isPublic !== true) {
+    return KeyEncoding.kKeyEncodingPKCS8;
+  } 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 KeyEncoding.kKeyEncodingSEC1;
+  }
+
+  throw new Error(`Invalid option ${optionName} - ${typeStr}`);
+}
+
+function parseKeyFormatAndType(
+  enc: EncodingOptions,
+  keyType?: string,
+  isPublic?: boolean,
+  objName?: string,
+) {
+  const { format: formatStr, type: typeStr } = enc;
+
+  const isInput = keyType === undefined;
+  const format = parseKeyFormat(
+    formatStr,
+    isInput ? KFormatType.kKeyFormatPEM : undefined,
+    option('format', objName),
+  );
+
+  const isRequired =
+    (!isInput || format === KFormatType.kKeyFormatDER) &&
+    format !== KFormatType.kKeyFormatJWK;
+
+  const type = parseKeyType(
+    typeStr,
+    isRequired,
+    keyType,
+    isPublic,
+    option('type', objName),
+  );
+  return { format, type };
+}