@crossdyne/security 0.2.0-beta.1 → 0.3.0-beta.1

package/dist/index.js

@@ -1,82 +1,150 @@
+// src/configurations/security-constants.ts
+var SecurityConstants = {
+  AesGcmNonceSize: 12,
+  AesGcmTagSize: 16,
+  AesGcmTagSizeMin: 12,
+  AesGcmTagSizeMax: 16,
+  KeySizeBytes: 32,
+  // 256 bits
+  Pbkdf2IterationsDefault: 6e5,
+  Pbkdf2IterationsMinimum: 1e5
+};
+
+// src/configurations/supported-hash-algorithms.ts
+var SupportedHashAlgorithms = ["SHA-256", "SHA-384", "SHA-512"];
+
 // src/utils/security.utils.ts
 var SecurityUtils = class {
-  /*                          
-      Base64 helpers
-  */
+  /** Encodes Uint8Array to standard Base64. */
   static toBase64(bytes) {
     let binary = "";
-    for (let i = 0; i < bytes.byteLength; i++)
+    for (let i = 0; i < bytes.length; i++)
       binary += String.fromCharCode(bytes[i]);
-    return window.btoa(binary);
+    return btoa(binary);
   }
+  /** Decodes URL-safe or standard Base64 to Uint8Array. */
   static fromBase64(base64) {
-    const cleaned = base64.replace(/-/g, "+").replace(/_/g, "/").replace(/\s/g, "");
-    const binary = window.atob(cleaned);
+    let cleaned = base64.replace(/-/g, "+").replace(/_/g, "/").replace(/\s/g, "");
+    const mod = cleaned.length % 4;
+    if (mod !== 0) {
+      cleaned += "=".repeat(4 - mod);
+    }
+    const binary = atob(cleaned);
     const bytes = new Uint8Array(binary.length);
     for (let i = 0; i < binary.length; i++)
       bytes[i] = binary.charCodeAt(i);
     return bytes;
   }
+  /** Converts big-endian bytes to bigint. */
+  static bytesToBigInt(bytes) {
+    if (bytes.length === 0)
+      return 0n;
+    return BigInt("0x" + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join(""));
+  }
+  /** Converts bigint to fixed-length big-endian bytes (pads/truncates). */
   static bigIntToFixedBytes(bn, length) {
     let hex = bn.toString(16);
     if (hex.length % 2 !== 0)
       hex = "0" + hex;
     if (hex.length > length * 2)
-      throw new Error(`\u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u0441\u043B\u0438\u0448\u043A\u043E\u043C \u0432\u0435\u043B\u0438\u043A\u043E \u0434\u043B\u044F ${length} \u0431\u0430\u0439\u0442`);
-    hex = hex.padStart(length * 2, "0");
-    return this.fromHex(hex);
+      hex = hex.slice(hex.length - length * 2);
+    else
+      hex = hex.padStart(length * 2, "0");
+    return new Uint8Array(hex.match(/.{1,2}/g)?.map((b) => parseInt(b, 16)) || []);
   }
-  static fromHex(hex) {
-    const matches = hex.match(/.{1,2}/g);
-    return new Uint8Array(matches ? matches.map((byte) => parseInt(byte, 16)) : []);
+  /** Constant-time comparison of two Uint8Arrays. */
+  static fixedTimeEquals(a, b) {
+    if (a.length !== b.length)
+      return false;
+    let diff = 0;
+    for (let i = 0; i < a.length; i++)
+      diff |= a[i] ^ b[i];
+    return diff === 0;
   }
-  /*                          
-      Math
-  */
+  /** Modular exponentiation (base^exp mod mod) using binary exponentiation. */
   static expMod(base, exp, mod) {
     let res = BigInt(1);
     base = base % mod;
-    while (exp > 0) {
-      if (exp % BigInt(2) === BigInt(1)) res = res * base % mod;
+    while (exp > 0n) {
+      if (exp % 2n === 1n)
+        res = res * base % mod;
       base = base * base % mod;
-      exp = exp / BigInt(2);
+      exp = exp / 2n;
     }
     return res;
   }
-  /*                          
-      SRP helper
-  */
-  static async hashAsPerSrp6a(items) {
-    const buffers = items.map(({ value, length }) => this.bigIntToFixedBytes(value, length));
-    const totalLen = buffers.reduce((sum, buf) => sum + buf.length, 0);
-    const combined = new Uint8Array(totalLen);
-    let offset = 0;
-    for (const buf of buffers) {
-      combined.set(buf, offset);
-      offset += buf.length;
-    }
-    const hash = await crypto.subtle.digest("SHA-256", combined);
-    return this.bytesToBigInt(new Uint8Array(hash));
+};
+
+// src/crypto/aes-gcm-options.ts
+var AesGcmOptions = class _AesGcmOptions {
+  constructor() {
+    this._nonceSize = SecurityConstants.AesGcmNonceSize;
+    this._tagSize = SecurityConstants.AesGcmTagSize;
+  }
+  /** Nonce size in bytes (must be 12). */
+  get nonceSize() {
+    return this._nonceSize;
+  }
+  set nonceSize(v) {
+    if (v !== SecurityConstants.AesGcmNonceSize) throw new RangeError(`AES-GCM requires ${SecurityConstants.AesGcmNonceSize}-byte nonce`);
+    this._nonceSize = v;
+  }
+  /** Tag size in bytes (12–16, default 16). */
+  get tagSize() {
+    return this._tagSize;
+  }
+  set tagSize(v) {
+    if (v < SecurityConstants.AesGcmTagSizeMin || v > SecurityConstants.AesGcmTagSizeMax) throw new RangeError(`Tag size must be between ${SecurityConstants.AesGcmTagSizeMin} and ${SecurityConstants.AesGcmTagSizeMax}`);
+    this._tagSize = v;
+  }
+  /** Validates that {@link tagSize} is in the allowed range. */
+  validate() {
+    if (this.tagSize < SecurityConstants.AesGcmTagSizeMin || this.tagSize > SecurityConstants.AesGcmTagSizeMax) throw new Error(`Invalid Tag Size: ${this.tagSize}`);
+  }
+  /** Default preset: nonce=12, tag=16, no AAD. */
+  static get default() {
+    return new _AesGcmOptions();
+  }
+  /** Fluent setter for {@link tagSize}. */
+  withTagSize(s) {
+    this.tagSize = s;
+    return this;
+  }
+  /**
+   * Fluent setter for {@link associatedData}.
+   * Accepts a byte array or a UTF-8 string (encoded internally).
+   */
+  withAssociatedData(aad) {
+    this.associatedData = typeof aad === "string" ? new TextEncoder().encode(aad) : aad;
+    return this;
+  }
+  /** Validates and returns this instance. */
+  build() {
+    this.validate();
+    return this;
   }
 };
-SecurityUtils.MODULUS_SIZE = 384;
-SecurityUtils.NONCE_SIZE = 12;
-SecurityUtils.TAG_SIZE = 16;
-SecurityUtils.KEY_SIZE = 32;
-SecurityUtils.N = BigInt("0xAC6BDB41324A9A9BF166DE5E1F403D434A6E1B3B94A7E62AC1211858E002C75AD4455C9D19C0A3180296917A376205164043E20144FF485719D181A99EB574671AC58054457ED444A67032EA17D03AD43464D2397449CA593630A670D90D95A78E846A3C8AF80862098D80F33C42ED7059E75225E0A52718E2379369F65B79680A6560B080092EE71986066735A96A7D42E7597116742B02D3A154471B6A23D84E0D642C790D597A2BB7F5A48F734898BDD138C69493E723491959C1B4BD40C91C1C7924F88D046467A006507E781220A80C55A927906A7C6C9C227E674686DD5D1B855D28F0D604E24586C608630B9A34C4808381A54F0D9080A5F90B60187F");
-SecurityUtils.g = BigInt(2);
-SecurityUtils.k = BigInt("0xD55AE1AEC9F9115621E93E16E5DE4517DF8450D0957024D1256AA32B71E4E412");
-/*                          
-    BigInt helpers
-*/
-SecurityUtils.bytesToBigInt = (bytes) => BigInt("0x" + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join(""));
 
 // src/crypto/crypto.service.ts
 var CryptoService = class {
   constructor() {
+    /**
+    * Generates cryptographically secure random bytes.
+    * @param length - Number of bytes (default 32).
+    * @returns Uint8Array of random bytes.
+    */
     this.generateRandomBytes = (length = 32) => crypto.getRandomValues(new Uint8Array(length));
   }
-  async encryptData(dataModel, key) {
+  /**
+  * Encrypts a serializable object to a Base64 string.
+  * @param dataModel - Object or Uint8Array to encrypt.
+  * @param key - AES-256 key (32 bytes).
+  * @param options - AES-GCM configuration; uses default if omitted.
+  * @returns Base64-encoded ciphertext with prepended nonce.
+  */
+  async encryptData(dataModel, key, options) {
+    const opts = options ?? AesGcmOptions.default;
+    opts.validate();
     const encoder = new TextEncoder();
     let jsonString;
     if (dataModel instanceof Uint8Array) {
@@ -85,7 +153,7 @@ var CryptoService = class {
       jsonString = JSON.stringify(dataModel);
     }
     const plainBytes = encoder.encode(jsonString);
-    const nonce = crypto.getRandomValues(new Uint8Array(SecurityUtils.NONCE_SIZE));
+    const nonce = crypto.getRandomValues(new Uint8Array(opts.nonceSize));
     const cryptoKey = await crypto.subtle.importKey(
       "raw",
       key,
@@ -93,28 +161,43 @@ var CryptoService = class {
       false,
       ["encrypt"]
     );
+    let associatedData = new Uint8Array(0);
+    if (opts.associatedData != null) {
+      associatedData = opts.associatedData;
+    }
     const encryptedContent = await crypto.subtle.encrypt(
       {
         name: "AES-GCM",
         iv: nonce,
-        tagLength: SecurityUtils.TAG_SIZE * 8
+        tagLength: opts.tagSize * 8,
+        additionalData: associatedData
       },
       cryptoKey,
       plainBytes
     );
-    const result = new Uint8Array(SecurityUtils.NONCE_SIZE + encryptedContent.byteLength);
+    const result = new Uint8Array(opts.nonceSize + encryptedContent.byteLength);
     result.set(nonce, 0);
-    result.set(new Uint8Array(encryptedContent), SecurityUtils.NONCE_SIZE);
+    result.set(new Uint8Array(encryptedContent), opts.nonceSize);
     return SecurityUtils.toBase64(result);
   }
-  async decryptedData(encryptedBase64, key) {
+  /**
+  * Decrypts a Base64-encoded ciphertext back to the original object.
+  * @param encryptedBase64 - The encrypted data.
+  * @param key - AES-256 key (32 bytes).
+  * @param options - AES-GCM configuration; uses default if omitted.
+  * @returns Deserialized object, or null if input is empty.
+  * @throws If authentication tag mismatch or corrupted data.
+  */
+  async decryptData(encryptedBase64, key, options) {
     if (!encryptedBase64)
       return null;
+    const opts = options ?? AesGcmOptions.default;
+    opts.validate();
     const encryptedBytes = SecurityUtils.fromBase64(encryptedBase64);
-    if (encryptedBytes.length < SecurityUtils.NONCE_SIZE + SecurityUtils.TAG_SIZE)
-      throw new Error("\u041D\u0435\u0434\u043E\u043F\u0443\u0441\u0442\u0438\u043C\u044B\u0439 \u0444\u043E\u0440\u043C\u0430\u0442 \u0437\u0430\u0448\u0438\u0444\u0440\u043E\u0432\u0430\u043D\u043D\u044B\u0445 \u0434\u0430\u043D\u043D\u044B\u0445");
-    const nonce = encryptedBytes.slice(0, SecurityUtils.NONCE_SIZE);
-    const ciphertextWithTag = encryptedBytes.slice(SecurityUtils.NONCE_SIZE);
+    if (encryptedBytes.length < opts.nonceSize + opts.tagSize)
+      throw new Error(`Invalid format: minimum expected ${opts.nonceSize + opts.tagSize} byte.`);
+    const nonce = encryptedBytes.slice(0, opts.nonceSize);
+    const ciphertextWithTag = encryptedBytes.slice(opts.nonceSize);
     const cryptoKey = await crypto.subtle.importKey(
       "raw",
       key,
@@ -123,11 +206,16 @@ var CryptoService = class {
       ["decrypt"]
     );
     try {
+      let associatedData = new Uint8Array(0);
+      if (opts.associatedData != null) {
+        associatedData = opts.associatedData;
+      }
       const decryptedBuffer = await crypto.subtle.decrypt(
         {
           name: "AES-GCM",
           iv: nonce,
-          tagLength: SecurityUtils.TAG_SIZE * 8
+          tagLength: opts.tagSize * 8,
+          additionalData: associatedData
         },
         cryptoKey,
         ciphertextWithTag
@@ -136,109 +224,502 @@ var CryptoService = class {
       const jsonString = decoder.decode(decryptedBuffer);
       return JSON.parse(jsonString);
     } catch (e) {
-      console.error("\u041E\u0448\u0438\u0431\u043A\u0430 \u0434\u0435\u0448\u0438\u0444\u0440\u043E\u0432\u0430\u043D\u0438\u044F:", e);
-      return null;
+      console.error("Decryption error:", e);
+      throw new Error("Decryption failed: authentication tag mismatch or corrupted data.");
     }
   }
 };
 
-// src/crypto/key-derivation.service.ts
-var KeyDerivationService = class {
+// src/crypto/kdf-options.ts
+var KdfOptions = class _KdfOptions {
   constructor() {
-    this.ITERATIONS = 6e5;
-    this.KEY_SIZE = 32;
+    this._pbkdf2Iterations = SecurityConstants.Pbkdf2IterationsDefault;
+    this._hashAlgorithm = "SHA-256";
+  }
+  /** PBKDF2 iteration count (minimum 100_000). */
+  get pbkdf2Iterations() {
+    return this._pbkdf2Iterations;
+  }
+  set pbkdf2Iterations(v) {
+    if (v < SecurityConstants.Pbkdf2IterationsMinimum)
+      throw new RangeError(`PBKDF2 iterations must be \u2265 ${SecurityConstants.Pbkdf2IterationsMinimum}`);
+    this._pbkdf2Iterations = v;
+  }
+  /** Hash algorithm used by PBKDF2. Must be one of {@link SupportedHashAlgorithms}. */
+  get hashAlgorithm() {
+    return this._hashAlgorithm;
+  }
+  set hashAlgorithm(v) {
+    if (!SupportedHashAlgorithms.includes(v))
+      throw new RangeError(`Unsupported hash: ${v}`);
+    this._hashAlgorithm = v;
+  }
+  /** Validates iterations and hash algorithm. */
+  validate() {
+    if (this.pbkdf2Iterations < SecurityConstants.Pbkdf2IterationsMinimum)
+      throw new Error(`Pbkdf2Iterations (${this.pbkdf2Iterations}) below minimum`);
+    if (!SupportedHashAlgorithms.includes(this.hashAlgorithm))
+      throw new Error(`Invalid hash algorithm: ${this.hashAlgorithm}`);
   }
-  async deriveKeysFromPassword(login, password, salt) {
+  /** Default preset: SHA-256, 600_000 iterations. */
+  static get default() {
+    return new _KdfOptions();
+  }
+  /** Fluent setter for {@link pbkdf2Iterations}. */
+  withPbkdf2Iterations(i) {
+    this.pbkdf2Iterations = i;
+    return this;
+  }
+  /** Fluent setter for {@link hashAlgorithm}. */
+  withHashAlgorithm(h) {
+    this.hashAlgorithm = h;
+    return this;
+  }
+  /** Validates and returns this instance. */
+  build() {
+    this.validate();
+    return this;
+  }
+};
+
+// src/crypto/key-derivation.service.ts
+var KeyDerivationService = class {
+  /**
+  * Derives KEK and Base64 AuthHash. Identity is normalized (trimmed, lowercase).
+  * @param identity - User identity (email, username).
+  * @param password - User password.
+  * @param salt - Random salt.
+  * @param options - KDF configuration; uses default if omitted.
+  * @returns Object with `kek` (Uint8Array) and `authHash` (Base64 string).
+  */
+  async deriveKeysFromPassword(identity, password, salt, options) {
+    const opts = options ?? KdfOptions.default;
+    opts.validate();
     const safeSalt = new Uint8Array(salt);
     const encoder = new TextEncoder();
-    const normalizedLogin = login.trim().toLocaleLowerCase();
+    const normalizedLogin = identity.trim().toLowerCase();
     const combinedPassword = `${normalizedLogin}:${password}`;
     const passwordBytes = encoder.encode(combinedPassword);
     const baseKey = await crypto.subtle.importKey("raw", passwordBytes, "PBKDF2", false, ["deriveBits", "deriveKey"]);
     const masterKeyBits = await crypto.subtle.deriveBits({
       name: "PBKDF2",
       salt: safeSalt,
-      iterations: this.ITERATIONS,
-      hash: "SHA-256"
-    }, baseKey, this.KEY_SIZE * 8);
+      iterations: opts.pbkdf2Iterations,
+      hash: opts.hashAlgorithm
+    }, baseKey, SecurityConstants.KeySizeBytes * 8);
     const masterKey = await crypto.subtle.importKey("raw", masterKeyBits, "HKDF", false, ["deriveBits"]);
     const kek = await crypto.subtle.deriveBits(
-      { name: "HKDF", hash: "SHA-256", salt: new Uint8Array(0), info: encoder.encode("AES-GCM-KEK-v1") },
+      { name: "HKDF", hash: opts.hashAlgorithm, salt: new Uint8Array(0), info: encoder.encode("AES-GCM-KEK-v1") },
       masterKey,
-      this.KEY_SIZE * 8
+      SecurityConstants.KeySizeBytes * 8
     );
     const authBytes = await crypto.subtle.deriveBits(
-      { name: "HKDF", hash: "SHA-256", salt: new Uint8Array(0), info: encoder.encode("SERVER-AUTH-HASH-v1") },
+      { name: "HKDF", hash: opts.hashAlgorithm, salt: new Uint8Array(0), info: encoder.encode("SERVER-AUTH-HASH-v1") },
       masterKey,
-      this.KEY_SIZE * 8
+      SecurityConstants.KeySizeBytes * 8
     );
     return {
       kek: new Uint8Array(kek),
       authHash: SecurityUtils.toBase64(new Uint8Array(authBytes))
     };
   }
+  /**
+  * Derives an SRP-compatible authentication hash (output size = hash output length).
+  * @param identity - User identity.
+  * @param password - User password.
+  * @param salt - Random salt.
+  * @param srpHashAlgorithm - SRP hash algorithm (SHA-256/384/512).
+  * @param options - KDF configuration; uses default if omitted.
+  * @returns Raw hash bytes for use as SRP verifier input (x).
+  */
+  async deriveAuthHashForSrp(identity, password, salt, srpHashAlgorithm, options) {
+    const opts = options ?? KdfOptions.default;
+    opts.validate();
+    const srpHashSize = srpHashAlgorithm === "SHA-256" ? 32 : srpHashAlgorithm === "SHA-384" ? 48 : 64;
+    const normalizedLogin = identity.trim().toLowerCase();
+    const combinedPassword = `${normalizedLogin}:${password}`;
+    const passwordBytes = new TextEncoder().encode(combinedPassword);
+    const baseKey = await crypto.subtle.importKey(
+      "raw",
+      passwordBytes,
+      "PBKDF2",
+      false,
+      ["deriveBits"]
+    );
+    const masterKeyBits = await crypto.subtle.deriveBits({
+      name: "PBKDF2",
+      salt,
+      iterations: opts.pbkdf2Iterations,
+      hash: srpHashAlgorithm
+    }, baseKey, SecurityConstants.KeySizeBytes * 8);
+    const masterKey = await crypto.subtle.importKey(
+      "raw",
+      masterKeyBits,
+      "HKDF",
+      false,
+      ["deriveBits"]
+    );
+    const info = new TextEncoder().encode("SRP-AUTH-HASH-v1");
+    const authBytes = await crypto.subtle.deriveBits(
+      {
+        name: "HKDF",
+        hash: srpHashAlgorithm,
+        salt: new Uint8Array(0),
+        info
+      },
+      masterKey,
+      srpHashSize * 8
+    );
+    return new Uint8Array(authBytes);
+  }
+};
+
+// src/crypto/crypto-version.ts
+var CryptoVersion = /* @__PURE__ */ ((CryptoVersion2) => {
+  CryptoVersion2[CryptoVersion2["V1"] = 1] = "V1";
+  return CryptoVersion2;
+})(CryptoVersion || {});
+
+// src/crypto/crypto-profile.ts
+var CryptoProfile = class {
+  /**
+   * Creates a new CryptoProfile.
+   * @param params - Object containing version, kdfOptions, aesGcmOptions.
+   */
+  constructor(params) {
+    this.version = params.version;
+    this.kdfOptions = params.kdfOptions;
+    this.aesGcmOptions = params.aesGcmOptions;
+  }
+};
+
+// src/crypto/crypto-profile-registry.ts
+var CryptoProfileRegistry = class {
+  static getProfile(version) {
+    switch (version) {
+      case 1 /* V1 */:
+        return new CryptoProfile({
+          version: 1 /* V1 */,
+          kdfOptions: KdfOptions.default,
+          aesGcmOptions: AesGcmOptions.default
+        });
+      default:
+        throw new Error(`Unsupported crypto version: ${version}`);
+    }
+  }
+  /** Latest supported profile (currently V1). */
+  static get latest() {
+    return this.getProfile(1 /* V1 */);
+  }
+};
+
+// src/utils/srp-encoding.ts
+var SrpEncoding = class {
+  /** Serializes a bigint to modulus-sized big-endian bytes. */
+  static toModulusBytes(ctx, value) {
+    return SecurityUtils.bigIntToFixedBytes(value, ctx.modulusSize);
+  }
+  /** Serializes a bigint to hash-sized big-endian bytes. */
+  static toHashBytes(ctx, value) {
+    return SecurityUtils.bigIntToFixedBytes(value, ctx.hashSize);
+  }
+  /** Hashes modulus-sized values (e.g., u = H(A, B)). */
+  static async hashModuli(ctx, ...values) {
+    const buffers = values.map((v) => this.toModulusBytes(ctx, v));
+    return this.hash(ctx.hashAlgorithmName, ...buffers);
+  }
+  /** Computes M1 = H(A || B || sessionKeyK). */
+  static async computeM1(ctx, A, B, sessionKeyK) {
+    return this.hash(ctx.hashAlgorithmName, this.toModulusBytes(ctx, A), this.toModulusBytes(ctx, B), sessionKeyK);
+  }
+  /** Computes M2 = H(A || M1 || sessionKeyK). */
+  static async computeM2(ctx, A, M1, sessionKeyK) {
+    return this.hash(ctx.hashAlgorithmName, this.toModulusBytes(ctx, A), this.toHashBytes(ctx, M1), sessionKeyK);
+  }
+  /** Computes session key K = H(S). */
+  static async computeSessionKey(ctx, S) {
+    const sBytes = this.toModulusBytes(ctx, S);
+    const hashBuffer = await crypto.subtle.digest(
+      ctx.hashAlgorithmName,
+      sBytes
+    );
+    return new Uint8Array(hashBuffer);
+  }
+  /** Concatenates byte arrays and returns the hash as bigint. */
+  static async hash(algo, ...buffers) {
+    const totalLen = buffers.reduce((sum, b) => sum + b.length, 0);
+    const combined = new Uint8Array(totalLen);
+    let offset = 0;
+    for (const buf of buffers) {
+      combined.set(buf, offset);
+      offset += buf.length;
+    }
+    const hashBuffer = await crypto.subtle.digest(algo, combined);
+    return SecurityUtils.bytesToBigInt(new Uint8Array(hashBuffer));
+  }
 };
 
-// src/srp/srp.service.ts
-var SrpService = class {
+// src/srp/srp-client-service.ts
+var SrpClientService = class {
   constructor() {
     this.keyDerivation = new KeyDerivationService();
   }
-  async generateSrpVerifier(authHash) {
+  /**
+  * Computes SRP verifier v = g^x mod N from the authentication hash.
+  * @param authHash - Auth hash (Base64).
+  * @param ctx - SRP context (N, g, hash algorithm, etc.).
+  * @returns Verifier as Base64 string.
+  */
+  async generateSrpVerifier(authHash, ctx) {
     const x = SecurityUtils.bytesToBigInt(SecurityUtils.fromBase64(authHash));
-    const v = SecurityUtils.expMod(SecurityUtils.g, x, SecurityUtils.N);
-    return SecurityUtils.toBase64(SecurityUtils.bigIntToFixedBytes(v, SecurityUtils.MODULUS_SIZE));
+    const v = SecurityUtils.expMod(ctx.g, x, ctx.N);
+    return SecurityUtils.toBase64(SrpEncoding.toModulusBytes(ctx, v));
   }
-  async generateSrpProof(login, password, saltBase64, B_base64) {
+  /**
+   * Generates client proof (A, M1, session key S) from server challenge.
+   * @param login - User login.
+   * @param password - Plaintext password.
+   * @param saltBase64 - Server salt (URL-safe Base64).
+   * @param B_base64 - Server public ephemeral B (URL-safe Base64).
+   * @param ctx - SRP context.
+   * @returns Object with A, M1, S as Base64 strings.
+   */
+  async generateSrpProof(login, password, saltBase64, B_base64, ctx) {
     const salt = SecurityUtils.fromBase64(saltBase64);
-    const { authHash } = await this.keyDerivation.deriveKeysFromPassword(login, password, salt);
-    const x = SecurityUtils.bytesToBigInt(SecurityUtils.fromBase64(authHash));
+    const authHash = await this.keyDerivation.deriveAuthHashForSrp(login, password, salt, ctx.hashAlgorithmName);
+    const x = SecurityUtils.bytesToBigInt(authHash);
     const aBytes = crypto.getRandomValues(new Uint8Array(32));
     const a = SecurityUtils.bytesToBigInt(aBytes);
-    const A = SecurityUtils.expMod(SecurityUtils.g, a, SecurityUtils.N);
-    if (A % SecurityUtils.N === 0n)
-      throw new Error("\u041A\u0440\u0438\u0442\u0438\u0447\u0435\u0441\u043A\u0430\u044F \u043E\u0448\u0438\u0431\u043A\u0430: A % N === 0");
+    const A = SecurityUtils.expMod(ctx.g, a, ctx.N);
+    if (A % ctx.N === 0n)
+      throw new Error("Critical error: A % N === 0");
     const B = SecurityUtils.bytesToBigInt(SecurityUtils.fromBase64(B_base64));
-    if (B % SecurityUtils.N === 0n)
-      throw new Error("\u041A\u0440\u0438\u0442\u0438\u0447\u0435\u0441\u043A\u0430\u044F \u043E\u0448\u0438\u0431\u043A\u0430: B % N === 0");
-    const u = await SecurityUtils.hashAsPerSrp6a([
-      { value: A, length: SecurityUtils.MODULUS_SIZE },
-      { value: B, length: SecurityUtils.MODULUS_SIZE }
-    ]);
+    if (B % ctx.N === 0n)
+      throw new Error("Critical error: B % N === 0");
+    const u = await SrpEncoding.hashModuli(ctx, A, B);
     if (u === 0n)
       throw new Error("\u041D\u0435\u0434\u043E\u043F\u0443\u0441\u0442\u0438\u043C\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435 u");
-    const gX = SecurityUtils.expMod(SecurityUtils.g, x, SecurityUtils.N);
-    const term = SecurityUtils.k * gX % SecurityUtils.N;
-    const base = (B - term + SecurityUtils.N) % SecurityUtils.N;
+    const gX = SecurityUtils.expMod(ctx.g, x, ctx.N);
+    const term = ctx.k * gX % ctx.N;
+    const base = (B - term + ctx.N) % ctx.N;
     const exponent = a + u * x;
-    const S = SecurityUtils.expMod(base, exponent, SecurityUtils.N);
+    const S = SecurityUtils.expMod(base, exponent, ctx.N);
     if (S === 0n)
-      throw new Error("\u041A\u0440\u0438\u0442\u0438\u0447\u0435\u0441\u043A\u0430\u044F \u043E\u0448\u0438\u0431\u043A\u0430: S === 0");
-    const M1 = await SecurityUtils.hashAsPerSrp6a([
-      { value: A, length: SecurityUtils.MODULUS_SIZE },
-      { value: B, length: SecurityUtils.MODULUS_SIZE },
-      { value: S, length: SecurityUtils.MODULUS_SIZE }
-    ]);
+      throw new Error("Critical error: S === 0");
+    const sessionKeyK = await SrpEncoding.computeSessionKey(ctx, S);
+    const M1 = await SrpEncoding.computeM1(ctx, A, B, sessionKeyK);
     return {
-      A: SecurityUtils.toBase64(SecurityUtils.bigIntToFixedBytes(A, SecurityUtils.MODULUS_SIZE)),
-      M1: SecurityUtils.toBase64(SecurityUtils.bigIntToFixedBytes(M1, 32)),
-      S: SecurityUtils.toBase64(SecurityUtils.bigIntToFixedBytes(S, SecurityUtils.MODULUS_SIZE))
+      A: SecurityUtils.toBase64(SrpEncoding.toModulusBytes(ctx, A)),
+      M1: SecurityUtils.toBase64(SrpEncoding.toHashBytes(ctx, M1)),
+      S: SecurityUtils.toBase64(SrpEncoding.toModulusBytes(ctx, S))
     };
   }
-  async verifyServerM2(A_b64, M1_b64, S_b64, serverM2_b64) {
+  /**
+   * Validates the server proof M2 to authenticate the server.
+   * @param A_b64 - Client public A (Base64).
+   * @param M1_b64 - Client proof M1 (Base64).
+   * @param S_b64 - Session key S (Base64).
+   * @param serverM2_b64 - Server proof M2 (Base64).
+   * @param ctx - SRP context.
+   * @returns True if the server proof is valid.
+   */
+  async verifyServerM2(A_b64, M1_b64, S_b64, serverM2_b64, ctx) {
     const A = SecurityUtils.bytesToBigInt(SecurityUtils.fromBase64(A_b64));
     const M1 = SecurityUtils.bytesToBigInt(SecurityUtils.fromBase64(M1_b64));
     const S = SecurityUtils.bytesToBigInt(SecurityUtils.fromBase64(S_b64));
-    const computedM2 = await SecurityUtils.hashAsPerSrp6a([
-      { value: A, length: SecurityUtils.MODULUS_SIZE },
-      { value: M1, length: 32 },
-      { value: S, length: SecurityUtils.MODULUS_SIZE }
-    ]);
-    const computedM2_b64 = SecurityUtils.toBase64(SecurityUtils.bigIntToFixedBytes(computedM2, 32));
-    return serverM2_b64 === computedM2_b64;
+    const sessionKeyK = await SrpEncoding.computeSessionKey(ctx, S);
+    const computedM2 = await SrpEncoding.computeM2(ctx, A, M1, sessionKeyK);
+    const computedM2Bytes = SrpEncoding.toHashBytes(ctx, computedM2);
+    const serverM2Bytes = SecurityUtils.fromBase64(serverM2_b64);
+    return SecurityUtils.fixedTimeEquals(computedM2Bytes, serverM2Bytes);
+  }
+};
+
+// src/srp/srp-server-service.ts
+var SrpServerService = class {
+  /**
+   * Generates server challenge B and session state from verifier.
+   * @param login - User login.
+   * @param verifierBytes - Stored verifier v as byte array.
+   * @param ctx - SRP context (hash, N, g, etc.).
+   * @returns Session state with private b, verifier, and public B.
+   */
+  async getSrpChallenge(login, verifierBytes, ctx) {
+    const v = SecurityUtils.bytesToBigInt(verifierBytes);
+    const bBytes = crypto.getRandomValues(new Uint8Array(32));
+    const b = SecurityUtils.bytesToBigInt(bBytes);
+    const gB = SecurityUtils.expMod(ctx.g, b, ctx.N);
+    const B = (ctx.k * v + gB) % ctx.N;
+    return {
+      login,
+      privateKeyB: SecurityUtils.toBase64(bBytes),
+      verifier: SecurityUtils.toBase64(verifierBytes),
+      publicKeyB: SecurityUtils.toBase64(SrpEncoding.toModulusBytes(ctx, B))
+    };
+  }
+  /**
+   * Verifies client M1 proof and returns server M2 proof.
+   * @param sessionState - Server session state.
+   * @param a - Client public A (Base64).
+   * @param m1 - Client proof M1 (Base64).
+   * @param ctx - SRP context.
+   * @returns Server proof M2 as Base64 string.
+   * @throws If verification fails or input is invalid.
+   */
+  async verifySrpProof(sessionState, a, m1, ctx) {
+    const A = SecurityUtils.bytesToBigInt(SecurityUtils.fromBase64(a));
+    const M1_client = SecurityUtils.bytesToBigInt(SecurityUtils.fromBase64(m1));
+    const b = SecurityUtils.bytesToBigInt(SecurityUtils.fromBase64(sessionState.privateKeyB));
+    const v = SecurityUtils.bytesToBigInt(SecurityUtils.fromBase64(sessionState.verifier));
+    const B = SecurityUtils.bytesToBigInt(SecurityUtils.fromBase64(sessionState.publicKeyB));
+    if (v <= 0n)
+      throw new Error("The verifier is corrupted");
+    if (A % ctx.N === 0n)
+      throw new Error("Incorrect value of A");
+    if (A <= 0n || A >= ctx.N)
+      throw new Error("Invalid A (out of range)");
+    const u = await SrpEncoding.hashModuli(ctx, A, B);
+    if (u === 0n)
+      throw new Error("Error in calculating the parameter u");
+    const vU = SecurityUtils.expMod(v, u, ctx.N);
+    const S = SecurityUtils.expMod(A * vU % ctx.N, b, ctx.N);
+    const sessionKeyK = await SrpEncoding.computeSessionKey(ctx, S);
+    const M1_server = await SrpEncoding.computeM1(ctx, A, B, sessionKeyK);
+    const m1ServerBytes = SrpEncoding.toHashBytes(ctx, M1_server);
+    const m1ClientBytes = SrpEncoding.toHashBytes(ctx, M1_client);
+    if (!SecurityUtils.fixedTimeEquals(m1ServerBytes, m1ClientBytes))
+      throw new Error("Invalid password");
+    const M2_server = await SrpEncoding.computeM2(ctx, A, M1_client, sessionKeyK);
+    return SecurityUtils.toBase64(SrpEncoding.toHashBytes(ctx, M2_server));
+  }
+};
+
+// src/srp/srp-group.ts
+var SrpGroup = /* @__PURE__ */ ((SrpGroup2) => {
+  SrpGroup2[SrpGroup2["Rfc5054_1024"] = 1] = "Rfc5054_1024";
+  SrpGroup2[SrpGroup2["Rfc5054_1536"] = 2] = "Rfc5054_1536";
+  SrpGroup2[SrpGroup2["Rfc5054_2048"] = 3] = "Rfc5054_2048";
+  SrpGroup2[SrpGroup2["Rfc5054_3072"] = 4] = "Rfc5054_3072";
+  SrpGroup2[SrpGroup2["Rfc5054_4096"] = 5] = "Rfc5054_4096";
+  SrpGroup2[SrpGroup2["Rfc5054_6144"] = 6] = "Rfc5054_6144";
+  SrpGroup2[SrpGroup2["Rfc5054_8192"] = 7] = "Rfc5054_8192";
+  SrpGroup2[SrpGroup2["Custom"] = 99] = "Custom";
+  return SrpGroup2;
+})(SrpGroup || {});
+
+// src/srp/srp-group-params.ts
+var SrpGroupParams = class {
+  /**
+   * Returns the prime modulus N for the given SRP group.
+   * @param group - SRP group identifier.
+   * @returns N as a bigint.
+   */
+  static getN(group) {
+    switch (group) {
+      case 1 /* Rfc5054_1024 */:
+        return BigInt("0xEEAF0AB9ADB38DD69C33F80AFA8FC5E86072618775FF3C0B9EA2314C9C256576D674DF7496EA81D3383B4813D692C6E0E0D5D8E250B98BE48E495C1D6089DAD15DC7D7B46154D6B6CE8EF4AD69B15D4982559B297BCF1885C529F566660E57EC68EDBC3C05726CC02FD4CBF4976EAA9AFD5138FE8376435B9FC61D2FC0EB06E3");
+      case 2 /* Rfc5054_1536 */:
+        return BigInt("0x9DEF3CAFB939277AB1F12A8617A47BBBDBA51DF499AC4C80BEEEA9614B19CC4D5F4F5F556E27CBDE51C6A94BE4607A291558903BA0D0F84380B655BB9A22E8DCDF028A7CEC67F0D08134B1C8B97989149B609E0BE3BAB63D47548381DBC5B1FC764E3F4B53DD9DA1158BFD3E2B9C8CF56EDF019539349627DB2FD53D24B7C48665772E437D6C7F8CE442734AF7CCB7AE837C264AE3A9BEB87F8A2FE9B8B5292E5A021FFF5E91479E8CE7A28C2442C6F315180F93499A234DCF76E3FED135F9BB");
+      case 3 /* Rfc5054_2048 */:
+        return BigInt("0xAC6BDB41324A9A9BF166DE5E1389582FAF72B6651987EE07FC3192943DB56050A37329CBB4A099ED8193E0757767A13DD52312AB4B03310DCD7F48A9DA04FD50E8083969EDB767B0CF6095179A163AB3661A05FBD5FAAAE82918A9962F0B93B855F97993EC975EEAA80D740ADBF4FF747359D041D5C33EA71D281E446B14773BCA97B43A23FB801676BD207A436C6481F1D2B9078717461A5B9D32E688F87748544523B524B0D57D5EA77A2775D2ECFA032CFBDBF52FB3786160279004E57AE6AF874E7303CE53299CCC041C7BC308D82A5698F3A8D0C38271AE35F8E9DBFBB694B5C803D89F7AE435DE236D525F54759B65E372FCD68EF20FA7111F9E4AFF73");
+      case 4 /* Rfc5054_3072 */:
+        return BigInt("0xFFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF6955817183995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6BF12FFA06D98A0864D87602733EC86A64521F2B18177B200CBBE117577A615D6C770988C0BAD946E208E24FA074E5AB3143DB5BFCE0FD108E4B82D120A93AD2CAFFFFFFFFFFFFFFFF");
+      case 5 /* Rfc5054_4096 */:
+        return BigInt("0xFFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF6955817183995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6BF12FFA06D98A0864D87602733EC86A64521F2B18177B200CBBE117577A615D6C770988C0BAD946E208E24FA074E5AB3143DB5BFCE0FD108E4B82D120A92108011A723C12A787E6D788719A10BDBA5B2699C327186AF4E23C1A946834B6150BDA2583E9CA2AD44CE8DBBBC2DB04DE8EF92E8EFC141FBECAA6287C59474E6BC05D99B2964FA090C3A2233BA186515BE7ED1F612970CEE2D7AFB81BDD762170481CD0069127D5B05AA993B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934063199FFFFFFFFFFFFFFFF");
+      case 6 /* Rfc5054_6144 */:
+        return BigInt("0xFFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF6955817183995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6BF12FFA06D98A0864D87602733EC86A64521F2B18177B200CBBE117577A615D6C770988C0BAD946E208E24FA074E5AB3143DB5BFCE0FD108E4B82D120A92108011A723C12A787E6D788719A10BDBA5B2699C327186AF4E23C1A946834B6150BDA2583E9CA2AD44CE8DBBBC2DB04DE8EF92E8EFC141FBECAA6287C59474E6BC05D99B2964FA090C3A2233BA186515BE7ED1F612970CEE2D7AFB81BDD762170481CD0069127D5B05AA993B4EA988D8FDDC186FFB7DC90A6C08F4DF435C93402849236C3FAB4D27C7026C1D4DCB2602646DEC9751E763DBA37BDF8FF9406AD9E530EE5DB382F413001AEB06A53ED9027D831179727B0865A8918DA3EDBEBCF9B14ED44CE6CBACED4BB1BDB7F1447E6CC254B332051512BD7AF426FB8F401378CD2BF5983CA01C64B92ECF032EA15D1721D03F482D7CE6E74FEF6D55E702F46980C82B5A84031900B1C9E59E7C97FBEC7E8F323A97A7E36CC88BE0F1D45B7FF585AC54BD407B22B4154AACC8F6D7EBF48E1D814CC5ED20F8037E0A79715EEF29BE32806A1D58BB7C5DA76F550AA3D8A1FBFF0EB19CCB1A313D55CDA56C9EC2EF29632387FE8D76E3C0468043E8F663F4860EE12BF2D5B0B7474D6E694F91E6DCC4024FFFFFFFFFFFFFFFF");
+      case 7 /* Rfc5054_8192 */:
+        return BigInt("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
+      default:
+        throw new Error("Unsupported group");
+    }
+  }
+  /**
+   * Returns the generator g for the given SRP group.
+   * @param group - SRP group identifier.
+   * @returns g as a bigint (2, 5, or 19).
+   */
+  static getG(group) {
+    switch (group) {
+      case 1 /* Rfc5054_1024 */:
+        return BigInt(2);
+      case 2 /* Rfc5054_1536 */:
+        return BigInt(2);
+      case 3 /* Rfc5054_2048 */:
+        return BigInt(2);
+      case 4 /* Rfc5054_3072 */:
+        return BigInt(5);
+      case 5 /* Rfc5054_4096 */:
+        return BigInt(5);
+      case 6 /* Rfc5054_6144 */:
+        return BigInt(5);
+      case 7 /* Rfc5054_8192 */:
+        return BigInt(19);
+      default:
+        throw new Error("Unsupported group");
+    }
+  }
+};
+
+// src/srp/srp-options.ts
+var SrpOptions = class {
+  constructor() {
+    /** Diffie-Hellman group. Default Rfc5054_3072 (g=5). */
+    this.group = 4 /* Rfc5054_3072 */;
+    /** Hash algorithm for SRP computations. Default SHA-256. */
+    this.hashAlgorithmName = "SHA-256";
+    /** Salt size in bytes. Default 32. */
+    this.saltSize = 32;
+  }
+  /** Prime modulus N for the selected group. */
+  get N() {
+    return SrpGroupParams.getN(this.group);
+  }
+  /** Generator g for the selected group (2, 5, or 19). */
+  get g() {
+    return SrpGroupParams.getG(this.group);
+  }
+  /** Byte length of N (ceil(bitLength / 8)). */
+  get modulusSize() {
+    return Math.floor((this.N.toString(2).length + 7) / 8);
+  }
+  /**
+   * Computes the multiplier parameter k = H(PAD(N) || PAD(g)) (RFC 5054, 2.5.3).
+   * @returns k as a bigint.
+   */
+  async computeK() {
+    const nBytes = SecurityUtils.bigIntToFixedBytes(this.N, this.modulusSize);
+    const gBytes = SecurityUtils.bigIntToFixedBytes(this.g, this.modulusSize);
+    const combined = new Uint8Array(nBytes.length + gBytes.length);
+    combined.set(nBytes, 0);
+    combined.set(gBytes, nBytes.length);
+    const hash = await crypto.subtle.digest(this.hashAlgorithmName, combined);
+    return SecurityUtils.bytesToBigInt(new Uint8Array(hash));
+  }
+};
+
+// src/srp/srp-context-factory.ts
+var SrpContextFactory = class {
+  /**
+   * Creates an SRP context with the specified group.
+   * @param group - SRP group (default Rfc5054_3072).
+   * @returns A ready-to-use SrpContext.
+   */
+  static async create(group = 4 /* Rfc5054_3072 */) {
+    const opts = new SrpOptions();
+    opts.group = group;
+    opts.hashAlgorithmName = group === 5 /* Rfc5054_4096 */ || group === 6 /* Rfc5054_6144 */ || group === 7 /* Rfc5054_8192 */ ? "SHA-384" : "SHA-256";
+    return {
+      N: opts.N,
+      g: opts.g,
+      k: await opts.computeK(),
+      modulusSize: opts.modulusSize,
+      hashAlgorithmName: opts.hashAlgorithmName,
+      hashSize: opts.hashAlgorithmName === "SHA-256" ? 32 : opts.hashAlgorithmName === "SHA-384" ? 48 : 64
+    };
   }
 };
 
-export { CryptoService, KeyDerivationService, SecurityUtils, SrpService };
+export { AesGcmOptions, CryptoProfile, CryptoProfileRegistry, CryptoService, CryptoVersion, KdfOptions, KeyDerivationService, SecurityConstants, SecurityUtils, SrpClientService, SrpContextFactory, SrpEncoding, SrpGroup, SrpGroupParams, SrpOptions, SrpServerService, SupportedHashAlgorithms };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map