react-native-quick-crypto 0.7.3 → 0.7.5

package/src/random.ts

@@ -1,105 +1,101 @@
+import { abvToArrayBuffer } from './Utils';
 import { NativeQuickCrypto } from './NativeQuickCrypto/NativeQuickCrypto';
 import { Buffer } from '@craftzdog/react-native-buffer';
 import type { TypedArray } from './Utils';
 
 const random = NativeQuickCrypto.random;
 
-type ArrayBufferView = TypedArray | DataView | ArrayBufferLike | Buffer;
+type RandomBuffer = TypedArray | DataView | ArrayBufferLike | Buffer;
 
-export function randomFill<T extends ArrayBufferView>(
+export function randomFill<T extends RandomBuffer>(
   buffer: T,
-  callback: (err: Error | null, buf: T) => void
+  callback: (err: Error | null, buf: T) => void,
 ): void;
 
-export function randomFill<T extends ArrayBufferView>(
+export function randomFill<T extends RandomBuffer>(
   buffer: T,
   offset: number,
-  callback: (err: Error | null, buf: T) => void
+  callback: (err: Error | null, buf: T) => void,
 ): void;
 
-export function randomFill<T extends ArrayBufferView>(
+export function randomFill<T extends RandomBuffer>(
   buffer: T,
   offset: number,
   size: number,
-  callback: (err: Error | null, buf: T) => void
+  callback: (err: Error | null, buf: T) => void,
 ): void;
 
-export function randomFill(buffer: any, ...rest: any[]): void {
+export function randomFill(buffer: RandomBuffer, ...rest: unknown[]): void {
   if (typeof rest[rest.length - 1] !== 'function') {
     throw new Error('No callback provided to randomFill');
   }
 
-  const callback = rest[rest.length - 1] as any as (
+  const callback = rest[rest.length - 1] as unknown as (
     err: Error | null,
-    buf?: ArrayBuffer
+    buf?: ArrayBuffer,
   ) => void;
 
   let offset: number = 0;
   let size: number = buffer.byteLength;
 
   if (typeof rest[2] === 'function') {
-    offset = rest[0];
-    size = rest[1];
+    offset = rest[0] as number;
+    size = rest[1] as number;
   }
 
   if (typeof rest[1] === 'function') {
-    offset = rest[0];
+    offset = rest[0] as number;
   }
 
   random
-    .randomFill(
-      Buffer.isBuffer(buffer)
-        ? buffer.buffer
-        : ArrayBuffer.isView(buffer)
-          ? buffer.buffer
-          : buffer,
-      offset,
-      size
-    )
+    .randomFill(abvToArrayBuffer(buffer as ArrayBufferView), offset, size)
     .then(
-      () => {
-        callback(null, buffer);
+      (res: ArrayBuffer) => {
+        callback(null, res);
       },
       (e: Error) => {
         callback(e);
-      }
+      },
     );
 }
 
-export function randomFillSync<T extends ArrayBufferView>(
+export function randomFillSync<T extends RandomBuffer>(
   buffer: T,
   offset?: number,
-  size?: number
+  size?: number,
 ): T;
 
-export function randomFillSync(buffer: any, offset: number = 0, size?: number) {
-  random.randomFillSync(
-    buffer.buffer ? buffer.buffer : buffer,
+export function randomFillSync(
+  buffer: RandomBuffer,
+  offset: number = 0,
+  size?: number,
+) {
+  return random.randomFillSync(
+    abvToArrayBuffer(buffer as ArrayBufferView),
     offset,
-    size ?? buffer.byteLength
+    size ?? buffer.byteLength,
   );
-  return buffer;
 }
 
 export function randomBytes(size: number): Buffer;
 
 export function randomBytes(
   size: number,
-  callback: (err: Error | null, buf?: Buffer) => void
+  callback: (err: Error | null, buf?: Buffer) => void,
 ): void;
 
 export function randomBytes(
   size: number,
-  callback?: (err: Error | null, buf?: Buffer) => void
+  callback?: (err: Error | null, buf?: Buffer) => void,
 ): void | Buffer {
   const buf = new Buffer(size);
 
   if (callback === undefined) {
-    randomFillSync(buf.buffer, 0, size);
+    randomFillSync(buf, 0, size);
     return buf;
   }
 
-  randomFill(buf.buffer, 0, size, (error: Error | null) => {
+  randomFill(buf, 0, size, (error: Error | null) => {
     if (error) {
       callback(error);
     }
@@ -139,13 +135,13 @@ export function randomInt(max: number): number;
 export function randomInt(
   min: number,
   max: number,
-  callback: RandomIntCallback
+  callback: RandomIntCallback,
 ): void;
 export function randomInt(min: number, max: number): number;
 export function randomInt(
   arg1: number,
   arg2?: number | RandomIntCallback,
-  callback?: RandomIntCallback
+  callback?: RandomIntCallback,
 ): void | number {
   // Detect optional min syntax
   // randomInt(max)
@@ -156,12 +152,12 @@ export function randomInt(
     typeof arg2 === 'undefined' || typeof arg2 === 'function';
 
   if (minNotSpecified) {
-    callback = arg2 as any as undefined | RandomIntCallback;
+    callback = arg2 as undefined | RandomIntCallback;
     max = arg1;
     min = 0;
   } else {
     min = arg1;
-    max = arg2 as any as number;
+    max = arg2 as number;
   }
   if (typeof callback !== 'undefined' && typeof callback !== 'function') {
     throw new TypeError('callback must be a function or undefined');
@@ -217,7 +213,7 @@ export function randomInt(
     if (x < randLimit) {
       const n = (x % range) + min;
       if (isSync) return n;
-      process.nextTick(callback as Function, undefined, n);
+      process.nextTick(callback as RandomIntCallback, undefined, n);
       return;
     }
   }
@@ -289,9 +285,7 @@ export function randomUUID() {
   randomFillSync(buffer, 0, size);
 
   // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
-  // eslint-disable-next-line no-bitwise
   buffer[6] = (buffer[6]! & 0x0f) | 0x40;
-  // eslint-disable-next-line no-bitwise
   buffer[8] = (buffer[8]! & 0x3f) | 0x80;
 
   return (

package/src/rsa.ts

@@ -43,7 +43,7 @@ export enum RSAKeyVariant {
 function verifyAcceptableRsaKeyUse(
   name: AnyAlgorithm,
   isPublic: boolean,
-  usages: KeyUsage[]
+  usages: KeyUsage[],
 ): void {
   let checkSet;
   switch (name) {
@@ -58,13 +58,13 @@ function verifyAcceptableRsaKeyUse(
     default:
       throw lazyDOMException(
         'The algorithm is not supported',
-        'NotSupportedError'
+        'NotSupportedError',
       );
   }
   if (hasAnyNotIn(usages, checkSet)) {
     throw lazyDOMException(
       `Unsupported key usage for an ${name} key`,
-      'SyntaxError'
+      'SyntaxError',
     );
   }
 }
@@ -73,14 +73,14 @@ const rsaOaepCipher = (
   mode: CipherOrWrapMode,
   key: CryptoKey,
   data: ArrayBuffer,
-  { label }: RsaOaepParams
+  { label }: RsaOaepParams,
 ): Promise<ArrayBuffer> => {
   const type =
     mode === CipherOrWrapMode.kWebCryptoCipherEncrypt ? 'public' : 'private';
   if (key.type !== type) {
     throw lazyDOMException(
       'The requested operation is not valid for the provided key',
-      'InvalidAccessError'
+      'InvalidAccessError',
     );
   }
   if (label !== undefined) {
@@ -93,7 +93,7 @@ const rsaOaepCipher = (
     data,
     RSAKeyVariant.RSA_OAEP,
     normalizeHashName(key.algorithm.hash) as DigestAlgorithm,
-    label !== undefined ? bufferLikeToArrayBuffer(label) : undefined
+    label !== undefined ? bufferLikeToArrayBuffer(label) : undefined,
   );
 };
 
@@ -102,17 +102,19 @@ export const rsaCipher = rsaOaepCipher;
 export const rsaKeyGenerate = async (
   algorithm: SubtleAlgorithm,
   extractable: boolean,
-  keyUsages: KeyUsage[]
+  keyUsages: KeyUsage[],
 ): Promise<CryptoKeyPair> => {
   const { name, modulusLength, publicExponent, hash: rawHash } = algorithm;
   const hash: HashAlgorithm = normalizeHashName(rawHash);
 
   // const usageSet = new SafeSet(keyUsages);
-  const publicExponentConverted = bigIntArrayToUnsignedInt(publicExponent);
+  const publicExponentConverted = bigIntArrayToUnsignedInt(
+    publicExponent as Uint8Array,
+  );
   if (publicExponentConverted === undefined) {
     throw lazyDOMException(
       'The publicExponent must be equivalent to an unsigned 32-bit value',
-      'OperationError'
+      'OperationError',
     );
   }
 
@@ -123,7 +125,7 @@ export const rsaKeyGenerate = async (
       ) {
         throw lazyDOMException(
           'Unsupported key usage for a RSA key',
-          'SyntaxError'
+          'SyntaxError',
         );
       }
       break;
@@ -131,7 +133,7 @@ export const rsaKeyGenerate = async (
       if (hasAnyNotIn(keyUsages, ['sign', 'verify'])) {
         throw lazyDOMException(
           'Unsupported key usage for a RSA key',
-          'SyntaxError'
+          'SyntaxError',
         );
       }
   }
@@ -143,7 +145,7 @@ export const rsaKeyGenerate = async (
   if (err) {
     throw lazyDOMException(
       'The operation failed for an operation-specific reason',
-      { name: 'OperationError', cause: err }
+      { name: 'OperationError', cause: err },
     );
   }
 
@@ -177,7 +179,7 @@ export const rsaKeyGenerate = async (
     priv,
     keyAlgorithm,
     privateUsages,
-    extractable
+    extractable,
   );
 
   return { publicKey, privateKey };
@@ -185,19 +187,19 @@ export const rsaKeyGenerate = async (
 
 export const rsaExportKey = (
   key: CryptoKey,
-  format: KWebCryptoKeyFormat
+  format: KWebCryptoKeyFormat,
 ): ArrayBuffer => {
   const variant = KeyVariantLookup[key.algorithm.name];
   if (variant === undefined) {
     throw lazyDOMException(
       `Unrecognized algorithm name '${key.algorithm.name}'`,
-      'NotSupportedError'
+      'NotSupportedError',
     );
   }
   return NativeQuickCrypto.webcrypto.rsaExportKey(
     format,
     key.keyObject.handle,
-    variant
+    variant,
   );
 };
 
@@ -206,7 +208,7 @@ export const rsaImportKey = (
   keyData: BufferLike | JWK,
   algorithm: SubtleAlgorithm,
   extractable: boolean,
-  keyUsages: KeyUsage[]
+  keyUsages: KeyUsage[],
 ): CryptoKey => {
   // const usagesSet = new SafeSet(keyUsages);
   let keyObject: PublicKeyObject | PrivateKeyObject;
@@ -254,7 +256,7 @@ export const rsaImportKey = (
       verifyAcceptableRsaKeyUse(
         algorithm.name,
         data.d === undefined,
-        keyUsages
+        keyUsages,
       );
 
       if (keyUsages.length > 0 && data.use !== undefined) {
@@ -272,19 +274,19 @@ export const rsaImportKey = (
       ) {
         throw lazyDOMException(
           'JWK "ext" Parameter and extractable mismatch',
-          'DataError'
+          'DataError',
         );
       }
 
       if (data.alg !== undefined) {
         const hash = normalizeHashName(
           data.alg as HashAlgorithm,
-          HashContext.WebCrypto
+          HashContext.WebCrypto,
         );
         if (hash !== algorithm.hash)
           throw lazyDOMException(
             'JWK "alg" does not match the requested algorithm',
-            'DataError'
+            'DataError',
           );
       }
 
@@ -303,7 +305,7 @@ export const rsaImportKey = (
     default:
       throw lazyDOMException(
         `Unable to import RSA key with format ${format}`,
-        'NotSupportedError'
+        'NotSupportedError',
       );
   }
 
@@ -326,7 +328,7 @@ export const rsaImportKey = (
       hash: algorithm.hash,
     },
     keyUsages,
-    extractable
+    extractable,
   );
 };
 

package/src/sig.ts

@@ -1,6 +1,6 @@
 import { NativeQuickCrypto } from './NativeQuickCrypto/NativeQuickCrypto';
 import type { InternalSign, InternalVerify } from './NativeQuickCrypto/sig';
-import Stream from 'readable-stream';
+import Stream, { type WritableOptions } from 'readable-stream';
 
 // TODO(osp) same as publicCipher on node this are defined on C++ and exposed to node
 // Do the same here
@@ -23,15 +23,15 @@ import {
 const createInternalSign = NativeQuickCrypto.createSign;
 const createInternalVerify = NativeQuickCrypto.createVerify;
 
-function getPadding(options: any) {
+function getPadding(options: EncodingOptions) {
   return getIntOption('padding', options);
 }
 
-function getSaltLength(options: any) {
+function getSaltLength(options: EncodingOptions) {
   return getIntOption('saltLength', options);
 }
 
-function getDSASignatureEncoding(options: any) {
+function getDSASignatureEncoding(options: EncodingOptions) {
   if (typeof options === 'object') {
     const { dsaEncoding = 'der' } = options;
     if (dsaEncoding === 'der') return DSASigEnc.kSigEncDER;
@@ -42,10 +42,9 @@ function getDSASignatureEncoding(options: any) {
   return DSASigEnc.kSigEncDER;
 }
 
-function getIntOption(name: string, options: any) {
+function getIntOption(name: keyof EncodingOptions, options: EncodingOptions) {
   const value = options[name];
   if (value !== undefined) {
-    // eslint-disable-next-line no-bitwise
     if (value === value >> 0) {
       return value;
     }
@@ -56,7 +55,7 @@ function getIntOption(name: string, options: any) {
 
 class Verify extends Stream.Writable {
   private internal: InternalVerify;
-  constructor(algorithm: string, options: Stream.WritableOptions) {
+  constructor(algorithm: string, options?: WritableOptions) {
     super(options);
     this.internal = createInternalVerify();
     this.internal.init(algorithm);
@@ -96,7 +95,7 @@ class Verify extends Stream.Writable {
       binaryLikeToArrayBuffer(signature),
       rsaPadding,
       pssSaltLength,
-      dsaSigEnc
+      dsaSigEnc,
     );
 
     return ret;
@@ -105,7 +104,7 @@ class Verify extends Stream.Writable {
 
 class Sign extends Stream.Writable {
   private internal: InternalSign;
-  constructor(algorithm: string, options: Stream.WritableOptions) {
+  constructor(algorithm: string, options?: WritableOptions) {
     super(options);
     this.internal = createInternalSign();
     this.internal.init(algorithm);
@@ -143,22 +142,22 @@ class Sign extends Stream.Writable {
       passphrase,
       rsaPadding,
       pssSaltLength,
-      dsaSigEnc
+      dsaSigEnc,
     );
 
     encoding = encoding || getDefaultEncoding();
     if (encoding && encoding !== 'buffer') {
-      return Buffer.from(ret).toString(encoding as any);
+      return Buffer.from(ret).toString(encoding as BufferEncoding);
     }
 
     return Buffer.from(ret);
   }
 }
 
-export function createSign(algorithm: string, options?: any) {
+export function createSign(algorithm: string, options?: WritableOptions) {
   return new Sign(algorithm, options);
 }
 
-export function createVerify(algorithm: string, options?: any) {
+export function createVerify(algorithm: string, options?: WritableOptions) {
   return new Verify(algorithm, options);
 }