@dstorage-tech/dstorage-sdk 0.0.4 → 0.0.5

package/dist/chunk-BBJCQFWP.mjs

@@ -1,275 +0,0 @@
-import {
-  EncryptionErrorCode
-} from "./chunk-O37NHERH.mjs";
-import {
-  DStorageError,
-  deriveKek,
-  unwrapKey,
-  wrapKey
-} from "./chunk-BWLEAAFW.mjs";
-
-// ../encryption/dist/chunk-PDWRI7YP.mjs
-import { scrypt } from "@noble/hashes/scrypt.js";
-var KDF_PRESETS = {
-  v1: { N: 131072, r: 8, p: 1 },
-  "v1-lite": { N: 65536, r: 8, p: 1 }
-};
-var PasswordEncryptionAdapter = class _PasswordEncryptionAdapter {
-  constructor(config) {
-    this.name = "password";
-    validatePassword(
-      config.password,
-      config.minPasswordLength ?? 12,
-      config.minEntropyBits ?? 60,
-      config.additionalValidators
-    );
-    this.salt = resolveSalt(config.salt);
-    const resolved = resolveParams(config.preset, config.params);
-    this.N = resolved.N;
-    this.r = resolved.r;
-    this.p = resolved.p;
-    const passwordBytes = new TextEncoder().encode(config.password);
-    const seed = scrypt(passwordBytes, this.salt, {
-      N: this.N,
-      r: this.r,
-      p: this.p,
-      dkLen: 64
-    });
-    this.kekMaterialPromise = globalThis.crypto.subtle.importKey("raw", seed, "HKDF", false, ["deriveBits"]).then(
-      (key) => {
-        seed.fill(0);
-        return key;
-      },
-      (err) => {
-        seed.fill(0);
-        throw err;
-      }
-    );
-  }
-  /**
-   * Reconstruct an adapter from parameters previously stored via `getKdfParams()`.
-   * Use this when loading existing encrypted data — ensures the exact same N/r/p
-   * are used regardless of what the current SDK defaults are.
-   *
-   * @example
-   * const adapter = PasswordEncryptionAdapter.fromKdfParams({
-   *   password,
-   *   salt: meta.salt,
-   *   kdf: meta.kdf,
-   *   N: meta.N,
-   *   r: meta.r,
-   *   p: meta.p,
-   * });
-   */
-  static fromKdfParams(config) {
-    if (config.kdf !== "scrypt") {
-      throw new DStorageError(
-        EncryptionErrorCode.PASSWORD_UNSUPPORTED_KDF,
-        `[dStorage] PasswordEncryptionAdapter.fromKdfParams: unsupported kdf "${config.kdf}". Only "scrypt" is supported.`
-      );
-    }
-    return new _PasswordEncryptionAdapter({
-      password: config.password,
-      salt: config.salt,
-      params: { N: config.N, r: config.r, p: config.p },
-      ...config.minPasswordLength !== void 0 && {
-        minPasswordLength: config.minPasswordLength
-      },
-      ...config.minEntropyBits !== void 0 && {
-        minEntropyBits: config.minEntropyBits
-      },
-      ...config.additionalValidators !== void 0 && {
-        additionalValidators: config.additionalValidators
-      }
-    });
-  }
-  /**
-   * Returns the resolved KDF parameters to store alongside encrypted data.
-   *
-   * These values are language- and SDK-agnostic: any scrypt implementation
-   * can re-derive the key from `{ kdf, N, r, p }` + the original salt and
-   * password, without any knowledge of this SDK's preset names.
-   *
-   * @example
-   * const meta = {
-   *   ...adapter.getKdfParams(),  // { kdf: "scrypt", N: 131072, r: 8, p: 1 }
-   *   salt: "myapp:alice@example.com",
-   * };
-   * await db.save({ encryptedData, meta });
-   */
-  getKdfParams() {
-    return { kdf: "scrypt", N: this.N, r: this.r, p: this.p };
-  }
-  async wrapDek(dek) {
-    const kekMaterial = await this.kekMaterialPromise;
-    const kek = await deriveKek(kekMaterial);
-    try {
-      return {
-        algorithm: "xchacha20poly1305-v1",
-        kekDerivation: "hkdf-sha256-v1",
-        wrappedDek: await wrapKey(dek, kek)
-      };
-    } finally {
-      kek.fill(0);
-    }
-  }
-  async unwrapDek({ wrappedDek }) {
-    const kekMaterial = await this.kekMaterialPromise;
-    const kek = await deriveKek(kekMaterial);
-    try {
-      return unwrapKey(wrappedDek, kek);
-    } finally {
-      kek.fill(0);
-    }
-  }
-  /**
-   * Deterministically derive a ML-KEM keypair from this adapter's key material.
-   *
-   * Uses Web Crypto HKDF to derive a 64-byte ML-KEM seed from the stored
-   * CryptoKey, domain-separated from the symmetric KEK derivation path with
-   * info="dstorage:mlkem-seed:v1". This is equivalent to noble's
-   * hkdf(sha256, scryptOutput, undefined, info, 64) but avoids materialising
-   * the raw scrypt output in a JS-accessible variable.
-   *
-   * Same password + salt + variant always produces the same keypair.
-   *
-   * @param variant  ML-KEM variant. Default: "mlkem768".
-   */
-  async intoKeypairEncryptionAdapter(context, variant) {
-    const { KeypairEncryptionAdapter } = await import("./KeypairEncryptionAdapter-AE75YC4W-VAOH6AAL.mjs");
-    const { mlkemGenerateKeypairFromSeed } = await import("./dist-INTAFXQ7.mjs");
-    const kekMaterial = await this.kekMaterialPromise;
-    const mlkemBits = await globalThis.crypto.subtle.deriveBits(
-      {
-        name: "HKDF",
-        hash: "SHA-256",
-        salt: new Uint8Array(32),
-        info: new TextEncoder().encode("dstorage:mlkem-seed:v1")
-      },
-      kekMaterial,
-      512
-      // 64 bytes
-    );
-    const mlkemSeed = new Uint8Array(mlkemBits);
-    try {
-      const { pk, sk } = mlkemGenerateKeypairFromSeed(mlkemSeed, variant);
-      return KeypairEncryptionAdapter.fromKeypair(pk, sk, context, variant);
-    } finally {
-      mlkemSeed.fill(0);
-    }
-  }
-};
-function resolveSalt(salt) {
-  const bytes = typeof salt === "string" ? new TextEncoder().encode(salt) : salt;
-  if (bytes.length === 0) {
-    throw new DStorageError(
-      EncryptionErrorCode.PASSWORD_EMPTY_SALT,
-      '[dStorage] PasswordEncryptionAdapter: salt must not be empty. Provide an app-specific domain label, e.g. "myapp:v1:alice@example.com".'
-    );
-  }
-  return bytes;
-}
-function resolveParams(preset, params) {
-  if (preset !== void 0) {
-    if (!(preset in KDF_PRESETS)) {
-      throw new DStorageError(
-        EncryptionErrorCode.PASSWORD_UNKNOWN_PRESET,
-        `[dStorage] PasswordEncryptionAdapter: unknown preset "${preset}". Valid presets: ${Object.keys(KDF_PRESETS).join(", ")}.`
-      );
-    }
-    return KDF_PRESETS[preset];
-  }
-  return {
-    N: params?.N ?? KDF_PRESETS["v1"].N,
-    r: params?.r ?? KDF_PRESETS["v1"].r,
-    p: params?.p ?? KDF_PRESETS["v1"].p
-  };
-}
-function estimateEntropyBits(password) {
-  let pool = 0;
-  if (/[a-z]/.test(password)) pool += 26;
-  if (/[A-Z]/.test(password)) pool += 26;
-  if (/[0-9]/.test(password)) pool += 10;
-  if (/[^a-zA-Z0-9]/.test(password)) pool += 32;
-  return pool === 0 ? 0 : Math.log2(pool) * password.length;
-}
-function hasSequentialRun(pw, runLength = 5) {
-  for (let i = 0; i <= pw.length - runLength; i++) {
-    let ascending = true;
-    let descending = true;
-    for (let j = 1; j < runLength; j++) {
-      const diff = pw.charCodeAt(i + j) - pw.charCodeAt(i + j - 1);
-      if (diff !== 1) ascending = false;
-      if (diff !== -1) descending = false;
-      if (!ascending && !descending) break;
-    }
-    if (ascending || descending) return true;
-  }
-  return false;
-}
-var KEYBOARD_ROWS = ["qwertyuiop", "asdfghjkl", "zxcvbnm", "1234567890"];
-function hasKeyboardWalk(pw, minLen = 5) {
-  const lower = pw.toLowerCase();
-  for (const row of KEYBOARD_ROWS) {
-    for (let i = 0; i <= row.length - minLen; i++) {
-      const fwd = row.slice(i, i + minLen);
-      const rev = fwd.split("").reverse().join("");
-      if (lower.includes(fwd) || lower.includes(rev)) return true;
-    }
-  }
-  return false;
-}
-function generatePqsPassword() {
-  while (true) {
-    const bytes = globalThis.crypto.getRandomValues(new Uint8Array(32));
-    const b64 = btoa(Array.from(bytes, (b) => String.fromCharCode(b)).join(""));
-    const password = b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
-    if (new Set(password).size >= 3 && !hasSequentialRun(password) && !hasKeyboardWalk(password)) {
-      return password;
-    }
-  }
-}
-function validatePassword(password, minLength, minEntropyBits, additionalValidators) {
-  if (password.length < minLength) {
-    throw new DStorageError(
-      EncryptionErrorCode.PASSWORD_TOO_SHORT,
-      `[dStorage] Password too short: ${password.length} character(s) (minimum ${minLength}). Use a longer passphrase.`
-    );
-  }
-  if (new Set(password).size < 3) {
-    throw new DStorageError(
-      EncryptionErrorCode.PASSWORD_TOO_FEW_DISTINCT,
-      "[dStorage] Password is too weak: too few distinct characters."
-    );
-  }
-  if (hasSequentialRun(password)) {
-    throw new DStorageError(
-      EncryptionErrorCode.PASSWORD_SEQUENTIAL_RUN,
-      "[dStorage] Password is too weak: contains a sequential character run (e.g. abcde, 12345)."
-    );
-  }
-  if (hasKeyboardWalk(password)) {
-    throw new DStorageError(
-      EncryptionErrorCode.PASSWORD_KEYBOARD_WALK,
-      "[dStorage] Password is too weak: contains a keyboard-row pattern (e.g. qwerty, asdfg)."
-    );
-  }
-  const entropy = estimateEntropyBits(password);
-  if (entropy < minEntropyBits) {
-    throw new DStorageError(
-      EncryptionErrorCode.PASSWORD_ENTROPY_TOO_LOW,
-      `[dStorage] Password entropy too low: ~${Math.round(entropy)} bits (minimum ${minEntropyBits} bits). Use a longer password with a mix of uppercase, lowercase, digits, and symbols.`
-    );
-  }
-  if (additionalValidators) {
-    for (const validate of additionalValidators) {
-      validate(password);
-    }
-  }
-}
-
-export {
-  KDF_PRESETS,
-  PasswordEncryptionAdapter,
-  generatePqsPassword
-};