Authentication

const hash = await Bun.password.hash(password, {
  algorithm: "argon2id",
  memoryCost: 19_456, // KiB (19 MiB)
  timeCost: 2,
});
// "$argon2id$v=19$m=19456,t=2,p=1$<salt>$<hash>"
 
const ok = await Bun.password.verify(password, hash);
// algorithm is read from the hash; bcrypt hashes work too

import {
  randomBytes,
  scrypt,
  timingSafeEqual,
} from "node:crypto";
 
const KEY_LEN = 32;
const PARAMS = {
  N: 2 ** 17,
  r: 8,
  p: 1,
  maxmem: 256 * 1024 * 1024, // default 32 MiB is too small
};
 
function derive(pw: string, salt: Buffer): Promise<Buffer> {
  return new Promise((resolve, reject) => {
    scrypt(pw.normalize("NFKC"), salt, KEY_LEN, PARAMS,
      (err, key) => (err ? reject(err) : resolve(key)));
  });
}
 
export async function hashPassword(pw: string) {
  const salt = randomBytes(16);
  const key = await derive(pw, salt);
  return `scrypt$${salt.toString("base64url")}` +
    `$${key.toString("base64url")}`;
}
 
export async function verifyPassword(
  pw: string,
  stored: string,
): Promise<boolean> {
  const [alg, salt, key] = stored.split("$");
  if (alg !== "scrypt" || !salt || !key) return false;
  const expected = Buffer.from(key, "base64url");
  const saltBuf = Buffer.from(salt, "base64url");
  const actual = await derive(pw, saltBuf);
  return expected.length === actual.length &&
    timingSafeEqual(actual, expected);
}

export async function isBreached(
  pw: string,
): Promise<boolean> {
  const bytes = new TextEncoder().encode(pw);
  const digest = await crypto.subtle.digest("SHA-1", bytes);
  const hex = Array.from(new Uint8Array(digest), (b) =>
    b.toString(16).padStart(2, "0"),
  ).join("").toUpperCase();
 
  const res = await fetch(
    `https://api.pwnedpasswords.com/range/` +
      hex.slice(0, 5),
    { headers: { "Add-Padding": "true" } },
  );
  if (!res.ok) return false; // fail open, but log it
  const suffix = hex.slice(5);
  return (await res.text()).split("\n").some((line) => {
    const [s, count] = line.trim().split(":");
    return s === suffix && count !== "0"; // 0 = padding
  });
}

Set-Cookie: __Host-sid=q3Vx…; Path=/; Max-Age=2592000; HttpOnly; Secure; SameSite=Lax

type Session = {
  id: string; // SHA-256 of the cookie token
  userId: string;
  expiresAt: number;
};
const TTL_MS = 30 * 24 * 60 * 60 * 1000;
 
export function base64url(bytes: Uint8Array): string {
  let bin = "";
  for (const b of bytes) bin += String.fromCharCode(b);
  return btoa(bin)
    .replaceAll("+", "-")
    .replaceAll("/", "_")
    .replace(/=+$/, "");
}
 
async function sha256(text: string): Promise<string> {
  const data = new TextEncoder().encode(text);
  return base64url(
    new Uint8Array(
      await crypto.subtle.digest("SHA-256", data),
    ),
  );
}
 
export async function createSession(userId: string) {
  // 256 random bits; crypto.randomUUID() (122 bits)
  // also fine
  const token = base64url(
    crypto.getRandomValues(new Uint8Array(32)),
  );
  const session: Session = {
    id: await sha256(token), // DB leak does not leak cookies
    userId,
    expiresAt: Date.now() + TTL_MS,
  };
  await store.insert(session);
  return { token, session }; // token goes only in the cookie
}
 
export async function validateSession(token: string) {
  const session = await store.get(await sha256(token));
  if (!session || session.expiresAt <= Date.now()) {
    return null;
  }
  return session;
}
 
export async function invalidateSession(token: string) {
  await store.delete(await sha256(token));
}

export function sessionCookie(token: string): string {
  return new Bun.Cookie("__Host-sid", token, {
    path: "/",
    httpOnly: true,
    secure: true,
    sameSite: "lax",
    maxAge: 30 * 24 * 60 * 60, // seconds
  }).toString();
}
 
// logout: same name and attributes, Max-Age=0
export const clearedCookie = new Bun.Cookie(
  "__Host-sid",
  "",
  {
    path: "/",
    httpOnly: true,
    secure: true,
    sameSite: "lax",
    maxAge: 0,
  },
).toString();

import { SignJWT, errors, jwtVerify } from "jose";
 
const ISSUER = "https://auth.example.com";
const AUDIENCE = "https://api.example.com";
// HS256 needs >= 32 random bytes; prefer EdDSA / ES256 keys
const secret = new TextEncoder().encode(
  process.env.JWT_SECRET,
);
 
export function issueAccessToken(userId: string) {
  return new SignJWT({ scope: "posts:read" })
    .setProtectedHeader({ alg: "HS256", typ: "at+jwt" })
    .setSubject(userId)
    .setIssuer(ISSUER)
    .setAudience(AUDIENCE)
    .setIssuedAt()
    .setExpirationTime("15m")
    .setJti(crypto.randomUUID())
    .sign(secret);
}
 
export async function verifyAccessToken(token: string) {
  try {
    const { payload } = await jwtVerify(token, secret, {
      // allow-list: never trust header
      algorithms: ["HS256"],
      issuer: ISSUER,
      audience: AUDIENCE,
      requiredClaims: ["exp", "sub"],
      clockTolerance: "5s",
    });
    return payload; // JWTPayload: validate further with Zod
  } catch (err) {
    if (err instanceof errors.JWTExpired) return null;
    if (err instanceof errors.JOSEError) return null;
    throw err;
  }
}

import { base64url } from "./session.js";
 
export function randomToken(bytes = 32): string {
  const buf = crypto.getRandomValues(new Uint8Array(bytes));
  return base64url(buf);
}
 
// verifier: 43–128 chars; challenge = base64url(SHA-256)
export async function pkce() {
  const verifier = randomToken(32); // 43 chars
  const hash = await crypto.subtle.digest(
    "SHA-256",
    new TextEncoder().encode(verifier),
  );
  const challenge = base64url(new Uint8Array(hash));
  return { verifier, challenge };
}
 
export async function authorizeUrl(cfg: {
  endpoint: string;
  clientId: string;
  redirectUri: string;
}) {
  const { verifier, challenge } = await pkce();
  const state = randomToken();
  const nonce = randomToken();
  const url = new URL(cfg.endpoint);
  url.search = new URLSearchParams({
    response_type: "code",
    client_id: cfg.clientId,
    redirect_uri: cfg.redirectUri,
    scope: "openid email profile",
    state,
    nonce,
    code_challenge: challenge,
    code_challenge_method: "S256",
  }).toString();
  return { url, saved: { verifier, state, nonce } };
}

import { createRemoteJWKSet, jwtVerify } from "jose";
import { z } from "zod";
 
const TokenResponse = z.object({
  access_token: z.string(),
  token_type: z.string(),
  expires_in: z.number().optional(),
  refresh_token: z.string().optional(),
  id_token: z.string(),
});
 
const ISSUER = "https://accounts.example.com";
const CLIENT_ID = "my-client";
const JWKS = createRemoteJWKSet(
  new URL(`${ISSUER}/.well-known/jwks.json`),
);
 
type Saved = {
  verifier: string;
  state: string;
  nonce: string;
};
 
export async function callback(url: URL, saved: Saved) {
  if (url.searchParams.get("state") !== saved.state) {
    throw new Error("state mismatch");
  }
  const code = url.searchParams.get("code");
  if (!code) throw new Error("authorization failed");
 
  const res = await fetch(`${ISSUER}/oauth/token`, {
    method: "POST",
    body: new URLSearchParams({
      grant_type: "authorization_code",
      code,
      redirect_uri: "https://app.example.com/callback",
      client_id: CLIENT_ID,
      code_verifier: saved.verifier,
    }),
  });
  if (!res.ok) {
    throw new Error(`token endpoint ${res.status}`);
  }
  const tokens = TokenResponse.parse(await res.json());
 
  const { payload } = await jwtVerify(
    tokens.id_token,
    JWKS,
    {
      issuer: ISSUER,
      audience: CLIENT_ID,
    },
  );
  if (payload.nonce !== saved.nonce) {
    throw new Error("nonce mismatch");
  }
  return { subject: payload.sub, tokens };
}

export async function registerPasskey(): Promise<void> {
  const res = await fetch("/webauthn/register/options", {
    method: "POST",
  });
  const json: PublicKeyCredentialCreationOptionsJSON =
    await res.json();
  const publicKey =
    PublicKeyCredential.parseCreationOptionsFromJSON(json);
  const cred = await navigator.credentials.create({
    publicKey,
  });
  if (!(cred instanceof PublicKeyCredential)) {
    throw new Error("Passkey creation canceled");
  }
  await fetch("/webauthn/register/verify", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(cred.toJSON()),
  });
}

import {
  type RegistrationResponseJSON,
  type WebAuthnCredential,
  generateRegistrationOptions,
  verifyRegistrationResponse,
} from "@simplewebauthn/server";
 
const rpID = "example.com";
const origin = "https://example.com";
 
type User = {
  id: string;
  email: string;
  passkeys: WebAuthnCredential[];
};
 
export async function registrationOptions(user: User) {
  const options = await generateRegistrationOptions({
    rpName: "Example",
    rpID,
    userName: user.email,
    userID: new TextEncoder().encode(user.id),
    attestationType: "none",
    excludeCredentials: user.passkeys.map((p) => ({
      id: p.id,
      transports: p.transports,
    })),
    authenticatorSelection: {
      residentKey: "preferred",
      userVerification: "preferred",
    },
  });
  await challenges.set(user.id, options.challenge);
  return options; // JSON to the browser
}
 
export async function verifyRegistration(
  user: User,
  response: RegistrationResponseJSON,
): Promise<boolean> {
  const result = await verifyRegistrationResponse({
    response,
    expectedChallenge: await challenges.take(user.id),
    expectedOrigin: origin,
    expectedRPID: rpID,
  });
  if (result.verified) {
    const { credential } = result.registrationInfo;
    // persist id, publicKey, counter, transports
    await passkeys.save(user.id, credential);
  }
  return result.verified;
}

otpauth://totp/Example:alice@example.com?secret=JBSWY3DPEHPK3PXP&issuer=Example

export async function totp(
  secret: Uint8Array<ArrayBuffer>,
  unixMs = Date.now(),
  step = 30,
  digits = 6,
): Promise<string> {
  const counter = new DataView(new ArrayBuffer(8));
  const t = Math.floor(unixMs / 1000 / step);
  counter.setBigUint64(0, BigInt(t)); // 8-byte big-endian
  const key = await crypto.subtle.importKey(
    "raw",
    secret,
    { name: "HMAC", hash: "SHA-1" },
    false,
    ["sign"],
  );
  const mac = new Uint8Array(
    await crypto.subtle.sign("HMAC", key, counter),
  );
  // RFC 4226 dynamic truncation
  const offset = mac[mac.length - 1]! & 0x0f;
  const bin =
    new DataView(mac.buffer).getUint32(offset) & 0x7fffffff;
  return String(bin % 10 ** digits).padStart(digits, "0");
}

const SAFE = new Set(["GET", "HEAD", "OPTIONS"]);
const ALLOWED = new Set(["https://app.example.com"]);
 
export function isSameOriginRequest(req: Request): boolean {
  if (SAFE.has(req.method)) return true;
  const site = req.headers.get("sec-fetch-site");
  if (site) return site === "same-origin" || site === "none";
  const origin = req.headers.get("origin"); // older browsers
  return origin !== null && ALLOWED.has(origin);
}

export const PERMISSIONS = [
  "post:read",
  "post:write",
  "post:delete",
  "user:manage",
] as const;
export type Permission = (typeof PERMISSIONS)[number];
 
export const ROLES = {
  viewer: ["post:read"],
  editor: ["post:read", "post:write"],
  admin: PERMISSIONS,
} as const satisfies Record<string, readonly Permission[]>;
export type Role = keyof typeof ROLES;
 
export function hasPermission(role: Role, p: Permission) {
  const granted: readonly Permission[] = ROLES[role];
  return granted.includes(p);
}
 
// @ts-expect-error: "post:publish" is not a Permission
hasPermission("editor", "post:publish");

type User = {
  id: string;
  role: "viewer" | "editor" | "admin";
};
type Post = { id: string; authorId: string };
 
type Policies = {
  "post:update": Post;
  "post:delete": Post;
  "user:list": null;
};
 
const policies: {
  [A in keyof Policies]: (
    u: User,
    r: Policies[A],
  ) => boolean;
} = {
  "post:update": (u, post) =>
    u.role === "admin" || post.authorId === u.id,
  "post:delete": (u) => u.role === "admin",
  "user:list": (u) => u.role === "admin",
};
 
export class ForbiddenError extends Error {}
 
export function authorize<A extends keyof Policies>(
  user: User,
  action: A,
  resource: Policies[A],
): void {
  if (!policies[action](user, resource)) {
    throw new ForbiddenError(action);
  }
}

import { z } from "zod";
 
// branded IDs: a plain string or a PostId is not a UserId
export const UserId = z.uuid().brand<"UserId">();
export type UserId = z.infer<typeof UserId>;
 
export type User = {
  id: UserId;
  email: string;
  role: "viewer" | "editor" | "admin";
};
 
export type AuthState =
  | { status: "loading" }
  | { status: "anonymous" }
  | { status: "mfa_required"; challengeId: string }
  | { status: "authenticated"; user: User; expiresAt: Date };
 
// validate claims instead of casting JWTPayload
export const AccessClaims = z.object({
  iss: z.literal("https://auth.example.com"),
  sub: UserId,
  aud: z.union([z.string(), z.array(z.string())]),
  exp: z.number().int(),
  scope: z.string().transform((s) => s.split(" ")),
});
export type AccessClaims = z.infer<typeof AccessClaims>;
 
export function greeting(state: AuthState): string {
  switch (state.status) {
    case "authenticated":
      return `Hi ${state.user.email}`; // user is narrowed
    case "mfa_required":
      return "Enter your code";
    case "loading":
    case "anonymous":
      return "Sign in";
  }
}
 
type Authed = Extract<
  AuthState,
  { status: "authenticated" }
>;
 
export function assertAuthed(
  state: AuthState,
): asserts state is Authed {
  if (state.status !== "authenticated") {
    throw new Error("Not authenticated");
  }
}