@digitaldefiance/ecies-lib 1.1.23 → 1.1.24

package/src/services/ecies/integration.ts

@@ -0,0 +1,241 @@
+/**
+ * Integration helpers for using the browser ECIES service with existing web-crypto functionality
+ */
+
+import { EciesComponentId, getEciesI18nEngine } from '../../i18n-setup';
+import { SecureString } from '../../secure-string';
+import { SignatureUint8Array } from '../../types';
+import {
+  hexToUint8Array,
+  stringToUint8Array,
+  uint8ArrayToHex,
+  uint8ArrayToString,
+} from '../../utils';
+import { IWalletSeed } from './interfaces';
+import { ECIESService } from './service';
+import { EciesStringKey } from '../../enumerations';
+
+/**
+ * Enhanced web crypto service that uses the new ECIES implementation
+ */
+export class EnhancedWebCryptoService {
+  private ecies: ECIESService;
+
+  constructor() {
+    this.ecies = new ECIESService();
+  }
+
+  /**
+   * Derive wallet from mnemonic using the new ECIES service
+   * This replaces the existing walletFromMnemonic method with better browser compatibility
+   */
+  public async walletFromMnemonic(
+    mnemonic: SecureString,
+  ): Promise<IWalletSeed> {
+    const { wallet, seed } = this.ecies.walletAndSeedFromMnemonic(mnemonic);
+    return {
+      wallet,
+      seed,
+    };
+  }
+
+  /**
+   * Decrypt challenge using the new ECIES service
+   * This provides better compatibility and error handling than the original implementation
+   */
+  public async decryptChallenge(
+    encryptedHex: string,
+    privateKey: Uint8Array,
+  ): Promise<Uint8Array> {
+    try {
+      const encryptedData = hexToUint8Array(encryptedHex);
+
+      // Try to decrypt using single mode first (most common)
+      try {
+        return await this.ecies.decryptSimpleOrSingleWithHeader(
+          false,
+          privateKey,
+          encryptedData,
+        );
+      } catch {
+        // Fallback to simple mode
+        return await this.ecies.decryptSimpleOrSingleWithHeader(
+          true,
+          privateKey,
+          encryptedData,
+        );
+      }
+    } catch (error) {
+      const engine = getEciesI18nEngine();
+      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_ECIESError_FailedToDecryptChallengeTemplate, { error: String(error) }));
+    }
+  }
+
+  /**
+   * Encrypt data for a recipient
+   */
+  public async encryptForRecipient(
+    recipientPublicKey: Uint8Array,
+    data: Uint8Array,
+    useSimpleMode: boolean = false,
+  ): Promise<string> {
+    const encrypted = await this.ecies.encryptSimpleOrSingle(
+      !useSimpleMode,
+      recipientPublicKey,
+      data,
+    );
+    return uint8ArrayToHex(encrypted);
+  }
+
+  /**
+   * Sign data with private key
+   */
+  public signData(privateKey: Uint8Array, data: Uint8Array): string {
+    const signature = this.ecies.signMessage(privateKey, data);
+    return uint8ArrayToHex(signature);
+  }
+
+  /**
+   * Verify signature
+   */
+  public verifySignature(
+    publicKey: Uint8Array,
+    data: Uint8Array,
+    signatureHex: string,
+  ): boolean {
+    const signature = hexToUint8Array(signatureHex) as SignatureUint8Array;
+    return this.ecies.verifyMessage(publicKey, data, signature);
+  }
+
+  /**
+   * Generate new mnemonic
+   */
+  public generateMnemonic(): SecureString {
+    return this.ecies.generateNewMnemonic();
+  }
+
+  /**
+   * Complete client-side challenge verification (enhanced version)
+   */
+  public async verifyChallengeResponse(
+    encryptedChallenge: string,
+    mnemonic: SecureString,
+    systemPublicKeyHex: string,
+  ): Promise<string> {
+    // Derive keys from mnemonic
+    const { wallet } = await this.walletFromMnemonic(mnemonic);
+
+    // Decrypt the challenge
+    const decryptedPayload = await this.decryptChallenge(
+      encryptedChallenge,
+      wallet.getPrivateKey(),
+    );
+
+    // Extract nonce and signature (assuming 48 bytes payload + signature)
+    const payload = decryptedPayload.slice(0, 48);
+    const signature = decryptedPayload.slice(48);
+
+    // Convert system public key from hex
+    const systemPubKey = hexToUint8Array(systemPublicKeyHex);
+
+    // Verify system signature
+    const isValid = this.verifySignature(
+      systemPubKey,
+      payload,
+      uint8ArrayToHex(signature),
+    );
+
+    if (!isValid) {
+      const engine = getEciesI18nEngine();
+      const error = engine.translate(EciesComponentId, EciesStringKey.Error_ECIESError_InvalidChallengeSignature);
+    }
+
+    return uint8ArrayToHex(decryptedPayload);
+  }
+}
+
+/**
+ * Migration helper to transition from old WebCryptoService to new ECIES service
+ */
+export class MigrationHelper {
+  /**
+   * Test compatibility between old and new implementations
+   */
+  public static async testCompatibility(mnemonic: SecureString): Promise<{
+    compatible: boolean;
+    details: {
+      mnemonicValid: boolean;
+      keysMatch: boolean;
+      encryptionWorks: boolean;
+    };
+  }> {
+    try {
+      const ecies = new ECIESService();
+      const enhanced = new EnhancedWebCryptoService();
+
+      // Test mnemonic validation
+      let mnemonicValid = false;
+      try {
+        ecies.walletAndSeedFromMnemonic(mnemonic);
+        mnemonicValid = true;
+      } catch {
+        mnemonicValid = false;
+      }
+
+      // Test key derivation
+      let keysMatch = false;
+      if (mnemonicValid) {
+        try {
+          const { wallet: wallet1 } = ecies.walletAndSeedFromMnemonic(mnemonic);
+          const { wallet: wallet2 } = await enhanced.walletFromMnemonic(
+            mnemonic,
+          );
+          keysMatch =
+            uint8ArrayToHex(wallet1.getPrivateKey()) ===
+            uint8ArrayToHex(wallet2.getPrivateKey());
+        } catch {
+          keysMatch = false;
+        }
+      }
+
+      // Test encryption roundtrip
+      let encryptionWorks = false;
+      if (keysMatch) {
+        try {
+          const { wallet } = await enhanced.walletFromMnemonic(mnemonic);
+          const testMessage = stringToUint8Array('Test message');
+          const encrypted = await enhanced.encryptForRecipient(
+            wallet.getPublicKey(),
+            testMessage,
+          );
+          const decrypted = await enhanced.decryptChallenge(
+            encrypted,
+            wallet.getPrivateKey(),
+          );
+          encryptionWorks =
+            uint8ArrayToString(testMessage) === uint8ArrayToString(decrypted);
+        } catch {
+          encryptionWorks = false;
+        }
+      }
+
+      return {
+        compatible: mnemonicValid && keysMatch && encryptionWorks,
+        details: {
+          mnemonicValid,
+          keysMatch,
+          encryptionWorks,
+        },
+      };
+    } catch {
+      return {
+        compatible: false,
+        details: {
+          mnemonicValid: false,
+          keysMatch: false,
+          encryptionWorks: false,
+        },
+      };
+    }
+  }
+}

package/src/services/ecies/interfaces.ts

@@ -0,0 +1,59 @@
+/**
+ * Browser-compatible ECIES interfaces
+ */
+
+import { Wallet } from '@ethereumjs/wallet';
+import { EciesEncryptionTypeEnum } from '../../enumerations/ecies-encryption-type';
+
+export interface ISimpleKeyPair {
+  privateKey: Uint8Array;
+  publicKey: Uint8Array;
+}
+
+export interface IWalletSeed {
+  wallet: Wallet;
+  seed: Uint8Array;
+}
+
+export interface ISingleEncryptedParsedHeader {
+  encryptionType: EciesEncryptionTypeEnum;
+  ephemeralPublicKey: Uint8Array;
+  iv: Uint8Array;
+  authTag: Uint8Array;
+  dataLength: number;
+  headerSize: number;
+}
+
+export interface IEncryptionResult {
+  encryptedData: Uint8Array;
+  ephemeralPublicKey: Uint8Array;
+  iv: Uint8Array;
+  authTag: Uint8Array;
+}
+
+export interface IDecryptionResult {
+  decrypted: Uint8Array;
+  consumedBytes: number;
+}
+
+export interface IMultiRecipient {
+  id: Uint8Array; // 16-byte ObjectId
+  publicKey: Uint8Array;
+}
+
+export interface IMultiEncryptedMessage {
+  dataLength: number;
+  recipientCount: number;
+  recipientIds: Uint8Array[];
+  recipientKeys: Uint8Array[];
+  encryptedMessage: Uint8Array;
+  headerSize: number;
+}
+
+export interface IMultiEncryptedParsedHeader {
+  dataLength: number;
+  recipientCount: number;
+  recipientIds: Uint8Array[];
+  recipientKeys: Uint8Array[];
+  headerSize: number;
+}

package/src/services/ecies/manual-test.ts

@@ -0,0 +1,219 @@
+/**
+ * Simple integration tests for the browser ECIES service
+ * These tests can be run in the browser console to verify functionality
+ */
+
+import { SecureString } from '../../secure-string';
+import {
+  stringToUint8Array,
+  uint8ArrayToHex,
+  uint8ArrayToString,
+} from '../../utils';
+import { ECIESService } from './service';
+
+/**
+ * Test basic encryption/decryption roundtrip
+ */
+export async function testBasicEncryption(): Promise<boolean> {
+  try {
+    const ecies = new ECIESService();
+    const mnemonic = ecies.generateNewMnemonic();
+    const { privateKey, publicKey } = ecies.mnemonicToSimpleKeyPair(mnemonic);
+
+    const message = stringToUint8Array('Test message');
+    const encrypted = await ecies.encryptSimpleOrSingle(
+      false,
+      publicKey,
+      message,
+    );
+    const decrypted = await ecies.decryptSimpleOrSingleWithHeader(
+      false,
+      privateKey,
+      encrypted,
+    );
+
+    return uint8ArrayToString(message) === uint8ArrayToString(decrypted);
+  } catch (error) {
+    console.error('Basic encryption test failed:', error);
+    return false;
+  }
+}
+
+/**
+ * Test simple mode encryption
+ */
+export async function testSimpleEncryption(): Promise<boolean> {
+  try {
+    const ecies = new ECIESService();
+    const mnemonic = ecies.generateNewMnemonic();
+    const { privateKey, publicKey } = ecies.mnemonicToSimpleKeyPair(mnemonic);
+
+    const message = stringToUint8Array('Simple test message');
+    const encrypted = await ecies.encryptSimpleOrSingle(
+      true,
+      publicKey,
+      message,
+    );
+    const decrypted = await ecies.decryptSimpleOrSingleWithHeader(
+      true,
+      privateKey,
+      encrypted,
+    );
+
+    return uint8ArrayToString(message) === uint8ArrayToString(decrypted);
+  } catch (error) {
+    console.error('Simple encryption test failed:', error);
+    return false;
+  }
+}
+
+/**
+ * Test signature operations
+ */
+export async function testSignatures(): Promise<boolean> {
+  try {
+    const ecies = new ECIESService();
+    const mnemonic = ecies.generateNewMnemonic();
+    const { privateKey, publicKey } = ecies.mnemonicToSimpleKeyPair(mnemonic);
+
+    const message = stringToUint8Array('Message to sign');
+    const signature = ecies.signMessage(privateKey, message);
+    const isValid = ecies.verifyMessage(publicKey, message, signature);
+
+    // Test with wrong message
+    const wrongMessage = stringToUint8Array('Wrong message');
+    const isInvalid = ecies.verifyMessage(publicKey, wrongMessage, signature);
+
+    return isValid && !isInvalid;
+  } catch (error) {
+    console.error('Signature test failed:', error);
+    return false;
+  }
+}
+
+/**
+ * Test mnemonic validation
+ */
+export async function testMnemonicValidation(): Promise<boolean> {
+  try {
+    const ecies = new ECIESService();
+
+    // Test valid mnemonic
+    const validMnemonic = new SecureString(
+      'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about',
+    );
+    const { wallet: wallet1 } = ecies.walletAndSeedFromMnemonic(validMnemonic);
+    const { wallet: wallet2 } = ecies.walletAndSeedFromMnemonic(validMnemonic);
+
+    // Should produce same keys
+    const sameKeys =
+      uint8ArrayToHex(wallet1.getPrivateKey()) ===
+      uint8ArrayToHex(wallet2.getPrivateKey());
+
+    // Test invalid mnemonic
+    try {
+      ecies.walletAndSeedFromMnemonic(
+        new SecureString('invalid mnemonic phrase'),
+      );
+      return false; // Should have thrown
+    } catch {
+      return sameKeys; // Expected to throw
+    }
+  } catch (error) {
+    console.error('Mnemonic validation test failed:', error);
+    return false;
+  }
+}
+
+/**
+ * Test cross-party encryption (Alice encrypts for Bob)
+ */
+export async function testCrossPartyEncryption(): Promise<boolean> {
+  try {
+    const ecies = new ECIESService();
+
+    // Alice generates her keys
+    const aliceMnemonic = ecies.generateNewMnemonic();
+    const aliceKeys = ecies.mnemonicToSimpleKeyPair(aliceMnemonic);
+
+    // Bob generates his keys
+    const bobMnemonic = ecies.generateNewMnemonic();
+    const bobKeys = ecies.mnemonicToSimpleKeyPair(bobMnemonic);
+
+    // Alice encrypts a message for Bob
+    const message = stringToUint8Array('Secret message from Alice to Bob');
+    const encrypted = await ecies.encryptSimpleOrSingle(
+      false,
+      bobKeys.publicKey,
+      message,
+    );
+
+    // Bob decrypts the message
+    const decrypted = await ecies.decryptSimpleOrSingleWithHeader(
+      false,
+      bobKeys.privateKey,
+      encrypted,
+    );
+
+    // Alice should not be able to decrypt (wrong private key)
+    try {
+      await ecies.decryptSimpleOrSingleWithHeader(
+        false,
+        aliceKeys.privateKey,
+        encrypted,
+      );
+      return false; // Should have failed
+    } catch {
+      // Expected to fail
+    }
+
+    return uint8ArrayToString(message) === uint8ArrayToString(decrypted);
+  } catch (error) {
+    console.error('Cross-party encryption test failed:', error);
+    return false;
+  }
+}
+
+/**
+ * Run all tests
+ */
+export async function runAllTests(): Promise<void> {
+  console.log('Running browser ECIES service tests...\n');
+
+  const tests = [
+    { name: 'Basic Encryption', test: testBasicEncryption },
+    { name: 'Simple Encryption', test: testSimpleEncryption },
+    { name: 'Digital Signatures', test: testSignatures },
+    { name: 'Mnemonic Validation', test: testMnemonicValidation },
+    { name: 'Cross-Party Encryption', test: testCrossPartyEncryption },
+  ];
+
+  let passed = 0;
+  let failed = 0;
+
+  for (const { name, test } of tests) {
+    try {
+      const result = await test();
+      if (result) {
+        console.log(`✅ ${name}: PASSED`);
+        passed++;
+      } else {
+        console.log(`❌ ${name}: FAILED`);
+        failed++;
+      }
+    } catch (error) {
+      console.log(`❌ ${name}: ERROR - ${error}`);
+      failed++;
+    }
+  }
+
+  console.log(`\nTest Results: ${passed} passed, ${failed} failed`);
+
+  if (failed === 0) {
+    console.log(
+      '🎉 All tests passed! The browser ECIES service is working correctly.',
+    );
+  } else {
+    console.log('⚠️  Some tests failed. Please check the implementation.');
+  }
+}