@digitaldefiance/ecies-lib 1.1.24 → 1.1.26

package/src/services/ecies/crypto-core.ts

@@ -1,180 +0,0 @@
-import { Wallet } from '@ethereumjs/wallet';
-import { HDKey } from '@scure/bip32';
-import {
-  generateMnemonic,
-  mnemonicToSeedSync,
-  validateMnemonic,
-} from '@scure/bip39';
-import { wordlist } from '@scure/bip39/wordlists/english';
-import { Constants } from '../../constants';
-import { IECIESConfig } from '../../interfaces/ecies-config';
-import { SecureString } from '../../secure-string';
-import { ISimpleKeyPair, IWalletSeed } from './interfaces';
-
-import { secp256k1 } from '@noble/curves/secp256k1.js';
-import { IECIESConstants } from '../../interfaces/ecies-consts';
-import { EciesComponentId, getEciesI18nEngine } from '../../i18n-setup';
-import { EciesStringKey } from '../../enumerations';
-
-/**
- * Browser-compatible crypto core for ECIES operations
- * Uses @scure libraries for browser compatibility
- */
-export class EciesCryptoCore {
-  protected readonly _config: IECIESConfig;
-  protected readonly _eciesConsts: IECIESConstants;
-
-  constructor(config: IECIESConfig, eciesParams: IECIESConstants = Constants.ECIES) {
-    this._config = config;
-    this._eciesConsts = eciesParams;
-  }
-
-
-
-  public get config(): IECIESConfig {
-    return this._config;
-  }
-
-  /**
-   * Validates and normalizes a public key for ECIES operations
-   */
-  public normalizePublicKey(publicKey: Uint8Array): Uint8Array {
-    if (!publicKey) {
-      const engine = getEciesI18nEngine();
-      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_ECIESError_ReceivedNullOrUndefinedPublicKey));
-    }
-
-    const keyLength = publicKey.length;
-
-    // Already in correct format (65 bytes with 0x04 prefix)
-    if (
-      keyLength === this._eciesConsts.PUBLIC_KEY_LENGTH &&
-      publicKey[0] === this._eciesConsts.PUBLIC_KEY_MAGIC
-    ) {
-      return publicKey;
-    }
-
-    // Raw key without prefix (64 bytes) - add the 0x04 prefix
-    if (keyLength === this._eciesConsts.RAW_PUBLIC_KEY_LENGTH) {
-      const result = new Uint8Array(this._eciesConsts.PUBLIC_KEY_LENGTH);
-      result[0] = this._eciesConsts.PUBLIC_KEY_MAGIC;
-      result.set(publicKey, 1);
-      return result;
-    }
-
-    const engine = getEciesI18nEngine();
-    throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_ECIESError_InvalidPublicKeyFormatOrLengthTemplate, { keyLength }));
-  }
-
-  /**
-   * Generate a new mnemonic
-   */
-  public generateNewMnemonic(): SecureString {
-    return new SecureString(
-      generateMnemonic(wordlist, this._config.mnemonicStrength),
-    );
-  }
-
-  /**
-   * Generate wallet and seed from mnemonic
-   */
-  public walletAndSeedFromMnemonic(mnemonic: SecureString): IWalletSeed {
-    if (!mnemonic || !validateMnemonic(mnemonic.value ?? '', wordlist)) {
-      const engine = getEciesI18nEngine();
-      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_ECIESError_InvalidMnemonic));
-    }
-
-    const seed = mnemonicToSeedSync(mnemonic.value ?? '');
-    const hdKey = HDKey.fromMasterSeed(seed);
-    const derivedKey = hdKey.derive(this._config.primaryKeyDerivationPath);
-
-    if (!derivedKey.privateKey) {
-      const engine = getEciesI18nEngine();
-      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_ECIESError_FailedToDervivePrivateKey));
-    }
-
-    const privateKey = derivedKey.privateKey;
-
-    const wallet = new Wallet(privateKey);
-
-    return {
-      wallet,
-      seed,
-    };
-  }
-
-  /**
-   * Create a simple key pair from a seed
-   */
-  public seedToSimpleKeyPair(seed: Uint8Array): ISimpleKeyPair {
-    const hdKey = HDKey.fromMasterSeed(seed);
-    const derivedKey = hdKey.derive(this._config.primaryKeyDerivationPath);
-
-    if (!derivedKey.privateKey) {
-      const engine = getEciesI18nEngine();
-      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_ECIESError_FailedToDervivePrivateKey));
-    }
-
-    const privateKey = derivedKey.privateKey;
-    const publicKey = secp256k1.getPublicKey(privateKey, false); // uncompressed with 0x04 prefix
-
-    return {
-      privateKey,
-      publicKey,
-    };
-  }
-
-  /**
-   * Create a simple key pair from a mnemonic
-   */
-  public mnemonicToSimpleKeyPair(mnemonic: SecureString): ISimpleKeyPair {
-    const { seed } = this.walletAndSeedFromMnemonic(mnemonic);
-    return this.seedToSimpleKeyPair(seed);
-  }
-
-  /**
-   * Generate a random private key
-   */
-  public generatePrivateKey(): Uint8Array {
-    return secp256k1.utils.randomSecretKey();
-  }
-
-  /**
-   * Get public key from private key
-   */
-  public getPublicKey(privateKey: Uint8Array): Uint8Array {
-    const publicKeyPoint = secp256k1.getPublicKey(privateKey, false); // uncompressed
-    // publicKeyPoint already includes the 0x04 prefix, so return as-is
-    return publicKeyPoint;
-  }
-
-  /**
-   * Generate ephemeral key pair for ECIES
-   */
-  public async generateEphemeralKeyPair(): Promise<ISimpleKeyPair> {
-    const privateKey = this.generatePrivateKey();
-    const publicKey = this.getPublicKey(privateKey);
-    return { privateKey, publicKey };
-  }
-
-  /**
-   * Compute ECDH shared secret
-   */
-  public computeSharedSecret(
-    privateKey: Uint8Array,
-    publicKey: Uint8Array,
-  ): Uint8Array {
-    // Normalize the public key to ensure it has the correct format
-    const normalizedPublicKey = this.normalizePublicKey(publicKey);
-
-    // Use uncompressed shared secret to match Node.js ECDH behavior
-    // Node.js ECDH.computeSecret() returns the x-coordinate of the shared point
-    const sharedSecret = secp256k1.getSharedSecret(
-      privateKey,
-      normalizedPublicKey,
-      false,
-    );
-    // Return only the x-coordinate (first 32 bytes after the 0x04 prefix)
-    return sharedSecret.slice(1, 33);
-  }
-}

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);
-  }
-}