@digitaldefiance/node-ecies-lib 1.1.22 → 1.1.23

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

@@ -1,213 +0,0 @@
-import {
-  ECIESError,
-  ECIESErrorTypeEnum,
-  IECIESConfig,
-  IECIESConstants,
-  SecureBuffer,
-  SecureString,
-} from '@digitaldefiance/ecies-lib';
-import { hdkey, Wallet } from '@ethereumjs/wallet';
-import { generateMnemonic, mnemonicToSeedSync, validateMnemonic } from 'bip39';
-import { secp256k1 } from 'ethereum-cryptography/secp256k1.js';
-import { createEciesTranslationEngine, getEciesPluginI18nEngine, NodeEciesComponentId, NodeEciesStringKey } from '../../i18n/ecies-i18n-factory';
-import { ISimpleKeyPairBuffer } from '../../interfaces/simple-keypair-buffer';
-import { IWalletSeed } from '../../interfaces/wallet-seed';
-import { Constants } from '../../constants';
-
-/**
- * Core encryption and decryption functions for ECIES
- * Includes coverage for simple and single modes, does not cover multiple mode which is in a separate module
- */
-export class EciesCryptoCore {
-  protected readonly _config: IECIESConfig;
-  protected readonly _consts: IECIESConstants;
-  public get config(): IECIESConfig {
-    return this._config;
-  }
-
-  public get consts(): IECIESConstants {
-    return this._consts;
-  }
-
-  constructor(config: IECIESConfig, eciesParams: IECIESConstants = Constants.ECIES) {
-    this._config = config;
-    this._consts = eciesParams;
-  }
-
-  /**
-   * Validates and normalizes a public key for ECIES operations
-   * @param publicKey The public key to normalize
-   * @returns Properly formatted public key
-   */
-  public normalizePublicKey(publicKey: Buffer): Buffer {
-    if (!publicKey) {
-      const engine = createEciesTranslationEngine();
-      const pluginEngine = getEciesPluginI18nEngine();
-      throw new ECIESError(
-        ECIESErrorTypeEnum.InvalidEphemeralPublicKey,
-        engine,
-        undefined,
-        undefined,
-        {
-          error: pluginEngine.translate(NodeEciesComponentId, NodeEciesStringKey.Error_InvalidPublicKey),
-        },
-      );
-    }
-
-    const keyLength = publicKey.length;
-
-    // Already in correct format (65 bytes with 0x04 prefix)
-    if (
-      keyLength === this._consts.PUBLIC_KEY_LENGTH &&
-      publicKey[0] === this._consts.PUBLIC_KEY_MAGIC
-    ) {
-      return publicKey;
-    }
-
-    // Raw key without prefix (64 bytes) - add the 0x04 prefix
-    if (keyLength === this._consts.RAW_PUBLIC_KEY_LENGTH) {
-      return Buffer.concat([Buffer.from([this._consts.PUBLIC_KEY_MAGIC]), publicKey]);
-    }
-
-    const engine = createEciesTranslationEngine();
-    const pluginEngine = getEciesPluginI18nEngine();
-    // Invalid format
-    throw new ECIESError(
-      ECIESErrorTypeEnum.InvalidEphemeralPublicKey,
-      engine,
-      undefined,
-      undefined,
-      {
-        error: pluginEngine.translate(NodeEciesComponentId, NodeEciesStringKey.Error_InvalidPublicKeyFormat),
-        keyLength: String(keyLength),
-        expectedLength64: String(this._consts.RAW_PUBLIC_KEY_LENGTH),
-        expectedLength65: String(this._consts.PUBLIC_KEY_LENGTH),
-        keyPrefix: keyLength > 0 ? String(publicKey[0]) : 'N/A',
-        expectedPrefix: String(this._consts.PUBLIC_KEY_MAGIC),
-      },
-    );
-  }
-
-  /**
-   * Generate a new mnemonic
-   * @returns {SecureString} The new mnemonic
-   */
-  public generateNewMnemonic(): SecureString {
-    return new SecureString(generateMnemonic(this._config.mnemonicStrength));
-  }
-
-  /**
-   * Generate a new wallet from a seed
-   * @param seed {Buffer} The seed to generate the wallet from
-   * @returns {Wallet} The new wallet
-   */
-  public walletFromSeed(seed: Buffer): Wallet {
-    const hdWallet = hdkey.EthereumHDKey.fromMasterSeed(seed);
-    return hdWallet
-      .derivePath(this._config.primaryKeyDerivationPath)
-      .getWallet();
-  }
-
-  /**
-   * Generate a new wallet and seed from a mnemonic
-   * @param mnemonic {SecureString} The mnemonic to generate the wallet and seed from
-   * @returns {IWalletSeed} The new wallet and seed
-   */
-  public walletAndSeedFromMnemonic(mnemonic: SecureString): IWalletSeed {
-    if (!mnemonic.value || !validateMnemonic(mnemonic.value)) {
-      throw new ECIESError(
-        ECIESErrorTypeEnum.InvalidMnemonic,
-        createEciesTranslationEngine(),
-      );
-    }
-
-    const seed = mnemonicToSeedSync(mnemonic.value);
-    const wallet = this.walletFromSeed(seed);
-
-    return {
-      seed: new SecureBuffer(seed),
-      wallet,
-    };
-  }
-
-  /**
-   * Generate a new wallet and seed from a mnemonic
-   * @param wallet {Wallet} The wallet to generate the key pair from
-   * @returns {ISimpleKeyPairBuffer} The new key pair
-   */
-  public walletToSimpleKeyPairBuffer(wallet: Wallet): ISimpleKeyPairBuffer {
-    const privateKey = Buffer.from(wallet.getPrivateKey());
-    const buf04 = new Uint8Array(1);
-    buf04[0] = this._consts.PUBLIC_KEY_MAGIC;
-    const publicKey = Buffer.concat([buf04, wallet.getPublicKey()]);
-
-    return {
-      privateKey,
-      publicKey,
-    };
-  }
-
-  /**
-   * Create a simple key pair from a seed
-   * @param seed {Buffer} The seed to generate the key pair from
-   * @returns {ISimpleKeyPairBuffer} The new key pair
-   */
-  public seedToSimpleKeyPairBuffer(seed: Buffer): ISimpleKeyPairBuffer {
-    const wallet = this.walletFromSeed(seed);
-    return this.walletToSimpleKeyPairBuffer(wallet);
-  }
-
-  /**
-   * Create a simple key pair from a mnemonic
-   * @param mnemonic {SecureString} The mnemonic to generate the key pair from
-   * @returns {ISimpleKeyPairBuffer} The new key pair
-   */
-  public mnemonicToSimpleKeyPairBuffer(
-    mnemonic: SecureString,
-  ): ISimpleKeyPairBuffer {
-    const { seed } = this.walletAndSeedFromMnemonic(mnemonic);
-    return this.seedToSimpleKeyPairBuffer(Buffer.from(seed.value));
-  }
-
-  /**
-   * Generate a random private key
-   * @returns {Buffer} The new private key
-   */
-  public generatePrivateKey(): Buffer {
-    return Buffer.from(secp256k1.utils.randomPrivateKey());
-  }
-
-  /**
-   * Get public key from private key
-   * @param privateKey {Buffer} The private key
-   * @returns {Buffer} The public key
-   */
-  public getPublicKey(privateKey: Buffer): Buffer {
-    const publicKey = secp256k1.getPublicKey(privateKey, false);
-    return Buffer.from(publicKey);
-  }
-
-  /**
-   * Generate ephemeral key pair for ECIES
-   * @returns {Promise<ISimpleKeyPairBuffer>} The key pair
-   */
-  public async generateEphemeralKeyPair(): Promise<{
-    privateKey: Buffer;
-    publicKey: Buffer;
-  }> {
-    const privateKey = this.generatePrivateKey();
-    const publicKey = this.getPublicKey(privateKey);
-    return { privateKey, publicKey };
-  }
-
-  /**
-   * Compute ECDH shared secret
-   * @param privateKey {Buffer} The private key
-   * @param publicKey {Buffer} The public key
-   * @returns {Buffer} The shared secret
-   */
-  public computeSharedSecret(privateKey: Buffer, publicKey: Buffer): Buffer {
-    const sharedSecret = secp256k1.getSharedSecret(privateKey, publicKey, true);
-    return Buffer.from(sharedSecret.slice(1)); // Remove the 0x02/0x03 prefix
-  }
-}

package/src/services/ecies/file.ts

@@ -1,174 +0,0 @@
-import * as fs from 'fs';
-import { ECIESService } from './service';
-
-interface ChunkedFileHeader {
-  version: number;
-  chunkSize: number;
-  totalChunks: number;
-  originalSize: number;
-}
-
-export class EciesFileService {
-  protected readonly eciesService: ECIESService;
-  protected readonly userPrivateKey: Buffer;
-  protected readonly config: { chunkSize: number; headerSize: number };
-
-  constructor(
-    eciesService: ECIESService,
-    userPrivateKey: Buffer,
-    config: { chunkSize: number; headerSize: number } = {
-      chunkSize: 1024 * 1024, // 1MB chunks
-      headerSize: 20,
-    }
-  ) {
-    this.eciesService = eciesService;
-    this.userPrivateKey = userPrivateKey;
-    this.config = Object.freeze(config);
-  }
-
-  decryptFile(encryptedData: Buffer): Buffer {
-    const { header, chunks } = this.parseEncryptedFile(encryptedData);
-    const decryptedChunks: Buffer[] = [];
-
-    for (const chunk of chunks) {
-      const decrypted = this.eciesService.decryptSimpleOrSingleWithHeader(
-        false,
-        this.userPrivateKey,
-        chunk,
-      );
-      decryptedChunks.push(decrypted);
-    }
-
-    const result = Buffer.alloc(header.originalSize);
-    let offset = 0;
-    for (const chunk of decryptedChunks) {
-      const copyLength = Math.min(chunk.length, header.originalSize - offset);
-      chunk.copy(result, offset, 0, copyLength);
-      offset += copyLength;
-    }
-    return result;
-  }
-
-  encryptFileFromPath(filePath: string, recipientPublicKey: Buffer): Buffer {
-    const stats = fs.statSync(filePath);
-    const totalChunks = Math.ceil(stats.size / this.config.chunkSize);
-    const header: ChunkedFileHeader = {
-      version: 1,
-      chunkSize: this.config.chunkSize,
-      totalChunks,
-      originalSize: stats.size,
-    };
-
-    const headerBytes = this.serializeHeader(header);
-    const encryptedHeader = this.eciesService.encryptSimpleOrSingle(
-      false,
-      recipientPublicKey,
-      headerBytes,
-    );
-
-    const chunks: Buffer[] = [encryptedHeader];
-    const fd = fs.openSync(filePath, 'r');
-
-    try {
-      for (let i = 0; i < totalChunks; i++) {
-        const offset = i * this.config.chunkSize;
-        const chunkSize = Math.min(
-          this.config.chunkSize,
-          stats.size - offset,
-        );
-        const chunkData = Buffer.alloc(chunkSize);
-        fs.readSync(fd, chunkData, 0, chunkSize, offset);
-
-        const encryptedChunk = this.eciesService.encryptSimpleOrSingle(
-          false,
-          recipientPublicKey,
-          chunkData,
-        );
-        chunks.push(encryptedChunk);
-      }
-    } finally {
-      fs.closeSync(fd);
-    }
-
-    return Buffer.concat(chunks);
-  }
-
-  decryptFileToPath(encryptedData: Buffer, outputPath: string): void {
-    const { header, chunks } = this.parseEncryptedFile(encryptedData);
-    const fd = fs.openSync(outputPath, 'w');
-    let offset = 0;
-
-    try {
-      for (const chunk of chunks) {
-        const decrypted = this.eciesService.decryptSimpleOrSingleWithHeader(
-          false,
-          this.userPrivateKey,
-          chunk,
-        );
-        const writeLength = Math.min(
-          decrypted.length,
-          header.originalSize - offset,
-        );
-        fs.writeSync(fd, decrypted, 0, writeLength, offset);
-        offset += writeLength;
-      }
-    } finally {
-      fs.closeSync(fd);
-    }
-  }
-
-  protected serializeHeader(header: ChunkedFileHeader): Buffer {
-    const buffer = Buffer.alloc(this.config.headerSize);
-    buffer.writeUInt32BE(header.version, 0);
-    buffer.writeUInt32BE(header.chunkSize, 4);
-    buffer.writeUInt32BE(header.totalChunks, 8);
-    buffer.writeUInt32BE(header.originalSize, 12);
-    return buffer;
-  }
-
-  protected deserializeHeader(data: Buffer): ChunkedFileHeader {
-    return {
-      version: data.readUInt32BE(0),
-      chunkSize: data.readUInt32BE(4),
-      totalChunks: data.readUInt32BE(8),
-      originalSize: data.readUInt32BE(12),
-    };
-  }
-
-  protected parseEncryptedFile(encryptedData: Buffer): {
-    header: ChunkedFileHeader;
-    chunks: Buffer[];
-  } {
-    const headerLength = this.eciesService.computeEncryptedLengthFromDataLength(
-      this.config.headerSize,
-      'single',
-    );
-
-    const encryptedHeader = encryptedData.subarray(0, headerLength);
-    const decryptedHeaderBytes =
-      this.eciesService.decryptSimpleOrSingleWithHeader(
-        false,
-        this.userPrivateKey,
-        encryptedHeader,
-      );
-
-    const header = this.deserializeHeader(decryptedHeaderBytes);
-    const chunks: Buffer[] = [];
-    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 };
-  }
-}