@ohos-ports/react-native-quick-crypto 0.0.0-stage → 1.1.8-beta.0

package/src/specs/certificate.nitro.ts

@@ -0,0 +1,8 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+export interface Certificate
+  extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  verifySpkac(spkac: ArrayBuffer): boolean;
+  exportPublicKey(spkac: ArrayBuffer): ArrayBuffer;
+  exportChallenge(spkac: ArrayBuffer): ArrayBuffer;
+}

package/src/specs/cipher.nitro.ts

@@ -0,0 +1,39 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+type CipherArgs = {
+  isCipher: boolean;
+  cipherType: string;
+  cipherKey: ArrayBuffer;
+  iv: ArrayBuffer;
+  authTagLen?: number;
+};
+
+interface CipherInfo {
+  name: string;
+  nid: number;
+  mode: string;
+  keyLength: number;
+  blockSize?: number;
+  ivLength?: number;
+}
+
+export interface Cipher extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  update(data: ArrayBuffer): ArrayBuffer;
+  final(): ArrayBuffer;
+  setArgs(args: CipherArgs): void;
+  setAAD(data: ArrayBuffer, plaintextLength?: number): boolean;
+  setAutoPadding(autoPad: boolean): boolean;
+  setAuthTag(tag: ArrayBuffer): boolean;
+  getAuthTag(): ArrayBuffer;
+  getSupportedCiphers(): string[];
+  getCipherInfo(
+    name: string,
+    keyLength?: number,
+    ivLength?: number,
+  ): CipherInfo | undefined;
+}
+
+export interface CipherFactory
+  extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  createCipher(args: CipherArgs): Cipher;
+}

package/src/specs/dhKeyPair.nitro.ts

@@ -0,0 +1,14 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+export interface DhKeyPair
+  extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  generateKeyPair(): Promise<void>;
+  generateKeyPairSync(): void;
+
+  setPrimeLength(primeLength: number): void;
+  setPrime(prime: ArrayBuffer): void;
+  setGenerator(generator: number): void;
+
+  getPublicKey(): ArrayBuffer;
+  getPrivateKey(): ArrayBuffer;
+}

package/src/specs/diffie-hellman.nitro.ts

@@ -0,0 +1,16 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+export interface DiffieHellman
+  extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  init(prime: ArrayBuffer, generator: ArrayBuffer): void;
+  initWithSize(primeLength: number, generator: number): void;
+  generateKeys(): ArrayBuffer;
+  computeSecret(otherPublicKey: ArrayBuffer): ArrayBuffer;
+  getPrime(): ArrayBuffer;
+  getGenerator(): ArrayBuffer;
+  getPublicKey(): ArrayBuffer;
+  getPrivateKey(): ArrayBuffer;
+  setPublicKey(publicKey: ArrayBuffer): void;
+  setPrivateKey(privateKey: ArrayBuffer): void;
+  getVerifyError(): number;
+}

package/src/specs/dsaKeyPair.nitro.ts

@@ -0,0 +1,13 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+export interface DsaKeyPair
+  extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  generateKeyPair(): Promise<void>;
+  generateKeyPairSync(): void;
+
+  setModulusLength(modulusLength: number): void;
+  setDivisorLength(divisorLength: number): void;
+
+  getPublicKey(): ArrayBuffer;
+  getPrivateKey(): ArrayBuffer;
+}

package/src/specs/ecKeyPair.nitro.ts

@@ -0,0 +1,40 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+//  Nitro-compatible interfaces defined locally
+interface KeyObject {
+  extractable: boolean;
+}
+
+export interface EcKeyPair
+  extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  // generateKeyPair functions
+  generateKeyPair(): Promise<void>;
+  generateKeyPairSync(): void;
+
+  // importKey
+  importKey(
+    format: string,
+    keyData: ArrayBuffer,
+    algorithm: string,
+    extractable: boolean,
+    keyUsages: string[],
+  ): KeyObject;
+
+  // exportKey
+  exportKey(key: KeyObject, format: string): ArrayBuffer;
+
+  getPublicKey(): ArrayBuffer;
+  getPrivateKey(): ArrayBuffer;
+
+  setCurve(curve: string): void;
+
+  // ECDSA sign/verify operations
+  sign(data: ArrayBuffer, hashAlgorithm: string): ArrayBuffer;
+  verify(
+    data: ArrayBuffer,
+    signature: ArrayBuffer,
+    hashAlgorithm: string,
+  ): boolean;
+
+  getSupportedCurves(): string[];
+}

package/src/specs/ecdh.nitro.ts

@@ -0,0 +1,12 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+export interface ECDH extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  init(curveName: string): void;
+  generateKeys(): ArrayBuffer;
+  computeSecret(otherPublicKey: ArrayBuffer): ArrayBuffer;
+  getPrivateKey(): ArrayBuffer;
+  setPrivateKey(privateKey: ArrayBuffer): void;
+  getPublicKey(): ArrayBuffer;
+  setPublicKey(publicKey: ArrayBuffer): void;
+  convertKey(key: ArrayBuffer, curve: string, format: number): ArrayBuffer;
+}

package/src/specs/edKeyPair.nitro.ts

@@ -0,0 +1,43 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+export interface EdKeyPair
+  extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  diffieHellman(privateKey: ArrayBuffer, publicKey: ArrayBuffer): ArrayBuffer;
+
+  generateKeyPair(
+    publicFormat: number,
+    publicType: number,
+    privateFormat: number,
+    privateType: number,
+    cipher?: string,
+    passphrase?: ArrayBuffer,
+  ): Promise<void>;
+
+  generateKeyPairSync(
+    publicFormat: number,
+    publicType: number,
+    privateFormat: number,
+    privateType: number,
+    cipher?: string,
+    passphrase?: ArrayBuffer,
+  ): void;
+
+  getPublicKey(): ArrayBuffer;
+  getPrivateKey(): ArrayBuffer;
+
+  sign(message: ArrayBuffer, key?: ArrayBuffer): Promise<ArrayBuffer>;
+  signSync(message: ArrayBuffer, key?: ArrayBuffer): ArrayBuffer;
+
+  verify(
+    signature: ArrayBuffer,
+    message: ArrayBuffer,
+    key?: ArrayBuffer,
+  ): Promise<boolean>;
+  verifySync(
+    signature: ArrayBuffer,
+    message: ArrayBuffer,
+    key?: ArrayBuffer,
+  ): boolean;
+
+  setCurve(curve: string): void;
+}

package/src/specs/hash.nitro.ts

@@ -0,0 +1,10 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+export interface Hash extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  createHash(algorithm: string, outputLength?: number): void;
+  update(data: ArrayBuffer | string): void;
+  digest(encoding?: string): ArrayBuffer;
+  copy(outputLength?: number): Hash;
+  getSupportedHashAlgorithms(): string[];
+  getOpenSSLVersion(): string;
+}

package/src/specs/hkdf.nitro.ts

@@ -0,0 +1,25 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+// RFC 5869 stage: 'full' (extract+expand), 'extract' (PRK only), or
+// 'expand' (from an existing PRK).
+export type HkdfMode = 'full' | 'extract' | 'expand';
+
+export interface Hkdf extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  deriveKeySync(
+    algorithm: string,
+    key: ArrayBuffer,
+    salt: ArrayBuffer,
+    info: ArrayBuffer,
+    length: number,
+    mode: HkdfMode,
+  ): ArrayBuffer;
+
+  deriveKey(
+    algorithm: string,
+    key: ArrayBuffer,
+    salt: ArrayBuffer,
+    info: ArrayBuffer,
+    length: number,
+    mode: HkdfMode,
+  ): Promise<ArrayBuffer>;
+}

package/src/specs/hmac.nitro.ts

@@ -0,0 +1,7 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+export interface Hmac extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  createHmac(algorithm: string, key: ArrayBuffer): void;
+  update(data: ArrayBuffer | string): void;
+  digest(): ArrayBuffer;
+}

package/src/specs/keyObjectHandle.nitro.ts

@@ -0,0 +1,56 @@
+import { type HybridObject } from 'react-native-nitro-modules';
+import type {
+  AsymmetricKeyType,
+  JWK,
+  KeyDetail,
+  KeyEncoding,
+  KeyType,
+  KFormatType,
+  NamedCurve,
+} from '../utils';
+
+export interface KeyObjectHandle
+  extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  exportKey(
+    format?: KFormatType,
+    type?: KeyEncoding,
+    cipher?: string,
+    passphrase?: ArrayBuffer,
+  ): ArrayBuffer;
+  exportJwk(key: JWK, handleRsaPss: boolean): JWK;
+  exportRawPublic(): ArrayBuffer;
+  exportRawPrivate(): ArrayBuffer;
+  exportRawSeed(): ArrayBuffer;
+  exportECPublicRaw(compressed: boolean): ArrayBuffer;
+  exportECPrivateRaw(): ArrayBuffer;
+  getAsymmetricKeyType(): AsymmetricKeyType;
+  init(
+    keyType: KeyType,
+    key: string | ArrayBuffer,
+    format?: KFormatType,
+    type?: KeyEncoding,
+    passphrase?: ArrayBuffer,
+  ): boolean;
+  initECRaw(namedCurve: string, keyData: ArrayBuffer): boolean;
+  initPqcRaw(
+    algorithmName: string,
+    keyData: ArrayBuffer,
+    isPublic: boolean,
+  ): boolean;
+  initRawPublic(
+    asymmetricKeyType: string,
+    keyData: ArrayBuffer,
+    namedCurve?: string,
+  ): boolean;
+  initRawPrivate(
+    asymmetricKeyType: string,
+    keyData: ArrayBuffer,
+    namedCurve?: string,
+  ): boolean;
+  initRawSeed(asymmetricKeyType: string, keyData: ArrayBuffer): boolean;
+  initJwk(keyData: JWK, namedCurve?: NamedCurve): KeyType | undefined;
+  keyDetail(): KeyDetail;
+  keyEquals(other: KeyObjectHandle): boolean;
+  getSymmetricKeySize(): number;
+  checkEcKeyData(): boolean;
+}

package/src/specs/kmac.nitro.ts

@@ -0,0 +1,12 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+export interface Kmac extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  createKmac(
+    algorithm: string,
+    key: ArrayBuffer,
+    outputLength: number,
+    customization?: ArrayBuffer,
+  ): void;
+  update(data: ArrayBuffer): void;
+  digest(): ArrayBuffer;
+}

package/src/specs/mlDsaKeyPair.nitro.ts

@@ -0,0 +1,29 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+export interface MlDsaKeyPair
+  extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  generateKeyPair(
+    publicFormat: number,
+    publicType: number,
+    privateFormat: number,
+    privateType: number,
+  ): Promise<void>;
+
+  generateKeyPairSync(
+    publicFormat: number,
+    publicType: number,
+    privateFormat: number,
+    privateType: number,
+  ): void;
+
+  getPublicKey(): ArrayBuffer;
+  getPrivateKey(): ArrayBuffer;
+
+  sign(message: ArrayBuffer): Promise<ArrayBuffer>;
+  signSync(message: ArrayBuffer): ArrayBuffer;
+
+  verify(signature: ArrayBuffer, message: ArrayBuffer): Promise<boolean>;
+  verifySync(signature: ArrayBuffer, message: ArrayBuffer): boolean;
+
+  setVariant(variant: string): void;
+}

package/src/specs/mlKemKeyPair.nitro.ts

@@ -0,0 +1,32 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+export interface MlKemKeyPair
+  extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  setVariant(variant: string): void;
+
+  generateKeyPair(
+    publicFormat: number,
+    publicType: number,
+    privateFormat: number,
+    privateType: number,
+  ): Promise<void>;
+
+  generateKeyPairSync(
+    publicFormat: number,
+    publicType: number,
+    privateFormat: number,
+    privateType: number,
+  ): void;
+
+  getPublicKey(): ArrayBuffer;
+  getPrivateKey(): ArrayBuffer;
+
+  setPublicKey(keyData: ArrayBuffer, format: number, type: number): void;
+  setPrivateKey(keyData: ArrayBuffer, format: number, type: number): void;
+
+  encapsulate(): Promise<ArrayBuffer>;
+  encapsulateSync(): ArrayBuffer;
+
+  decapsulate(ciphertext: ArrayBuffer): Promise<ArrayBuffer>;
+  decapsulateSync(ciphertext: ArrayBuffer): ArrayBuffer;
+}

package/src/specs/pbkdf2.nitro.ts

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

package/src/specs/prime.nitro.ts

@@ -0,0 +1,18 @@
+import { type HybridObject } from 'react-native-nitro-modules';
+
+export interface Prime extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  generatePrime(
+    size: number,
+    safe: boolean,
+    add?: ArrayBuffer,
+    rem?: ArrayBuffer,
+  ): Promise<ArrayBuffer>;
+  generatePrimeSync(
+    size: number,
+    safe: boolean,
+    add?: ArrayBuffer,
+    rem?: ArrayBuffer,
+  ): ArrayBuffer;
+  checkPrime(candidate: ArrayBuffer, checks: number): Promise<boolean>;
+  checkPrimeSync(candidate: ArrayBuffer, checks: number): boolean;
+}

package/src/specs/random.nitro.ts

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

package/src/specs/rsaCipher.nitro.ts

@@ -0,0 +1,82 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { KeyObjectHandle } from './keyObjectHandle.nitro';
+
+export interface RsaCipher
+  extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  /**
+   * Encrypt data using RSA with specified padding
+   * @param keyHandle The public key handle
+   * @param data The data to encrypt
+   * @param padding RSA padding mode (1=PKCS1, 4=OAEP)
+   * @param hashAlgorithm The hash algorithm for OAEP (e.g., 'SHA-256')
+   * @param label Optional label for OAEP
+   * @returns Encrypted data
+   */
+  encrypt(
+    keyHandle: KeyObjectHandle,
+    data: ArrayBuffer,
+    padding: number,
+    hashAlgorithm: string,
+    label?: ArrayBuffer,
+  ): ArrayBuffer;
+
+  /**
+   * Decrypt data using RSA with specified padding
+   * @param keyHandle The private key handle
+   * @param data The data to decrypt
+   * @param padding RSA padding mode (1=PKCS1, 4=OAEP)
+   * @param hashAlgorithm The hash algorithm for OAEP (e.g., 'SHA-256')
+   * @param label Optional label for OAEP
+   * @returns Decrypted data
+   */
+  decrypt(
+    keyHandle: KeyObjectHandle,
+    data: ArrayBuffer,
+    padding: number,
+    hashAlgorithm: string,
+    label?: ArrayBuffer,
+  ): ArrayBuffer;
+
+  /**
+   * Decrypt data using public key (inverse of privateEncrypt, for signature verification)
+   * @param keyHandle The public key handle
+   * @param data The data to decrypt
+   * @param padding RSA padding mode (1=PKCS1)
+   * @returns Decrypted data
+   */
+  publicDecrypt(
+    keyHandle: KeyObjectHandle,
+    data: ArrayBuffer,
+    padding: number,
+  ): ArrayBuffer;
+
+  /**
+   * Encrypt data using private key (for signatures)
+   * @param keyHandle The private key handle
+   * @param data The data to encrypt
+   * @param padding RSA padding mode (1=PKCS1)
+   * @returns Encrypted data
+   */
+  privateEncrypt(
+    keyHandle: KeyObjectHandle,
+    data: ArrayBuffer,
+    padding: number,
+  ): ArrayBuffer;
+
+  /**
+   * Decrypt data using private key (inverse of publicEncrypt)
+   * @param keyHandle The private key handle
+   * @param data The data to decrypt
+   * @param padding RSA padding mode (1=PKCS1, 4=OAEP)
+   * @param hashAlgorithm The hash algorithm for OAEP (e.g., 'SHA-256')
+   * @param label Optional label for OAEP
+   * @returns Decrypted data
+   */
+  privateDecrypt(
+    keyHandle: KeyObjectHandle,
+    data: ArrayBuffer,
+    padding: number,
+    hashAlgorithm: string,
+    label?: ArrayBuffer,
+  ): ArrayBuffer;
+}

package/src/specs/rsaKeyPair.nitro.ts

@@ -0,0 +1,33 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+// Nitro-compatible interfaces defined locally
+interface KeyObject {
+  extractable: boolean;
+}
+
+export interface RsaKeyPair
+  extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  // generateKeyPair functions
+  generateKeyPair(): Promise<void>;
+  generateKeyPairSync(): void;
+
+  // RSA-specific setters
+  setModulusLength(modulusLength: number): void;
+  setPublicExponent(publicExponent: ArrayBuffer): void;
+  setHashAlgorithm(hashAlgorithm: string): void;
+
+  // importKey
+  importKey(
+    format: string,
+    keyData: ArrayBuffer,
+    algorithm: string,
+    extractable: boolean,
+    keyUsages: string[],
+  ): KeyObject;
+
+  // exportKey
+  exportKey(key: KeyObject, format: string): ArrayBuffer;
+
+  getPublicKey(): ArrayBuffer;
+  getPrivateKey(): ArrayBuffer;
+}

package/src/specs/scrypt.nitro.ts

@@ -0,0 +1,23 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+export interface Scrypt extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  deriveKey(
+    password: ArrayBuffer,
+    salt: ArrayBuffer,
+    N: number,
+    r: number,
+    p: number,
+    maxmem: number,
+    keylen: number,
+  ): Promise<ArrayBuffer>;
+
+  deriveKeySync(
+    password: ArrayBuffer,
+    salt: ArrayBuffer,
+    N: number,
+    r: number,
+    p: number,
+    maxmem: number,
+    keylen: number,
+  ): ArrayBuffer;
+}

package/src/specs/sign.nitro.ts

@@ -0,0 +1,31 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { KeyObjectHandle } from './keyObjectHandle.nitro';
+
+export interface SignHandle
+  extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  init(algorithm: string): void;
+
+  update(data: ArrayBuffer): void;
+
+  sign(
+    keyHandle: KeyObjectHandle,
+    padding?: number,
+    saltLength?: number,
+    dsaEncoding?: number,
+  ): ArrayBuffer;
+}
+
+export interface VerifyHandle
+  extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  init(algorithm: string): void;
+
+  update(data: ArrayBuffer): void;
+
+  verify(
+    keyHandle: KeyObjectHandle,
+    signature: ArrayBuffer,
+    padding?: number,
+    saltLength?: number,
+    dsaEncoding?: number,
+  ): boolean;
+}

package/src/specs/slhDsaKeyPair.nitro.ts

@@ -0,0 +1,29 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+export interface SlhDsaKeyPair
+  extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  generateKeyPair(
+    publicFormat: number,
+    publicType: number,
+    privateFormat: number,
+    privateType: number,
+  ): Promise<void>;
+
+  generateKeyPairSync(
+    publicFormat: number,
+    publicType: number,
+    privateFormat: number,
+    privateType: number,
+  ): void;
+
+  getPublicKey(): ArrayBuffer;
+  getPrivateKey(): ArrayBuffer;
+
+  sign(message: ArrayBuffer): Promise<ArrayBuffer>;
+  signSync(message: ArrayBuffer): ArrayBuffer;
+
+  verify(signature: ArrayBuffer, message: ArrayBuffer): Promise<boolean>;
+  verifySync(signature: ArrayBuffer, message: ArrayBuffer): boolean;
+
+  setVariant(variant: string): void;
+}

package/src/specs/turboshake.nitro.ts

@@ -0,0 +1,21 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+export type TurboShakeVariant = 'TurboSHAKE128' | 'TurboSHAKE256';
+export type KangarooTwelveVariant = 'KT128' | 'KT256';
+
+export interface TurboShake
+  extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  turboShake(
+    variant: TurboShakeVariant,
+    domainSeparation: number,
+    outputLength: number,
+    data: ArrayBuffer,
+  ): Promise<ArrayBuffer>;
+
+  kangarooTwelve(
+    variant: KangarooTwelveVariant,
+    outputLength: number,
+    data: ArrayBuffer,
+    customization?: ArrayBuffer,
+  ): Promise<ArrayBuffer>;
+}

package/src/specs/utils.nitro.ts

@@ -0,0 +1,5 @@
+import { type HybridObject } from 'react-native-nitro-modules';
+
+export interface Utils extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  timingSafeEqual(a: ArrayBuffer, b: ArrayBuffer): boolean;
+}