@uln/auth 0.4.2 → 0.6.0

package/dist/flow.js

@@ -0,0 +1,393 @@
+// @bun
+// src/cookie.ts
+function makeSessionCookie(config, token) {
+  const parts = [`${config.name}=${token}`, `Max-Age=${config.maxAgeSeconds}`, "Path=/", "HttpOnly", "SameSite=Lax"];
+  if (config.secure)
+    parts.push("Secure");
+  return parts.join("; ");
+}
+function makeClearCookie(config) {
+  const parts = [`${config.name}=`, "Max-Age=0", "Path=/", "HttpOnly", "SameSite=Lax"];
+  if (config.secure)
+    parts.push("Secure");
+  return parts.join("; ");
+}
+function extractCookie(cookieHeader, name) {
+  const prefix = `${name}=`;
+  for (const cookie of cookieHeader.split(";")) {
+    const trimmed = cookie.trim();
+    if (trimmed.startsWith(prefix)) {
+      return trimmed.substring(prefix.length);
+    }
+  }
+  return null;
+}
+
+// src/token.ts
+var encoder = new TextEncoder;
+function base64urlEncode(data) {
+  let binary = "";
+  for (const byte of data) {
+    binary += String.fromCharCode(byte);
+  }
+  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);
+  for (let i = 0;i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+var ECDSA_PARAMS = { name: "ECDSA", namedCurve: "P-256" };
+var SIGN_PARAMS = { name: "ECDSA", hash: "SHA-256" };
+async function generateKeyPair() {
+  const kid = crypto.randomUUID().slice(0, 8);
+  const keyPair = await crypto.subtle.generateKey(ECDSA_PARAMS, true, ["sign", "verify"]);
+  if (!("privateKey" in keyPair))
+    throw new Error("Expected CryptoKeyPair from ECDSA generateKey");
+  const privateExport = await crypto.subtle.exportKey("jwk", keyPair.privateKey);
+  const publicExport = await crypto.subtle.exportKey("jwk", keyPair.publicKey);
+  if (privateExport instanceof ArrayBuffer || publicExport instanceof ArrayBuffer)
+    throw new Error("Expected JWK from exportKey");
+  return { kid, privateKeyJwk: privateExport, publicKeyJwk: publicExport };
+}
+async function importPrivateKey(jwk) {
+  return crypto.subtle.importKey("jwk", jwk, ECDSA_PARAMS, false, ["sign"]);
+}
+async function importPublicKey(jwk) {
+  return crypto.subtle.importKey("jwk", jwk, ECDSA_PARAMS, false, ["verify"]);
+}
+async function createToken(config, user, options = {}) {
+  const now = options.issuedAt ?? Math.floor(Date.now() / 1000);
+  const payload = {
+    sub: user.id,
+    email: user.email,
+    name: user.name,
+    admin: user.isAdmin,
+    scopes: user.scopes,
+    flags: user.flags,
+    kid: config.kid,
+    iat: now,
+    exp: now + config.maxAgeSeconds,
+    ...user.audience === undefined ? {} : { aud: user.audience }
+  };
+  const payloadB64 = base64urlEncode(encoder.encode(JSON.stringify(payload)));
+  const payloadBytes = encoder.encode(payloadB64);
+  const signature = await crypto.subtle.sign(SIGN_PARAMS, config.privateKey, payloadBytes);
+  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 parts = token.split(".");
+  if (parts.length !== 2)
+    return null;
+  const [payloadB64 = "", sigB64 = ""] = parts;
+  if (!payloadB64 || !sigB64)
+    return null;
+  let decoded;
+  try {
+    decoded = JSON.parse(new TextDecoder().decode(base64urlDecode(payloadB64)));
+  } catch {
+    return null;
+  }
+  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;
+  try {
+    const signatureBytes = base64urlDecode(sigB64);
+    const payloadBytes = encoder.encode(payloadB64);
+    const valid = await crypto.subtle.verify(SIGN_PARAMS, entry.key, signatureBytes, payloadBytes);
+    if (!valid)
+      return null;
+  } catch {
+    return null;
+  }
+  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/remote.ts
+function publicFetcher(authUrl) {
+  return { fetch: (path, init) => fetch(new URL(path, authUrl), init) };
+}
+function bindingFetcher(binding) {
+  return { fetch: (path, init) => binding.fetch(new URL(path, "https://auth").toString(), init) };
+}
+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;
+  }
+}
+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 exchangeAuthCode(auth, code, redirectOrigin, codeVerifier) {
+  const res = await auth.fetch("/api/exchange-code", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(codeVerifier === undefined ? { code, redirectOrigin } : { code, redirectOrigin, codeVerifier })
+  });
+  if (!res.ok)
+    return null;
+  const body = await readJsonObject(res);
+  if (!body || !("token" in body) || typeof body.token !== "string")
+    return null;
+  return body.token;
+}
+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)
+    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 });
+  }
+  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();
+}
+export {
+  CHALLENGE_PARAM,
+  DEFAULT_AUTH_URL,
+  DEFAULT_REVALIDATE_SECONDS,
+  INSECURE_STATE_COOKIE,
+  STATE_COOKIE,
+  STATE_PARAM,
+  clearRevalidationCache,
+  handleLoginCallback,
+  pkceChallenge,
+  redirectToLogin,
+  revalidateToken
+};

package/dist/hono.d.ts

@@ -1,9 +1,15 @@
 import type { Context, MiddlewareHandler } from "hono";
 import type { TokenPayload } from "./types.ts";
+declare module "hono" {
+    interface ContextVariableMap {
+        user: TokenPayload;
+    }
+}
 interface AuthOptions {
     /**
      * Service binding name (e.g. "AUTH"). If provided, validates tokens
      * via the auth worker service binding instead of fetching public keys.
+     * Binding mode also rejects tokens for deleted users and revoked sessions.
      */
     binding?: string;
     /**
@@ -15,18 +21,38 @@ interface AuthOptions {
      * Auth service base URL. Defaults to "https://auth.uln.industries".
      */
     authUrl?: string;
-    /** Cookie name. Defaults to "uln_auth". */
+    /**
+     * Cookie name. Defaults to "__Host-uln_auth": the `__Host-` prefix means only this exact host can set it, so a page on
+     * a sibling subdomain can't plant a session cookie (session fixation / cookie tossing).
+     */
     cookie?: string;
     /** Cookie/token max age in seconds. Defaults to 86400 (24h). */
     maxAge?: number;
+    /**
+     * The registered origin of this site, used for the scope check. Defaults to the request URL's origin.
+     * Set this when the Worker is reached through a different hostname than the one registered in auth.
+     */
+    siteOrigin?: string;
+    /**
+     * Public-key mode only: confirm a locally valid token with the auth service at most this often (seconds, per
+     * token), so password resets, deleted users and removed scopes take effect within this window instead of when the
+     * token expires. If the auth service is unreachable the local result stands. Defaults to 300; 0 disables.
+     */
+    revalidateSeconds?: number;
 }
+/** Test hook: forget cached JWKS. */
+export declare function clearPublicKeyCache(): void;
 /**
  * Hono middleware that handles the full auth flow:
  *
- * 1. If `?code=` in URL → exchange for token, set cookie, redirect to clean URL
- * 2. If session cookie present → validate, set `c.get("user")`
+ * 1. If `?code=` in URL → check it belongs to this browser's login, exchange for token, set cookie, redirect to
+ *    clean URL
+ * 2. If session cookie or `Authorization: Bearer` present → validate, check site access, set `c.get("user")`
  * 3. If unauthenticated → redirect to auth.uln.industries/login
  *
+ * Tokens issued to another origin are rejected. Users without access to this site (not admin, origin not in
+ * `scopes`) get a 403.
+ *
  * Usage:
  * ```ts
  * import { auth } from "@uln/auth/hono";
@@ -45,6 +71,6 @@ interface AuthOptions {
  * ```
  */
 export declare function auth(options?: AuthOptions): MiddlewareHandler;
-/** Type-safe helper to get the authenticated user from context. */
+/** Get the authenticated user from context. Throws if called on a route that `auth()` doesn't cover. */
 export declare function getUser(c: Context): TokenPayload;
 export type { TokenPayload } from "./types.ts";