@slicedearth/whoisleuth-cli 1.43.0 → 1.47.4

package/frontend/src/lib/analysis/lookup-presentation.js

@@ -1,9 +1,6 @@
 export const LOOKUP_PRESENTATION_STORAGE_KEY = 'whoisleuth:lookup-presentation:v1';
-export const LOOKUP_EVIDENCE_DENSITIES = Object.freeze([
-    Object.freeze({ id: 'summary', label: 'Essentials', detail: 'A compact assessment, key observations, unresolved evidence, and one summary for each evidence family.' }),
-    Object.freeze({ id: 'standard', label: 'Evidence', detail: 'Settled evidence is grouped by task while source detail and raw evidence stay collapsed until you inspect them.' }),
-    Object.freeze({ id: 'full', label: 'All evidence', detail: 'Every settled evidence family remains available, including advanced and bounded raw evidence.' }),
-]);
+export const MAX_LOOKUP_PRESENTATION_SERIALIZED_BYTES = 1_024;
+export const MAX_LOOKUP_URL_QUERY_LENGTH = 4_096;
 export const LOOKUP_TASK_VIEWS = Object.freeze([
     Object.freeze({ id: 'general', label: 'General investigation' }),
     Object.freeze({ id: 'acquisition', label: 'Acquisition review' }),
@@ -11,24 +8,84 @@ export const LOOKUP_TASK_VIEWS = Object.freeze([
     Object.freeze({ id: 'incident', label: 'Incident response' }),
     Object.freeze({ id: 'owned', label: 'Owned-domain posture' }),
 ]);
-const DENSITIES = new Set(LOOKUP_EVIDENCE_DENSITIES.map((option) => option.id));
 const TASKS = new Set(LOOKUP_TASK_VIEWS.map((option) => option.id));
-export function normalizeLookupEvidenceDensity(value) {
-    return typeof value === 'string' && DENSITIES.has(value)
-        ? value
-        : 'summary';
+const CONTROL_CHARACTERS = /[\u0000-\u001f\u007f]/u;
+export function parseLookupTaskContext(value) {
+    if (typeof value !== 'string' || value.length > 16)
+        return null;
+    return TASKS.has(value) ? value : null;
 }
 export function normalizeLookupTaskView(value) {
     return typeof value === 'string' && TASKS.has(value)
         ? value
         : 'general';
 }
+function lookupUrlQuery(value) {
+    if (value === null || value.length > MAX_LOOKUP_URL_QUERY_LENGTH || CONTROL_CHARACTERS.test(value))
+        return null;
+    const normalized = value.trim();
+    return normalized ? normalized : null;
+}
+function lookupUrlDepth(value) {
+    return value === 'fast' || value === 'deep' ? value : null;
+}
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+export function lookupResultDepth(value, fallback = null) {
+    const result = record(value);
+    if (!result)
+        return fallback;
+    const availability = record(result.availability);
+    if (availability?.deepScanComplete === false)
+        return 'fast';
+    if (availability?.deepScanComplete === true)
+        return 'deep';
+    const whois = record(result.whois);
+    if (whois?.skipped === true
+        && typeof whois.detail === 'string'
+        && /fast rdap-only mode/iu.test(whois.detail))
+        return 'fast';
+    const scanModes = [
+        record(result.reverseDns)?.scanMode,
+        record(availability?.dns)?.scanMode,
+        record(availability?.http)?.scanMode,
+    ];
+    if (scanModes.includes('deep'))
+        return 'deep';
+    if (scanModes.includes('fast'))
+        return 'fast';
+    return fallback;
+}
+export function reconcileLookupUrlState(current, searchParams, preferredTask) {
+    const explicitQuery = lookupUrlQuery(searchParams.get('q'));
+    const explicitDepth = lookupUrlDepth(searchParams.get('depth'));
+    const queryChanged = explicitQuery !== null && explicitQuery !== current.query;
+    const depthChanged = explicitDepth !== null && explicitDepth !== current.depth;
+    const conflictsWithResult = current.result !== null && ((explicitQuery !== null && explicitQuery !== current.completedTarget)
+        || (explicitDepth !== null && explicitDepth !== current.retainedResultDepth));
+    return {
+        query: explicitQuery ?? current.query,
+        depth: explicitDepth ?? current.depth,
+        task: parseLookupTaskContext(searchParams.get('task')) ?? normalizeLookupTaskView(preferredTask),
+        result: conflictsWithResult ? null : current.result,
+        completedTarget: conflictsWithResult ? '' : current.completedTarget,
+        error: conflictsWithResult || queryChanged || depthChanged ? '' : current.error,
+    };
+}
 export function readLookupPresentation(storage) {
     try {
-        const stored = JSON.parse(storage.getItem(LOOKUP_PRESENTATION_STORAGE_KEY) || 'null');
+        const serialized = storage.getItem(LOOKUP_PRESENTATION_STORAGE_KEY);
+        if (serialized === null
+            || serialized.length > MAX_LOOKUP_PRESENTATION_SERIALIZED_BYTES
+            || new TextEncoder().encode(serialized).byteLength > MAX_LOOKUP_PRESENTATION_SERIALIZED_BYTES) {
+            return { task: 'general' };
+        }
+        const stored = JSON.parse(serialized);
         if (stored?.version === 1) {
             return {
-                density: normalizeLookupEvidenceDensity(stored.density),
                 task: normalizeLookupTaskView(stored.task),
             };
         }
@@ -36,13 +93,12 @@ export function readLookupPresentation(storage) {
     catch {
         // Invalid or unavailable browser storage falls back to the stable defaults.
     }
-    return { density: 'summary', task: 'general' };
+    return { task: 'general' };
 }
 export function writeLookupPresentation(storage, state) {
     try {
         storage.setItem(LOOKUP_PRESENTATION_STORAGE_KEY, JSON.stringify({
             version: 1,
-            density: normalizeLookupEvidenceDensity(state.density),
             task: normalizeLookupTaskView(state.task),
         }));
     }

package/frontend/src/lib/analysis/lookup-source-refresh.js

@@ -1,3 +1,4 @@
+import { BoundedJsonResponseError, requestJsonCapped, } from "../bounded-json-response.js";
 export const LOOKUP_SOURCE_REFRESH_VERSION = 1;
 export const LOOKUP_SOURCE_STALE_AFTER_DAYS = 7;
 export const LOOKUP_FRESHNESS_POLICY_VERSION = 1;
@@ -141,47 +142,6 @@ function record(value) {
         ? value
         : {};
 }
-async function boundedJson(response) {
-    const declaredLength = Number(response.headers.get('content-length'));
-    if (Number.isFinite(declaredLength) && declaredLength > MAX_LOOKUP_SOURCE_REFRESH_BYTES) {
-        throw new Error('oversized');
-    }
-    if (!response.body)
-        return {};
-    const reader = response.body.getReader();
-    const chunks = [];
-    let total = 0;
-    try {
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            if (!value)
-                continue;
-            total += value.byteLength;
-            if (total > MAX_LOOKUP_SOURCE_REFRESH_BYTES)
-                throw new Error('oversized');
-            chunks.push(value);
-        }
-    }
-    finally {
-        if (total > MAX_LOOKUP_SOURCE_REFRESH_BYTES)
-            await reader.cancel().catch(() => { });
-        reader.releaseLock();
-    }
-    const bytes = new Uint8Array(total);
-    let offset = 0;
-    for (const chunk of chunks) {
-        bytes.set(chunk, offset);
-        offset += chunk.byteLength;
-    }
-    try {
-        return JSON.parse(new TextDecoder().decode(bytes));
-    }
-    catch {
-        return {};
-    }
-}
 function text(value, maximum = 180) {
     return String(value ?? '')
         .replace(/[\u0000-\u001f\u007f]+/gu, ' ')
@@ -194,6 +154,7 @@ function summarizeSource(plan, body, observedAt, depth, supersedesObservedAt) {
         version: LOOKUP_SOURCE_REFRESH_VERSION,
         id: plan.id,
         observedAt,
+        attemptedAt: observedAt,
         reason: plan.reason,
         evidenceIds: plan.evidenceIds.slice(0, 12),
         supersedesObservedAt,
@@ -208,7 +169,6 @@ function summarizeSource(plan, body, observedAt, depth, supersedesObservedAt) {
             detail: complete
                 ? `Registry RDAP returned a validated ${upstreamStatus} response.`
                 : `Registry RDAP returned ${Number.isFinite(upstreamStatus) ? `HTTP ${upstreamStatus}` : 'no complete structured record'}.`,
-            observedAt,
         };
     }
     if (plan.id === 'whois') {
@@ -221,7 +181,6 @@ function summarizeSource(plan, body, observedAt, depth, supersedesObservedAt) {
             detail: complete
                 ? `WHOIS returned a complete ${chain.length}-hop referral chain.`
                 : `WHOIS returned ${chain.length} hop${chain.length === 1 ? '' : 's'} with ${chainStatus || 'unknown'} chain status.`,
-            observedAt,
         };
     }
     const state = text(body.state, 40) || 'unknown';
@@ -234,7 +193,19 @@ function summarizeSource(plan, body, observedAt, depth, supersedesObservedAt) {
         ...base,
         state: complete ? 'complete' : 'limited',
         detail: `Domain evidence returned ${state}${sourceStates.length ? `; DNS, HTTP, and TLS states: ${sourceStates.join(', ')}` : ''}.`,
-        observedAt,
+    };
+}
+function unavailableRefreshResult(plan, attemptedAt, supersedesObservedAt, detail) {
+    return {
+        version: LOOKUP_SOURCE_REFRESH_VERSION,
+        id: plan.id,
+        state: 'unavailable',
+        detail,
+        observedAt: null,
+        attemptedAt,
+        reason: plan.reason,
+        evidenceIds: plan.evidenceIds.slice(0, 12),
+        supersedesObservedAt,
     };
 }
 export async function requestLookupSourceRefresh(plan, query, depth, options = {}) {
@@ -244,19 +215,24 @@ export async function requestLookupSourceRefresh(plan, query, depth, options = {
     const timeoutMs = Number.isFinite(options.timeoutMs)
         ? Math.max(1, Math.min(LOOKUP_SOURCE_REFRESH_TIMEOUT_MS, Math.round(Number(options.timeoutMs))))
         : LOOKUP_SOURCE_REFRESH_TIMEOUT_MS;
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort('timeout'), timeoutMs);
+    const attemptedAt = options.now?.() ?? new Date().toISOString();
+    const supersedesObservedAt = options.supersedesObservedAt === undefined
+        ? plan.supersedesObservedAt
+        : options.supersedesObservedAt;
     try {
         const url = `${plan.endpoint}?q=${encodeURIComponent(normalizedQuery)}${plan.id === 'availability' && depth === 'fast' ? '&fast=true' : ''}`;
-        const response = await (options.fetchImpl ?? fetch)(url, {
+        const { response, body: rawBody } = await requestJsonCapped(url, {
             credentials: 'same-origin',
-            signal: controller.signal,
+        }, {
+            ...(options.fetchImpl ? { fetchImpl: options.fetchImpl } : {}),
+            maximumBytes: MAX_LOOKUP_SOURCE_REFRESH_BYTES,
+            timeoutMs,
         });
-        const body = record(await boundedJson(response));
+        const body = record(rawBody);
         if (!response.ok) {
             return {
-                ok: false,
-                message: text(body.error, 240) || `Source refresh failed with HTTP ${response.status}.`,
+                ok: true,
+                value: unavailableRefreshResult(plan, attemptedAt, supersedesObservedAt, text(body.error, 240) || `The source returned HTTP ${response.status}; no new observation was recorded.`),
             };
         }
         if (Object.keys(body).length > MAX_LOOKUP_SOURCE_REFRESH_KEYS) {
@@ -264,23 +240,20 @@ export async function requestLookupSourceRefresh(plan, query, depth, options = {
         }
         return {
             ok: true,
-            value: summarizeSource(plan, body, options.now?.() ?? new Date().toISOString(), depth, options.supersedesObservedAt === undefined
-                ? plan.supersedesObservedAt
-                : options.supersedesObservedAt),
+            value: summarizeSource(plan, body, attemptedAt, depth, supersedesObservedAt),
         };
     }
     catch (cause) {
-        if (cause instanceof Error && cause.message === 'oversized') {
-            return { ok: false, message: 'Source refresh returned an oversized response.' };
+        if (cause instanceof BoundedJsonResponseError && cause.code === 'response_too_large') {
+            return { ok: true, value: unavailableRefreshResult(plan, attemptedAt, supersedesObservedAt, 'The source response exceeded the local limit; no new observation was recorded.') };
         }
         return {
-            ok: false,
-            message: controller.signal.aborted ? 'Source refresh timed out.' : 'Source refresh could not be completed.',
+            ok: true,
+            value: unavailableRefreshResult(plan, attemptedAt, supersedesObservedAt, cause instanceof BoundedJsonResponseError && cause.code === 'timeout'
+                ? 'The source refresh timed out; no new observation was recorded.'
+                : 'The source refresh could not be completed; no new observation was recorded.'),
         };
     }
-    finally {
-        clearTimeout(timeout);
-    }
 }
 export function mergeLookupSourceRefreshLedger(current, result) {
     const candidates = [
@@ -289,10 +262,10 @@ export function mergeLookupSourceRefreshLedger(current, result) {
     ];
     const byObservation = new Map();
     for (const entry of candidates.slice(-MAX_LOOKUP_SOURCE_REFRESH_HISTORY * 4)) {
-        byObservation.set(`${entry.id}:${entry.observedAt}`, entry);
+        byObservation.set(`${entry.id}:${entry.attemptedAt}`, entry);
     }
     const ordered = [...byObservation.values()]
-        .sort((left, right) => Date.parse(left.observedAt) - Date.parse(right.observedAt));
+        .sort((left, right) => Date.parse(left.attemptedAt) - Date.parse(right.attemptedAt));
     const truncated = Boolean(current?.truncated)
         || ordered.length > MAX_LOOKUP_SOURCE_REFRESH_HISTORY
         || candidates.length > MAX_LOOKUP_SOURCE_REFRESH_HISTORY;

package/frontend/src/lib/analysis/opaque-reference-id.js

@@ -0,0 +1,9 @@
+// Opaque browser-local identifiers shared by independently owned record
+// models. Validation is intentionally exact: callers must not trim, case-fold,
+// repair, resolve, or otherwise reinterpret an identifier.
+export const OPAQUE_REFERENCE_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
+export function normalizeOpaqueReferenceId(value) {
+    return typeof value === 'string' && OPAQUE_REFERENCE_ID_PATTERN.test(value)
+        ? value
+        : null;
+}

package/frontend/src/lib/analysis/utils.js

@@ -5,7 +5,7 @@ import { hammingDistanceHex, isInformativePerceptualHash, isPerceptualHash, } fr
 // this only gates whether a WHOIS/RDAP-sourced string is safe to drop into a
 // mailto: URI as the recipient, not a general email validator. mailto:
 // treats a comma as an additional-recipient separator (RFC 6068), so a
-// registrant/abuse-contact field containing e.g. "victim@x.com,cc@evil.com"
+// registrant/abuse-contact field containing e.g. "person@example.test,cc@hostile.example"
 // would silently add a second recipient to the outreach/abuse draft the user
 // opens - rejecting anything outside a single plain address closes that off.
 const SIMPLE_EMAIL_RE = /^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$/;
@@ -151,6 +151,10 @@ function splitDelimitedLine(line, delimiter = ',') {
     return result.map((s) => s.trim());
 }
 const DOMAIN_HEADER_NAMES = ['domain', 'domain_name', 'domain name', 'hostname', 'name'];
+export const MAX_DOMAIN_INPUT_CHARACTERS = 2 * 1024 * 1024;
+export const MAX_DOMAIN_INPUT_BYTES = 2 * 1024 * 1024;
+export const MAX_DOMAIN_INPUT_LINES = 10_000;
+export const MAX_DOMAIN_INPUT_SEPARATORS = 20_000;
 function detectDelimiter(line) {
     const candidates = [',', ';', '\t'];
     let best = null;
@@ -182,10 +186,29 @@ function looksLikeLookupToken(value) {
     }
 }
 export function parseDomainInput(text) {
-    const normalized = String(text || '').replace(/^\uFEFF/, '');
+    const source = String(text || '');
+    if (source.length > MAX_DOMAIN_INPUT_CHARACTERS) {
+        return { entries: [], duplicates: 0, usedHeader: false, tooLarge: true };
+    }
+    if (new TextEncoder().encode(source).byteLength > MAX_DOMAIN_INPUT_BYTES) {
+        return { entries: [], duplicates: 0, usedHeader: false, tooLarge: true };
+    }
+    let lineCount = 1;
+    let separatorCount = 0;
+    for (let index = 0; index < source.length; index += 1) {
+        const character = source[index];
+        if (character === '\n')
+            lineCount += 1;
+        if (character === ',' || character === ';' || character === '\t')
+            separatorCount += 1;
+        if (lineCount > MAX_DOMAIN_INPUT_LINES || separatorCount > MAX_DOMAIN_INPUT_SEPARATORS) {
+            return { entries: [], duplicates: 0, usedHeader: false, tooLarge: true };
+        }
+    }
+    const normalized = source.replace(/^\uFEFF/, '');
     const lines = normalized.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
     if (lines.length === 0)
-        return { entries: [], duplicates: 0, usedHeader: false };
+        return { entries: [], duplicates: 0, usedHeader: false, tooLarge: false };
     const firstLine = lines[0] ?? '';
     const delimiter = detectDelimiter(firstLine);
     const firstCells = delimiter ? splitDelimitedLine(firstLine, delimiter) : [firstLine];
@@ -228,5 +251,5 @@ export function parseDomainInput(text) {
         seen.add(key);
         entries.push(value);
     }
-    return { entries, duplicates, usedHeader };
+    return { entries, duplicates, usedHeader, tooLarge: false };
 }

package/frontend/src/lib/analysis/visualization-matrix.js

@@ -2,7 +2,14 @@ import { scaleBand } from 'd3-scale';
 import { boundedVisualizationId as boundedId, boundedVisualizationText as boundedText, } from "./visualization-bounds.js";
 export const MAX_VISUAL_MATRIX_ROWS = 24;
 export const MAX_VISUAL_MATRIX_COLUMNS = 6;
-function normalizedMatrixState(value) {
+// A row is one source-pair lane, so it can publish at most one cell for each
+// allowed column. This keeps output at 24 × 6 = 144 cells and prevents hostile
+// duplicate inputs from creating sub-pixel marks or unbounded cell arrays.
+export const MAX_VISUAL_MATRIX_CELLS = MAX_VISUAL_MATRIX_ROWS * MAX_VISUAL_MATRIX_COLUMNS;
+const MAX_VISUAL_MATRIX_COLUMN_INPUTS = MAX_VISUAL_MATRIX_COLUMNS * 4;
+const MAX_VISUAL_MATRIX_ROW_INPUTS = MAX_VISUAL_MATRIX_ROWS * 4;
+const MAX_VISUAL_MATRIX_CELL_INPUTS_PER_ROW = MAX_VISUAL_MATRIX_COLUMNS * 4;
+function normalizedMatrixTone(value) {
     const state = boundedText(value, 30).toLowerCase();
     if (state === 'equal' || state === 'equivalent' || state === 'same')
         return 'equal';
@@ -22,45 +29,79 @@ function normalizedMatrixState(value) {
     return 'unknown';
 }
 export function projectEvidenceMatrix(rawColumns, rawRows) {
-    const columns = [...new Set((Array.isArray(rawColumns) ? rawColumns : [])
-            .map((column) => boundedText(column, 40))
-            .filter(Boolean))]
-        .slice(0, MAX_VISUAL_MATRIX_COLUMNS);
+    const columnInputs = Array.isArray(rawColumns) ? rawColumns : [];
+    const columns = [];
+    const seenColumns = new Set();
+    for (const rawColumn of columnInputs.slice(0, MAX_VISUAL_MATRIX_COLUMN_INPUTS)) {
+        const column = boundedText(rawColumn, 40);
+        if (!column || seenColumns.has(column) || columns.length >= MAX_VISUAL_MATRIX_COLUMNS)
+            continue;
+        seenColumns.add(column);
+        columns.push(column);
+    }
     const columnSet = new Set(columns);
     const seenRows = new Set();
-    const candidates = (Array.isArray(rawRows) ? rawRows : [])
-        .map((row, index) => {
+    const rowInputs = Array.isArray(rawRows) ? rawRows : [];
+    const rows = [];
+    let discardedCellInputs = 0;
+    const scannedRows = rowInputs.slice(0, MAX_VISUAL_MATRIX_ROW_INPUTS);
+    for (const [index, row] of scannedRows.entries()) {
+        if (rows.length >= MAX_VISUAL_MATRIX_ROWS)
+            break;
         const id = boundedId(row?.id) || `row-${index}`;
         const label = boundedText(row?.label, 56);
         if (!label || seenRows.has(id))
-            return null;
+            continue;
         seenRows.add(id);
         const rowCells = (Array.isArray(row.cells) ? row.cells : []);
-        const byColumn = new Map(rowCells
-            .map((cell) => {
+        const scannedCells = rowCells.slice(0, MAX_VISUAL_MATRIX_CELL_INPUTS_PER_ROW);
+        discardedCellInputs += Math.max(0, rowCells.length - scannedCells.length);
+        const byColumn = new Map();
+        for (const cell of scannedCells) {
             const column = boundedText(cell?.column, 40);
-            return [column, {
-                    state: normalizedMatrixState(cell?.state),
-                    detail: boundedText(cell?.detail, 120),
+            if (!columnSet.has(column) || byColumn.has(column)) {
+                discardedCellInputs += 1;
+                continue;
+            }
+            const exactState = boundedText(cell?.state, 40).toLowerCase() || 'unknown';
+            byColumn.set(column, {
+                column,
+                state: exactState,
+                tone: normalizedMatrixTone(cell?.tone ?? exactState),
+                detail: boundedText(cell?.detail, 320),
+            });
+        }
+        const cells = columns.flatMap((column) => {
+            const value = byColumn.get(column);
+            if (value)
+                return [value];
+            if (row.sparse === true)
+                return [];
+            return [{
+                    column,
+                    state: 'not_collected',
+                    tone: 'not_collected',
+                    detail: '',
                 }];
-        })
-            .filter(([column]) => columnSet.has(column)));
-        return {
+        });
+        rows.push({
             id,
             label,
-            cells: columns.map((column) => ({
-                column,
-                state: byColumn.get(column)?.state ?? 'not_collected',
-                detail: byColumn.get(column)?.detail ?? '',
-            })),
-        };
-    })
-        .filter((row) => Boolean(row));
-    const rows = candidates.slice(0, MAX_VISUAL_MATRIX_ROWS);
+            context: boundedText(row.context, 90),
+            status: boundedText(row.status, 40).toLowerCase() || 'unknown',
+            assessment: boundedText(row.assessment, 80),
+            cells,
+        });
+    }
+    const discarded = {
+        columnInputs: Math.max(0, columnInputs.length - columns.length),
+        rowInputs: Math.max(0, rowInputs.length - rows.length),
+        cellInputs: discardedCellInputs,
+    };
     const width = 900;
     const top = 54;
-    const left = 210;
-    const rowHeight = 30;
+    const left = 250;
+    const rowHeight = 40;
     const x = scaleBand().domain(columns).range([left, 870]).padding(0.12);
     const y = scaleBand().domain(rows.map((row) => row.id))
         .range([top, top + Math.max(1, rows.length) * rowHeight])
@@ -83,6 +124,8 @@ export function projectEvidenceMatrix(rawColumns, rawRows) {
                 width: x.bandwidth(),
             })),
         })),
-        truncated: candidates.length > rows.length || rawColumns.length > columns.length,
+        discarded,
+        projectedCellCount: rows.reduce((sum, row) => sum + row.cells.length, 0),
+        truncated: discarded.columnInputs > 0 || discarded.rowInputs > 0 || discarded.cellInputs > 0,
     };
 }