@digitaldefiance/node-ecies-lib 4.4.9 → 4.4.12

package/src/services/ecies/utilities.ts

@@ -1,128 +0,0 @@
-import {
-  EciesEncryptionType,
-  ECIESError,
-  ECIESErrorTypeEnum,
-  IConstants as IBaseConstants,
-  IECIESConstants,
-} from '@digitaldefiance/ecies-lib';
-import { getNodeRuntimeConfiguration } from '../../constants';
-
-/**
- * Utility functions for ECIES operations
- */
-export class EciesUtilities {
-  /**
-   * Computes the encrypted length from the data length.
-   * @param dataLength - The length of the data.
-   * @param encryptionMode - The encryption mode (simple, single, multiple).
-   * @param recipientCount - The number of recipients for multiple encryption mode.
-   * @param constants - The constants to use for calculations.
-   * @returns The encrypted length details.
-   */
-  public computeEncryptedLengthFromDataLength(
-    dataLength: number,
-    encryptionMode: EciesEncryptionType,
-    recipientCount?: number,
-    constants: IBaseConstants = getNodeRuntimeConfiguration()
-  ): number {
-    if (dataLength < 0) {
-      throw new ECIESError(ECIESErrorTypeEnum.InvalidDataLength);
-    }
-    const eciesDefaults: IECIESConstants = constants.ECIES;
-
-    switch (encryptionMode) {
-      case 'simple':
-        // type (1) + public key (65) + IV (16) + auth tag (16) = 98
-        return dataLength + eciesDefaults.SIMPLE.FIXED_OVERHEAD_SIZE;
-      case 'single':
-        // type (1) + public key (65) + IV (16) + auth tag (16) + data length (4) + crc16 (2) = 104
-        return dataLength + eciesDefaults.SINGLE.FIXED_OVERHEAD_SIZE;
-      case 'multiple':
-        // Calculate multiple recipient overhead without instantiating service
-        return (
-          dataLength +
-          this.calculateMultipleRecipientOverhead(
-            recipientCount ?? 1,
-            true,
-            eciesDefaults
-          )
-        );
-      default:
-        throw new ECIESError(ECIESErrorTypeEnum.InvalidEncryptionType);
-    }
-  }
-
-  /**
-   * Calculates the overhead for multiple recipient encryption.
-   * This is a pure calculation that doesn't require service instantiation.
-   * Matches the logic in EciesMultiRecipient.calculateECIESMultipleRecipientOverhead.
-   * @param recipientCount - The number of recipients.
-   * @param includeMessageOverhead - Whether to include message overhead.
-   * @param eciesConstants - The ECIES constants to use.
-   * @returns The overhead in bytes.
-   */
-  private calculateMultipleRecipientOverhead(
-    recipientCount: number,
-    includeMessageOverhead: boolean,
-    eciesConstants: IECIESConstants
-  ): number {
-    if (recipientCount < 1) {
-      throw new ECIESError(ECIESErrorTypeEnum.InvalidRecipientCount);
-    }
-
-    // Calculate encrypted keys size (default assumption: all keys use Simple encryption type)
-    const encryptedKeysSize =
-      recipientCount * eciesConstants.MULTIPLE.ENCRYPTED_KEY_SIZE;
-
-    // Base overhead calculation
-    const baseOverhead =
-      eciesConstants.VERSION_SIZE +
-      eciesConstants.CIPHER_SUITE_SIZE +
-      eciesConstants.ENCRYPTION_TYPE_SIZE +
-      eciesConstants.MULTIPLE.DATA_LENGTH_SIZE +
-      eciesConstants.MULTIPLE.RECIPIENT_COUNT_SIZE +
-      recipientCount * eciesConstants.MULTIPLE.RECIPIENT_ID_SIZE + // recipient ids (dynamic based on ID provider)
-      encryptedKeysSize; // actual encrypted keys size
-
-    return includeMessageOverhead
-      ? baseOverhead + eciesConstants.MULTIPLE.FIXED_OVERHEAD_SIZE
-      : baseOverhead;
-  }
-
-  /**
-   * Computes the decrypted length from the encrypted data length.
-   * @param encryptedDataLength - The length of the encrypted data.
-   * @param padding - Optional padding value.
-   * @returns The decrypted length.
-   */
-  public computeDecryptedLengthFromEncryptedDataLength(
-    encryptedDataLength: number,
-    padding?: number,
-    constants: IBaseConstants = getNodeRuntimeConfiguration()
-  ): number {
-    if (encryptedDataLength < 0) {
-      throw new ECIESError(ECIESErrorTypeEnum.InvalidEncryptedDataLength);
-    }
-
-    const { ECIES: eciesDefaults } = constants;
-    const overhead = eciesDefaults.SINGLE.FIXED_OVERHEAD_SIZE;
-    const actualPadding = padding !== undefined ? padding : 0;
-
-    const decryptedLength = encryptedDataLength - overhead - actualPadding;
-    if (decryptedLength < 0) {
-      throw new ECIESError(
-        ECIESErrorTypeEnum.InvalidEncryptedDataLength,
-        undefined,
-        undefined,
-        {
-          encryptedDataLength: String(encryptedDataLength),
-          overhead: String(overhead),
-          padding: String(actualPadding),
-          computedLength: String(decryptedLength),
-        }
-      );
-    }
-
-    return decryptedLength;
-  }
-}

package/src/services/encryption-stream.ts

@@ -1,432 +0,0 @@
-import {
-  NodeEciesComponentId,
-  NodeEciesStringKey,
-} from '../i18n/ecies-i18n-factory';
-import { getNodeEciesI18nEngine } from '../i18n/node-ecies-i18n-setup';
-import { IEncryptedChunk } from '../interfaces/encrypted-chunk';
-import { IMultiRecipientChunk } from '../interfaces/multi-recipient-chunk';
-import {
-  DEFAULT_STREAM_CONFIG,
-  IStreamConfig,
-} from '../interfaces/stream-config';
-import { IStreamProgress } from '../interfaces/stream-progress';
-import { ChunkProcessor } from './chunk-processor';
-import { ECIESService } from './ecies/service';
-import { MultiRecipientProcessor } from './multi-recipient-processor';
-import { ProgressTracker } from './progress-tracker';
-
-export interface IEncryptStreamOptions {
-  chunkSize?: number;
-  signal?: AbortSignal;
-  includeChecksums?: boolean;
-  onProgress?: (progress: IStreamProgress) => void;
-}
-
-export interface IDecryptStreamOptions {
-  signal?: AbortSignal;
-  onProgress?: (progress: IStreamProgress) => void;
-}
-
-export class EncryptionStream {
-  private readonly processor: ChunkProcessor;
-  private readonly multiRecipientProcessor: MultiRecipientProcessor;
-  private readonly engine = getNodeEciesI18nEngine();
-
-  constructor(
-    private readonly ecies: ECIESService,
-    private readonly config: IStreamConfig = DEFAULT_STREAM_CONFIG,
-    processor?: ChunkProcessor,
-    multiRecipientProcessor?: MultiRecipientProcessor
-  ) {
-    // Use injected dependencies or create defaults
-    this.processor = processor ?? new ChunkProcessor(ecies);
-    this.multiRecipientProcessor =
-      multiRecipientProcessor ??
-      new MultiRecipientProcessor(ecies.core, ecies.core.consts);
-  }
-
-  public async *encryptStream(
-    source: AsyncIterable<Buffer>,
-    publicKey: Buffer,
-    options: IEncryptStreamOptions = {}
-  ): AsyncGenerator<IEncryptedChunk, void, unknown> {
-    if (!publicKey || (publicKey.length !== 65 && publicKey.length !== 33)) {
-      throw new Error(
-        this.engine.translate(
-          NodeEciesComponentId,
-          NodeEciesStringKey.Error_Stream_InvalidPublicKeyLength
-        )
-      );
-    }
-
-    const chunkSize = options.chunkSize ?? this.config.chunkSize;
-    const includeChecksums =
-      options.includeChecksums ?? this.config.includeChecksums;
-    const signal = options.signal;
-    const onProgress = options.onProgress;
-
-    let buffer = Buffer.alloc(0);
-    let chunkIndex = 0;
-    let lastYieldedChunk: IEncryptedChunk | null = null;
-    let tracker: ProgressTracker | undefined;
-    const maxSingleChunk = 100 * 1024 * 1024;
-
-    for await (const data of source) {
-      if (signal?.aborted) {
-        throw new Error(
-          this.engine.translate(
-            NodeEciesComponentId,
-            NodeEciesStringKey.Error_Stream_EncryptionCancelled
-          )
-        );
-      }
-
-      if (data.length > maxSingleChunk) {
-        throw new Error(
-          this.engine.translate(
-            NodeEciesComponentId,
-            NodeEciesStringKey.Error_Stream_BufferOverflow
-          )
-        );
-      }
-
-      buffer = Buffer.concat([buffer, data]);
-
-      if (!tracker && onProgress) {
-        tracker = new ProgressTracker();
-      }
-
-      while (buffer.length >= chunkSize) {
-        if (signal?.aborted) {
-          throw new Error(
-            this.engine.translate(
-              NodeEciesComponentId,
-              NodeEciesStringKey.Error_Stream_EncryptionCancelled
-            )
-          );
-        }
-
-        const chunkData = buffer.subarray(0, chunkSize);
-        buffer = buffer.subarray(chunkSize);
-
-        const encryptedChunk = await this.processor.encryptChunk(
-          chunkData,
-          publicKey,
-          chunkIndex++,
-          false,
-          includeChecksums
-        );
-
-        lastYieldedChunk = encryptedChunk;
-        yield encryptedChunk;
-
-        if (tracker && onProgress) {
-          onProgress(tracker.update(chunkSize));
-        }
-      }
-    }
-
-    if (buffer.length > 0) {
-      if (signal?.aborted) {
-        throw new Error(
-          this.engine.translate(
-            NodeEciesComponentId,
-            NodeEciesStringKey.Error_Stream_EncryptionCancelled
-          )
-        );
-      }
-
-      const encryptedChunk = await this.processor.encryptChunk(
-        buffer,
-        publicKey,
-        chunkIndex,
-        true,
-        includeChecksums
-      );
-
-      yield encryptedChunk;
-
-      if (tracker && onProgress) {
-        onProgress(tracker.update(buffer.length));
-      }
-    } else if (chunkIndex === 0) {
-      return;
-    } else if (lastYieldedChunk) {
-      lastYieldedChunk.isLast = true;
-    }
-  }
-
-  public async *encryptStreamMultiple(
-    source: AsyncIterable<Buffer>,
-    recipients: Array<{ id: Buffer; publicKey: Buffer }>,
-    options: IEncryptStreamOptions = {}
-  ): AsyncGenerator<IMultiRecipientChunk, void, unknown> {
-    if (recipients.length === 0) {
-      throw new Error(
-        this.engine.translate(
-          NodeEciesComponentId,
-          NodeEciesStringKey.Error_Stream_AtLeastOneRecipientRequired
-        )
-      );
-    }
-    if (recipients.length > 65535) {
-      throw new Error(
-        this.engine.translate(
-          NodeEciesComponentId,
-          NodeEciesStringKey.Error_Stream_MaxRecipientsExceeded
-        )
-      );
-    }
-
-    for (const recipient of recipients) {
-      if (
-        !recipient.publicKey ||
-        (recipient.publicKey.length !== 65 && recipient.publicKey.length !== 33)
-      ) {
-        throw new Error(
-          this.engine.translate(
-            NodeEciesComponentId,
-            NodeEciesStringKey.Error_Stream_InvalidRecipientPublicKeyLength
-          )
-        );
-      }
-      if (
-        !recipient.id ||
-        recipient.id.length !==
-          this.ecies.core.consts.MULTIPLE.RECIPIENT_ID_SIZE
-      ) {
-        throw new Error(
-          this.engine.translate(
-            NodeEciesComponentId,
-            NodeEciesStringKey.Error_Stream_InvalidRecipientIdLength
-          )
-        );
-      }
-    }
-
-    const chunkSize = options.chunkSize ?? this.config.chunkSize;
-    const signal = options.signal;
-    const onProgress = options.onProgress;
-
-    const symmetricKey = Buffer.from(require('crypto').randomBytes(32));
-
-    let buffer = Buffer.alloc(0);
-    let chunkIndex = 0;
-    let tracker: ProgressTracker | undefined;
-    const maxSingleChunk = 100 * 1024 * 1024;
-
-    for await (const data of source) {
-      if (signal?.aborted) {
-        throw new Error(
-          this.engine.translate(
-            NodeEciesComponentId,
-            NodeEciesStringKey.Error_Stream_EncryptionCancelled
-          )
-        );
-      }
-
-      if (data.length > maxSingleChunk) {
-        throw new Error(
-          this.engine.translate(
-            NodeEciesComponentId,
-            NodeEciesStringKey.Error_Stream_BufferOverflow
-          )
-        );
-      }
-
-      buffer = Buffer.concat([buffer, data]);
-
-      if (!tracker && onProgress) {
-        tracker = new ProgressTracker();
-      }
-
-      while (buffer.length >= chunkSize) {
-        if (signal?.aborted) {
-          throw new Error(
-            this.engine.translate(
-              NodeEciesComponentId,
-              NodeEciesStringKey.Error_Stream_EncryptionCancelled
-            )
-          );
-        }
-
-        const chunkData = buffer.subarray(0, chunkSize);
-        buffer = buffer.subarray(chunkSize);
-
-        const encryptedChunk = await this.multiRecipientProcessor.encryptChunk(
-          chunkData,
-          recipients,
-          chunkIndex++,
-          false,
-          symmetricKey
-        );
-
-        yield encryptedChunk;
-
-        if (tracker && onProgress) {
-          onProgress(tracker.update(chunkSize));
-        }
-      }
-    }
-
-    if (buffer.length > 0) {
-      if (signal?.aborted) {
-        throw new Error(
-          this.engine.translate(
-            NodeEciesComponentId,
-            NodeEciesStringKey.Error_Stream_EncryptionCancelled
-          )
-        );
-      }
-
-      const encryptedChunk = await this.multiRecipientProcessor.encryptChunk(
-        buffer,
-        recipients,
-        chunkIndex,
-        true,
-        symmetricKey
-      );
-
-      yield encryptedChunk;
-
-      if (tracker && onProgress) {
-        onProgress(tracker.update(buffer.length));
-      }
-    }
-  }
-
-  public async *decryptStream(
-    source: AsyncIterable<Buffer>,
-    privateKey: Buffer,
-    options: IDecryptStreamOptions = {}
-  ): AsyncGenerator<Buffer, void, unknown> {
-    if (!privateKey || privateKey.length !== 32) {
-      throw new Error(
-        this.engine.translate(
-          NodeEciesComponentId,
-          NodeEciesStringKey.Error_Stream_InvalidPrivateKeyLength
-        )
-      );
-    }
-
-    const signal = options.signal;
-    const onProgress = options.onProgress;
-    let expectedIndex = 0;
-    let tracker: ProgressTracker | undefined;
-
-    if (onProgress) {
-      tracker = new ProgressTracker();
-    }
-
-    for await (const chunkData of source) {
-      if (signal?.aborted) {
-        throw new Error(
-          this.engine.translate(
-            NodeEciesComponentId,
-            NodeEciesStringKey.Error_Stream_DecryptionCancelled
-          )
-        );
-      }
-
-      const { data, header } = await this.processor.decryptChunk(
-        chunkData,
-        privateKey
-      );
-
-      if (header.index !== expectedIndex) {
-        throw new Error(
-          this.engine.translate(
-            NodeEciesComponentId,
-            NodeEciesStringKey.Error_Stream_ChunkSequenceError
-          )
-        );
-      }
-
-      expectedIndex++;
-      yield data;
-
-      if (tracker && onProgress) {
-        onProgress(tracker.update(data.length));
-      }
-
-      const isLast = (header.flags & 0x01) !== 0;
-      if (isLast) {
-        break;
-      }
-    }
-  }
-
-  public async *decryptStreamMultiple(
-    source: AsyncIterable<Buffer>,
-    recipientId: Buffer,
-    privateKey: Buffer,
-    options: IDecryptStreamOptions = {}
-  ): AsyncGenerator<Buffer, void, unknown> {
-    if (
-      !recipientId ||
-      recipientId.length !== this.ecies.core.consts.MULTIPLE.RECIPIENT_ID_SIZE
-    ) {
-      throw new Error(
-        this.engine.translate(
-          NodeEciesComponentId,
-          NodeEciesStringKey.Error_Stream_InvalidRecipientIdLength
-        )
-      );
-    }
-    if (!privateKey || privateKey.length !== 32) {
-      throw new Error(
-        this.engine.translate(
-          NodeEciesComponentId,
-          NodeEciesStringKey.Error_Stream_InvalidPrivateKeyLength
-        )
-      );
-    }
-
-    const signal = options.signal;
-    const onProgress = options.onProgress;
-    let expectedIndex = 0;
-    let tracker: ProgressTracker | undefined;
-
-    if (onProgress) {
-      tracker = new ProgressTracker();
-    }
-
-    for await (const chunkData of source) {
-      if (signal?.aborted) {
-        throw new Error(
-          this.engine.translate(
-            NodeEciesComponentId,
-            NodeEciesStringKey.Error_Stream_DecryptionCancelled
-          )
-        );
-      }
-
-      const { data, header } = await this.multiRecipientProcessor.decryptChunk(
-        chunkData,
-        recipientId,
-        privateKey
-      );
-
-      if (header.chunkIndex !== expectedIndex) {
-        throw new Error(
-          this.engine.translate(
-            NodeEciesComponentId,
-            NodeEciesStringKey.Error_Stream_ChunkSequenceError
-          )
-        );
-      }
-
-      expectedIndex++;
-      yield data;
-
-      if (tracker && onProgress) {
-        onProgress(tracker.update(data.length));
-      }
-
-      const isLast = (header.flags & 0x01) !== 0;
-      if (isLast) {
-        break;
-      }
-    }
-  }
-}