@digitaldefiance/ecies-lib 4.4.13 → 4.4.14

package/src/services/ecies/example.ts

@@ -1,185 +0,0 @@
-/**
- * Example usage of the browser-compatible ECIES service
- * This file demonstrates how to use the web-based ECIES implementation
- */
-
-import { SecureString } from '../../secure-string';
-import {
-  stringToUint8Array,
-  uint8ArrayToHex,
-  uint8ArrayToString,
-} from '../../utils';
-import { ECIESService } from './service';
-
-// https://docs.rs/bip39/latest/src/bip39/lib.rs.html
-
-/**
- * Example: Basic encryption and decryption
- */
-export async function basicEncryptionExample(): Promise<void> {
-  console.log('=== Basic ECIES Encryption Example ===');
-
-  // Create ECIES service instance
-  const ecies = new ECIESService();
-
-  // Generate a mnemonic and derive keys
-  const mnemonic = ecies.generateNewMnemonic();
-  console.log('Generated mnemonic:', mnemonic);
-
-  const { privateKey, publicKey } = ecies.mnemonicToSimpleKeyPair(mnemonic);
-  console.log('Private key hash:', uint8ArrayToHex(privateKey).slice(0, 16) + '...');
-  console.log('Public key:', uint8ArrayToHex(publicKey));
-
-  // Message to encrypt
-  const message = stringToUint8Array('Hello, Digital Defiance!');
-  console.log('Original message:', uint8ArrayToString(message));
-
-  // Encrypt using single mode (with CRC and length)
-  const encrypted = await ecies.encryptSimpleOrSingle(
-    false,
-    publicKey,
-    message,
-  );
-  console.log('Encrypted data length:', encrypted.length);
-  console.log('Encrypted data (hex):', uint8ArrayToHex(encrypted));
-
-  // Decrypt the message
-  const decrypted = await ecies.decryptSimpleOrSingleWithHeader(
-    false,
-    privateKey,
-    encrypted,
-  );
-  console.log('Decrypted message:', uint8ArrayToString(decrypted));
-
-  // Verify the message matches
-  const matches = uint8ArrayToString(message) === uint8ArrayToString(decrypted);
-  console.log('Encryption/Decryption successful:', matches);
-}
-
-/**
- * Example: Simple mode encryption (without CRC)
- */
-export async function simpleEncryptionExample(): Promise<void> {
-  console.log('\n=== Simple ECIES Encryption Example ===');
-
-  const ecies = new ECIESService();
-
-  // Generate keys for sender and receiver
-  const senderMnemonic = ecies.generateNewMnemonic();
-  const receiverMnemonic = ecies.generateNewMnemonic();
-
-  const senderKeys = ecies.mnemonicToSimpleKeyPair(senderMnemonic);
-  const receiverKeys = ecies.mnemonicToSimpleKeyPair(receiverMnemonic);
-
-  console.log('Sender public key:', uint8ArrayToHex(senderKeys.publicKey));
-  console.log('Receiver public key:', uint8ArrayToHex(receiverKeys.publicKey));
-
-  // Message to encrypt
-  const message = stringToUint8Array('This is a simple encrypted message');
-  console.log('Original message:', uint8ArrayToString(message));
-
-  // Encrypt using simple mode (no CRC, no length prefix)
-  const encrypted = await ecies.encryptSimpleOrSingle(
-    true,
-    receiverKeys.publicKey,
-    message,
-  );
-  console.log('Encrypted data length:', encrypted.length);
-
-  // Decrypt the message
-  const decrypted = await ecies.decryptSimpleOrSingleWithHeader(
-    true,
-    receiverKeys.privateKey,
-    encrypted,
-  );
-  console.log('Decrypted message:', uint8ArrayToString(decrypted));
-
-  // Verify the message matches
-  const matches = uint8ArrayToString(message) === uint8ArrayToString(decrypted);
-  console.log('Simple encryption/decryption successful:', matches);
-}
-
-/**
- * Example: Digital signature
- */
-export async function signatureExample(): Promise<void> {
-  console.log('\n=== Digital Signature Example ===');
-
-  const ecies = new ECIESService();
-
-  // Generate keys
-  const mnemonic = ecies.generateNewMnemonic();
-  const { privateKey, publicKey } = ecies.mnemonicToSimpleKeyPair(mnemonic);
-
-  // Message to sign
-  const message = stringToUint8Array('This message is digitally signed');
-  console.log('Message to sign:', uint8ArrayToString(message));
-
-  // Sign the message
-  const signature = ecies.signMessage(privateKey, message);
-  console.log('Signature:', uint8ArrayToHex(signature));
-
-  // Verify the signature
-  const isValid = ecies.verifyMessage(publicKey, message, signature);
-  console.log('Signature valid:', isValid);
-
-  // Test with tampered message
-  const tamperedMessage = stringToUint8Array(
-    'This message has been tampered with',
-  );
-  const isTamperedValid = ecies.verifyMessage(
-    publicKey,
-    tamperedMessage,
-    signature,
-  );
-  console.log('Tampered message signature valid:', isTamperedValid);
-}
-
-/**
- * Example: Wallet derivation from mnemonic
- */
-export async function walletDerivationExample(): Promise<void> {
-  console.log('\n=== Wallet Derivation Example ===');
-
-  const ecies = new ECIESService();
-
-  // Use a known mnemonic for reproducible results
-  const mnemonic = new SecureString(
-    'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about',
-  );
-  console.log('Test mnemonic: [REDACTED - known test mnemonic]');
-
-  // Derive wallet
-  const { wallet, seed } = ecies.walletAndSeedFromMnemonic(mnemonic);
-  console.log('Seed:', uint8ArrayToHex(seed));
-  console.log('Private key hash:', uint8ArrayToHex(wallet.getPrivateKey()).slice(0, 16) + '...');
-  console.log('Public key:', uint8ArrayToHex(wallet.getPublicKey()));
-
-  // Derive the same keys using the simple method
-  const simpleKeys = ecies.mnemonicToSimpleKeyPair(mnemonic);
-  console.log(
-    'Simple private key matches:',
-    uint8ArrayToHex(wallet.getPrivateKey()) ===
-      uint8ArrayToHex(simpleKeys.privateKey),
-  );
-  console.log(
-    'Simple public key matches:',
-    uint8ArrayToHex(wallet.getPublicKey()) ===
-      uint8ArrayToHex(simpleKeys.publicKey),
-  );
-}
-
-/**
- * Run all examples
- */
-export async function runAllExamples(): Promise<void> {
-  try {
-    await basicEncryptionExample();
-    await simpleEncryptionExample();
-    await signatureExample();
-    await walletDerivationExample();
-    console.log('\n=== All examples completed successfully! ===');
-  } catch (error) {
-    console.error('Example failed:', error);
-  }
-}

package/src/services/ecies/file.ts

@@ -1,167 +0,0 @@
-import { IEciesFileService } from '../../interfaces/ecies-file-service';
-import { ECIESService } from './service';
-
-interface ChunkedFileHeader {
-  version: number;
-  chunkSize: number;
-  totalChunks: number;
-  originalSize: number;
-}
-
-export class EciesFileService implements IEciesFileService {
-  private static readonly CHUNK_SIZE = 1024 * 1024; // 1MB chunks
-  private static readonly HEADER_SIZE = 20; // 4 bytes each: version, chunkSize, totalChunks, originalSize, padding
-
-  constructor(
-    private eciesService: ECIESService,
-    private userPrivateKey: Uint8Array,
-  ) {}
-
-  async encryptFile(
-    file: File,
-    recipientPublicKey: Uint8Array,
-  ): Promise<Uint8Array> {
-    const totalChunks = Math.ceil(file.size / EciesFileService.CHUNK_SIZE);
-    const header: ChunkedFileHeader = {
-      version: 1,
-      chunkSize: EciesFileService.CHUNK_SIZE,
-      totalChunks,
-      originalSize: file.size,
-    };
-
-    const headerBytes = this.serializeHeader(header);
-    const encryptedHeader = await this.eciesService.encryptSimpleOrSingle(
-      false,
-      recipientPublicKey,
-      headerBytes,
-    );
-
-    const chunks: Uint8Array[] = [encryptedHeader];
-
-    for (let i = 0; i < totalChunks; i++) {
-      const offset = i * EciesFileService.CHUNK_SIZE;
-      const chunk = file.slice(offset, offset + EciesFileService.CHUNK_SIZE);
-      const chunkData = new Uint8Array(await chunk.arrayBuffer());
-      const encryptedChunk = await this.eciesService.encryptSimpleOrSingle(
-        false,
-        recipientPublicKey,
-        chunkData,
-      );
-      chunks.push(encryptedChunk);
-    }
-
-    const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const chunk of chunks) {
-      result.set(chunk, offset);
-      offset += chunk.length;
-    }
-    return result;
-  }
-
-  async decryptFile(encryptedData: Uint8Array): Promise<Uint8Array> {
-    const { header, chunks } = await this.parseEncryptedFile(encryptedData);
-    const decryptedChunks: Uint8Array[] = [];
-
-    for (const chunk of chunks) {
-      const decrypted = await this.eciesService.decryptSimpleOrSingleWithHeader(
-        false,
-        this.userPrivateKey,
-        chunk,
-      );
-      decryptedChunks.push(decrypted);
-    }
-
-    const result = new Uint8Array(header.originalSize);
-    let offset = 0;
-    for (const chunk of decryptedChunks) {
-      const copyLength = Math.min(chunk.length, header.originalSize - offset);
-      result.set(chunk.subarray(0, copyLength), offset);
-      offset += copyLength;
-    }
-    return result;
-  }
-
-  downloadEncryptedFile(encryptedData: Uint8Array, filename: string): void {
-    this.downloadFile(encryptedData, `${filename}.encrypted`);
-  }
-
-  downloadDecryptedFile(decryptedData: Uint8Array, filename: string): void {
-    this.downloadFile(decryptedData, filename);
-  }
-
-  private serializeHeader(header: ChunkedFileHeader): Uint8Array {
-    const buffer = new ArrayBuffer(EciesFileService.HEADER_SIZE);
-    const view = new DataView(buffer);
-    view.setUint32(0, header.version, false);
-    view.setUint32(4, header.chunkSize, false);
-    view.setUint32(8, header.totalChunks, false);
-    view.setUint32(12, header.originalSize, false);
-    return new Uint8Array(buffer);
-  }
-
-  private deserializeHeader(data: Uint8Array): ChunkedFileHeader {
-    const view = new DataView(
-      data.buffer,
-      data.byteOffset,
-      EciesFileService.HEADER_SIZE,
-    );
-    return {
-      version: view.getUint32(0, false),
-      chunkSize: view.getUint32(4, false),
-      totalChunks: view.getUint32(8, false),
-      originalSize: view.getUint32(12, false),
-    };
-  }
-
-  private async parseEncryptedFile(encryptedData: Uint8Array): Promise<{
-    header: ChunkedFileHeader;
-    chunks: Uint8Array[];
-  }> {
-    // First, decrypt the header to get metadata
-    const headerLength = this.eciesService.computeEncryptedLengthFromDataLength(
-      EciesFileService.HEADER_SIZE,
-      'single',
-    );
-
-    const encryptedHeader = encryptedData.subarray(0, headerLength);
-    const decryptedHeaderBytes =
-      await this.eciesService.decryptSimpleOrSingleWithHeader(
-        false,
-        this.userPrivateKey,
-        encryptedHeader,
-      );
-
-    const header = this.deserializeHeader(decryptedHeaderBytes);
-    const chunks: Uint8Array[] = [];
-    let offset = headerLength;
-
-    for (let i = 0; i < header.totalChunks; i++) {
-      const chunkLength =
-        this.eciesService.computeEncryptedLengthFromDataLength(
-          i === header.totalChunks - 1
-            ? header.originalSize % header.chunkSize || header.chunkSize
-            : header.chunkSize,
-          'single',
-        );
-
-      chunks.push(encryptedData.subarray(offset, offset + chunkLength));
-      offset += chunkLength;
-    }
-
-    return { header, chunks };
-  }
-
-  private downloadFile(data: Uint8Array, filename: string): void {
-    const blob = new Blob([data.slice()]);
-    const url = URL.createObjectURL(blob);
-    const a = document.createElement('a');
-    a.href = url;
-    a.download = filename;
-    document.body.appendChild(a);
-    a.click();
-    document.body.removeChild(a);
-    URL.revokeObjectURL(url);
-  }
-}

package/src/services/ecies/integration.ts

@@ -1,241 +0,0 @@
-/**
- * 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

@@ -1,62 +0,0 @@
-/**
- * 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 {
-  preamble?: Uint8Array;
-  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;
-  ephemeralPublicKey?: Uint8Array; // Added for shared ephemeral key optimization
-}
-
-export interface IMultiEncryptedParsedHeader {
-  dataLength: number;
-  recipientCount: number;
-  recipientIds: Uint8Array[];
-  recipientKeys: Uint8Array[];
-  headerSize: number;
-  ephemeralPublicKey?: Uint8Array; // Added for shared ephemeral key optimization
-}