react-native-quick-crypto 0.3.0 → 0.4.0

package/lib/module/sig.js.map

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

package/lib/typescript/Cipher.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import Stream from 'stream';
+import Stream from 'stream-browserify';
 import { BinaryLike, CipherEncoding, Encoding } from './Utils';
 import { Buffer } from '@craftzdog/react-native-buffer';
 declare class CipherCommon extends Stream.Transform {

package/lib/typescript/Hash.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import 'react-native';
 import { Encoding } from './Utils';
-import Stream from 'stream';
+import Stream from 'stream-browserify';
 import { Buffer } from '@craftzdog/react-native-buffer';
 interface HashOptionsBase extends Stream.TransformOptions {
     outputLength?: number | undefined;

package/lib/typescript/Hmac.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { Encoding, BinaryLike } from './Utils';
-import Stream from 'stream';
+import Stream from 'stream-browserify';
 import { Buffer } from '@craftzdog/react-native-buffer';
 export declare function createHmac(algorithm: string, key: BinaryLike, options?: Stream.TransformOptions): Hmac;
 declare class Hmac extends Stream.Transform {

package/lib/typescript/NativeQuickCrypto/NativeQuickCrypto.d.ts

@@ -3,6 +3,7 @@ import type { CreateHashMethod } from './hash';
 import type { Pbkdf2Object } from './pbkdf2';
 import type { RandomObject } from './random';
 import type { CreateCipherMethod, CreateDecipherMethod, PublicEncryptMethod, PrivateDecryptMethod, GenerateKeyPairMethod, GenerateKeyPairSyncMethod } from './Cipher';
+import type { CreateSignMethod, CreateVerifyMethod } from './sig';
 interface NativeQuickCryptoSpec {
     createHmac: CreateHmacMethod;
     pbkdf2: Pbkdf2Object;
@@ -15,6 +16,8 @@ interface NativeQuickCryptoSpec {
     privateDecrypt: PrivateDecryptMethod;
     generateKeyPair: GenerateKeyPairMethod;
     generateKeyPairSync: GenerateKeyPairSyncMethod;
+    createSign: CreateSignMethod;
+    createVerify: CreateVerifyMethod;
 }
 declare global {
     function nativeCallSyncHook(): unknown;

package/lib/typescript/NativeQuickCrypto/sig.d.ts

@@ -0,0 +1,12 @@
+export declare type InternalSign = {
+    init: (algorithm: string) => void;
+    update: (data: ArrayBuffer) => void;
+    sign: (...args: any) => Uint8Array;
+};
+export declare type InternalVerify = {
+    init: (algorithm: string) => void;
+    update: (data: ArrayBuffer) => void;
+    verify: (...args: any) => boolean;
+};
+export declare type CreateSignMethod = () => InternalSign;
+export declare type CreateVerifyMethod = () => InternalVerify;

package/lib/typescript/QuickCrypto.d.ts

@@ -1,5 +1,6 @@
 import * as random from './random';
 import { createCipher, createCipheriv, createDecipher, createDecipheriv, generateKeyPair, generateKeyPairSync } from './Cipher';
+import { createSign, createVerify } from './sig';
 import { createHmac } from './Hmac';
 import { createHash } from './Hash';
 export declare const QuickCrypto: {
@@ -57,6 +58,8 @@ export declare const QuickCrypto: {
     }, buffer: import("./Utils").BinaryLike) => import("@craftzdog/react-native-buffer").Buffer;
     generateKeyPair: typeof generateKeyPair;
     generateKeyPairSync: typeof generateKeyPairSync;
+    createSign: typeof createSign;
+    createVerify: typeof createVerify;
     constants: {
         OPENSSL_VERSION_NUMBER: number;
         SSL_OP_ALL: number;

package/lib/typescript/index.d.ts

@@ -1,3 +1,207 @@
-import { QuickCrypto } from './QuickCrypto';
-export * from './QuickCrypto';
-export default QuickCrypto;
+/// <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.0",
+  "version": "0.4.0",
   "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": [
@@ -163,6 +164,7 @@
     "react-native-quick-base64": "^2.0.2",
     "stream": "^0.0.2",
     "stream-browserify": "^3.0.0",
-    "string_decoder": "^1.3.0"
+    "string_decoder": "^1.3.0",
+    "crypto-browserify": "^3.12.0"
   }
 }

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

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

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

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

package/src/Cipher.ts

@@ -1,6 +1,6 @@
 /* eslint-disable no-dupe-class-members */
 import { NativeQuickCrypto } from './NativeQuickCrypto/NativeQuickCrypto';
-import Stream from 'stream';
+import Stream from 'stream-browserify';
 import {
   BinaryLike,
   binaryLikeToArrayBuffer,
@@ -749,6 +749,7 @@ export function generateKeyPairSync(
   type: string,
   options?: GenerateKeyPairOptions
 ): { publicKey: any; privateKey: any } {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   const [_, publicKey, privateKey] = internalGenerateKeyPair(
     false,
     type,

package/src/Hash.ts

@@ -3,7 +3,7 @@ import 'react-native';
 import { NativeQuickCrypto } from './NativeQuickCrypto/NativeQuickCrypto';
 import type { InternalHash } from './NativeQuickCrypto/hash';
 import { Encoding, toArrayBuffer } from './Utils';
-import Stream from 'stream';
+import Stream from 'stream-browserify';
 import { Buffer } from '@craftzdog/react-native-buffer';
 interface HashOptionsBase extends Stream.TransformOptions {
   outputLength?: number | undefined;

package/src/Hmac.ts

@@ -7,7 +7,7 @@ import {
   BinaryLike,
   binaryLikeToArrayBuffer,
 } from './Utils';
-import Stream from 'stream';
+import Stream from 'stream-browserify';
 import { Buffer } from '@craftzdog/react-native-buffer';
 
 const createInternalHmac = NativeQuickCrypto.createHmac;

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,5 +1,15 @@
+import { Buffer } from '@craftzdog/react-native-buffer';
 import { QuickCrypto } from './QuickCrypto';
+import FallbackCrypto from 'crypto-browserify';
 
-export * from './QuickCrypto';
+// @ts-expect-error Buffer does not match exact same type definition.
+global.Buffer = Buffer;
 
-export default QuickCrypto;
+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;
+export default 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');