@digitaldefiance/ecies-lib 4.4.1 → 4.4.3

package/src/services/ecies/service.ts

@@ -0,0 +1,370 @@
+import { IECIESConstants } from '../../interfaces/ecies-consts';
+import { Constants } from '../../constants';
+import {
+  EciesEncryptionType,
+  EciesEncryptionTypeEnum,
+} from '../../enumerations/ecies-encryption-type';
+import { IECIESConfig } from '../../interfaces/ecies-config';
+import { SecureString } from '../../secure-string';
+import { SignatureString, SignatureUint8Array } from '../../types';
+import { EciesCryptoCore } from './crypto-core';
+import { IMultiEncryptedMessage, IMultiRecipient, ISimpleKeyPair, IWalletSeed } from './interfaces';
+import { EciesSignature } from './signature';
+import { EciesSingleRecipient } from './single-recipient';
+import { getEciesI18nEngine, EciesComponentId } from '../../i18n-setup';
+import { EciesStringKey } from '../../enumerations/ecies-string-key';
+import { EciesMultiRecipient } from './multi-recipient';
+
+/**
+ * Browser-compatible ECIES service that mirrors the server-side functionality
+ * Uses Web Crypto API and @scure/@noble libraries for browser compatibility
+ */
+export class ECIESService {
+  protected readonly _config: IECIESConfig;
+  protected readonly cryptoCore: EciesCryptoCore;
+  protected readonly signature: EciesSignature;
+  protected readonly singleRecipient: EciesSingleRecipient;
+  protected readonly multiRecipient: EciesMultiRecipient;
+  protected readonly eciesConsts: IECIESConstants;
+
+  constructor(config?: Partial<IECIESConfig>, eciesParams: IECIESConstants = Constants.ECIES) {
+    this.eciesConsts = eciesParams;
+    this._config = {
+      curveName: this.eciesConsts.CURVE_NAME,
+      primaryKeyDerivationPath: this.eciesConsts.PRIMARY_KEY_DERIVATION_PATH,
+      mnemonicStrength: this.eciesConsts.MNEMONIC_STRENGTH,
+      symmetricAlgorithm: this.eciesConsts.SYMMETRIC.ALGORITHM,
+      symmetricKeyBits: this.eciesConsts.SYMMETRIC.KEY_BITS,
+      symmetricKeyMode: this.eciesConsts.SYMMETRIC.MODE,
+      ...config,
+    };
+
+    // Initialize components
+    this.cryptoCore = new EciesCryptoCore(this._config, this.eciesConsts);
+    this.signature = new EciesSignature(this.cryptoCore);
+    this.singleRecipient = new EciesSingleRecipient(this._config, this.eciesConsts);
+    this.multiRecipient = new EciesMultiRecipient(this._config, this.eciesConsts);
+  }
+
+  public get core(): EciesCryptoCore {
+    return this.cryptoCore;
+  }
+
+  public get config(): IECIESConfig {
+    return this._config;
+  }
+
+  public get curveName(): string {
+    return this._config.curveName;
+  }
+
+  // === Key Management Methods ===
+
+  /**
+   * Generate a new mnemonic
+   */
+  public generateNewMnemonic(): SecureString {
+    return this.cryptoCore.generateNewMnemonic();
+  }
+
+  /**
+   * Generate wallet and seed from mnemonic
+   */
+  public walletAndSeedFromMnemonic(mnemonic: SecureString): IWalletSeed {
+    return this.cryptoCore.walletAndSeedFromMnemonic(mnemonic);
+  }
+
+  /**
+   * Create simple key pair from seed
+   */
+  public seedToSimpleKeyPair(seed: Uint8Array): ISimpleKeyPair {
+    return this.cryptoCore.seedToSimpleKeyPair(seed);
+  }
+
+  /**
+   * Create simple key pair from mnemonic
+   */
+  public mnemonicToSimpleKeyPair(mnemonic: SecureString): ISimpleKeyPair {
+    return this.cryptoCore.mnemonicToSimpleKeyPair(mnemonic);
+  }
+
+  /**
+   * Get public key from private key
+   */
+  public getPublicKey(privateKey: Uint8Array): Uint8Array {
+    return this.cryptoCore.getPublicKey(privateKey);
+  }
+
+  // === Core Encryption/Decryption Methods ===
+
+  /**
+   * Encrypt for single recipient (simple or single mode)
+   */
+  public async encryptSimpleOrSingle(
+    encryptSimple: boolean,
+    receiverPublicKey: Uint8Array,
+    message: Uint8Array,
+    preamble: Uint8Array = new Uint8Array(0),
+  ): Promise<Uint8Array> {
+    return this.singleRecipient.encrypt(
+      encryptSimple,
+      receiverPublicKey,
+      message,
+      preamble,
+    );
+  }
+
+  /**
+   * Parse single encrypted header
+   */
+  public parseSingleEncryptedHeader(
+    encryptionType: EciesEncryptionTypeEnum,
+    data: Uint8Array,
+    preambleSize: number = 0,
+    options?: { dataLength?: number },
+  ) {
+    const { header } = this.singleRecipient.parseEncryptedMessage(
+      encryptionType,
+      data,
+      preambleSize,
+      options,
+    );
+    return header;
+  }
+
+  /**
+   * Decrypt with header
+   */
+  public async decryptSimpleOrSingleWithHeader(
+    decryptSimple: boolean,
+    privateKey: Uint8Array,
+    encryptedData: Uint8Array,
+    preambleSize: number = 0,
+    options?: { dataLength?: number },
+  ): Promise<Uint8Array> {
+    return await this.singleRecipient.decryptWithHeader(
+      decryptSimple
+        ? EciesEncryptionTypeEnum.Simple
+        : EciesEncryptionTypeEnum.Single,
+      privateKey,
+      encryptedData,
+      preambleSize,
+      options,
+    );
+  }
+
+  /**
+   * Extended decrypt with header
+   */
+  public async decryptSimpleOrSingleWithHeaderEx(
+    encryptionType: EciesEncryptionTypeEnum,
+    privateKey: Uint8Array,
+    encryptedData: Uint8Array,
+    preambleSize: number = 0,
+    options?: { dataLength?: number },
+  ) {
+    return this.singleRecipient.decryptWithHeaderEx(
+      encryptionType,
+      privateKey,
+      encryptedData,
+      preambleSize,
+      options,
+    );
+  }
+
+  /**
+   * Decrypt with individual components
+   */
+  public async decryptSingleWithComponents(
+    privateKey: Uint8Array,
+    ephemeralPublicKey: Uint8Array,
+    iv: Uint8Array,
+    authTag: Uint8Array,
+    encrypted: Uint8Array,
+  ): Promise<{ decrypted: Uint8Array; ciphertextLength?: number }> {
+    const decrypted = await this.singleRecipient.decryptWithComponents(
+      privateKey,
+      ephemeralPublicKey,
+      iv,
+      authTag,
+      encrypted,
+    );
+
+    return { decrypted, ciphertextLength: encrypted.length };
+  }
+
+  // === Signature Methods ===
+
+  /**
+   * Sign a message
+   */
+  public signMessage(
+    privateKey: Uint8Array,
+    data: Uint8Array,
+  ): SignatureUint8Array {
+    return this.signature.signMessage(privateKey, data);
+  }
+
+  /**
+   * Verify a message signature
+   */
+  public verifyMessage(
+    publicKey: Uint8Array,
+    data: Uint8Array,
+    signature: SignatureUint8Array,
+  ): boolean {
+    return this.signature.verifyMessage(publicKey, data, signature);
+  }
+
+  /**
+   * Convert signature string to buffer
+   */
+  public signatureStringToSignatureUint8Array(
+    signatureString: SignatureString,
+  ): SignatureUint8Array {
+    return this.signature.signatureStringToSignatureUint8Array(signatureString);
+  }
+
+  /**
+   * Convert signature buffer to string
+   */
+  public signatureUint8ArrayToSignatureString(
+    signatureArray: SignatureUint8Array,
+  ): string {
+    return this.signature.signatureUint8ArrayToSignatureString(signatureArray);
+  }
+
+  // === Utility Methods ===
+
+  /**
+   * Compute encrypted length from data length
+   */
+  public computeEncryptedLengthFromDataLength(
+    dataLength: number,
+    encryptionMode: EciesEncryptionType,
+    recipientCount?: number,
+  ): number {
+    if (dataLength < 0) {
+      const engine = getEciesI18nEngine();
+      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_Service_InvalidDataLength));
+    }
+
+    switch (encryptionMode) {
+      case 'simple':
+        return dataLength + this.eciesConsts.SIMPLE.FIXED_OVERHEAD_SIZE;
+      case 'single':
+        return dataLength + this.eciesConsts.SINGLE.FIXED_OVERHEAD_SIZE;
+      case 'multiple':
+        // Basic calculation for multiple recipients
+        return (
+          dataLength +
+          this.eciesConsts.MULTIPLE.FIXED_OVERHEAD_SIZE +
+          (recipientCount ?? 1) * this.eciesConsts.MULTIPLE.ENCRYPTED_KEY_SIZE
+        );
+      default:
+        const engine = getEciesI18nEngine();
+        throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_Service_InvalidEncryptionType));
+    }
+  }
+
+  /**
+   * Compute decrypted length from encrypted data length
+   */
+  public computeDecryptedLengthFromEncryptedDataLength(
+    encryptedDataLength: number,
+    padding?: number,
+  ): number {
+    if (encryptedDataLength < 0) {
+      const engine = getEciesI18nEngine();
+      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_Service_InvalidEncryptedDataLength));
+    }
+
+  const overhead = this.eciesConsts.SINGLE.FIXED_OVERHEAD_SIZE;
+    const actualPadding = padding !== undefined ? padding : 0;
+    const decryptedLength = encryptedDataLength - overhead - actualPadding;
+
+    if (decryptedLength < 0) {
+      const engine = getEciesI18nEngine();
+      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_Service_ComputedDecryptedLengthNegative));
+    }
+
+    return decryptedLength;
+  }
+
+  /**
+   * Generic encrypt method
+   */
+  public async encrypt(
+    encryptionType: EciesEncryptionTypeEnum,
+    recipientPublicKey: Uint8Array,
+    message: Uint8Array,
+    preamble?: Uint8Array,
+  ): Promise<Uint8Array> {
+    if (encryptionType === EciesEncryptionTypeEnum.Multiple) {
+      throw new Error(
+        getEciesI18nEngine().translate(
+          EciesComponentId,
+          EciesStringKey.Error_ECIESError_MultipleEncryptionTypeNotSupportedInSingleRecipientMode,
+        ),
+      );
+    }
+    return this.singleRecipient.encrypt(
+      encryptionType === EciesEncryptionTypeEnum.Simple,
+      recipientPublicKey,
+      message,
+      preamble,
+    );
+  }
+  /**
+   * Encrypt for multiple recipients
+   * @param recipients 
+   * @param message 
+   * @param preamble 
+   * @returns 
+   */
+  public async encryptMultiple(
+    recipients: Array<IMultiRecipient>,
+    message: Uint8Array,
+    preamble?: Uint8Array,
+  ): Promise<IMultiEncryptedMessage> {
+      return this.multiRecipient.encryptMultiple(
+        recipients,
+        message,
+        preamble,
+      );
+    }
+
+    /**
+   * Encrypt a symmetric key for a recipient using an ephemeral private key
+   */
+  public async encryptKey(
+    receiverPublicKey: Uint8Array,
+    messageSymmetricKey: Uint8Array,
+    ephemeralPrivateKey: Uint8Array,
+    aad?: Uint8Array,
+  ): Promise<Uint8Array> {
+    return this.multiRecipient.encryptKey(
+      receiverPublicKey,
+      messageSymmetricKey,
+      ephemeralPrivateKey,
+      aad,
+    );
+  }
+
+  /**
+   * Decrypt a symmetric key using an ephemeral public key
+   */
+  public async decryptKey(
+    privateKey: Uint8Array,
+    encryptedKey: Uint8Array,
+    ephemeralPublicKey: Uint8Array,
+    aad?: Uint8Array,
+  ): Promise<Uint8Array> {
+    return this.multiRecipient.decryptKey(
+      privateKey,
+      encryptedKey,
+      ephemeralPublicKey,
+      aad,
+    );
+  }
+  }

package/src/services/ecies/signature.ts

@@ -0,0 +1,93 @@
+import { secp256k1 } from '@noble/curves/secp256k1.js';
+import { sha256 } from '@noble/hashes/sha2.js';
+import { SignatureString, SignatureUint8Array } from '../../types';
+import { uint8ArrayToHex } from '../../utils';
+import { EciesCryptoCore } from './crypto-core';
+
+/**
+ * Browser-compatible ECDSA signature operations
+ */
+export class EciesSignature {
+  private readonly cryptoCore: EciesCryptoCore;
+
+  constructor(cryptoCore: EciesCryptoCore) {
+    this.cryptoCore = cryptoCore;
+  }
+
+  /**
+   * Sign arbitrary binary data with a secp256k1 private key.
+   * Returns 64 bytes: [r(32) | s(32)]
+   */
+  public signMessage(
+    privateKey: Uint8Array,
+    data: Uint8Array,
+  ): SignatureUint8Array {
+    const hash = sha256(data);
+    // Use deterministic signatures (RFC 6979) for consistency
+    const signature = secp256k1.sign(hash, privateKey, {
+      format: 'compact',
+      extraEntropy: false,
+    });
+    return signature as SignatureUint8Array;
+  }
+
+  /**
+   * Verify signature (64 bytes: [r|s]) over arbitrary binary data against a public key.
+   */
+  public verifyMessage(
+    publicKey: Uint8Array,
+    data: Uint8Array,
+    signature: SignatureUint8Array,
+  ): boolean {
+    try {
+      if (!signature || signature.length !== 64) return false;
+      const hash = sha256(data);
+      const normalizedPublicKey = this.cryptoCore.normalizePublicKey(publicKey);
+
+      // Try direct verification first
+      try {
+        const directResult = secp256k1.verify(
+          signature,
+          hash,
+          normalizedPublicKey,
+        );
+        if (directResult) return true;
+      } catch {
+        // Continue to alternative verification methods
+      }
+
+      // If direct verification fails, the signature might be from a different library
+      // that uses different nonce generation. Since we can't make @noble/curves
+      // verify signatures from ethereumjs-util directly, we'll return false here.
+      // The calling code should handle cross-platform verification at a higher level.
+
+      return false;
+    } catch (err) {
+      console.error('Signature verification failed:', err);
+      return false;
+    }
+  }
+
+  /**
+   * Convert signature string to signature Uint8Array
+   */
+  public signatureStringToSignatureUint8Array(
+    signatureString: SignatureString,
+  ): SignatureUint8Array {
+    const cleanHex = signatureString.replace(/^0x/, '');
+    const result = new Uint8Array(cleanHex.length / 2);
+    for (let i = 0; i < cleanHex.length; i += 2) {
+      result[i / 2] = parseInt(cleanHex.substring(i, i + 2), 16);
+    }
+    return result as SignatureUint8Array;
+  }
+
+  /**
+   * Convert signature buffer to signature string
+   */
+  public signatureUint8ArrayToSignatureString(
+    signatureArray: SignatureUint8Array,
+  ): SignatureString {
+    return uint8ArrayToHex(signatureArray) as SignatureString;
+  }
+}