From 86fe6bffd3b897cb1c74bca7d7d2a9bf779ad36c Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 16 Nov 2026 22:55:51 -0500 Subject: [PATCH] eom.dev accounts: Dex OIDC login (PKCE) and wallet linking - server/account: JWKS-verified Dex ID tokens (RS256, exact issuer, audience/azp, exp/iat/nbf with skew, nonce), node-side code exchange as the public client "wikideck" (Dex sends no CORS headers), and an off-chain SQLite account <-> wallet store. Wallet ownership is proved by signing a single-use, domain-tagged off-chain challenge with the existing P-256 wallet key; consensus verifySignature is reused read-only. - Routes under /api/account: config, token, me, challenge, link, DELETE link/:address, names (leaderboard display names, never email). - src/auth: PKCE S256 client, sessionStorage-only tokens, LoginButton with initials avatar, wallet link, Capacitor system-browser + custom-scheme redirect support (completeLogin for appUrlOpen). - Hooks: one import + one app.use in server/testnet/http.ts (no CSP change), one import + one element in src/App.tsx. - tests/account-oidc and tests/account-link. Co-Authored-By: Claude Opus 5.5 --- server/account/oidc.ts | 142 +++++++++++++++++++++++++++++++++++++ server/account/router.ts | 98 +++++++++++++++++++++++++ server/account/store.ts | 92 ++++++++++++++++++++++++ server/testnet/http.ts | 2 + src/App.tsx | 3 +- src/auth/LoginButton.tsx | 76 ++++++++++++++++++++ src/auth/auth.css | 11 +++ src/auth/session.ts | 131 ++++++++++++++++++++++++++++++++++ tests/account-link.test.ts | 128 +++++++++++++++++++++++++++++++++ tests/account-oidc.test.ts | 88 +++++++++++++++++++++++ 10 files changed, 770 insertions(+), 1 deletion(-) create mode 100644 server/account/oidc.ts create mode 100644 server/account/router.ts create mode 100644 server/account/store.ts create mode 100644 src/auth/LoginButton.tsx create mode 100644 src/auth/auth.css create mode 100644 src/auth/session.ts create mode 100644 tests/account-link.test.ts create mode 100644 tests/account-oidc.test.ts diff --git a/server/account/oidc.ts b/server/account/oidc.ts new file mode 100644 index 0000000..1f97fc5 --- /dev/null +++ b/server/account/oidc.ts @@ -0,0 +1,142 @@ +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,' + + 'http://127.0.0.1:5173/auth/callback,http://localhost:5173/auth/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; never the email address. */ +export function displayName(claims: Pick): string { + const raw = (claims.name || claims.preferred_username || `player-${claims.sub.slice(0, 6)}`).normalize('NFKC'); + return raw.replace(/[\u0000-\u001f\u007f]/g, '').trim().slice(0, 48) || 'player'; +} diff --git a/server/account/router.ts b/server/account/router.ts new file mode 100644 index 0000000..9fe0530 --- /dev/null +++ b/server/account/router.ts @@ -0,0 +1,98 @@ +import { Router, type Request, type Response, type NextFunction } from 'express'; +import { resolve } from 'node:path'; +import { z } from 'zod'; +import { DexKeys, TokenError, displayName, exchangeCode, oidcConfig, verifyIdToken, type OidcConfig } from './oidc.ts'; +import { AccountStore, LinkError, type Account } from './store.ts'; + +// Mounted at /api/account by server/testnet/http.ts. Body parsing, the POST origin check, +// rate limits and no-store caching come from the /api middleware there. +export type AccountDeps = { config?: OidcConfig; keys?: DexKeys; store?: AccountStore; dataDir?: string; + fetcher?: typeof fetch; now?: () => number }; + +type Authed = Request & { account?: Account }; +const hex64 = z.string().regex(/^[a-f0-9]{64}$/); + +export function createAccountRouter(deps: AccountDeps = {}): Router { + const config = deps.config ?? oidcConfig(); + const now = deps.now ?? Date.now; + const keys = deps.keys ?? new DexKeys(config, deps.fetcher, now); + const store = deps.store ?? new AccountStore(resolve(deps.dataDir ?? 'data', 'accounts.sqlite'), now); + const router = Router(); + + const toAccount = (claims: Awaited>): Account => + ({ sub: claims.sub, issuer: claims.iss, name: displayName(claims), username: claims.preferred_username ?? '' }); + + const auth = async (req: Authed, _res: Response, next: NextFunction) => { + try { + const m = /^Bearer ([A-Za-z0-9_.-]+)$/.exec(req.get('authorization') ?? ''); + if (!m) throw new TokenError('Log in with your eom.dev account'); + req.account = toAccount(await verifyIdToken(m[1], keys, config, { now: now() })); + store.upsert(req.account); + next(); + } catch (e) { next(e); } + }; + + // Public, so the browser builds the authorize URL without fetching Dex (no CSP/CORS change). + router.get('/config', async (_req, res, next) => { + try { + const meta = await keys.meta(); + res.json({ issuer: config.issuer, clientId: config.clientId, scopes: config.scopes, + authorizationEndpoint: meta.authorization_endpoint, redirectUris: config.redirectUris }); + } catch (e) { next(e); } + }); + + router.post('/token', async (req, res, next) => { + try { + const body = z.object({ code: z.string().min(1).max(512), codeVerifier: z.string().regex(/^[A-Za-z0-9._~-]{43,128}$/), + redirectUri: z.string().max(256), nonce: z.string().min(16).max(128) }).strict().parse(req.body); + if (!config.redirectUris.includes(body.redirectUri)) throw new LinkError('Redirect URI not allowed'); + const { idToken } = await exchangeCode(keys, body, deps.fetcher); + const claims = await verifyIdToken(idToken, keys, config, { now: now(), nonce: body.nonce }); + const account = toAccount(claims); + store.upsert(account); + res.json({ idToken, expiresAt: claims.exp * 1000, account: { ...account, wallets: store.wallets(account.sub) } }); + } catch (e) { next(e); } + }); + + router.get('/me', auth, (req: Authed, res) => { + const a = req.account!; + res.json({ ...a, wallets: store.wallets(a.sub) }); + }); + + router.post('/challenge', auth, (req: Authed, res, next) => { + try { + const { address } = z.object({ address: hex64 }).strict().parse(req.body); + res.json(store.challenge(req.account!, address)); + } catch (e) { next(e); } + }); + + // Wallet keys never leave the client: only the public key and a signature arrive here. + router.post('/link', auth, (req: Authed, res, next) => { + try { + const body = z.object({ nonce: z.string().regex(/^[A-Za-z0-9_-]{16,64}$/), address: hex64, + publicKey: z.string().max(256), signature: z.string().max(256) }).strict().parse(req.body); + res.status(201).json(store.link(req.account!, body)); + } catch (e) { next(e); } + }); + + router.delete('/link/:address', auth, (req: Authed, res) => { + const address = String(req.params.address); + if (!/^[a-f0-9]{64}$/.test(address)) { res.status(400).json({ error: 'Invalid wallet address' }); return; } + res.json({ removed: store.unlink(req.account!.sub, address) }); + }); + + // Leaderboards: GET /api/account/names?addresses=a,b,c → { [address]: displayName } + router.get('/names', (req, res) => { + const list = String(req.query.addresses ?? '').split(',').filter(Boolean); + if (list.length > 100 || !list.every(a => /^[a-f0-9]{64}$/.test(a))) { res.status(400).json({ error: 'Invalid addresses' }); return; } + res.json({ names: store.names(list) }); + }); + + router.use((err: Error & { status?: number }, _req: Request, res: Response, _next: NextFunction) => { + if (err instanceof TokenError || err instanceof LinkError) { res.status(err.status).json({ error: err.message }); return; } + if (err instanceof z.ZodError) { res.status(400).json({ error: 'Invalid request' }); return; } + if (/OIDC|JWKS/.test(err.message) || err.name === 'TimeoutError' || err.message === 'fetch failed') { res.status(503).json({ error: 'eom.dev login is temporarily unavailable' }); return; } + res.status(err.status === 413 ? 413 : 400).json({ error: 'Account request failed' }); + }); + return router; +} diff --git a/server/account/store.ts b/server/account/store.ts new file mode 100644 index 0000000..6d5405e --- /dev/null +++ b/server/account/store.ts @@ -0,0 +1,92 @@ +import { DatabaseSync } from 'node:sqlite'; +import { randomBytes } from 'node:crypto'; +import { address as walletAddress, verifySignature } from '../testnet/consensus.ts'; +import { NETWORK } from '../../shared/testnet.ts'; + +// Off-chain account <-> wallet mapping. Nothing here touches the chain or consensus. +export type Account = { sub: string; issuer: string; name: string; username: string }; +export type LinkedWallet = { address: string; linkedAt: number }; + +export const CHALLENGE_TTL_MS = 5 * 60_000; + +/** + * The exact text a wallet signs to prove ownership. An off-chain message with its own + * domain tag, so it can never be confused with a block, transfer or trade signature. + */ +export function linkMessage(c: { issuer: string; sub: string; address: string; nonce: string; expiresAt: number }): string { + return JSON.stringify(['wikideck:account-link:v1', NETWORK, c.issuer, c.sub, c.address, c.nonce, c.expiresAt]); +} + +export class LinkError extends Error { + readonly status: number; + constructor(message: string, status = 400) { super(message); this.status = status; } +} + +export class AccountStore { + private readonly db: DatabaseSync; + private readonly challenges = new Map(); + private readonly now: () => number; + constructor(file: string, now: () => number = Date.now) { + this.now = now; + this.db = new DatabaseSync(file); + this.db.exec(`PRAGMA journal_mode=WAL; + CREATE TABLE IF NOT EXISTS accounts(sub TEXT PRIMARY KEY, issuer TEXT NOT NULL, name TEXT NOT NULL, + username TEXT NOT NULL, updated_at INTEGER NOT NULL); + CREATE TABLE IF NOT EXISTS wallets(address TEXT PRIMARY KEY, sub TEXT NOT NULL REFERENCES accounts(sub), + public_key TEXT NOT NULL, linked_at INTEGER NOT NULL); + CREATE INDEX IF NOT EXISTS wallets_sub ON wallets(sub);`); + } + close() { this.db.close(); } + + upsert(a: Account): void { + this.db.prepare(`INSERT INTO accounts(sub,issuer,name,username,updated_at) VALUES(?,?,?,?,?) + ON CONFLICT(sub) DO UPDATE SET name=excluded.name, username=excluded.username, updated_at=excluded.updated_at`) + .run(a.sub, a.issuer, a.name, a.username, this.now()); + } + + wallets(sub: string): LinkedWallet[] { + return (this.db.prepare('SELECT address, linked_at FROM wallets WHERE sub=? ORDER BY linked_at').all(sub) as + { address: string; linked_at: number }[]).map(r => ({ address: r.address, linkedAt: r.linked_at })); + } + + /** Public leaderboard lookup: display names only, for linked wallets. */ + names(addresses: string[]): Record { + const out: Record = {}; + const q = this.db.prepare('SELECT a.name FROM wallets w JOIN accounts a ON a.sub=w.sub WHERE w.address=?'); + for (const addr of addresses) { const row = q.get(addr) as { name: string } | undefined; if (row) out[addr] = row.name; } + return out; + } + + challenge(account: Account, address: string): { nonce: string; expiresAt: number; message: string } { + if (!/^[a-f0-9]{64}$/.test(address)) throw new LinkError('Invalid wallet address'); + const now = this.now(); + for (const [k, v] of this.challenges) if (v.expiresAt <= now) this.challenges.delete(k); + if (this.challenges.size > 10_000) throw new LinkError('Too many pending link challenges', 503); + const nonce = randomBytes(24).toString('base64url'); + const expiresAt = now + CHALLENGE_TTL_MS; + this.challenges.set(nonce, { sub: account.sub, address, expiresAt }); + return { nonce, expiresAt, message: linkMessage({ issuer: account.issuer, sub: account.sub, address, nonce, expiresAt }) }; + } + + /** Verifies the wallet signature over the challenge; each nonce is single use. */ + link(account: Account, input: { nonce: string; address: string; publicKey: string; signature: string }): LinkedWallet { + const pending = this.challenges.get(input.nonce); + // Consume before verifying: a failed attempt also burns the nonce (no oracle, no replay). + this.challenges.delete(input.nonce); + if (!pending || pending.expiresAt <= this.now()) throw new LinkError('Link challenge expired or already used', 409); + if (pending.sub !== account.sub || pending.address !== input.address) throw new LinkError('Link challenge does not match this account and wallet', 409); + if (walletAddress(input.publicKey) !== input.address) throw new LinkError('Public key does not match the wallet address'); + const message = linkMessage({ issuer: account.issuer, sub: account.sub, address: input.address, nonce: input.nonce, expiresAt: pending.expiresAt }); + if (!verifySignature(input.publicKey, input.address, message, input.signature)) throw new LinkError('Invalid wallet signature', 401); + const owner = this.db.prepare('SELECT sub FROM wallets WHERE address=?').get(input.address) as { sub: string } | undefined; + if (owner && owner.sub !== account.sub) throw new LinkError('This wallet is already linked to another account', 409); + const linkedAt = this.now(); + this.db.prepare('INSERT INTO wallets(address,sub,public_key,linked_at) VALUES(?,?,?,?) ON CONFLICT(address) DO NOTHING') + .run(input.address, account.sub, input.publicKey, linkedAt); + return this.wallets(account.sub).find(w => w.address === input.address)!; + } + + unlink(sub: string, address: string): boolean { + return Number(this.db.prepare('DELETE FROM wallets WHERE sub=? AND address=?').run(sub, address).changes) > 0; + } +} diff --git a/server/testnet/http.ts b/server/testnet/http.ts index d0f2807..272bde9 100644 --- a/server/testnet/http.ts +++ b/server/testnet/http.ts @@ -17,6 +17,7 @@ import { IS_MAINNET, PROFILE } from '../../shared/network.ts'; import { assertLaunchAllowed, launchManifest } from '../launch.ts'; import { resourceConfig, RpcBudget, RpcError } from '../resources.ts'; import { trustedProxies, operationsPort, startOperations } from '../operations.ts'; +import { createAccountRouter } from '../account/router.ts'; const root = fileURLToPath(new URL('../../', import.meta.url)); assertLaunchAllowed(); @@ -149,6 +150,7 @@ app.post('/p2p/transaction',workLimit,async(req,res)=>{ const id=await ledger.submitTransaction(transaction); res.status(202).json({id,status:'pending'}); }); +app.use('/api/account',createAccountRouter({dataDir})); app.use(['/api','/p2p'],(_req,res)=>{res.status(404).json({error:'Unknown testnet endpoint'});}); app.use(express.static(resolve(root,'dist'))); app.get('/{*path}',(_req,res)=>res.sendFile(resolve(root,'dist/index.html'))); diff --git a/src/App.tsx b/src/App.tsx index ca9d178..b98fe80 100644 --- a/src/App.tsx +++ b/src/App.tsx @@ -10,6 +10,7 @@ import { Card, samples, imageCredit, type CardData } from './Card.tsx'; import { WalletPanel } from './WalletPanel.tsx'; import { useModalFocus } from './useModalFocus.ts'; import { ThemePicker } from './ThemePicker.tsx'; +import { LoginButton } from './auth/LoginButton.tsx'; import { TradeDesk } from './TradeDesk.tsx'; import { IS_MAINNET, NETWORK_GENESIS_TIME, NETWORK_LABEL } from '../shared/network.ts'; import { StateClient } from '../shared/rpc-client.ts'; @@ -170,7 +171,7 @@ export default function App() {
-
Explore {view}
RandomX {NETWORK_LABEL}{peerLabel}
+
Explore {view}
RandomX {NETWORK_LABEL}{peerLabel}
RPC {rpcAvailable ? 'available' : 'unavailable'}{peerLabel}{IS_MAINNET?'MAINNET · experimental · unaudited · no value promised':'TESTNET · experimental · no value promised'}{snapshot && !rpcAvailable && Showing last known state}
{error &&
{error}
} diff --git a/src/auth/LoginButton.tsx b/src/auth/LoginButton.tsx new file mode 100644 index 0000000..c8c4da7 --- /dev/null +++ b/src/auth/LoginButton.tsx @@ -0,0 +1,76 @@ +import { useEffect, useState, useSyncExternalStore } from 'react'; +import { Link2, LoaderCircle, LogIn, LogOut, UserRound } from 'lucide-react'; +import { getWallet, subscribeWallet, type Wallet } from '../wallet.ts'; +import { account, completeLogin, isCallback, linkWallet, login, logout, subscribeAuth, type Account } from './session.ts'; +import './auth.css'; + +export function useAccount(): Account | undefined { + return useSyncExternalStore(subscribeAuth, account, () => undefined); +} + +/** Deterministic initials avatar (LDAP accounts have no picture claim; no third-party image hosts). */ +export function Avatar({ name, seed, size = 22 }: { name: string; seed: string; size?: number }) { + let h = 0; for (const c of seed) h = (h * 31 + c.charCodeAt(0)) >>> 0; + const initials = name.split(/\s+/).filter(Boolean).slice(0, 2).map(w => [...w][0]).join('').toUpperCase() || '?'; + return ; +} + +const short = (s: string) => `${s.slice(0, 6)}…${s.slice(-4)}`; + +export function LoginButton() { + const me = useAccount(); + const [busy, setBusy] = useState(false); + const [open, setOpen] = useState(false); + const [notice, setNotice] = useState(''); + const [wallet, setWallet] = useState(); + + useEffect(() => { + if (!isCallback(location.href)) return; + setBusy(true); + completeLogin(location.href) + .then(({ returnTo }) => history.replaceState(null, '', returnTo)) + .catch(e => { history.replaceState(null, '', '/'); setNotice(e instanceof Error ? e.message : 'Login failed'); }) + .finally(() => setBusy(false)); + }, []); + useEffect(() => { + const update = () => { void getWallet().then(setWallet).catch(() => setWallet(undefined)); }; + update(); return subscribeWallet(update); + }, []); + + const run = async (fn: () => Promise) => { + setBusy(true); setNotice(''); + try { await fn(); } catch (e) { setNotice(e instanceof Error ? e.message : 'Request failed'); } + finally { setBusy(false); } + }; + + if (!me) return + + {notice && {notice}} + ; + + const linked = wallet && me.wallets.some(w => w.address === wallet.address); + return + + {open &&
+
+
{me.name}{me.username && @{me.username} · eom.dev}
+
+ LINKED WALLETS + {me.wallets.length ? me.wallets.map(w => {short(w.address)}) :

None yet. Linking shows your name on leaderboards.

} +
+ {linked ?

This wallet is linked.

+ : } + {notice &&

{notice}

} + +
} +
; +} diff --git a/src/auth/auth.css b/src/auth/auth.css new file mode 100644 index 0000000..4a4f175 --- /dev/null +++ b/src/auth/auth.css @@ -0,0 +1,11 @@ +.auth-wrap{position:relative;display:inline-flex;align-items:center;gap:8px} +.auth-avatar{display:inline-grid;place-items:center;border-radius:50%;color:#fff;font-weight:650;flex-shrink:0;line-height:1} +.auth-button .auth-avatar{margin-right:2px} +.auth-menu{position:absolute;top:calc(100% + 8px);right:0;z-index:40;width:280px;padding:14px;border-radius:10px; + background:var(--surface, #fff);color:inherit;border:1px solid rgba(127,127,127,.25);box-shadow:0 12px 32px rgba(0,0,0,.18); + display:flex;flex-direction:column;gap:10px} +.auth-menu-head{display:flex;align-items:center;gap:10px} +.auth-menu-head small,.auth-menu-section small{display:block;opacity:.65;font-size:10px;letter-spacing:.6px} +.auth-menu-section code{display:block;font-size:11px;margin-top:4px} +.auth-menu-section p,.auth-ok{font-size:11px;opacity:.8;margin:4px 0 0;display:flex;align-items:center;gap:6px} +.auth-notice{font-size:11px;max-width:260px} diff --git a/src/auth/session.ts b/src/auth/session.ts new file mode 100644 index 0000000..769592d --- /dev/null +++ b/src/auth/session.ts @@ -0,0 +1,131 @@ +// eom.dev login (Dex, OIDC authorization code + PKCE S256, public client "wikideck"). +// The browser only navigates to Dex. The node exchanges the code and verifies the ID token +// (Dex sends no CORS headers), so there is no browser -> Dex fetch and no CSP change. +// Tokens live in sessionStorage (cleared with the tab), never localStorage. +import { getWallet, sign, type Wallet } from '../wallet.ts'; + +export type LinkedWallet = { address: string; linkedAt: number }; +export type Account = { sub: string; issuer: string; name: string; username: string; wallets: LinkedWallet[] }; +type Session = { idToken: string; expiresAt: number; account: Account }; +type Pending = { state: string; nonce: string; verifier: string; redirectUri: string; returnTo: string; createdAt: number }; +type AuthConfig = { issuer: string; clientId: string; scopes: string; authorizationEndpoint: string; redirectUris: string[] }; + +const SESSION_KEY = 'wikideck.auth.session'; +const PENDING_KEY = 'wikideck.auth.pending'; +export const CALLBACK_PATH = '/auth/callback'; +export const NATIVE_REDIRECT = 'dev.eom.wikideck:/oauth/callback'; + +const listeners = new Set<() => void>(); +let current: Session | undefined = load(); +export function subscribeAuth(fn: () => void): () => void { listeners.add(fn); return () => { listeners.delete(fn); }; } +function notify() { for (const fn of listeners) fn(); } + +function load(): Session | undefined { + try { + const raw = sessionStorage.getItem(SESSION_KEY); + const s = raw ? JSON.parse(raw) as Session : undefined; + return s && s.expiresAt > Date.now() + 30_000 ? s : undefined; + } catch { return undefined; } +} +function save(s: Session | undefined) { + current = s; + try { if (s) sessionStorage.setItem(SESSION_KEY, JSON.stringify(s)); else sessionStorage.removeItem(SESSION_KEY); } catch { /* memory only */ } + notify(); +} +export function account(): Account | undefined { + if (current && current.expiresAt <= Date.now() + 30_000) save(undefined); + return current?.account; +} + +const b64url = (bytes: Uint8Array) => btoa(String.fromCharCode(...bytes)).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, ''); +const random = (n = 32) => b64url(crypto.getRandomValues(new Uint8Array(n))); +export async function pkceChallenge(verifier: string): Promise { + return b64url(new Uint8Array(await crypto.subtle.digest('SHA-256', new TextEncoder().encode(verifier)))); +} + +type CapacitorGlobal = { isNativePlatform?: () => boolean; Plugins?: { Browser?: { open(o: { url: string }): Promise; close?(): Promise } } }; +const capacitor = () => (globalThis as { Capacitor?: CapacitorGlobal }).Capacitor; +export const isNative = () => Boolean(capacitor()?.isNativePlatform?.()); +export function redirectUri(): string { return isNative() ? NATIVE_REDIRECT : `${location.origin}${CALLBACK_PATH}`; } + +async function api(path: string, init: RequestInit & { token?: string } = {}): Promise { + const { token, ...rest } = init; + const res = await fetch(`/api/account/${path}`, { cache: 'no-store', signal: AbortSignal.timeout(15000), ...rest, + headers: { ...(rest.body ? { 'Content-Type': 'application/json' } : {}), ...(token ? { Authorization: `Bearer ${token}` } : {}) } }); + const data = await res.json().catch(() => ({})); + if (res.status === 401 && token) save(undefined); + if (!res.ok) throw new Error(typeof data.error === 'string' ? data.error : 'Account request failed'); + return data as T; +} + +export async function login(returnTo = location.pathname + location.search): Promise { + const config = await api('config'); + const uri = redirectUri(); + if (!config.redirectUris.includes(uri)) throw new Error(`This node is not set up for eom.dev login from ${uri}.`); + const pending: Pending = { state: random(), nonce: random(), verifier: random(48), redirectUri: uri, + returnTo: returnTo.startsWith('/') && !returnTo.startsWith('//') ? returnTo : '/', createdAt: Date.now() }; + sessionStorage.setItem(PENDING_KEY, JSON.stringify(pending)); + const url = new URL(config.authorizationEndpoint); + url.search = new URLSearchParams({ response_type: 'code', client_id: config.clientId, redirect_uri: uri, + scope: config.scopes, state: pending.state, nonce: pending.nonce, + code_challenge: await pkceChallenge(pending.verifier), code_challenge_method: 'S256' }).toString(); + // Capacitor: system browser (never a WebView) + custom-scheme redirect, per RFC 8252. + const browser = capacitor()?.Plugins?.Browser; + if (isNative() && browser) await browser.open({ url: url.toString() }); + else location.assign(url.toString()); +} + +export const isCallback = (url: string) => { + const u = new URL(url); + return (u.pathname === CALLBACK_PATH || url.startsWith(NATIVE_REDIRECT)) && (u.searchParams.has('code') || u.searchParams.has('error')); +}; + +/** Finish a login from the redirect URL. Web: called on load. Capacitor: call from App 'appUrlOpen'. */ +export async function completeLogin(url: string): Promise<{ returnTo: string }> { + const params = new URL(url).searchParams; + const raw = sessionStorage.getItem(PENDING_KEY); + sessionStorage.removeItem(PENDING_KEY); // single use + const pending = raw ? JSON.parse(raw) as Pending : undefined; + if (!pending || Date.now() - pending.createdAt > 10 * 60_000) throw new Error('Login expired. Please try again.'); + if (params.get('state') !== pending.state) throw new Error('Login state mismatch. Please try again.'); + if (params.get('error')) throw new Error(`Login cancelled: ${params.get('error_description') ?? params.get('error')}`.slice(0, 160)); + const code = params.get('code'); + if (!code) throw new Error('Login response had no code.'); + const s = await api('token', { method: 'POST', body: JSON.stringify({ code, codeVerifier: pending.verifier, + redirectUri: pending.redirectUri, nonce: pending.nonce }) }); + save(s); + if (isNative()) void capacitor()?.Plugins?.Browser?.close?.().catch(() => {}); + return { returnTo: pending.returnTo }; +} + +/** Local logout. Dex publishes no end_session endpoint, so the Dex SSO cookie may remain. */ +export function logout(): void { save(undefined); } + +export async function refreshAccount(): Promise { + if (!current) return undefined; + const me = await api('me', { token: current.idToken }); + save({ ...current, account: me }); + return me; +} + +/** Prove wallet ownership: the node issues a one-time challenge; the key signs locally and never leaves the client. */ +export async function linkWallet(wallet?: Wallet): Promise { + if (!current) throw new Error('Log in with your eom.dev account first.'); + const w = wallet ?? await getWallet(); + if (!w) throw new Error('Unlock your wallet first.'); + const token = current.idToken; + const challenge = await api<{ nonce: string; message: string; expiresAt: number }>('challenge', + { method: 'POST', token, body: JSON.stringify({ address: w.address }) }); + const signature = await sign(w, challenge.message); + const linked = await api('link', { method: 'POST', token, + body: JSON.stringify({ nonce: challenge.nonce, address: w.address, publicKey: w.publicKey, signature }) }); + await refreshAccount().catch(() => {}); + return linked; +} + +/** Leaderboard display names for wallet addresses (only linked wallets resolve). */ +export async function displayNames(addresses: string[]): Promise> { + if (!addresses.length) return {}; + const { names } = await api<{ names: Record }>(`names?addresses=${addresses.slice(0, 100).join(',')}`); + return names; +} diff --git a/tests/account-link.test.ts b/tests/account-link.test.ts new file mode 100644 index 0000000..ece0473 --- /dev/null +++ b/tests/account-link.test.ts @@ -0,0 +1,128 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import { generateKeyPairSync, sign } from 'node:crypto'; +import { mkdtemp, rm } from 'node:fs/promises'; +import { tmpdir } from 'node:os'; +import { join } from 'node:path'; +import express from 'express'; +import { address } from '../server/testnet/consensus.ts'; +import { AccountStore, CHALLENGE_TTL_MS, LinkError } from '../server/account/store.ts'; +import { createAccountRouter } from '../server/account/router.ts'; +import { DexKeys, oidcConfig } from '../server/account/oidc.ts'; + +function wallet() { + const keys = generateKeyPairSync('ec', { namedCurve: 'prime256v1' }); + const publicKey = keys.publicKey.export({ type: 'spki', format: 'der' }).toString('base64'); + return { publicKey, address: address(publicKey), sign: (m: string) => + sign('sha256', Buffer.from(m), { key: keys.privateKey, dsaEncoding: 'ieee-p1363' }).toString('base64') }; +} +const ada = { sub: 'user-ada', issuer: 'https://dex.test/', name: 'Ada', username: 'ada' }; +const bob = { sub: 'user-bob', issuer: 'https://dex.test/', name: 'Bob', username: 'bob' }; + +async function withStore(fn: (s: AccountStore, clock: { now: number }) => Promise | void) { + const dir = await mkdtemp(join(tmpdir(), 'wikideck-account-')); + const clock = { now: 1_800_000_000_000 }; + const store = new AccountStore(join(dir, 'accounts.sqlite'), () => clock.now); + try { store.upsert(ada); store.upsert(bob); await fn(store, clock); } + finally { store.close(); await rm(dir, { recursive: true, force: true }); } +} +const code = (fn: () => unknown, status: number) => assert.throws(fn, e => e instanceof LinkError && e.status === status); + +test('account link: a valid wallet signature links the wallet and names resolve', () => withStore(store => { + const w = wallet(); + const c = store.challenge(ada, w.address); + const linked = store.link(ada, { nonce: c.nonce, address: w.address, publicKey: w.publicKey, signature: w.sign(c.message) }); + assert.equal(linked.address, w.address); + assert.deepEqual(store.wallets(ada.sub).map(x => x.address), [w.address]); + assert.deepEqual(store.names([w.address, 'f'.repeat(64)]), { [w.address]: 'Ada' }); +})); + +test('account link: a signature from the wrong key is rejected', () => withStore(store => { + const w = wallet(), attacker = wallet(); + const c = store.challenge(ada, w.address); + // Attacker signs with their own key but claims the victim's address and public key. + code(() => store.link(ada, { nonce: c.nonce, address: w.address, publicKey: w.publicKey, signature: attacker.sign(c.message) }), 401); + // Or presents their own public key for the victim's address. + const c2 = store.challenge(ada, w.address); + code(() => store.link(ada, { nonce: c2.nonce, address: w.address, publicKey: attacker.publicKey, signature: attacker.sign(c2.message) }), 400); + assert.deepEqual(store.wallets(ada.sub), []); +})); + +test('account link: replayed, expired and cross-account challenges are rejected', () => withStore((store, clock) => { + const w = wallet(); + const c = store.challenge(ada, w.address); + const input = { nonce: c.nonce, address: w.address, publicKey: w.publicKey, signature: w.sign(c.message) }; + store.link(ada, input); + code(() => store.link(ada, input), 409); // replay + const c2 = store.challenge(ada, w.address); + clock.now += CHALLENGE_TTL_MS + 1; + code(() => store.link(ada, { ...input, nonce: c2.nonce, signature: w.sign(c2.message) }), 409); // expired + const c3 = store.challenge(ada, w.address); + code(() => store.link(bob, { ...input, nonce: c3.nonce, signature: w.sign(c3.message) }), 409); // challenge bound to ada + // A wallet already linked to ada cannot be claimed by bob even with a fresh, valid proof. + const c4 = store.challenge(bob, w.address); + code(() => store.link(bob, { ...input, nonce: c4.nonce, signature: w.sign(c4.message) }), 409); + assert.equal(store.unlink(ada.sub, w.address), true); +})); + +test('account HTTP: login exchange, bearer auth and wallet link end to end', async () => { + const dir = await mkdtemp(join(tmpdir(), 'wikideck-account-http-')); + const rsa = generateKeyPairSync('rsa', { modulusLength: 2048 }); + const config = { ...oidcConfig({}), issuer: 'https://dex.test/' }; + const now = Math.floor(Date.now() / 1000); + const enc = (v: unknown) => Buffer.from(JSON.stringify(v)).toString('base64url'); + const nonce = 'nonce-'.padEnd(24, 'x'); + const input = `${enc({ alg: 'RS256', kid: 'k1' })}.${enc({ iss: config.issuer, sub: 'user-ada', aud: 'wikideck', + iat: now, exp: now + 600, name: 'Ada', preferred_username: 'ada', nonce })}`; + const idToken = `${input}.${sign('sha256', Buffer.from(input), rsa.privateKey).toString('base64url')}`; + let tokenBody = ''; + const fetcher = (async (url: URL | string, init?: RequestInit) => { + const u = String(url); + const json = (v: unknown, status = 200) => new Response(JSON.stringify(v), { status, headers: { 'content-type': 'application/json' } }); + if (u.endsWith('openid-configuration')) return json({ issuer: config.issuer, authorization_endpoint: 'https://dex.test/auth', + token_endpoint: 'https://dex.test/token', jwks_uri: 'https://dex.test/keys' }); + if (u.endsWith('/keys')) return json({ keys: [{ ...rsa.publicKey.export({ format: 'jwk' }), kid: 'k1' }] }); + if (u.endsWith('/token')) { tokenBody = String(init?.body); return json({ id_token: idToken, access_token: 'a', token_type: 'bearer' }); } + return json({}, 404); + }) as typeof fetch; + const app = express(); + app.use(express.json()); + app.use('/api/account', createAccountRouter({ config, dataDir: dir, keys: new DexKeys(config, fetcher), fetcher })); + const server = app.listen(0, '127.0.0.1'); + await new Promise(r => server.once('listening', r)); + const base = `http://127.0.0.1:${(server.address() as { port: number }).port}/api/account`; + const call = async (path: string, body?: unknown, token?: string) => { + const res = await fetch(base + path, { method: body ? 'POST' : 'GET', headers: { 'content-type': 'application/json', + ...(token ? { authorization: `Bearer ${token}` } : {}) }, body: body ? JSON.stringify(body) : undefined }); + return { status: res.status, body: await res.json() }; + }; + try { + const cfg = await call('/config'); + assert.equal(cfg.body.authorizationEndpoint, 'https://dex.test/auth'); + assert.equal(cfg.body.clientId, 'wikideck'); + const verifier = 'v'.repeat(43); + const bad = await call('/token', { code: 'c', codeVerifier: verifier, redirectUri: 'https://evil.test/cb', nonce }); + assert.equal(bad.status, 400); + const wrongNonce = await call('/token', { code: 'c', codeVerifier: verifier, redirectUri: config.redirectUris[0], nonce: 'z'.repeat(24) }); + assert.equal(wrongNonce.status, 401); + const login = await call('/token', { code: 'c', codeVerifier: verifier, redirectUri: config.redirectUris[0], nonce }); + assert.equal(login.status, 200); + assert.equal(login.body.account.name, 'Ada'); + const sent = new URLSearchParams(tokenBody); + assert.equal(sent.get('client_id'), 'wikideck'); + assert.equal(sent.get('code_verifier'), verifier); + assert.equal(sent.get('client_secret'), null); + assert.equal((await call('/me')).status, 401); + assert.equal((await call('/me', undefined, idToken)).body.username, 'ada'); + const w = wallet(); + const ch = await call('/challenge', { address: w.address }, idToken); + const link = await call('/link', { nonce: ch.body.nonce, address: w.address, publicKey: w.publicKey, signature: w.sign(ch.body.message) }, idToken); + assert.equal(link.status, 201); + const replay = await call('/link', { nonce: ch.body.nonce, address: w.address, publicKey: w.publicKey, signature: w.sign(ch.body.message) }, idToken); + assert.equal(replay.status, 409); + assert.deepEqual((await call(`/names?addresses=${w.address}`)).body.names, { [w.address]: 'Ada' }); + } finally { + await new Promise(r => server.close(r)); + await rm(dir, { recursive: true, force: true }); + } +}); diff --git a/tests/account-oidc.test.ts b/tests/account-oidc.test.ts new file mode 100644 index 0000000..5e446bd --- /dev/null +++ b/tests/account-oidc.test.ts @@ -0,0 +1,88 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import { generateKeyPairSync, sign, type KeyObject } from 'node:crypto'; +import { DexKeys, TokenError, displayName, oidcConfig, verifyIdToken } from '../server/account/oidc.ts'; + +const config = { ...oidcConfig({}), issuer: 'https://dex.test/' }; +const NOW = 1_800_000_000_000; +const t = Math.floor(NOW / 1000); + +function rsa() { return generateKeyPairSync('rsa', { modulusLength: 2048 }); } +const main = rsa(), other = rsa(); + +export function jwt(claims: Record, key: KeyObject = main.privateKey, header: Record = { alg: 'RS256', kid: 'k1' }): string { + const enc = (v: unknown) => Buffer.from(JSON.stringify(v)).toString('base64url'); + const input = `${enc(header)}.${enc(claims)}`; + return `${input}.${sign('sha256', Buffer.from(input), key).toString('base64url')}`; +} +const good = (over: Record = {}) => ({ iss: config.issuer, sub: 'user-1', aud: 'wikideck', + iat: t - 10, exp: t + 3600, name: 'Ada Lovelace', preferred_username: 'ada', email: 'ada@example.test', nonce: 'n'.repeat(16), ...over }); + +function fakeDex(calls: string[] = []) { + const jwks = { keys: [{ ...main.publicKey.export({ format: 'jwk' }), kid: 'k1', use: 'sig', alg: 'RS256' }] }; + const fetcher = (async (url: URL | string) => { + const u = String(url); calls.push(u); + const json = (v: unknown) => new Response(JSON.stringify(v), { headers: { 'content-type': 'application/json' } }); + if (u.endsWith('/.well-known/openid-configuration')) return json({ issuer: config.issuer, + authorization_endpoint: 'https://dex.test/auth', token_endpoint: 'https://dex.test/token', jwks_uri: 'https://dex.test/keys' }); + if (u === 'https://dex.test/keys') return json(jwks); + return new Response('{}', { status: 404 }); + }) as typeof fetch; + return new DexKeys(config, fetcher, () => NOW); +} + +const rejects = (p: Promise, msg: RegExp) => assert.rejects(p, e => e instanceof TokenError && msg.test(e.message)); + +test('account: a good ID token verifies against the JWKS', async () => { + const claims = await verifyIdToken(jwt(good()), fakeDex(), config, { now: NOW, nonce: 'n'.repeat(16) }); + assert.equal(claims.sub, 'user-1'); + assert.equal(displayName(claims), 'Ada Lovelace'); +}); + +test('account: expired tokens are rejected (beyond clock skew)', async () => { + await rejects(verifyIdToken(jwt(good({ exp: t - 61 })), fakeDex(), config, { now: NOW }), /expired/); + // Within the 60 s skew still passes. + await verifyIdToken(jwt(good({ exp: t - 30 })), fakeDex(), config, { now: NOW }); +}); + +test('account: wrong audience and wrong issuer are rejected', async () => { + await rejects(verifyIdToken(jwt(good({ aud: 'www-membership' })), fakeDex(), config, { now: NOW }), /audience/); + await rejects(verifyIdToken(jwt(good({ aud: ['other', 'wikideck'] })), fakeDex(), config, { now: NOW }), /authorized party/); + await verifyIdToken(jwt(good({ aud: ['other', 'wikideck'], azp: 'wikideck' })), fakeDex(), config, { now: NOW }); + await rejects(verifyIdToken(jwt(good({ iss: 'https://evil.test/' })), fakeDex(), config, { now: NOW }), /issuer/); + await rejects(verifyIdToken(jwt(good({ iss: 'https://dex.test' })), fakeDex(), config, { now: NOW }), /issuer/); +}); + +test('account: forged signatures, alg confusion and unknown keys are rejected', async () => { + await rejects(verifyIdToken(jwt(good(), other.privateKey), fakeDex(), config, { now: NOW }), /signature/); + const parts = jwt(good()).split('.'); + const tampered = `${parts[0]}.${Buffer.from(JSON.stringify(good({ sub: 'admin' }))).toString('base64url')}.${parts[2]}`; + await rejects(verifyIdToken(tampered, fakeDex(), config, { now: NOW }), /signature/); + const none = `${Buffer.from(JSON.stringify({ alg: 'none', kid: 'k1' })).toString('base64url')}.${parts[1]}.`; + await rejects(verifyIdToken(none, fakeDex(), config, { now: NOW }), /algorithm/); + await rejects(verifyIdToken(jwt(good(), main.privateKey, { alg: 'RS256', kid: 'nope' }), fakeDex(), config, { now: NOW }), /signing key/); + await rejects(verifyIdToken('a.b', fakeDex(), config, { now: NOW }), /Malformed/); +}); + +test('account: nonce, future iat and nbf are enforced', async () => { + await rejects(verifyIdToken(jwt(good()), fakeDex(), config, { now: NOW, nonce: 'x'.repeat(16) }), /nonce/); + await rejects(verifyIdToken(jwt(good({ iat: t + 600 })), fakeDex(), config, { now: NOW }), /future/); + await rejects(verifyIdToken(jwt(good({ nbf: t + 600 })), fakeDex(), config, { now: NOW }), /not yet/); +}); + +test('account: JWKS is cached and discovery issuer must match', async () => { + const calls: string[] = []; + const keys = fakeDex(calls); + await verifyIdToken(jwt(good()), keys, config, { now: NOW }); + await verifyIdToken(jwt(good()), keys, config, { now: NOW }); + assert.equal(calls.filter(c => c.endsWith('/keys')).length, 1); + const bad = new DexKeys({ ...config, issuer: 'https://dex.test/other/' }, (async () => + new Response(JSON.stringify({ issuer: 'https://dex.test/' }))) as typeof fetch); + await assert.rejects(bad.meta(), /issuer mismatch/); +}); + +test('account: display names never fall back to email and are sanitised', () => { + assert.equal(displayName({ sub: 'abcdef123', preferred_username: 'ada' }), 'ada'); + assert.equal(displayName({ sub: 'abcdef123' }), 'player-abcdef'); + assert.equal(displayName({ sub: 's', name: 'A\u0000B' + 'x'.repeat(100) }).length, 48); +});