@digitaldefiance/node-ecies-lib 1.1.22 → 1.1.24

package/src/services/ecies/service.ts

@@ -1,351 +0,0 @@
-import {
-  EciesEncryptionType,
-  EciesEncryptionTypeEnum,
-  ECIESError,
-  ECIESErrorTypeEnum,
-  HexString,
-  IECIESConfig,
-  IECIESConstants,
-  SecureString,
-} from '@digitaldefiance/ecies-lib';
-import { Wallet } from '@ethereumjs/wallet';
-import {
-  createEciesTranslationEngine,
-  getEciesPluginI18nEngine,
-  NodeEciesComponentId,
-  NodeEciesStringKey,
-} from '../../i18n/ecies-i18n-factory';
-import { Member } from '../../member';
-
-// Import all the modular components
-import { CoreLanguageCode, PluginI18nEngine } from '@digitaldefiance/i18n-lib';
-import { Constants } from '../../constants';
-import { IWalletSeed } from '../../interfaces';
-import { IMultiEncryptedMessage } from '../../interfaces/multi-encrypted-message';
-import { IMultiEncryptedParsedHeader } from '../../interfaces/multi-encrypted-parsed-header';
-import { ISingleEncryptedParsedHeader } from '../../interfaces/single-encrypted-parsed-header';
-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;
-  protected readonly engine: PluginI18nEngine<CoreLanguageCode>;
-
-  constructor(
-    engineOrConfig?: PluginI18nEngine<CoreLanguageCode> | Partial<IECIESConfig>,
-    config?: Partial<IECIESConfig>,
-    eciesParams: IECIESConstants = Constants.ECIES
-  ) {
-    // Determine if first parameter is engine or config
-    let engine: PluginI18nEngine<CoreLanguageCode>;
-    let actualConfig: Partial<IECIESConfig>;
-
-    if (engineOrConfig && 'translate' in engineOrConfig) {
-      // First parameter is an engine
-      engine = engineOrConfig as PluginI18nEngine<CoreLanguageCode>;
-      actualConfig = config || {};
-    } else {
-      // First parameter is config or undefined
-      engine = createEciesTranslationEngine();
-      actualConfig = (engineOrConfig as Partial<IECIESConfig>) || {};
-    }
-
-    const eciesConsts = eciesParams;
-    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.engine = engine;
-    this.cryptoCore = new EciesCryptoCore(this._config, eciesParams);
-    this.signature = new EciesSignature(this.cryptoCore);
-    this.singleRecipient = new EciesSingleRecipientCore(this._config, engine);
-    this.multiRecipient = new EciesMultiRecipient(this.cryptoCore, engine);
-    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);
-  }
-
-  // === 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
-  ): { decrypted: Buffer; ciphertextLength?: number } {
-    const decrypted = this.singleRecipient.decryptWithComponents(
-      privateKey,
-      ephemeralPublicKey,
-      iv,
-      authTag,
-      encrypted
-    );
-
-    // 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 encryptMultiple(
-    recipients: Member[],
-    message: Buffer
-  ): IMultiEncryptedMessage {
-    return this.multiRecipient.encryptMultiple(recipients, message);
-  }
-
-  public decryptMultipleECIEForRecipient(
-    encryptedData: IMultiEncryptedMessage,
-    recipient: Member
-  ): 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,
-    recipients: Member[],
-    message: Buffer,
-    preamble?: Buffer
-  ): Buffer {
-    if (
-      (encryptionType === 'simple' || encryptionType === 'single') &&
-      recipients.length === 1
-    ) {
-      return this.singleRecipient.encrypt(
-        encryptionType === 'simple',
-        recipients[0].publicKey,
-        message,
-        preamble
-      );
-    } else if (encryptionType === 'multiple' && recipients.length > 1) {
-      const result = this.multiRecipient.encryptMultiple(
-        recipients,
-        message,
-        preamble
-      );
-      return result.encryptedMessage;
-    } else {
-      const pluginEngine = getEciesPluginI18nEngine();
-      throw new ECIESError(
-        ECIESErrorTypeEnum.InvalidEncryptionType,
-        this.engine,
-        undefined,
-        undefined,
-        {
-          error: pluginEngine.translate(
-            NodeEciesComponentId,
-            NodeEciesStringKey.Error_InvalidEncryptionTypeOrNumberOfRecipients
-          ),
-          encryptionType: encryptionType,
-          recipients: String(recipients.length),
-        }
-      );
-    }
-  }
-}

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