@digitaldefiance/node-ecies-lib 1.1.21 → 1.1.22

package/src/services/ecies/service.ts

@@ -0,0 +1,351 @@
+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

@@ -0,0 +1,91 @@
+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;
+  }
+}