@digitaldefiance/node-ecies-lib 4.4.2 → 4.4.5

package/src/services/ecies/utilities.ts

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

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

package/src/services/{index.d.ts → index.ts}

@@ -5,4 +5,3 @@ export * from './chunk-processor';
 export * from './encryption-stream';
 export * from './multi-recipient-processor';
 export * from './progress-tracker';
-//# sourceMappingURL=index.d.ts.map