@digitaldefiance/ecies-lib 4.4.13 → 4.4.14

package/src/secure-buffer.ts

@@ -1,226 +0,0 @@
-/// <reference path="../../../types/global.d.ts" />
-import { SecureStorageErrorType } from './enumerations/secure-storage-error-type';
-import { DisposedError } from './errors/disposed';
-import { SecureStorageError } from './errors/secure-storage';
-import type { IIdProvider } from './interfaces/id-provider';
-import { ObjectIdProvider } from './lib/id-providers/objectid-provider';
-import { XorService } from './services/xor';
-import { uint8ArrayToHex } from './utils';
-
-/**
- * Default ID provider (singleton, no circular dependency)
- */
-const DEFAULT_ID_PROVIDER = new ObjectIdProvider();
-
-/**
- * A secure string buffer is a buffer whose intent is to prevent the raw password from being stored in memory.
- * The buffer is encrypted with a key derived from a random ID.
- * The ID is stored in the clear, but the buffer is encrypted with a key derived from the ID.
- * This allows the buffer to be decrypted, but only if the ID and salt are known.
- *
- * Supports explicit resource management (TC39 proposal) for automatic disposal:
- * ```typescript
- * using buffer = new SecureBuffer(sensitiveData);
- * // buffer automatically disposed when leaving scope
- * ```
- */
-export class SecureBuffer implements Disposable {
-  private _disposed: boolean = false;
-  private readonly _id: Uint8Array;
-  private readonly _idProvider: IIdProvider;
-  private readonly _length: number;
-  private readonly _obfuscatedValue: Uint8Array;
-  private readonly _key: Uint8Array;
-  private readonly _obfuscatedChecksum: Uint8Array;
-  private _disposedAt?: string;
-
-  constructor(
-    data?: Uint8Array,
-    idProvider: IIdProvider = DEFAULT_ID_PROVIDER,
-  ) {
-    this._idProvider = idProvider;
-    this._id = this._idProvider.generate();
-    // don't bother encrypting an empty buffer
-    if (data === undefined || data.length === 0) {
-      this._length = 0;
-      this._obfuscatedValue = new Uint8Array(0);
-      this._key = new Uint8Array(0);
-      this._obfuscatedChecksum = new Uint8Array(0);
-      return;
-    }
-    this._length = data.length;
-    this._key = this._id;
-    this._obfuscatedValue = this.obfuscateData(data);
-    // Create a simple checksum without crypto for synchronous operation
-    this._obfuscatedChecksum = this.createSimpleObfuscatedChecksum(data);
-  }
-  public dispose(): void {
-    const err = new DisposedError();
-    if (typeof Error.captureStackTrace === 'function') {
-      Error.captureStackTrace(err, this.dispose);
-    }
-    this._disposedAt = err.stack ?? 'stack unavailable';
-    this._obfuscatedValue.fill(0);
-    this._key.fill(0);
-    this._obfuscatedChecksum.fill(0);
-    this._disposed = true;
-  }
-
-  /**
-   * Symbol.dispose implementation for explicit resource management
-   * Allows using 'using' keyword (TC39 proposal)
-   */
-  [Symbol.dispose](): void {
-    this.dispose();
-  }
-
-  /**
-   * Factory method for backward compatibility that uses Constants.idProvider
-   * @param data Optional data to secure
-   * @returns A new SecureBuffer instance using the global ID provider
-   */
-  static create(data?: Uint8Array): SecureBuffer {
-    const { Constants } = require('./constants');
-    return new SecureBuffer(data, Constants.idProvider);
-  }
-
-  /**
-   * Static factory method that creates a SecureBuffer for a symmetric key
-   * Useful for managing encryption keys securely
-   */
-  static allocateKey(sizeBytes: number = 32): SecureBuffer {
-    const keyData = new Uint8Array(sizeBytes);
-    // Will be filled by crypto.getRandomValues by caller
-    return new SecureBuffer(keyData);
-  }
-
-  private assertNotDisposed(): void {
-    if (this._disposed) {
-      const e = new DisposedError();
-      try {
-        e.disposedAt = this._disposedAt;
-      } catch {
-        // ignore if Error object is sealed/frozen
-      }
-      throw e;
-    }
-  }
-  public static fromString(data: string): SecureBuffer {
-    return new SecureBuffer(new TextEncoder().encode(data));
-  }
-  public get disposedAtStack(): string | undefined {
-    return this._disposedAt;
-  }
-  public get id(): string {
-    this.assertNotDisposed();
-    return this._idProvider.serialize(this._id);
-  }
-  public get idUint8Array(): Uint8Array {
-    this.assertNotDisposed();
-    return this._id;
-  }
-  public get originalLength(): number {
-    this.assertNotDisposed();
-    return this._length;
-  }
-  public get value(): Uint8Array {
-    this.assertNotDisposed();
-    if (this._length === 0) {
-      return new Uint8Array(0);
-    }
-    try {
-      const deobfuscatedResult = this.deobfuscateData(this._obfuscatedValue);
-      if (deobfuscatedResult.length !== this._length) {
-        throw new SecureStorageError(
-          SecureStorageErrorType.DecryptedValueLengthMismatch,
-        );
-      }
-      if (!this.validateObfuscatedChecksum(deobfuscatedResult)) {
-        throw new SecureStorageError(
-          SecureStorageErrorType.DecryptedValueChecksumMismatch,
-        );
-      }
-      return deobfuscatedResult;
-    } catch (error) {
-      // If it's already a SecureStorageError, re-throw it
-      if (error instanceof SecureStorageError) {
-        throw error;
-      }
-      // Convert any other error (including AES-GCM authentication errors) to SecureStorageError
-      throw new SecureStorageError(
-        SecureStorageErrorType.DecryptedValueChecksumMismatch,
-      );
-    }
-  }
-  public get valueAsString(): string {
-    this.assertNotDisposed();
-    return new TextDecoder().decode(this.value);
-  }
-  public get valueAsHexString(): string {
-    this.assertNotDisposed();
-    return uint8ArrayToHex(this.value);
-  }
-  public get valueAsBase64String(): string {
-    this.assertNotDisposed();
-    return btoa(String.fromCharCode(...this.value));
-  }
-  public get checksum(): string {
-    this.assertNotDisposed();
-    const deobfuscatedChecksum = new TextDecoder().decode(
-      this.deobfuscateData(this._obfuscatedChecksum),
-    );
-    return deobfuscatedChecksum;
-  }
-  private generateSimpleChecksum(data: string | Uint8Array): string {
-    const dataBytes =
-      typeof data === 'string' ? new TextEncoder().encode(data) : data;
-    let hash = 0;
-    for (let i = 0; i < dataBytes.length; i++) {
-      hash = ((hash << 5) - hash + dataBytes[i]) & 0xffffffff;
-    }
-    return hash.toString(16);
-  }
-  private createSimpleObfuscatedChecksum(
-    data: string | Uint8Array,
-  ): Uint8Array {
-    const checksum = this.generateSimpleChecksum(data);
-    const result = this.obfuscateData(new TextEncoder().encode(checksum));
-    return result;
-  }
-  private validateSimpleChecksum(
-    data: string | Uint8Array,
-    checksum: string,
-  ): boolean {
-    const generatedChecksum = this.generateSimpleChecksum(data);
-    const a = new TextEncoder().encode(generatedChecksum);
-    const b = new TextEncoder().encode(checksum);
-    return this.timingSafeEqual(a, b);
-  }
-
-  private timingSafeEqual(a: Uint8Array, b: Uint8Array): boolean {
-    if (a.length !== b.length) {
-      return false;
-    }
-    let result = 0;
-    for (let i = 0; i < a.length; i++) {
-      result |= a[i] ^ b[i];
-    }
-    return result === 0;
-  }
-  private validateObfuscatedChecksum(data: string | Uint8Array): boolean {
-    const deobfuscatedChecksum = new TextDecoder().decode(
-      this.deobfuscateData(this._obfuscatedChecksum),
-    );
-    return this.validateSimpleChecksum(data, deobfuscatedChecksum);
-  }
-  private obfuscateData(data: Uint8Array): Uint8Array {
-    return XorService.xor(data, this._key);
-  }
-  private deobfuscateData(data: Uint8Array): Uint8Array {
-    return XorService.xor(data, this._key);
-  }
-  public get length(): number {
-    this.assertNotDisposed();
-    return this._length;
-  }
-}

package/src/secure-string.ts

@@ -1,244 +0,0 @@
-/// <reference path="../../../types/global.d.ts" />
-import { SecureStorageErrorType } from './enumerations/secure-storage-error-type';
-import { DisposedError } from './errors/disposed';
-import { SecureStorageError } from './errors/secure-storage';
-import type { IIdProvider } from './interfaces/id-provider';
-import { ObjectIdProvider } from './lib/id-providers/objectid-provider';
-import { XorService } from './services/xor';
-import { uint8ArrayToHex } from './utils';
-
-/**
- * Default ID provider (singleton, no circular dependency)
- */
-const DEFAULT_ID_PROVIDER = new ObjectIdProvider();
-
-/**
- * A secure string buffer is a buffer whose intent is to prevent the raw password from being stored in memory.
- */
-export class SecureString {
-  private _disposed: boolean = false;
-  private readonly _isNull: boolean;
-  private readonly _id: Uint8Array;
-  private readonly _idProvider: IIdProvider;
-  private readonly _length: number;
-  private readonly _obfuscatedValue: Uint8Array;
-  private readonly _key: Uint8Array;
-  private readonly _obfuscatedChecksum: Uint8Array;
-  private _disposedAt?: string;
-  constructor(
-    data?: string | Uint8Array | null,
-    idProvider: IIdProvider = DEFAULT_ID_PROVIDER,
-  ) {
-    this._idProvider = idProvider;
-    this._id = this._idProvider.generate();
-    // only treat null/undefined as null, empty strings/arrays are valid empty data
-    if (data === null || data === undefined) {
-      this._isNull = true;
-      this._length = 0;
-      this._obfuscatedValue = new Uint8Array(0);
-      this._key = new Uint8Array(0);
-      this._obfuscatedChecksum = new Uint8Array(0);
-      return;
-    }
-    this._isNull = false;
-    this._key = this._id;
-    const dataAsUint8Array =
-      typeof data === 'string'
-        ? new TextEncoder().encode(data)
-        : (data as Uint8Array);
-    // Store the byte length, not the character length
-    this._length = dataAsUint8Array.length;
-    this._obfuscatedValue = this.obfuscateData(dataAsUint8Array);
-    this._obfuscatedChecksum =
-      this.createSimpleObfuscatedChecksum(dataAsUint8Array);
-  }
-
-  /**
-   * Factory method for backward compatibility that uses Constants.idProvider
-   * @param data Optional data to secure
-   * @returns A new SecureString instance using the global ID provider
-   */
-  static create(data?: string | Uint8Array | null): SecureString {
-    const { Constants } = require('./constants');
-    return new SecureString(data, Constants.idProvider);
-  }
-
-  private assertNotDisposed(): void {
-    if (this._disposed) {
-      const e = new DisposedError();
-      try {
-        e.disposedAt = this._disposedAt;
-      } catch {
-        // ignore if Error object is sealed/frozen
-      }
-      throw e;
-    }
-  }
-  public dispose(): void {
-    const err = new DisposedError();
-    if (typeof Error.captureStackTrace === 'function') {
-      Error.captureStackTrace(err, this.dispose);
-    }
-    this._disposedAt = err.stack ?? 'stack unavailable';
-    this._obfuscatedValue.fill(0);
-    this._key.fill(0);
-    this._obfuscatedChecksum.fill(0);
-    this._disposed = true;
-  }
-  public get disposedAtStack(): string | undefined {
-    return this._disposedAt;
-  }
-  public get id(): string {
-    this.assertNotDisposed();
-    return this._idProvider.serialize(this._id);
-  }
-  public get idUint8Array(): Uint8Array {
-    this.assertNotDisposed();
-    return this._id;
-  }
-  public get originalLength(): number {
-    this.assertNotDisposed();
-    return this._length;
-  }
-  public get valueAsUint8Array(): Uint8Array {
-    this.assertNotDisposed();
-    if (this._isNull) {
-      return new Uint8Array(0);
-    }
-    try {
-      const deobfuscatedResult = this.deobfuscateData(this._obfuscatedValue);
-      if (deobfuscatedResult.length !== this._length) {
-        throw new SecureStorageError(
-          SecureStorageErrorType.DecryptedValueLengthMismatch,
-        );
-      }
-
-      // Validate checksum
-      const expectedChecksum = this.createSimpleChecksum(deobfuscatedResult);
-      const storedChecksum = new TextDecoder().decode(
-        this.deobfuscateData(this._obfuscatedChecksum),
-      );
-
-      const expectedBytes = new TextEncoder().encode(expectedChecksum);
-      const storedBytes = new TextEncoder().encode(storedChecksum);
-      if (!this.timingSafeEqual(expectedBytes, storedBytes)) {
-        throw new SecureStorageError(
-          SecureStorageErrorType.DecryptedValueChecksumMismatch,
-        );
-      }
-
-      return deobfuscatedResult;
-    } catch (error) {
-      // If it's already a SecureStorageError, re-throw it
-      if (error instanceof SecureStorageError) {
-        throw error;
-      }
-      // Convert any other error to SecureStorageError
-      throw new SecureStorageError(
-        SecureStorageErrorType.DecryptedValueChecksumMismatch,
-      );
-    }
-  }
-  public get value(): string | null {
-    this.assertNotDisposed();
-    if (this._isNull) {
-      return null;
-    }
-    return new TextDecoder().decode(this.valueAsUint8Array);
-  }
-  public get notNullValue(): string {
-    this.assertNotDisposed();
-    if (this._isNull) {
-      throw new SecureStorageError(SecureStorageErrorType.ValueIsNull);
-    }
-    return new TextDecoder().decode(this.valueAsUint8Array);
-  }
-  public get valueAsHexString(): string {
-    this.assertNotDisposed();
-    return uint8ArrayToHex(this.valueAsUint8Array);
-  }
-  public get valueAsBase64String(): string {
-    this.assertNotDisposed();
-    return btoa(String.fromCharCode(...this.valueAsUint8Array));
-  }
-  public get hasValue(): boolean {
-    this.assertNotDisposed();
-    return !this._isNull && this._length > 0;
-  }
-  public get checksum(): string {
-    this.assertNotDisposed();
-    const deobfuscatedChecksum = new TextDecoder().decode(
-      this.deobfuscateData(this._obfuscatedChecksum),
-    );
-    return deobfuscatedChecksum;
-  }
-  public get length(): number {
-    this.assertNotDisposed();
-    return this._length;
-  }
-  private async generateChecksum(data: string | Uint8Array): Promise<string> {
-    const dataBytes =
-      typeof data === 'string' ? new TextEncoder().encode(data) : data;
-    const hashArray = await crypto.subtle.digest(
-      'SHA-256',
-      new Uint8Array(dataBytes),
-    );
-    return uint8ArrayToHex(new Uint8Array(hashArray));
-  }
-  private createSimpleChecksum(data: Uint8Array): string {
-    let hash = 0;
-    for (let i = 0; i < data.length; i++) {
-      hash = ((hash << 5) - hash + data[i]) & 0xffffffff;
-    }
-    return hash.toString(16);
-  }
-
-  private createSimpleObfuscatedChecksum(
-    data: string | Uint8Array,
-  ): Uint8Array {
-    const dataBytes =
-      typeof data === 'string' ? new TextEncoder().encode(data) : data;
-    const checksum = this.createSimpleChecksum(dataBytes);
-    return this.obfuscateData(new TextEncoder().encode(checksum));
-  }
-
-  private async createObfuscatedChecksum(
-    data: string | Uint8Array,
-  ): Promise<Uint8Array> {
-    const checksum = await this.generateChecksum(data);
-    const result = this.obfuscateData(new TextEncoder().encode(checksum));
-    return result;
-  }
-  private async validateChecksum(
-    data: string | Uint8Array,
-    checksum: string,
-  ): Promise<boolean> {
-    const generatedChecksum = await this.generateChecksum(data);
-    return generatedChecksum === checksum;
-  }
-
-  private timingSafeEqual(a: Uint8Array, b: Uint8Array): boolean {
-    if (a.length !== b.length) {
-      return false;
-    }
-    let result = 0;
-    for (let i = 0; i < a.length; i++) {
-      result |= a[i] ^ b[i];
-    }
-    return result === 0;
-  }
-  private async validateObfuscatedChecksum(
-    data: string | Uint8Array,
-  ): Promise<boolean> {
-    const deobfuscatedChecksum = new TextDecoder().decode(
-      this.deobfuscateData(this._obfuscatedChecksum),
-    );
-    return this.validateChecksum(data, deobfuscatedChecksum);
-  }
-  private obfuscateData(data: Uint8Array): Uint8Array {
-    return XorService.xor(data, this._key);
-  }
-  private deobfuscateData(data: Uint8Array): Uint8Array {
-    return XorService.xor(data, this._key);
-  }
-}

package/src/services/aes-gcm.ts

@@ -1,220 +0,0 @@
-import { IECIESConstants } from '../interfaces/ecies-consts';
-import { Constants } from '../constants';
-import { EciesComponentId, getEciesI18nEngine } from '../i18n-setup';
-import { EciesStringKey } from '../enumerations';
-
-export abstract class AESGCMService {
-  public static readonly ALGORITHM_NAME = 'AES-GCM';
-  /**
-   * Encrypt data using AES-GCM
-   * @param data Data to encrypt
-   * @param key Key to use for encryption (must be 16, 24 or 32 bytes for AES)
-   * @returns Encrypted data
-   */
-  public static async encrypt(
-    data: Uint8Array,
-    key: Uint8Array,
-    authTag: boolean = false,
-    eciesParams: IECIESConstants = Constants.ECIES,
-    aad?: Uint8Array,
-  ): Promise<{ encrypted: Uint8Array; iv: Uint8Array; tag?: Uint8Array }> {
-    // Validate key length (AES supports 16, 24, or 32 bytes)
-    if (!key || (key.length !== 16 && key.length !== 24 && key.length !== 32)) {
-      const engine = getEciesI18nEngine();
-      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_ECIESError_InvalidAESKeyLength));
-    }
-
-    // Validate data exists (empty data is allowed for AES-GCM)
-    if (!data) {
-      const engine = getEciesI18nEngine();
-      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_ECIESError_CannotEncryptEmptyData));
-    }
-    if (data.length > eciesParams.MAX_RAW_DATA_SIZE) {
-      const engine = getEciesI18nEngine();
-      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_ECIESError_MessageLengthExceedsMaximumAllowedSizeTemplate, { messageLength: data.length }));
-    }
-
-    const cryptoKey = await crypto.subtle.importKey(
-      'raw',
-      new Uint8Array(key),
-      { name: AESGCMService.ALGORITHM_NAME },
-      false,
-      ['encrypt'],
-    );
-
-    const eciesConsts = eciesParams;
-    const iv = crypto.getRandomValues(new Uint8Array(eciesConsts.IV_SIZE));
-    const encryptedResult = await crypto.subtle.encrypt(
-      {
-        name: AESGCMService.ALGORITHM_NAME,
-        iv,
-        additionalData: aad,
-        ...(authTag && { tagLength: eciesConsts.AUTH_TAG_SIZE * 8 }),
-      },
-      cryptoKey,
-      new Uint8Array(data),
-    );
-
-    const encryptedArray = new Uint8Array(encryptedResult);
-    if (!authTag) {
-      return { encrypted: encryptedArray, iv };
-    }
-    const authTagLengthBytes = eciesConsts.AUTH_TAG_SIZE;
-    const encryptedBytes = encryptedArray.slice(0, -authTagLengthBytes); // Remove auth tag
-    const authTagBytes = encryptedArray.slice(-authTagLengthBytes); // Last 16 bytes are auth tag
-
-    return { encrypted: encryptedBytes, iv, tag: authTagBytes };
-  }
-
-  /**
-   * Combine encrypted data and auth tag into a single Uint8Array
-   * @param encryptedData The encrypted data
-   * @param authTag The authentication tag
-   * @returns The combined Uint8Array
-   */
-  public static combineEncryptedDataAndTag(
-    encryptedData: Uint8Array,
-    authTag: Uint8Array,
-  ): Uint8Array {
-    const combined = new Uint8Array(encryptedData.length + authTag.length);
-    combined.set(encryptedData);
-    combined.set(authTag, encryptedData.length);
-    return combined;
-  }
-
-  /**
-   * Combine IV and encrypted data (with optional auth tag) into a single Uint8Array
-   * @param iv The initialization vector
-   * @param encryptedDataWithTag The encrypted data with auth tag already appended (if applicable)
-   * @returns The combined Uint8Array
-   */
-  public static combineIvAndEncryptedData(
-    iv: Uint8Array,
-    encryptedDataWithTag: Uint8Array,
-  ): Uint8Array {
-    const combined = new Uint8Array(iv.length + encryptedDataWithTag.length);
-    combined.set(iv);
-    combined.set(encryptedDataWithTag, iv.length);
-    return combined;
-  }
-
-  /**
-   * Combine IV, encrypted data and auth tag into a single Uint8Array
-   * @param iv The initialization vector
-   * @param encryptedData The encrypted data
-   * @param authTag The authentication tag
-   * @returns The combined Uint8Array
-   */
-  public static combineIvTagAndEncryptedData(
-    iv: Uint8Array,
-    encryptedData: Uint8Array,
-    authTag: Uint8Array,
-  ): Uint8Array {
-    const encryptedWithTag = AESGCMService.combineEncryptedDataAndTag(
-      encryptedData,
-      authTag,
-    );
-    return AESGCMService.combineIvAndEncryptedData(iv, encryptedWithTag);
-  }
-
-  /**
-   * Split combined encrypted data back into its components
-   * @param combinedData The combined data containing IV, encrypted data, and optionally auth tag
-   * @param hasAuthTag Whether the combined data includes an authentication tag
-   * @returns Object containing the split components
-   */
-  public static splitEncryptedData(
-    combinedData: Uint8Array,
-    hasAuthTag: boolean = true,
-    eciesParams: IECIESConstants = Constants.ECIES,
-  ): { iv: Uint8Array; encryptedDataWithTag: Uint8Array } {
-    const eciesConsts = eciesParams;
-    const ivLength = eciesConsts.IV_SIZE;
-    const tagLength = hasAuthTag ? eciesConsts.AUTH_TAG_SIZE : 0;
-
-    if (combinedData.length < ivLength + tagLength) {
-      const engine = getEciesI18nEngine();
-      throw new Error(
-        engine.translate(EciesComponentId, EciesStringKey.Error_ECIESError_CombinedDataTooShortForComponents),
-      );
-    }
-
-    const iv = combinedData.slice(0, ivLength);
-    const encryptedDataWithTag = combinedData.slice(ivLength);
-
-    return { iv, encryptedDataWithTag };
-  }
-
-  /**
-   * Decrypt data using AES-GCM
-   * @param iv The initialization vector
-   * @param encryptedData Data to decrypt (with auth tag appended if authTag is true)
-   * @param key Key to use for decryption (must be 16, 24 or 32 bytes for AES)
-   * @param authTag Whether the encrypted data includes an authentication tag
-   * @returns Decrypted data
-   */
-  public static async decrypt(
-    iv: Uint8Array,
-    encryptedData: Uint8Array,
-    key: Uint8Array,
-    authTag: boolean = false,
-    eciesParams: IECIESConstants = Constants.ECIES,
-    aad?: Uint8Array,
-  ): Promise<Uint8Array> {
-    const eciesConsts = eciesParams;
-
-    // Validate key length
-    if (!key || (key.length !== 16 && key.length !== 24 && key.length !== 32)) {
-      const engine = getEciesI18nEngine();
-      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_ECIESError_InvalidAESKeyLength));
-    }
-
-    // Validate IV
-    if (!iv || iv.length !== eciesConsts.IV_SIZE) {
-      const engine = getEciesI18nEngine();
-      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_ECIESError_InvalidIV));
-    }
-
-    // Validate encrypted data exists (empty encrypted data is allowed)
-    if (!encryptedData) {
-      const engine = getEciesI18nEngine();
-      throw new Error(engine.translate(EciesComponentId, EciesStringKey.Error_ECIESError_CannotDecryptEmptyData));
-    }
-
-    const cryptoKey = await crypto.subtle.importKey(
-      'raw',
-      new Uint8Array(key),
-      { name: AESGCMService.ALGORITHM_NAME },
-      false,
-      ['decrypt'],
-    );
-
-    if (!authTag) {
-      const decrypted = await crypto.subtle.decrypt(
-        { 
-          name: AESGCMService.ALGORITHM_NAME, 
-          iv: new Uint8Array(iv),
-          additionalData: aad,
-        },
-        cryptoKey,
-        new Uint8Array(encryptedData),
-      );
-
-      return new Uint8Array(decrypted);
-    }
-
-    // Decrypt with auth tag (already appended to encryptedData)
-    const decryptedResult = await crypto.subtle.decrypt(
-      {
-        name: AESGCMService.ALGORITHM_NAME,
-        iv: new Uint8Array(iv),
-        tagLength: eciesConsts.AUTH_TAG_SIZE * 8,
-        additionalData: aad,
-      },
-      cryptoKey,
-      new Uint8Array(encryptedData),
-    );
-
-    return new Uint8Array(decryptedResult);
-  }
-}