react-native-quick-crypto 0.3.0 → 0.4.0

package/src/sig.ts

@@ -0,0 +1,179 @@
+import { NativeQuickCrypto } from './NativeQuickCrypto/NativeQuickCrypto';
+import type { InternalSign, InternalVerify } from './NativeQuickCrypto/sig';
+import Stream from 'stream';
+
+// TODO(osp) same as publicCipher on node this are defined on C++ and exposed to node
+// Do the same here
+enum DSASigEnc {
+  kSigEncDER,
+  kSigEncP1363,
+}
+
+import {
+  BinaryLike,
+  binaryLikeToArrayBuffer,
+  getDefaultEncoding,
+} from './Utils';
+import { preparePrivateKey, preparePublicOrPrivateKey } from './keys';
+
+const createInternalSign = NativeQuickCrypto.createSign;
+const createInternalVerify = NativeQuickCrypto.createVerify;
+
+function getPadding(options: any) {
+  return getIntOption('padding', options);
+}
+
+function getSaltLength(options: any) {
+  return getIntOption('saltLength', options);
+}
+
+function getDSASignatureEncoding(options: any) {
+  if (typeof options === 'object') {
+    const { dsaEncoding = 'der' } = options;
+    if (dsaEncoding === 'der') return DSASigEnc.kSigEncDER;
+    else if (dsaEncoding === 'ieee-p1363') return DSASigEnc.kSigEncP1363;
+    throw new Error(`options.dsaEncoding: ${dsaEncoding} not a valid encoding`);
+  }
+
+  return DSASigEnc.kSigEncDER;
+}
+
+function getIntOption(name: string, options: any) {
+  const value = options[name];
+  if (value !== undefined) {
+    if (value === value >> 0) {
+      return value;
+    }
+    throw new Error(`options.${name}: ${value} not a valid int value`);
+  }
+  return undefined;
+}
+
+class Verify extends Stream.Writable {
+  private internal: InternalVerify;
+  constructor(algorithm: string, options: Stream.WritableOptions) {
+    super(options);
+    this.internal = createInternalVerify();
+    this.internal.init(algorithm);
+  }
+
+  _write(chunk: BinaryLike, encoding: string, callback: () => void) {
+    this.update(chunk, encoding);
+    callback();
+  }
+
+  update(data: BinaryLike, encoding?: string) {
+    encoding = encoding ?? getDefaultEncoding();
+    data = binaryLikeToArrayBuffer(data, encoding);
+    this.internal.update(data);
+    return this;
+  }
+
+  verify(
+    options: {
+      key: string | Buffer;
+      format?: string;
+      type?: string;
+      passphrase?: string;
+      padding?: number;
+      saltLength?: number;
+    },
+    signature: BinaryLike
+  ): boolean {
+    if (!options) {
+      throw new Error('Crypto sign key required');
+    }
+
+    const { data, format, type, passphrase } =
+      preparePublicOrPrivateKey(options);
+
+    const rsaPadding = getPadding(options);
+    const pssSaltLength = getSaltLength(options);
+
+    // Options specific to (EC)DSA
+    const dsaSigEnc = getDSASignatureEncoding(options);
+
+    const ret = this.internal.verify(
+      data,
+      format,
+      type,
+      passphrase,
+      binaryLikeToArrayBuffer(signature),
+      rsaPadding,
+      pssSaltLength,
+      dsaSigEnc
+    );
+
+    return ret;
+  }
+}
+
+class Sign extends Stream.Writable {
+  private internal: InternalSign;
+  constructor(algorithm: string, options: Stream.WritableOptions) {
+    super(options);
+    this.internal = createInternalSign();
+    this.internal.init(algorithm);
+  }
+
+  _write(chunk: BinaryLike, encoding: string, callback: () => void) {
+    this.update(chunk, encoding);
+    callback();
+  }
+
+  update(data: BinaryLike, encoding?: string) {
+    encoding = encoding ?? getDefaultEncoding();
+    data = binaryLikeToArrayBuffer(data, encoding);
+    this.internal.update(data);
+    return this;
+  }
+
+  sign(
+    options: {
+      key: string | Buffer;
+      format?: string;
+      type?: string;
+      passphrase?: string;
+      padding?: number;
+      saltLength?: number;
+    },
+    encoding?: string
+  ) {
+    if (!options) {
+      throw new Error('Crypto sign key required');
+    }
+
+    const { data, format, type, passphrase } = preparePrivateKey(options);
+
+    const rsaPadding = getPadding(options);
+    const pssSaltLength = getSaltLength(options);
+
+    // Options specific to (EC)DSA
+    const dsaSigEnc = getDSASignatureEncoding(options);
+
+    const ret = this.internal.sign(
+      data,
+      format,
+      type,
+      passphrase,
+      rsaPadding,
+      pssSaltLength,
+      dsaSigEnc
+    );
+
+    encoding = encoding || getDefaultEncoding();
+    if (encoding && encoding !== 'buffer') {
+      return Buffer.from(ret).toString(encoding as any);
+    }
+
+    return Buffer.from(ret);
+  }
+}
+
+export function createSign(algorithm: string, options?: any) {
+  return new Sign(algorithm, options);
+}
+
+export function createVerify(algorithm: string, options?: any) {
+  return new Verify(algorithm, options);
+}

package/android/src/main/java/com/reactnativequickcrypto/QuickCryptoModule.java

@@ -1,70 +0,0 @@
-package com.reactnativequickcrypto;
-
-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);
-}