react-native-quick-crypto 0.3.1 → 0.4.1

package/lib/typescript/index.d.ts

@@ -1,2 +1,207 @@
-declare const crypto: any;
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { Buffer } from '@craftzdog/react-native-buffer';
+import FallbackCrypto from 'crypto-browserify';
+declare const crypto: {
+    randomFill<T extends Buffer | ArrayBufferLike | (Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float32Array | Float64Array) | DataView>(buffer: T, callback: (err: Error | null, buf: T) => void): void;
+    randomFill<T_1 extends Buffer | ArrayBufferLike | (Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float32Array | Float64Array) | DataView>(buffer: T_1, offset: number, callback: (err: Error | null, buf: T_1) => void): void;
+    randomFill<T_2 extends Buffer | ArrayBufferLike | (Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float32Array | Float64Array) | DataView>(buffer: T_2, offset: number, size: number, callback: (err: Error | null, buf: T_2) => void): void;
+    randomFillSync<T_3 extends Buffer | ArrayBufferLike | (Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float32Array | Float64Array) | DataView>(buffer: T_3, offset?: number | undefined, size?: number | undefined): T_3;
+    randomBytes(size: number): ArrayBuffer;
+    randomBytes(size: number, callback: (err: Error | null, buf?: ArrayBuffer | undefined) => void): void;
+    randomInt(max: number, callback: (err: Error | null, value: number) => void): void;
+    randomInt(max: number): number;
+    randomInt(min: number, max: number, callback: (err: Error | null, value: number) => void): void;
+    randomInt(min: number, max: number): number;
+    getRandomValues(data: Uint8Array | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array): Uint8Array | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array;
+    rng: typeof import("./random").randomBytes;
+    pseudoRandomBytes: typeof import("./random").randomBytes;
+    prng: typeof import("./random").randomBytes;
+    pbkdf2(password: import("./Utils").BinaryLike, salt: import("./Utils").BinaryLike, iterations: number, keylen: number, digest: string, callback: (err: Error | null, derivedKey?: Buffer | undefined) => void): void;
+    pbkdf2(password: import("./Utils").BinaryLike, salt: import("./Utils").BinaryLike, iterations: number, keylen: number, callback: (err: Error | null, derivedKey?: Buffer | undefined) => void): void;
+    pbkdf2Sync(password: import("./Utils").BinaryLike, salt: import("./Utils").BinaryLike, iterations: number, keylen: number, digest?: string | undefined): Buffer;
+    createHmac: typeof import("./Hmac").createHmac;
+    Hmac: typeof import("./Hmac").createHmac;
+    Hash: typeof import("./Hash").createHash;
+    createHash: typeof import("./Hash").createHash;
+    createCipher: typeof import("./Cipher").createCipher;
+    createCipheriv: typeof import("./Cipher").createCipheriv;
+    createDecipher: typeof import("./Cipher").createDecipher;
+    createDecipheriv: typeof import("./Cipher").createDecipheriv;
+    publicEncrypt: (options: {
+        key: any;
+        encoding?: string | undefined;
+        format?: any;
+        padding?: any;
+        oaepHash?: any;
+        oaepLabel?: any;
+        passphrase?: string | undefined;
+    }, buffer: import("./Utils").BinaryLike) => Buffer;
+    publicDecrypt: (options: {
+        key: any;
+        encoding?: string | undefined;
+        format?: any;
+        padding?: any;
+        oaepHash?: any;
+        oaepLabel?: any;
+        passphrase?: string | undefined;
+    }, buffer: import("./Utils").BinaryLike) => Buffer;
+    privateDecrypt: (options: {
+        key: any;
+        encoding?: string | undefined;
+        format?: any;
+        padding?: any;
+        oaepHash?: any;
+        oaepLabel?: any;
+        passphrase?: string | undefined;
+    }, buffer: import("./Utils").BinaryLike) => Buffer;
+    generateKeyPair: typeof import("./Cipher").generateKeyPair;
+    generateKeyPairSync: typeof import("./Cipher").generateKeyPairSync;
+    createSign: typeof import("./sig").createSign;
+    createVerify: typeof import("./sig").createVerify;
+    constants: {
+        OPENSSL_VERSION_NUMBER: number;
+        SSL_OP_ALL: number;
+        SSL_OP_ALLOW_NO_DHE_KEX: number;
+        SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION: number;
+        SSL_OP_CIPHER_SERVER_PREFERENCE: number;
+        SSL_OP_CISCO_ANYCONNECT: number;
+        SSL_OP_COOKIE_EXCHANGE: number;
+        SSL_OP_CRYPTOPRO_TLSEXT_BUG: number;
+        SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS: number;
+        SSL_OP_EPHEMERAL_RSA: number;
+        SSL_OP_LEGACY_SERVER_CONNECT: number;
+        SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER: number;
+        SSL_OP_MICROSOFT_SESS_ID_BUG: number;
+        SSL_OP_MSIE_SSLV2_RSA_PADDING: number;
+        SSL_OP_NETSCAPE_CA_DN_BUG: number;
+        SSL_OP_NETSCAPE_CHALLENGE_BUG: number;
+        SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG: number;
+        SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG: number;
+        SSL_OP_NO_COMPRESSION: number;
+        SSL_OP_NO_ENCRYPT_THEN_MAC: number;
+        SSL_OP_NO_QUERY_MTU: number;
+        SSL_OP_NO_RENEGOTIATION: number;
+        SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION: number;
+        SSL_OP_NO_SSLv2: number;
+        SSL_OP_NO_SSLv3: number;
+        SSL_OP_NO_TICKET: number;
+        SSL_OP_NO_TLSv1: number;
+        SSL_OP_NO_TLSv1_1: number;
+        SSL_OP_NO_TLSv1_2: number;
+        SSL_OP_NO_TLSv1_3: number;
+        SSL_OP_PKCS1_CHECK_1: number;
+        SSL_OP_PKCS1_CHECK_2: number;
+        SSL_OP_PRIORITIZE_CHACHA: number;
+        SSL_OP_SINGLE_DH_USE: number;
+        SSL_OP_SINGLE_ECDH_USE: number;
+        SSL_OP_SSLEAY_080_CLIENT_DH_BUG: number;
+        SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG: number;
+        SSL_OP_TLS_BLOCK_PADDING_BUG: number;
+        SSL_OP_TLS_D5_BUG: number;
+        SSL_OP_TLS_ROLLBACK_BUG: number;
+        ENGINE_METHOD_RSA: number;
+        ENGINE_METHOD_DSA: number;
+        ENGINE_METHOD_DH: number;
+        ENGINE_METHOD_RAND: number;
+        ENGINE_METHOD_EC: number;
+        ENGINE_METHOD_CIPHERS: number;
+        ENGINE_METHOD_DIGESTS: number;
+        ENGINE_METHOD_PKEY_METHS: number;
+        ENGINE_METHOD_PKEY_ASN1_METHS: number;
+        ENGINE_METHOD_ALL: number;
+        ENGINE_METHOD_NONE: number;
+        DH_CHECK_P_NOT_SAFE_PRIME: number;
+        DH_CHECK_P_NOT_PRIME: number;
+        DH_UNABLE_TO_CHECK_GENERATOR: number;
+        DH_NOT_SUITABLE_GENERATOR: number;
+        ALPN_ENABLED: number;
+        RSA_PKCS1_PADDING: number;
+        RSA_SSLV23_PADDING: number;
+        RSA_NO_PADDING: number;
+        RSA_PKCS1_OAEP_PADDING: number;
+        RSA_X931_PADDING: number;
+        RSA_PKCS1_PSS_PADDING: number;
+        RSA_PSS_SALTLEN_DIGEST: number;
+        RSA_PSS_SALTLEN_MAX_SIGN: number;
+        RSA_PSS_SALTLEN_AUTO: number;
+        defaultCoreCipherList: string;
+        TLS1_VERSION: number;
+        TLS1_1_VERSION: number;
+        TLS1_2_VERSION: number;
+        TLS1_3_VERSION: number;
+        POINT_CONVERSION_COMPRESSED: number;
+        POINT_CONVERSION_UNCOMPRESSED: number;
+        POINT_CONVERSION_HYBRID: number;
+    };
+    generateKey(type: "hmac" | "aes", options: {
+        length: number;
+    }, callback: (err: Error | null, key: FallbackCrypto.KeyObject) => void): void;
+    generateKeySync(type: "hmac" | "aes", options: {
+        length: number;
+    }): FallbackCrypto.KeyObject;
+    createPrivateKey(key: string | globalThis.Buffer | FallbackCrypto.PrivateKeyInput | FallbackCrypto.JsonWebKeyInput): FallbackCrypto.KeyObject;
+    createPublicKey(key: string | globalThis.Buffer | FallbackCrypto.KeyObject | FallbackCrypto.JsonWebKeyInput | FallbackCrypto.PublicKeyInput): FallbackCrypto.KeyObject;
+    createSecretKey(key: NodeJS.ArrayBufferView): FallbackCrypto.KeyObject;
+    createSecretKey(key: string, encoding: BufferEncoding): FallbackCrypto.KeyObject;
+    createDiffieHellman(primeLength: number, generator?: number | NodeJS.ArrayBufferView | undefined): FallbackCrypto.DiffieHellman;
+    createDiffieHellman(prime: NodeJS.ArrayBufferView): FallbackCrypto.DiffieHellman;
+    createDiffieHellman(prime: string, primeEncoding: FallbackCrypto.BinaryToTextEncoding): FallbackCrypto.DiffieHellman;
+    createDiffieHellman(prime: string, primeEncoding: FallbackCrypto.BinaryToTextEncoding, generator: number | NodeJS.ArrayBufferView): FallbackCrypto.DiffieHellman;
+    createDiffieHellman(prime: string, primeEncoding: FallbackCrypto.BinaryToTextEncoding, generator: string, generatorEncoding: FallbackCrypto.BinaryToTextEncoding): FallbackCrypto.DiffieHellman;
+    getDiffieHellman(groupName: string): FallbackCrypto.DiffieHellman;
+    scrypt(password: FallbackCrypto.BinaryLike, salt: FallbackCrypto.BinaryLike, keylen: number, callback: (err: Error | null, derivedKey: globalThis.Buffer) => void): void;
+    scrypt(password: FallbackCrypto.BinaryLike, salt: FallbackCrypto.BinaryLike, keylen: number, options: FallbackCrypto.ScryptOptions, callback: (err: Error | null, derivedKey: globalThis.Buffer) => void): void;
+    scryptSync(password: FallbackCrypto.BinaryLike, salt: FallbackCrypto.BinaryLike, keylen: number, options?: FallbackCrypto.ScryptOptions | undefined): globalThis.Buffer;
+    privateEncrypt(privateKey: FallbackCrypto.RsaPrivateKey | FallbackCrypto.KeyLike, buffer: NodeJS.ArrayBufferView): globalThis.Buffer;
+    getCiphers(): string[];
+    getCurves(): string[];
+    getFips(): 0 | 1;
+    getHashes(): string[];
+    createECDH(curveName: string): FallbackCrypto.ECDH;
+    timingSafeEqual(a: NodeJS.ArrayBufferView, b: NodeJS.ArrayBufferView): boolean;
+    sign(algorithm: string | null | undefined, data: NodeJS.ArrayBufferView, key: FallbackCrypto.KeyLike | FallbackCrypto.SignKeyObjectInput | FallbackCrypto.SignPrivateKeyInput): globalThis.Buffer;
+    sign(algorithm: string | null | undefined, data: NodeJS.ArrayBufferView, key: FallbackCrypto.KeyLike | FallbackCrypto.SignKeyObjectInput | FallbackCrypto.SignPrivateKeyInput, callback: (error: Error | null, data: globalThis.Buffer) => void): void;
+    verify(algorithm: string | null | undefined, data: NodeJS.ArrayBufferView, key: FallbackCrypto.KeyLike | FallbackCrypto.VerifyKeyObjectInput | FallbackCrypto.VerifyPublicKeyInput, signature: NodeJS.ArrayBufferView): boolean;
+    verify(algorithm: string | null | undefined, data: NodeJS.ArrayBufferView, key: FallbackCrypto.KeyLike | FallbackCrypto.VerifyKeyObjectInput | FallbackCrypto.VerifyPublicKeyInput, signature: NodeJS.ArrayBufferView, callback: (error: Error | null, result: boolean) => void): void;
+    diffieHellman(options: {
+        privateKey: FallbackCrypto.KeyObject;
+        publicKey: FallbackCrypto.KeyObject;
+    }): globalThis.Buffer;
+    getCipherInfo(nameOrNid: string | number, options?: FallbackCrypto.CipherInfoOptions | undefined): FallbackCrypto.CipherInfo | undefined;
+    hkdf(digest: string, irm: FallbackCrypto.KeyObject | FallbackCrypto.BinaryLike, salt: FallbackCrypto.BinaryLike, info: FallbackCrypto.BinaryLike, keylen: number, callback: (err: Error | null, derivedKey: ArrayBuffer) => void): void;
+    hkdfSync(digest: string, ikm: FallbackCrypto.KeyObject | FallbackCrypto.BinaryLike, salt: FallbackCrypto.BinaryLike, info: FallbackCrypto.BinaryLike, keylen: number): ArrayBuffer;
+    secureHeapUsed(): FallbackCrypto.SecureHeapUsage;
+    randomUUID(options?: FallbackCrypto.RandomUUIDOptions | undefined): string;
+    generatePrime(size: number, callback: (err: Error | null, prime: ArrayBuffer) => void): void;
+    generatePrime(size: number, options: FallbackCrypto.GeneratePrimeOptionsBigInt, callback: (err: Error | null, prime: bigint) => void): void;
+    generatePrime(size: number, options: FallbackCrypto.GeneratePrimeOptionsArrayBuffer, callback: (err: Error | null, prime: ArrayBuffer) => void): void;
+    generatePrime(size: number, options: FallbackCrypto.GeneratePrimeOptions, callback: (err: Error | null, prime: bigint | ArrayBuffer) => void): void;
+    generatePrimeSync(size: number): ArrayBuffer;
+    generatePrimeSync(size: number, options: FallbackCrypto.GeneratePrimeOptionsBigInt): bigint;
+    generatePrimeSync(size: number, options: FallbackCrypto.GeneratePrimeOptionsArrayBuffer): ArrayBuffer;
+    generatePrimeSync(size: number, options: FallbackCrypto.GeneratePrimeOptions): bigint | ArrayBuffer;
+    checkPrime(value: FallbackCrypto.LargeNumberLike, callback: (err: Error | null, result: boolean) => void): void;
+    checkPrime(value: FallbackCrypto.LargeNumberLike, options: FallbackCrypto.CheckPrimeOptions, callback: (err: Error | null, result: boolean) => void): void;
+    checkPrimeSync(candidate: FallbackCrypto.LargeNumberLike, options?: FallbackCrypto.CheckPrimeOptions | undefined): boolean;
+    Certificate: FallbackCrypto.Certificate & {
+        (): FallbackCrypto.Certificate;
+        new (): FallbackCrypto.Certificate;
+        exportChallenge(spkac: FallbackCrypto.BinaryLike): globalThis.Buffer;
+        exportPublicKey(spkac: FallbackCrypto.BinaryLike, encoding?: string | undefined): globalThis.Buffer;
+        verifySpkac(spkac: NodeJS.ArrayBufferView): boolean;
+    };
+    fips: boolean;
+    KeyObject: typeof FallbackCrypto.KeyObject;
+    Cipher: typeof FallbackCrypto.Cipher;
+    Decipher: typeof FallbackCrypto.Decipher;
+    Sign: typeof FallbackCrypto.Sign;
+    Verify: typeof FallbackCrypto.Verify;
+    DiffieHellman: typeof FallbackCrypto.DiffieHellman;
+    ECDH: typeof FallbackCrypto.ECDH;
+    DEFAULT_ENCODING: BufferEncoding;
+    X509Certificate: typeof FallbackCrypto.X509Certificate;
+    webcrypto: typeof FallbackCrypto.webcrypto;
+};
 export default crypto;

package/lib/typescript/sig.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import Stream from 'stream';
+import { BinaryLike } from './Utils';
+declare class Verify extends Stream.Writable {
+    private internal;
+    constructor(algorithm: string, options: Stream.WritableOptions);
+    _write(chunk: BinaryLike, encoding: string, callback: () => void): void;
+    update(data: BinaryLike, encoding?: string): this;
+    verify(options: {
+        key: string | Buffer;
+        format?: string;
+        type?: string;
+        passphrase?: string;
+        padding?: number;
+        saltLength?: number;
+    }, signature: BinaryLike): boolean;
+}
+declare class Sign extends Stream.Writable {
+    private internal;
+    constructor(algorithm: string, options: Stream.WritableOptions);
+    _write(chunk: BinaryLike, encoding: string, callback: () => void): void;
+    update(data: BinaryLike, encoding?: string): this;
+    sign(options: {
+        key: string | Buffer;
+        format?: string;
+        type?: string;
+        passphrase?: string;
+        padding?: number;
+        saltLength?: number;
+    }, encoding?: string): string | Buffer;
+}
+export declare function createSign(algorithm: string, options?: any): Sign;
+export declare function createVerify(algorithm: string, options?: any): Verify;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-quick-crypto",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "description": "A fast implementation of Node's `crypto` module written in C/C++ JSI",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -128,7 +128,8 @@
       ]
     },
     "globals": {
-      "BufferEncoding": true
+      "BufferEncoding": true,
+      "Buffer": true
     }
   },
   "eslintIgnore": [

package/src/@types/crypto-browserify.d.ts

@@ -0,0 +1,4 @@
+declare module 'crypto-browserify' {
+  import Crypto from 'crypto';
+  export = Crypto;
+}

package/src/NativeQuickCrypto/NativeQuickCrypto.ts

@@ -11,6 +11,7 @@ import type {
   GenerateKeyPairMethod,
   GenerateKeyPairSyncMethod,
 } from './Cipher';
+import type { CreateSignMethod, CreateVerifyMethod } from './sig';
 
 interface NativeQuickCryptoSpec {
   createHmac: CreateHmacMethod;
@@ -24,6 +25,8 @@ interface NativeQuickCryptoSpec {
   privateDecrypt: PrivateDecryptMethod;
   generateKeyPair: GenerateKeyPairMethod;
   generateKeyPairSync: GenerateKeyPairSyncMethod;
+  createSign: CreateSignMethod;
+  createVerify: CreateVerifyMethod;
 }
 
 // global func declaration for JSI functions

package/src/NativeQuickCrypto/sig.ts

@@ -0,0 +1,17 @@
+// TODO Add real types to sign/verify, the problem is that because of encryption schemes
+// they will have variable amount of parameters
+export type InternalSign = {
+  init: (algorithm: string) => void;
+  update: (data: ArrayBuffer) => void;
+  sign: (...args: any) => Uint8Array; // returns raw bytes
+};
+
+export type InternalVerify = {
+  init: (algorithm: string) => void;
+  update: (data: ArrayBuffer) => void;
+  verify: (...args: any) => boolean;
+};
+
+export type CreateSignMethod = () => InternalSign;
+
+export type CreateVerifyMethod = () => InternalVerify;

package/src/QuickCrypto.ts

@@ -11,6 +11,7 @@ import {
   generateKeyPair,
   generateKeyPairSync,
 } from './Cipher';
+import { createSign, createVerify } from './sig';
 import { createHmac } from './Hmac';
 import { createHash } from './Hash';
 import { constants } from './constants';
@@ -29,6 +30,8 @@ export const QuickCrypto = {
   privateDecrypt,
   generateKeyPair,
   generateKeyPairSync,
+  createSign,
+  createVerify,
   constants,
   ...pbkdf2,
   ...random,

package/src/index.ts

@@ -1,13 +1,14 @@
 import { Buffer } from '@craftzdog/react-native-buffer';
 import { QuickCrypto } from './QuickCrypto';
+import FallbackCrypto from 'crypto-browserify';
 
-// @ts-expect-error
+// @ts-expect-error Buffer does not match exact same type definition.
 global.Buffer = Buffer;
-// @ts-expect-error
-global.crypto = QuickCrypto; // for randombytes https://github.com/crypto-browserify/randombytes/blob/master/browser.js#L16
 
-const fallbackCrypto = require('crypto-browserify');
-const crypto = { ...fallbackCrypto, ...QuickCrypto }; // Maybe use proxy to not load everything?
+const crypto = { ...FallbackCrypto, ...QuickCrypto };
+
+// for randombytes https://github.com/crypto-browserify/randombytes/blob/master/browser.js#L16
+// @ts-expect-error QuickCrypto is missing `subtle` and `randomUUID`
 global.crypto = crypto;
 
 module.exports = crypto;

package/src/keys.ts

@@ -36,7 +36,7 @@ function option(name: string, objName: string | undefined) {
 }
 
 function parseKeyFormat(
-  formatStr: string,
+  formatStr: string | undefined,
   defaultFormat: KFormatType | undefined,
   optionName?: string
 ) {
@@ -50,10 +50,10 @@ function parseKeyFormat(
 }
 
 function parseKeyType(
-  typeStr: string,
+  typeStr: string | undefined,
   required: boolean,
-  keyType: string,
-  isPublic: boolean,
+  keyType: string | undefined,
+  isPublic: boolean | undefined,
   optionName: string
 ) {
   if (typeStr === undefined && !required) {
@@ -63,10 +63,6 @@ function parseKeyType(
       throw new Error(
         `Crypto incompatible key options: ${typeStr} can only be used for RSA keys`
       );
-      // throw new ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS(
-      //   typeStr,
-      //   'can only be used for RSA keys'
-      // );
     }
     return KeyEncoding.kKeyEncodingPKCS1;
   } else if (typeStr === 'spki' && isPublic !== false) {
@@ -86,10 +82,17 @@ function parseKeyType(
 }
 
 function parseKeyFormatAndType(
-  enc: any,
-  keyType: any,
-  isPublic: any,
-  objName: any
+  enc: {
+    key: any;
+    type?: string;
+    encoding?: string;
+    format?: string;
+    cipher?: string;
+    passphrase?: string;
+  },
+  keyType: string | undefined,
+  isPublic: boolean | undefined,
+  objName: string | undefined
 ) {
   const { format: formatStr, type: typeStr } = enc;
 
@@ -103,6 +106,7 @@ function parseKeyFormatAndType(
   const isRequired =
     (!isInput || format === KFormatType.kKeyFormatDER) &&
     format !== KFormatType.kKeyFormatJWK;
+
   const type = parseKeyType(
     typeStr,
     isRequired,
@@ -116,6 +120,7 @@ function parseKeyFormatAndType(
 function parseKeyEncoding(
   enc: {
     key: any;
+    type?: string;
     encoding?: string;
     format?: string;
     cipher?: string;
@@ -123,7 +128,7 @@ function parseKeyEncoding(
   },
   keyType: string | undefined,
   isPublic: boolean | undefined,
-  objName?: string
+  objName?: string | undefined
 ) {
   // validateObject(enc, 'options');
 

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);
-}