《互联网产品的 AI 架构·平台化与治理》9.3 事故响应与披露

// file: src/gov/incident-gov.ts
// tier: L2
// verify: node --test test/gov/security-gov.test.ts

/** 安全事件响应：分级、时限、止血清单与对外披露口径。 */
export type IncidentSeverity = "sev1" | "sev2" | "sev3" | "sev4";
export type IncidentKind =
  | "prompt-injection" | "tool-misuse" | "data-exfiltration" | "unauthorized-action";

export interface Incident {
  id: string; kind: IncidentKind; severity: IncidentSeverity;
  /** 带时区的 ISO 8601 时间戳。 */
  detectedAt: string;
  acknowledgedAt?: string; containedAt?: string; forensicsStartedAt?: string;
  customerData: boolean; crossBorder: boolean; exploited: boolean;
}
export interface ResponseDeadlines { acknowledge: string; contain: string; forensics: string }
export interface DisclosureDecision {
  required: boolean; reasons: string[];
  customerDeadline?: string; regulatorDeadline?: string; publicDeadline?: string;
}
export interface IncidentAssessment {
  id: string; severity: IncidentSeverity; deadlines: ResponseDeadlines;
  breached: string[]; pending: string[]; containedInMinutes?: number;
  disclosure: DisclosureDecision;
}

type Sla = { acknowledgeMinutes: number; containMinutes: number; forensicsMinutes: number };
export const RESPONSE_SLA: Record<IncidentSeverity, Sla> = {
  sev1: { acknowledgeMinutes: 15, containMinutes: 60, forensicsMinutes: 120 },
  sev2: { acknowledgeMinutes: 30, containMinutes: 240, forensicsMinutes: 480 },
  sev3: { acknowledgeMinutes: 240, containMinutes: 1_440, forensicsMinutes: 4_320 },
  sev4: { acknowledgeMinutes: 1_440, containMinutes: 10_080, forensicsMinutes: 10_080 },
};

function addMinutes(timestamp: string, minutes: number): string {
  return new Date(Date.parse(timestamp) + minutes * 60_000).toISOString();
}

/** 分级只看事实：是否涉及客户数据、是否跨境、是否已被利用。 */
export function classifyIncident(
  kind: IncidentKind,
  facts: { customerData: boolean; crossBorder: boolean; exploited: boolean },
): IncidentSeverity {
  if (kind === "data-exfiltration" && (facts.customerData || facts.crossBorder)) return "sev1";
  if (kind === "unauthorized-action" && facts.exploited) return "sev1";
  if (facts.exploited || facts.customerData || facts.crossBorder) return "sev2";
  if (kind === "data-exfiltration" || kind === "tool-misuse") return "sev2";
  if (kind === "prompt-injection" || kind === "unauthorized-action") return "sev3";
  return "sev4";
}

export function responseDeadlines(
  severity: IncidentSeverity, detectedAt: string,
): ResponseDeadlines {
  const sla = RESPONSE_SLA[severity];
  return {
    acknowledge: addMinutes(detectedAt, sla.acknowledgeMinutes),
    contain: addMinutes(detectedAt, sla.containMinutes),
    forensics: addMinutes(detectedAt, sla.forensicsMinutes),
  };
}

/**
 * 披露判定：严重级别、客户数据、跨境、已利用四个条件任一成立即需披露。
 * 时间线是示例口径，不是法规结论；实际以法务与监管要求为准。
 */
export function decideDisclosure(incident: Incident): DisclosureDecision {
  const reasons: string[] = [];
  if (incident.severity === "sev1" || incident.severity === "sev2") reasons.push("severity");
  if (incident.customerData) reasons.push("customer-data");
  if (incident.crossBorder) reasons.push("cross-border");
  if (incident.exploited) reasons.push("exploited");
  if (reasons.length === 0) return { required: false, reasons };
  const customerHours = incident.severity === "sev1" ? 24 : incident.severity === "sev2" ? 48 : 120;
  const publicHours = incident.severity === "sev1" ? 72 : incident.severity === "sev2" ? 168 : 336;
  const decision: DisclosureDecision = {
    required: true, reasons,
    publicDeadline: addMinutes(incident.detectedAt, publicHours * 60),
  };
  if (incident.customerData) {
    decision.customerDeadline = addMinutes(incident.detectedAt, customerHours * 60);
  }
  if (incident.customerData || incident.crossBorder) {
    decision.regulatorDeadline = addMinutes(incident.detectedAt, 72 * 60);
  }
  return decision;
}

export function assessIncident(incident: Incident, now: string): IncidentAssessment {
  const deadlines = responseDeadlines(incident.severity, incident.detectedAt);
  const phases = [
    { name: "acknowledge", deadline: deadlines.acknowledge, done: incident.acknowledgedAt },
    { name: "contain", deadline: deadlines.contain, done: incident.containedAt },
    { name: "forensics", deadline: deadlines.forensics, done: incident.forensicsStartedAt },
  ];
  const breached: string[] = [];
  const pending: string[] = [];
  for (const phase of phases) {
    if (phase.done !== undefined) {
      if (Date.parse(phase.done) > Date.parse(phase.deadline)) breached.push(phase.name);
    } else if (Date.parse(now) > Date.parse(phase.deadline)) {
      breached.push(phase.name);
    } else {
      pending.push(phase.name);
    }
  }
  return {
    id: incident.id,
    severity: incident.severity,
    deadlines,
    breached,
    pending,
    containedInMinutes: incident.containedAt === undefined ? undefined
      : Math.round((Date.parse(incident.containedAt) - Date.parse(incident.detectedAt)) / 60_000),
    disclosure: decideDisclosure(incident),
  };
}

// file: src/gov/security-gov.ts
// tier: L2
// verify: node --test test/gov/security-gov.test.ts

/** 安全风险登记：提示注入、工具滥用、数据外泄、越权动作；金额无关，分数为整数。 */
export type RiskCategory = "prompt-injection" | "tool-misuse" | "data-exfiltration" | "unauthorized-action";
export type Impact = "low" | "medium" | "high" | "critical";
export type Likelihood = "rare" | "unlikely" | "possible" | "likely";
export type ControlMaturity = "planned" | "partial" | "effective";
export type RiskStatus = "open" | "mitigating" | "accepted" | "closed";
export type ResidualRating = "low" | "medium" | "high" | "critical";
export type ReviewState = "scheduled" | "due-soon" | "overdue" | "closed";

const IMPACT: Record<Impact, number> = { low: 1, medium: 2, high: 3, critical: 4 };
const LIKELIHOOD: Record<Likelihood, number> = { rare: 1, unlikely: 2, possible: 3, likely: 4 };
const MATURITY: Record<ControlMaturity, number> = { planned: 0, partial: 1, effective: 2 };
const CONTROL_CAP = 8;
const REVIEW_DAYS: Record<ResidualRating, number> = {
  critical: 30, high: 60, medium: 90, low: 180,
};
export const RISK_CATEGORIES: readonly RiskCategory[] = [
  "prompt-injection", "tool-misuse", "data-exfiltration", "unauthorized-action",
];

export interface RiskControl { id: string; description: string; maturity: ControlMaturity }
export interface RiskEntry {
  id: string; category: RiskCategory; title: string; impact: Impact; likelihood: Likelihood;
  controls: readonly RiskControl[]; owner: string; status: RiskStatus;
  /** 最近一次复查与下一次复查，均为 YYYY-MM-DD。 */
  lastReviewed: string; reviewDate: string;
}
export interface RiskAssessment {
  id: string; inherentScore: number; controlPoints: number; residualScore: number;
  residualRating: ResidualRating; reviewState: ReviewState; overdueDays: number; escalate: boolean;
}
export type RiskIssueCode = "duplicate-id" | "invalid-category" | "empty-owner" | "invalid-date"
  | "review-before-last" | "review-interval-exceeded" | "invalid-control";
export interface RiskIssue { id: string; code: RiskIssueCode; detail: string }

const DATE = /^\d{4}-\d{2}-\d{2}$/;

export function daysBetween(from: string, to: string): number {
  return Math.round((Date.parse(`${to}T00:00:00Z`) - Date.parse(`${from}T00:00:00Z`)) / 86_400_000);
}

export function reviewIntervalDays(rating: ResidualRating): number { return REVIEW_DAYS[rating]; }

export function rateResidual(score: number): ResidualRating {
  if (score >= 12) return "critical";
  if (score >= 8) return "high";
  if (score >= 4) return "medium";
  return "low";
}

/** 固有分 = 影响 × 可能性；控制分 planned 0 / partial 1 / effective 2，合计封顶 8。 */
export function assessRisk(entry: RiskEntry, today: string): RiskAssessment {
  const inherentScore = IMPACT[entry.impact] * LIKELIHOOD[entry.likelihood];
  const controlPoints = Math.min(
    CONTROL_CAP, entry.controls.reduce((sum, item) => sum + MATURITY[item.maturity], 0),
  );
  const residualScore = Math.max(1, inherentScore - controlPoints);
  const residualRating = rateResidual(residualScore);
  if (entry.status === "closed") {
    return {
      id: entry.id, inherentScore, controlPoints, residualScore, residualRating,
      reviewState: "closed", overdueDays: 0, escalate: false,
    };
  }
  const until = daysBetween(today, entry.reviewDate);
  const overdueDays = until < 0 ? -until : 0;
  const reviewState: ReviewState = until < 0 ? "overdue" : until <= 14 ? "due-soon" : "scheduled";
  const effective = entry.controls.some((item) => item.maturity === "effective");
  const escalate = residualRating === "critical"
    || (residualRating === "high" && !effective) || overdueDays > 0;
  return {
    id: entry.id, inherentScore, controlPoints, residualScore, residualRating,
    reviewState, overdueDays, escalate,
  };
}

/** 日期不可解析时只报 invalid-date，不继续做间隔比较。 */
export function validateRegister(entries: readonly RiskEntry[]): RiskIssue[] {
  const issues: RiskIssue[] = [];
  const seen = new Set<string>();
  for (const entry of entries) {
    if (seen.has(entry.id)) issues.push({ id: entry.id, code: "duplicate-id", detail: "id twice" });
    seen.add(entry.id);
    if (!RISK_CATEGORIES.includes(entry.category)) {
      issues.push({ id: entry.id, code: "invalid-category", detail: entry.category });
    }
    if (entry.owner.trim() === "") {
      issues.push({ id: entry.id, code: "empty-owner", detail: "owner empty" });
    }
    const dates = [entry.lastReviewed, entry.reviewDate];
    if (dates.some((date) => !DATE.test(date) || Number.isNaN(Date.parse(`${date}T00:00:00Z`)))) {
      issues.push({ id: entry.id, code: "invalid-date", detail: dates.join(",") });
      continue;
    }
    const interval = daysBetween(entry.lastReviewed, entry.reviewDate);
    const allowed = reviewIntervalDays(assessRisk(entry, entry.lastReviewed).residualRating);
    if (interval <= 0) issues.push({ id: entry.id, code: "review-before-last", detail: `${interval}` });
    else if (interval > allowed) {
      issues.push({ id: entry.id, code: "review-interval-exceeded", detail: `${interval}>${allowed}` });
    }
    for (const control of entry.controls) {
      if (control.id.trim() === "" || control.description.trim() === "") {
        issues.push({ id: entry.id, code: "invalid-control", detail: control.id });
      }
    }
  }
  return issues;
}

export interface RegisterSummary {
  total: number; open: number; overdue: number; escalate: number;
  missingOwner: number; byRating: Record<ResidualRating, number>;
}

export function summarizeRegister(entries: readonly RiskEntry[], today: string): RegisterSummary {
  const byRating: Record<ResidualRating, number> = { low: 0, medium: 0, high: 0, critical: 0 };
  let open = 0; let overdue = 0; let escalate = 0; let missingOwner = 0;
  for (const entry of entries) {
    const item = assessRisk(entry, today);
    byRating[item.residualRating] += 1;
    if (entry.status !== "closed") open += 1;
    if (item.reviewState === "overdue") overdue += 1;
    if (item.escalate) escalate += 1;
    if (entry.owner.trim() === "") missingOwner += 1;
  }
  return { total: entries.length, open, overdue, escalate, missingOwner, byRating };
}