react-native-quick-crypto 0.7.3 → 0.7.4

package/src/aes.ts

@@ -52,7 +52,7 @@ export const getAlgorithmName = (name: string, length?: number) => {
   if (length === undefined)
     throw lazyDOMException(
       `Invalid algorithm length: ${length}`,
-      'SyntaxError'
+      'SyntaxError',
     );
   switch (name) {
     case 'AES-CBC':
@@ -84,7 +84,7 @@ function getVariant(name: AESAlgorithm, length: AESLength): AESKeyVariant {
         case 256:
           return AESKeyVariant.AES_CBC_256;
       }
-      // @ts-ignore
+      // @ts-expect-error unreachable code
       break;
     case 'AES-CTR':
       switch (length) {
@@ -95,7 +95,7 @@ function getVariant(name: AESAlgorithm, length: AESLength): AESKeyVariant {
         case 256:
           return AESKeyVariant.AES_CTR_256;
       }
-      // @ts-ignore
+      // @ts-expect-error unreachable code
       break;
     case 'AES-GCM':
       switch (length) {
@@ -106,7 +106,7 @@ function getVariant(name: AESAlgorithm, length: AESLength): AESKeyVariant {
         case 256:
           return AESKeyVariant.AES_GCM_256;
       }
-      // @ts-ignore
+      // @ts-expect-error unreachable code
       break;
     case 'AES-KW':
       switch (length) {
@@ -117,14 +117,14 @@ function getVariant(name: AESAlgorithm, length: AESLength): AESKeyVariant {
         case 256:
           return AESKeyVariant.AES_KW_256;
       }
-      // @ts-ignore
+      // @ts-expect-error unreachable code
       break;
   }
 
-  // @ts-ignore
+  // @ts-expect-error unreachable code
   throw lazyDOMException(
     `Error getting variant ${name} at length: ${length}`,
-    'DataError'
+    'DataError',
   );
 }
 
@@ -132,7 +132,7 @@ function asyncAesCtrCipher(
   mode: CipherOrWrapMode,
   key: CryptoKey,
   data: ArrayBuffer,
-  { counter, length }: AesCtrParams
+  { counter, length }: AesCtrParams,
 ): Promise<ArrayBuffer> {
   validateByteLength(counter, 'algorithm.counter', 16);
   // The length must specify an integer between 1 and 128. While
@@ -140,7 +140,7 @@ function asyncAesCtrCipher(
   if (length === 0 || length > kMaxCounterLength) {
     throw lazyDOMException(
       'AES-CTR algorithm.length must be between 1 and 128',
-      'OperationError'
+      'OperationError',
     );
   }
 
@@ -150,7 +150,7 @@ function asyncAesCtrCipher(
     data,
     getVariant('AES-CTR', key.algorithm.length as AESLength),
     bufferLikeToArrayBuffer(counter),
-    length
+    length,
   );
 }
 
@@ -158,7 +158,7 @@ function asyncAesCbcCipher(
   mode: CipherOrWrapMode,
   key: CryptoKey,
   data: ArrayBuffer,
-  { iv }: AesCbcParams
+  { iv }: AesCbcParams,
 ): Promise<ArrayBuffer> {
   validateByteLength(iv, 'algorithm.iv', 16);
   return NativeQuickCrypto.webcrypto.aesCipher(
@@ -166,7 +166,7 @@ function asyncAesCbcCipher(
     key.keyObject.handle,
     data,
     getVariant('AES-CBC', key.algorithm.length as AESLength),
-    bufferLikeToArrayBuffer(iv)
+    bufferLikeToArrayBuffer(iv),
   );
 }
 
@@ -187,12 +187,12 @@ function asyncAesGcmCipher(
   mode: CipherOrWrapMode,
   key: CryptoKey,
   data: ArrayBuffer,
-  { iv, additionalData, tagLength = 128 }: AesGcmParams
+  { iv, additionalData, tagLength = 128 }: AesGcmParams,
 ) {
   if (!kTagLengths.includes(tagLength)) {
     throw lazyDOMException(
       `${tagLength} is not a valid AES-GCM tag length`,
-      'OperationError'
+      'OperationError',
     );
   }
 
@@ -219,7 +219,7 @@ function asyncAesGcmCipher(
       if (tagByteLength > tag.byteLength) {
         throw lazyDOMException(
           'The provided data is too small.',
-          'OperationError'
+          'OperationError',
         );
       }
 
@@ -239,7 +239,7 @@ function asyncAesGcmCipher(
     bufferLikeToArrayBuffer(iv),
     length,
     bufferLikeToArrayBuffer(tag),
-    bufferLikeToArrayBuffer(additionalData || new ArrayBuffer(0))
+    bufferLikeToArrayBuffer(additionalData || new ArrayBuffer(0)),
   );
 }
 
@@ -247,7 +247,7 @@ export const aesCipher = (
   mode: CipherOrWrapMode,
   key: CryptoKey,
   data: ArrayBuffer,
-  algorithm: EncryptDecryptParams // | WrapUnwrapParams
+  algorithm: EncryptDecryptParams, // | WrapUnwrapParams
 ): Promise<ArrayBuffer> => {
   switch (algorithm.name) {
     case 'AES-CTR':
@@ -265,7 +265,7 @@ export const aesCipher = (
 export const aesGenerateKey = async (
   algorithm: AesKeyGenParams,
   extractable: boolean,
-  keyUsages: KeyUsage[]
+  keyUsages: KeyUsage[],
 ): Promise<CryptoKey> => {
   const { name, length } = algorithm;
   if (!name) {
@@ -274,7 +274,7 @@ export const aesGenerateKey = async (
   if (!kAesKeyLengths.includes(length)) {
     throw lazyDOMException(
       'AES key length must be 128, 192, or 256 bits',
-      'OperationError'
+      'OperationError',
     );
   }
 
@@ -286,7 +286,7 @@ export const aesGenerateKey = async (
   if (hasAnyNotIn(keyUsages, checkUsages)) {
     throw lazyDOMException(
       `Unsupported key usage for an AES key: ${keyUsages}`,
-      'SyntaxError'
+      'SyntaxError',
     );
   }
 
@@ -297,7 +297,7 @@ export const aesGenerateKey = async (
       {
         name: 'OperationError',
         cause: err,
-      }
+      },
     );
   }
 
@@ -305,7 +305,7 @@ export const aesGenerateKey = async (
     key as SecretKeyObject,
     { name, length },
     Array.from(keyUsages),
-    extractable
+    extractable,
   );
 };
 
@@ -314,7 +314,7 @@ export const aesImportKey = async (
   format: ImportFormat,
   keyData: BufferLike | JWK,
   extractable: boolean,
-  keyUsages: KeyUsage[]
+  keyUsages: KeyUsage[],
 ): Promise<CryptoKey> => {
   const { name } = algorithm;
   const checkUsages = ['wrapKey', 'unwrapKey'];
@@ -326,7 +326,7 @@ export const aesImportKey = async (
   if (hasAnyNotIn(keyUsages, checkUsages)) {
     throw lazyDOMException(
       'Unsupported key usage for an AES key',
-      'SyntaxError'
+      'SyntaxError',
     );
   }
 
@@ -335,9 +335,9 @@ export const aesImportKey = async (
 
   switch (format) {
     case 'raw': {
-      const data = keyData as BufferLike;
+      const data = bufferLikeToArrayBuffer(keyData as BufferLike);
       validateKeyLength(data.byteLength * 8);
-      keyObject = createSecretKey(keyData);
+      keyObject = createSecretKey(data);
       break;
     }
     case 'jwk': {
@@ -365,7 +365,7 @@ export const aesImportKey = async (
       ) {
         throw lazyDOMException(
           'JWK "ext" Parameter and extractable mismatch',
-          'DataError'
+          'DataError',
         );
       }
 
@@ -379,7 +379,7 @@ export const aesImportKey = async (
         if (data.alg !== getAlgorithmName(algorithm.name, length))
           throw lazyDOMException(
             'JWK "alg" does not match the requested algorithm',
-            'DataError'
+            'DataError',
           );
       }
 
@@ -389,7 +389,7 @@ export const aesImportKey = async (
     default:
       throw lazyDOMException(
         `Unable to import AES key with format ${format}`,
-        'NotSupportedError'
+        'NotSupportedError',
       );
   }
 

package/src/ec.ts

@@ -80,7 +80,7 @@ import type { KeyObjectHandle } from './NativeQuickCrypto/webcrypto';
 function verifyAcceptableEcKeyUse(
   name: AnyAlgorithm,
   isPublic: boolean,
-  usages: KeyUsage[]
+  usages: KeyUsage[],
 ): void {
   let checkSet;
   switch (name) {
@@ -93,20 +93,20 @@ function verifyAcceptableEcKeyUse(
     default:
       throw lazyDOMException(
         'The algorithm is not supported',
-        'NotSupportedError'
+        'NotSupportedError',
       );
   }
   if (hasAnyNotIn(usages, checkSet)) {
     throw lazyDOMException(
       `Unsupported key usage for a ${name} key`,
-      'SyntaxError'
+      'SyntaxError',
     );
   }
 }
 
 function createECPublicKeyRaw(
   namedCurve: NamedCurve | undefined,
-  keyData: ArrayBuffer
+  keyData: ArrayBuffer,
 ): PublicKeyObject {
   if (!namedCurve) {
     throw new Error('Invalid namedCurve');
@@ -122,7 +122,7 @@ function createECPublicKeyRaw(
 
 export function ecExportKey(
   key: CryptoKey,
-  format: KWebCryptoKeyFormat
+  format: KWebCryptoKeyFormat,
 ): ArrayBuffer {
   return NativeQuickCrypto.webcrypto.ecExportKey(format, key.keyObject.handle);
 }
@@ -132,7 +132,7 @@ export function ecImportKey(
   keyData: BufferLike | BinaryLike | JWK,
   algorithm: SubtleAlgorithm,
   extractable: boolean,
-  keyUsages: KeyUsage[]
+  keyUsages: KeyUsage[],
 ): CryptoKey {
   const { name, namedCurve } = algorithm;
 
@@ -178,7 +178,7 @@ export function ecImportKey(
       if (data.crv !== namedCurve)
         throw lazyDOMException(
           'JWK "crv" does not match the requested algorithm',
-          'DataError'
+          'DataError',
         );
 
       verifyAcceptableEcKeyUse(name, data.d === undefined, keyUsages);
@@ -198,7 +198,7 @@ export function ecImportKey(
       ) {
         throw lazyDOMException(
           'JWK "ext" Parameter and extractable mismatch',
-          'DataError'
+          'DataError',
         );
       }
 
@@ -218,7 +218,7 @@ export function ecImportKey(
         if (algNamedCurve !== namedCurve)
           throw lazyDOMException(
             'JWK "alg" does not match the requested algorithm',
-            'DataError'
+            'DataError',
           );
       }
 
@@ -235,7 +235,7 @@ export function ecImportKey(
     case 'raw': {
       const data = keyData as BufferLike | BinaryLike;
       verifyAcceptableEcKeyUse(name, true, keyUsages);
-      let buffer =
+      const buffer =
         typeof data === 'string'
           ? binaryLikeToArrayBuffer(data)
           : bufferLikeToArrayBuffer(data);
@@ -271,7 +271,7 @@ export const ecdsaSignVerify = (
   key: CryptoKey,
   data: BufferLike,
   { hash }: SubtleAlgorithm,
-  signature?: BufferLike
+  signature?: BufferLike,
 ) => {
   const mode: SignMode =
     signature === undefined
@@ -296,32 +296,31 @@ export const ecdsaSignVerify = (
     undefined, // salt length, not used with ECDSA
     undefined, // pss padding, not used with ECDSA
     DSASigEnc.kSigEncP1363,
-    bufferLikeToArrayBuffer(signature || new ArrayBuffer(0))
+    bufferLikeToArrayBuffer(signature || new ArrayBuffer(0)),
   );
 };
 
 export const ecGenerateKey = async (
   algorithm: SubtleAlgorithm,
   extractable: boolean,
-  keyUsages: KeyUsage[]
+  keyUsages: KeyUsage[],
 ): Promise<CryptoKeyPair> => {
   const { name, namedCurve } = algorithm;
 
   if (!Object.keys(kNamedCurveAliases).includes(namedCurve || '')) {
     throw lazyDOMException(
       `Unrecognized namedCurve '${namedCurve}'`,
-      'NotSupportedError'
+      'NotSupportedError',
     );
   }
 
   // const usageSet = new SafeSet(keyUsages);
   switch (name) {
     case 'ECDSA':
-      const checkUsages = ['sign', 'verify'];
-      if (hasAnyNotIn(keyUsages, checkUsages)) {
+      if (hasAnyNotIn(keyUsages, ['sign', 'verify'])) {
         throw lazyDOMException(
           'Unsupported key usage for an ECDSA key',
-          'SyntaxError'
+          'SyntaxError',
         );
       }
       break;
@@ -329,7 +328,7 @@ export const ecGenerateKey = async (
       if (hasAnyNotIn(keyUsages, ['deriveKey', 'deriveBits'])) {
         throw lazyDOMException(
           'Unsupported key usage for an ECDH key',
-          'SyntaxError'
+          'SyntaxError',
         );
       }
     // Fall through
@@ -368,7 +367,7 @@ export const ecGenerateKey = async (
     priv,
     keyAlgorithm,
     privateUsages,
-    extractable
+    extractable,
   );
 
   return { publicKey, privateKey };

package/src/keygen.ts

@@ -9,12 +9,12 @@ import {
 
 export type KeyGenCallback = (
   err: Error | undefined,
-  key?: SecretKeyObject
+  key?: SecretKeyObject,
 ) => void;
 
 export const generateKeyPromise = (
   type: SecretKeyType,
-  options: AesKeyGenParams // | HmacKeyGenParams
+  options: AesKeyGenParams, // | HmacKeyGenParams
 ): Promise<[Error | undefined, SecretKeyObject | undefined]> => {
   return new Promise((resolve, reject) => {
     generateKey(type, options, (err, key) => {
@@ -29,7 +29,7 @@ export const generateKeyPromise = (
 export const generateKey = (
   type: SecretKeyType,
   options: AesKeyGenParams, // | HmacKeyGenParams,
-  callback: KeyGenCallback
+  callback: KeyGenCallback,
 ): void => {
   validateLength(type, options.length);
   if (!validateFunction(callback)) {
@@ -47,11 +47,11 @@ export const generateKey = (
 
 export const generateKeySync = (
   type: SecretKeyType,
-  options: AesKeyGenParams // | HmacKeyGenParams,
+  options: AesKeyGenParams, // | HmacKeyGenParams,
 ): SecretKeyObject => {
   validateLength(type, options.length);
   const handle = NativeQuickCrypto.webcrypto.generateSecretKeySync(
-    options.length
+    options.length,
   );
   return new SecretKeyObject(handle);
 };
@@ -62,7 +62,7 @@ const validateLength = (type: SecretKeyType, length: number) => {
       if (!kAesKeyLengths.includes(length)) {
         throw lazyDOMException(
           'AES key length must be 128, 192, or 256 bits',
-          'OperationError'
+          'OperationError',
         );
       }
       break;
@@ -70,7 +70,7 @@ const validateLength = (type: SecretKeyType, length: number) => {
       if (length < 8 || length > 2 ** 31 - 1) {
         throw lazyDOMException(
           'HMAC key length must be between 8 and 2^31 - 1',
-          'OperationError'
+          'OperationError',
         );
       }
       break;