@luckystack/login 0.7.2 → 0.7.4

package/dist/index.js

@@ -14,7 +14,7 @@ import {
   registerOAuthProviderFactory,
   registerOAuthProviders,
   registerUserAdapter
-} from "./chunk-L5MHCPNN.js";
+} from "./chunk-CLYMWF3A.js";
 import {
   activeUsersKeyFor,
   deleteSession,
@@ -139,10 +139,20 @@ var registerPostLoginRedirect = (resolver) => {
   return resolver;
 };
 var getPostLoginRedirect = () => activeResolver;
+var RELATIVE_BASE = "http://luckystack-relative.invalid";
+var resolvePostLoginRedirectAgainstDefault = (candidate, defaultUrl) => {
+  if (!URL.canParse(candidate, RELATIVE_BASE)) return candidate;
+  const parsed = new URL(candidate, RELATIVE_BASE);
+  if (parsed.origin !== RELATIVE_BASE) return candidate;
+  if (!URL.canParse(defaultUrl)) return candidate;
+  const fallback = new URL(defaultUrl);
+  if (fallback.protocol !== "http:" && fallback.protocol !== "https:") return candidate;
+  return new URL(candidate, fallback).toString();
+};
 
 // src/login.ts
 import { URLSearchParams as URLSearchParams2 } from "url";
-import { tryCatch as tryCatch2, tryCatchSync, redis as redisClient, getUploadsDir, dispatchHook, getLogger as getLogger3, formatKey, getProjectConfig as getProjectConfig4, getCookieValue } from "@luckystack/core";
+import { tryCatch as tryCatch2, tryCatchSync, redis as redisClient, getUploadsDir, dispatchHook, getLogger as getLogger3, formatKey, getProjectConfig as getProjectConfig4, getCookieValue, resolveDevCallbackUrl } from "@luckystack/core";
 import bcrypt from "bcryptjs";
 import { randomBytes, createHash, timingSafeEqual } from "crypto";
 import validator from "validator";
@@ -773,11 +783,12 @@ var isAllowedRedirectUrl = (url) => {
   });
 };
 var exchangeOAuthToken = async (provider, code, codeVerifier) => {
+  const redirectUri = resolveDevCallbackUrl(provider.callbackURL);
   const values = {
     code,
     client_id: provider.clientID,
     client_secret: provider.clientSecret,
-    redirect_uri: provider.callbackURL,
+    redirect_uri: redirectUri,
     grant_type: "authorization_code",
     ...codeVerifier ? { code_verifier: codeVerifier } : {}
   };
@@ -799,7 +810,7 @@ var exchangeOAuthToken = async (provider, code, codeVerifier) => {
     formParams.append("client_secret", provider.clientSecret);
     formParams.append("code", values.code);
     formParams.append("grant_type", "authorization_code");
-    formParams.append("redirect_uri", provider.callbackURL);
+    formParams.append("redirect_uri", redirectUri);
     if (codeVerifier) {
       formParams.append("code_verifier", codeVerifier);
     }
@@ -986,7 +997,9 @@ var resolvePostLoginRedirect = async ({
     getLogger3().warn(`[oauth] postLoginRedirect resolver threw`, { message: resolverError.message });
     return fallbackUrl;
   }
-  if (resolved && isAllowedRedirectUrl(resolved)) return resolved;
+  if (resolved && isAllowedRedirectUrl(resolved)) {
+    return resolvePostLoginRedirectAgainstDefault(resolved, fallbackUrl);
+  }
   if (resolved) {
     getLogger3().warn(
       `[oauth] postLoginRedirect returned a URL not in allowed origins \u2014 falling back`,
@@ -1266,33 +1279,53 @@ var normalizeIdentity = (identity) => identity.trim().toLowerCase();
 var codeKey = (purpose, identity) => formatKey4("-emailcode", `${purpose}:${normalizeIdentity(identity)}`);
 var attemptsKey = (purpose, identity) => formatKey4("-emailcode-attempts", `${purpose}:${normalizeIdentity(identity)}`);
 var hashCode = (code) => crypto.createHash("sha256").update(code).digest("hex");
+var ISSUE_CODE_SCRIPT = `
+redis.call('set', KEYS[1], ARGV[1], 'EX', ARGV[2])
+redis.call('del', KEYS[2])
+return 1
+`;
+var VERIFY_CODE_SCRIPT = `
+local stored = redis.call('get', KEYS[1])
+if not stored then return 0 end
+local attempts = redis.call('incr', KEYS[2])
+local remaining = redis.call('ttl', KEYS[1])
+redis.call('expire', KEYS[2], remaining > 0 and remaining or 600)
+if attempts > tonumber(ARGV[2]) then
+  redis.call('del', KEYS[1])
+  redis.call('del', KEYS[2])
+  return 3
+end
+if stored ~= ARGV[1] then return 1 end
+redis.call('del', KEYS[1])
+redis.call('del', KEYS[2])
+return 2
+`;
 var generateNumericCode = (digits) => String(crypto.randomInt(0, 10 ** digits)).padStart(digits, "0");
 var issueEmailCode = async ({ purpose, identity, ttlSeconds, digits }) => {
   const code = generateNumericCode(digits);
-  await redis3.set(codeKey(purpose, identity), hashCode(code), "EX", ttlSeconds);
-  await redis3.del(attemptsKey(purpose, identity));
+  await redis3.eval(
+    ISSUE_CODE_SCRIPT,
+    2,
+    codeKey(purpose, identity),
+    attemptsKey(purpose, identity),
+    hashCode(code),
+    String(ttlSeconds)
+  );
   return code;
 };
 var verifyEmailCode = async ({ purpose, identity, code, maxAttempts }) => {
-  const key = codeKey(purpose, identity);
-  const storedHash = await redis3.get(key);
-  if (!storedHash) return "expired";
-  const counter = attemptsKey(purpose, identity);
-  const attempts = await redis3.incr(counter);
-  const remaining = await redis3.ttl(key);
-  await redis3.expire(counter, remaining > 0 ? remaining : 600);
-  if (attempts > maxAttempts) {
-    await redis3.del(key);
-    await redis3.del(counter);
-    return "locked";
-  }
-  const submitted = Buffer.from(hashCode(code.trim()));
-  const expected = Buffer.from(storedHash);
-  const matches = submitted.length === expected.length && crypto.timingSafeEqual(submitted, expected);
-  if (!matches) return "invalid";
-  const deleted = await redis3.del(key);
-  await redis3.del(counter);
-  return deleted > 0 ? "valid" : "expired";
+  const result = Number(await redis3.eval(
+    VERIFY_CODE_SCRIPT,
+    2,
+    codeKey(purpose, identity),
+    attemptsKey(purpose, identity),
+    hashCode(code.trim()),
+    String(maxAttempts)
+  ));
+  if (result === 2) return "valid";
+  if (result === 1) return "invalid";
+  if (result === 3) return "locked";
+  return "expired";
 };
 var clearEmailCode = async (purpose, identity) => {
   await redis3.del(codeKey(purpose, identity));
@@ -1377,16 +1410,65 @@ var buildOtpauthUri = ({ secret, accountName, issuer }) => {
 
 // src/twoFactor.ts
 var sha256 = (value) => crypto3.createHash("sha256").update(value).digest("hex");
-var ENCRYPTED_PREFIX = "gcm:";
+var LEGACY_ENCRYPTED_PREFIX = "gcm:";
+var VERSIONED_ENCRYPTED_PREFIX = "enc:v2:";
+var KEY_ID_LENGTH = 24;
 var warnedPlaintextSecret = false;
-var encryptionKey = () => {
-  const raw = process.env.TOTP_ENCRYPTION_KEY;
-  if (!raw) return null;
-  return crypto3.createHash("sha256").update(raw).digest();
+var warnedInvalidLegacyKeyRing = false;
+var toEncryptionKey = (raw) => ({
+  id: crypto3.createHash("sha256").update(`luckystack-totp-key-id:${raw}`).digest("hex").slice(0, KEY_ID_LENGTH),
+  key: crypto3.createHash("sha256").update(raw).digest()
+});
+var readLegacyEncryptionKeys = () => {
+  const raw = process.env.TOTP_ENCRYPTION_LEGACY_KEYS;
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) {
+      throw new TypeError("expected a JSON array of non-empty strings");
+    }
+    const keys = [];
+    for (const value of parsed) {
+      if (typeof value !== "string" || value.length === 0) {
+        throw new TypeError("expected a JSON array of non-empty strings");
+      }
+      keys.push(value);
+    }
+    return keys;
+  } catch {
+    if (!warnedInvalidLegacyKeyRing) {
+      warnedInvalidLegacyKeyRing = true;
+      getLogger5().error("[2fa] TOTP_ENCRYPTION_LEGACY_KEYS must be a JSON array of non-empty strings; legacy TOTP rows cannot be decrypted until it is fixed.");
+    }
+    return [];
+  }
+};
+var encryptionKeyRing = () => {
+  const primaryRaw = process.env.TOTP_ENCRYPTION_KEY;
+  const primary = primaryRaw ? toEncryptionKey(primaryRaw) : null;
+  const seen = /* @__PURE__ */ new Set();
+  const all = [];
+  for (const raw of [primaryRaw, ...readLegacyEncryptionKeys()]) {
+    if (!raw) continue;
+    const entry = toEncryptionKey(raw);
+    if (seen.has(entry.id)) continue;
+    seen.add(entry.id);
+    all.push(entry);
+  }
+  return { primary, all };
+};
+var decryptWithKey = (key, ivPart, tagPart, dataPart) => {
+  try {
+    const decipher = crypto3.createDecipheriv("aes-256-gcm", key, Buffer.from(ivPart, "base64"));
+    decipher.setAuthTag(Buffer.from(tagPart, "base64"));
+    return Buffer.concat([decipher.update(Buffer.from(dataPart, "base64")), decipher.final()]).toString("utf8");
+  } catch {
+    return null;
+  }
 };
 var encryptTotpSecret = (secret) => {
-  const key = encryptionKey();
-  if (!key) {
+  const { primary } = encryptionKeyRing();
+  if (!primary) {
     if (!warnedPlaintextSecret) {
       warnedPlaintextSecret = true;
       getLogger5().warn("[2fa] TOTP_ENCRYPTION_KEY is not set \u2014 TOTP secrets are stored unencrypted. Set it in .env.local to encrypt new enrollments at rest.");
@@ -1394,34 +1476,58 @@ var encryptTotpSecret = (secret) => {
     return secret;
   }
   const iv = crypto3.randomBytes(12);
-  const cipher = crypto3.createCipheriv("aes-256-gcm", key, iv);
+  const cipher = crypto3.createCipheriv("aes-256-gcm", primary.key, iv);
   const ciphertext = Buffer.concat([cipher.update(secret, "utf8"), cipher.final()]);
-  return `${ENCRYPTED_PREFIX}${iv.toString("base64")}:${cipher.getAuthTag().toString("base64")}:${ciphertext.toString("base64")}`;
-};
-var decryptTotpSecret = (stored) => {
-  if (!stored.startsWith(ENCRYPTED_PREFIX)) return stored;
-  const key = encryptionKey();
-  if (!key) {
-    getLogger5().error("[2fa] found an encrypted TOTP secret but TOTP_ENCRYPTION_KEY is not set \u2014 cannot verify TOTP codes.");
+  return `${VERSIONED_ENCRYPTED_PREFIX}${primary.id}:${iv.toString("base64")}:${cipher.getAuthTag().toString("base64")}:${ciphertext.toString("base64")}`;
+};
+var decryptTotpSecretWithMetadata = (stored) => {
+  const ring = encryptionKeyRing();
+  if (!stored.startsWith(LEGACY_ENCRYPTED_PREFIX) && !stored.startsWith("enc:")) {
+    return { secret: stored, needsReencrypt: ring.primary !== null };
+  }
+  if (stored.startsWith(VERSIONED_ENCRYPTED_PREFIX)) {
+    const [keyId, ivPart2, tagPart2, dataPart2] = stored.slice(VERSIONED_ENCRYPTED_PREFIX.length).split(":");
+    if (!keyId || !ivPart2 || !tagPart2 || !dataPart2) return null;
+    const entry = ring.all.find((candidate) => candidate.id === keyId);
+    if (!entry) {
+      getLogger5().error("[2fa] TOTP secret references an unavailable encryption key id. Add the previous key to TOTP_ENCRYPTION_LEGACY_KEYS.");
+      return null;
+    }
+    const secret = decryptWithKey(entry.key, ivPart2, tagPart2, dataPart2);
+    if (!secret) {
+      getLogger5().error("[2fa] TOTP secret decryption failed (ciphertext is invalid or the configured key is wrong).");
+      return null;
+    }
+    return {
+      secret,
+      needsReencrypt: ring.primary !== null && entry.id !== ring.primary.id
+    };
+  }
+  if (!stored.startsWith(LEGACY_ENCRYPTED_PREFIX)) {
+    getLogger5().error("[2fa] unsupported TOTP ciphertext version.");
     return null;
   }
-  const [ivPart, tagPart, dataPart] = stored.slice(ENCRYPTED_PREFIX.length).split(":");
-  if (!ivPart || !tagPart || !dataPart) return null;
-  try {
-    const decipher = crypto3.createDecipheriv("aes-256-gcm", key, Buffer.from(ivPart, "base64"));
-    decipher.setAuthTag(Buffer.from(tagPart, "base64"));
-    return Buffer.concat([decipher.update(Buffer.from(dataPart, "base64")), decipher.final()]).toString("utf8");
-  } catch {
-    getLogger5().error("[2fa] TOTP secret decryption failed (wrong TOTP_ENCRYPTION_KEY?).");
+  const [ivPart, tagPart, dataPart] = stored.slice(LEGACY_ENCRYPTED_PREFIX.length).split(":");
+  if (!ivPart || !tagPart || !dataPart || ring.all.length === 0) {
+    getLogger5().error("[2fa] found a legacy encrypted TOTP secret but no matching primary/legacy key is configured.");
     return null;
   }
+  for (const entry of ring.all) {
+    const secret = decryptWithKey(entry.key, ivPart, tagPart, dataPart);
+    if (secret) return { secret, needsReencrypt: ring.primary !== null };
+  }
+  getLogger5().error("[2fa] legacy TOTP secret decryption failed with every configured key.");
+  return null;
 };
+var decryptTotpSecret = (stored) => decryptTotpSecretWithMetadata(stored)?.secret ?? null;
 var challengeKey = (token) => formatKey5("-2fa-challenge", sha256(token));
 var challengeAttemptsKey = (token) => formatKey5("-2fa-challenge-attempts", sha256(token));
 var usedTimestepKey = (userId, timestep) => formatKey5("-2fa-usedstep", `${userId}:${String(timestep)}`);
 var accountFailureKey = (userId) => formatKey5("-2fa-accountfail", userId);
 var RECOVERY_LEASE_MS = 5e3;
 var recoveryLeaseName = (userId) => `2fa-recovery:${userId}`;
+var ENROLLMENT_LEASE_MS = 3e4;
+var enrollmentLeaseName = (userId) => `2fa-enrollment:${userId}`;
 var pendingSecretKey = (userId) => formatKey5("-2fa-pending", userId);
 var ACCOUNT_FAIL_LIMIT = 10;
 var ACCOUNT_FAIL_WINDOW_SECONDS = 15 * 60;
@@ -1475,13 +1581,23 @@ var burnChallenge = async (token) => {
 var verifyTotpForUser = async (user, code, enforceSingleUse) => {
   if (!user.totpSecret) return false;
   if (!/^\d{6}$/.test(code.trim())) return false;
-  const secret = decryptTotpSecret(user.totpSecret);
-  if (!secret) return false;
-  const result = verifyTotp({ secret, code });
+  const decrypted = decryptTotpSecretWithMetadata(user.totpSecret);
+  if (!decrypted) return false;
+  const result = verifyTotp({ secret: decrypted.secret, code });
   if (!result.valid || result.timestep === null) return false;
-  if (!enforceSingleUse) return true;
-  const claimed = await redis4.set(usedTimestepKey(user.id, result.timestep), "1", "EX", 60 * 2, "NX");
-  return claimed !== null;
+  if (enforceSingleUse) {
+    const claimed = await redis4.set(usedTimestepKey(user.id, result.timestep), "1", "EX", 60 * 2, "NX");
+    if (claimed === null) return false;
+  }
+  if (decrypted.needsReencrypt) {
+    const [migrationError] = await tryCatch3(() => getUserAdapter().update(user.id, {
+      totpSecret: encryptTotpSecret(decrypted.secret)
+    }));
+    if (migrationError) {
+      getLogger5().error("[2fa] TOTP encryption-key lazy migration failed; verification succeeded but the existing ciphertext was kept.", migrationError);
+    }
+  }
+  return true;
 };
 var matchRecoveryHash = (hashes, code) => {
   const submitted = Buffer.from(sha256(code.trim().toLowerCase()));
@@ -1628,24 +1744,30 @@ var generateRecoveryCodes = () => {
 var confirmTotpEnrollment = async (user, code) => {
   const blocked = enrollmentBlockedReason(user);
   if (blocked) return { ok: false, reason: blocked };
-  const pendingStored = await redis4.get(pendingSecretKey(user.id));
-  if (!pendingStored) return { ok: false, reason: "login.twoFactorEnrollmentExpired" };
-  const secret = decryptTotpSecret(pendingStored);
-  if (!secret) return { ok: false, reason: "login.twoFactorEnrollmentExpired" };
-  const result = verifyTotp({ secret, code });
-  if (!result.valid) return { ok: false, reason: "login.twoFactorInvalidCode" };
-  const { raw, hashes } = generateRecoveryCodes();
-  const [updateError] = await tryCatch3(() => getUserAdapter().update(user.id, {
-    totpSecret: encryptTotpSecret(secret),
-    twoFactorEnabled: true,
-    recoveryCodes: hashes
-  }));
-  if (updateError) {
-    getLogger5().error("[2fa] enrollment persist failed \u2014 is your UserAdapter/schema missing the 2FA fields? (twoFactorEnabled, totpSecret, recoveryCodes)", updateError);
-    return { ok: false, reason: "login.twoFactorPersistFailed" };
+  const leaseToken = await acquireLease(enrollmentLeaseName(user.id), ENROLLMENT_LEASE_MS);
+  if (!leaseToken) return { ok: false, reason: "login.twoFactorEnrollmentExpired" };
+  try {
+    const pendingStored = await redis4.get(pendingSecretKey(user.id));
+    if (!pendingStored) return { ok: false, reason: "login.twoFactorEnrollmentExpired" };
+    const secret = decryptTotpSecret(pendingStored);
+    if (!secret) return { ok: false, reason: "login.twoFactorEnrollmentExpired" };
+    const result = verifyTotp({ secret, code });
+    if (!result.valid) return { ok: false, reason: "login.twoFactorInvalidCode" };
+    const { raw, hashes } = generateRecoveryCodes();
+    const [updateError] = await tryCatch3(() => getUserAdapter().update(user.id, {
+      totpSecret: encryptTotpSecret(secret),
+      twoFactorEnabled: true,
+      recoveryCodes: hashes
+    }));
+    if (updateError) {
+      getLogger5().error("[2fa] enrollment persist failed \u2014 is your UserAdapter/schema missing the 2FA fields? (twoFactorEnabled, totpSecret, recoveryCodes)", updateError);
+      return { ok: false, reason: "login.twoFactorPersistFailed" };
+    }
+    await redis4.del(pendingSecretKey(user.id));
+    return { ok: true, recoveryCodes: raw };
+  } finally {
+    await releaseLease(enrollmentLeaseName(user.id), leaseToken);
   }
-  await redis4.del(pendingSecretKey(user.id));
-  return { ok: true, recoveryCodes: raw };
 };
 var disableTwoFactor = async (user, code) => {
   const viaTotp = await verifyTotpForUser(user, code, false);