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

package/src/{NativeQuickCrypto/pbkdf2.ts → specs/pbkdf2.nitro.ts}

@@ -1,16 +1,18 @@
-export type Pbkdf2Object = {
-  pbkdf2: (
+import { type HybridObject } from 'react-native-nitro-modules';
+
+export interface Pbkdf2 extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  pbkdf2(
     password: ArrayBuffer,
     salt: ArrayBuffer,
     iterations: number,
     keylen: number,
     digest: string,
-  ) => Promise<ArrayBuffer>;
-  pbkdf2Sync: (
+  ): Promise<ArrayBuffer>;
+  pbkdf2Sync(
     password: ArrayBuffer,
     salt: ArrayBuffer,
     iterations: number,
     keylen: number,
     digest: string,
-  ) => ArrayBuffer;
-};
+  ): ArrayBuffer;
+}

package/src/specs/random.nitro.ts

@@ -0,0 +1,14 @@
+import { type HybridObject } from 'react-native-nitro-modules';
+
+export interface Random extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  randomFill(
+    buffer: ArrayBuffer,
+    offset: number,
+    size: number,
+  ): Promise<ArrayBuffer>;
+  randomFillSync(
+    buffer: ArrayBuffer,
+    offset: number,
+    size: number,
+  ): ArrayBuffer;
+}

package/src/utils/conversion.ts

@@ -0,0 +1,123 @@
+import { Buffer as CraftzdogBuffer } from '@craftzdog/react-native-buffer';
+import { Buffer as SafeBuffer } from 'safe-buffer';
+import type { ABV, BinaryLikeNode, BufferLike } from './types';
+
+/**
+ * Converts supplied argument to an ArrayBuffer.  Note this does not copy the
+ * data so it is faster than toArrayBuffer.  Not copying is important for
+ * functions like randomFill which need to be able to write to the underlying
+ * buffer.
+ * @param buf
+ * @returns ArrayBuffer
+ */
+export const abvToArrayBuffer = (buf: ABV) => {
+  if (CraftzdogBuffer.isBuffer(buf)) {
+    return buf.buffer as ArrayBuffer;
+  }
+  if (ArrayBuffer.isView(buf)) {
+    return buf.buffer as ArrayBuffer;
+  }
+  return buf as ArrayBuffer;
+};
+
+/**
+ * Converts supplied argument to an ArrayBuffer.  Note this copies data if the
+ * supplied buffer has the .slice() method, so can be a bit slow.
+ * @param buf
+ * @returns ArrayBuffer
+ */
+export function toArrayBuffer(
+  buf: CraftzdogBuffer | SafeBuffer | ArrayBufferView,
+): ArrayBuffer {
+  if (CraftzdogBuffer.isBuffer(buf) || ArrayBuffer.isView(buf)) {
+    if (buf?.buffer?.slice) {
+      return buf.buffer.slice(
+        buf.byteOffset,
+        buf.byteOffset + buf.byteLength,
+      ) as ArrayBuffer;
+    } else {
+      return buf.buffer as ArrayBuffer;
+    }
+  }
+  const ab = new ArrayBuffer(buf.length);
+  const view = new Uint8Array(ab);
+  for (let i = 0; i < buf.length; ++i) {
+    view[i] = SafeBuffer.isBuffer(buf) ? buf.readUInt8(i) : buf[i]!;
+  }
+  return ab;
+}
+
+export function bufferLikeToArrayBuffer(buf: BufferLike): ArrayBuffer {
+  // Buffer
+  if (CraftzdogBuffer.isBuffer(buf) || SafeBuffer.isBuffer(buf)) {
+    return toArrayBuffer(buf);
+  }
+  // ArrayBufferView
+  if (ArrayBuffer.isView(buf)) {
+    return toArrayBuffer(buf);
+  }
+  // ArrayBuffer
+  return buf;
+}
+
+export function binaryLikeToArrayBuffer(
+  input: BinaryLikeNode, // CipherKey adds compat with node types
+  encoding: string = 'utf-8',
+): ArrayBuffer {
+  // string
+  if (typeof input === 'string') {
+    if (encoding === 'buffer') {
+      throw new Error(
+        'Cannot create a buffer from a string with a buffer encoding',
+      );
+    }
+
+    const buffer = CraftzdogBuffer.from(input, encoding);
+
+    return buffer.buffer.slice(
+      buffer.byteOffset,
+      buffer.byteOffset + buffer.byteLength,
+    );
+  }
+
+  // Buffer
+  if (CraftzdogBuffer.isBuffer(input) || SafeBuffer.isBuffer(input)) {
+    return toArrayBuffer(input);
+  }
+
+  // ArrayBufferView
+  // TODO add further binary types to BinaryLike, UInt8Array and so for have this array as property
+  if (ArrayBuffer.isView(input)) {
+    return toArrayBuffer(input);
+  }
+
+  // ArrayBuffer
+  if (input instanceof ArrayBuffer) {
+    return input;
+  }
+
+  // if (!(input instanceof ArrayBuffer)) {
+  //   try {
+  //     // this is a strange fallback case and input is unknown at this point
+  //     const buffer = Buffer.from(input as unknown as string);
+  //     return buffer.buffer.slice(
+  //       buffer.byteOffset,
+  //       buffer.byteOffset + buffer.byteLength
+  //     );
+  //   } catch(e: unknown) {
+  //     console.log('throwing 1');
+  //     const err = e as Error;
+  //     throw new Error(err.message);
+  //   }
+  // }
+
+  // TODO: handle if input is KeyObject?
+
+  throw new Error('input could not be converted to ArrayBuffer');
+}
+
+export function ab2str(buf: ArrayBuffer, encoding: string = 'hex') {
+  return CraftzdogBuffer.from(buf).toString(encoding);
+}
+
+export const kEmptyObject = Object.freeze(Object.create(null));

package/src/utils/errors.ts

@@ -0,0 +1,15 @@
+type DOMName =
+  | string
+  | {
+      name: string;
+      cause: unknown;
+    };
+
+export function lazyDOMException(message: string, domName: DOMName): Error {
+  let cause = '';
+  if (typeof domName !== 'string') {
+    cause = `\nCaused by: ${domName.cause}`;
+  }
+
+  return new Error(`[${domName}]: ${message}${cause}`);
+}

package/src/{Hashnames.ts → utils/hashnames.ts}

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

package/src/utils/index.ts

@@ -0,0 +1,5 @@
+export * from './conversion';
+export * from './errors';
+export * from './hashnames';
+export * from './types';
+export * from './validation';

package/src/utils/types.ts

@@ -0,0 +1,275 @@
+import type { Buffer as CraftzdogBuffer } from '@craftzdog/react-native-buffer';
+import type { Buffer as SafeBuffer } from 'safe-buffer';
+import type { CipherKey } from 'crypto'; // @types/node
+import type { KeyObjectHandle } from '../specs/keyObjectHandle.nitro';
+
+export type ABV = TypedArray | DataView | ArrayBufferLike | CraftzdogBuffer;
+
+export type TypedArray =
+  | Uint8Array
+  | Uint8ClampedArray
+  | Uint16Array
+  | Uint32Array
+  | Int8Array
+  | Int16Array
+  | Int32Array
+  | Float32Array
+  | Float64Array;
+
+export type RandomCallback<T> = (err: Error | null, value: T) => void;
+
+export type BufferLike =
+  | ArrayBuffer
+  | CraftzdogBuffer
+  | SafeBuffer
+  | ArrayBufferView;
+
+export type BinaryLike =
+  | string
+  | ArrayBuffer
+  | CraftzdogBuffer
+  | SafeBuffer
+  | TypedArray
+  | DataView;
+
+export type BinaryLikeNode = CipherKey | BinaryLike;
+
+export type DigestAlgorithm = 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512';
+
+export type HashAlgorithm = DigestAlgorithm | 'SHA-224' | 'RIPEMD-160';
+
+export type RSAKeyPairAlgorithm = 'RSASSA-PKCS1-v1_5' | 'RSA-PSS' | 'RSA-OAEP';
+
+export type ECKeyPairAlgorithm = 'ECDSA' | 'ECDH';
+
+export type CFRGKeyPairAlgorithm = 'Ed25519' | 'Ed448' | 'X25519' | 'X448';
+export type CFRGKeyPairType = 'ed25519' | 'ed448' | 'x25519' | 'x448';
+
+export type KeyPairAlgorithm =
+  | RSAKeyPairAlgorithm
+  | ECKeyPairAlgorithm
+  | CFRGKeyPairAlgorithm;
+
+export type AESAlgorithm = 'AES-CTR' | 'AES-CBC' | 'AES-GCM' | 'AES-KW';
+
+export type SecretKeyAlgorithm = 'HMAC' | AESAlgorithm;
+
+export type SignVerifyAlgorithm =
+  | 'RSASSA-PKCS1-v1_5'
+  | 'RSA-PSS'
+  | 'ECDSA'
+  | 'HMAC'
+  | 'Ed25519'
+  | 'Ed448';
+
+export type DeriveBitsAlgorithm =
+  | 'PBKDF2'
+  | 'HKDF'
+  | 'ECDH'
+  | 'X25519'
+  | 'X448';
+
+export type EncryptDecryptAlgorithm =
+  | 'RSA-OAEP'
+  | 'AES-CTR'
+  | 'AES-CBC'
+  | 'AES-GCM';
+
+export type AnyAlgorithm =
+  | DigestAlgorithm
+  | HashAlgorithm
+  | KeyPairAlgorithm
+  | SecretKeyAlgorithm
+  | SignVerifyAlgorithm
+  | DeriveBitsAlgorithm
+  | EncryptDecryptAlgorithm
+  | AESAlgorithm
+  | 'PBKDF2'
+  | 'HKDF'
+  | 'unknown';
+
+export type NamedCurve = 'P-256' | 'P-384' | 'P-521';
+
+export type SubtleAlgorithm = {
+  name: AnyAlgorithm;
+  salt?: string;
+  iterations?: number;
+  hash?: HashAlgorithm;
+  namedCurve?: NamedCurve;
+  length?: number;
+  modulusLength?: number;
+  publicExponent?: number | Uint8Array;
+};
+
+export type KeyPairType = CFRGKeyPairType;
+
+export type KeyUsage =
+  | 'encrypt'
+  | 'decrypt'
+  | 'sign'
+  | 'verify'
+  | 'deriveKey'
+  | 'deriveBits'
+  | 'wrapKey'
+  | 'unwrapKey';
+
+// On node this value is defined on the native side, for now I'm just creating it here in JS
+// TODO(osp) move this into native side to make sure they always match
+export enum KFormatType {
+  kKeyFormatDER,
+  kKeyFormatPEM,
+  kKeyFormatJWK,
+}
+
+// Same as KFormatType, this enum needs to be defined on the native side
+export enum KeyType {
+  Secret,
+  Public,
+  Private,
+}
+
+export enum KeyEncoding {
+  kKeyEncodingPKCS1,
+  kKeyEncodingPKCS8,
+  kKeyEncodingSPKI,
+  kKeyEncodingSEC1,
+}
+
+export type KeyPairGenConfig = {
+  publicFormat?: KFormatType;
+  publicType?: KeyEncoding;
+  privateFormat?: KFormatType;
+  privateType?: KeyEncoding;
+  cipher?: string;
+  passphrase?: ArrayBuffer;
+};
+
+export type AsymmetricKeyType =
+  // 'rsa' |
+  // 'rsa-pss' |
+  // 'dsa' |
+  // 'ec' |
+  // 'dh' |
+  CFRGKeyPairType;
+
+type JWKkty = 'AES' | 'RSA' | 'EC' | 'oct';
+type JWKuse = 'sig' | 'enc';
+
+export interface JWK {
+  kty?: JWKkty;
+  use?: JWKuse;
+  key_ops?: KeyUsage[];
+  alg?: string; // TODO: enumerate these (RFC-7517)
+  crv?: string;
+  kid?: string;
+  x5u?: string;
+  x5c?: string[];
+  x5t?: string;
+  'x5t#256'?: string;
+  n?: string;
+  e?: string;
+  d?: string;
+  p?: string;
+  q?: string;
+  x?: string;
+  y?: string;
+  k?: string;
+  dp?: string;
+  dq?: string;
+  qi?: string;
+  ext?: boolean;
+}
+
+export type KTypePrivate = 'pkcs1' | 'pkcs8' | 'sec1';
+export type KTypePublic = 'pkcs1' | 'spki';
+export type KType = KTypePrivate | KTypePublic;
+
+export type KFormat = 'der' | 'pem' | 'jwk';
+
+export type DSAEncoding = 'der' | 'ieee-p1363';
+
+export type EncodingOptions = {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  key?: any;
+  type?: KType;
+  encoding?: string;
+  dsaEncoding?: DSAEncoding;
+  format?: KFormat;
+  padding?: number;
+  cipher?: string;
+  passphrase?: BinaryLike;
+  saltLength?: number;
+  oaepHash?: string;
+  oaepLabel?: BinaryLike;
+};
+
+export interface KeyDetail {
+  length?: number;
+  publicExponent?: number;
+  modulusLength?: number;
+  hashAlgorithm?: string;
+  mgf1HashAlgorithm?: string;
+  saltLength?: number;
+  namedCurve?: string;
+}
+
+export type GenerateKeyPairOptions = {
+  modulusLength?: number; // Key size in bits (RSA, DSA).
+  publicExponent?: number; // Public exponent (RSA). Default: 0x10001.
+  hashAlgorithm?: string; // Name of the message digest (RSA-PSS).
+  mgf1HashAlgorithm?: string; // string Name of the message digest used by MGF1 (RSA-PSS).
+  saltLength?: number; // Minimal salt length in bytes (RSA-PSS).
+  divisorLength?: number; // Size of q in bits (DSA).
+  namedCurve?: string; // Name of the curve to use (EC).
+  prime?: CraftzdogBuffer; // The prime parameter (DH).
+  primeLength?: number; // Prime length in bits (DH).
+  generator?: number; // Custom generator (DH). Default: 2.
+  groupName?: string; // Diffie-Hellman group name (DH). See crypto.getDiffieHellman().
+  publicKeyEncoding?: EncodingOptions; // See keyObject.export().
+  privateKeyEncoding?: EncodingOptions; // See keyObject.export().
+  paramEncoding?: string;
+  hash?: string;
+  mgf1Hash?: string;
+};
+
+// Note: removed CryptoKey class from this type (from 0.x) because Nitro doesn't
+//       handle custom JS objects.  We might need to make it a JS object.
+export type KeyPairKey = ArrayBuffer | KeyObjectHandle | undefined;
+
+export type GenerateKeyPairReturn = [
+  error?: Error,
+  privateKey?: KeyPairKey,
+  publicKey?: KeyPairKey,
+];
+
+export type GenerateKeyPairCallback = (
+  error?: Error,
+  publicKey?: KeyPairKey,
+  privateKey?: KeyPairKey,
+) => GenerateKeyPairReturn | void;
+
+export type KeyPair = {
+  publicKey?: KeyPairKey;
+  privateKey?: KeyPairKey;
+};
+
+export type GenerateKeyPairPromiseReturn = [error?: Error, keypair?: KeyPair];
+
+export type CryptoKeyPair = {
+  publicKey: KeyPairKey;
+  privateKey: KeyPairKey;
+};
+
+export enum KeyVariant {
+  RSA_SSA_PKCS1_v1_5,
+  RSA_PSS,
+  RSA_OAEP,
+  DSA,
+  EC,
+  NID,
+  DH,
+}
+
+export type SignCallback = (err: Error | null, signature?: ArrayBuffer) => void;
+
+export type VerifyCallback = (err: Error | null, valid?: boolean) => void;

package/src/utils/validation.ts

@@ -0,0 +1,35 @@
+export function validateFunction(f: unknown): boolean {
+  return f !== null && typeof f === 'function';
+}
+
+export function isStringOrBuffer(val: unknown): val is string | ArrayBuffer {
+  return (
+    typeof val === 'string' ||
+    ArrayBuffer.isView(val) ||
+    val instanceof ArrayBuffer
+  );
+}
+
+export function validateObject<T>(
+  value: unknown,
+  name: string,
+  options?: {
+    allowArray: boolean;
+    allowFunction: boolean;
+    nullable: boolean;
+  } | null,
+): value is T {
+  const useDefaultOptions = options == null;
+  const allowArray = useDefaultOptions ? false : options.allowArray;
+  const allowFunction = useDefaultOptions ? false : options.allowFunction;
+  const nullable = useDefaultOptions ? false : options.nullable;
+  if (
+    (!nullable && value === null) ||
+    (!allowArray && Array.isArray(value)) ||
+    (typeof value !== 'object' &&
+      (!allowFunction || typeof value !== 'function'))
+  ) {
+    throw new Error(`${name} is not a valid object $${value}`);
+  }
+  return true;
+}

package/android/src/main/java/com/margelo/quickcrypto/QuickCryptoModule.java

@@ -1,70 +0,0 @@
-package com.margelo.quickcrypto;
-
-import android.util.Log;
-
-import androidx.annotation.NonNull;
-
-import com.facebook.jni.HybridData;
-import com.facebook.proguard.annotations.DoNotStrip;
-import com.facebook.react.bridge.JavaScriptContextHolder;
-import com.facebook.react.bridge.ReactContextBaseJavaModule;
-import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReactMethod;
-import com.facebook.react.module.annotations.ReactModule;
-import com.facebook.react.turbomodule.core.CallInvokerHolderImpl;
-
-@ReactModule(name = QuickCryptoModule.NAME)
-public class QuickCryptoModule extends ReactContextBaseJavaModule {
-  public static final String NAME = "QuickCrypto";
-
-  @DoNotStrip
-  private HybridData mHybridData;
-
-  private native HybridData initHybrid();
-
-  public QuickCryptoModule(ReactApplicationContext reactContext) {
-    super(reactContext);
-  }
-
-  @NonNull
-  @Override
-  public String getName() {
-    return NAME;
-  }
-
-  @ReactMethod(isBlockingSynchronousMethod = true)
-  public boolean install() {
-    try {
-      if (mHybridData != null) {
-        return false;
-      }
-      Log.i(NAME, "Loading C++ library...");
-      System.loadLibrary("reactnativequickcrypto");
-
-      JavaScriptContextHolder jsContext = getReactApplicationContext().getJavaScriptContextHolder();
-      CallInvokerHolderImpl jsCallInvokerHolder = (CallInvokerHolderImpl) getReactApplicationContext()
-                                                  .getCatalystInstance()
-                                                  .getJSCallInvokerHolder();
-
-
-      Log.i(NAME, "Installing JSI Bindings for react-native-quick-crypto...");
-      mHybridData = initHybrid();
-      nativeInstall(jsContext.get(), jsCallInvokerHolder);
-      Log.i(NAME, "Successfully installed JSI Bindings for react-native-quick-crypto!");
-
-      return true;
-    } catch (Exception exception) {
-      Log.e(NAME, "Failed to install JSI Bindings for react-native-quick-crypto!", exception);
-      return false;
-    }
-  }
-
-  public void destroy() {
-    if (mHybridData == null) {
-      return;
-    }
-    mHybridData.resetNative();
-  }
-
-  private native void nativeInstall(long jsiPtr, CallInvokerHolderImpl jsCallInvokerHolder);
-}

package/android/src/main/java/com/margelo/quickcrypto/QuickCryptoPackage.java

@@ -1,25 +0,0 @@
-package com.margelo.quickcrypto;
-
-import androidx.annotation.NonNull;
-
-import com.facebook.react.ReactPackage;
-import com.facebook.react.bridge.NativeModule;
-import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.uimanager.ViewManager;
-
-import java.util.Collections;
-import java.util.List;
-
-public class QuickCryptoPackage implements ReactPackage {
-  @NonNull
-  @Override
-  public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
-    return Collections.singletonList(new QuickCryptoModule(reactContext));
-  }
-
-  @NonNull
-  @Override
-  public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
-    return Collections.emptyList();
-  }
-}