Files
2026-11-01 15:22:21 -05:00

62 lines
3.9 KiB
JavaScript
Executable File

import { randomBytes } from 'node:crypto';
import * as oidc from 'openid-client';
export function authSettings(env) {
const mode = env.AUTH_MODE || 'demo';
if (!['demo', 'dex'].includes(mode)) throw new Error('AUTH_MODE must be demo or dex.');
if (mode === 'demo' && env.NODE_ENV === 'production') throw new Error('Production requires AUTH_MODE=dex.');
if (mode === 'demo') return { mode };
for (const key of ['DEX_ISSUER', 'DEX_CLIENT_ID', 'DEX_CLIENT_SECRET', 'APP_ORIGIN']) if (!env[key]) throw new Error(`${key} is required in Dex mode.`);
const issuer = new URL(env.DEX_ISSUER), origin = new URL(env.APP_ORIGIN);
if (issuer.protocol !== 'https:' || origin.protocol !== 'https:' || origin.origin !== env.APP_ORIGIN) throw new Error('Dex requires an HTTPS issuer and an exact HTTPS APP_ORIGIN without a trailing slash.');
return { mode, issuer: issuer.href, clientId: env.DEX_CLIENT_ID, secret: env.DEX_CLIENT_SECRET, origin: origin.origin, connector: env.DEX_CONNECTOR_ID || 'ldap' };
}
export class Auth {
constructor(settings, game) { this.settings = settings; this.game = game; this.sessions = new Map(); }
async initialize() {
if (this.settings.mode === 'dex') {
this.config = await oidc.discovery(new URL(this.settings.issuer), this.settings.clientId, this.settings.secret);
if (this.config.serverMetadata().issuer !== this.settings.issuer) throw new Error('Discovered issuer does not match configured Dex issuer.');
// Direct HTTPS token responses otherwise rely on TLS issuer validation.
// Explicitly require JWS verification against Dex's discovered signing keys.
oidc.enableNonRepudiationChecks(this.config);
}
}
cookie(value, age = 28_800) { return `id=${value}; Path=/; HttpOnly; SameSite=Lax; Max-Age=${age}${this.settings.mode === 'dex' ? '; Secure' : ''}`; }
issue(account = null, pending = null) {
this.prune();
if (this.sessions.size >= 1000) throw new Error('Session capacity reached.');
const token = randomBytes(32).toString('base64url');
this.sessions.set(token, { account, pending, expires: Date.now() + (pending ? 600_000 : 28_800_000), last: Date.now() });
return token;
}
prune() { for (const [token, s] of this.sessions) if (s.expires <= Date.now() || s.last + 1_800_000 <= Date.now()) this.sessions.delete(token); }
read(req) {
this.prune();
const token = /(?:^|;\s*)id=([A-Za-z0-9_-]+)/.exec(req.headers.cookie || '')?.[1];
const session = this.sessions.get(token);
if (session) session.last = Date.now();
return { token, session };
}
async login() {
const verifier = oidc.randomPKCECodeVerifier(), state = oidc.randomState(), nonce = oidc.randomNonce();
const token = this.issue(null, { verifier, state, nonce });
const url = oidc.buildAuthorizationUrl(this.config, {
redirect_uri: `${this.settings.origin}/auth/oidc/callback`, scope: 'openid email profile federated:id',
code_challenge: await oidc.calculatePKCECodeChallenge(verifier), code_challenge_method: 'S256', state, nonce,
});
return { token, url: url.href };
}
async callback(req, requestUrl) {
const { token, session } = this.read(req);
if (!session?.pending) throw new Error('Login expired.');
this.sessions.delete(token);
const tokens = await oidc.authorizationCodeGrant(this.config, requestUrl, { pkceCodeVerifier: session.pending.verifier, expectedState: session.pending.state, expectedNonce: session.pending.nonce, idTokenExpected: true });
const claims = tokens.claims();
if (!claims || claims.iss !== this.settings.issuer || claims.email_verified !== true || claims.federated_claims?.connector_id !== this.settings.connector) throw new Error('Unsupported identity.');
const account = this.game.accountForIdentity(claims.iss, claims.sub, claims.name || 'New traveler');
return this.issue(account);
}
}