react-native-quick-crypto 0.7.10 → 0.7.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-quick-crypto",
-  "version": "0.7.10",
+  "version": "0.7.11",
   "description": "A fast implementation of Node's `crypto` module written in C/C++ JSI",
   "packageManager": "bun@1.1.26",
   "main": "lib/commonjs/index",
@@ -26,17 +26,16 @@
     "!**/__mocks__"
   ],
   "scripts": {
+    "clean": "del-cli android/build lib",
+    "deepclean": "del-cli node_modules",
     "tsc": "tsc --noEmit",
     "typescript": "tsc --noEmit",
     "lint": "eslint \"**/*.{js,ts,tsx}\"",
     "lint:fix": "eslint \"**/*.{js,ts,tsx}\" --fix",
     "format": "prettier --check \"**/*.{js,ts,tsx}\"",
     "format:fix": "prettier --write \"**/*.{js,ts,tsx}\"",
-    "prepare": "bob build",
+    "prepare": "bun clean && bun tsc && bob build",
     "release": "release-it",
-    "example": "cd example && bun start",
-    "pods": "cd example && bun install && bun pods",
-    "bootstrap": "bun install && bun pods && bun example",
     "test": "jest"
   },
   "keywords": [
@@ -53,7 +52,11 @@
     "type": "git",
     "url": "git+https://github.com/margelo/react-native-quick-crypto.git"
   },
-  "authors": "Szymon Kapała (szymon20000@gmail.com) & Marc Rousavy <me@mrousavy.com> (https://github.com/mrousavy)",
+  "authors": [
+    "Szymon Kapała <szymon20000@gmail.com>",
+    "Marc Rousavy <me@mrousavy.com> (https://github.com/mrousavy)",
+    "Brad Anderson <brad@sankatygroup.com> (https://github.com/boorad)"
+  ],
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/margelo/react-native-quick-crypto/issues"
@@ -71,69 +74,50 @@
   },
   "devDependencies": {
     "@eslint/compat": "^1.1.1",
-    "@eslint/js": "10.0.0",
-    "@react-native/babel-preset": "^0.75.0-main",
-    "@react-native/eslint-config": "^0.75.0-main",
-    "@react-native/eslint-plugin": "^0.75.0-main",
+    "@eslint/js": "9.17.0",
+    "@react-native/babel-preset": "0.76.5",
+    "@react-native/eslint-config": "0.76.5",
+    "@react-native/eslint-plugin": "0.76.5",
     "@release-it/conventional-changelog": "^9.0.3",
     "@types/jest": "^29.5.11",
     "@types/node": "^22.0.0",
     "@types/react": "^18.0.33",
     "@types/readable-stream": "^4.0.11",
+    "del-cli": "^6.0.0",
     "eslint": "9.15.0",
     "eslint-plugin-react-native": "^4.1.0",
     "jest": "^29.7.0",
     "prettier": "3.3.3",
-    "react": "^18.2.0",
-    "react-native": "^0.72.7",
-    "react-native-builder-bob": "0.32.1",
-    "release-it": "^17.2.0",
+    "react": "18.2.0",
+    "react-native": "0.72.7",
+    "react-native-builder-bob": "0.35.2",
+    "release-it": "17.11.0",
     "sscrypto": "^1.1.1",
-    "typescript": "5.6.3",
-    "typescript-eslint": "8.15.0"
-  },
-  "peerDependencies": {
-    "react": "*",
-    "react-native": "*"
+    "typescript": "5.7.2",
+    "typescript-eslint": "8.19.0"
   },
   "release-it": {
-    "git": {
-      "commitMessage": "chore: release ${version}",
-      "tagName": "v${version}"
-    },
     "npm": {
       "publish": true
     },
+    "git": false,
     "github": {
-      "release": true
+      "release": false
+    },
+    "hooks": {
+      "after:bump": "bun tsc && bun lint && bun format && bun prepare"
     },
     "plugins": {
-      "@release-it/conventional-changelog": {
-        "preset": {
-          "name": "conventionalcommits",
-          "types": [
-            {
-              "type": "feat",
-              "section": "✨ Features"
-            },
-            {
-              "type": "fix",
-              "section": "🐛 Bug Fixes"
-            },
-            {
-              "type": "perf",
-              "section": "💨 Performance Improvements"
-            },
-            {
-              "type": "chore(deps)",
-              "section": "🛠️ Dependency Upgrades"
-            },
-            {
-              "type": "docs",
-              "section": "📚 Documentation"
-            }
-          ]
-        }
+      "@release-it/bumper": {
+        "out": [
+          {
+            "file": "../../packages/example/package.json",
+            "path": [
+              "version",
+              "dependencies.react-native-quick-crypto"
+            ]
+          }
+        ]
       }
     }
   },
@@ -150,5 +134,9 @@
         }
       ]
     ]
-  }
+  },
+  "workspaces": [
+    ".",
+    "example"
+  ]
 }

package/react-native-quick-crypto.podspec

@@ -11,7 +11,7 @@ Pod::Spec.new do |s|
   s.authors      = package["authors"]
 
   s.platforms    = { :ios => "12.4", :tvos => "12.0", :osx => "10.14" }
-  s.source       = { :git => "https://github.com/mrousavy/react-native-quick-crypto.git", :tag => "#{s.version}" }
+  s.source       = { :git => "https://github.com/margelo/react-native-quick-crypto.git", :tag => "#{s.version}" }
 
   s.source_files = [
     "ios/**/*.{h,m,mm}",

package/src/Algorithms.ts

@@ -0,0 +1,247 @@
+import type {
+  AnyAlgorithm,
+  DeriveBitsAlgorithm,
+  DigestAlgorithm,
+  EncryptDecryptAlgorithm,
+  EncryptDecryptParams,
+  KeyPairAlgorithm,
+  SecretKeyAlgorithm,
+  SignVerifyAlgorithm,
+  SubtleAlgorithm,
+} from './keys';
+
+type SupportedAlgorithm<Type extends string> = {
+  [key in Type]: string | null;
+};
+
+type SupportedAlgorithms = {
+  digest: SupportedAlgorithm<DigestAlgorithm>;
+  generateKey: SupportedAlgorithm<KeyPairAlgorithm | SecretKeyAlgorithm>;
+  sign: SupportedAlgorithm<SignVerifyAlgorithm>;
+  verify: SupportedAlgorithm<SignVerifyAlgorithm>;
+  importKey: SupportedAlgorithm<
+    KeyPairAlgorithm | 'PBKDF2' | SecretKeyAlgorithm | 'HKDF'
+  >;
+  deriveBits: SupportedAlgorithm<DeriveBitsAlgorithm>;
+  encrypt: SupportedAlgorithm<EncryptDecryptAlgorithm>;
+  decrypt: SupportedAlgorithm<EncryptDecryptAlgorithm>;
+  'get key length': SupportedAlgorithm<SecretKeyAlgorithm | 'PBKDF2' | 'HKDF'>;
+  wrapKey: SupportedAlgorithm<'AES-KW'>;
+  unwrapKey: SupportedAlgorithm<'AES-KW'>;
+};
+
+export type Operation =
+  | 'digest'
+  | 'generateKey'
+  | 'sign'
+  | 'verify'
+  | 'importKey'
+  | 'deriveBits'
+  | 'encrypt'
+  | 'decrypt'
+  | 'get key length'
+  | 'wrapKey'
+  | 'unwrapKey';
+
+const kSupportedAlgorithms: SupportedAlgorithms = {
+  digest: {
+    'SHA-1': null,
+    'SHA-256': null,
+    'SHA-384': null,
+    'SHA-512': null,
+  },
+  generateKey: {
+    'RSASSA-PKCS1-v1_5': 'RsaHashedKeyGenParams',
+    'RSA-PSS': 'RsaHashedKeyGenParams',
+    'RSA-OAEP': 'RsaHashedKeyGenParams',
+    ECDSA: 'EcKeyGenParams',
+    ECDH: 'EcKeyGenParams',
+    'AES-CTR': 'AesKeyGenParams',
+    'AES-CBC': 'AesKeyGenParams',
+    'AES-GCM': 'AesKeyGenParams',
+    'AES-KW': 'AesKeyGenParams',
+    HMAC: 'HmacKeyGenParams',
+    X25519: null,
+    Ed25519: null,
+    X448: null,
+    Ed448: null,
+  },
+  sign: {
+    'RSASSA-PKCS1-v1_5': null,
+    'RSA-PSS': 'RsaPssParams',
+    ECDSA: 'EcdsaParams',
+    HMAC: null,
+    Ed25519: null,
+    Ed448: 'Ed448Params',
+  },
+  verify: {
+    'RSASSA-PKCS1-v1_5': null,
+    'RSA-PSS': 'RsaPssParams',
+    ECDSA: 'EcdsaParams',
+    HMAC: null,
+    Ed25519: null,
+    Ed448: 'Ed448Params',
+  },
+  importKey: {
+    'RSASSA-PKCS1-v1_5': 'RsaHashedImportParams',
+    'RSA-PSS': 'RsaHashedImportParams',
+    'RSA-OAEP': 'RsaHashedImportParams',
+    ECDSA: 'EcKeyImportParams',
+    ECDH: 'EcKeyImportParams',
+    HMAC: 'HmacImportParams',
+    HKDF: null,
+    PBKDF2: null,
+    'AES-CTR': null,
+    'AES-CBC': null,
+    'AES-GCM': null,
+    'AES-KW': null,
+    Ed25519: null,
+    X25519: null,
+    Ed448: null,
+    X448: null,
+  },
+  deriveBits: {
+    HKDF: 'HkdfParams',
+    PBKDF2: 'Pbkdf2Params',
+    ECDH: 'EcdhKeyDeriveParams',
+    X25519: 'EcdhKeyDeriveParams',
+    X448: 'EcdhKeyDeriveParams',
+  },
+  encrypt: {
+    'RSA-OAEP': 'RsaOaepParams',
+    'AES-CBC': 'AesCbcParams',
+    'AES-GCM': 'AesGcmParams',
+    'AES-CTR': 'AesCtrParams',
+  },
+  decrypt: {
+    'RSA-OAEP': 'RsaOaepParams',
+    'AES-CBC': 'AesCbcParams',
+    'AES-GCM': 'AesGcmParams',
+    'AES-CTR': 'AesCtrParams',
+  },
+  'get key length': {
+    'AES-CBC': 'AesDerivedKeyParams',
+    'AES-CTR': 'AesDerivedKeyParams',
+    'AES-GCM': 'AesDerivedKeyParams',
+    'AES-KW': 'AesDerivedKeyParams',
+    HMAC: 'HmacImportParams',
+    HKDF: null,
+    PBKDF2: null,
+  },
+  wrapKey: {
+    'AES-KW': null,
+  },
+  unwrapKey: {
+    'AES-KW': null,
+  },
+};
+
+type AlgorithmDictionaries = {
+  [key in string]: object;
+};
+
+const simpleAlgorithmDictionaries: AlgorithmDictionaries = {
+  AesGcmParams: { iv: 'BufferSource', additionalData: 'BufferSource' },
+  RsaHashedKeyGenParams: { hash: 'HashAlgorithmIdentifier' },
+  EcKeyGenParams: {},
+  HmacKeyGenParams: { hash: 'HashAlgorithmIdentifier' },
+  RsaPssParams: {},
+  EcdsaParams: { hash: 'HashAlgorithmIdentifier' },
+  HmacImportParams: { hash: 'HashAlgorithmIdentifier' },
+  HkdfParams: {
+    hash: 'HashAlgorithmIdentifier',
+    salt: 'BufferSource',
+    info: 'BufferSource',
+  },
+  Ed448Params: { context: 'BufferSource' },
+  Pbkdf2Params: { hash: 'HashAlgorithmIdentifier', salt: 'BufferSource' },
+  RsaOaepParams: { label: 'BufferSource' },
+  RsaHashedImportParams: { hash: 'HashAlgorithmIdentifier' },
+  EcKeyImportParams: {},
+};
+
+// https://w3c.github.io/webcrypto/#algorithm-normalization-normalize-an-algorithm
+// adapted for Node.js from Deno's implementation
+// https://github.com/denoland/deno/blob/v1.29.1/ext/crypto/00_crypto.js#L195
+export const normalizeAlgorithm = (
+  algorithm: SubtleAlgorithm | EncryptDecryptParams | AnyAlgorithm,
+  op: Operation,
+): SubtleAlgorithm | EncryptDecryptParams => {
+  if (typeof algorithm === 'string') {
+    return normalizeAlgorithm({ name: algorithm }, op);
+  }
+
+  // 1.
+  const registeredAlgorithms = kSupportedAlgorithms[op];
+  // 2. 3.
+  // commented, because typescript takes care of this for us 🤞👀
+  // const initialAlg = webidl.converters.Algorithm(algorithm, {
+  //   prefix: 'Failed to normalize algorithm',
+  //   context: 'passed algorithm',
+  // });
+
+  // 4.
+  let algName = algorithm.name;
+  if (algName === undefined) return { name: 'unknown' };
+
+  // 5.
+  let desiredType: string | null | undefined;
+  for (const key in registeredAlgorithms) {
+    if (!Object.prototype.hasOwnProperty.call(registeredAlgorithms, key)) {
+      continue;
+    }
+    if (key.toUpperCase() === algName.toUpperCase()) {
+      algName = key as AnyAlgorithm;
+      desiredType = (
+        registeredAlgorithms as Record<string, typeof desiredType>
+      )[algName];
+    }
+  }
+  if (desiredType === undefined)
+    throw new Error(`Unrecognized algorithm name: ${algName}`);
+
+  // Fast path everything below if the registered dictionary is null
+  if (desiredType === null) return { name: algName };
+
+  // 6.
+  const normalizedAlgorithm = algorithm;
+  // TODO: implement this?  Maybe via typescript?
+  // webidl.converters[desiredType](algorithm, {
+  //   prefix: 'Failed to normalize algorithm',
+  //   context: 'passed algorithm',
+  // });
+  // 7.
+  normalizedAlgorithm.name = algName;
+
+  // 9.
+  const dict = simpleAlgorithmDictionaries[desiredType];
+  // 10.
+  const dictKeys = dict ? Object.keys(dict) : [];
+  for (let i = 0; i < dictKeys.length; i++) {
+    const member = dictKeys[i] || '';
+    if (!Object.prototype.hasOwnProperty.call(dict, member)) continue;
+    // TODO: implement this?  Maybe via typescript?
+    // const idlType = dict[member];
+    // const idlValue = normalizedAlgorithm[member];
+    // 3.
+    // if (idlType === 'BufferSource' && idlValue) {
+    //   const isView = ArrayBufferIsView(idlValue);
+    //   normalizedAlgorithm[member] = TypedArrayPrototypeSlice(
+    //     new Uint8Array(
+    //       isView ? getDataViewOrTypedArrayBuffer(idlValue) : idlValue,
+    //       isView ? getDataViewOrTypedArrayByteOffset(idlValue) : 0,
+    //       isView
+    //         ? getDataViewOrTypedArrayByteLength(idlValue)
+    //         : ArrayBufferPrototypeGetByteLength(idlValue)
+    //     )
+    //   );
+    // } else if (idlType === 'HashAlgorithmIdentifier') {
+    //   normalizedAlgorithm[member] = normalizeAlgorithm(idlValue, 'digest');
+    // } else if (idlType === 'AlgorithmIdentifier') {
+    //   // This extension point is not used by any supported algorithm (yet?)
+    //   throw lazyDOMException('Not implemented.', 'NotSupportedError');
+    // }
+  }
+
+  return normalizedAlgorithm;
+};

package/src/Hash.ts

@@ -135,5 +135,5 @@ const internalDigest = (
   const normalizedHashName = normalizeHashName(algorithm.name);
   const hash = new Hash(normalizedHashName);
   hash.update(bufferLikeToArrayBuffer(data));
-  return hash.digest();
+  return toArrayBuffer(hash.digest());
 };

package/src/Hashnames.ts

@@ -1,4 +1,4 @@
-import type { HashAlgorithm, SubtleAlgorithm } from './keys';
+import type { HashAlgorithmIdentifier, HashAlgorithm } from './keys';
 
 export enum HashContext {
   Node,
@@ -79,7 +79,7 @@ const kHashNames: HashNames = {
 }
 
 export function normalizeHashName(
-  algo: string | HashAlgorithm | SubtleAlgorithm | undefined,
+  algo: string | HashAlgorithm | HashAlgorithmIdentifier | undefined,
   context: HashContext = HashContext.Node,
 ): HashAlgorithm {
   if (typeof algo !== 'undefined') {
@@ -91,8 +91,8 @@ export function normalizeHashName(
       const alias = kHashNames[normAlgo]![context] as HashAlgorithm;
       if (alias) return alias;
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    } catch (_e) {
-      // ignore
+    } catch (_e: unknown) {
+      /* empty */
     }
   }
   throw new Error(`Invalid Hash Algorithm: ${algo}`);