149 lines
8.9 KiB
JavaScript
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));
|
|
}
|