@hxa-rn/react-native-quick-crypto 1.1.0-beta.1

package/dist/module/x509certificate.js

@@ -0,0 +1,186 @@
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { NitroModules } from 'react-native-nitro-modules';
+import { Buffer } from '@craftzdog/react-native-buffer';
+import { PublicKeyObject, KeyObject } from './keys';
+import { binaryLikeToArrayBuffer } from './utils';
+const X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT = 0x1;
+const X509_CHECK_FLAG_NO_WILDCARDS = 0x2;
+const X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS = 0x4;
+const X509_CHECK_FLAG_MULTI_LABEL_WILDCARDS = 0x8;
+const X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS = 0x10;
+const X509_CHECK_FLAG_NEVER_CHECK_SUBJECT = 0x20;
+function getFlags(options) {
+  if (!options) return 0;
+  let flags = 0;
+  if (options.subject === 'always') {
+    flags |= X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT;
+  } else if (options.subject === 'never') {
+    flags |= X509_CHECK_FLAG_NEVER_CHECK_SUBJECT;
+  }
+  if (options.wildcards === false) {
+    flags |= X509_CHECK_FLAG_NO_WILDCARDS;
+  }
+  if (options.partialWildcards === false) {
+    flags |= X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS;
+  }
+  if (options.multiLabelWildcards === true) {
+    flags |= X509_CHECK_FLAG_MULTI_LABEL_WILDCARDS;
+  }
+  if (options.singleLabelSubdomains === true) {
+    flags |= X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS;
+  }
+  return flags;
+}
+export class X509Certificate {
+  constructor(buffer) {
+    _defineProperty(this, "handle", void 0);
+    _defineProperty(this, "cache", new Map());
+    this.handle = NitroModules.createHybridObject('X509CertificateHandle');
+    let ab;
+    if (typeof buffer === 'string') {
+      ab = Buffer.from(buffer).buffer;
+    } else {
+      ab = binaryLikeToArrayBuffer(buffer);
+    }
+    this.handle.init(ab);
+  }
+  cached(key, compute) {
+    if (this.cache.has(key)) {
+      return this.cache.get(key);
+    }
+    const value = compute();
+    this.cache.set(key, value);
+    return value;
+  }
+  get subject() {
+    return this.cached('subject', () => this.handle.subject());
+  }
+  get subjectAltName() {
+    return this.cached('subjectAltName', () => this.handle.subjectAltName());
+  }
+  get issuer() {
+    return this.cached('issuer', () => this.handle.issuer());
+  }
+  get infoAccess() {
+    return this.cached('infoAccess', () => this.handle.infoAccess());
+  }
+  get validFrom() {
+    return this.cached('validFrom', () => this.handle.validFrom());
+  }
+  get validTo() {
+    return this.cached('validTo', () => this.handle.validTo());
+  }
+  get validFromDate() {
+    return this.cached('validFromDate', () => new Date(this.handle.validFromDate()));
+  }
+  get validToDate() {
+    return this.cached('validToDate', () => new Date(this.handle.validToDate()));
+  }
+  get fingerprint() {
+    return this.cached('fingerprint', () => this.handle.fingerprint());
+  }
+  get fingerprint256() {
+    return this.cached('fingerprint256', () => this.handle.fingerprint256());
+  }
+  get fingerprint512() {
+    return this.cached('fingerprint512', () => this.handle.fingerprint512());
+  }
+  get extKeyUsage() {
+    return this.cached('extKeyUsage', () => this.handle.keyUsage());
+  }
+  get keyUsage() {
+    return this.extKeyUsage;
+  }
+  get serialNumber() {
+    return this.cached('serialNumber', () => this.handle.serialNumber());
+  }
+  get signatureAlgorithm() {
+    return this.cached('signatureAlgorithm', () => this.handle.signatureAlgorithm());
+  }
+  get signatureAlgorithmOid() {
+    return this.cached('signatureAlgorithmOid', () => this.handle.signatureAlgorithmOid());
+  }
+  get ca() {
+    return this.cached('ca', () => this.handle.ca());
+  }
+  get raw() {
+    return this.cached('raw', () => Buffer.from(this.handle.raw()));
+  }
+  get publicKey() {
+    return this.cached('publicKey', () => new PublicKeyObject(this.handle.publicKey()));
+  }
+  get issuerCertificate() {
+    return undefined;
+  }
+  checkHost(name, options) {
+    if (typeof name !== 'string') {
+      throw new TypeError('The "name" argument must be a string');
+    }
+    return this.handle.checkHost(name, getFlags(options));
+  }
+  checkEmail(email, options) {
+    if (typeof email !== 'string') {
+      throw new TypeError('The "email" argument must be a string');
+    }
+    return this.handle.checkEmail(email, getFlags(options));
+  }
+  checkIP(ip) {
+    if (typeof ip !== 'string') {
+      throw new TypeError('The "ip" argument must be a string');
+    }
+    return this.handle.checkIP(ip);
+  }
+  checkIssued(otherCert) {
+    if (!(otherCert instanceof X509Certificate)) {
+      throw new TypeError('The "otherCert" argument must be an instance of X509Certificate');
+    }
+    return this.handle.checkIssued(otherCert.handle);
+  }
+  checkPrivateKey(pkey) {
+    if (!(pkey instanceof KeyObject)) {
+      throw new TypeError('The "pkey" argument must be an instance of KeyObject');
+    }
+    if (pkey.type !== 'private') {
+      throw new TypeError('The "pkey" argument must be a private key');
+    }
+    return this.handle.checkPrivateKey(pkey.handle);
+  }
+  verify(pkey) {
+    if (!(pkey instanceof KeyObject)) {
+      throw new TypeError('The "pkey" argument must be an instance of KeyObject');
+    }
+    if (pkey.type !== 'public') {
+      throw new TypeError(`The "pkey" argument must be a public key, got '${pkey.type}'`);
+    }
+    return this.handle.verify(pkey.handle);
+  }
+  toString() {
+    return this.cached('pem', () => this.handle.pem());
+  }
+  toJSON() {
+    return this.toString();
+  }
+  toLegacyObject() {
+    return {
+      subject: this.subject,
+      issuer: this.issuer,
+      subjectaltname: this.subjectAltName,
+      infoAccess: this.infoAccess,
+      ca: this.ca,
+      modulus: undefined,
+      bits: undefined,
+      exponent: undefined,
+      valid_from: this.validFrom,
+      valid_to: this.validTo,
+      fingerprint: this.fingerprint,
+      fingerprint256: this.fingerprint256,
+      fingerprint512: this.fingerprint512,
+      ext_key_usage: this.keyUsage,
+      serialNumber: this.serialNumber,
+      raw: this.raw
+    };
+  }
+}
+//# sourceMappingURL=x509certificate.js.map

package/dist/module/x509certificate.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NitroModules","Buffer","PublicKeyObject","KeyObject","binaryLikeToArrayBuffer","X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT","X509_CHECK_FLAG_NO_WILDCARDS","X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS","X509_CHECK_FLAG_MULTI_LABEL_WILDCARDS","X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS","X509_CHECK_FLAG_NEVER_CHECK_SUBJECT","getFlags","options","flags","subject","wildcards","partialWildcards","multiLabelWildcards","singleLabelSubdomains","X509Certificate","constructor","buffer","_defineProperty","Map","handle","createHybridObject","ab","from","init","cached","key","compute","cache","has","get","value","set","subjectAltName","issuer","infoAccess","validFrom","validTo","validFromDate","Date","validToDate","fingerprint","fingerprint256","fingerprint512","extKeyUsage","keyUsage","serialNumber","signatureAlgorithm","signatureAlgorithmOid","ca","raw","publicKey","issuerCertificate","undefined","checkHost","name","TypeError","checkEmail","email","checkIP","ip","checkIssued","otherCert","checkPrivateKey","pkey","type","verify","toString","pem","toJSON","toLegacyObject","subjectaltname","modulus","bits","exponent","valid_from","valid_to","ext_key_usage"],"sources":["x509certificate.ts"],"sourcesContent":["import { NitroModules } from 'react-native-nitro-modules';\r\nimport { Buffer } from '@craftzdog/react-native-buffer';\r\nimport type { X509CertificateHandle } from './specs/v1/x509certificate.nitro';\r\nimport { PublicKeyObject, KeyObject } from './keys';\r\nimport type { BinaryLike } from './utils';\r\nimport { binaryLikeToArrayBuffer } from './utils';\r\n\r\nconst X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT = 0x1;\r\nconst X509_CHECK_FLAG_NO_WILDCARDS = 0x2;\r\nconst X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS = 0x4;\r\nconst X509_CHECK_FLAG_MULTI_LABEL_WILDCARDS = 0x8;\r\nconst X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS = 0x10;\r\nconst X509_CHECK_FLAG_NEVER_CHECK_SUBJECT = 0x20;\r\n\r\nexport interface X509LegacyObject {\r\n  subject: string;\r\n  issuer: string;\r\n  subjectaltname: string;\r\n  infoAccess: string;\r\n  ca: boolean;\r\n  modulus: undefined;\r\n  bits: undefined;\r\n  exponent: undefined;\r\n  valid_from: string;\r\n  valid_to: string;\r\n  fingerprint: string;\r\n  fingerprint256: string;\r\n  fingerprint512: string;\r\n  ext_key_usage: string[];\r\n  serialNumber: string;\r\n  raw: Buffer;\r\n}\r\n\r\nexport interface CheckOptions {\r\n  subject?: 'default' | 'always' | 'never';\r\n  wildcards?: boolean;\r\n  partialWildcards?: boolean;\r\n  multiLabelWildcards?: boolean;\r\n  singleLabelSubdomains?: boolean;\r\n}\r\n\r\nfunction getFlags(options?: CheckOptions): number {\r\n  if (!options) return 0;\r\n\r\n  let flags = 0;\r\n\r\n  if (options.subject === 'always') {\r\n    flags |= X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT;\r\n  } else if (options.subject === 'never') {\r\n    flags |= X509_CHECK_FLAG_NEVER_CHECK_SUBJECT;\r\n  }\r\n\r\n  if (options.wildcards === false) {\r\n    flags |= X509_CHECK_FLAG_NO_WILDCARDS;\r\n  }\r\n\r\n  if (options.partialWildcards === false) {\r\n    flags |= X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS;\r\n  }\r\n\r\n  if (options.multiLabelWildcards === true) {\r\n    flags |= X509_CHECK_FLAG_MULTI_LABEL_WILDCARDS;\r\n  }\r\n\r\n  if (options.singleLabelSubdomains === true) {\r\n    flags |= X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS;\r\n  }\r\n\r\n  return flags;\r\n}\r\n\r\nexport class X509Certificate {\r\n  private readonly handle: X509CertificateHandle;\r\n  private readonly cache = new Map<string, unknown>();\r\n\r\n  constructor(buffer: BinaryLike) {\r\n    this.handle = NitroModules.createHybridObject<X509CertificateHandle>(\r\n      'X509CertificateHandle',\r\n    );\r\n\r\n    let ab: ArrayBuffer;\r\n    if (typeof buffer === 'string') {\r\n      ab = Buffer.from(buffer).buffer as ArrayBuffer;\r\n    } else {\r\n      ab = binaryLikeToArrayBuffer(buffer);\r\n    }\r\n\r\n    this.handle.init(ab);\r\n  }\r\n\r\n  private cached<T>(key: string, compute: () => T): T {\r\n    if (this.cache.has(key)) {\r\n      return this.cache.get(key) as T;\r\n    }\r\n    const value = compute();\r\n    this.cache.set(key, value);\r\n    return value;\r\n  }\r\n\r\n  get subject(): string {\r\n    return this.cached('subject', () => this.handle.subject());\r\n  }\r\n\r\n  get subjectAltName(): string {\r\n    return this.cached('subjectAltName', () => this.handle.subjectAltName());\r\n  }\r\n\r\n  get issuer(): string {\r\n    return this.cached('issuer', () => this.handle.issuer());\r\n  }\r\n\r\n  get infoAccess(): string {\r\n    return this.cached('infoAccess', () => this.handle.infoAccess());\r\n  }\r\n\r\n  get validFrom(): string {\r\n    return this.cached('validFrom', () => this.handle.validFrom());\r\n  }\r\n\r\n  get validTo(): string {\r\n    return this.cached('validTo', () => this.handle.validTo());\r\n  }\r\n\r\n  get validFromDate(): Date {\r\n    return this.cached(\r\n      'validFromDate',\r\n      () => new Date(this.handle.validFromDate()),\r\n    );\r\n  }\r\n\r\n  get validToDate(): Date {\r\n    return this.cached(\r\n      'validToDate',\r\n      () => new Date(this.handle.validToDate()),\r\n    );\r\n  }\r\n\r\n  get fingerprint(): string {\r\n    return this.cached('fingerprint', () => this.handle.fingerprint());\r\n  }\r\n\r\n  get fingerprint256(): string {\r\n    return this.cached('fingerprint256', () => this.handle.fingerprint256());\r\n  }\r\n\r\n  get fingerprint512(): string {\r\n    return this.cached('fingerprint512', () => this.handle.fingerprint512());\r\n  }\r\n\r\n  get extKeyUsage(): string[] {\r\n    return this.cached('extKeyUsage', () => this.handle.keyUsage());\r\n  }\r\n\r\n  get keyUsage(): string[] {\r\n    return this.extKeyUsage;\r\n  }\r\n\r\n  get serialNumber(): string {\r\n    return this.cached('serialNumber', () => this.handle.serialNumber());\r\n  }\r\n\r\n  get signatureAlgorithm(): string {\r\n    return this.cached('signatureAlgorithm', () =>\r\n      this.handle.signatureAlgorithm(),\r\n    );\r\n  }\r\n\r\n  get signatureAlgorithmOid(): string {\r\n    return this.cached('signatureAlgorithmOid', () =>\r\n      this.handle.signatureAlgorithmOid(),\r\n    );\r\n  }\r\n\r\n  get ca(): boolean {\r\n    return this.cached('ca', () => this.handle.ca());\r\n  }\r\n\r\n  get raw(): Buffer {\r\n    return this.cached('raw', () => Buffer.from(this.handle.raw()));\r\n  }\r\n\r\n  get publicKey(): PublicKeyObject {\r\n    return this.cached(\r\n      'publicKey',\r\n      () => new PublicKeyObject(this.handle.publicKey()),\r\n    );\r\n  }\r\n\r\n  get issuerCertificate(): undefined {\r\n    return undefined;\r\n  }\r\n\r\n  checkHost(name: string, options?: CheckOptions): string | undefined {\r\n    if (typeof name !== 'string') {\r\n      throw new TypeError('The \"name\" argument must be a string');\r\n    }\r\n    return this.handle.checkHost(name, getFlags(options));\r\n  }\r\n\r\n  checkEmail(email: string, options?: CheckOptions): string | undefined {\r\n    if (typeof email !== 'string') {\r\n      throw new TypeError('The \"email\" argument must be a string');\r\n    }\r\n    return this.handle.checkEmail(email, getFlags(options));\r\n  }\r\n\r\n  checkIP(ip: string): string | undefined {\r\n    if (typeof ip !== 'string') {\r\n      throw new TypeError('The \"ip\" argument must be a string');\r\n    }\r\n    return this.handle.checkIP(ip);\r\n  }\r\n\r\n  checkIssued(otherCert: X509Certificate): boolean {\r\n    if (!(otherCert instanceof X509Certificate)) {\r\n      throw new TypeError(\r\n        'The \"otherCert\" argument must be an instance of X509Certificate',\r\n      );\r\n    }\r\n    return this.handle.checkIssued(otherCert.handle);\r\n  }\r\n\r\n  checkPrivateKey(pkey: KeyObject): boolean {\r\n    if (!(pkey instanceof KeyObject)) {\r\n      throw new TypeError(\r\n        'The \"pkey\" argument must be an instance of KeyObject',\r\n      );\r\n    }\r\n    if (pkey.type !== 'private') {\r\n      throw new TypeError('The \"pkey\" argument must be a private key');\r\n    }\r\n    return this.handle.checkPrivateKey(pkey.handle);\r\n  }\r\n\r\n  verify(pkey: KeyObject): boolean {\r\n    if (!(pkey instanceof KeyObject)) {\r\n      throw new TypeError(\r\n        'The \"pkey\" argument must be an instance of KeyObject',\r\n      );\r\n    }\r\n    if (pkey.type !== 'public') {\r\n      throw new TypeError(\r\n        `The \"pkey\" argument must be a public key, got '${pkey.type}'`,\r\n      );\r\n    }\r\n    return this.handle.verify(pkey.handle);\r\n  }\r\n\r\n  toString(): string {\r\n    return this.cached('pem', () => this.handle.pem());\r\n  }\r\n\r\n  toJSON(): string {\r\n    return this.toString();\r\n  }\r\n\r\n  toLegacyObject(): X509LegacyObject {\r\n    return {\r\n      subject: this.subject,\r\n      issuer: this.issuer,\r\n      subjectaltname: this.subjectAltName,\r\n      infoAccess: this.infoAccess,\r\n      ca: this.ca,\r\n      modulus: undefined,\r\n      bits: undefined,\r\n      exponent: undefined,\r\n      valid_from: this.validFrom,\r\n      valid_to: this.validTo,\r\n      fingerprint: this.fingerprint,\r\n      fingerprint256: this.fingerprint256,\r\n      fingerprint512: this.fingerprint512,\r\n      ext_key_usage: this.keyUsage,\r\n      serialNumber: this.serialNumber,\r\n      raw: this.raw,\r\n    };\r\n  }\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/typescript/argon2.d.ts

@@ -0,0 +1,15 @@
+import { Buffer } from '@craftzdog/react-native-buffer';
+import type { BinaryLike } from './utils';
+export interface Argon2Params {
+    message: BinaryLike;
+    nonce: BinaryLike;
+    parallelism: number;
+    tagLength: number;
+    memory: number;
+    passes: number;
+    secret?: BinaryLike;
+    associatedData?: BinaryLike;
+    version?: number;
+}
+export declare function argon2Sync(algorithm: string, params: Argon2Params): Buffer;
+export declare function argon2(algorithm: string, params: Argon2Params, callback: (err: Error | null, result: Buffer) => void): void;

package/dist/typescript/blake3.d.ts

@@ -0,0 +1,32 @@
+import { Buffer } from '@craftzdog/react-native-buffer';
+import type { BinaryLike, Encoding } from './utils';
+export interface Blake3Options {
+    dkLen?: number;
+    key?: Uint8Array;
+    context?: string;
+}
+export declare class Blake3 {
+    private native;
+    private mode;
+    private keyData?;
+    private contextData?;
+    constructor(opts?: Blake3Options);
+    update(data: BinaryLike, inputEncoding?: Encoding): this;
+    digest(): Buffer;
+    digest(encoding: Encoding): string;
+    digest(length: number): Buffer;
+    digestLength(length: number): Buffer;
+    reset(): this;
+    copy(): Blake3;
+    static getVersion(): string;
+}
+export declare function createBlake3(opts?: Blake3Options): Blake3;
+export declare function blake3(data: BinaryLike, opts?: Blake3Options): Uint8Array;
+export declare namespace blake3 {
+    var create: typeof createBlake3;
+}
+export declare const blake3Exports: {
+    Blake3: typeof Blake3;
+    createBlake3: typeof createBlake3;
+    blake3: typeof blake3;
+};

package/dist/typescript/certificate.d.ts

@@ -0,0 +1,7 @@
+import { Buffer } from '@craftzdog/react-native-buffer';
+import type { BinaryLike } from './utils';
+export declare class Certificate {
+    static exportChallenge(spkac: BinaryLike, encoding?: BufferEncoding): Buffer;
+    static exportPublicKey(spkac: BinaryLike, encoding?: BufferEncoding): Buffer;
+    static verifySpkac(spkac: BinaryLike, encoding?: BufferEncoding): boolean;
+}

package/dist/typescript/cipher.d.ts

@@ -0,0 +1,74 @@
+import Stream, { type TransformOptions } from 'readable-stream';
+import { Buffer } from '@craftzdog/react-native-buffer';
+import type { BinaryLike, BinaryLikeNode, Encoding } from './utils';
+import type { CipherCCMOptions, CipherCCMTypes, CipherGCMTypes, CipherGCMOptions, CipherOCBOptions, CipherOCBTypes } from 'crypto';
+export type CipherOptions = CipherCCMOptions | CipherOCBOptions | CipherGCMOptions | TransformOptions;
+export interface CipherInfoResult {
+    name: string;
+    nid: number;
+    mode: string;
+    keyLength: number;
+    blockSize?: number;
+    ivLength?: number;
+}
+export declare function getCiphers(): string[];
+export declare function getCipherInfo(name: string, options?: {
+    keyLength?: number;
+    ivLength?: number;
+}): CipherInfoResult | undefined;
+interface CipherArgs {
+    isCipher: boolean;
+    cipherType: string;
+    cipherKey: BinaryLikeNode;
+    iv: BinaryLike;
+    options?: CipherOptions;
+}
+declare class CipherCommon extends Stream.Transform {
+    private native;
+    private _decoder;
+    private _decoderEncoding;
+    constructor({ isCipher, cipherType, cipherKey, iv, options }: CipherArgs);
+    private getDecoder;
+    update(data: Buffer): Buffer;
+    update(data: BinaryLike, inputEncoding?: Encoding): Buffer;
+    update(data: BinaryLike, inputEncoding: Encoding, outputEncoding: Encoding): string;
+    final(): Buffer;
+    final(outputEncoding: BufferEncoding | 'buffer'): string;
+    _transform(chunk: BinaryLike, encoding: BufferEncoding, callback: () => void): void;
+    _flush(callback: () => void): void;
+    setAutoPadding(autoPadding?: boolean): this;
+    setAAD(buffer: Buffer, options?: {
+        plaintextLength: number;
+    }): this;
+    getAuthTag(): Buffer;
+    setAuthTag(tag: Buffer): this;
+    getSupportedCiphers(): string[];
+}
+declare class Cipheriv extends CipherCommon {
+    constructor(cipherType: string, cipherKey: BinaryLikeNode, iv: BinaryLike, options?: CipherOptions);
+}
+export type Cipher = Cipheriv;
+declare class Decipheriv extends CipherCommon {
+    constructor(cipherType: string, cipherKey: BinaryLikeNode, iv: BinaryLike, options?: CipherOptions);
+}
+export type Decipher = Decipheriv;
+export declare function createDecipheriv(algorithm: CipherCCMTypes, key: BinaryLikeNode, iv: BinaryLike, options: CipherCCMOptions): Decipher;
+export declare function createDecipheriv(algorithm: CipherOCBTypes, key: BinaryLikeNode, iv: BinaryLike, options: CipherOCBOptions): Decipher;
+export declare function createDecipheriv(algorithm: CipherGCMTypes, key: BinaryLikeNode, iv: BinaryLike, options?: CipherGCMOptions): Decipher;
+export declare function createDecipheriv(algorithm: string, key: BinaryLikeNode, iv: BinaryLike, options?: TransformOptions): Decipher;
+export declare function createCipheriv(algorithm: CipherCCMTypes, key: BinaryLikeNode, iv: BinaryLike, options: CipherCCMOptions): Cipher;
+export declare function createCipheriv(algorithm: CipherOCBTypes, key: BinaryLikeNode, iv: BinaryLike, options: CipherOCBOptions): Cipher;
+export declare function createCipheriv(algorithm: CipherGCMTypes, key: BinaryLikeNode, iv: BinaryLike, options?: CipherGCMOptions): Cipher;
+export declare function createCipheriv(algorithm: string, key: BinaryLikeNode, iv: BinaryLike, options?: TransformOptions): Cipher;
+/**
+ * xsalsa20 stream encryption with @noble/ciphers compatible API
+ *
+ * @param key - 32 bytes
+ * @param nonce - 24 bytes
+ * @param data - data to encrypt
+ * @param output - unused
+ * @param counter - unused
+ * @returns encrypted data
+ */
+export declare function xsalsa20(key: Uint8Array, nonce: Uint8Array, data: Uint8Array, output?: Uint8Array | undefined, counter?: number): Uint8Array;
+export {};

package/dist/typescript/constants.d.ts

@@ -0,0 +1,20 @@
+export declare const constants: {
+    readonly RSA_PKCS1_PADDING: 1;
+    readonly RSA_NO_PADDING: 3;
+    readonly RSA_PKCS1_OAEP_PADDING: 4;
+    readonly RSA_X931_PADDING: 5;
+    readonly RSA_PKCS1_PSS_PADDING: 6;
+    readonly RSA_PSS_SALTLEN_DIGEST: -1;
+    readonly RSA_PSS_SALTLEN_MAX_SIGN: -2;
+    readonly RSA_PSS_SALTLEN_AUTO: -2;
+    readonly POINT_CONVERSION_COMPRESSED: 2;
+    readonly POINT_CONVERSION_UNCOMPRESSED: 4;
+    readonly POINT_CONVERSION_HYBRID: 6;
+    readonly DH_CHECK_P_NOT_PRIME: 1;
+    readonly DH_CHECK_P_NOT_SAFE_PRIME: 2;
+    readonly DH_UNABLE_TO_CHECK_GENERATOR: 4;
+    readonly DH_NOT_SUITABLE_GENERATOR: 8;
+    readonly OPENSSL_VERSION_NUMBER: 805306368;
+};
+export declare const defaultCoreCipherList = "TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256";
+export declare const defaultCipherList = "TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256";

package/dist/typescript/dh-groups.d.ts

@@ -0,0 +1,4 @@
+export declare const DH_GROUPS: Record<string, {
+    prime: string;
+    generator: string;
+}>;

package/dist/typescript/dhKeyPair.d.ts

@@ -0,0 +1,18 @@
+import { Buffer } from '@craftzdog/react-native-buffer';
+import { PublicKeyObject, PrivateKeyObject } from './keys/classes';
+import type { DhKeyPair } from './specs/v1/dhKeyPair.nitro';
+import type { GenerateKeyPairOptions, KeyPairGenConfig } from './utils/types';
+export declare class DhKeyPairGen {
+    native: DhKeyPair;
+    constructor(options: GenerateKeyPairOptions);
+    generateKeyPair(): Promise<void>;
+    generateKeyPairSync(): void;
+}
+export declare function dh_generateKeyPairNode(options: GenerateKeyPairOptions | undefined, encoding: KeyPairGenConfig): Promise<{
+    publicKey: PublicKeyObject | Buffer | string | ArrayBuffer;
+    privateKey: PrivateKeyObject | Buffer | string | ArrayBuffer;
+}>;
+export declare function dh_generateKeyPairNodeSync(options: GenerateKeyPairOptions | undefined, encoding: KeyPairGenConfig): {
+    publicKey: PublicKeyObject | Buffer | string | ArrayBuffer;
+    privateKey: PrivateKeyObject | Buffer | string | ArrayBuffer;
+};

package/dist/typescript/diffie-hellman.d.ts

@@ -0,0 +1,17 @@
+import { Buffer } from '@craftzdog/react-native-buffer';
+export declare class DiffieHellman {
+    private _hybrid;
+    constructor(sizeOrPrime: number | Buffer | string, generator?: number | Buffer | string, encoding?: BufferEncoding);
+    generateKeys(encoding?: BufferEncoding): Buffer | string;
+    computeSecret(otherPublicKey: Buffer | string, inputEncoding?: BufferEncoding, outputEncoding?: BufferEncoding): Buffer | string;
+    getPrime(encoding?: BufferEncoding): Buffer | string;
+    getGenerator(encoding?: BufferEncoding): Buffer | string;
+    getPublicKey(encoding?: BufferEncoding): Buffer | string;
+    getPrivateKey(encoding?: BufferEncoding): Buffer | string;
+    setPublicKey(publicKey: Buffer | string, encoding?: BufferEncoding): void;
+    setPrivateKey(privateKey: Buffer | string, encoding?: BufferEncoding): void;
+    get verifyError(): number;
+}
+export declare function createDiffieHellman(primeOrSize: number | string | Buffer, primeEncodingOrGenerator?: string | number | Buffer, generator?: number | string | Buffer, _generatorEncoding?: string): DiffieHellman;
+export declare function getDiffieHellman(groupName: string): DiffieHellman;
+export { getDiffieHellman as createDiffieHellmanGroup };

package/dist/typescript/dsa.d.ts

@@ -0,0 +1,18 @@
+import { Buffer } from '@craftzdog/react-native-buffer';
+import { PublicKeyObject, PrivateKeyObject } from './keys/classes';
+import type { DsaKeyPair } from './specs/v1/dsaKeyPair.nitro';
+import type { GenerateKeyPairOptions, KeyPairGenConfig } from './utils/types';
+export declare class Dsa {
+    native: DsaKeyPair;
+    constructor(modulusLength: number, divisorLength?: number);
+    generateKeyPair(): Promise<void>;
+    generateKeyPairSync(): void;
+}
+export declare function dsa_generateKeyPairNode(options: GenerateKeyPairOptions | undefined, encoding: KeyPairGenConfig): Promise<{
+    publicKey: PublicKeyObject | Buffer | string | ArrayBuffer;
+    privateKey: PrivateKeyObject | Buffer | string | ArrayBuffer;
+}>;
+export declare function dsa_generateKeyPairNodeSync(options: GenerateKeyPairOptions | undefined, encoding: KeyPairGenConfig): {
+    publicKey: PublicKeyObject | Buffer | string | ArrayBuffer;
+    privateKey: PrivateKeyObject | Buffer | string | ArrayBuffer;
+};

package/dist/typescript/ec.d.ts

@@ -0,0 +1,23 @@
+import type { EcKeyPair } from './specs/v1/ecKeyPair.nitro';
+import { CryptoKey, PublicKeyObject, PrivateKeyObject } from './keys/classes';
+import type { CryptoKeyPair, KeyPairOptions, KeyUsage, SubtleAlgorithm, BufferLike, BinaryLike, JWK, ImportFormat, GenerateKeyPairOptions, KeyPairGenConfig } from './utils/types';
+import { Buffer } from '@craftzdog/react-native-buffer';
+export declare function getCurves(): string[];
+export declare class Ec {
+    native: EcKeyPair;
+    constructor(curve: string);
+    generateKeyPair(): Promise<CryptoKeyPair>;
+    generateKeyPairSync(): CryptoKeyPair;
+}
+export declare function ecImportKey(format: ImportFormat, keyData: BufferLike | BinaryLike | JWK, algorithm: SubtleAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): CryptoKey;
+export declare const ecdsaSignVerify: (key: CryptoKey, data: BufferLike, { hash }: SubtleAlgorithm, signature?: BufferLike) => ArrayBuffer | boolean;
+export declare function ec_generateKeyPair(name: string, namedCurve: string, extractable: boolean, keyUsages: KeyUsage[], _options?: KeyPairOptions): Promise<CryptoKeyPair>;
+export declare function ec_generateKeyPairNode(options: GenerateKeyPairOptions | undefined, encoding: KeyPairGenConfig): Promise<{
+    publicKey: PublicKeyObject | Buffer | string | ArrayBuffer;
+    privateKey: PrivateKeyObject | Buffer | string | ArrayBuffer;
+}>;
+export declare function ec_generateKeyPairNodeSync(options: GenerateKeyPairOptions | undefined, encoding: KeyPairGenConfig): {
+    publicKey: PublicKeyObject | Buffer | string | ArrayBuffer;
+    privateKey: PrivateKeyObject | Buffer | string | ArrayBuffer;
+};
+export declare function ecDeriveBits(algorithm: SubtleAlgorithm, baseKey: CryptoKey, length: number | null): ArrayBuffer;

package/dist/typescript/ecdh.d.ts

@@ -0,0 +1,18 @@
+import { Buffer } from '@craftzdog/react-native-buffer';
+export declare class ECDH {
+    private static _convertKeyHybrid;
+    private static get convertKeyHybrid();
+    private _hybrid;
+    constructor(curveName: string);
+    generateKeys(): Buffer;
+    computeSecret(otherPublicKey: Buffer | string | {
+        code: number;
+        byteLength: number;
+    }, inputEncoding?: BufferEncoding): Buffer;
+    getPrivateKey(): Buffer;
+    setPrivateKey(privateKey: Buffer | string, encoding?: BufferEncoding): void;
+    getPublicKey(encoding?: BufferEncoding): Buffer | string;
+    setPublicKey(publicKey: Buffer | string, encoding?: BufferEncoding): void;
+    static convertKey(key: Buffer | string, curve: string, inputEncoding?: BufferEncoding, outputEncoding?: BufferEncoding, format?: 'uncompressed' | 'compressed' | 'hybrid'): Buffer | string;
+}
+export declare function createECDH(curveName: string): ECDH;

package/dist/typescript/ed.d.ts

@@ -0,0 +1,46 @@
+import { Buffer } from '@craftzdog/react-native-buffer';
+import { CryptoKey } from './keys/classes';
+import type { EdKeyPair } from './specs/v1/edKeyPair.nitro';
+import type { BinaryLike, CFRGKeyPairType, CryptoKeyPair, DiffieHellmanCallback, DiffieHellmanOptions, GenerateKeyPairCallback, GenerateKeyPairReturn, Hex, KeyPairGenConfig, KeyUsage, SubtleAlgorithm } from './utils';
+export declare class Ed {
+    type: CFRGKeyPairType;
+    config: KeyPairGenConfig;
+    native: EdKeyPair;
+    constructor(type: CFRGKeyPairType, config: KeyPairGenConfig);
+    /**
+     * Computes the Diffie-Hellman secret based on a privateKey and a publicKey.
+     * Both keys must have the same asymmetricKeyType, which must be one of 'dh'
+     * (for Diffie-Hellman), 'ec', 'x448', or 'x25519' (for ECDH).
+     *
+     * @api nodejs/node
+     *
+     * @param options `{ privateKey, publicKey }`, both of which are `KeyObject`s
+     * @param callback optional `(err, secret) => void`
+     * @returns `Buffer` if no callback, or `void` if callback is provided
+     */
+    diffieHellman(options: DiffieHellmanOptions, callback?: DiffieHellmanCallback): Buffer | void;
+    generateKeyPair(): Promise<void>;
+    generateKeyPairSync(): void;
+    getPublicKey(): ArrayBuffer;
+    getPrivateKey(): ArrayBuffer;
+    /**
+     * Computes the Diffie-Hellman shared secret based on a privateKey and a
+     * publicKey for key exchange
+     *
+     * @api \@paulmillr/noble-curves/ed25519
+     *
+     * @param privateKey
+     * @param publicKey
+     * @returns shared secret key
+     */
+    getSharedSecret(privateKey: Hex, publicKey: Hex): ArrayBuffer;
+    sign(message: BinaryLike, key?: BinaryLike): Promise<ArrayBuffer>;
+    signSync(message: BinaryLike, key?: BinaryLike): ArrayBuffer;
+    verify(signature: BinaryLike, message: BinaryLike, key?: BinaryLike): Promise<boolean>;
+    verifySync(signature: BinaryLike, message: BinaryLike, key?: BinaryLike): boolean;
+}
+export declare function diffieHellman(options: DiffieHellmanOptions, callback?: DiffieHellmanCallback): Buffer | void;
+export declare function ed_generateKeyPair(isAsync: boolean, type: CFRGKeyPairType, encoding: KeyPairGenConfig, callback: GenerateKeyPairCallback | undefined): GenerateKeyPairReturn | void;
+export declare function ed_generateKeyPairWebCrypto(type: 'ed25519' | 'ed448', extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair>;
+export declare function x_generateKeyPairWebCrypto(type: 'x25519' | 'x448', extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair>;
+export declare function xDeriveBits(algorithm: SubtleAlgorithm, baseKey: CryptoKey, length: number | null): ArrayBuffer;

package/dist/typescript/hash.d.ts

@@ -0,0 +1,125 @@
+import { Stream } from 'readable-stream';
+import type { TransformOptions } from 'readable-stream';
+import { Buffer } from '@craftzdog/react-native-buffer';
+import type { BinaryLike, Encoding, BufferLike, SubtleAlgorithm } from './utils';
+export declare function getHashes(): string[];
+interface HashOptions extends TransformOptions {
+    /**
+     * For XOF hash functions such as `shake256`, the
+     * outputLength option can be used to specify the desired output length in bytes.
+     */
+    outputLength?: number | undefined;
+}
+declare class Hash extends Stream.Transform {
+    private algorithm;
+    private options;
+    private native;
+    private validate;
+    /**
+     * @internal use `createHash()` instead
+     */
+    private constructor();
+    /**
+     * Updates the hash content with the given `data`, the encoding of which
+     * is given in `inputEncoding`.
+     * If `encoding` is not provided, and the `data` is a string, an
+     * encoding of `'utf8'` is enforced. If `data` is a `Buffer`, `TypedArray`, or`DataView`, then `inputEncoding` is ignored.
+     *
+     * This can be called many times with new data as it is streamed.
+     * @since v1.0.0
+     * @param inputEncoding The `encoding` of the `data` string.
+     */
+    update(data: BinaryLike): Hash;
+    update(data: BinaryLike, inputEncoding: Encoding): Buffer;
+    /**
+     * Calculates the digest of all of the data passed to be hashed (using the `hash.update()` method).
+     * If `encoding` is provided a string will be returned; otherwise
+     * a `Buffer` is returned.
+     *
+     * The `Hash` object can not be used again after `hash.digest()` method has been
+     * called. Multiple calls will cause an error to be thrown.
+     * @since v1.0.0
+     * @param encoding The `encoding` of the return value.
+     */
+    digest(): Buffer;
+    digest(encoding: Encoding): string;
+    /**
+     * Creates a new `Hash` object that contains a deep copy of the internal state
+     * of the current `Hash` object.
+     *
+     * The optional `options` argument controls stream behavior. For XOF hash
+     * functions such as `'shake256'`, the `outputLength` option can be used to
+     * specify the desired output length in bytes.
+     *
+     * An error is thrown when an attempt is made to copy the `Hash` object after
+     * its `hash.digest()` method has been called.
+     *
+     * ```js
+     * // Calculate a rolling hash.
+     * import { createHash } from 'react-native-quick-crypto';
+     *
+     * const hash = createHash('sha256');
+     *
+     * hash.update('one');
+     * console.log(hash.copy().digest('hex'));
+     *
+     * hash.update('two');
+     * console.log(hash.copy().digest('hex'));
+     *
+     * hash.update('three');
+     * console.log(hash.copy().digest('hex'));
+     *
+     * // Etc.
+     * ```
+     * @since v1.0.0
+     * @param options `stream.transform` options
+     */
+    copy(): Hash;
+    copy(options: HashOptions): Hash;
+    /**
+     * Returns the OpenSSL version string
+     * @since v1.0.0
+     */
+    getOpenSSLVersion(): string;
+    _transform(chunk: BinaryLike, encoding: BufferEncoding, callback: () => void): void;
+    _flush(callback: () => void): void;
+}
+/**
+ * Creates and returns a `Hash` object that can be used to generate hash digests
+ * using the given `algorithm`. Optional `options` argument controls stream
+ * behavior. For XOF hash functions such as `'shake256'`, the `outputLength` option
+ * can be used to specify the desired output length in bytes.
+ *
+ * The `algorithm` is dependent on the available algorithms supported by the
+ * version of OpenSSL on the platform. Examples are `'sha256'`, `'sha512'`, etc.
+ * On recent releases of OpenSSL, `openssl list -digest-algorithms` will
+ * display the available digest algorithms.
+ *
+ * Example: generating the sha256 sum of a file
+ *
+ * ```js
+ * import crypto from 'react-native-quick-crypto';
+ *
+ * const hash = crypto.createHash('sha256').update('Test123').digest('hex');
+ * console.log('SHA-256 of "Test123":', hash);
+ * ```
+ * @since v1.0.0
+ * @param options `stream.transform` options
+ */
+export declare function createHash(algorithm: string, options?: HashOptions): Hash;
+/**
+ * Asynchronous digest function for WebCrypto SubtleCrypto API
+ * @param algorithm The hash algorithm to use
+ * @param data The data to hash
+ * @returns Promise resolving to the hash digest as ArrayBuffer
+ */
+export declare const asyncDigest: (algorithm: SubtleAlgorithm, data: BufferLike) => Promise<ArrayBuffer>;
+export declare function hash(algorithm: string, data: BinaryLike, outputEncoding: Encoding): string;
+export declare function hash(algorithm: string, data: BinaryLike): Buffer;
+export declare const hashExports: {
+    createHash: typeof createHash;
+    getHashes: typeof getHashes;
+    hash: typeof hash;
+    asyncDigest: (algorithm: SubtleAlgorithm, data: BufferLike) => Promise<ArrayBuffer>;
+};
+export {};