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

package/src/hash.ts

@@ -2,8 +2,20 @@ import { Stream } from 'readable-stream';
 import { NitroModules } from 'react-native-nitro-modules';
 import type { TransformOptions } from 'readable-stream';
 import type { Hash as NativeHash } from './specs/hash.nitro';
-import type { BinaryLike, Encoding } from './utils';
-import { ab2str, binaryLikeToArrayBuffer } from './utils';
+import type {
+  BinaryLike,
+  Encoding,
+  BufferLike,
+  SubtleAlgorithm,
+} from './utils';
+import {
+  ab2str,
+  binaryLikeToArrayBuffer,
+  bufferLikeToArrayBuffer,
+} from './utils';
+import { validateMaxBufferLength } from './utils/validation';
+import { lazyDOMException } from './utils/errors';
+import { normalizeHashName } from './utils/hashnames';
 
 class HashUtils {
   private static native = NitroModules.createHybridObject<NativeHash>('Hash');
@@ -157,6 +169,14 @@ class Hash extends Stream.Transform {
     return hash;
   }
 
+  /**
+   * Returns the OpenSSL version string
+   * @since v1.0.0
+   */
+  getOpenSSLVersion(): string {
+    return this.native.getOpenSSLVersion();
+  }
+
   // stream interface
   _transform(
     chunk: BinaryLike,
@@ -202,7 +222,53 @@ export function createHash(algorithm: string, options?: HashOptions): Hash {
   });
 }
 
+// Implementation for WebCrypto subtle.digest()
+
+/**
+ * Asynchronous digest function for WebCrypto SubtleCrypto API
+ * @param algorithm The hash algorithm to use
+ * @param data The data to hash
+ * @returns Promise resolving to the hash digest as ArrayBuffer
+ */
+export const asyncDigest = async (
+  algorithm: SubtleAlgorithm,
+  data: BufferLike,
+): Promise<ArrayBuffer> => {
+  validateMaxBufferLength(data, 'data');
+
+  switch (algorithm.name) {
+    case 'SHA-1':
+    // Fall through
+    case 'SHA-256':
+    // Fall through
+    case 'SHA-384':
+    // Fall through
+    case 'SHA-512':
+      return internalDigest(algorithm, data);
+  }
+
+  throw lazyDOMException(
+    `Unrecognized algorithm name: ${algorithm.name}`,
+    'NotSupportedError',
+  );
+};
+
+const internalDigest = (
+  algorithm: SubtleAlgorithm,
+  data: BufferLike,
+): ArrayBuffer => {
+  const normalizedHashName = normalizeHashName(algorithm.name);
+  const hash = createHash(normalizedHashName);
+  hash.update(bufferLikeToArrayBuffer(data));
+  const result = hash.digest();
+  const arrayBuffer = new ArrayBuffer(result.length);
+  const view = new Uint8Array(arrayBuffer);
+  view.set(result);
+  return arrayBuffer;
+};
+
 export const hashExports = {
   createHash,
   getHashes,
+  asyncDigest,
 };

package/src/index.ts

@@ -3,6 +3,7 @@ import { Buffer } from '@craftzdog/react-native-buffer';
 
 // API imports
 import * as keys from './keys';
+import * as blake3 from './blake3';
 import * as cipher from './cipher';
 import * as ed from './ed';
 import { hashExports as hash } from './hash';
@@ -12,6 +13,7 @@ import * as random from './random';
 
 // utils import
 import * as utils from './utils';
+import * as subtle from './subtle';
 
 /**
  * Loosely matches Node.js {crypto} with some unimplemented functionality.
@@ -19,6 +21,7 @@ import * as utils from './utils';
  */
 const QuickCrypto = {
   ...keys,
+  ...blake3,
   ...cipher,
   ...ed,
   ...hash,
@@ -26,6 +29,7 @@ const QuickCrypto = {
   ...pbkdf2,
   ...random,
   ...utils,
+  ...subtle,
 };
 
 /**
@@ -45,13 +49,17 @@ global.process.nextTick = setImmediate;
 
 // exports
 export default QuickCrypto;
+export * from './blake3';
 export * from './cipher';
 export * from './ed';
+export * from './keys';
 export * from './hash';
 export * from './hmac';
 export * from './pbkdf2';
 export * from './random';
 export * from './utils';
+export * from './subtle';
+export { subtle, isCryptoKeyPair } from './subtle';
 
 // Additional exports for CommonJS compatibility
 module.exports = QuickCrypto;

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,84 @@ 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?: '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 {
@@ -110,17 +202,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 +249,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 +268,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 +293,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;
   }
 }