Files
stack/packages/webui/src/decision-http.mjs
T

149 lines
8.9 KiB
JavaScript

// Row 252 (#1753, Gander's design approved by Webby at 5d8f0f4b5): Approve and Deny for a grant
// request, from the signed-in Console only. Two POSTs. /confirmation asks the bus for the decision's
// two answers and digest and returns a one-use confirmation bound to this session, business,
// decision, choice and digest. /resolve takes only that choice and confirmation, consumes the
// confirmation before it awaits the bus, and asks the bus to resolve with the digest. The bus
// rechecks everything in the resolve transaction. Nothing here retries.
import { createHash, randomBytes } from 'node:crypto';
import { BusReadError, subjectOk } from './bus.mjs';
export const DECISION_ROUTE = /^\/api\/decisions\/([^/]*)\/(confirmation|resolve)$/;
// The endpoint contract, design section 4. Each refusal is one of these, never a 200.
export const DECISION_REFUSALS = Object.freeze({
'sign-in-required': [401, 'Sign in again before answering.'],
'read-only': [403, 'Console decision answers are not enabled. Use mosaic decide.'],
'cross-origin': [403, 'Answer from the signed-in Console page.'],
'not-found': [404, 'Not found.'],
'human-required': [403, 'The bus refused this human identity.'],
'peercred-required': [403, 'The bus could not verify this connection.'],
'method-not-allowed': [405, 'Use POST.'],
'invalid-request': [400, 'Invalid decision answer.'],
'request-too-large': [413, 'Decision answer is too large.'],
'decision-not-found': [404, 'This decision is unavailable.'],
'decision-not-eligible': [403, 'Answer this decision with mosaic decide.'],
'decision-closed': [409, 'This decision is no longer open. Refresh the inbox.'],
'decision-stale': [409, 'The choices changed. Review the decision again.'],
'confirmation-required': [409, 'Review and confirm this answer again.'],
'confirmation-unavailable': [503, 'Confirmation is unavailable. Try again later.'],
'outcome-unknown': [503, 'The answer may have reached the bus. Refresh before trying again.'],
});
// Bus codes by name. A bus that refuses this caller is human-required, whatever its code. Any
// other code, or no answer, is confirmation-unavailable at the preview and outcome-unknown at the
// resolve, which the page reads as "refresh first".
const BUS_CODES = {
'human-required': 'human-required', unauthenticated: 'human-required', 'unknown-business': 'human-required',
'access-refused': 'human-required', 'access-revoked': 'human-required', 'agent-required': 'human-required',
'peercred-required': 'peercred-required',
'decision-not-found': 'decision-not-found', 'decision-not-eligible': 'decision-not-eligible',
'decision-closed': 'decision-closed', 'decision-stale': 'decision-stale', 'invalid-choice': 'decision-stale',
'invalid-request': 'invalid-request',
};
const BODY_MAX = 4096;
const TOKEN = /^[a-f0-9]{64}$/;
const DIGEST = /^[a-f0-9]{64}$/;
const one = (req, name) => (req.headersDistinct[name]?.length === 1 ? req.headersDistinct[name][0] : null);
const hash = (token) => createHash('sha256').update(token).digest('hex');
export function decisionRefuse(res, code) {
const [status, message] = DECISION_REFUSALS[code];
res.writeHead(status, { 'content-type': 'application/json', 'cache-control': 'no-store' });
res.end(JSON.stringify({ error: code, message }));
}
// The confirmations, in this process's memory only and stored by hash. 120 seconds, at most 1024
// live. A full store refuses a new one rather than drop a live one. An expired one is swept.
export function createConfirmations({ ttlMs = 120000, max = 1024, now = Date.now } = {}) {
const live = new Map();
const sweep = () => { const t = now(); for (const [k, v] of live) if (v.expires <= t) live.delete(k); };
return {
issue(binding) {
sweep();
if (live.size >= max) return null;
const token = randomBytes(32).toString('hex');
live.set(hash(token), { ...binding, expires: now() + ttlMs });
return token;
},
// One use: a token found is gone, whether or not it matches.
consume(token, { session, decision, choice }) {
sweep();
if (typeof token !== 'string' || !TOKEN.test(token)) return null;
const k = hash(token), v = live.get(k);
if (!v) return null;
live.delete(k);
return v.session === session && v.decision === decision && v.choice === choice ? v : null;
},
get size() { sweep(); return live.size; },
};
}
async function readBody(req) {
if (one(req, 'content-type')?.split(';')[0].trim().toLowerCase() !== 'application/json') return { code: 'invalid-request' };
const chunks = [];
let size = 0;
for await (const chunk of req) {
size += chunk.length;
if (size > BODY_MAX) return { code: 'request-too-large' };
chunks.push(chunk);
}
try {
const value = JSON.parse(Buffer.concat(chunks).toString('utf8'));
return value && typeof value === 'object' && !Array.isArray(value) ? { value } : { code: 'invalid-request' };
} catch { return { code: 'invalid-request' }; }
}
const preview = (v, id) =>
v && typeof v === 'object' && v.id === id && typeof v.business === 'string' && DIGEST.test(v.digest ?? '') &&
['approve', 'deny'].every((k) => typeof v[k]?.key === 'string' && typeof v[k]?.text === 'string') &&
v.approve.key !== v.deny.key && v.grant && typeof v.grant.method === 'string';
// `session` is the live sign-in session object this request passed, and `live()` reads it again
// right before each spawn. `call(verb, args, { subject, business })` is the console transport.
export async function decisionHTTP(req, res, { path, decide, session, live, confirmations, log }) {
const [, raw, step] = DECISION_ROUTE.exec(path);
let id = null;
try { id = decodeURIComponent(raw); } catch { /* refused below */ }
if (req.method !== 'POST') return decisionRefuse(res, 'method-not-allowed');
if (!decide) return decisionRefuse(res, 'read-only');
if (!session) return decisionRefuse(res, 'sign-in-required');
if (one(req, 'origin') !== decide.origin || one(req, 'sec-fetch-site') !== 'same-origin') return decisionRefuse(res, 'cross-origin');
const line = (outcome) => log(`${new Date().toISOString()} decide user=${JSON.stringify(String(session.name ?? '').slice(0, 64))} decision=${JSON.stringify(String(id ?? '').slice(0, 64))} step=${step} ${outcome}`);
const refuse = (code) => { line(`error=${code}`); return decisionRefuse(res, code); };
const { value, code } = await readBody(req);
if (code) return refuse(code);
if (!subjectOk(id)) return refuse('decision-not-found');
const subject = { provider: session.provider, iss: session.iss, sub: session.sub };
const busCode = (err, open) => {
const c = err instanceof BusReadError ? BUS_CODES[err.code] : undefined;
return c ?? open;
};
if (step === 'confirmation') {
if (Object.keys(value).length !== 1 || typeof value.choice !== 'string') return refuse('invalid-request');
if (live() !== session) return refuse('sign-in-required');
let v;
try { v = await decide.call('decision.preview.console', { id }, { subject }); } catch (err) { return refuse(busCode(err, 'confirmation-unavailable')); }
if (!preview(v, id)) return refuse('confirmation-unavailable');
const action = value.choice === v.approve.key ? 'approve' : value.choice === v.deny.key ? 'deny' : null;
if (!action) return refuse('decision-stale');
if (live() !== session) return refuse('sign-in-required');
const confirmation = confirmations.issue({ session, business: v.business, decision: id, choice: value.choice, digest: v.digest });
if (!confirmation) return refuse('confirmation-unavailable');
line(`action=${action}`);
return json(res, 200, { id, question: typeof v.question === 'string' ? v.question : '', action, choice: value.choice, text: v[action].text, grant: v.grant, confirmation });
}
const keys = Object.keys(value);
if (keys.length !== 2 || !keys.includes('choice') || !keys.includes('confirmation') || typeof value.choice !== 'string') return refuse('invalid-request');
// Consumed before any await on the bus, so a second click finds nothing (J12).
const held = confirmations.consume(value.confirmation, { session, decision: id, choice: value.choice });
if (!held) return refuse('confirmation-required');
if (live() !== session) return refuse('sign-in-required');
let r;
try {
r = await decide.call('decision.resolve.console', { id, choice: held.choice, digest: held.digest }, { subject, business: held.business });
} catch (err) { return refuse(busCode(err, 'outcome-unknown')); }
if (r?.id !== id || r.op !== 'resolved' || r.choice !== held.choice) return refuse('outcome-unknown');
line(`choice=${JSON.stringify(held.choice.slice(0, 64))}${r.grant ? ` grant=${r.grant}` : ''}`);
return json(res, 200, { id, op: 'resolved', choice: r.choice, ...(r.grant === 'started' ? { grant: 'started' } : {}) });
}
function json(res, status, body) {
res.writeHead(status, { 'content-type': 'application/json', 'cache-control': 'no-store' });
res.end(JSON.stringify(body));
}