From 326340b8cd86a1cdb5eed3558ca94b153fa55e39 Mon Sep 17 00:00:00 2001 From: Neil Date: Sun, 15 Nov 2026 15:00:25 -0800 Subject: [PATCH] fix(cloud): provider-policy audit counts injection/forward/response rules; dev resume-raw and echo-probe MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit egress-docs' probe 2 re-run through #803 found transformRuleCount always 0: Vercel's redacted shapes name header swaps injectionRules (session) next to forwardRules and responseRules. The audit now reports each kind separately (count + header names), so a scrubbed policy is checkable: 0 injection rules, response rules only. Two more dev-only operator routes so the probe needs no personal Vercel login: - POST …/resume-raw: resume the provider session from its stored record with no policy write of ours (the row is left as it was; dev throwaways only). - POST …/echo-probe?marker=orcaprobebogus…: one fixed request from inside the VM to httpbin.org or postman-echo.com carrying a placeholder header (placeholders only, validated); the answer is whether the echo contained the marker. No body comes back or is logged. --- cloud/apps/sandbox-control/src/operator.ts | 96 +++++++++++++++---- .../test/provider-policy-audit.test.ts | 40 +++++++- 2 files changed, 114 insertions(+), 22 deletions(-) diff --git a/cloud/apps/sandbox-control/src/operator.ts b/cloud/apps/sandbox-control/src/operator.ts index b1a6d298fb2..1cbd3ede154 100644 --- a/cloud/apps/sandbox-control/src/operator.ts +++ b/cloud/apps/sandbox-control/src/operator.ts @@ -93,7 +93,7 @@ export async function handleOperator( } // Dev only (probe 2, egress-docs): redacted facts about what Vercel holds for one sandbox, read with the // Worker's own token. Never a value or a body; anywhere but dev, these routes don't exist. - const policyAudit = /^\/v1\/internal\/sandboxes\/([A-Za-z0-9_]+)\/(provider-policy-audit|provider-policy-scrub-test)$/.exec(path) + const policyAudit = /^\/v1\/internal\/sandboxes\/([A-Za-z0-9_]+)\/(provider-policy-audit|provider-policy-scrub-test|resume-raw|echo-probe)$/.exec(path) if (policyAudit && life.config.environment === 'dev') { const row = await getSandbox(life.db, policyAudit[1]!) if (!row) { @@ -104,6 +104,36 @@ export async function handleOperator( console.log(JSON.stringify({ event: 'provider_policy_scrub_test', sandboxId: row.id, outcome: typeof outcome === 'string' ? outcome : 'failed' })) return Response.json({ sandboxId: row.id, outcome }) } + if (policyAudit[2] === 'resume-raw' && request.method === 'POST') { + // Probe 2 only: resume the provider session from its stored record with NO policy write of ours, so a probe + // can see which value the resumed session swaps. The row is left as it was (dev throwaways only). + const state = await life.provider.getSandbox(row.provider_name, { resume: true }) + console.log(JSON.stringify({ event: 'provider_resume_raw', sandboxId: row.id, sessionStatus: state?.session.status ?? null })) + return Response.json({ sandboxId: row.id, sessionStatus: state?.session.status ?? null }) + } + if (policyAudit[2] === 'echo-probe' && request.method === 'POST') { + // Probe 2 only: one fixed request from inside the VM to an echo host, carrying a placeholder header; the + // answer is whether the echoed request contained the marker (i.e. what the firewall swapped in). No body back. + const body = EchoProbeBody.safeParse(await deps.readJson()) + const marker = new URL(request.url).searchParams.get('marker') ?? '' + if (!body.success || marker.length < 12 || !marker.startsWith('orcaprobebogus')) { + return Response.json({ error: 'invalid_request' }, { status: 400 }) + } + const state = await life.provider.getSandbox(row.provider_name, { resume: false }) + if (!state || state.session.status !== 'running') { + return Response.json({ error: 'not_running' }, { status: 409 }) + } + const url = body.data.host === 'httpbin.org' ? 'https://httpbin.org/headers' : 'https://postman-echo.com/headers' + const result = await life.provider.runCommand(state.session.id, { + command: 'bash', + args: ['-c', 'curl -s --max-time 20 -o /tmp/orca-echo-probe -w "%{http_code}" -H "$1: $2" "$3"; echo; grep -c -- "$4" /tmp/orca-echo-probe || true; rm -f /tmp/orca-echo-probe', 'echo-probe', body.data.header, body.data.placeholder, url, marker], + timeoutMs: 30_000 + }) + const [status, count] = result.stdout.trim().split('\n') + const markerFound = Number(count ?? '0') > 0 + console.log(JSON.stringify({ event: 'provider_echo_probe', sandboxId: row.id, markerFound })) + return Response.json({ sandboxId: row.id, status: Number(status) || null, markerFound }) + } if (policyAudit[2] === 'provider-policy-audit' && request.method === 'GET') { const marker = new URL(request.url).searchParams.get('marker') ?? '' if (marker.length < 12 || !marker.startsWith('orcaprobebogus')) { @@ -250,8 +280,24 @@ export async function handleOperator( const EgressModeBody = z.object({ mode: z.enum(['proxy', 'firewall']).nullable() }) -/** Redacted facts about a raw provider body: rule counts and header NAMES only, plus a marker substring test. */ -export function policyFacts(body: string, marker: string): { hasNetworkPolicy: boolean; transformRuleCount: number; headerNames: string[]; markerFound: boolean } { +/** Rule kinds in Vercel's redacted policy shapes (probe 2): injection = a header swap, forward, response. */ +const RULE_KINDS: Record = { + injectionrules: 'injection', + transformrules: 'injection', + forwardrules: 'forward', + responserules: 'response' +} + +type RuleFacts = { count: number; headerNames: string[] } + +/** + * Redacted facts about a raw provider body: per rule kind, a count and header NAMES only, plus a marker + * substring test. A scrubbed policy reads as 0 injection rules and some response rules. + */ +export function policyFacts( + body: string, + marker: string +): { hasNetworkPolicy: boolean; injectionRules: RuleFacts; forwardRules: RuleFacts; responseRules: RuleFacts; markerFound: boolean } { let parsed: unknown = null try { parsed = JSON.parse(body) @@ -259,14 +305,20 @@ export function policyFacts(body: string, marker: string): { hasNetworkPolicy: b // Facts from the substring test only. } let hasNetworkPolicy = false - let transformRuleCount = 0 - const headerNames = new Set() - const walk = (value: unknown, key: string): void => { - if (Array.isArray(value)) { - if (/transform/i.test(key)) { - transformRuleCount += value.length + const kinds = { injection: { count: 0, names: new Set() }, forward: { count: 0, names: new Set() }, response: { count: 0, names: new Set() } } + const collectNames = (rule: unknown, into: Set): void => { + const names = (rule as { headerNames?: unknown } | null)?.headerNames + if (Array.isArray(names)) { + for (const header of names) { + if (typeof header === 'string' && /^[A-Za-z0-9-]{1,64}$/.test(header)) { + into.add(header.toLowerCase()) + } } - value.forEach((item) => walk(item, key)) + } + } + const walk = (value: unknown): void => { + if (Array.isArray(value)) { + value.forEach(walk) return } if (value && typeof value === 'object') { @@ -274,17 +326,23 @@ export function policyFacts(body: string, marker: string): { hasNetworkPolicy: b if (/^networkpolicy$/i.test(name)) { hasNetworkPolicy = true } - if (/^headerNames$/i.test(name) && Array.isArray(child)) { - for (const header of child) { - if (typeof header === 'string' && /^[A-Za-z0-9-]{1,64}$/.test(header)) { - headerNames.add(header.toLowerCase()) - } - } + const kind = RULE_KINDS[name.toLowerCase()] + if (kind && Array.isArray(child)) { + kinds[kind].count += child.length + child.forEach((rule) => collectNames(rule, kinds[kind].names)) } - walk(child, name) + walk(child) } } } - walk(parsed, '') - return { hasNetworkPolicy, transformRuleCount, headerNames: [...headerNames].sort(), markerFound: body.includes(marker) } + walk(parsed) + const facts = (kind: keyof typeof kinds): RuleFacts => ({ count: kinds[kind].count, headerNames: [...kinds[kind].names].sort() }) + return { hasNetworkPolicy, injectionRules: facts('injection'), forwardRules: facts('forward'), responseRules: facts('response'), markerFound: body.includes(marker) } } + +const EchoProbeBody = z.object({ + host: z.enum(['httpbin.org', 'postman-echo.com']), + header: z.string().regex(/^[A-Za-z0-9-]{1,64}$/), + // A placeholder (ours are orca-ph-…, or Bearer orca-ph-…): never a value worth echoing. + placeholder: z.string().regex(/^(Bearer |token )?orca-ph-(?:[a-z0-9-]{1,80}-)?sbx_[a-f0-9]{24}$/) +}) diff --git a/cloud/apps/sandbox-control/test/provider-policy-audit.test.ts b/cloud/apps/sandbox-control/test/provider-policy-audit.test.ts index 5cad17477a4..c5d656b33ce 100644 --- a/cloud/apps/sandbox-control/test/provider-policy-audit.test.ts +++ b/cloud/apps/sandbox-control/test/provider-policy-audit.test.ts @@ -53,8 +53,42 @@ describe('provider-policy-audit (dev only)', () => { }) describe('policyFacts', () => { - it('counts transform rules and keeps header names only', () => { - const body = JSON.stringify({ session: { networkPolicy: { transformRules: [{ domain: 'a.com', headerNames: ['Authorization', 'x-api-key'] }, { domain: 'b.com', headerNames: ['bad header'] }] } } }) - expect(policyFacts(body, MARKER)).toEqual({ hasNetworkPolicy: true, transformRuleCount: 2, headerNames: ['authorization', 'x-api-key'], markerFound: false }) + it('counts injection, forward and response rules separately, with header names per kind only', () => { + const live = JSON.stringify({ session: { networkPolicy: { injectionRules: [{ domain: 'a.com', headerNames: ['Authorization', 'x-api-key'] }], forwardRules: [{ domain: 'b.com', headerNames: ['bad header'] }], responseRules: [{ domain: 'a.com', statusCode: 403 }] } } }) + expect(policyFacts(live, MARKER)).toEqual({ + hasNetworkPolicy: true, + injectionRules: { count: 1, headerNames: ['authorization', 'x-api-key'] }, + forwardRules: { count: 1, headerNames: [] }, + responseRules: { count: 1, headerNames: [] }, + markerFound: false + }) + // A scrubbed policy reads as no injection rules, response rules only. + const scrubbed = JSON.stringify({ session: { networkPolicy: { responseRules: [{ domain: 'a.com', statusCode: 403 }, { domain: 'a.com', statusCode: 403 }] } } }) + expect(policyFacts(scrubbed, MARKER)).toMatchObject({ injectionRules: { count: 0 }, responseRules: { count: 2 } }) + }) +}) + +describe('resume-raw and echo-probe (dev only)', () => { + it('echo-probe answers only whether the marker came back; placeholders only', async () => { + const { h, id } = await setup({ SANDBOX_ENV: 'dev' }) + h.vercel.commandHandler = (params) => + params.command === 'bash' && params.args?.[1]?.includes('orca-echo-probe') ? { exitCode: 0, stdout: '200\n1\n', stderr: '' } : undefined + const placeholder = `orca-ph-anthropic-api-key-${id}` + const ok = await h.call('POST', `/v1/internal/sandboxes/${id}/echo-probe?marker=${MARKER}`, { bearer: OP, body: { host: 'httpbin.org', header: 'x-api-key', placeholder } }) + expect(ok.body).toEqual({ sandboxId: id, status: 200, markerFound: true }) + const value = await h.call('POST', `/v1/internal/sandboxes/${id}/echo-probe?marker=${MARKER}`, { bearer: OP, body: { host: 'httpbin.org', header: 'x-api-key', placeholder: 'sk-ant-real' } }) + expect(value.status).toBe(400) + const elsewhere = await h.call('POST', `/v1/internal/sandboxes/${id}/echo-probe?marker=${MARKER}`, { bearer: OP, body: { host: 'evil.example', header: 'x-api-key', placeholder } }) + expect(elsewhere.status).toBe(400) + }) + + it('resume-raw resumes the provider session without writing a policy', async () => { + const { h, id, box } = await setup({ SANDBOX_ENV: 'dev' }) + const mia = await h.token('mia', 'acme', 'sandbox', {}) + expect((await h.call('POST', `/v1/sandboxes/${id}/suspend`, { bearer: mia })).status).toBe(200) + const before = JSON.stringify(box().policy) + const res = await h.call('POST', `/v1/internal/sandboxes/${id}/resume-raw`, { bearer: OP }) + expect(res.body.sandboxId).toBe(id) + expect(JSON.stringify(box().policy)).toBe(before) }) })