@digitaldefiance/ecies-lib 1.1.24 → 1.1.26

package/src/services/pbkdf2.ts

@@ -1,172 +0,0 @@
-import { CoreLanguageCode, PluginI18nEngine } from '@digitaldefiance/i18n-lib';
-import { Constants } from '../constants';
-import { Pbkdf2ErrorType } from '../enumerations/pbkdf2-error-type';
-import { Pbkdf2ProfileEnum } from '../enumerations/pbkdf2-profile';
-import { Pbkdf2Error } from '../errors/pbkdf2';
-import { IPbkdf2Config } from '../interfaces/pbkdf2-config';
-import { IPbkdf2Result } from '../interfaces/pbkdf2-result';
-import { IECIESConstants } from '../interfaces/ecies-consts';
-import { IPBkdf2Consts } from '../interfaces/pbkdf2-consts';
-
-/**
- * Service for handling PBKDF2 (Password-Based Key Derivation Function 2) operations.
- * This service provides functionality for:
- * - Generating secure key derivation configurations
- * - Deriving cryptographic keys from passwords
- * - Managing salt and iteration parameters
- * - Both synchronous and asynchronous key derivation
- */
-export class Pbkdf2Service<TLanguage extends CoreLanguageCode> {
-  protected readonly engine: PluginI18nEngine<TLanguage>;
-  protected readonly profiles: Record<string, IPbkdf2Config>;
-  protected readonly eciesConsts: IECIESConstants;
-  protected readonly pbkdf2Consts: IPBkdf2Consts;
-  
-  constructor(
-    engine: PluginI18nEngine<TLanguage>,
-    profiles: Record<string, IPbkdf2Config> = Constants.PBKDF2_PROFILES,
-    eciesParams: IECIESConstants = Constants.ECIES,
-    pbkdf2Params: IPBkdf2Consts = Constants.PBKDF2,
-  ) {
-    this.engine = engine;
-    this.profiles = profiles;
-    this.eciesConsts = eciesParams;
-    this.pbkdf2Consts = pbkdf2Params;
-  }
-  /**
-   * Get a predefined configuration profile for common use cases
-   * @param profile The name of the profile to use
-   * @returns Configuration object for the specified profile
-   */
-  public getProfileConfig(
-    profile: string,
-  ): IPbkdf2Config {
-    const profileConfig = this.profiles[profile];
-    if (!profileConfig) {
-      throw new Pbkdf2Error(Pbkdf2ErrorType.InvalidProfile, this.engine);
-    }
-    return {
-      hashBytes: profileConfig.hashBytes,
-      saltBytes: profileConfig.saltBytes,
-      iterations: profileConfig.iterations,
-      algorithm: profileConfig.algorithm,
-    };
-  }
-
-  /**
-   * Generate an options object for pbkdf2
-   * @param iterations Optional number of iterations (defaults to Pbkdf2IterationsPerSecond)
-   * @param saltBytes Optional salt size in bytes (defaults to PBKDF2.SALT_BYTES)
-   * @param hashBytes Optional hash size in bytes (defaults to ECIES.SYMMETRIC.KEY_SIZE)
-   * @param algorithm Optional hash algorithm (defaults to PBKDF2.ALGORITHM)
-   * @returns Configuration object for PBKDF2
-   */
-  public getConfig(
-    iterations?: number,
-    saltBytes?: number,
-    hashBytes?: number,
-    algorithm?: string,
-  ): IPbkdf2Config {
-    // larger numbers mean better security, less
-    return {
-      // size of the generated hash
-      hashBytes: hashBytes ?? this.eciesConsts.SYMMETRIC.KEY_SIZE,
-      // larger salt means hashed passwords are more resistant to rainbow table, but
-      // you get diminishing returns pretty fast
-      saltBytes: saltBytes ?? this.pbkdf2Consts.SALT_BYTES,
-      // more iterations means an attacker has to take longer to brute force an
-      // individual password, so larger is better. however, larger also means longer
-      // to hash the password. tune so that hashing the password takes about a
-      // second
-      iterations: iterations ?? this.pbkdf2Consts.ITERATIONS_PER_SECOND,
-      // hash algorithm
-      algorithm: algorithm ?? this.pbkdf2Consts.ALGORITHM,
-    };
-  }
-
-  /**
-   * Given a password, use pbkdf2 to generate an appropriately sized key for AES encryption
-   * @param password The password to derive a key from
-   * @param salt Optional salt (will be randomly generated if not provided)
-   * @param iterations Optional number of iterations
-   * @param saltBytes Optional salt size in bytes
-   * @param keySize Optional key size in bytes
-   * @param algorithm Optional hash algorithm
-   * @returns Object containing the derived key, salt, and iteration count
-   */
-  public async deriveKeyFromPasswordAsync(
-    password: Uint8Array,
-    salt?: Uint8Array,
-    iterations?: number,
-    saltBytes?: number,
-    keySize?: number,
-    algorithm?: string,
-  ): Promise<IPbkdf2Result> {
-    const config = this.getConfig(
-      iterations,
-      saltBytes,
-      keySize,
-      algorithm,
-    );
-    const saltBytes_ =
-      salt ?? crypto.getRandomValues(new Uint8Array(config.saltBytes));
-
-    if (saltBytes_.length !== config.saltBytes) {
-      throw new Pbkdf2Error(Pbkdf2ErrorType.InvalidSaltLength, this.engine);
-    }
-
-    const keyMaterial = await crypto.subtle.importKey(
-      'raw',
-      new Uint8Array(password),
-      'PBKDF2',
-      false,
-      ['deriveBits'],
-    );
-
-    const keyArray = await crypto.subtle.deriveBits(
-      {
-        name: 'PBKDF2',
-        salt: new Uint8Array(saltBytes_),
-        iterations: config.iterations,
-        hash: config.algorithm,
-      },
-      keyMaterial,
-      config.hashBytes * 8,
-    );
-
-    const keyBytes = new Uint8Array(keyArray);
-
-    if (keyBytes.length !== config.hashBytes) {
-      throw new Pbkdf2Error(Pbkdf2ErrorType.InvalidHashLength, this.engine);
-    }
-
-    return {
-      salt: saltBytes_,
-      hash: keyBytes,
-      iterations: config.iterations,
-    };
-  }
-
-  /**
-   * Derive a key using a predefined configuration profile
-   * @param password The password to derive a key from
-   * @param profile The configuration profile to use
-   * @param salt Optional salt (will be randomly generated if not provided)
-   * @returns Object containing the derived key, salt, and iteration count
-   */
-  public async deriveKeyFromPasswordWithProfileAsync(
-    password: Uint8Array,
-    profile: Pbkdf2ProfileEnum,
-    salt?: Uint8Array,
-  ): Promise<IPbkdf2Result> {
-    const config = this.getProfileConfig(profile);
-    return await this.deriveKeyFromPasswordAsync(
-      password,
-      salt,
-      config.iterations,
-      config.saltBytes,
-      config.hashBytes,
-      config.algorithm,
-    );
-  }
-}

package/src/services/xor.ts

@@ -1,65 +0,0 @@
-/**
- * A simple and fast XOR cipher for obfuscating data in memory for browser environments.
- * This is not a substitute for strong cryptography but provides a lightweight way
- * to prevent sensitive data from being stored in plaintext in memory.
- */
-export class XorService {
-  /**
-   * Encrypts or decrypts data using a simple XOR cipher.
-   * The key is XORed with the data. The same function is used for
-   * both encryption and decryption.
-   *
-   * @param data The data to process.
-   * @param key The key to use for the XOR operation.
-   * @returns A new Uint8Array containing the result of the XOR operation.
-   */
-  public static xor(data: Uint8Array, key: Uint8Array): Uint8Array {
-    const result = new Uint8Array(data.length);
-    for (let i = 0; i < data.length; i++) {
-      result[i] = data[i] ^ key[i % key.length];
-    }
-    return result;
-  }
-
-  /**
-   * Generates a random key of a specified length.
-   * @param length The length of the key in bytes.
-   * @returns A Uint8Array containing the random key.
-   * @throws Error if crypto API is not available.
-   */
-  public static generateKey(length: number): Uint8Array {
-    const randomBytes = new Uint8Array(length);
-
-    // Check if running in a browser with crypto support
-    if (typeof window !== 'undefined' && window.crypto) {
-      window.crypto.getRandomValues(randomBytes);
-    } else if (typeof crypto !== 'undefined') {
-      // For environments where crypto is global (some newer JS runtimes)
-      crypto.getRandomValues(randomBytes);
-    } else {
-      throw new Error('Crypto API not available in this environment');
-    }
-
-    return randomBytes;
-  }
-
-  /**
-   * Helper method to convert a string to a Uint8Array.
-   * @param str The string to convert.
-   * @returns A Uint8Array representation of the string.
-   */
-  public static stringToBytes(str: string): Uint8Array {
-    const encoder = new TextEncoder();
-    return encoder.encode(str);
-  }
-
-  /**
-   * Helper method to convert a Uint8Array to a string.
-   * @param bytes The Uint8Array to convert.
-   * @returns A string representation of the Uint8Array.
-   */
-  public static bytesToString(bytes: Uint8Array): string {
-    const decoder = new TextDecoder();
-    return decoder.decode(bytes);
-  }
-}

package/src/types/deep-partial.ts

@@ -1,11 +0,0 @@
-export type DeepPartial<T> = {
-  [P in keyof T]?: T[P] extends (...args: any[]) => any
-    ? T[P]
-    : T[P] extends ReadonlyArray<infer U>
-    ? ReadonlyArray<DeepPartial<U>>
-    : T[P] extends Array<infer U>
-    ? Array<DeepPartial<U>>
-    : T[P] extends object
-    ? DeepPartial<T[P]>
-    : T[P];
-};

package/src/utils.ts

@@ -1,331 +0,0 @@
-import { LengthEncodingType } from './enumerations/length-encoding-type';
-import { LengthErrorType } from './enumerations/length-error-type';
-import { LengthError } from './errors';
-import { getEciesI18nEngine } from './i18n-setup';
-
-/**
- * Encodes the length of the data in the buffer
- * @param buffer The buffer to encode
- * @returns The encoded buffer
- */
-export function lengthEncodeData(buffer: Uint8Array): Uint8Array {
-  const lengthType: LengthEncodingType = getLengthEncodingTypeForLength(
-    buffer.length,
-  );
-  const lengthTypeSize: number = getLengthForLengthType(lengthType);
-  const result = new Uint8Array(1 + lengthTypeSize + buffer.length);
-  const view = new DataView(result.buffer);
-
-  view.setUint8(0, lengthType);
-  switch (lengthType) {
-    case LengthEncodingType.UInt8:
-      view.setUint8(1, buffer.length);
-      break;
-    case LengthEncodingType.UInt16:
-      view.setUint16(1, buffer.length, false); // big-endian
-      break;
-    case LengthEncodingType.UInt32:
-      view.setUint32(1, buffer.length, false); // big-endian
-      break;
-    case LengthEncodingType.UInt64:
-      view.setBigUint64(1, BigInt(buffer.length), false); // big-endian
-      break;
-  }
-  result.set(buffer, 1 + lengthTypeSize);
-  return result;
-}
-
-export function decodeLengthEncodedData(buffer: Uint8Array): {
-  data: Uint8Array;
-  totalLength: number;
-} {
-  if (buffer.length < 1) {
-    throw new LengthError(
-      LengthErrorType.LengthIsTooShort,
-      getEciesI18nEngine() as any,
-    );
-  }
-
-  const view = new DataView(
-    buffer.buffer,
-    buffer.byteOffset,
-    buffer.byteLength,
-  );
-  const lengthType: LengthEncodingType = getLengthEncodingTypeFromValue(
-    view.getUint8(0),
-  );
-  const lengthTypeSize: number = getLengthForLengthType(lengthType);
-
-  if (buffer.length < 1 + lengthTypeSize) {
-    throw new LengthError(
-      LengthErrorType.LengthIsTooShort,
-      getEciesI18nEngine() as any,
-    );
-  }
-
-  let length: number | BigInt;
-  switch (lengthType) {
-    case LengthEncodingType.UInt8:
-      length = view.getUint8(1);
-      break;
-    case LengthEncodingType.UInt16:
-      length = view.getUint16(1, false); // big-endian
-      break;
-    case LengthEncodingType.UInt32:
-      length = view.getUint32(1, false); // big-endian
-      break;
-    case LengthEncodingType.UInt64:
-      length = view.getBigUint64(1, false); // big-endian
-      if (length.valueOf() > BigInt(Number.MAX_SAFE_INTEGER)) {
-        throw new LengthError(
-          LengthErrorType.LengthIsTooLong,
-          getEciesI18nEngine() as any,
-        );
-      }
-      break;
-    default:
-      throw new LengthError(
-        LengthErrorType.LengthIsInvalidType,
-        getEciesI18nEngine() as any,
-      );
-  }
-
-  const totalLength = 1 + lengthTypeSize + Number(length);
-  if (totalLength > buffer.length) {
-    throw new LengthError(
-      LengthErrorType.LengthIsTooShort,
-      getEciesI18nEngine() as any,
-    );
-  }
-  return {
-    data: buffer.subarray(1 + lengthTypeSize, totalLength),
-    totalLength,
-  };
-}
-
-export function uint8ArrayToBase64(uint8Array: Uint8Array): string {
-  let binaryString = '';
-  for (let i = 0; i < uint8Array.length; i++) {
-    binaryString += String.fromCharCode(uint8Array[i]);
-  }
-  return btoa(binaryString);
-}
-
-export function base64ToUint8Array(base64String: string): Uint8Array {
-  const binaryString = atob(base64String);
-  const len = binaryString.length;
-  const bytes = new Uint8Array(len);
-  for (let i = 0; i < len; i++) {
-    bytes[i] = binaryString.charCodeAt(i);
-  }
-  return bytes;
-}
-
-export function uint8ArrayToHex(uint8Array: Uint8Array): string {
-  return Array.from(uint8Array)
-    .map((byte) => byte.toString(16).padStart(2, '0'))
-    .join('');
-}
-
-export function hexToUint8Array(hexString: string): Uint8Array {
-  if (!hexString || typeof hexString !== 'string') {
-    throw new Error('Invalid hex string');
-  }
-  if (hexString.length % 2 !== 0) {
-    throw new Error('Hex string must have even length');
-  }
-  if (!/^[0-9a-fA-F]*$/.test(hexString)) {
-    throw new Error('Hex string contains invalid characters');
-  }
-  const len = hexString.length;
-  const bytes = new Uint8Array(len / 2);
-  for (let i = 0; i < len; i += 2) {
-    bytes[i / 2] = parseInt(hexString.substring(i, i + 2), 16);
-  }
-  return bytes;
-}
-
-/**
- * Utility functions for browser ECIES implementation
- */
-
-/**
- * CRC16-CCITT implementation for data integrity checking
- * Uses CRC16-CCITT-FALSE variant (init 0xFFFF)
- */
-export function crc16(data: Uint8Array): Uint8Array {
-  let crc = 0xffff; // Initial value for CRC16-CCITT-FALSE
-  const polynomial = 0x1021; // CRC16-CCITT polynomial
-
-  for (let i = 0; i < data.length; i++) {
-    crc ^= data[i] << 8;
-    for (let j = 0; j < 8; j++) {
-      if (crc & 0x8000) {
-        crc = (crc << 1) ^ polynomial;
-      } else {
-        crc = crc << 1;
-      }
-      crc &= 0xffff; // Keep it 16-bit
-    }
-  }
-
-  const result = new Uint8Array(2);
-  result[0] = (crc >>> 8) & 0xff; // Big-endian
-  result[1] = crc & 0xff;
-  return result;
-}
-
-/**
- * Convert string to Uint8Array (UTF-8 encoding)
- */
-export function stringToUint8Array(str: string): Uint8Array {
-  return new TextEncoder().encode(str);
-}
-
-/**
- * Convert Uint8Array to string (UTF-8 decoding)
- */
-export function uint8ArrayToString(array: Uint8Array): string {
-  return new TextDecoder().decode(array);
-}
-
-/**
- * Secure random bytes generation
- */
-export function randomBytes(length: number): Uint8Array {
-  return crypto.getRandomValues(new Uint8Array(length));
-}
-
-/**
- * Compare two Uint8Arrays for equality
- */
-export function arraysEqual(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;
-}
-
-/**
- * Concatenate multiple Uint8Arrays
- */
-export function concatUint8Arrays(...arrays: Uint8Array[]): Uint8Array {
-  const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
-  const result = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const array of arrays) {
-    result.set(array, offset);
-    offset += array.length;
-  }
-  return result;
-}
-
-/**
- * Get the length encoding type for a given length
- * @param length The length to evaluate
- * @returns The corresponding LengthEncodingType
- */
-export function getLengthEncodingTypeForLength<
-  TStringKey extends string,
-  TLanguage extends string,
->(length: number | BigInt): LengthEncodingType {
-  if (typeof length === 'number') {
-    if (length < 256) {
-      return LengthEncodingType.UInt8;
-    } else if (length < 65536) {
-      return LengthEncodingType.UInt16;
-    } else if (length < 4294967296) {
-      return LengthEncodingType.UInt32;
-    } else if (length < Number.MAX_SAFE_INTEGER) {
-      return LengthEncodingType.UInt64;
-    } else {
-      throw new LengthError(
-        LengthErrorType.LengthIsTooLong,
-        getEciesI18nEngine() as any,
-      );
-    }
-  } else if (typeof length === 'bigint') {
-    if (length < 256n) {
-      return LengthEncodingType.UInt8;
-    } else if (length < 65536n) {
-      return LengthEncodingType.UInt16;
-    } else if (length < 4294967296n) {
-      return LengthEncodingType.UInt32;
-    } else if (length < 18446744073709551616n) {
-      return LengthEncodingType.UInt64;
-    } else {
-      throw new LengthError(
-        LengthErrorType.LengthIsTooLong,
-        getEciesI18nEngine() as any,
-      );
-    }
-  } else {
-    throw new LengthError(
-      LengthErrorType.LengthIsInvalidType,
-      getEciesI18nEngine() as any,
-    );
-  }
-}
-
-/**
- * Get the length encoding type for a given value
- * @param value The value to evaluate
- * @returns The corresponding LengthEncodingType
- */
-export function getLengthEncodingTypeFromValue<
-  TStringKey extends string,
-  TLanguage extends string,
->(value: number): LengthEncodingType {
-  for (const length of Object.values(LengthEncodingType)) {
-    if (length === value) {
-      return length;
-    }
-  }
-  throw new LengthError(
-    LengthErrorType.LengthIsInvalidType,
-    getEciesI18nEngine() as any,
-  );
-}
-
-/**
- * Safely converts BigInt to Number, throwing if value exceeds safe integer range
- * @param value The BigInt value to convert
- * @returns The number value
- */
-export function safeBigIntToNumber(value: bigint): number {
-  if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
-    throw new Error('Value exceeds safe integer range');
-  }
-  if (value < BigInt(Number.MIN_SAFE_INTEGER)) {
-    throw new Error('Value below safe integer range');
-  }
-  return Number(value);
-}
-
-/**
- * Get the length in bytes for a given LengthEncodingType
- * @param type The LengthEncodingType to evaluate
- * @returns The length in bytes
- */
-export function getLengthForLengthType<
-  TStringKey extends string,
-  TLanguage extends string,
->(type: LengthEncodingType): number {
-  switch (type) {
-    case LengthEncodingType.UInt8:
-      return 1;
-    case LengthEncodingType.UInt16:
-      return 2;
-    case LengthEncodingType.UInt32:
-      return 4;
-    case LengthEncodingType.UInt64:
-      return 8;
-    default:
-      throw new LengthError(
-        LengthErrorType.LengthIsInvalidType,
-        getEciesI18nEngine() as any,
-      );
-  }
-}