148 lines
11 KiB
TypeScript
148 lines
11 KiB
TypeScript
/** Private codec only. A future caller must own a bounded, locked SQL
|
|
* snapshot, and readers must still prove current scope and protections. */
|
|
import { createHash } from "node:crypto"
|
|
import { z } from "zod"
|
|
import { authenticateServerProbeExecutionSourceRow } from "../modules/mcp/diagnostic-cancellation-source.js"
|
|
import { serverProbeReceiptMetadata } from "../modules/mcp/server-probe-actions.js"
|
|
import { serviceDiagnosticReceipt } from "../modules/mcp/service-diagnostic-progress.js"
|
|
import { constantEqual, decryptSecretExisting, fingerprint, privateFingerprinterExisting } from "../modules/mcp/security.js"
|
|
import { createLegacyServerProbeVerifier } from "./server-probe-legacy-verifier.js"
|
|
import { validateServerProbeJournalReceipt } from "./server-probe-journal.js"
|
|
import type { ServerProbeReceipt } from "./server-probe-execution.js"
|
|
import { canonicalPollArchiveTimestamp } from "./server-poll-terminal-archive.js"
|
|
|
|
const purpose="server-probe-retired-source-v1"
|
|
const uuid=z.string().uuid(),hash=z.string().regex(/^[0-9a-f]{64}$/),sid=z.number().int().positive().safe()
|
|
const time=z.string().transform(canonicalPollArchiveTimestamp)
|
|
const tool=z.enum(["ping","traceroute","bandwidth","dns","route","mtu"])
|
|
const record=z.record(z.string(),z.unknown())
|
|
const originalSchema=z.object({
|
|
operation_id:uuid,connection_id:uuid,owner_id:z.string().min(1).max(200),plan_id:uuid,
|
|
operation_name:z.literal("servers.probes.run"),operation_version:z.literal(1),operation_state:z.literal("applied"),
|
|
operation_verification:z.literal("inconclusive"),operation_error_code:z.null(),operation_result:z.unknown(),
|
|
plan_state:z.literal("completed"),approved_by:z.string().min(1).max(200),evidence:record,
|
|
step_index:z.literal(0),step_state:z.literal("acknowledged"),intended_state:record,step_result:record,
|
|
operation_created_at:time,operation_finished_at:time,plan_created_at:time,plan_approved_at:time,
|
|
plan_expires_at:time,step_created_at:time,step_finished_at:time,
|
|
}).strict()
|
|
const admissionSchema=z.object({
|
|
receipt_id:uuid,owner_id:z.string().min(1).max(200),identity_kind:z.literal("mcp"),execution_id:uuid,binding_proof:hash,
|
|
authority_expires_at:time,claim_token:z.null(),claim_attempted_at:time,purged_at:z.null(),cancelled_at:z.null(),created_at:time,
|
|
retention_days:z.number().int().min(1).max(365),safety_ms:z.number().int().min(60000).max(86400000),gc_not_before:time,
|
|
}).strict()
|
|
const sourceSchema=z.object({
|
|
original:originalSchema,admission:admissionSchema,anchor:record,
|
|
payload:z.object({receipt_id:uuid,receipt_proof:hash,receipt_ciphertext:z.string().min(1).max(262144)}).strict(),
|
|
stages:z.array(record).min(1).max(11),quarantineCount:z.literal(0),cancellationCount:z.literal(0),
|
|
}).strict()
|
|
const signedSchema=z.object({
|
|
version:z.literal(1),receiptId:uuid,executionId:uuid,connectionId:uuid,ownerId:z.string().min(1).max(200),planId:uuid,
|
|
operation:z.literal("servers.probes.run"),operationVersion:z.literal(1),originalCredentialId:uuid,
|
|
sourceServerId:sid,destinationServerId:sid.optional(),tool,serverIds:z.array(sid).min(1).max(2),
|
|
issuedAt:z.number().int().nonnegative().safe(),authorityExpiresAt:time,terminalAt:time,activityAt:time,gcNotBefore:time,
|
|
retentionDays:z.number().int().min(1).max(365),safetyMs:z.number().int().min(60000).max(86400000),
|
|
bindingProof:hash,sourceDigest:hash,terminalDigest:hash,stageSnapshotDigest:hash,receiptProof:hash,ciphertextSha256:hash,
|
|
}).strict().refine(value=>{
|
|
const expected=[...new Set([value.sourceServerId,...(value.destinationServerId===undefined?[]:[value.destinationServerId])])].sort((a,b)=>a-b)
|
|
return fingerprint(expected)===fingerprint(value.serverIds)
|
|
&& (value.tool==="bandwidth" ? value.destinationServerId!==undefined&&value.destinationServerId!==value.sourceServerId : value.destinationServerId===undefined)
|
|
&& value.issuedAt<Date.parse(value.authorityExpiresAt) && value.terminalAt<=value.activityAt
|
|
&& value.authorityExpiresAt<=value.activityAt
|
|
&& micros(value.gcNotBefore)>=micros(value.authorityExpiresAt)+BigInt(value.retentionDays*86400000+value.safetyMs)*1000n
|
|
})
|
|
|
|
export type ServerProbeRetiredSource = z.output<typeof signedSchema>
|
|
/** Match the exact canonical live terminal projection after payload expiry. */
|
|
export function matchesServerProbeRetiredTerminal(source: ServerProbeRetiredSource, raw: unknown): boolean {
|
|
const parsed = originalSchema.safeParse(raw)
|
|
return parsed.success && parsed.data.operation_id === source.executionId && parsed.data.plan_id === source.planId
|
|
&& parsed.data.connection_id === source.connectionId && parsed.data.owner_id === source.ownerId
|
|
&& fingerprint(parsed.data) === source.terminalDigest
|
|
}
|
|
export interface SignedServerProbeRetiredSource { source: ServerProbeRetiredSource; proof: string }
|
|
export class ServerProbeRetirementSourceRefused extends Error {
|
|
readonly automaticReplay=false
|
|
constructor(){super("Diagnostic retirement source cannot be authenticated");this.name="ServerProbeRetirementSourceRefused"}
|
|
}
|
|
function requireThat(value:unknown):asserts value {if(!value)throw new ServerProbeRetirementSourceRefused()}
|
|
function micros(value:string){return BigInt(Date.parse(value))*1000n+BigInt(value.slice(23,26))}
|
|
const maximum=(...values:string[])=>values.sort().at(-1)!
|
|
|
|
/** Produces no operation/payload/cancellation mutation or public authorization.
|
|
* Only settled successful sources with the original retained payload qualify. */
|
|
export async function projectServerProbeRetiredSource(raw:unknown):Promise<SignedServerProbeRetiredSource>{
|
|
try{
|
|
requireThat(Buffer.byteLength(JSON.stringify(raw))<=3*1048576)
|
|
const source=sourceSchema.parse(structuredClone(raw)),{original,admission,anchor,payload,stages}=source
|
|
const authenticated=await authenticateServerProbeExecutionSourceRow(original,original.operation_id,
|
|
{connectionId:original.connection_id,ownerId:original.owner_id})
|
|
requireThat(authenticated.terminal&&authenticated.sourceState==="applied")
|
|
const context=authenticated.originalContext,id=context.identity
|
|
requireThat(admission.receipt_id===authenticated.scope.receiptId&&admission.execution_id===id.executionId&&
|
|
admission.owner_id===id.ownerId&&admission.binding_proof===authenticated.scope.bindingProof&&
|
|
micros(admission.authority_expires_at)===BigInt(id.expiresAt)*1000n&&time.parse(anchor.authority_expires_at)===admission.authority_expires_at&&
|
|
payload.receipt_id===admission.receipt_id&&
|
|
payload.receipt_proof===anchor.receipt_proof&&anchor.state==="completed")
|
|
const verify=createLegacyServerProbeVerifier({loadMcpSource:async operationId=>{
|
|
requireThat(operationId===id.executionId)
|
|
return authenticated
|
|
}})
|
|
const verified=await verify({identityKind:"mcp",executionId:id.executionId,
|
|
anchor:{...anchor,receipt_ciphertext:payload.receipt_ciphertext},stages})
|
|
requireThat(verified.status==="verified"&&verified.authentication==="receipt"&&verified.bindingAuthenticated&&
|
|
verified.progressAuthenticated&&verified.terminal&&!verified.quarantined&&!verified.cancelled)
|
|
// The same ciphertext has already passed the existing receipt MAC and
|
|
// original-context checks above. Match its actual public effect as well.
|
|
const envelope=JSON.parse(await decryptSecretExisting(payload.receipt_ciphertext)) as {receipt:ServerProbeReceipt}
|
|
const receipt=validateServerProbeJournalReceipt(context,admission.receipt_id,envelope.receipt)
|
|
requireThat(receipt.state==="completed")
|
|
const metadata=serverProbeReceiptMetadata(receipt,id.executionId,authenticated.stageBudget)
|
|
const confirmed=serviceDiagnosticReceipt(metadata,true,id.executionId,authenticated.stageBudget)
|
|
requireThat(confirmed&&fingerprint(original.step_result)===fingerprint(metadata)&&fingerprint(original.operation_result)===fingerprint({
|
|
confirmedWrites:0,verificationScope:"acknowledgement",completedServiceSteps:1,diagnosticReceipt:confirmed,
|
|
}))
|
|
// The original receipt authenticates context and progress, not SQL row
|
|
// timestamps. Sign the exact observed locked snapshot and its chronology,
|
|
// without upgrading the historical journal's stage or timestamp proofs.
|
|
const anchorCreated=time.parse(anchor.created_at),anchorFinished=time.parse(anchor.finished_at)
|
|
requireThat(original.plan_created_at<=original.plan_approved_at&&original.plan_approved_at<=original.operation_created_at&&
|
|
original.operation_created_at<original.plan_expires_at&&original.operation_created_at<=original.step_created_at&&
|
|
original.step_created_at<=admission.created_at&&admission.created_at<=admission.claim_attempted_at&&
|
|
admission.claim_attempted_at<=anchorCreated&&anchorCreated<=anchorFinished&&anchorFinished<admission.authority_expires_at&&
|
|
anchorFinished<=original.step_finished_at&&original.step_finished_at<=original.operation_finished_at)
|
|
let stageActivity=anchorCreated
|
|
for(const stage of stages){
|
|
const created=time.parse(stage.created_at),received=time.parse(stage.received_at)
|
|
requireThat(stage.state==="received"&&stageActivity<=created&&created<=received&&received<=anchorFinished)
|
|
stageActivity=received
|
|
}
|
|
const terminalAt=maximum(original.operation_finished_at,original.plan_expires_at)
|
|
const result=signedSchema.parse({
|
|
version:1,receiptId:admission.receipt_id,executionId:id.executionId,connectionId:id.connectionId,ownerId:id.ownerId,
|
|
planId:original.plan_id,operation:"servers.probes.run",operationVersion:1,originalCredentialId:id.credentialId,
|
|
sourceServerId:context.sourceServerId,...(context.destinationServerId===undefined?{}:{destinationServerId:context.destinationServerId}),
|
|
tool:context.tool,serverIds:authenticated.serverIds,
|
|
issuedAt:id.issuedAt,authorityExpiresAt:admission.authority_expires_at,terminalAt,
|
|
activityAt:maximum(terminalAt,admission.authority_expires_at,admission.created_at,anchorFinished,stageActivity),
|
|
gcNotBefore:admission.gc_not_before,retentionDays:admission.retention_days,safetyMs:admission.safety_ms,
|
|
bindingProof:authenticated.scope.bindingProof,sourceDigest:authenticated.sourceDigest,terminalDigest:fingerprint(original),
|
|
stageSnapshotDigest:fingerprint(stages),receiptProof:payload.receipt_proof,
|
|
ciphertextSha256:createHash("sha256").update(payload.receipt_ciphertext).digest("hex"),
|
|
})
|
|
const sign=await privateFingerprinterExisting(purpose)
|
|
return {source:result,proof:sign(fingerprint(result))}
|
|
}catch{throw new ServerProbeRetirementSourceRefused()}
|
|
}
|
|
|
|
/** Authenticates the private projection. It never grants current access or
|
|
* authorizes the retained ciphertext without a fresh SQL identity read. */
|
|
export async function openServerProbeRetiredSource(raw:unknown):Promise<ServerProbeRetiredSource>{
|
|
try{
|
|
requireThat(Buffer.byteLength(JSON.stringify(raw))<=8192)
|
|
const {source,proof}=z.object({source:signedSchema,proof:hash}).strict().parse(structuredClone(raw))
|
|
const sign=await privateFingerprinterExisting(purpose)
|
|
requireThat(constantEqual(proof,sign(fingerprint(source))))
|
|
return source
|
|
}catch{throw new ServerProbeRetirementSourceRefused()}
|
|
}
|