@digitaldefiance/node-ecies-lib 4.4.9 → 4.4.10

package/src/services/ecies/service.ts

@@ -1,316 +0,0 @@
-import {
-  EciesComponentId,
-  EciesEncryptionType,
-  EciesEncryptionTypeEnum,
-  EciesStringKey,
-  getEciesI18nEngine,
-  HexString,
-  IECIESConfig,
-  IECIESConstants,
-  SecureString,
-} from '@digitaldefiance/ecies-lib';
-import { Wallet } from '@ethereumjs/wallet';
-
-// Import all the modular components
-import { Constants } from '../../constants';
-import type { IMember } from '../../interfaces/member';
-import type { IMultiEncryptedMessage } from '../../interfaces/multi-encrypted-message';
-import type { IMultiEncryptedParsedHeader } from '../../interfaces/multi-encrypted-parsed-header';
-import type { ISingleEncryptedParsedHeader } from '../../interfaces/single-encrypted-parsed-header';
-import type { IWalletSeed } from '../../interfaces/wallet-seed';
-import { SignatureBuffer, SignatureString } from '../../types';
-import { EciesCryptoCore } from './crypto-core';
-import { EciesMultiRecipient } from './multi-recipient';
-import { EciesSignature } from './signature';
-import { EciesSingleRecipientCore } from './single-recipient';
-import { EciesUtilities } from './utilities';
-
-/**
- * Unified ECIES service that integrates all the modular components
- */
-export class ECIESService {
-  protected readonly _config: IECIESConfig;
-  protected readonly cryptoCore: EciesCryptoCore;
-  protected readonly signature: EciesSignature;
-  protected readonly singleRecipient: EciesSingleRecipientCore;
-  protected readonly multiRecipient: EciesMultiRecipient;
-  protected readonly utilities: EciesUtilities;
-
-  constructor(
-    config?: Partial<IECIESConfig>,
-    eciesParams: IECIESConstants = Constants.ECIES
-  ) {
-    const actualConfig = config || {};
-    const eciesConsts = eciesParams || Constants.ECIES;
-
-    this._config = {
-      ...config,
-      curveName: eciesConsts.CURVE_NAME,
-      primaryKeyDerivationPath: eciesConsts.PRIMARY_KEY_DERIVATION_PATH,
-      mnemonicStrength: eciesConsts.MNEMONIC_STRENGTH,
-      symmetricAlgorithm: eciesConsts.SYMMETRIC.ALGORITHM,
-      symmetricKeyBits: eciesConsts.SYMMETRIC.KEY_BITS,
-      symmetricKeyMode: eciesConsts.SYMMETRIC.MODE,
-      ...actualConfig,
-    };
-
-    // Initialize all components
-    this.cryptoCore = new EciesCryptoCore(this._config, eciesParams);
-    this.signature = new EciesSignature(this.cryptoCore);
-    this.singleRecipient = new EciesSingleRecipientCore(this._config);
-    this.multiRecipient = new EciesMultiRecipient(this.cryptoCore);
-    this.utilities = new EciesUtilities();
-  }
-
-  public get core(): EciesCryptoCore {
-    return this.cryptoCore;
-  }
-
-  public get config(): IECIESConfig {
-    return this._config;
-  }
-
-  /**
-   * The name of the elliptic curve used for ECIES encryption/decryption
-   */
-  public get curveName(): string {
-    return this._config.curveName;
-  }
-
-  // === Key Management Methods ===
-
-  public generateNewMnemonic(): SecureString {
-    return this.cryptoCore.generateNewMnemonic();
-  }
-
-  public walletFromSeed(seed: Buffer): Wallet {
-    return this.cryptoCore.walletFromSeed(seed);
-  }
-
-  public walletAndSeedFromMnemonic(mnemonic: SecureString): IWalletSeed {
-    return this.cryptoCore.walletAndSeedFromMnemonic(mnemonic);
-  }
-
-  public walletToSimpleKeyPairBuffer(wallet: Wallet) {
-    return this.cryptoCore.walletToSimpleKeyPairBuffer(wallet);
-  }
-
-  public seedToSimpleKeyPairBuffer(seed: Buffer) {
-    return this.cryptoCore.seedToSimpleKeyPairBuffer(seed);
-  }
-
-  public mnemonicToSimpleKeyPairBuffer(mnemonic: SecureString) {
-    return this.cryptoCore.mnemonicToSimpleKeyPairBuffer(mnemonic);
-  }
-
-  public mnemonicToSimpleKeyPair(mnemonic: SecureString) {
-    return this.mnemonicToSimpleKeyPairBuffer(mnemonic);
-  }
-
-  // === Core Encryption/Decryption Methods ===
-
-  public encryptSimpleOrSingle(
-    encryptSimple: boolean,
-    receiverPublicKey: Buffer,
-    message: Buffer,
-    preamble: Buffer = Buffer.alloc(0)
-  ): Buffer {
-    return this.singleRecipient.encrypt(
-      encryptSimple,
-      receiverPublicKey,
-      message,
-      preamble
-    );
-  }
-
-  public parseSingleEncryptedHeader(
-    encryptionType: EciesEncryptionTypeEnum,
-    data: Buffer,
-    preambleSize: number = 0,
-    options?: {
-      dataLength?: number;
-    }
-  ): ISingleEncryptedParsedHeader {
-    const { header } = this.singleRecipient.parseEncryptedMessage(
-      encryptionType,
-      data,
-      preambleSize,
-      options
-    );
-    return header;
-  }
-
-  public decryptSimpleOrSingleWithHeader(
-    decryptSimple: boolean,
-    privateKey: Buffer,
-    encryptedData: Buffer,
-    preambleSize: number = 0,
-    options?: {
-      dataLength?: number;
-    }
-  ): Buffer {
-    return this.singleRecipient.decryptWithHeader(
-      decryptSimple
-        ? EciesEncryptionTypeEnum.Simple
-        : EciesEncryptionTypeEnum.Single,
-      privateKey,
-      encryptedData,
-      preambleSize,
-      options
-    );
-  }
-
-  public decryptSimpleOrSingleWithHeaderEx(
-    encryptionType: EciesEncryptionTypeEnum,
-    privateKey: Buffer,
-    encryptedData: Buffer,
-    preambleSize: number = 0,
-    options?: {
-      dataLength?: number;
-    }
-  ): { decrypted: Buffer; consumedBytes: number } {
-    return this.singleRecipient.decryptWithHeaderEx(
-      encryptionType,
-      privateKey,
-      encryptedData,
-      preambleSize,
-      options
-    );
-  }
-
-  public decryptSingleWithComponents(
-    privateKey: Buffer,
-    ephemeralPublicKey: Buffer,
-    iv: Buffer,
-    authTag: Buffer,
-    encrypted: Buffer,
-    aad?: Buffer
-  ): { decrypted: Buffer; ciphertextLength?: number } {
-    const decrypted = this.singleRecipient.decryptWithComponents(
-      privateKey,
-      ephemeralPublicKey,
-      iv,
-      authTag,
-      encrypted,
-      aad
-    );
-
-    // Return an object with a 'decrypted' property for compatibility with existing code
-    return { decrypted, ciphertextLength: encrypted.length };
-  }
-
-  // === Signature Methods ===
-
-  public signMessage(privateKey: Buffer, data: Buffer): SignatureBuffer {
-    return this.signature.signMessage(privateKey, data);
-  }
-
-  public verifyMessage(
-    publicKey: Buffer,
-    data: Buffer,
-    signature: SignatureBuffer
-  ): boolean {
-    return this.signature.verifyMessage(publicKey, data, signature);
-  }
-
-  public signatureStringToSignatureBuffer(
-    signatureString: HexString
-  ): SignatureBuffer {
-    return this.signature.signatureStringToSignatureBuffer(signatureString);
-  }
-
-  public signatureBufferToSignatureString(
-    signatureBuffer: SignatureBuffer
-  ): SignatureString {
-    return this.signature.signatureBufferToSignatureString(signatureBuffer);
-  }
-
-  // === Multi-Recipient Methods ===
-  public async encryptMultiple(
-    recipients: Array<IMember>,
-    message: Buffer,
-    preamble?: Buffer
-  ): Promise<IMultiEncryptedMessage> {
-    return this.multiRecipient.encryptMultiple(recipients, message, preamble);
-  }
-
-  public decryptMultipleECIEForRecipient(
-    encryptedData: IMultiEncryptedMessage,
-    recipient: IMember
-  ): Buffer {
-    return this.multiRecipient.decryptMultipleECIEForRecipient(
-      encryptedData,
-      recipient
-    );
-  }
-
-  public calculateECIESMultipleRecipientOverhead(
-    recipientCount: number,
-    includeMessageOverhead: boolean
-  ): number {
-    return this.multiRecipient.calculateECIESMultipleRecipientOverhead(
-      recipientCount,
-      includeMessageOverhead
-    );
-  }
-
-  public buildECIESMultipleRecipientHeader(
-    data: IMultiEncryptedMessage
-  ): Buffer {
-    return this.multiRecipient.buildECIESMultipleRecipientHeader(data);
-  }
-
-  public parseMultiEncryptedHeader(data: Buffer): IMultiEncryptedParsedHeader {
-    return this.multiRecipient.parseMultiEncryptedHeader(data);
-  }
-
-  public parseMultiEncryptedBuffer(data: Buffer): IMultiEncryptedMessage {
-    return this.multiRecipient.parseMultiEncryptedBuffer(data);
-  }
-
-  // === Utility Methods ===
-
-  public computeEncryptedLengthFromDataLength(
-    dataLength: number,
-    encryptionMode: EciesEncryptionType,
-    recipientCount?: number
-  ): number {
-    return this.utilities.computeEncryptedLengthFromDataLength(
-      dataLength,
-      encryptionMode,
-      recipientCount
-    );
-  }
-
-  public computeDecryptedLengthFromEncryptedDataLength(
-    encryptedDataLength: number,
-    padding?: number
-  ): number {
-    return this.utilities.computeDecryptedLengthFromEncryptedDataLength(
-      encryptedDataLength,
-      padding
-    );
-  }
-
-  public encrypt(
-    encryptionType: EciesEncryptionType,
-    recipient: IMember,
-    message: Buffer,
-    preamble?: Buffer
-  ): Buffer {
-    if (encryptionType === 'multiple') {
-      throw new Error(
-        getEciesI18nEngine().translate(
-          EciesComponentId,
-          EciesStringKey.Error_ECIESError_MultipleEncryptionTypeNotSupportedInSingleRecipientMode
-        )
-      );
-    }
-    return this.singleRecipient.encrypt(
-      encryptionType === 'simple',
-      recipient.publicKey,
-      message,
-      preamble
-    );
-  }
-}

package/src/services/ecies/signature.ts

@@ -1,91 +0,0 @@
-import {
-  ECIESError,
-  ECIESErrorTypeEnum,
-  HexString,
-} from '@digitaldefiance/ecies-lib';
-import { secp256k1 } from '@noble/curves/secp256k1.js';
-import { sha256 } from '@noble/hashes/sha2.js';
-import { createEciesTranslationEngine } from '../../i18n/ecies-i18n-factory';
-import { SignatureBuffer, SignatureString } from '../../types';
-import { EciesCryptoCore } from './crypto-core';
-
-/**
- * Signature-related functions for ECIES
- */
-export class EciesSignature {
-  private readonly cryptoCore: EciesCryptoCore;
-
-  constructor(cryptoCore: EciesCryptoCore) {
-    this.cryptoCore = cryptoCore;
-  }
-
-  /**
-   * Signs arbitrary binary data with the given private key.
-   * @param privateKey The private key to sign the message with.
-   * @param data The data to sign.
-   * @returns The signature (64 bytes: r + s).
-   */
-  public signMessage(privateKey: Buffer, data: Buffer): SignatureBuffer {
-    const hash = sha256(data);
-    const signature = secp256k1.sign(hash, privateKey, {
-      format: 'compact',
-      extraEntropy: false,
-    });
-    return Buffer.from(signature) as SignatureBuffer;
-  }
-
-  /**
-   * Verifies arbitrary binary data with the given public key.
-   * @param publicKey The public key to verify the message with.
-   * @param data The data to verify.
-   * @param signature The signature to verify (64 bytes: r + s).
-   * @returns True if the signature is valid, false otherwise.
-   */
-  public verifyMessage(
-    publicKey: Buffer,
-    data: Buffer,
-    signature: SignatureBuffer,
-  ): boolean {
-    if (signature.length !== 64) {
-      throw new ECIESError(
-        ECIESErrorTypeEnum.InvalidSignature,
-        createEciesTranslationEngine(),
-      );
-    }
-
-    // Normalize and validate the public key
-    try {
-      publicKey = this.cryptoCore.normalizePublicKey(publicKey);
-    } catch {
-      throw new ECIESError(
-        ECIESErrorTypeEnum.InvalidSenderPublicKey,
-        createEciesTranslationEngine(),
-      );
-    }
-
-    const hash = sha256(data);
-    return secp256k1.verify(signature, hash, publicKey);
-  }
-
-  /**
-   * Converts a signature string to a signature buffer.
-   * @param signatureString - The signature string to convert.
-   * @returns The signature buffer.
-   */
-  public signatureStringToSignatureBuffer(
-    signatureString: HexString,
-  ): SignatureBuffer {
-    return Buffer.from(signatureString, 'hex') as SignatureBuffer;
-  }
-
-  /**
-   * Converts a signature buffer to a signature string.
-   * @param signatureBuffer - The signature buffer to convert.
-   * @returns The signature string.
-   */
-  public signatureBufferToSignatureString(
-    signatureBuffer: SignatureBuffer,
-  ): SignatureString {
-    return signatureBuffer.toString('hex') as SignatureString;
-  }
-}