import { createPublicKey, verify, type JsonWebKey, type KeyObject } from 'node:crypto'; // eom.dev accounts through Dex. WikiDeck is a *public* OIDC client (PKCE, no secret). // The node performs the code exchange because Dex sends no CORS headers; it then // verifies the ID token against Dex's JWKS. No Dex credentials live on the node. export type OidcConfig = { issuer: string; clientId: string; scopes: string; /** Exact redirect URIs the node will pass to Dex (Dex enforces its own allowlist too). */ redirectUris: string[]; /** Allowed clock skew, seconds. */ skew: number; }; export function oidcConfig(env: NodeJS.ProcessEnv = process.env): OidcConfig { const issuer = env.WIKIDECK_OIDC_ISSUER ?? 'https://dex.eom.dev/'; const redirectUris = (env.WIKIDECK_OIDC_REDIRECT_URIS ?? 'http://192.168.1.32:3101/auth/callback,http://192.168.1.32:3102/auth/callback,' + 'http://192.168.1.32:3103/auth/callback,dev.eom.wikideck:/oauth/callback') .split(',').map(s => s.trim()).filter(Boolean); return { issuer, clientId: env.WIKIDECK_OIDC_CLIENT_ID ?? 'wikideck', scopes: 'openid profile email groups', redirectUris, skew: 60 }; } export type Discovery = { issuer: string; authorization_endpoint: string; token_endpoint: string; jwks_uri: string }; export type IdClaims = { iss: string; sub: string; aud: string | string[]; exp: number; iat: number; nbf?: number; azp?: string; nonce?: string; name?: string; preferred_username?: string; email?: string; email_verified?: boolean; groups?: string[]; }; export class TokenError extends Error { readonly status = 401; } const b64url = (s: string) => Buffer.from(s, 'base64url'); function decodeJson(part: string): Record { if (!/^[A-Za-z0-9_-]+$/.test(part)) throw new TokenError('Malformed token'); const value = JSON.parse(b64url(part).toString('utf8')); if (!value || typeof value !== 'object' || Array.isArray(value)) throw new TokenError('Malformed token'); return value as Record; } /** Fetches and caches the discovery document and JWKS; refreshes keys on an unknown kid (rotation). */ export class DexKeys { private discovery?: Promise; private keys = new Map(); private fetchedAt = 0; readonly config: OidcConfig; private readonly fetcher: typeof fetch; private readonly now: () => number; constructor(config: OidcConfig, fetcher: typeof fetch = fetch, now: () => number = Date.now) { this.config = config; this.fetcher = fetcher; this.now = now; } async meta(): Promise { this.discovery ??= (async () => { const url = new URL('.well-known/openid-configuration', this.config.issuer.endsWith('/') ? this.config.issuer : this.config.issuer + '/'); const res = await this.fetcher(url, { signal: AbortSignal.timeout(8000) }); if (!res.ok) throw new Error('OIDC discovery failed'); const doc = await res.json() as Discovery; // Issuer in discovery must match exactly (OIDC Discovery ยง4.3). if (doc.issuer !== this.config.issuer) throw new Error('OIDC discovery issuer mismatch'); return doc; })().catch(e => { this.discovery = undefined; throw e; }); return this.discovery; } async key(kid: string): Promise { const cached = this.keys.get(kid); if (cached) return cached; // Rate-limit refetches so random kids can't hammer Dex. if (this.now() - this.fetchedAt < 30_000 && this.keys.size) return undefined; await this.refresh(); return this.keys.get(kid); } async refresh(): Promise { const { jwks_uri } = await this.meta(); const res = await this.fetcher(jwks_uri, { signal: AbortSignal.timeout(8000) }); if (!res.ok) throw new Error('JWKS fetch failed'); const { keys } = await res.json() as { keys: (JsonWebKey & { kid?: string; use?: string; alg?: string })[] }; const next = new Map(); for (const jwk of keys ?? []) { if (!jwk.kid || jwk.kty !== 'RSA' || (jwk.use && jwk.use !== 'sig') || (jwk.alg && jwk.alg !== 'RS256')) continue; try { next.set(jwk.kid, createPublicKey({ key: jwk, format: 'jwk' })); } catch { /* skip bad key */ } } this.keys = next; this.fetchedAt = this.now(); } } /** * Verifies a compact JWS ID token: RS256 only, signature against JWKS, exact issuer, * audience contains our client (azp must be us when there are several), exp/nbf/iat with skew, * and the nonce when one is expected. */ export async function verifyIdToken(token: string, keys: Pick, config: OidcConfig, opts: { now?: number; nonce?: string } = {}): Promise { if (typeof token !== 'string' || token.length > 8192) throw new TokenError('Malformed token'); const parts = token.split('.'); if (parts.length !== 3) throw new TokenError('Malformed token'); let header: Record, claims: Record; try { header = decodeJson(parts[0]); claims = decodeJson(parts[1]); } catch (e) { throw e instanceof TokenError ? e : new TokenError('Malformed token'); } if (header.alg !== 'RS256') throw new TokenError('Unsupported token algorithm'); if (typeof header.kid !== 'string') throw new TokenError('Token key id missing'); const key = await keys.key(header.kid); if (!key) throw new TokenError('Unknown token signing key'); if (!/^[A-Za-z0-9_-]+$/.test(parts[2]) || !verify('sha256', Buffer.from(`${parts[0]}.${parts[1]}`), key, b64url(parts[2]))) throw new TokenError('Invalid token signature'); const now = Math.floor((opts.now ?? Date.now()) / 1000); if (claims.iss !== config.issuer) throw new TokenError('Wrong token issuer'); const aud = Array.isArray(claims.aud) ? claims.aud : [claims.aud]; if (!aud.includes(config.clientId)) throw new TokenError('Wrong token audience'); if (aud.length > 1 && claims.azp !== config.clientId) throw new TokenError('Wrong token authorized party'); if (typeof claims.sub !== 'string' || !claims.sub || claims.sub.length > 512) throw new TokenError('Token subject missing'); if (typeof claims.exp !== 'number' || now - config.skew >= claims.exp) throw new TokenError('Token expired'); if (typeof claims.iat !== 'number' || claims.iat > now + config.skew) throw new TokenError('Token issued in the future'); if (typeof claims.nbf === 'number' && claims.nbf > now + config.skew) throw new TokenError('Token not yet valid'); if (opts.nonce !== undefined && claims.nonce !== opts.nonce) throw new TokenError('Token nonce mismatch'); return claims as unknown as IdClaims; } /** Authorization-code exchange as a public client (no secret), with the PKCE verifier. */ export async function exchangeCode(keys: DexKeys, input: { code: string; codeVerifier: string; redirectUri: string }, fetcher: typeof fetch = fetch): Promise<{ idToken: string }> { const { token_endpoint } = await keys.meta(); const res = await fetcher(token_endpoint, { method: 'POST', signal: AbortSignal.timeout(10000), headers: { 'Content-Type': 'application/x-www-form-urlencoded', Accept: 'application/json' }, body: new URLSearchParams({ grant_type: 'authorization_code', client_id: keys.config.clientId, code: input.code, code_verifier: input.codeVerifier, redirect_uri: input.redirectUri }) }); const body = await res.json().catch(() => ({})) as { id_token?: string; error?: string }; if (!res.ok || typeof body.id_token !== 'string') throw new TokenError(`Login failed${body.error ? `: ${String(body.error).slice(0, 60)}` : ''}`); return { idToken: body.id_token }; } /** Display name used on leaderboards: the eom.dev username, else name; never the email address. */ export function displayName(claims: Pick): string { const raw = (claims.preferred_username || claims.name || `player-${claims.sub.slice(0, 6)}`).normalize('NFKC'); return raw.replace(/[\u0000-\u001f\u007f]/g, '').trim().slice(0, 48) || 'player'; }