@uln/auth 0.4.1 → 0.6.0

package/dist/index.js

@@ -22,7 +22,6 @@ function extractCookie(cookieHeader, name) {
   }
   return null;
 }
-
 // src/token.ts
 var encoder = new TextEncoder;
 function base64urlEncode(data) {
@@ -33,6 +32,8 @@ function base64urlEncode(data) {
   return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
 }
 function base64urlDecode(str) {
+  if (!/^[A-Za-z0-9_-]*$/.test(str))
+    throw new Error("Invalid base64url");
   const padded = str.replace(/-/g, "+").replace(/_/g, "/");
   const binary = atob(padded);
   const bytes = new Uint8Array(binary.length);
@@ -60,8 +61,8 @@ async function importPrivateKey(jwk) {
 async function importPublicKey(jwk) {
   return crypto.subtle.importKey("jwk", jwk, ECDSA_PARAMS, false, ["verify"]);
 }
-async function createToken(config, user) {
-  const now = Math.floor(Date.now() / 1000);
+async function createToken(config, user, options = {}) {
+  const now = options.issuedAt ?? Math.floor(Date.now() / 1000);
   const payload = {
     sub: user.id,
     email: user.email,
@@ -71,7 +72,8 @@ async function createToken(config, user) {
     flags: user.flags,
     kid: config.kid,
     iat: now,
-    exp: now + config.maxAgeSeconds
+    exp: now + config.maxAgeSeconds,
+    ...user.audience === undefined ? {} : { aud: user.audience }
   };
   const payloadB64 = base64urlEncode(encoder.encode(JSON.stringify(payload)));
   const payloadBytes = encoder.encode(payloadB64);
@@ -79,25 +81,46 @@ async function createToken(config, user) {
   const sigB64 = base64urlEncode(new Uint8Array(signature));
   return `${payloadB64}.${sigB64}`;
 }
+var CLOCK_SKEW_SECONDS = 60;
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((v) => typeof v === "string");
+}
+function isFlags(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
+  return Object.values(value).every(isStringArray);
+}
+function isTokenPayload(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  if (!("sub" in value) || !("email" in value) || !("name" in value) || !("admin" in value) || !("scopes" in value) || !("flags" in value) || !("kid" in value) || !("iat" in value) || !("exp" in value)) {
+    return false;
+  }
+  return typeof value.sub === "string" && typeof value.email === "string" && typeof value.name === "string" && typeof value.admin === "boolean" && isStringArray(value.scopes) && isFlags(value.flags) && typeof value.kid === "string" && Number.isSafeInteger(value.iat) && Number.isSafeInteger(value.exp) && (!("aud" in value) || value.aud === undefined || typeof value.aud === "string");
+}
 async function validateToken(config, token) {
-  const dotIndex = token.indexOf(".");
-  if (dotIndex === -1)
+  const parts = token.split(".");
+  if (parts.length !== 2)
     return null;
-  const payloadB64 = token.substring(0, dotIndex);
-  const sigB64 = token.substring(dotIndex + 1);
-  let payload;
+  const [payloadB64 = "", sigB64 = ""] = parts;
+  if (!payloadB64 || !sigB64)
+    return null;
+  let decoded;
   try {
-    const decoded = new TextDecoder().decode(base64urlDecode(payloadB64));
-    payload = JSON.parse(decoded);
+    decoded = JSON.parse(new TextDecoder().decode(base64urlDecode(payloadB64)));
   } catch {
     return null;
   }
-  if (typeof payload.sub !== "string" || typeof payload.exp !== "number" || typeof payload.kid !== "string") {
+  if (!isTokenPayload(decoded))
     return null;
-  }
+  const payload = decoded;
   const now = Math.floor(Date.now() / 1000);
   if (now > payload.exp)
     return null;
+  if (payload.iat > now + CLOCK_SKEW_SECONDS)
+    return null;
+  if (now - payload.iat > config.maxAgeSeconds)
+    return null;
   const entry = config.publicKeys.find((k) => k.kid === payload.kid);
   if (!entry)
     return null;
@@ -112,69 +135,301 @@ async function validateToken(config, token) {
   }
   return payload;
 }
+function peekTokenPayload(token) {
+  const payloadB64 = token.split(".")[0];
+  if (!payloadB64)
+    return null;
+  try {
+    const decoded = JSON.parse(new TextDecoder().decode(base64urlDecode(payloadB64)));
+    return isTokenPayload(decoded) ? decoded : null;
+  } catch {
+    return null;
+  }
+}
+function peekTokenKid(token) {
+  const payloadB64 = token.split(".")[0];
+  if (!payloadB64)
+    return null;
+  try {
+    const decoded = JSON.parse(new TextDecoder().decode(base64urlDecode(payloadB64)));
+    if (typeof decoded !== "object" || decoded === null || !("kid" in decoded))
+      return null;
+    return typeof decoded.kid === "string" ? decoded.kid : null;
+  } catch {
+    return null;
+  }
+}
 
-// src/middleware.ts
-function getClientIP(request) {
-  return request.headers.get("cf-connecting-ip") ?? request.headers.get("x-forwarded-for")?.split(",")[0]?.trim() ?? "unknown";
+// src/remote.ts
+function publicFetcher(authUrl) {
+  return { fetch: (path, init) => fetch(new URL(path, authUrl), init) };
 }
-function checkBearerToken(request, expectedToken) {
-  const header = request.headers.get("Authorization");
-  return header === `Bearer ${expectedToken}`;
+function bindingFetcher(binding) {
+  return { fetch: (path, init) => binding.fetch(new URL(path, "https://auth").toString(), init) };
 }
-async function getAuthUser(request, verifyConfig, cookieConfig) {
-  const cookieHeader = request.headers.get("Cookie");
-  if (!cookieHeader)
-    return null;
-  const token = extractCookie(cookieHeader, cookieConfig.name);
-  if (!token)
+function isLoopbackHostname(hostname) {
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
+}
+function toOrigin(value) {
+  try {
+    return new URL(value).origin;
+  } catch {
     return null;
-  return validateToken(verifyConfig, token);
+  }
 }
-function redirectToLogin(currentUrl) {
-  const loginUrl = new URL("/login", "https://auth.uln.industries");
-  loginUrl.searchParams.set("redirect", currentUrl);
-  loginUrl.searchParams.set("response_type", "code");
-  return Response.redirect(loginUrl.toString(), 302);
+function hasSiteAccess(payload, origin) {
+  return hasSiteAccessFor(payload, { audiences: [origin], scopeOrigin: origin });
+}
+function hasSiteAccessFor(payload, site) {
+  const scopeOrigin = toOrigin(site.scopeOrigin);
+  if (!scopeOrigin || payload.aud === undefined)
+    return false;
+  if (!site.audiences.some((audience) => toOrigin(audience) === payload.aud))
+    return false;
+  if (payload.admin)
+    return true;
+  if (isLoopbackHostname(new URL(scopeOrigin).hostname))
+    return true;
+  return payload.scopes.includes(scopeOrigin);
+}
+async function readJsonObject(res) {
+  try {
+    const body = await res.json();
+    return typeof body === "object" && body !== null ? body : null;
+  } catch {
+    return null;
+  }
 }
-async function exchangeCode(code, redirectOrigin, config) {
-  const res = await fetch(`${config.authUrl}/api/exchange-code`, {
+async function exchangeAuthCode(auth, code, redirectOrigin, codeVerifier) {
+  const res = await auth.fetch("/api/exchange-code", {
     method: "POST",
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ code, redirectOrigin })
+    body: JSON.stringify(codeVerifier === undefined ? { code, redirectOrigin } : { code, redirectOrigin, codeVerifier })
   });
   if (!res.ok)
     return null;
-  const data = await res.json();
-  return typeof data.token === "string" ? data.token : null;
+  const body = await readJsonObject(res);
+  if (!body || !("token" in body) || typeof body.token !== "string")
+    return null;
+  return body.token;
 }
-async function handleCallback(request, verifyConfig, cookieConfig, exchangeConfig) {
+async function checkTokenRemote(auth, token, audience) {
+  let res;
+  try {
+    res = await auth.fetch("/api/verify-token", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(audience === undefined ? { token } : { token, audience })
+    });
+  } catch {
+    return { status: "unavailable" };
+  }
+  if (res.status >= 500)
+    return { status: "unavailable" };
+  if (!res.ok)
+    return { status: "invalid" };
+  const body = await readJsonObject(res);
+  if (!body || !("user" in body) || typeof body.user !== "object" || body.user === null)
+    return { status: "invalid" };
+  const user = body.user;
+  if (!("id" in user))
+    return { status: "invalid" };
+  const candidate = { ...user, sub: user.id, iat: "iat" in user ? user.iat : 0, exp: "exp" in user ? user.exp : 0 };
+  if (!isTokenPayload(candidate))
+    return { status: "invalid" };
+  return {
+    status: "valid",
+    payload: {
+      sub: candidate.sub,
+      email: candidate.email,
+      name: candidate.name,
+      admin: candidate.admin,
+      scopes: candidate.scopes,
+      flags: candidate.flags,
+      kid: candidate.kid,
+      iat: candidate.iat,
+      exp: candidate.exp,
+      ...candidate.aud === undefined ? {} : { aud: candidate.aud }
+    }
+  };
+}
+async function verifyTokenRemote(auth, token, audience) {
+  const result = await checkTokenRemote(auth, token, audience);
+  return result.status === "valid" ? result.payload : null;
+}
+async function fetchJwks(auth) {
+  const res = await auth.fetch("/.well-known/jwk.json");
+  if (!res.ok)
+    throw new Error(`Failed to fetch JWKS: ${res.status}`);
+  const body = await readJsonObject(res);
+  if (!body || !("keys" in body) || !Array.isArray(body.keys))
+    throw new Error("Malformed JWKS response");
+  const entries = [];
+  for (const jwk of body.keys) {
+    if (typeof jwk !== "object" || jwk === null || !("kid" in jwk) || typeof jwk.kid !== "string")
+      continue;
+    if (!("kty" in jwk) || typeof jwk.kty !== "string")
+      continue;
+    const { kid, ...keyData } = jwk;
+    entries.push({ kid, key: await importPublicKey({ ...keyData, kty: jwk.kty }) });
+  }
+  return entries;
+}
+
+// src/flow.ts
+var DEFAULT_AUTH_URL = "https://auth.uln.industries";
+var STATE_COOKIE = "__Host-uln_auth_state";
+var INSECURE_STATE_COOKIE = "uln_auth_state";
+var STATE_PARAM = "uln_state";
+var CHALLENGE_PARAM = "uln_challenge";
+var STATE_MAX_AGE_SECONDS = 600;
+function base64url(bytes) {
+  let binary = "";
+  for (const byte of bytes)
+    binary += String.fromCharCode(byte);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function randomToken() {
+  return base64url(crypto.getRandomValues(new Uint8Array(32)));
+}
+async function pkceChallenge(verifier) {
+  return base64url(new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier))));
+}
+function stateCookie(value, secure, maxAgeSeconds) {
+  const name = secure ? STATE_COOKIE : INSECURE_STATE_COOKIE;
+  const parts = [`${name}=${value}`, `Max-Age=${maxAgeSeconds}`, "Path=/", "HttpOnly", "SameSite=Lax"];
+  if (secure)
+    parts.push("Secure");
+  return parts.join("; ");
+}
+function readStateCookie(request, secure) {
+  const name = secure ? STATE_COOKIE : INSECURE_STATE_COOKIE;
+  const [state = "", verifier = "", ...rest] = (extractCookie(request.headers.get("Cookie") ?? "", name) ?? "").split(".");
+  return state && verifier && rest.length === 0 ? { state, verifier } : null;
+}
+function stripCallbackParams(url) {
+  url.searchParams.delete("code");
+  url.searchParams.delete(STATE_PARAM);
+  url.searchParams.delete(CHALLENGE_PARAM);
+}
+async function redirectToLogin(currentUrl, authUrl = DEFAULT_AUTH_URL) {
+  const returnUrl = new URL(currentUrl);
+  stripCallbackParams(returnUrl);
+  const state = randomToken();
+  const verifier = randomToken();
+  returnUrl.searchParams.set(STATE_PARAM, state);
+  returnUrl.searchParams.set(CHALLENGE_PARAM, await pkceChallenge(verifier));
+  const loginUrl = new URL("/login", authUrl);
+  loginUrl.searchParams.set("redirect", returnUrl.toString());
+  loginUrl.searchParams.set("response_type", "code");
+  const headers = new Headers({ Location: loginUrl.toString() });
+  headers.append("Set-Cookie", stateCookie(`${state}.${verifier}`, returnUrl.protocol === "https:", STATE_MAX_AGE_SECONDS));
+  return new Response(null, { status: 302, headers });
+}
+async function handleLoginCallback(request, options) {
   const url = new URL(request.url);
   const code = url.searchParams.get("code");
-  if (code) {
-    if (!exchangeConfig)
-      return redirectToLogin(url.origin);
-    const token = await exchangeCode(code, url.origin, exchangeConfig);
-    if (!token)
-      return redirectToLogin(url.origin);
-    const payload = await validateToken(verifyConfig, token);
-    if (!payload)
-      return redirectToLogin(url.origin);
-    url.searchParams.delete("code");
-    return new Response(null, {
-      status: 302,
-      headers: {
-        Location: url.toString(),
-        "Set-Cookie": makeSessionCookie(cookieConfig, token)
-      }
-    });
+  if (!code)
+    return null;
+  const state = url.searchParams.get(STATE_PARAM);
+  const secure = url.protocol === "https:";
+  const expected = readStateCookie(request, secure);
+  stripCallbackParams(url);
+  const startOver = () => redirectToLogin(url.toString(), options.authUrl);
+  if (!state || !expected || state !== expected.state)
+    return startOver();
+  const token = await exchangeAuthCode(options.auth, code, url.origin, expected.verifier);
+  if (!token)
+    return startOver();
+  const payload = await options.validate(token);
+  if (!payload)
+    return startOver();
+  const scopeOrigin = options.scopeOrigin ?? url.origin;
+  if (!hasSiteAccessFor(payload, { audiences: [url.origin, scopeOrigin], scopeOrigin })) {
+    return new Response("You don't have access to this site", { status: 403 });
   }
-  return null;
+  const headers = new Headers({ Location: url.toString() });
+  headers.append("Set-Cookie", makeSessionCookie(options.cookieConfig, token));
+  headers.append("Set-Cookie", stateCookie("", secure, 0));
+  return new Response(null, { status: 302, headers });
+}
+var confirmedAt = new Map;
+var MAX_CONFIRMED = 5000;
+var DEFAULT_REVALIDATE_SECONDS = 300;
+async function revalidateToken(auth, token, local, audience, intervalSeconds = DEFAULT_REVALIDATE_SECONDS) {
+  const last = confirmedAt.get(token);
+  if (last !== undefined && Date.now() - last < intervalSeconds * 1000)
+    return local;
+  const result = await checkTokenRemote(auth, token, audience);
+  if (result.status === "unavailable")
+    return local;
+  confirmedAt.delete(token);
+  if (result.status === "invalid")
+    return null;
+  if (confirmedAt.size >= MAX_CONFIRMED) {
+    const oldest = confirmedAt.keys().next();
+    if (!oldest.done)
+      confirmedAt.delete(oldest.value);
+  }
+  confirmedAt.set(token, Date.now());
+  return result.payload;
+}
+function clearRevalidationCache() {
+  confirmedAt.clear();
 }
 
+// src/middleware.ts
+function getClientIP(request) {
+  return request.headers.get("cf-connecting-ip") ?? request.headers.get("x-forwarded-for")?.split(",")[0]?.trim() ?? "unknown";
+}
+function checkBearerToken(request, expectedToken) {
+  const header = request.headers.get("Authorization") ?? "";
+  const expected = `Bearer ${expectedToken}`;
+  const a = new TextEncoder().encode(header);
+  const b = new TextEncoder().encode(expected);
+  let diff = a.length ^ b.length;
+  for (let i = 0;i < b.length; i++) {
+    diff |= (a[i] ?? 0) ^ (b[i] ?? 0);
+  }
+  return diff === 0;
+}
+async function getAuthUser(request, verifyConfig, cookieConfig, siteOrigin) {
+  const cookieHeader = request.headers.get("Cookie");
+  if (!cookieHeader)
+    return null;
+  const token = extractCookie(cookieHeader, cookieConfig.name);
+  if (!token)
+    return null;
+  const audience = new URL(request.url).origin;
+  const scopeOrigin = siteOrigin ?? audience;
+  const site = { audiences: [audience, scopeOrigin], scopeOrigin };
+  const payload = await validateToken(verifyConfig, token);
+  if (!payload || !hasSiteAccessFor(payload, site))
+    return null;
+  const { revalidate } = verifyConfig;
+  if (!revalidate)
+    return payload;
+  const current = await revalidateToken(publicFetcher(revalidate.authUrl), token, payload, payload.aud ?? audience, revalidate.intervalSeconds);
+  return current && hasSiteAccessFor(current, site) ? current : null;
+}
+async function handleCallback(request, verifyConfig, cookieConfig, exchangeConfig) {
+  const authUrl = exchangeConfig?.authUrl ?? DEFAULT_AUTH_URL;
+  return handleLoginCallback(request, {
+    auth: publicFetcher(authUrl),
+    authUrl,
+    cookieConfig,
+    validate: (token) => validateToken(verifyConfig, token)
+  });
+}
 // src/password.ts
 var SALT_LENGTH = 32;
 var KEY_LENGTH = 64;
-var ITERATIONS = 1e5;
+var STAGE_ITERATIONS = 1e5;
+var ITERATIONS = 600000;
+var MAX_ITERATIONS = 1e7;
+var MAX_PASSWORD_LENGTH = 1024;
+var HEX_REGEX = /^(?:[0-9a-f]{2})+$/;
+var PREFIX = "pbkdf2-sha256";
 function toHex(buffer) {
   return Array.from(new Uint8Array(buffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
@@ -185,98 +440,76 @@ function fromHex(hex) {
   }
   return bytes;
 }
-async function deriveKey(password, salt) {
-  const encoder2 = new TextEncoder;
-  const keyMaterial = await crypto.subtle.importKey("raw", encoder2.encode(password), "PBKDF2", false, ["deriveBits"]);
-  return crypto.subtle.deriveBits({
-    name: "PBKDF2",
-    salt,
-    iterations: ITERATIONS,
-    hash: "SHA-256"
-  }, keyMaterial, KEY_LENGTH * 8);
+async function deriveKey(password, salt, iterations) {
+  let material = new TextEncoder().encode(password);
+  let derived = new ArrayBuffer(0);
+  for (let done = 0;done < iterations; done += STAGE_ITERATIONS) {
+    const keyMaterial = await crypto.subtle.importKey("raw", material, "PBKDF2", false, ["deriveBits"]);
+    derived = await crypto.subtle.deriveBits({ name: "PBKDF2", salt, iterations: STAGE_ITERATIONS, hash: "SHA-256" }, keyMaterial, KEY_LENGTH * 8);
+    material = new Uint8Array(derived);
+  }
+  return derived;
+}
+function parseHash(storedHash) {
+  let iterations = STAGE_ITERATIONS;
+  let saltHex;
+  let keyHex;
+  if (storedHash.startsWith(`${PREFIX}$`)) {
+    const [, rawIterations = "", salt = "", key = ""] = storedHash.split("$");
+    if (!/^[1-9]\d*$/.test(rawIterations))
+      return null;
+    iterations = Number(rawIterations);
+    if (iterations % STAGE_ITERATIONS !== 0 || iterations > MAX_ITERATIONS)
+      return null;
+    saltHex = salt;
+    keyHex = key;
+  } else {
+    const separatorIndex = storedHash.indexOf(":");
+    if (separatorIndex === -1)
+      return null;
+    saltHex = storedHash.substring(0, separatorIndex);
+    keyHex = storedHash.substring(separatorIndex + 1);
+  }
+  if (!HEX_REGEX.test(saltHex) || !HEX_REGEX.test(keyHex))
+    return null;
+  return { iterations, salt: fromHex(saltHex), key: fromHex(keyHex) };
 }
 async function hashPassword(password) {
   const salt = crypto.getRandomValues(new Uint8Array(SALT_LENGTH));
-  const derived = await deriveKey(password, salt);
-  return `${toHex(salt.buffer)}:${toHex(derived)}`;
+  const derived = await deriveKey(password, salt, ITERATIONS);
+  return `${PREFIX}$${ITERATIONS}$${toHex(salt.buffer)}$${toHex(derived)}`;
 }
 async function verifyPassword(password, storedHash) {
-  const separatorIndex = storedHash.indexOf(":");
-  if (separatorIndex === -1)
+  const parsed = parseHash(storedHash);
+  if (!parsed)
     return false;
-  const saltHex = storedHash.substring(0, separatorIndex);
-  const keyHex = storedHash.substring(separatorIndex + 1);
-  const salt = fromHex(saltHex);
-  const expectedKey = fromHex(keyHex);
-  const derived = new Uint8Array(await deriveKey(password, salt));
-  if (derived.length !== expectedKey.length)
+  const derived = new Uint8Array(await deriveKey(password, parsed.salt, parsed.iterations));
+  if (derived.length !== parsed.key.length)
     return false;
   let diff = 0;
   for (let i = 0;i < derived.length; i++) {
-    diff |= (derived[i] ?? 0) ^ (expectedKey[i] ?? 0);
+    diff |= (derived[i] ?? 0) ^ (parsed.key[i] ?? 0);
   }
   return diff === 0;
 }
-
-// src/users.ts
-var EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-function isValidEmail(email) {
-  return email.length <= 254 && EMAIL_REGEX.test(email);
-}
-async function createUser(store, input) {
-  if (!isValidEmail(input.email))
-    throw new Error("Invalid email address");
-  const existing = await store.getUserByEmail(input.email);
-  if (existing)
-    throw new Error(`User with email ${input.email} already exists`);
-  const now = new Date().toISOString();
-  const passwordHash = input.password ? await hashPassword(input.password) : await hashPassword(crypto.randomUUID());
-  const user = {
-    id: crypto.randomUUID(),
-    email: input.email.toLowerCase(),
-    name: input.name,
-    passwordHash,
-    isAdmin: input.isAdmin ?? false,
-    emailVerified: input.isAdmin ?? false,
-    totpSecret: null,
-    totpEnabled: false,
-    createdAt: now,
-    updatedAt: now
-  };
-  await store.saveUser(user);
-  return user;
-}
-async function verifyUserCredentials(store, email, password) {
-  const user = await store.getUserByEmail(email.toLowerCase());
-  if (!user)
-    return null;
-  const valid = await verifyPassword(password, user.passwordHash);
-  return valid ? user : null;
+function needsRehash(storedHash) {
+  return !storedHash.startsWith(`${PREFIX}$`) || (parseHash(storedHash)?.iterations ?? 0) < ITERATIONS;
 }
-async function updateName(store, userId, name) {
-  const user = await store.getUser(userId);
-  if (!user)
-    throw new Error(`User ${userId} not found`);
-  const updated = {
-    ...user,
-    name,
-    updatedAt: new Date().toISOString()
-  };
-  await store.saveUser(updated);
+// src/rate-limit.ts
+async function consumeRateLimit(store, key, config) {
+  const entry = store.increment ? await store.increment(key, config.windowSeconds) : await incrementViaGetSet(store, key, config);
+  if (entry.attempts <= config.maxAttempts)
+    return { blocked: false };
+  const remaining = config.windowSeconds - Math.floor((Date.now() - entry.firstAttempt) / 1000);
+  return { blocked: true, remainingSeconds: Math.max(remaining, 1) };
 }
-async function changePassword(store, userId, newPassword) {
-  const user = await store.getUser(userId);
-  if (!user)
-    throw new Error(`User ${userId} not found`);
-  const updated = {
-    ...user,
-    passwordHash: await hashPassword(newPassword),
-    updatedAt: new Date().toISOString()
-  };
-  await store.saveUser(updated);
+async function incrementViaGetSet(store, key, config) {
+  const existing = await store.get(key);
+  const windowOver = existing !== null && Date.now() - existing.firstAttempt >= config.windowSeconds * 1000;
+  const entry = existing && !windowOver ? { attempts: existing.attempts + 1, firstAttempt: existing.firstAttempt } : { attempts: 1, firstAttempt: Date.now() };
+  await store.set(key, entry, config.windowSeconds);
+  return entry;
 }
-
-// src/rate-limit.ts
 async function checkRateLimit(store, key, config) {
   const entry = await store.get(key);
   if (!entry)
@@ -292,6 +525,10 @@ async function checkRateLimit(store, key, config) {
   return { blocked: false };
 }
 async function recordFailedAttempt(store, key, config) {
+  if (store.increment) {
+    await store.increment(key, config.windowSeconds);
+    return;
+  }
   const entry = await store.get(key);
   if (entry) {
     await store.set(key, { attempts: entry.attempts + 1, firstAttempt: entry.firstAttempt }, config.windowSeconds);
@@ -302,7 +539,6 @@ async function recordFailedAttempt(store, key, config) {
 async function clearRateLimit(store, key) {
   await store.delete(key);
 }
-
 // src/totp.ts
 var TOTP_PERIOD = 30;
 var TOTP_DIGITS = 6;
@@ -380,17 +616,21 @@ async function currentTotpCode(secret, nowMs = Date.now()) {
   const step = Math.floor(nowMs / 1000 / TOTP_PERIOD);
   return generateCode(secret, step);
 }
-async function verifyTotpCode(secret, code) {
-  if (code.length !== TOTP_DIGITS)
-    return false;
-  const now = Math.floor(Date.now() / 1000);
-  const currentStep = Math.floor(now / TOTP_PERIOD);
+async function verifyTotpStep(secret, code, nowMs = Date.now()) {
+  if (!/^\d{6}$/.test(code))
+    return null;
+  const currentStep = Math.floor(nowMs / 1000 / TOTP_PERIOD);
+  let matched = null;
   for (let offset = -TOTP_WINDOW;offset <= TOTP_WINDOW; offset++) {
-    const expected = await generateCode(secret, currentStep + offset);
+    const step = currentStep + offset;
+    const expected = await generateCode(secret, step);
     if (timingSafeEqual(code, expected))
-      return true;
+      matched = step;
   }
-  return false;
+  return matched;
+}
+async function verifyTotpCode(secret, code) {
+  return await verifyTotpStep(secret, code) !== null;
 }
 var BACKUP_CODE_COUNT = 10;
 var BACKUP_CODE_LENGTH = 8;
@@ -398,11 +638,14 @@ var BACKUP_CODE_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789";
 function generateBackupCodes() {
   const codes = [];
   for (let i = 0;i < BACKUP_CODE_COUNT; i++) {
-    const bytes = new Uint8Array(BACKUP_CODE_LENGTH);
-    crypto.getRandomValues(bytes);
     let code = "";
-    for (const byte of bytes) {
-      code += BACKUP_CODE_CHARS[byte % BACKUP_CODE_CHARS.length];
+    while (code.length < BACKUP_CODE_LENGTH) {
+      const bytes = new Uint8Array(BACKUP_CODE_LENGTH);
+      crypto.getRandomValues(bytes);
+      for (const byte of bytes) {
+        if (byte < 252 && code.length < BACKUP_CODE_LENGTH)
+          code += BACKUP_CODE_CHARS[byte % BACKUP_CODE_CHARS.length];
+      }
     }
     codes.push(code);
   }
@@ -422,32 +665,109 @@ function timingSafeEqual(a, b) {
   }
   return result === 0;
 }
+// src/users.ts
+var EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+function isValidEmail(email) {
+  return email.length <= 254 && EMAIL_REGEX.test(email);
+}
+async function createUser(store, input) {
+  if (!isValidEmail(input.email))
+    throw new Error("Invalid email address");
+  if (input.password !== undefined && input.password.length > MAX_PASSWORD_LENGTH)
+    throw new Error("Password is too long");
+  const existing = await store.getUserByEmail(input.email);
+  if (existing)
+    throw new Error(`User with email ${input.email} already exists`);
+  const now = new Date().toISOString();
+  const passwordHash = input.password ? await hashPassword(input.password) : await hashPassword(crypto.randomUUID());
+  const user = {
+    id: crypto.randomUUID(),
+    email: input.email.toLowerCase(),
+    name: input.name,
+    passwordHash,
+    isAdmin: input.isAdmin ?? false,
+    emailVerified: input.isAdmin ?? false,
+    totpSecret: null,
+    totpEnabled: false,
+    createdAt: now,
+    updatedAt: now
+  };
+  await store.saveUser(user);
+  return user;
+}
+var dummyHash = null;
+async function verifyUserCredentials(store, email, password) {
+  const user = await store.getUserByEmail(email.toLowerCase());
+  if (!user) {
+    dummyHash ??= hashPassword(crypto.randomUUID());
+    await verifyPassword(password, await dummyHash);
+    return null;
+  }
+  const valid = await verifyPassword(password, user.passwordHash);
+  if (!valid)
+    return null;
+  if (!needsRehash(user.passwordHash))
+    return user;
+  const upgraded = { ...user, passwordHash: await hashPassword(password), updatedAt: new Date().toISOString() };
+  await store.saveUser(upgraded);
+  return upgraded;
+}
+async function updateName(store, userId, name) {
+  const user = await store.getUser(userId);
+  if (!user)
+    throw new Error(`User ${userId} not found`);
+  const updated = {
+    ...user,
+    name,
+    updatedAt: new Date().toISOString()
+  };
+  await store.saveUser(updated);
+}
+async function changePassword(store, userId, newPassword) {
+  if (newPassword.length > MAX_PASSWORD_LENGTH)
+    throw new Error("Password is too long");
+  const user = await store.getUser(userId);
+  if (!user)
+    throw new Error(`User ${userId} not found`);
+  const updated = {
+    ...user,
+    passwordHash: await hashPassword(newPassword),
+    updatedAt: new Date().toISOString()
+  };
+  await store.saveUser(updated);
+}
 export {
-  verifyUserCredentials,
-  verifyTotpCode,
-  verifyPassword,
-  validateToken,
-  redirectToLogin,
-  recordFailedAttempt,
-  makeSessionCookie,
-  makeClearCookie,
-  isValidEmail,
-  importPublicKey,
-  importPrivateKey,
-  hashPassword,
-  hashBackupCode,
-  getTotpUri,
-  getClientIP,
-  getAuthUser,
-  generateTotpSecret,
-  generateKeyPair,
-  generateBackupCodes,
-  extractCookie,
-  createUser,
-  createToken,
-  clearRateLimit,
-  checkRateLimit,
-  checkBearerToken,
+  MAX_PASSWORD_LENGTH,
+  base32Encode,
   changePassword,
-  base32Encode
+  checkBearerToken,
+  checkRateLimit,
+  clearRateLimit,
+  consumeRateLimit,
+  createToken,
+  createUser,
+  extractCookie,
+  generateBackupCodes,
+  generateKeyPair,
+  generateTotpSecret,
+  getAuthUser,
+  getClientIP,
+  getTotpUri,
+  hasSiteAccess,
+  hashBackupCode,
+  hashPassword,
+  importPrivateKey,
+  importPublicKey,
+  isTokenPayload,
+  isValidEmail,
+  makeClearCookie,
+  makeSessionCookie,
+  needsRehash,
+  recordFailedAttempt,
+  redirectToLogin,
+  validateToken,
+  verifyPassword,
+  verifyTotpCode,
+  verifyTotpStep,
+  verifyUserCredentials
 };