Compare commits

...
Author SHA1 Message Date
BaaRai 6bb2fe199e fix(server): judge NAT64 and 6to4 addresses by their embedded IPv4
POST /api/llm/models refused 64:ff9b::/96 and 2002::/16 as a whole. A
DNS64 resolver answers with a 64:ff9b::/96 address for every IPv4-only
name, so on a NAT64 network every public provider was refused and no
setting brought it back.

An address in 64:ff9b::/96 (the IPv4 address in the low 32 bits) or in
2002::/16 (the IPv4 address in bits 16 to 47) is now judged as the
IPv4 address it embeds, by the rule a bare IPv4 address gets: private,
loopback, link-local, metadata, reserved, carrier-grade NAT and
unspecified addresses stay refused, a public one is accepted. The rule
is the same for literal hosts, resolved names, redirects and at dial
time, and an endpoint listed in ARTEX_LLM_PRIVATE_ENDPOINTS gets behind
such an address what it gets as a bare IPv4 address.
2026-11-21 07:34:30 +01:00
BaaRai a1998685f9 fix(server): block carrier-grade NAT and reserved ranges; stop echoing upstream model errors
POST /api/llm/models treated every address outside RFC 1918, loopback,
link-local, multicast and the metadata addresses as public. It now
also refuses 100.64.0.0/10, 198.18.0.0/15, 192.0.0.0/24, 240.0.0.0/4,
NAT64 64:ff9b::/96 and 6to4 2002::/16, for literal hosts, resolved
names, redirects and at dial time. An endpoint listed in
ARTEX_LLM_PRIVATE_ENDPOINTS may still sit in 100.64.0.0/10 or
198.18.0.0/15, as it may in RFC 1918 space; the other ranges are never
allowed.

A non-200 answer was returned with the first 512 bytes of its body,
which let a caller read what any reachable host answers. The answer
now carries the status only.
2026-11-21 07:34:30 +01:00
BaaRai 6765d01b94 fix(server): keep the capture CA, index and blob store out of workspace deletes
The workspace file manager refused traffic/_ca and traffic/_index by
path, but DELETE /api/workspace/delete on their parent, traffic,
removed the whole tree: the capture CA private key, the exchange index
and the blobs went with it. The blob store, traffic/_blobs, was not
denied at all and could be listed, read and downloaded.

traffic/_blobs joins the denied prefixes, and a delete is refused with
400 when a denied prefix lies beneath the entry it would remove. A
symlink to such a directory is still removed as a link.
2026-11-21 07:34:30 +01:00
BaaRai 8eff7b907c fix(server): keep the setup token and proxy credentials out of the log sink
The log sink keeps every standard-logger line in a ring, persists it to
server_logs and serves it through /api/logs, /api/logs/history and
/api/logs/stream to any session. Two secrets went through it.

The one-time setup token was logged with log.Printf. It is now printed
on stderr directly, with the same wording, so `docker compose logs` and
the journal still show it; the sink gets a line that says where it was
printed.

A global proxy with user:password was logged in full when the browser
MCP was synced and when a stored value failed validation at startup,
and was written with its credentials into the --proxy-server argument
of the browser MCP row, which GET /api/mcp lists. The log lines and the
row now carry the proxy without its userinfo. A stored address that
does not parse is not written to the row at all.

As a second line of defence the sink masks the password of any
scheme://user:password@ it is given, in the ring and on stderr, and
rows persisted earlier are masked when they are read back.
2026-11-21 07:34:30 +01:00
BaaRai ee35fb4b29 fix(server): refuse cookie-authenticated state changes from a foreign origin
requireAuth accepted the artex_token cookie on its own for every method
and checked neither Origin nor Sec-Fetch-Site. The handlers decode a
JSON body whatever its Content-Type, so a page on another origin of the
same site (another port of the host, a sibling subdomain) could send a
text/plain POST that the browser sends without a preflight and with the
cookie: POST /api/mcp stored a server entry with a command.

A POST, PUT, PATCH or DELETE whose session comes from the cookie must
now be same-origin: Sec-Fetch-Site is same-origin, or Origin names the
scheme, host and port the request was sent to. Anything else, including
a request with neither header, is answered 403. Requests that carry a
bearer token are not checked, nor are GET and HEAD. The /api/auth/*
routes stay outside requireAuth, so setup and login are unchanged. The
web console sends the bearer token on every state-changing request.
2026-11-21 07:34:30 +01:00
BaaRai 57d3bf67e7 fix(intercept): fail closed when the rule store cannot be read
A failed rule load left the enabled-tools set nil, so IsToolEnabled
answered false for every tool and the guard returned before any rule
ran; Match, MatchBuiltin and MatchPersistence answered "no match" on
the same error. A database outage therefore let every tool call run
unchecked.

Now, when the rules or the enabled-tools setting cannot be read,
IsToolEnabled answers true so the call reaches the rule path, and the
three matchers return a deny. The error is logged once per outage. A
failed read of the enabled-tools setting counts as a failed load
instead of silently selecting the defaults.

A deny or ask rule whose pattern does not compile is no longer skipped:
it matches every call as a deny until it is fixed or disabled. A broken
allow rule still allows nothing.
2026-11-21 07:34:29 +01:00
BaaRai 5876d517f8 Merge pull request #435 from BaaRai/feat/tamper-hooks-ui
P4.2 PR2: Traffic Hooks admin panel, versions/rollback and dry-run UI
2026-11-21 01:34:03 +01:00
BaaRai e712c05ccd feat(web): add Traffic > Hooks admin panel, versions/rollback, and dry-run UI (P4.2 PR2) 2026-11-21 01:20:05 +01:00
BaaRai f787b5f6ee Merge pull request #434 from BaaRai/feat/tamper-hooks-backend
feat(traffic): constrained Go tampering hooks, backend and admin API (P4.2 PR1)
2026-11-21 01:19:22 +01:00
BaaRai 7933df96f3 test: stabilize the UDP control-close test and the sealed hook test
The UDP close test raced the asynchronous association close with a goroutine count heuristic; probe until forwarding stops instead. The sealed hook test called InitSecrets with a fresh temp dir on a database already sealed by the package test key; use the package key. gofmt trace.go.
2026-11-21 01:00:52 +01:00
BaaRai e2eeea9bec Merge pull request #433 from BaaRai/feat/proxy-socks5-udp
feat(traffic): opt-in SOCKS5 UDP ASSOCIATE and raw UDP recording (P4.1c)
2026-11-21 00:48:36 +01:00
BaaRai db9e121f68 fix(traffic/hookvm): account string->[]byte, strSlice, append, and regexp.Compile in memory budget 2026-11-21 00:48:27 +01:00
BaaRai 680227b1ea docs: document constrained Go tampering hooks subset, API, and trace (P4.2 PR1) 2026-11-21 00:48:27 +01:00
BaaRai 76e936d8f3 feat(server): add admin API for tampering hooks (CRUD, toggle, versions, rollback, dry-run) 2026-11-21 00:48:27 +01:00
BaaRai d522a9cc47 feat(traffic): integrate opt-in Go tampering hooks after rewrite rules with exchange_rewrites trace 2026-11-21 00:48:27 +01:00
BaaRai f7779ff1de feat(db): add traffic_tamper_hooks migration 0011, sealed CRUD, versions, and rollback 2026-11-21 00:48:27 +01:00
BaaRai 95d6d98307 feat(traffic/hookvm): add deterministic resource-bounded Go-subset VM and sandbox tests 2026-11-21 00:48:27 +01:00
BaaRai f45d75bda5 fix(intercept): keep the TCP dialer TCP-only after adding UDP parsing
P4.1c widened addrTarget to udp, which let PinnedDialer accept a non-TCP network and broke TestPinnedDialScopeUnreadableFailsClosed/network. Split addrTarget (TCP) from addrTargetUDP (UDP relay) so the TCP gate stays fail-closed while the UDP resolver keeps its parser.
2026-11-21 00:34:27 +01:00
BaaRai 82d8fa2b4a Merge pull request #432 from BaaRai/feat/proxy-transparent-tcp
feat(traffic): opt-in Linux transparent TCP inbound (P4.1b)
2026-11-21 00:20:02 +01:00
BaaRai 5c298aa523 Merge pull request #431 from BaaRai/feat/proxy-socks5-raw-tcp
feat(traffic): opt-in SOCKS5 CONNECT listener and raw TCP recording (P4.1a)
2026-11-21 00:05:31 +01:00
BaaRai 64765c74d7 Merge pull request #430 from BaaRai/chore/p36-hygiene
chore: P3.6 hygiene (web bundle, Go 1.26.11, dead code, dashboard indexes, test cleanup)
2026-11-20 23:20:51 +01:00
BaaRai 3c2c6991ca docs: document opt-in SOCKS5 UDP ASSOCIATE and raw UDP recording (P4.1c) 2026-11-20 23:16:52 +01:00
BaaRai bd2ee05caf test(traffic): add SOCKS5 UDP ASSOCIATE policy, bounds, store, and server PG tests 2026-11-20 23:16:52 +01:00
BaaRai 9b84442a7f feat(traffic): record SOCKS5 UDP datagrams in SQLite raw_udp_datagrams with blob refs 2026-11-20 23:13:10 +01:00
BaaRai 68e214c438 feat(traffic): add opt-in RFC 1928 SOCKS5 UDP ASSOCIATE relay with per-datagram policy 2026-11-20 23:12:19 +01:00
BaaRai 2d5906295c docs(traffic): note that IP/CIDR rules apply on transparent TCP (no hostname) 2026-11-20 23:08:42 +01:00
BaaRai 752d0cfab4 test: clean remaining residual rows across db, agent, and server test suites 2026-11-20 22:54:57 +01:00
BaaRai bd59d7d9d5 docs: document Linux transparent TCP inbound (P4.1b) and firewall rules/cleanup 2026-11-20 22:52:51 +01:00
BaaRai 095d3a57d4 test(traffic): add transparent TCP unit, policy, store, and Linux iptables REDIRECT tests 2026-11-20 22:52:51 +01:00
BaaRai 82691f1cc2 feat(traffic): add opt-in Linux IPv4 transparent TCP listener (SO_ORIGINAL_DST) 2026-11-20 22:52:50 +01:00
BaaRai 792e965f26 fix(traffic): atomic temp+rename raw TCP blob spill and document SOCKS5 proxy caveats 2026-11-20 22:44:20 +01:00
BaaRai afa5d0e1a1 docs: document opt-in SOCKS5 raw TCP capture (P4.1a) and update CHANGELOG 2026-11-20 22:32:18 +01:00
BaaRai 026213f216 Merge pull request #398 from YunzhouLi-hub/fix/show-bash-exit-127
fix(web): explain Bash exit 127 in session transcripts
2026-11-20 22:30:55 +01:00
BaaRai 8b49362db4 test(traffic): add SOCKS5 listener and raw TCP recording tests 2026-11-20 22:30:08 +01:00
BaaRai 551c14e644 feat(traffic): record raw TCP streams in SQLite store with previews and blob refs 2026-11-20 22:23:24 +01:00
BaaRai 19af5ba329 feat(traffic): add opt-in RFC 1928 SOCKS5 CONNECT listener with target gate and egress governor 2026-11-20 22:22:13 +01:00
BaaRai 49721523c5 fix(i18n): add the zh-CN translation for the bash exit 127 notice 2026-11-20 22:21:57 +01:00
BaaRai 79119ae9bd test: clean up residual findings, retest conversations, parent assets, and test rows 2026-11-20 22:18:53 +01:00
BaaRai 0d332d18be Merge remote-tracking branch 'origin/main' into pr398-wire
# Conflicts:
#	web/package.json
2026-11-20 22:12:54 +01:00
BaaRai b7e3079059 test(web): run the bash exit 127 test in the web job 2026-11-20 22:12:23 +01:00
BaaRai 9057b36e55 Merge pull request #318 from renaesop/codex/s3-archive-server
feat: connect S3 task archives with recoverable server lifecycle
2026-11-20 21:56:56 +01:00
BaaRai b3b9334dc8 perf(db): add partial covering indexes for dashboard/usage queries (migration 0010) 2026-11-20 21:48:31 +01:00
BaaRai 65876b7abb fix(server): scrub the container authorization token file path too
The SDK reads AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE while LoadDefaultConfig
builds the archive store and captures the path; the file itself is read lazily.
Adding the name to secretEnv keeps that path out of agent child processes, the
same way AWS_WEB_IDENTITY_TOKEN_FILE is already scrubbed, and does not affect
the client.
2026-11-20 21:45:15 +01:00
BaaRai 33e8d79426 chore: remove provably unused unexported Go helpers and dead web template files 2026-11-20 21:43:43 +01:00
BaaRai 42e8d3554d chore(deps): bump Go to 1.26.11 and x/crypto to v0.59.0 (govulncheck) 2026-11-20 21:28:26 +01:00
BaaRai 3593297664 fix(server): do not fsync the journal directory on Windows
writeRemoteArchiveJournal ended with Sync on two directory handles.
Windows cannot flush a directory handle, so the journal write failed
there and no remote archive or remote deletion could start.

Move the directory sync to syncDir: the unix build keeps the fsync, the
other builds return nil (the journal file itself is already synced).
2026-11-20 21:13:55 +01:00
BaaRai 74116993cc fix(server): fail the archive job instead of crashing on a worker panic
The archive worker goroutine had no recover. An S3-compatible endpoint
that answers CreateMultipartUpload with 200 and no UploadId makes the
SDK upload manager dereference a nil pointer, which ended the server.

Run each claimed job under a recover: log the panic value and stack and
return it as the job error, so the job is failed through the same
FailTaskArchiveJob path as any other error. The job's deferred rollbacks
have run by then, so the source data stays in place.

FailTaskArchiveJob now only fails a job that is still in its active
state. A panic recovered after the archive committed would otherwise
turn a ready archive into archive_failed, which can be neither restored
nor deleted.
2026-11-20 21:13:55 +01:00
BaaRai 745204423c fix(server): scrub ambient AWS credential variables from child processes
The archive store falls back to the AWS SDK default chain when no
ARTEX_ARCHIVE_S3_* override is set. Those AWS_* variables stayed in the
environment after startup, so agent shells, custom tools and MCP stdio
servers inherited them. Add them to secretEnv: they are scrubbed after
the store is built and kept out of /proc/<pid>/environ by the seal.

The SDK captures what it needs at config load. Tests cover static keys
(both spellings), container credentials and web identity fetched after
the scrub, and a real New with WithSecretScrub.
2026-11-20 21:05:22 +01:00
BaaRai caa38f6ca8 chore(web): remove dead imports, unused template components, and 18 unused dependencies 2026-11-20 21:02:09 +01:00
BaaRai 0d85fc9b06 Merge pull request #427 from BaaRai/feat/worker-cache-prefix
feat(agent): opt-in worker cache-prefix split (P3.5 phase C)
2026-11-20 20:57:10 +01:00
BaaRai 40a43580fe Merge pull request #410 from tglemser/fix/record-fact-facts-only-schema
fix(agent): publish record_fact as a facts-only contract
2026-11-20 20:48:32 +01:00
BaaRai 5def7bf57e docs(server): correct the record_fact refresh comment 2026-11-20 20:07:50 +01:00
BaaRai 268693066a Merge pull request #413 from BlackGownQ/feat/i18n-zh-cn
feat(i18n): add Simplified Chinese locale using the existing translation layer
2026-11-20 20:00:03 +01:00
BaaRai 0ffb0a68c4 Merge pull request #420 from ldevbr/contrib/api-recon-npm-registry
skills(api-recon): point the lockfile at the public npm registry
2026-11-20 19:59:45 +01:00
BaaRai 892d1330f6 Merge pull request #416 from ldevbr/contrib/npm-ci-ignore-scripts
build: run npm ci with --ignore-scripts in the build/install/update s…
2026-11-20 19:59:28 +01:00
BaaRai 11adad32ce Merge pull request #415 from ldevbr/contrib/bump-vuln-deps
deps: bump klauspost/compress and brotli to fix known advisories
2026-11-20 19:59:10 +01:00
BaaRai 49c5e8fa8a Merge pull request #406 from maheshBawa/fix/compose-llm-private-endpoints
fix(compose): pass ARTEX_LLM_PRIVATE_ENDPOINTS to the artex container
2026-11-20 19:58:40 +01:00
BaaRai f6f9575b19 Merge pull request #401 from YunzhouLi-hub/feat/neon-theme-preset
feat(web): add an optional Neon theme preset
2026-11-20 19:58:29 +01:00
BaaRai 280e99eace Merge pull request #396 from YunzhouLi-hub/docs/tool-input-troubleshooting
docs: troubleshoot empty tool input in session transcripts
2026-11-20 19:58:19 +01:00
BaaRai e2ca0118e7 Merge pull request #400 from YunzhouLi-hub/docs/first-time-contributors
docs: add a first-contribution guide
2026-11-20 19:58:08 +01:00
BaaRai 1e9079267b Merge pull request #411 from adam-33-pixel/fix/llmrec-explicit-stop-status
llmrec: decide usage status when the consumer stops reading
2026-11-20 19:57:57 +01:00
BaaRai aa8ba54efb fix(server): reword the record_fact default-mismatch log line 2026-11-20 19:13:38 +01:00
BaaRai 5e1c55db4d fix(server): recognise the released record_fact descriptions as known defaults
The releases v0.4.0 to v0.6.0 seed a record_fact description without the source bullet and their own facts property description. Neither was in the list of known defaults, so the one-time refresh kept both texts on a database seeded by a release and logged the description as an operator edit.

Both released texts are now known defaults, taken byte for byte from agent/tools.go at those tags, and the log line says the description does not match a known default.
2026-11-20 18:48:06 +01:00
BaaRai 5679618ea7 ci: drop the stale skip note for the llmrec usage status test 2026-11-20 18:17:05 +01:00
BaaRai 9ab895f2b7 docs: link SECURITY.md in the first-contribution guide 2026-11-20 18:16:44 +01:00
BaaRai f758b4d964 fix(server): keep the record_fact refresh flag unset when the refresh fails
refreshRecordFactContract wrote its one-time flag in a defer, so a start on
which GetTool, the schema decode or the UPDATE failed still spent the flag.
No later start retried and the database kept the earlier description.

The flag is now written once the outcome is known: after the UPDATE
succeeded (also when it changed no row), or when the row is not the
built-in one. A failed read, decode or UPDATE leaves it unset and the next
start retries.

Test: TestFix410RefreshFlagNotSetOnFailure (an UPDATE refused by a trigger,
and a stored schema that does not decode; the next start refreshes the
text and sets the flag).
2026-11-20 18:11:42 +01:00
BaaRai c5cb1afad7 fix(agent): keep the record_fact harness opt-out through tool wrappers
record_fact opts out of the harness schema check (norma Spec.RawInput) and
validates its own input. The harness finds the opt-out with a type
assertion on the tool it is handed, and that tool is a wrapper: catalog
tools are metered (meteredTool), and guardPanic wraps every tool last
(guardedTool). Both embed CoreTool, which hides AcceptsRawInput, so the
opt-out was lost and a malformed call was answered by the SDK ("invalid
tool input: facts: expected array") instead of by the handler.

guardedTool and meteredTool now forward AcceptsRawInput, as overriddenTool
already does.

Test: TestFix410AcceptsRawInputSurvivesWrappers covers each wrapper and
record_fact through wireTools, AugmentTools and harness.Query.
2026-11-20 18:11:16 +01:00
Luis 3feeb37a3a deps: bump klauspost/compress and brotli to fix known advisories
- github.com/klauspost/compress 1.18.6 -> 1.20.2 (GO-2026-5841, GO-2026-6865)
- github.com/andybalholm/brotli 1.2.1 -> 1.2.7 (GO-2026-6888)

`go mod tidy` and `go build ./...` pass; the change is limited to these two
modules in go.mod/go.sum.
2026-11-20 10:26:02 -05:00
Luis bbe95d085b skills(api-recon): point the lockfile at the public npm registry
Every `resolved` URL in skills/api-recon/scripts/package-lock.json pointed at
registry.npmmirror.com (a third-party mirror). Repoint them to
registry.npmjs.org. The integrity hashes are unchanged and still valid, so the
tarballs are byte-identical; `npm ci --registry=https://registry.npmjs.org`
installs cleanly and puppeteer-core loads.
2026-11-20 10:26:01 -05:00
Luis 9be6b76420 build: run npm ci with --ignore-scripts in the build/install/update scripts
The Dockerfile already uses `npm ci --ignore-scripts`; the host-side build
helpers (build.sh, install.sh, update.sh) did not. Align them so a lifecycle
script in a dependency cannot run during a local rebuild. No package in the
current lockfile declares install scripts, so this is a hardening no-op today.
2026-11-20 10:26:01 -05:00
BlackGownQ ada0092168 feat(i18n): add Simplified Chinese translations 2026-11-20 23:21:59 +08:00
BlackGownQ 2d6d5c4e2b feat(i18n): register and document Simplified Chinese 2026-11-20 23:21:13 +08:00
BlackGownQ 12f0ec0432 test(i18n): validate catalogs and locale behavior 2026-11-20 23:20:24 +08:00
BlackGownQ 2ff2fc59ac test(i18n): run locale validation and runtime regression tests 2026-11-20 23:19:32 +08:00
renaesop 64a53ea9c1 fix: initialize archive credentials before startup environment scrub 2026-11-20 14:26:07 +00:00
renaesop 3f16151fc8 Merge remote-tracking branch 'upstream/main' into codex/s3-archive-server 2026-11-20 14:21:05 +00:00
Adam Rufaro Dzitiro 2db355389a llmrec: decide usage status when the consumer stops reading 2026-11-20 12:21:22 +02:00
tglemserandClaude Mythos 5.1 6e906b4920 fix(agent): publish record_fact as a facts-only contract
The schema the model sees for record_fact declared every fact field twice:
at the top level (single-fact shape) and inside facts[] (batch shape), with
the handler deciding which shape a call is. A model that fills every
declared property sends the single fact inside facts[] and a copy, or a
placeholder such as "", [] or "x", of each field beside it; since PR #282
every such call is refused by name, and the refusal text ("summary is not
allowed at the top level") leads the model to send a dummy value next, so
the same refusal repeats until the intent ends. Observed with a model over
the OpenAI Responses API: 209 of 212 record_fact calls of two tasks were
refused, 156 of them identical in one intent.

The published schema is now {facts:[{...}]} and nothing else (required:
facts, additionalProperties false). The handler keeps the strict contract
of PR #282: unknown or mis-cased fields, invalid or foreign asset ids,
missing summaries, empty batches and any top-level field beside facts
(other than the legacy intent_id) are refused before anything is written,
with an error that names the fields and the one accepted shape. It still
accepts the legacy single fact and the legacy batch with a top-level
intent_id. An item without intent_id is linked to the intent the worker is
running (SetOwnerNode), as report_finding already does.

record_fact opts out of the harness schema check (norma Spec.RawInput) so
the stricter published schema does not reject the legacy shapes before the
handler sees them; the catalog decorator forwards the opt-out.
RepairRecordFactSchema republishes stored and cached schemas as facts-only
and keeps the annotations of facts and its items. A one-time startup
refresh replaces the stored description and the texts that referred to the
top level when they equal the previous defaults; operator edits stay and
are logged. seedFactSourceSchema adds the source enum on the items.

Tests: the handler contract (TestRecordFactSummaryContract,
TestRecordFactStrictFields, TestRecordFactBatchTopLevelConflicts,
TestRecordFactRefusesTopLevelCopiesBesideFacts), the published schema and
its repair (TestRecordFactSchemaIsFactsOnly, TestRecordFactStoredContractRepair,
TestRecordFactInputSchemaUpgrade, TestRecordFactSourceSchemaUpgrade,
TestWireTools), the running-intent default, the one-time refresh
(TestRefreshRecordFactContract) and a synthetic replay of the call shapes
(TestRecordFactShapesReplay).

Co-Authored-By: Claude Mythos 5.1 <noreply@anthropic.com>
2026-11-20 10:03:52 +00:00
maheshBawaandClaude Opus 5.5 594d1918fd fix(compose): pass ARTEX_LLM_PRIVATE_ENDPOINTS to the artex container
The model-list allow-list (#390) is read from the
environment, but docker-compose.yml never forwarded it, so a Docker install
could not list models from a local Ollama at host.docker.internal:11434.
Empty by default, so the strict public-only policy is unchanged.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-11-20 14:43:27 +05:30
李云周 84c77021c4 feat(web): add an optional Neon theme preset 2026-11-20 15:24:57 +08:00
李云周 5e979f102a docs: add a first-contribution guide 2026-11-20 15:18:38 +08:00
李云周 bb22be6972 fix(web): explain Bash exit 127 in session transcripts 2026-11-20 15:03:45 +08:00
李云周 cc465be782 docs: explain empty tool input in session transcripts 2026-11-20 14:59:02 +08:00
renaesop 044fbdf2cb Merge remote-tracking branch 'upstream/main' into codex/s3-archive-server 2026-11-20 02:18:38 +00:00
Chubboy Ren f69eb060e3 Merge remote-tracking branch 'upstream/main' into codex/s3-archive-server 2026-11-19 03:33:51 +00:00
Chubboy Ren 672a38e2be fix: recover partial archives and defer unknown storage labels 2026-11-19 03:33:51 +00:00
Chubboy Ren bdd14ff7f0 feat: wire remote task archive lifecycle and recovery 2026-11-18 02:05:18 +00:00
182 changed files with 19538 additions and 3363 deletions
+2
View File
@@ -21,6 +21,8 @@ ARTEX_LLM_PROVIDER=
ARTEX_LLM_MODEL=
ARTEX_LLM_BASE_URL=
ARTEX_LLM_PROXY=
# Allow the UI model list to reach a local Ollama, e.g. host.docker.internal:11434
ARTEX_LLM_PRIVATE_ENDPOINTS=
# Untrusted-output boundary. Frames every tool output between nonce-tagged markers so
# the model treats it as data, not instructions. On by default (unset or empty = on);
+1 -2
View File
@@ -39,8 +39,6 @@ jobs:
# - TestGraphOverviewExpandsAssociatedCompanyScope,
# TestCaptureApprovalLifecycle: fail on unmodified upstream code with a
# fresh database.
# - TestSideUsageRecordedOnceOnConsumerCancellation: concurrency/cancellation
# test that passes locally but is timing-sensitive on 2-core CI runners.
# They now skip themselves in code (t.Skip with a pointer to the issue).
- name: go test
# -p 1: package test suites share the single postgres service; running
@@ -150,6 +148,7 @@ jobs:
- run: npm run test:replay
- run: npm run test:upload
- run: npm run test:i18n
- run: npm run test:bash
- run: npm run build:static
python:
+5
View File
@@ -23,6 +23,10 @@ All notable changes to this project are documented in this file. The format is b
- **`ask_operator` target warning**: a request whose question names a host or URL outside the goal targets is tagged as containing target-derived text (#197).
- **Opt-in update banner**: `ARTEX_UPDATE_CHECK` makes the backend check the latest GitHub release at most once per 24 hours and the UI show a banner; off by default (#202).
- **Release provenance**: release archives carry GitHub build provenance attestations and a CycloneDX SBOM (`gh attestation verify <zip> --repo BaaRai/ARTEX`); release notes are the matching `CHANGELOG.md` section (#219, #201).
- **Opt-in constrained Go tampering hooks — backend, API & trace (P4.2 PR1)**: opt-in behind `ARTEX_TAMPER_HOOKS_ENABLED=1` (off by default; flag off loads zero hooks and keeps the no-hook baseline unchanged). Adds a small, deterministic, zero-dependency Go-subset evaluator (`traffic/hookvm`, parsed via `go/parser` with sorted map iteration, hard 100k step / 25 ms per-hook / 100 ms per-phase / 4 MiB memory bounds, and AST rejection of FS/network/exec/env/time/rand/goroutine/channel/defer/goto/global-var/pointer/switch constructs). Operator-only hooks (never an agent tool) are stored sealed at rest in `traffic_tamper_hooks` and `traffic_tamper_hook_versions` (migration `0011_traffic_tamper_hooks.sql`), managed via `/api/traffic/hooks*` (CRUD, toggle, version history, rollback, dry-run), prefiltered with `traffic/rewrite` matchers, executed after declarative rewrite rules per phase (fail-open only in 0.7; binary/compressed/>1 MiB bodies skipped; tainted sensitive fields stay HMAC-masked), and traced in SQLite `exchange_rewrites` (`source_kind`, `hook_id`, `hook_version`). See `docs/traffic-tamper-hooks.md`.
- **Opt-in SOCKS5 UDP ASSOCIATE & raw UDP recording (P4.1c)**: when traffic capture is enabled, setting `ARTEX_SOCKS5_UDP_ENABLED=1` enables RFC 1928 `UDP ASSOCIATE` (`0x03`, IPv4 first) on the SOCKS5 listener (off by default: with flags off no listener starts; with SOCKS5 TCP on and UDP off, `UDP ASSOCIATE` returns `0x07` and no UDP socket is opened). Enforces per-datagram destination policy before forwarding using the existing target gate (`intercept.Interceptor.ResolveUDP4` / `intercept.PinnedUDP4Resolver`) and egress governor (`egress.Do`), dropping denied datagrams without passthrough; bounds associations (`UDPMaxDatagrams`, `UDPMaxBytes`, `UDPIdleTimeout`) and tears them down with the TCP control connection; drops `FRAG != 0` with no fragmentation reassembly; and records each forwarded datagram individually in SQLite `raw_udp_datagrams` with capped previews and atomic `_blobs` refs without writing HTTP `exchanges` rows or PG migrations. Transparent UDP (`IP_RECVORIGDSTADDR`) is deferred to C2. See `docs/traffic-socks5-udp.md`.
- **Opt-in Linux transparent TCP inbound & raw TCP recording (P4.1b)**: on Linux when traffic capture is enabled, setting `ARTEX_TRANSPARENT_TCP_ENABLED=1` (loopback `127.0.0.1:1081` by default) or `ARTEX_TRANSPARENT_TCP_ADDR=<ipv4:port>` starts an IPv4 transparent TCP listener fed by operator-managed `iptables`/`nftables` `REDIRECT` rules (off by default; ARTEX never touches the host firewall; root/`CAP_NET_ADMIN` is required only for the operator's redirect rules; IPv6 is not covered). Recovers original IPv4 destinations via `SO_ORIGINAL_DST` with self-redirect loop protection, reuses the P4.1a target gate (`intercept.Interceptor.DialSOCKS5`), egress governor (`egress.Do`), half-close relay bounds, and SQLite `raw_tcp_streams` store (atomic `_blobs` spill, no HTTP `exchanges` row, no PostgreSQL migration). See `docs/traffic-transparent.md`.
- **Opt-in SOCKS5 inbound proxy & raw TCP recording (P4.1a)**: when traffic capture is enabled, setting `ARTEX_SOCKS5_ENABLED=1` (loopback `127.0.0.1:1080` by default) or `ARTEX_SOCKS5_ADDR=<addr>` starts an RFC 1928 SOCKS5 `CONNECT` listener alongside the HTTP recording proxy (off by default; HTTP proxy and agent proxy env vars are unchanged; listener does not start if traffic recording is disabled). Accepts loopback no-auth and RFC 1929 username/password without verifying credentials (carrying `artex-pace` in the username; binding to a non-loopback address therefore exposes an unauthenticated proxy, though the target gate and governor still apply), rejects `BIND`/`UDP ASSOCIATE` with `0x07`, enforces the existing target gate (`intercept.Interceptor.DialSOCKS5` / `intercept.PinnedDialer`) and egress governor (`egress.Do`) before dialing, relays half-close-aware TCP with concurrency/byte/idle/handshake bounds, and records one row per connection in SQLite `raw_tcp_streams` with capped directional previews and atomic (temp+rename) `_blobs` refs without writing HTTP `exchanges` rows. See `docs/traffic-socks5.md`.
- **Opt-in worker cache-prefix split (P3.5 Phase C)**: setting `ARTEX_CACHE_PREFIX=1` (off by default) splits the `worker` system prompt at `DynamicBoundary = 1` into a sibling-shareable static prefix (`body + untrustedContentTail + workerTrafficBlock`) and a per-intent dynamic suffix (`workerArtifactSpec(runDir)` through `<available-deferred-tools>`) without reordering sections or altering the visible joined prompt text. Planner, mainagent, chat, and goals are unchanged; custom worker prompts referencing `{{.Now}}` remain volatile in the static segment. See `docs/context-telemetry.md`.
- **Opt-in LLM context size telemetry (P3.5 Phase A)**: setting `ARTEX_CONTEXT_TELEMETRY=1` (off by default) records per-call request section byte sizes (`system_static`/`system_dynamic` split at `DynamicBoundary`, serialized `tools`, `messages` by role, `tool_result` subset, and `last_message_bytes`), tool/message counts, and token/cache usage in the new `llm_context` table (migration `0009_llm_context.sql`), with zero prompt/behavior change and zero content stored, independent of `llm_record`. `GET /api/llm/context/summary` aggregates input percentiles (`p50`/`p90`/`p99`), pro-rata section shares over real `input_tokens`, `cache_read/input` ratios by `(worker, model)`, and top tasks. See `docs/context-telemetry.md`.
- **HAR 1.2 traffic import and export**: `POST /api/traffic/import/har` imports raw HAR 1.2 JSON captures (up to 32 MiB / 2,000 entries / 32 MiB decoded bodies) with deterministic `har-<sha256>` IDs (and `_artexExchangeId` preservation for ARTEX exports so distinct same-second exchanges round-trip without collapsing), base64 decoding, `postData.params` and `cookies` array fallbacks, URL userinfo stripping, blob spilling above 256 KiB, and full-text indexing, without applying capture rewrite rules (`exchange_rewrites` stays empty); per-entry errors are reported alongside `imported`/`skipped`/`failed` counts. `GET /api/traffic/export/har` exports filtered traffic (reusing the `GET /api/traffic` filters) as a compliant HAR 1.2 document (with explicit unknown placeholders for unrecorded timings and header sizes) in stable `(ts, id)` order, encoding UTF-8 bodies as text and binary bodies as base64, capped at 1,000 entries / 20 MiB raw headers+bodies (31 MiB JSON backstop, guaranteed under the 32 MiB import limit) with explicit truncation reporting via `X-ARTEX-HAR-*` headers and `_truncated`/`_truncatedReason`/`_totalMatched` fields. The Traffic page adds **Import HAR** and **Export HAR** controls. See `docs/traffic-har.md`.
@@ -53,6 +57,7 @@ All notable changes to this project are documented in this file. The format is b
### Fixed
- **LLM usage status on early stream exit**: when a consumer stops reading a stream before `message_stop`, the recorder now stores the `llm_usage` row as `error` at that point, whether or not the context was cancelled, instead of inferring the status from `ctx.Err()` in a deferred call. `TestSideUsageRecordedOnceOnConsumerCancellation` runs again (follow-up to #9).
- **Workspace and skill symlink confinement**: workspace file operations, the skill file APIs and the skill loader resolve symlinks in every path component and refuse a target outside their root, so a link planted in the workspace or a skill directory cannot expose another file.
- **Target gate behind proxies**: a target approval is name-only whenever a proxy is in the path, including the recording proxy, the global egress proxy and a custom tool's own proxy, so the gate never claims an IP binding the proxy does not enforce.
- **Remote MCP response bound**: Streamable HTTP JSON-RPC bodies and SSE data payloads are refused above 8 MiB, so a remote MCP server cannot force an unbounded decode.
+7
View File
@@ -1,5 +1,12 @@
# Contributing
## First contribution
- **Share feedback.** Check [open issues](https://github.com/BaaRai/ARTEX/issues) for the same problem or proposal and add any new details there. For a new idea, explain what you were trying to do and what would make it easier.
- **Report a problem.** Include a short reproduction and the relevant environment. For a UI issue, a sanitized screenshot and the browser version can help. Remove credentials, private URLs, and sensitive task data before posting.
- **Report a security issue.** Do not open a public issue for a vulnerability; follow [SECURITY.md](SECURITY.md) to report it privately.
- **Send a small change.** A documentation correction or a focused UI improvement is a good place to start. Check [open pull requests](https://github.com/BaaRai/ARTEX/pulls) for overlapping work and refer to the relevant issue in your PR so readers can find the discussion.
## Pull requests
- **At most 7 open pull requests per contributor.** The repository enforces this with GitHub's pull request creation limit, drafts included: when you reach it, close or merge one before opening another. Review is manual, one change at a time, so a larger batch makes the queue unmanageable and slows everyone down, including you. If you have more changes queued, open one issue that lists them and wait for the current ones to be reviewed.
+19
View File
@@ -545,6 +545,25 @@ a trusted peer can claim any client address.
## Operations
### Troubleshooting an empty tool call
In the task's session transcript, expand the affected tool call and compare **Command** and
**Output**. The `UNTRUSTED_OUTPUT` markers identify the boundary around tool output. They are
expected and should stay enabled while troubleshooting.
- **Command shows `{}`.** The recorded tool input is an empty JSON object. For a tool that
requires a command, this means its command argument was missing. Check which model and version
produced the call.
- **Command shows `(empty)` or `(failed to load)`.** The transcript has no input detail to display
or could not fetch it. If the session record contains a command, include that discrepancy in a
report.
- **Output shows `[]`.** This is the recorded result body. Check the row's success or failure
indicator and its input separately before drawing conclusions about what ran.
For a recurring problem, share the ARTEX version or commit, the model and version, and a sanitized
excerpt of the affected input and result. Remove credentials, target data, and other sensitive
content before sharing.
### Backups
`scripts/backup.sh` dumps the Postgres database (and optionally the data directory) with
+2 -2
View File
@@ -45,9 +45,9 @@ Accepted gap: when a task has no allow-list, there is no allow rule to apply (bl
## Outbound Model Listing (`POST /api/llm/models`)
`POST /api/llm/models` fetches model lists from the provider endpoint and optional HTTP proxy supplied in the request. By default, ARTEX allows only `http` and `https` URLs whose hosts resolve exclusively to public IP addresses (blocking loopback, RFC1918 private networks, IPv6 unique-local `fc00::/7`, link-local/cloud metadata such as `169.254.169.254`, unspecified, and multicast addresses), and enforces the same checks on redirects and at dial time. The built-in local Ollama default (`http://127.0.0.1:11434/v1`) is permitted only when the request leaves `base_url` empty for the `ollama` provider.
`POST /api/llm/models` fetches model lists from the provider endpoint and optional HTTP proxy supplied in the request. By default, ARTEX allows only `http` and `https` URLs whose hosts resolve exclusively to public IP addresses (blocking loopback, RFC1918 private networks, IPv6 unique-local `fc00::/7`, link-local/cloud metadata such as `169.254.169.254`, unspecified, and multicast addresses, carrier-grade NAT `100.64.0.0/10`, the benchmarking range `198.18.0.0/15`, `192.0.0.0/24` and the reserved block `240.0.0.0/4`; a NAT64 `64:ff9b::/96` or 6to4 `2002::/16` address is judged by the IPv4 address it embeds), and enforces the same checks on redirects and at dial time. A non-200 answer from the endpoint is reported by its status only; its body is not returned. The built-in local Ollama default (`http://127.0.0.1:11434/v1`) is permitted only when the request leaves `base_url` empty for the `ollama` provider.
Operators running self-hosted LLM gateways or Ollama on a LAN or Docker bridge can allow specific endpoints with `ARTEX_LLM_PRIVATE_ENDPOINTS`, a comma-separated list of exact `host:port` entries (for example, `127.0.0.1:11434,host.docker.internal:11434,192.168.1.10:11434`). A URL whose `host:port` matches an entry may resolve to a loopback or private address while scheme restrictions, link-local/cloud-metadata blocks, and redirect validation still apply; everything else stays refused. Leaving `ARTEX_LLM_PRIVATE_ENDPOINTS` unset or empty keeps the strict public-only policy.
Operators running self-hosted LLM gateways or Ollama on a LAN or Docker bridge can allow specific endpoints with `ARTEX_LLM_PRIVATE_ENDPOINTS`, a comma-separated list of exact `host:port` entries (for example, `127.0.0.1:11434,host.docker.internal:11434,192.168.1.10:11434`). A URL whose `host:port` matches an entry may resolve to a loopback or private address, or to an address in `100.64.0.0/10` or `198.18.0.0/15` (an overlay network, a fake-IP resolver), while scheme restrictions, link-local/cloud-metadata blocks, the other reserved ranges above, and redirect validation still apply; everything else stays refused. Leaving `ARTEX_LLM_PRIVATE_ENDPOINTS` unset or empty keeps the strict public-only policy.
## Agent Process Isolation
+8
View File
@@ -101,6 +101,14 @@ func guardPanic(t actool.CoreTool) actool.CoreTool { return &guardedTool{CoreToo
type guardedTool struct{ actool.CoreTool }
// AcceptsRawInput forwards the wrapped tool's opt-out of the harness schema
// check, as overriddenTool does: this wrapper is the one the harness sees, and
// the embedded interface alone would hide the opt-out from its type assertion.
func (g *guardedTool) AcceptsRawInput() bool {
r, ok := g.CoreTool.(interface{ AcceptsRawInput() bool })
return ok && r.AcceptsRawInput()
}
func (g *guardedTool) Call(ctx context.Context, in json.RawMessage, tc *actool.ToolContext) (res actool.Result, err error) {
defer func() {
if r := recover(); r != nil {
+1 -1
View File
@@ -33,7 +33,7 @@ func TestTaskScopeLabelIsHonest(t *testing.T) {
// denominator and list_untested_assets.
func TestAutoScopeOutsideDeclaredRootExcluded(t *testing.T) {
d := testDB(t)
defer d.Close()
t.Cleanup(func() { _ = d.Close() })
stamp := time.Now().UnixNano()
declared := fmt.Sprintf("app.f8-%d.invalid", stamp)
+2 -2
View File
@@ -194,7 +194,7 @@ func companiesName(t *testing.T, companies *db.CompanyStore, companyID int64) st
func TestBlackboardToolsReadDirectSources(t *testing.T) {
d := testDB(t)
defer d.Close()
t.Cleanup(func() { _ = d.Close() })
grand, err := d.CreateTask("grand", "grand goal", nil, 0, 0)
if err != nil {
@@ -378,7 +378,7 @@ func TestBlackboardToolsReadDirectSources(t *testing.T) {
// model which ids it deferred, after de-duplicating and dropping invalid ids.
func TestGetWorkerTraceStepIDsDegradeGracefully(t *testing.T) {
d := testDB(t)
defer d.Close()
t.Cleanup(func() { _ = d.Close() })
task, err := d.CreateTask("trace-cap", "goal", nil, 0, 0)
if err != nil {
+1 -1
View File
@@ -16,7 +16,7 @@ import (
// write happens even when the stored flag is off, which is the outage behaviour.
func TestCoverageReadFailureKeepsToolsAndWritesAutoScope(t *testing.T) {
d := testDB(t)
defer d.Close()
t.Cleanup(func() { _ = d.Close() })
off := false
task, err := d.CreateTaskWithOptions("coverage outage", "goal", db.TaskCreateOptions{CoverageEnabled: &off})
if err != nil {
+3 -4
View File
@@ -115,10 +115,9 @@ func TestRecordFactAssetAliases(t *testing.T) {
func TestRecordFactAssetAliasSchema(t *testing.T) {
schema := NewToolSet(nil, "").recordFact().InputSchema()
props := schema["properties"].(map[string]any)
for _, name := range []string{"asset_ids", "tested_asset_ids"} {
if props[name] == nil {
t.Fatalf("single schema missing %s", name)
}
// Facts-only contract: the alias lives on the items.
if len(props) != 1 || props["facts"] == nil {
t.Fatalf("top level must hold facts only: %v", props)
}
item := props["facts"].(map[string]any)["items"].(map[string]any)
itemProps, _ := item["properties"].(map[string]any)
+88 -58
View File
@@ -4,10 +4,12 @@ import (
"bytes"
"encoding/json"
"fmt"
"sort"
"strings"
)
// Match strings.TrimSpace, including Unicode whitespace, in the published schema.
const factWhitespace = "\t\n\v\f\r \u0085\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000"
const factWhitespace = "\t\n\v\f\r \u0085   - 

   "
func factAssetIDSchema() map[string]any {
return map[string]any{
@@ -16,10 +18,13 @@ func factAssetIDSchema() map[string]any {
}
}
// factItemSchema is one fact: the shape of every facts[] item. It is also the
// shape of the legacy single-fact call (fields at the top level, no facts),
// which the handler still accepts but the published schema no longer shows.
func factItemSchema() map[string]any {
schema := obj(map[string]any{
"summary": str("Required on every fact: a non-empty one-sentence summary of this conclusion. Batch items do not inherit summary from the top level."),
"intent_id": idp("The intent that produced this fact; only this field inherits from the top level in a batch."),
"summary": str("Required: a non-empty one-sentence summary of this conclusion."),
"intent_id": idp("The intent that produced this fact. Omit it to link the fact to the intent this worker is running; a batch may name a different intent per item."),
"detail": str("Details of this fact, including all related observations."),
"evidence": str("One line of key evidence: the command and the most proving output lines. Put longer output in detail."),
"confidence": str("observed (seen directly in output) | inferred (inferred from phenomena). Label negative conclusions honestly."),
@@ -34,68 +39,67 @@ func factItemSchema() map[string]any {
return schema
}
// recordFactFactsDescription documents the only top-level property of
// record_fact. The wording tells a model that tends to fill every declared
// property that there is nothing else to fill.
const recordFactFactsDescription = "The facts to record, usually exactly one. Every item is a complete fact with its own summary. This is the only top-level property: never send summary, detail, evidence, confidence, source, intent_id or asset ids beside facts. Returned ids match item order; retry only failed indices."
// recordFactContractNote is appended to the record_fact description: the one
// call shape the model is given.
const recordFactContractNote = "\n★Call shape: exactly {\"facts\":[{...}]} with one item per distinct conclusion (usually one item). Each item carries its own summary, detail, evidence, confidence, source, asset_ids and, when it differs from the intent you are running, intent_id. Nothing else at the top level; a top-level fact field beside facts is refused and nothing is written."
// RecordFactContractNote exposes the text to the server's one-time refresh.
func RecordFactContractNote() string { return recordFactContractNote }
// recordFactSchema is the published input contract: facts[] and nothing else.
// Providers reject root-level anyOf, and the earlier contract (fact fields at
// the top level beside facts[]) made models fill both; the handler alone keeps
// the legacy shapes alive.
func recordFactSchema() map[string]any {
props := factItemSchema()["properties"].(map[string]any)
props["facts"] = map[string]any{
"type": "array", "minItems": 1, "items": factItemSchema(),
"description": "A non-empty batch of complete facts. Every item needs its own summary. Only intent_id inherits from the top level. Returned ids match item order; retry only failed indices.",
}
schema := obj(props)
// Providers reject root-level anyOf. The handler enforces single/batch mode.
schema := obj(map[string]any{
"facts": map[string]any{
"type": "array", "minItems": 1, "items": factItemSchema(),
"description": recordFactFactsDescription,
},
}, "facts")
schema["additionalProperties"] = false
return schema
}
// RepairRecordFactSchema restores the single/batch input contract in stored or
// cached schemas, preserving annotations only on fields the handler accepts.
// RepairRecordFactSchema brings a stored or cached record_fact schema to the
// facts-only contract. The structure always comes from the code; of the stored
// schema only the annotations (description, default) of facts and of its known
// item fields survive. Top-level fact fields of the earlier contract are
// dropped: the handler still accepts them, but the model must not see them.
func RepairRecordFactSchema(stored map[string]any) map[string]any {
raw, _ := json.Marshal(stored)
var out map[string]any
_ = json.Unmarshal(raw, &out)
if out == nil {
out = map[string]any{}
out := recordFactSchema()
facts := out["properties"].(map[string]any)["facts"].(map[string]any)
storedProps, _ := stored["properties"].(map[string]any)
storedFacts, _ := storedProps["facts"].(map[string]any)
if storedFacts == nil {
return out
}
mergeFactContract(out, recordFactSchema())
// A batch requires summaries on its items, never a redundant top-level one.
delete(out, "required")
delete(out, "anyOf")
canonical := recordFactSchema()["properties"].(map[string]any)
props := out["properties"].(map[string]any)
for name := range props {
if _, known := canonical[name]; !known {
delete(props, name)
if d, ok := storedFacts["description"].(string); ok && strings.TrimSpace(d) != "" {
facts["description"] = d
}
storedItems, _ := storedFacts["items"].(map[string]any)
storedItemProps, _ := storedItems["properties"].(map[string]any)
itemProps := facts["items"].(map[string]any)["properties"].(map[string]any)
for name, p := range itemProps {
sp, _ := storedItemProps[name].(map[string]any)
if sp == nil {
continue
}
}
items := props["facts"].(map[string]any)["items"].(map[string]any)
itemProps := items["properties"].(map[string]any)
for name := range itemProps {
if _, known := canonical[name]; !known || name == "facts" {
delete(itemProps, name)
prop := p.(map[string]any)
for _, key := range []string{"description", "default"} {
if v, ok := sp[key]; ok && v != nil {
prop[key] = v
}
}
}
return out
}
func mergeFactContract(dst, src map[string]any) {
for key, value := range src {
if key == "description" || key == "default" {
if _, ok := dst[key]; ok {
continue
}
}
if child, ok := value.(map[string]any); ok {
target, _ := dst[key].(map[string]any)
if target == nil {
target = map[string]any{}
dst[key] = target
}
mergeFactContract(target, child)
} else {
dst[key] = value
}
}
}
type recordFactInput struct {
Facts []factItem `json:"facts"`
factItem
@@ -103,6 +107,9 @@ type recordFactInput struct {
// Validate exact field names before decoding: encoding/json otherwise treats
// Summary, SUMMARY, etc. as aliases even with DisallowUnknownFields enabled.
// Three input shapes reach the handler: the published one ({facts:[...]}), the
// legacy single fact (fields at the top level, no facts) and the legacy batch
// with a top-level intent_id as the default of its items.
func decodeRecordFactInput(in json.RawMessage) (recordFactInput, bool, error) {
var out recordFactInput
fields, err := exactFactFields(in, true)
@@ -111,11 +118,6 @@ func decodeRecordFactInput(in json.RawMessage) (recordFactInput, bool, error) {
}
_, batch := fields["facts"]
if batch {
for name := range fields {
if name != "intent_id" && name != "facts" {
return out, true, fmt.Errorf("field %q is not allowed at the top level in batch mode; only intent_id and facts are accepted", name)
}
}
var items []json.RawMessage
if err := json.Unmarshal(fields["facts"], &items); err != nil {
return out, true, fmt.Errorf("facts must be an array: %w", err)
@@ -123,10 +125,16 @@ func decodeRecordFactInput(in json.RawMessage) (recordFactInput, bool, error) {
if len(items) == 0 {
return out, true, fmt.Errorf("facts must be a non-empty array of complete facts, each with its own summary")
}
itemFields := make([]map[string]json.RawMessage, len(items))
for i, item := range items {
if _, err := exactFactFields(item, false); err != nil {
f, err := exactFactFields(item, false)
if err != nil {
return out, true, fmt.Errorf("facts[%d]: %w", i, err)
}
itemFields[i] = f
}
if err := checkBatchTopLevel(fields, itemFields); err != nil {
return out, true, err
}
}
decoder := json.NewDecoder(bytes.NewReader(in))
@@ -137,6 +145,28 @@ func decodeRecordFactInput(in json.RawMessage) (recordFactInput, bool, error) {
return out, batch, nil
}
// checkBatchTopLevel enforces the contract at the top level of a facts[] call,
// where only facts and (legacy) intent_id carry meaning. Any other top-level
// field is refused by name before anything is written, including empty
// placeholders and copies of a fact's fields: a value there is at best
// redundant and at worst a second, conflicting claim. The message names the
// one accepted shape, so a model that filled every declared property of an
// older schema learns where the fields belong.
func checkBatchTopLevel(fields map[string]json.RawMessage, items []map[string]json.RawMessage) error {
var extra []string
for name := range fields {
if name == "intent_id" || name == "facts" {
continue
}
extra = append(extra, fmt.Sprintf("%q", name))
}
if len(extra) == 0 {
return nil
}
sort.Strings(extra)
return fmt.Errorf("top-level field(s) %s are not allowed beside facts (%d item(s)): record_fact takes only {\"facts\":[...]}; put every field of a fact inside its facts item and send nothing else at the top level", strings.Join(extra, ", "), len(items))
}
func exactFactFields(in json.RawMessage, topLevel bool) (map[string]json.RawMessage, error) {
var fields map[string]json.RawMessage
if err := json.Unmarshal(in, &fields); err != nil {
+54
View File
@@ -0,0 +1,54 @@
package agent
// Texts of the earlier record_fact contract (fact fields at the top level
// beside facts[]), kept verbatim so the server's one-time refresh
// (server/fact_input_schema.go) can tell a stored default from an operator
// edit. Nothing here is published to a model.
// recordFactLegacyDescription is the record_fact description seeded up to the
// facts-only contract.
const recordFactLegacyDescription = "Write an exploration [fact/conclusion] into the exploration graph, linked to the intent that produced it (intent_id). Used to record exploration results — both [positive conclusions] like fingerprinting/enumeration, and [negative conclusions] like 'port closed'/'parameter not injectable'/'no login entry found'.\n" +
"⚠️Multiple observations from one exploration must be [consolidated into ONE fact], not split into many; whenever they can be merged into one fact, use one: summary = a one-sentence summary of this conclusion, detail = the related details (may contain multiple concrete items). Example: a fingerprinting intent → one fact {summary:'identified the tech stack and response characteristics of site X', detail:'nginx 1.25 / Vue3 / 200 / title=.. / body_len=..'}, rather than one fact each for status code, fingerprint, and title. One intent usually produces exactly one fact; splitting too finely bloats the graph endlessly.\n" +
"★The facts array writes several [mutually distinct] conclusions at once (each may omit intent_id, defaulting to the top-level intent_id). Returns an ids array, same length and order as facts.\n" +
"⚠️Write only conclusions you [actually saw] in tool output — don't extrapolate. evidence and confidence keep inaccurate conclusions from polluting the graph:\n" +
" · evidence = [one line] of key evidence supporting this conclusion (the command + the one or two most proving output lines), **keep it brief** — details belong in detail; don't paste large output blocks here.\n" +
" · confidence = observed (seen directly in output) | inferred (inferred from phenomena).\n" +
" · source = where the content came from: target_response (content the target itself returned: page bodies, headers, error messages, banners, even when a tool fetched it) | tool_output (a tool's own result about the target: port states, scanner verdicts, status codes, timings) | third_party_intel (OSINT, CVE databases, public reports) | operator_input (given by the human operator) | inference (your own reasoning; the default when omitted). Any other value is refused.\n" +
" · **Negative conclusions** (not injectable / port closed / no entry found, etc.) state only \"observation + tentative reading\" — state what you actually saw; whether to abandon the direction is for the planner to decide globally; always provide evidence, mark inferred when the means weren't exhausted or the evidence is weak (including probed only once, looks-like), and mark observed only when truly exhausted and directly seen."
// recordFactReleasedDescription is the record_fact description seeded by the
// releases v0.4.0 to v0.6.0 (agent/tools.go at those tags): the text above
// without the source bullet.
const recordFactReleasedDescription = "Write an exploration [fact/conclusion] into the exploration graph, linked to the intent that produced it (intent_id). Used to record exploration results — both [positive conclusions] like fingerprinting/enumeration, and [negative conclusions] like 'port closed'/'parameter not injectable'/'no login entry found'.\n" +
"⚠️Multiple observations from one exploration must be [consolidated into ONE fact], not split into many; whenever they can be merged into one fact, use one: summary = a one-sentence summary of this conclusion, detail = the related details (may contain multiple concrete items). Example: a fingerprinting intent → one fact {summary:'identified the tech stack and response characteristics of site X', detail:'nginx 1.25 / Vue3 / 200 / title=.. / body_len=..'}, rather than one fact each for status code, fingerprint, and title. One intent usually produces exactly one fact; splitting too finely bloats the graph endlessly.\n" +
"★The facts array writes several [mutually distinct] conclusions at once (each may omit intent_id, defaulting to the top-level intent_id). Returns an ids array, same length and order as facts.\n" +
"⚠️Write only conclusions you [actually saw] in tool output — don't extrapolate. evidence and confidence keep inaccurate conclusions from polluting the graph:\n" +
" · evidence = [one line] of key evidence supporting this conclusion (the command + the one or two most proving output lines), **keep it brief** — details belong in detail; don't paste large output blocks here.\n" +
" · confidence = observed (seen directly in output) | inferred (inferred from phenomena).\n" +
" · **Negative conclusions** (not injectable / port closed / no entry found, etc.) state only \"observation + tentative reading\" — state what you actually saw; whether to abandon the direction is for the planner to decide globally; always provide evidence, mark inferred when the means weren't exhausted or the evidence is weak (including probed only once, looks-like), and mark observed only when truly exhausted and directly seen."
// recordFactLegacyItemDescriptions are the facts[] item descriptions of the
// earlier contract whose wording referred to the top level; the refresh
// replaces exactly these texts with the current ones.
var recordFactLegacyItemDescriptions = map[string]string{
"summary": "Required on every fact: a non-empty one-sentence summary of this conclusion. Batch items do not inherit summary from the top level.",
"intent_id": "The intent that produced this fact; only this field inherits from the top level in a batch.",
}
// recordFactLegacyFactsDescription is the facts property description of the
// earlier contract.
const recordFactLegacyFactsDescription = "A non-empty batch of complete facts. Every item needs its own summary. Only intent_id inherits from the top level. Returned ids match item order; retry only failed indices."
// recordFactReleasedFactsDescription is the facts property description seeded
// by the releases v0.4.0 to v0.6.0. RepairRecordFactSchema keeps a stored facts
// description, so the refresh has to know this text to replace it.
const recordFactReleasedFactsDescription = "[use when there are several distinct conclusions] array of facts; element fields same as the top-level fields below (summary/detail/evidence/confidence/intent_id/asset_ids); omitting intent_id falls back to the top-level intent_id. The returned ids match this array in length and order."
// RecordFactLegacyDescriptions returns the description texts of the earlier
// contract that the refresh may replace: the tool descriptions, the facts
// property descriptions and the item descriptions.
func RecordFactLegacyDescriptions() (tool, facts []string, items map[string]string) {
return []string{recordFactLegacyDescription, recordFactReleasedDescription},
[]string{recordFactLegacyFactsDescription, recordFactReleasedFactsDescription},
recordFactLegacyItemDescriptions
}
+244 -16
View File
@@ -3,9 +3,11 @@ package agent
import (
"encoding/json"
"regexp"
"strconv"
"strings"
"testing"
"github.com/Autumn-27/artex/db"
actool "github.com/Autumn-27/norma/tool"
)
@@ -47,6 +49,10 @@ func TestRecordFactSummaryContract(t *testing.T) {
}
}
// A stored schema of the earlier contract (fact fields at the top level beside
// facts[], operator annotations, a stray property) is republished as the
// facts-only contract; annotations of facts and of its items survive, the top
// level loses every fact field, and the result is idempotent.
func TestRecordFactStoredContractRepair(t *testing.T) {
old := map[string]any{
"type": "object", "required": []any{"summary"},
@@ -55,32 +61,40 @@ func TestRecordFactStoredContractRepair(t *testing.T) {
"summary": map[string]any{"type": "string", "description": "operator summary"},
"confidence": map[string]any{"type": "string", "default": "inferred"},
"custom_field": map[string]any{"type": "string"},
"facts": map[string]any{"type": "array", "items": map[string]any{"type": "object"}},
"facts": map[string]any{"type": "array", "description": "operator facts", "items": map[string]any{"type": "object", "properties": map[string]any{
"summary": map[string]any{"type": "string", "description": "operator item summary"},
"confidence": map[string]any{"type": "string", "default": "observed"},
"custom": map[string]any{"type": "string"},
}}},
},
}
base := NewToolSet(nil, "").recordFact()
repaired := DecorateTool(base, "operator tool", old)
schema := repaired.InputSchema()
if _, required := schema["required"]; required {
t.Fatal("batch still requires a top-level summary")
if req, _ := schema["required"].([]string); len(req) != 1 || req[0] != "facts" {
t.Fatalf("facts must be the only required property: %v", schema["required"])
}
if _, exists := schema["anyOf"]; exists {
t.Fatal("root anyOf reaches the provider")
}
props := schema["properties"].(map[string]any)
item := props["facts"].(map[string]any)["items"].(map[string]any)
if len(props) != 1 || props["facts"] == nil || schema["additionalProperties"] != false {
t.Fatalf("top level must hold facts only: %v", props)
}
facts := props["facts"].(map[string]any)
item := facts["items"].(map[string]any)
required := item["required"].([]string)
if len(required) != 1 || required[0] != "summary" || props["facts"].(map[string]any)["minItems"] != 1 {
if len(required) != 1 || required[0] != "summary" || facts["minItems"] != 1 {
t.Fatal("batch must require a nonempty list with a summary per item")
}
if props["summary"].(map[string]any)["minLength"] != 1 ||
item["properties"].(map[string]any)["summary"].(map[string]any)["minLength"] != 1 {
itemProps := item["properties"].(map[string]any)
if itemProps["summary"].(map[string]any)["minLength"] != 1 {
t.Fatal("empty summaries permitted by schema")
}
if repaired.Description() != "operator tool" ||
props["summary"].(map[string]any)["description"] != "operator summary" ||
props["confidence"].(map[string]any)["default"] != "inferred" || props["custom_field"] != nil {
t.Fatal("operator annotations lost")
if repaired.Description() != "operator tool" || facts["description"] != "operator facts" ||
itemProps["summary"].(map[string]any)["description"] != "operator item summary" ||
itemProps["confidence"].(map[string]any)["default"] != "observed" || itemProps["custom"] != nil {
t.Fatalf("item annotations lost or stray property kept: %v", itemProps)
}
if _, ok := old["properties"].(map[string]any)["tested_asset_ids"]; ok {
t.Fatal("shared old schema mutated")
@@ -94,9 +108,18 @@ func TestRecordFactStoredContractRepair(t *testing.T) {
if err := json.Unmarshal(first, &roundTrip); err != nil {
t.Fatal(err)
}
for _, input := range []string{`{"summary":"single"}`, `{"facts":[{"summary":"batch"}]}`} {
if err := actool.ValidateInput(roundTrip, json.RawMessage(input)); err != nil {
t.Fatalf("SDK rejects valid %s after catalog round trip: %v", input, err)
if err := actool.ValidateInput(roundTrip, json.RawMessage(`{"facts":[{"summary":"batch"}]}`)); err != nil {
t.Fatalf("SDK rejects the published shape after catalog round trip: %v", err)
}
// The legacy single shape no longer passes the published schema; the
// handler validates its own input instead, also behind the catalog wrapper.
if err := actool.ValidateInput(roundTrip, json.RawMessage(`{"summary":"single"}`)); err == nil {
t.Fatal("published schema must require facts")
}
for _, tool := range []actool.CoreTool{base, repaired} {
r, ok := tool.(interface{ AcceptsRawInput() bool })
if !ok || !r.AcceptsRawInput() {
t.Fatalf("%T must opt out of the harness schema check", tool)
}
}
}
@@ -140,7 +163,7 @@ func TestRecordFactStrictFields(t *testing.T) {
}
func TestRecordFactSchemaMatchesStrings(t *testing.T) {
props := recordFactSchema()["properties"].(map[string]any)
props := factItemSchema()["properties"].(map[string]any)
summary := regexp.MustCompile(props["summary"].(map[string]any)["pattern"].(string))
for _, value := range []string{"", " ", "\t\r\n", "\u00a0\u0085", "\u2003\u3000", "conclusion", " observed "} {
if got, want := summary.MatchString(value), strings.TrimSpace(value) != ""; got != want {
@@ -155,7 +178,7 @@ func TestRecordFactSchemaMatchesStrings(t *testing.T) {
}
}
for _, input := range []string{
`{"summary":"single","asset_ids":["1",2]}`,
`{"facts":[{"summary":"batch","asset_ids":["1",2]}]}`,
`{"facts":[{"summary":"batch","tested_asset_ids":["1",2]}]}`,
} {
if err := actool.ValidateInput(recordFactSchema(), json.RawMessage(input)); err != nil {
@@ -163,3 +186,208 @@ func TestRecordFactSchemaMatchesStrings(t *testing.T) {
}
}
}
// A model that fills every declared property of the earlier schema sends the
// single fact inside facts[] and a copy (or a placeholder) of every fact field
// beside it. Such a call is refused by name before any write, whether the
// copies are identical, empty or dummies, and the message names the one shape
// that is accepted. The published schema no longer declares those fields.
func TestRecordFactRefusesTopLevelCopiesBesideFacts(t *testing.T) {
store := guardTaskStore(t)
intentID := addGuardNode(t, store, db.KindIntent, map[string]any{"summary": "fingerprint the service"}, "running")
tools := NewToolSet(store, "worker")
before, err := store.ListByKind(db.KindFact, 100)
if err != nil {
t.Fatal(err)
}
id := strconv.FormatInt(intentID, 10)
fact := `{"summary":"TLS 1.0 is offered on port 8443","detail":"the handshake succeeded with TLSv1.0","evidence":"openssl s_client -tls1 → Protocol: TLSv1","confidence":"observed","source":"tool_output","intent_id":` + id + `,"asset_ids":[]}`
for _, tc := range []struct{ call, want string }{
// an exact copy of every field beside facts[]
{`{"summary":"TLS 1.0 is offered on port 8443","detail":"the handshake succeeded with TLSv1.0","evidence":"openssl s_client -tls1 → Protocol: TLSv1","confidence":"observed","source":"tool_output","intent_id":` + id + `,"asset_ids":[],"facts":[` + fact + `]}`, `"asset_ids", "confidence", "detail", "evidence", "source", "summary"`},
// empty placeholders only
{`{"summary":"","detail":"","evidence":"","confidence":"","source":"","asset_ids":[],"tested_asset_ids":[],"intent_id":` + id + `,"facts":[` + fact + `]}`, `"asset_ids", "confidence", "detail", "evidence", "source", "summary", "tested_asset_ids"`},
// dummy values
{`{"summary":"x","facts":[` + fact + `]}`, `"summary"`},
{`{"summary":null,"facts":[` + fact + `]}`, `"summary"`},
} {
w := tools.Writes().Facts
r := callGuardTool(t, tools.recordFact(), tc.call)
if !r.IsError || !strings.Contains(r.Flatten(), tc.want) || !strings.Contains(r.Flatten(), `record_fact takes only {"facts":[...]}`) || tools.Writes().Facts != w {
t.Errorf("%s: want refusal naming %s, got %s (writes %d→%d)", tc.call, tc.want, r.Flatten(), w, tools.Writes().Facts)
}
}
if n, err := store.ListByKind(db.KindFact, 100); err != nil || len(n) != len(before) {
t.Fatalf("refused calls wrote facts: %d → %d %v", len(before), len(n), err)
}
// The same fact in the published shape is written once and linked.
res := callGuardTool(t, tools.recordFact(), `{"facts":[`+fact+`]}`)
if res.IsError || tools.Writes().Facts != 1 {
t.Fatalf("published shape refused: %s", res.Flatten())
}
var out struct {
IDs []int64 `json:"ids"`
}
if err := json.Unmarshal([]byte(res.Flatten()), &out); err != nil || len(out.IDs) != 1 || out.IDs[0] <= 0 {
t.Fatalf("batch result must carry exactly one id: %s", res.Flatten())
}
if yielded, err := store.FactsYielded(intentID); err != nil || len(yielded) != 1 || yielded[0] != out.IDs[0] {
t.Fatalf("fact not linked to the intent: %v %v", yielded, err)
}
node, err := store.GetNode(out.IDs[0])
if err != nil || node == nil {
t.Fatal(err)
}
var payload map[string]any
_ = json.Unmarshal(node.Payload, &payload)
if payload["summary"] != "TLS 1.0 is offered on port 8443" || payload["source"] != "tool_output" || payload["confidence"] != "observed" {
t.Fatalf("fact payload: %s", node.Payload)
}
}
// Conflicting copies, placeholders, unknown fields, bad asset ids, missing
// summaries and empty batches are refused, and nothing is written by a
// refused call.
func TestRecordFactBatchTopLevelConflicts(t *testing.T) {
store := guardTaskStore(t)
tools := NewToolSet(store, "worker")
before, err := store.ListByKind(db.KindFact, 100) // the task's origin fact
if err != nil {
t.Fatal(err)
}
for _, tc := range []struct{ call, want string }{
// dummy summaries a model may send after a refusal
{`{"summary":"x","facts":[{"summary":"real conclusion"}]}`, `"summary"`},
{`{"summary":"placeholder","detail":"test","evidence":"test","facts":[{"summary":"real","detail":"real detail","evidence":"real evidence"}]}`, `"detail", "evidence", "summary"`},
{`{"summary":"contradictory","facts":[{"summary":"different"}]}`, `"summary"`},
{`{"detail":"invented","facts":[{"summary":"legitimate"}]}`, `"detail"`},
{`{"confidence":"observed","facts":[{"summary":"fact says inferred","confidence":"inferred"}]}`, `"confidence"`},
{`{"source":"inference","facts":[{"summary":"fact says tool_output","source":"tool_output"}]}`, `"source"`},
{`{"asset_ids":[1],"facts":[{"summary":"fact has other assets","asset_ids":[2]}]}`, `"asset_ids"`},
{`{"summary":"first","facts":[{"summary":"first"},{"summary":"second"}]}`, `(2 item(s))`},
{`{"summary":"x","typo":1,"facts":[{"summary":"unknown field"}]}`, `"typo"`},
{`{"facts":[{"summary":"unknown nested","typo":1}]}`, `"typo"`},
{`{"facts":[{"summary":"bad asset id","asset_ids":["abc"]}]}`, `asset`},
{`{"summary":"must not inherit","facts":[{"detail":"missing summary"}]}`, `"summary"`},
{`{"summary":"x","facts":[]}`, `non-empty`},
{`{"facts":[]}`, `non-empty`},
{`{"summary":"","facts":[]}`, `non-empty`},
} {
w := tools.Writes().Facts
r := callGuardTool(t, tools.recordFact(), tc.call)
if !r.IsError || !strings.Contains(r.Flatten(), tc.want) || tools.Writes().Facts != w {
t.Errorf("%s: want refusal mentioning %s, got %s (writes %d→%d)", tc.call, tc.want, r.Flatten(), w, tools.Writes().Facts)
}
}
if n, err := store.ListByKind(db.KindFact, 100); err != nil || len(n) != len(before) {
t.Fatalf("refused calls wrote facts: %d → %d %v", len(before), len(n), err)
}
}
// The published schema holds facts[] and nothing else, and the description
// names that one shape; the earlier "two shapes" wording is gone.
func TestRecordFactSchemaIsFactsOnly(t *testing.T) {
schema := recordFactSchema()
props := schema["properties"].(map[string]any)
if len(props) != 1 || props["facts"] == nil {
t.Fatalf("top-level properties: %v", props)
}
if req, _ := schema["required"].([]string); len(req) != 1 || req[0] != "facts" || schema["additionalProperties"] != false {
t.Fatalf("facts must be required and the only property: %v %v", schema["required"], schema["additionalProperties"])
}
facts := props["facts"].(map[string]any)
if d, _ := facts["description"].(string); !strings.Contains(d, "never send summary") {
t.Errorf("facts description must forbid top-level copies: %q", d)
}
item := facts["items"].(map[string]any)["properties"].(map[string]any)
for _, name := range []string{"summary", "intent_id", "detail", "evidence", "confidence", "source", "asset_ids", "tested_asset_ids"} {
if item[name] == nil {
t.Errorf("facts[] item lacks %s", name)
}
}
for name, d := range map[string]string{
"summary": item["summary"].(map[string]any)["description"].(string),
"intent_id": item["intent_id"].(map[string]any)["description"].(string),
} {
if strings.Contains(d, "top level") || strings.Contains(d, "top-level") {
t.Errorf("facts[].%s still refers to a top level: %q", name, d)
}
}
desc := NewToolSet(nil, "").recordFact().Description()
if !strings.HasSuffix(desc, recordFactContractNote) || strings.Contains(desc, "top-level intent_id") {
t.Fatalf("record_fact description must describe the facts-only contract: %q", desc)
}
// The seed the catalog stores is the same contract.
for _, seed := range BuiltinToolSeeds() {
if seed.Key != "record_fact" {
continue
}
if seed.Desc != desc {
t.Fatal("seed description differs from the tool")
}
if p := seed.Schema["properties"].(map[string]any); len(p) != 1 || p["facts"] == nil {
t.Fatalf("seed schema is not facts-only: %v", p)
}
}
}
// A facts[] item without intent_id is linked to the intent the worker runs
// (SetOwnerNode); a legacy top-level intent_id still wins; a planner ToolSet
// (owner = the task root, not an intent) writes an unlinked fact.
func TestRecordFactDefaultsToRunningIntent(t *testing.T) {
store := guardTaskStore(t)
running := addGuardNode(t, store, db.KindIntent, map[string]any{"summary": "running intent"}, "running")
other := addGuardNode(t, store, db.KindIntent, map[string]any{"summary": "other intent"}, "open")
tools := NewToolSet(store, "worker")
tools.SetOwnerNode(running)
ids := func(res actool.Result) []int64 {
t.Helper()
var out struct {
IDs []int64 `json:"ids"`
}
if err := json.Unmarshal([]byte(res.Flatten()), &out); err != nil || len(out.IDs) != 1 || out.IDs[0] <= 0 {
t.Fatalf("batch result: %s", res.Flatten())
}
return out.IDs
}
res := callGuardTool(t, tools.recordFact(), `{"facts":[{"summary":"linked to the running intent","confidence":"observed","source":"tool_output"}]}`)
if res.IsError {
t.Fatal(res.Flatten())
}
first := ids(res)[0]
if yielded, err := store.FactsYielded(running); err != nil || len(yielded) != 1 || yielded[0] != first {
t.Fatalf("fact %d not linked to the running intent %d: %v %v", first, running, yielded, err)
}
res = callGuardTool(t, tools.recordFact(), `{"intent_id":`+strconv.FormatInt(other, 10)+`,"facts":[{"summary":"legacy top-level intent"}]}`)
if res.IsError {
t.Fatal(res.Flatten())
}
second := ids(res)[0]
if yielded, err := store.FactsYielded(other); err != nil || len(yielded) != 1 || yielded[0] != second {
t.Fatalf("legacy top-level intent_id must win: %v %v", yielded, err)
}
res = callGuardTool(t, tools.recordFact(), `{"facts":[{"summary":"item intent","intent_id":`+strconv.FormatInt(other, 10)+`}]}`)
if res.IsError {
t.Fatal(res.Flatten())
}
third := ids(res)[0]
if yielded, _ := store.FactsYielded(other); len(yielded) != 2 || yielded[1] != third && yielded[0] != third {
t.Fatalf("item intent_id must win: %v", yielded)
}
if yielded, _ := store.FactsYielded(running); len(yielded) != 1 {
t.Fatalf("running intent gained facts it did not produce: %v", yielded)
}
planner := NewToolSet(store, "planner")
origin, err := store.ListByKind(db.KindFact, 1)
if err != nil || len(origin) == 0 {
t.Fatalf("origin fact: %v", err)
}
planner.SetOwnerNode(origin[0].ID)
res = callGuardTool(t, planner.recordFact(), `{"facts":[{"summary":"planner fact without intent"}]}`)
if res.IsError || planner.Writes().Facts != 1 {
t.Fatalf("planner write refused: %s", res.Flatten())
}
if yielded, _ := store.FactsYielded(running); len(yielded) != 1 {
t.Fatalf("planner fact must not be linked to a worker intent: %v", yielded)
}
}
+4 -1
View File
@@ -44,7 +44,10 @@ func TestReportFindingStoresReasoningFields(t *testing.T) {
if err != nil {
t.Fatal(err)
}
defer d.DeleteTask(task.ID)
defer func() {
_, _ = d.DeleteFindingsByTask(task.ID)
_ = d.DeleteTask(task.ID)
}()
ts := NewToolSet(nil, "")
ts.ts, ts.taskID = d.Exploration(task.ExplorationID), task.ID
for _, tc := range []struct{ extra, counter, rationale string }{
+8 -2
View File
@@ -25,7 +25,10 @@ func TestReportFindingOptionalTrafficWithoutCapture(t *testing.T) {
if err != nil {
t.Fatal(err)
}
defer d.DeleteTask(task.ID)
defer func() {
_, _ = d.DeleteFindingsByTask(task.ID)
_ = d.DeleteTask(task.ID)
}()
ts := NewToolSet(nil, "")
ts.ts, ts.taskID = d.Exploration(task.ExplorationID), task.ID
ts.SetFindingRecorder(evidence.New(d, nil, t.TempDir()))
@@ -60,7 +63,10 @@ func TestReportFindingAtomicContract(t *testing.T) {
if err != nil {
t.Fatal(err)
}
defer d.DeleteTask(task.ID)
defer func() {
_, _ = d.DeleteFindingsByTask(task.ID)
_ = d.DeleteTask(task.ID)
}()
ts := NewToolSet(nil, "")
ts.ts = d.Exploration(task.ExplorationID)
ts.taskID = task.ID
+128
View File
@@ -0,0 +1,128 @@
package agent
import (
"encoding/json"
"fmt"
"strconv"
"strings"
"testing"
"github.com/Autumn-27/artex/db"
)
// Synthetic replay of the record_fact call shapes a model produces, replayed
// against the handler in the package test database. The shapes mirror what
// was observed in production before the facts-only contract (a model filling
// every declared top-level property beside facts[]) without using recorded
// data. Checked per call: the verdict, that an accepted call writes exactly one
// node per facts item linked to the intent and anchored to the assets, and
// that a refused call writes nothing and names the top-level fields.
func TestRecordFactShapesReplay(t *testing.T) {
d := testDB(t)
t.Cleanup(func() { _ = d.Close() })
task, err := d.CreateTaskWithOptions("record_fact shapes", "replay synthetic record_fact call shapes", db.TaskCreateOptions{})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = d.DeleteTask(task.ID) })
store := d.Exploration(task.ExplorationID)
intentID := addGuardNode(t, store, db.KindIntent, map[string]any{"summary": "enumerate the service"}, "running")
var assets []int64
for i := 1; i <= 2; i++ {
id, err := d.Assets().UpsertIP(db.UpsertIPReq{IP: fmt.Sprintf("203.0.113.%d", i), TaskID: task.ID})
if err != nil {
t.Fatal(err)
}
assets = append(assets, id)
}
t.Cleanup(func() { _, _ = d.Assets().DeleteByIDs(assets) })
tools := NewToolSet(store, "worker")
tools.SetOwnerNode(intentID)
tool := tools.recordFact()
iid := strconv.FormatInt(intentID, 10)
a1, a2 := strconv.FormatInt(assets[0], 10), strconv.FormatInt(assets[1], 10)
item := func(n int) string {
return fmt.Sprintf(`{"summary":"conclusion %d","detail":"detail %d","evidence":"cmd %d → line","confidence":"observed","source":"tool_output","asset_ids":[%s]}`, n, n, n, a1)
}
type shape struct {
name string
call string
accept bool
items int
fields string // named in the refusal
}
shapes := []shape{
{"published: one item", `{"facts":[` + item(1) + `]}`, true, 1, ""},
{"published: two items", `{"facts":[` + item(1) + `,` + item(2) + `]}`, true, 2, ""},
{"published: item with its own intent_id and alias", `{"facts":[{"summary":"alias","tested_asset_ids":["` + a2 + `"],"intent_id":` + iid + `}]}`, true, 1, ""},
{"legacy batch: top-level intent_id", `{"intent_id":` + iid + `,"facts":[` + item(3) + `]}`, true, 1, ""},
{"legacy single", `{"summary":"single fact","confidence":"inferred","asset_ids":[` + a2 + `]}`, true, 1, ""},
{"copies of every field beside facts", `{"summary":"conclusion 1","detail":"detail 1","evidence":"cmd 1 → line","confidence":"observed","source":"tool_output","asset_ids":[` + a1 + `],"facts":[` + item(1) + `]}`, false, 1, `"asset_ids", "confidence", "detail", "evidence", "source", "summary"`},
{"empty placeholders beside facts", `{"summary":"","detail":"","asset_ids":[],"tested_asset_ids":[],"facts":[` + item(1) + `]}`, false, 1, `"asset_ids", "detail", "summary", "tested_asset_ids"`},
{"dummy summary beside facts", `{"summary":"x","facts":[` + item(1) + `]}`, false, 1, `"summary"`},
{"abbreviated copy beside facts", `{"summary":"short","detail":"short detail","facts":[` + item(1) + `]}`, false, 1, `"detail", "summary"`},
{"conflicting source beside facts", `{"source":"inference","facts":[` + item(1) + `]}`, false, 1, `"source"`},
{"top-level summary beside two items", `{"summary":"conclusion 1","facts":[` + item(1) + `,` + item(2) + `]}`, false, 2, `"summary"`},
}
for _, s := range shapes {
before := tools.Writes().Facts
linked, _ := store.FactsYielded(intentID)
res := callGuardTool(t, tool, s.call)
written := tools.Writes().Facts - before
if !res.IsError != s.accept {
t.Errorf("%s: accepted=%v want %v: %s", s.name, !res.IsError, s.accept, res.Flatten())
continue
}
if !s.accept {
if written != 0 || !strings.Contains(res.Flatten(), "top-level field(s) "+s.fields) || !strings.Contains(res.Flatten(), "no facts were written") {
t.Errorf("%s: refusal must write nothing and name %s: %s (writes %d)", s.name, s.fields, res.Flatten(), written)
}
continue
}
if written != s.items {
t.Errorf("%s: wrote %d facts for %d items", s.name, written, s.items)
}
after, _ := store.FactsYielded(intentID)
if len(after) != len(linked)+s.items {
t.Errorf("%s: intent links %d → %d for %d items", s.name, len(linked), len(after), s.items)
}
ids := after[len(linked):]
if strings.HasPrefix(s.call, `{"facts"`) || strings.HasPrefix(s.call, `{"intent_id"`) {
var out struct {
IDs []int64 `json:"ids"`
}
if err := json.Unmarshal([]byte(res.Flatten()), &out); err != nil || len(out.IDs) != s.items {
t.Errorf("%s: ids: %s", s.name, res.Flatten())
}
}
for _, id := range ids {
node, err := store.GetNode(id)
if err != nil || node == nil || node.Kind != db.KindFact {
t.Fatalf("%s: fact %d: %v", s.name, id, err)
}
var payload map[string]any
_ = json.Unmarshal(node.Payload, &payload)
if sum, _ := payload["summary"].(string); sum == "" || sum == "x" {
t.Errorf("%s: stored summary %q", s.name, sum)
}
if strings.Contains(s.call, "asset_ids") {
anchored := false
for _, asset := range assets {
refs, err := store.AssetRefs(asset)
if err != nil {
t.Fatal(err)
}
for _, r := range refs {
if r.ID == id {
anchored = true
}
}
}
if !anchored {
t.Errorf("%s: fact %d not anchored to an asset", s.name, id)
}
}
}
}
}
+3 -3
View File
@@ -22,7 +22,7 @@ func TestIngestScanOutputPG(t *testing.T) {
if err != nil {
t.Fatal(err)
}
const assetsWhere = `ip IN ('198.51.100.77','2001:db8::77') OR domain LIKE '%scan-ingest.example.com' OR url LIKE '%198.51.100.77%' OR url LIKE '%2001:db8::77%'`
const assetsWhere = `ip IN ('198.51.100.77','2001:db8::77') OR domain IN ('198.51.100.77','2001:db8::77','example.com') OR domain LIKE '%scan-ingest.example.com' OR url LIKE '%198.51.100.77%' OR url LIKE '%2001:db8::77%'`
t.Cleanup(func() {
_ = d.DeleteTask(task.ID)
_, _ = d.Exec(`DELETE FROM assets WHERE ` + assetsWhere)
@@ -127,7 +127,7 @@ func TestIngestScanOutputJSONPG(t *testing.T) {
if err != nil {
t.Fatal(err)
}
const assetsWhere = `domain LIKE '%scan-ingest.example.com' OR url LIKE '%scan-ingest.example.com%'`
const assetsWhere = `ip IN ('198.51.100.77','2001:db8::77') OR domain IN ('198.51.100.77','2001:db8::77','example.com') OR domain LIKE '%scan-ingest.example.com' OR url LIKE '%scan-ingest.example.com%'`
t.Cleanup(func() {
_ = d.DeleteTask(task.ID)
_, _ = d.Exec(`DELETE FROM assets WHERE ` + assetsWhere)
@@ -210,7 +210,7 @@ func TestIngestScanOutputUserinfoPG(t *testing.T) {
if err != nil {
t.Fatal(err)
}
const assetsWhere = `domain LIKE '%scan-ingest.example.com' OR url LIKE '%scan-ingest.example.com%'`
const assetsWhere = `ip IN ('198.51.100.77','2001:db8::77') OR domain IN ('198.51.100.77','2001:db8::77','example.com') OR domain LIKE '%scan-ingest.example.com' OR url LIKE '%scan-ingest.example.com%'`
t.Cleanup(func() {
_ = d.DeleteTask(task.ID)
_, _ = d.Exec(`DELETE FROM assets WHERE ` + assetsWhere)
+8
View File
@@ -180,6 +180,14 @@ type overriddenTool struct {
func (o *overriddenTool) Description() string { return o.desc }
func (o *overriddenTool) InputSchema() map[string]any { return o.schema }
// AcceptsRawInput forwards the wrapped tool's opt-out of the harness schema
// check (record_fact validates its own input); the embedded interface alone
// would hide it from the harness's type assertion.
func (o *overriddenTool) AcceptsRawInput() bool {
r, ok := o.CoreTool.(interface{ AcceptsRawInput() bool })
return ok && r.AcceptsRawInput()
}
func (o *overriddenTool) Call(ctx context.Context, in json.RawMessage, tc *actool.ToolContext) (actool.Result, error) {
return o.CoreTool.Call(ctx, injectDefaults(in, o.schema), tc)
}
+44 -5
View File
@@ -394,8 +394,21 @@ func readTool(name, desc string, schema map[string]any, run func(context.Context
}
func writeTool(name, desc string, schema map[string]any, run func(context.Context, json.RawMessage) (actool.Result, error)) actool.CoreTool {
return buildWriteTool(name, desc, schema, false, run)
}
// writeRawTool is writeTool for a handler that validates its own input: the
// harness skips its schema check (Spec.RawInput), so the published schema can
// be stricter (required properties) than the legacy shapes the handler still
// accepts, and refusals carry the handler's own message instead of the
// SDK's generic one.
func writeRawTool(name, desc string, schema map[string]any, run func(context.Context, json.RawMessage) (actool.Result, error)) actool.CoreTool {
return buildWriteTool(name, desc, schema, true, run)
}
func buildWriteTool(name, desc string, schema map[string]any, raw bool, run func(context.Context, json.RawMessage) (actool.Result, error)) actool.CoreTool {
return actool.Build(actool.Spec{
Name: name, Description: desc, Schema: schema,
Name: name, Description: desc, Schema: schema, RawInput: raw,
Permissions: func(context.Context, json.RawMessage, acperm.Context) acperm.Decision { return acperm.Allowed() },
Run: func(ctx context.Context, in json.RawMessage, _ *actool.ToolContext) (actool.Result, error) {
return run(ctx, in)
@@ -419,6 +432,12 @@ func (t *ToolSet) writeExpTool(name, desc string, schema map[string]any, run fun
return writeTool(name, desc, schema, t.needExploration(name, run))
}
// writeExpToolRaw is writeExpTool with the harness schema check skipped (see
// writeRawTool); the handler validates the input itself.
func (t *ToolSet) writeExpToolRaw(name, desc string, schema map[string]any, run func(context.Context, json.RawMessage) (actool.Result, error)) actool.CoreTool {
return writeRawTool(name, desc, schema, t.needExploration(name, run))
}
// needExploration wraps a handler so it only runs with an exploration store.
// Tools that degrade more usefully than "unavailable" (report_finding points at
// add_task_hint, set_goals/set_constraints at the task itself) keep their own
@@ -1588,15 +1607,30 @@ func (t *ToolSet) recordOneFact(it factItem, defaultIntent int64) (int64, error)
return id, nil
}
// runningIntent is the intent this ToolSet works for (the worker's claimed
// intent, set by SetOwnerNode), or 0 when the owner node is not an intent
// (planner: the task root) or unknown.
func (t *ToolSet) runningIntent() int64 {
if t.ts == nil || t.ownerNode <= 0 {
return 0
}
node, err := t.ts.GetNode(t.ownerNode)
if err != nil || node == nil || node.Kind != db.KindIntent {
return 0
}
return node.ID
}
func (t *ToolSet) recordFact() actool.CoreTool {
return t.writeExpTool("record_fact", "Write an exploration [fact/conclusion] into the exploration graph, linked to the intent that produced it (intent_id). Used to record exploration results — both [positive conclusions] like fingerprinting/enumeration, and [negative conclusions] like 'port closed'/'parameter not injectable'/'no login entry found'.\n"+
return t.writeExpToolRaw("record_fact", "Write an exploration [fact/conclusion] into the exploration graph, linked to the intent that produced it (intent_id). Used to record exploration results — both [positive conclusions] like fingerprinting/enumeration, and [negative conclusions] like 'port closed'/'parameter not injectable'/'no login entry found'.\n"+
"⚠️Multiple observations from one exploration must be [consolidated into ONE fact], not split into many; whenever they can be merged into one fact, use one: summary = a one-sentence summary of this conclusion, detail = the related details (may contain multiple concrete items). Example: a fingerprinting intent → one fact {summary:'identified the tech stack and response characteristics of site X', detail:'nginx 1.25 / Vue3 / 200 / title=.. / body_len=..'}, rather than one fact each for status code, fingerprint, and title. One intent usually produces exactly one fact; splitting too finely bloats the graph endlessly.\n"+
"★The facts array writes several [mutually distinct] conclusions at once (each may omit intent_id, defaulting to the top-level intent_id). Returns an ids array, same length and order as facts.\n"+
"★facts is the only parameter: facts:[{...}] with one item per [mutually distinct] conclusion, usually exactly one item. Returns an ids array, same length and order as facts. An item without intent_id is linked to the intent you are running.\n"+
"⚠️Write only conclusions you [actually saw] in tool output — don't extrapolate. evidence and confidence keep inaccurate conclusions from polluting the graph:\n"+
" · evidence = [one line] of key evidence supporting this conclusion (the command + the one or two most proving output lines), **keep it brief** — details belong in detail; don't paste large output blocks here.\n"+
" · confidence = observed (seen directly in output) | inferred (inferred from phenomena).\n"+
" · source = where the content came from: target_response (content the target itself returned: page bodies, headers, error messages, banners, even when a tool fetched it) | tool_output (a tool's own result about the target: port states, scanner verdicts, status codes, timings) | third_party_intel (OSINT, CVE databases, public reports) | operator_input (given by the human operator) | inference (your own reasoning; the default when omitted). Any other value is refused.\n"+
" · **Negative conclusions** (not injectable / port closed / no entry found, etc.) state only \"observation + tentative reading\" — state what you actually saw; whether to abandon the direction is for the planner to decide globally; always provide evidence, mark inferred when the means weren't exhausted or the evidence is weak (including probed only once, looks-like), and mark observed only when truly exhausted and directly seen.",
" · **Negative conclusions** (not injectable / port closed / no entry found, etc.) state only \"observation + tentative reading\" — state what you actually saw; whether to abandon the direction is for the planner to decide globally; always provide evidence, mark inferred when the means weren't exhausted or the evidence is weak (including probed only once, looks-like), and mark observed only when truly exhausted and directly seen."+
recordFactContractNote,
recordFactSchema(),
func(_ context.Context, in json.RawMessage) (actool.Result, error) {
a, batch, err := decodeRecordFactInput(in)
@@ -1607,7 +1641,12 @@ func (t *ToolSet) recordFact() actool.CoreTool {
if !batch {
items = []factItem{a.factItem}
}
defaultIntent := pid(a.factItem.IntentID) // top-level intent_id = batch default
// Default intent of the items: a legacy top-level intent_id, else the
// intent this worker is running (the published schema has no top level).
defaultIntent := pid(a.factItem.IntentID)
if defaultIntent <= 0 {
defaultIntent = t.runningIntent()
}
ids := make([]int64, len(items))
errs := map[string]string{}
+117
View File
@@ -9,6 +9,7 @@ import (
"os"
"path/filepath"
"strings"
"sync/atomic"
"testing"
"time"
)
@@ -130,3 +131,119 @@ func TestArchiveIncompleteCredentialOverride(t *testing.T) {
}
}
}
// The server removes the AWS credential variables from its environment once the
// store is built, so that child processes do not inherit them. The SDK must have
// captured by then everything it needs to sign: the static keys, and for the
// container and web-identity providers the endpoint, token and file path they
// fetch credentials from later (their first fetch happens after the scrub here).
func TestReview318CredentialsSurviveEnvScrub(t *testing.T) {
scrubbed := []string{
"AWS_ACCESS_KEY_ID", "AWS_ACCESS_KEY", "AWS_SECRET_ACCESS_KEY", "AWS_SECRET_KEY", "AWS_SESSION_TOKEN",
"AWS_CONTAINER_CREDENTIALS_FULL_URI", "AWS_CONTAINER_CREDENTIALS_RELATIVE_URI", "AWS_CONTAINER_AUTHORIZATION_TOKEN", "AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE",
"AWS_WEB_IDENTITY_TOKEN_FILE", "AWS_ROLE_ARN",
}
for _, mode := range []string{"environment", "environment-alternate-names", "container", "web-identity"} {
t.Run(mode, func(t *testing.T) {
isolateAWSCredentials(t)
for _, key := range append([]string{
"ARTEX_ARCHIVE_S3_ACCESS_KEY_ID", "ARTEX_ARCHIVE_S3_SECRET_ACCESS_KEY", "ARTEX_ARCHIVE_S3_SESSION_TOKEN",
"ARTEX_ARCHIVE_S3_SSE", "ARTEX_ARCHIVE_S3_KMS_KEY_ID", "ARTEX_ARCHIVE_S3_PREFIX", "AWS_ENDPOINT_URL_STS",
}, scrubbed...) {
t.Setenv(key, "")
}
var envScrubbed atomic.Bool
var fetchedAfterScrub atomic.Int32
provider := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if envScrubbed.Load() {
fetchedAfterScrub.Add(1)
}
expiration := time.Now().Add(time.Hour).UTC().Format(time.RFC3339)
if mode == "container" {
if r.Header.Get("Authorization") != "fixture-container-token" {
t.Error("missing container authorization token")
}
_ = json.NewEncoder(w).Encode(map[string]any{
"AccessKeyId": "fixture-key", "SecretAccessKey": "fixture-secret",
"Token": "fixture-session", "Expiration": expiration,
})
return
}
if err := r.ParseForm(); err != nil || r.PostForm.Get("Action") != "AssumeRoleWithWebIdentity" ||
r.PostForm.Get("WebIdentityToken") != "fixture-web-identity-token" ||
r.PostForm.Get("RoleArn") != "arn:aws:iam::123456789012:role/archive" {
t.Errorf("unexpected STS request: %v %v", err, r.PostForm)
}
w.Header().Set("Content-Type", "text/xml")
fmt.Fprintf(w, `<AssumeRoleWithWebIdentityResponse xmlns="https://sts.amazonaws.com/doc/2011-06-15/"><AssumeRoleWithWebIdentityResult><Credentials><AccessKeyId>fixture-key</AccessKeyId><SecretAccessKey>fixture-secret</SecretAccessKey><SessionToken>fixture-session</SessionToken><Expiration>%s</Expiration></Credentials></AssumeRoleWithWebIdentityResult></AssumeRoleWithWebIdentityResponse>`, expiration)
}))
defer provider.Close()
switch mode {
case "environment":
t.Setenv("AWS_ACCESS_KEY_ID", "fixture-key")
t.Setenv("AWS_SECRET_ACCESS_KEY", "fixture-secret")
t.Setenv("AWS_SESSION_TOKEN", "fixture-session")
case "environment-alternate-names":
t.Setenv("AWS_ACCESS_KEY", "fixture-key")
t.Setenv("AWS_SECRET_KEY", "fixture-secret")
t.Setenv("AWS_SESSION_TOKEN", "fixture-session")
case "container":
t.Setenv("AWS_CONTAINER_CREDENTIALS_FULL_URI", provider.URL+"/credentials")
t.Setenv("AWS_CONTAINER_AUTHORIZATION_TOKEN", "fixture-container-token")
case "web-identity":
tokenFile := filepath.Join(t.TempDir(), "token")
if err := os.WriteFile(tokenFile, []byte("fixture-web-identity-token"), 0600); err != nil {
t.Fatal(err)
}
t.Setenv("AWS_WEB_IDENTITY_TOKEN_FILE", tokenFile)
t.Setenv("AWS_ROLE_ARN", "arn:aws:iam::123456789012:role/archive")
t.Setenv("AWS_ENDPOINT_URL_STS", provider.URL)
}
var authorization, sessionToken atomic.Value
objects := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodHead {
t.Errorf("unexpected S3 operation: %s", r.Method)
}
authorization.Store(r.Header.Get("Authorization"))
sessionToken.Store(r.Header.Get("X-Amz-Security-Token"))
w.WriteHeader(http.StatusNotFound)
}))
defer objects.Close()
t.Setenv("ARTEX_ARCHIVE_STORAGE", "s3")
t.Setenv("ARTEX_ARCHIVE_S3_ENDPOINT", objects.URL)
t.Setenv("ARTEX_ARCHIVE_S3_REGION", "us-east-1")
t.Setenv("ARTEX_ARCHIVE_S3_BUCKET", "fixture")
t.Setenv("ARTEX_ARCHIVE_S3_PATH_STYLE", "true")
store, err := FromEnv()
if err != nil || store == nil {
t.Fatalf("store from environment: %v", err)
}
for _, key := range scrubbed {
if err := os.Unsetenv(key); err != nil {
t.Fatal(err)
}
}
envScrubbed.Store(true)
// HEAD is the first request of a download. The fixture answers 404, so
// the call fails; only the signature of the request matters here.
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
checksum := strings.Repeat("a", 64)
err = store.Download(ctx, store.URI(1, 2, checksum), filepath.Join(t.TempDir(), "probe"), checksum, 1)
if err == nil {
t.Fatal("the fixture has no object: the download must fail")
}
got, _ := authorization.Load().(string)
if !strings.Contains(got, "Credential=fixture-key/") || !strings.Contains(got, "Signature=") {
t.Fatalf("request not signed with the captured key after the scrub: Authorization=%q (%v)", got, err)
}
if token, _ := sessionToken.Load().(string); token != "fixture-session" {
t.Fatalf("session token lost after the scrub: %q", token)
}
if lazy := mode == "container" || mode == "web-identity"; lazy && fetchedAfterScrub.Load() == 0 {
t.Fatal("the provider was expected to fetch its credentials after the scrub")
}
})
}
}
+1 -1
View File
@@ -118,7 +118,7 @@ else
command -v rsync >/dev/null 2>&1 || die "rsync not detected"
info "Building frontend static assets"
if [ "${ARTEX_SKIP_NPM_CI:-0}" != "1" ]; then
(cd web && npm ci)
(cd web && npm ci --ignore-scripts)
fi
(cd web && npm run build:static)
info "Syncing frontend assets to server/webui/dist"
+2 -2
View File
@@ -22,7 +22,7 @@ func TestFlushActivityOutboxReplaysOnce(t *testing.T) {
if err != nil {
SkipPGUnavailable(t, err)
}
defer d.Close()
t.Cleanup(func() { _ = d.Close() })
expID, err := d.CreateExploration("outbox", "replay")
if err != nil {
t.Fatal(err)
@@ -65,7 +65,7 @@ func TestFlushActivityOutboxDropsStuckRow(t *testing.T) {
if err != nil {
SkipPGUnavailable(t, err)
}
defer d.Close()
t.Cleanup(func() { _ = d.Close() })
const missing = int64(9_000_000_000_001)
t.Cleanup(func() { _, _ = d.Exec(`DELETE FROM activity_outbox WHERE exploration_id=$1`, missing) })
es := d.Exploration(missing)
+1
View File
@@ -1143,6 +1143,7 @@ func TestAssetIPRejectsHostname(t *testing.T) {
t.Fatalf("empty ip rejected: %v", err)
}
deleteAsset(d, id)
_, _ = d.Exec(`DELETE FROM assets WHERE domain IN ('ip-guard.example.com','example.com')`)
id, err = av2.UpsertIP(UpsertIPReq{IP: "203.0.113.7"})
if err != nil {
t.Fatalf("valid ip rejected: %v", err)
+96
View File
@@ -0,0 +1,96 @@
package db
import (
"fmt"
"strings"
"testing"
"time"
)
func TestDashboardUsageIndexesMigration0010(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
SkipPGUnavailable(t, err)
}
t.Cleanup(func() { _ = d.Close() })
wantIndexes := []struct {
name string
table string
pred string
}{
{"idx_act_result_created", "activity", "kind = 'result'"},
{"idx_conv_act_result", "conversation_activities", "kind = 'result'"},
{"idx_llm_usage_judge_ts", "llm_usage", "worker = 'judge'"},
}
for _, want := range wantIndexes {
var valid, ready bool
var def string
err := d.QueryRow(`
SELECT i.indisvalid, i.indisready, pg_get_indexdef(i.indexrelid)
FROM pg_index i
JOIN pg_class c ON c.oid = i.indexrelid
JOIN pg_namespace n ON n.oid = c.relnamespace
WHERE n.nspname = 'public' AND c.relname = $1`, want.name).Scan(&valid, &ready, &def)
if err != nil {
t.Fatalf("index public.%s missing after Open: %v", want.name, err)
}
if !valid || !ready {
t.Fatalf("index %s indisvalid=%v indisready=%v, want both true (%s)", want.name, valid, ready, def)
}
if !strings.Contains(def, want.table) || !strings.Contains(def, want.pred) {
t.Fatalf("index %s definition %q missing table %q or predicate %q", want.name, def, want.table, want.pred)
}
}
// Verify sargable TokenByModel matches both specific task_id and empty task_id.
taskID := fmt.Sprintf("idx-test-%d", time.Now().UnixNano())
t.Cleanup(func() {
_, _ = d.Exec(`DELETE FROM llm_usage WHERE task_id = $1 OR profile_name = $2`, taskID, taskID)
})
if err := d.InsertLLMUsage(&LLMUsage{
TaskID: taskID,
Worker: "worker",
Model: "claude-sonnet-4",
ProfileName: taskID,
InputTokens: 1000,
OutputTokens: 200,
Status: "ok",
}); err != nil {
t.Fatal(err)
}
if err := d.InsertLLMUsage(&LLMUsage{
TaskID: "",
Worker: "chat",
Model: "gpt-5",
ProfileName: taskID,
InputTokens: 500,
OutputTokens: 100,
Status: "ok",
}); err != nil {
t.Fatal(err)
}
got, err := d.TokenByModel(taskID)
if err != nil {
t.Fatalf("TokenByModel(%q): %v", taskID, err)
}
if len(got) != 1 || got[0].Model != "claude-sonnet-4" || got[0].InputTokens != 1000 || got[0].OutputTokens != 200 {
t.Fatalf("TokenByModel(%q) = %+v, want 1 claude-sonnet-4 row", taskID, got)
}
emptyGot, err := d.TokenByModel("")
if err != nil {
t.Fatalf("TokenByModel(\"\"): %v", err)
}
foundChat := false
for _, m := range emptyGot {
if m.Model == "gpt-5" && m.InputTokens >= 500 {
foundChat = true
}
}
if !foundChat {
t.Fatalf("TokenByModel(\"\") did not include NULL/empty task_id row: %+v", emptyGot)
}
}
+1
View File
@@ -28,6 +28,7 @@ func TestFindingQualityByNodeID(t *testing.T) {
if err != nil {
t.Fatal(err)
}
defer d.DeleteFinding(rec.FindingID)
if err := d.SetFindingVerification(rec.FindingID, VerificationVerified, 3, "reproduced twice on staging"); err != nil {
t.Fatal(err)
}
+2
View File
@@ -24,10 +24,12 @@ func TestFindingReasoningFieldsRoundTrip(t *testing.T) {
if err != nil {
t.Fatal(err)
}
defer d.DeleteFinding(with.FindingID)
without, err := es.RecordFinding(t.Context(), RecordFindingInput{TaskID: tk.ID, VulnClass: "IDOR", Severity: "low", Summary: "without reasoning", Worker: "test"})
if err != nil {
t.Fatal(err)
}
defer d.DeleteFinding(without.FindingID)
want := map[int64][2]string{
with.FindingID: {"UUID guessing returned 404", "two accounts, same response body"},
without.FindingID: {"", ""},
+5 -1
View File
@@ -32,7 +32,11 @@ func TestFindingTrafficLegacyArchiveDefaults(t *testing.T) {
if err != nil {
t.Fatal(err)
}
defer func() { d.Exec(`DELETE FROM task_archives WHERE task_id=$1`, task.ID); d.DeleteTask(task.ID) }()
defer func() {
_, _ = d.DeleteFindingsByTask(task.ID)
_, _ = d.Exec(`DELETE FROM task_archives WHERE task_id=$1`, task.ID)
_ = d.DeleteTask(task.ID)
}()
f, err := d.Exploration(task.ExplorationID).RecordFinding(t.Context(), RecordFindingInput{TaskID: task.ID, ExplorationID: task.ExplorationID, Summary: "legacy", Severity: "low"})
if err != nil {
t.Fatal(err)
+9 -3
View File
@@ -100,6 +100,7 @@ func TestSetFindingStatusMirrorsNodePayload(t *testing.T) {
if err != nil {
t.Fatal(err)
}
defer d.DeleteFinding(fid)
n, err := d.SetFindingStatus(fid, FindingFalsePositive)
if err != nil || n != 1 {
@@ -146,13 +147,13 @@ func TestFindingReportState(t *testing.T) {
if err != nil {
SkipPGUnavailable(t, err)
}
defer d.Close()
t.Cleanup(func() { d.Close() })
tk, err := d.CreateTask("finding report state", "goal", nil, 0, 0)
if err != nil {
t.Fatal(err)
}
defer d.DeleteTask(tk.ID)
t.Cleanup(func() { _ = d.DeleteTask(tk.ID) })
es := d.Exploration(tk.ExplorationID)
nodeID, err := es.AddNode(KindFinding, map[string]any{"summary": "x", "severity": "high"}, 5, "confirmed", "worker", nil)
@@ -167,7 +168,11 @@ func TestFindingReportState(t *testing.T) {
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { d.Exec(`DELETE FROM notification_events WHERE finding_id IN ($1,$2)`, fid, second) })
t.Cleanup(func() {
_, _ = d.Exec(`DELETE FROM notification_events WHERE finding_id IN ($1,$2)`, fid, second)
_, _ = d.DeleteFinding(fid)
_, _ = d.DeleteFinding(second)
})
one, err := d.GetFinding(fid)
if err != nil || one == nil || one.ReportState != FindingReportNone {
@@ -633,6 +638,7 @@ func TestAddFindingFollowUpIntent(t *testing.T) {
if err != nil {
t.Fatal(err)
}
defer d.DeleteFinding(findingID)
auditInput := Activity{Worker: "system", Kind: "text", Summary: "Manually submitted vulnerability deep-exploitation intent", Detail: "Verify exploitability and build an evidence chain"}
intentID, audit, err := store.AddFindingFollowUpIntent(findingID, findingNodeID, "Verify exploitability and build an evidence chain", auditInput)
+12 -2
View File
@@ -191,11 +191,14 @@ func TestExtractLessonsScopesSingleCompanyFromTaskScope(t *testing.T) {
t.Fatal(err)
}
t.Cleanup(func() { cleanupErr(t, "extract task", d.DeleteTask(task.ID)) })
if _, err := d.Exec(`
var extractedFID int64
if err := d.QueryRow(`
INSERT INTO findings(task_id,vulnclass,name,summary,severity,status)
VALUES ($1,'xss','Reflected XSS','reflected in search','high','confirmed')`, task.ID); err != nil {
VALUES ($1,'xss','Reflected XSS','reflected in search','high','confirmed')
RETURNING id`, task.ID).Scan(&extractedFID); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, extractedFID) })
n, err := d.ExtractLessonsForTask(t.Context(), task.ID)
if err != nil {
t.Fatal(err)
@@ -477,6 +480,7 @@ func TestExtractLessonsRetractsReversedDisposition(t *testing.T) {
RETURNING id`, task.ID, cue, label).Scan(&fid); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, fid) })
n, err := d.ExtractLessonsForTask(t.Context(), task.ID)
if err != nil {
@@ -589,12 +593,14 @@ func TestExtractLessonsRetireOnlyWhenLastEvidence(t *testing.T) {
RETURNING id`, task.ID, cue, label).Scan(&aID); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, aID) })
if err := d.QueryRow(`
INSERT INTO findings(task_id,vulnclass,name,summary,severity,status)
VALUES ($1,$2,'Reflected XSS',$3,'high','confirmed')
RETURNING id`, task.ID, cue, label).Scan(&bID); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, bID) })
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
t.Fatal(err)
@@ -681,6 +687,7 @@ func TestExtractLessonsRetractsAllRetests(t *testing.T) {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, fid) })
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, fid) })
r1 := insertLessonRetest(t, d, fid, "reproduced")
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
@@ -752,6 +759,7 @@ func TestExtractLessonsDoesNotUnretireWithEvidence(t *testing.T) {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, fid) })
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, fid) })
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
t.Fatal(err)
@@ -798,6 +806,7 @@ func TestExtractLessonsLeavesAdopted(t *testing.T) {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, fid) })
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, fid) })
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
t.Fatal(err)
@@ -841,6 +850,7 @@ func TestExtractLessonsReopenRetractsNothing(t *testing.T) {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, fid) })
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, fid) })
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
t.Fatal(err)
+21 -2
View File
@@ -1,6 +1,7 @@
package db
import (
"database/sql"
"sort"
"strconv"
"time"
@@ -71,14 +72,32 @@ VALUES (NULLIF($1,''),$2,NULLIF($3,''),NULLIF($4,''),NULLIF($5,''),$6,$7,$8,$9,$
// Accurate even with per-agent model bindings, pool rotation/failover, and
// interrupted runs, since every call (success or error) is metered.
func (d *DB) TokenByModel(taskID string) ([]ModelTokenStat, error) {
rows, err := d.Query(`
// Keep the predicate sargable for non-empty task IDs so PostgreSQL can use
// idx_llm_usage_model(task_id, model) instead of sequentially scanning the
// table via COALESCE(task_id, '').
var (
rows *sql.Rows
err error
)
if taskID == "" {
rows, err = d.Query(`
SELECT COALESCE(NULLIF(model,''),'(unknown)') AS model, COUNT(*) AS calls,
COALESCE(SUM(input_tokens),0), COALESCE(SUM(output_tokens),0),
COALESCE(SUM(cache_read),0), COALESCE(SUM(cache_write),0)
FROM llm_usage
WHERE COALESCE(task_id,'') = $1
WHERE task_id IS NULL OR task_id = ''
GROUP BY model
ORDER BY SUM(input_tokens) + SUM(output_tokens) DESC, model`)
} else {
rows, err = d.Query(`
SELECT COALESCE(NULLIF(model,''),'(unknown)') AS model, COUNT(*) AS calls,
COALESCE(SUM(input_tokens),0), COALESCE(SUM(output_tokens),0),
COALESCE(SUM(cache_read),0), COALESCE(SUM(cache_write),0)
FROM llm_usage
WHERE task_id = $1
GROUP BY model
ORDER BY SUM(input_tokens) + SUM(output_tokens) DESC, model`, taskID)
}
if err != nil {
return nil, err
}
+2 -2
View File
@@ -44,7 +44,7 @@ func TestCostSeparatesFreshReadAndWriteBuckets(t *testing.T) {
if err != nil {
t.Fatal(err)
}
defer d.Close()
t.Cleanup(func() { d.Close() })
priced, unpriced := costProfiles(t, d)
// Every case adds 100k output tokens: 0.1 × 4.00 = 0.40.
for _, tc := range []struct {
@@ -82,7 +82,7 @@ func TestUsageByProfileCostAggregatesRows(t *testing.T) {
if err != nil {
t.Fatal(err)
}
defer d.Close()
t.Cleanup(func() { d.Close() })
priced, unpriced := costProfiles(t, d)
t.Cleanup(func() { d.Exec(`DELETE FROM llm_usage WHERE profile_name IN ($1,$2)`, priced, unpriced) })
rows := []LLMUsage{
+4 -3
View File
@@ -123,7 +123,7 @@ func readApplied(t *testing.T, d *DB) []appliedMigration {
// embedded migration is recorded with the SHA-256 of its file.
func assertEmbeddedApplied(t *testing.T, d *DB) []appliedMigration {
t.Helper()
for _, table := range []string{"llm_records", "llm_usage", "llm_context"} {
for _, table := range []string{"llm_records", "llm_usage", "llm_context", "traffic_tamper_hooks", "traffic_tamper_hook_versions"} {
var exists bool
if err := d.QueryRow(`SELECT to_regclass($1) IS NOT NULL`, table).Scan(&exists); err != nil {
t.Fatal(err)
@@ -138,9 +138,10 @@ func assertEmbeddedApplied(t *testing.T, d *DB) []appliedMigration {
name string
}{{1, llmRecordsMigration}, {2, llmUsageMigration}, {3, "0003_task_scope_icp_index.sql"}, {4, "0004_llm_usage_ts_index.sql"},
{5, "0005_traffic_rewrite_rules.sql"}, {6, "0006_activity_outbox.sql"}, {7, "0007_finding_report_state.sql"},
{8, "0008_traffic_evidence_rewrite_flag.sql"}, {9, "0009_llm_context.sql"}}
{8, "0008_traffic_evidence_rewrite_flag.sql"}, {9, "0009_llm_context.sql"}, {10, "0010_dashboard_usage_indexes.sql"},
{11, "0011_traffic_tamper_hooks.sql"}}
if len(applied) != len(want) {
t.Fatalf("schema_migrations = %+v, want versions 1 to 9", applied)
t.Fatalf("schema_migrations = %+v, want versions 1 to 11", applied)
}
for i, w := range want {
content, err := fs.ReadFile(migrationsFS(), w.name)
@@ -0,0 +1,36 @@
-- Partial covering indexes proved via EXPLAIN (ANALYZE, BUFFERS) on seeded
-- production-shaped tables (P3.6 dashboard & usage query hygiene):
--
-- 1. idx_act_result_created: TokenDailyAll (db/exploration.go) aggregates
-- activity WHERE kind='result' AND created_at >= now() - interval. The
-- existing idx_act_result_usage is keyed on exploration_id, so date-bounded
-- global daily rollups previously fell back to a bitmap heap scan across all
-- result rows (~100x fewer shared buffers with an index-only scan).
-- 2. idx_conv_act_result: ConversationTokenSummaries (db/conversation.go,
-- polled every 5s by the dashboard) left-joins conversation_activities on
-- (conversation_id) WHERE kind='result'. Without a partial index on
-- kind='result', every poll sequentially scans the entire
-- conversation_activities table (~65x fewer shared buffers).
-- 3. idx_llm_usage_judge_ts: JudgeUsageStats (db/llm_usage.go) filters
-- llm_usage WHERE worker='judge' (all-time and recent window). Judge rows
-- are a small fraction of the append-only ledger; a partial covering index
-- turns both queries into index-only scans (~60-80x fewer shared buffers).
--
-- Plain CREATE INDEX (migrations run in a transaction at startup before the
-- HTTP server listens). Very large installs can pre-build them online with
-- CREATE INDEX CONCURRENTLY IF NOT EXISTS before upgrading.
CREATE INDEX IF NOT EXISTS idx_act_result_created
ON activity(created_at)
INCLUDE (input_tokens, output_tokens, cache_read_tokens)
WHERE kind = 'result';
CREATE INDEX IF NOT EXISTS idx_conv_act_result
ON conversation_activities(conversation_id)
INCLUDE (input_tokens, output_tokens, cache_read_tokens, cache_write_tokens)
WHERE kind = 'result';
CREATE INDEX IF NOT EXISTS idx_llm_usage_judge_ts
ON llm_usage(ts)
INCLUDE (input_tokens, output_tokens, cache_read, cache_write)
WHERE worker = 'judge';
@@ -0,0 +1,42 @@
-- Constrained Go tampering hooks of the capture proxy (P4.2). Global
-- configuration: neither table is part of a task archive.
--
-- source (TEXT) and matchers (JSONB) on BOTH traffic_tamper_hooks and
-- traffic_tamper_hook_versions are sealed at rest by db/secrets.go because a
-- hook can carry a hardcoded secret (for example an HMAC signing key).
--
-- Execution order is priority ascending, then id ascending. A hook is always
-- created disabled (enabled = false).
CREATE TABLE IF NOT EXISTS traffic_tamper_hooks (
id BIGSERIAL PRIMARY KEY,
name TEXT NOT NULL,
enabled BOOLEAN NOT NULL DEFAULT false,
phase TEXT NOT NULL CHECK (phase IN ('request', 'response')),
priority INTEGER NOT NULL DEFAULT 0,
matchers JSONB NOT NULL DEFAULT '{}'::jsonb,
source TEXT NOT NULL,
source_sha256 TEXT NOT NULL,
version INTEGER NOT NULL DEFAULT 1,
note TEXT NOT NULL DEFAULT '',
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
DROP TRIGGER IF EXISTS trg_traffic_tamper_hooks_upd ON traffic_tamper_hooks;
CREATE TRIGGER trg_traffic_tamper_hooks_upd BEFORE UPDATE ON traffic_tamper_hooks
FOR EACH ROW EXECUTE FUNCTION set_updated_at();
CREATE TABLE IF NOT EXISTS traffic_tamper_hook_versions (
id BIGSERIAL PRIMARY KEY,
hook_id BIGINT NOT NULL REFERENCES traffic_tamper_hooks(id) ON DELETE CASCADE,
version INTEGER NOT NULL,
name TEXT NOT NULL,
phase TEXT NOT NULL CHECK (phase IN ('request', 'response')),
priority INTEGER NOT NULL DEFAULT 0,
matchers JSONB NOT NULL DEFAULT '{}'::jsonb,
source TEXT NOT NULL,
source_sha256 TEXT NOT NULL,
note TEXT NOT NULL DEFAULT '',
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
UNIQUE (hook_id, version)
);
CREATE INDEX IF NOT EXISTS idx_tamper_hook_versions_hook ON traffic_tamper_hook_versions(hook_id, version DESC);
+17 -6
View File
@@ -534,7 +534,7 @@ func TestSetFindingStatusWithNotifyOnlyEmitsOnRealChange(t *testing.T) {
if err != nil {
t.Fatal(err)
}
defer d.DeleteTask(tk.ID)
t.Cleanup(func() { _ = d.DeleteTask(tk.ID) })
es := d.Exploration(tk.ExplorationID)
f, err := es.RecordFinding(ctx, RecordFindingInput{
TaskID: tk.ID, Worker: "test", VulnClass: "SQL injection", Name: "status change case",
@@ -543,7 +543,10 @@ func TestSetFindingStatusWithNotifyOnlyEmitsOnRealChange(t *testing.T) {
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { d.Exec(`DELETE FROM notification_events WHERE finding_id=$1`, f.FindingID) })
t.Cleanup(func() {
_, _ = d.Exec(`DELETE FROM notification_events WHERE finding_id=$1`, f.FindingID)
_, _ = d.DeleteFinding(f.FindingID)
})
// Writing the finding already registered one finding_created event; count it as the baseline.
var base int
@@ -617,7 +620,7 @@ func TestSetFindingStatusesWithNotify(t *testing.T) {
if err != nil {
t.Fatal(err)
}
defer d.DeleteTask(tk.ID)
t.Cleanup(func() { _ = d.DeleteTask(tk.ID) })
es := d.Exploration(tk.ExplorationID)
record := func(name string) int64 {
fi, err := es.RecordFinding(ctx, RecordFindingInput{
@@ -627,7 +630,10 @@ func TestSetFindingStatusesWithNotify(t *testing.T) {
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { d.Exec(`DELETE FROM notification_events WHERE finding_id=$1`, fi.FindingID) })
t.Cleanup(func() {
_, _ = d.Exec(`DELETE FROM notification_events WHERE finding_id=$1`, fi.FindingID)
_, _ = d.DeleteFinding(fi.FindingID)
})
return fi.FindingID
}
first, second := record("bulk one"), record("bulk two")
@@ -891,7 +897,7 @@ func TestFinishFindingRetestEmitsStatusChange(t *testing.T) {
if err != nil {
t.Fatal(err)
}
defer d.DeleteTask(tk.ID)
t.Cleanup(func() { _ = d.DeleteTask(tk.ID) })
es := d.Exploration(tk.ExplorationID)
f, err := es.RecordFinding(ctx, RecordFindingInput{
TaskID: tk.ID, Worker: "test", VulnClass: "SQL injection", Name: "retest target",
@@ -900,7 +906,10 @@ func TestFinishFindingRetestEmitsStatusChange(t *testing.T) {
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { d.Exec(`DELETE FROM notification_events WHERE finding_id=$1`, f.FindingID) })
t.Cleanup(func() {
_, _ = d.Exec(`DELETE FROM notification_events WHERE finding_id=$1`, f.FindingID)
_, _ = d.DeleteFinding(f.FindingID)
})
// Create a retest record and drive it straight to completion.
rt, _, _, err := d.CreateFindingRetest(ctx, f.FindingID, "review")
@@ -910,6 +919,8 @@ func TestFinishFindingRetestEmitsStatusChange(t *testing.T) {
if rt.ConversationID == nil {
t.Fatal("a retest should be associated with a session")
}
retestConvID := *rt.ConversationID
t.Cleanup(func() { _ = d.DeleteConversation(retestConvID) })
// A retest must enter running before a verdict can land (consistent with the real flow).
if ok, err := d.StartFindingRetest(ctx, rt.ID); err != nil || !ok {
t.Fatalf("failed to start retest: ok=%v err=%v", ok, err)
+6 -1
View File
@@ -90,7 +90,12 @@ var (
// Capture-proxy rewrite rules: an action may carry a token, a matcher a header value.
colRewriteMatchers = secretColumn{"traffic_rewrite_rules", "matchers", true, ""}
colRewriteActions = secretColumn{"traffic_rewrite_rules", "actions", true, ""}
secretColumns = append([]secretColumn{colLLMKey, colLLMProxy, colMCPEnv, colCredPass, colNotifConfig, colToolExec, colEvReqHead, colEvRespHead, colRewriteMatchers, colRewriteActions}, secretSettingColumns()...)
// Capture-proxy tampering hooks and their version history: source may carry hardcoded secrets.
colHookMatchers = secretColumn{"traffic_tamper_hooks", "matchers", true, ""}
colHookSource = secretColumn{"traffic_tamper_hooks", "source", false, ""}
colHookVerMatchers = secretColumn{"traffic_tamper_hook_versions", "matchers", true, ""}
colHookVerSource = secretColumn{"traffic_tamper_hook_versions", "source", false, ""}
secretColumns = append([]secretColumn{colLLMKey, colLLMProxy, colMCPEnv, colCredPass, colNotifConfig, colToolExec, colEvReqHead, colEvRespHead, colRewriteMatchers, colRewriteActions, colHookMatchers, colHookSource, colHookVerMatchers, colHookVerSource}, secretSettingColumns()...)
)
// secretSettingKeys are the settings stored encrypted, AAD "settings.<key>".
+11 -1
View File
@@ -60,6 +60,7 @@ type TaskArchive struct {
Warnings json.RawMessage `json:"warnings"`
FormatVersion int `json:"format_version"`
ArchivePath string `json:"-"`
Storage string `json:"storage,omitempty"`
SHA256 string `json:"sha256,omitempty"`
OriginalSize int64 `json:"original_size"`
CompressedSize int64 `json:"compressed_size"`
@@ -161,6 +162,12 @@ func scanTaskArchive(sc interface{ Scan(...any) error }) (*TaskArchive, error) {
if err != nil {
return nil, err
}
if item.ArchivePath != "" {
item.Storage = "local"
if strings.HasPrefix(item.ArchivePath, "s3://") {
item.Storage = "s3"
}
}
if err := json.Unmarshal([]byte(sources), &item.SourceTaskIDs); err != nil {
return nil, err
}
@@ -449,7 +456,10 @@ func (d *DB) FailTaskArchiveJob(id int64, activeState string, cause error) error
if cause != nil {
message = cause.Error()
}
_, err := d.Exec(`UPDATE task_archives SET state=$2,phase='failed',error=$3 WHERE id=$1`, id, failed, message)
// Only a job still in its active state fails. The worker also reports a panic
// it recovered after the job committed: a ready archive marked archive_failed
// could be neither restored nor deleted.
_, err := d.Exec(`UPDATE task_archives SET state=$2,phase='failed',error=$3 WHERE id=$1 AND state=$4`, id, failed, message, activeState)
return err
}
+61 -3
View File
@@ -154,19 +154,28 @@ func TestTaskArchiveDatabaseRoundTrip(t *testing.T) {
VALUES($1,$2,0,'quota_exhausted','balance exhausted',$3,$4,$3)`, task.ID, llmProfileID, exhaustedAt, chainCreatedAt); err != nil {
t.Fatal(err)
}
var assetID, findingID int64
defer func() {
_, _ = d.Exec(`DELETE FROM llm_usage WHERE task_id=$1 OR exploration_id=$2`, fmt.Sprint(task.ID), task.ExplorationID)
_, _ = d.Exec(`DELETE FROM llm_records WHERE task_id=$1`, fmt.Sprint(task.ID))
_, _ = d.Exec(`DELETE FROM skill_usage WHERE task_id=$1 OR exploration_id=$2`, task.ID, task.ExplorationID)
_, _ = d.Exec(`DELETE FROM tool_usage WHERE task_id=$1 OR exploration_id=$2`, task.ID, task.ExplorationID)
_, _ = d.DeleteFindingsByTask(task.ID)
if findingID != 0 {
_, _ = d.DeleteFinding(findingID)
}
_, _ = d.Exec(`DELETE FROM task_archives WHERE task_id=$1`, task.ID)
_ = d.DeleteTask(task.ID)
if assetID != 0 {
_, _ = d.Exec(`DELETE FROM assets WHERE id=$1`, assetID)
}
_, _ = d.Exec(`DELETE FROM llm_profiles WHERE id=$1`, llmProfileID)
_, _ = d.Exec(`DELETE FROM companies WHERE id=$1`, companyID)
}()
if err := d.SetPaused(task.ID, true); err != nil {
t.Fatal(err)
}
assetID, err := d.Assets().UpsertRootDomain(UpsertRootDomainReq{Domain: fmt.Sprintf("archive-%d.example", task.ID), TaskID: task.ID})
assetID, err = d.Assets().UpsertRootDomain(UpsertRootDomainReq{Domain: fmt.Sprintf("archive-%d.example", task.ID), TaskID: task.ID})
if err != nil {
t.Fatal(err)
}
@@ -197,13 +206,20 @@ VALUES($1,$2,0,'quota_exhausted','balance exhausted',$3,$4,$3)`, task.ID, llmPro
}); err != nil {
t.Fatal(err)
}
if _, err := d.AddFinding(task.ID, nodeID, vulnclass, "archive finding", SeverityCritical, "summary", "evidence", "worker", []int64{assetID}); err != nil {
if findingID, err = d.AddFinding(task.ID, nodeID, vulnclass, "archive finding", SeverityCritical, "summary", "evidence", "worker", []int64{assetID}); err != nil {
t.Fatal(err)
}
archive, err := d.QueueTaskArchive(task.ID)
if err != nil {
t.Fatal(err)
}
if archive.Storage != "" {
t.Fatalf("queued archive without a location has storage %q", archive.Storage)
}
encoded, err := json.Marshal(archive)
if err != nil || bytes.Contains(encoded, []byte(`"storage"`)) {
t.Fatalf("unknown storage must be omitted from JSON: %s, %v", encoded, err)
}
claimed, err := d.ClaimTaskArchiveJob(t.Context())
if err != nil || claimed == nil || claimed.ID != archive.ID || claimed.State != Archiving {
t.Fatalf("claim = %+v, %v", claimed, err)
@@ -242,7 +258,7 @@ VALUES($1,$2,0,'quota_exhausted','balance exhausted',$3,$4,$3)`, task.ID, llmPro
t.Fatalf("hot compaction left nodes=%d assets=%d usage=%d", nodes, assets, usage)
}
ready, err := d.GetTaskArchive(archive.ID)
if err != nil || ready == nil || ready.State != ArchiveReady {
if err != nil || ready == nil || ready.State != ArchiveReady || ready.Storage != "local" {
t.Fatalf("ready archive = %+v, %v", ready, err)
}
var stats map[string]any
@@ -517,3 +533,45 @@ func TestFillArchiveDefaults(t *testing.T) {
t.Fatalf("activity changed: %s err=%v", out, err)
}
}
// FailTaskArchiveJob fails a job that is still running. A failure reported after
// the archive committed (the worker recovers a panic in the cleanup that follows
// the commit) must not turn a ready archive into archive_failed: it could then
// be neither restored nor deleted.
func TestFailTaskArchiveJobKeepsCommittedState(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
SkipPGUnavailable(t, err)
}
defer d.Close()
task, err := d.CreateTaskWithOptions("late archive failure", "must stay ready", TaskCreateOptions{})
if err != nil {
t.Fatal(err)
}
defer func() {
_, _ = d.Exec(`DELETE FROM task_archives WHERE task_id=$1`, task.ID)
_ = d.DeleteTask(task.ID)
}()
if err := d.SetPaused(task.ID, true); err != nil {
t.Fatal(err)
}
queued, err := d.QueueTaskArchive(task.ID)
if err != nil {
t.Fatal(err)
}
for _, c := range []struct{ state, want string }{{Archiving, ArchiveFailed}, {ArchiveReady, ArchiveReady}} {
if _, err := d.Exec(`UPDATE task_archives SET state=$2,error='' WHERE id=$1`, queued.ID, c.state); err != nil {
t.Fatal(err)
}
if err := d.FailTaskArchiveJob(queued.ID, Archiving, errors.New("late failure")); err != nil {
t.Fatal(err)
}
item, err := d.GetTaskArchive(queued.ID)
if err != nil || item == nil {
t.Fatalf("archive %d: %v", queued.ID, err)
}
if item.State != c.want || (c.want == ArchiveFailed) != (item.Error == "late failure") {
t.Fatalf("failing a job in state %s: state=%s error=%q, want state %s", c.state, item.State, item.Error, c.want)
}
}
}
+5 -1
View File
@@ -168,8 +168,9 @@ func TestIntentAssetsIncludesDirectSourceProvenance(t *testing.T) {
cleanupErr(t, "source task", d.DeleteTask(source.ID))
})
intentHost := fmt.Sprintf("intent-%d.example.test", time.Now().UnixNano())
assetID, err := d.Assets().UpsertHTTPService(UpsertHTTPServiceReq{
URL: fmt.Sprintf("https://intent-%d.example.test", time.Now().UnixNano()), TaskID: source.ID,
URL: "https://" + intentHost, TaskID: source.ID,
})
if err != nil {
t.Fatal(err)
@@ -177,6 +178,9 @@ func TestIntentAssetsIncludesDirectSourceProvenance(t *testing.T) {
t.Cleanup(func() {
_, err := d.Assets().DeleteByIDs([]int64{assetID})
cleanupErr(t, "asset", err)
// UpsertHTTPService also creates the parent subdomain and root_domain rows.
_, err = d.Exec(`DELETE FROM assets WHERE domain IN ($1, 'example.test')`, intentHost)
cleanupErr(t, "parent assets", err)
})
intentID, err := d.Exploration(source.ExplorationID).AddIntent(map[string]any{"summary": "source worker"}, 5, []int64{assetID}, "planner")
if err != nil {
+1 -1
View File
@@ -13,7 +13,7 @@ func TestTaskLLMSpendCountsJudgeNotChat(t *testing.T) {
if err != nil {
SkipPGUnavailable(t, err)
}
defer d.Close()
t.Cleanup(func() { _ = d.Close() })
taskID := fmt.Sprintf("spend-%d", time.Now().UnixNano())
t.Cleanup(func() {
+329
View File
@@ -0,0 +1,329 @@
package db
import (
"crypto/sha256"
"database/sql"
"encoding/hex"
"encoding/json"
"errors"
"time"
)
// Limits on capture-proxy tampering hooks (P4.2).
const (
MaxTrafficTamperHooks = 50
MaxEnabledTrafficTamperHooks = 20
MaxTamperHookVersions = 20
)
var (
ErrTrafficTamperHookLimit = errors.New("the limit of 50 tampering hooks is reached")
ErrTrafficTamperHookEnabledLimit = errors.New("the limit of 20 enabled tampering hooks is reached")
)
// TrafficTamperHook is one row of traffic_tamper_hooks. Source and Matchers
// are sealed at rest with db/secrets.go and decrypted here.
type TrafficTamperHook struct {
ID int64
Name string
Enabled bool
Phase string // request | response
Priority int
Matchers json.RawMessage
Source string
SourceSHA256 string
Version int
Note string
CreatedAt time.Time
UpdatedAt time.Time
}
// TrafficTamperHookVersion is one immutable historical revision in
// traffic_tamper_hook_versions. Source and Matchers are sealed at rest.
type TrafficTamperHookVersion struct {
ID int64
HookID int64
Version int
Name string
Phase string
Priority int
Matchers json.RawMessage
Source string
SourceSHA256 string
Note string
CreatedAt time.Time
}
const (
tamperHookCols = `id, name, enabled, phase, priority, matchers::text, source, source_sha256, version, note, created_at, updated_at`
tamperHookVerCols = `id, hook_id, version, name, phase, priority, matchers::text, source, source_sha256, note, created_at`
)
func hookSourceSHA256(src string) string {
sum := sha256.Sum256([]byte(src))
return hex.EncodeToString(sum[:])
}
func normalizeMatchersJSON(raw json.RawMessage) string {
if len(raw) == 0 {
return "{}"
}
return string(raw)
}
func scanTamperHook(row interface{ Scan(...any) error }) (TrafficTamperHook, error) {
var h TrafficTamperHook
var matchers, source string
err := row.Scan(&h.ID, &h.Name, &h.Enabled, &h.Phase, &h.Priority, &matchers, &source, &h.SourceSHA256, &h.Version, &h.Note, &h.CreatedAt, &h.UpdatedAt)
if err == nil {
matchers, err = openSecret(colHookMatchers, matchers)
}
if err == nil {
source, err = openSecret(colHookSource, source)
}
h.Matchers, h.Source = json.RawMessage(matchers), source
return h, err
}
func scanTamperHookVersion(row interface{ Scan(...any) error }) (TrafficTamperHookVersion, error) {
var v TrafficTamperHookVersion
var matchers, source string
err := row.Scan(&v.ID, &v.HookID, &v.Version, &v.Name, &v.Phase, &v.Priority, &matchers, &source, &v.SourceSHA256, &v.Note, &v.CreatedAt)
if err == nil {
matchers, err = openSecret(colHookVerMatchers, matchers)
}
if err == nil {
source, err = openSecret(colHookVerSource, source)
}
v.Matchers, v.Source = json.RawMessage(matchers), source
return v, err
}
func sealTamperHook(h TrafficTamperHook) (matchers, source string, err error) {
if matchers, err = sealSecret(colHookMatchers, normalizeMatchersJSON(h.Matchers)); err != nil {
return "", "", err
}
source, err = sealSecret(colHookSource, h.Source)
return matchers, source, err
}
func sealTamperHookVersion(h TrafficTamperHook) (matchers, source string, err error) {
if matchers, err = sealSecret(colHookVerMatchers, normalizeMatchersJSON(h.Matchers)); err != nil {
return "", "", err
}
source, err = sealSecret(colHookVerSource, h.Source)
return matchers, source, err
}
func (d *DB) tamperHookTx(fn func(tx *sql.Tx) error) error {
tx, err := d.Begin()
if err != nil {
return err
}
defer tx.Rollback() //nolint:errcheck
if _, err := tx.Exec(`LOCK TABLE traffic_tamper_hooks IN SHARE ROW EXCLUSIVE MODE`); err != nil {
return err
}
if err := fn(tx); err != nil {
return err
}
return tx.Commit()
}
func tamperHookEnabledRoom(tx *sql.Tx, id int64) error {
var n int
if err := tx.QueryRow(`SELECT count(*) FROM traffic_tamper_hooks WHERE enabled AND id<>$1`, id).Scan(&n); err != nil {
return err
}
if n >= MaxEnabledTrafficTamperHooks {
return ErrTrafficTamperHookEnabledLimit
}
return nil
}
func recordTamperHookVersionTx(tx *sql.Tx, h TrafficTamperHook) error {
matchers, source, err := sealTamperHookVersion(h)
if err != nil {
return err
}
if _, err := tx.Exec(`
INSERT INTO traffic_tamper_hook_versions(hook_id, version, name, phase, priority, matchers, source, source_sha256, note)
VALUES ($1, $2, $3, $4, $5, $6::jsonb, $7, $8, $9)`,
h.ID, h.Version, h.Name, h.Phase, h.Priority, matchers, source, h.SourceSHA256, h.Note); err != nil {
return err
}
// Retain at most MaxTamperHookVersions newest revisions per hook.
_, err = tx.Exec(`
DELETE FROM traffic_tamper_hook_versions
WHERE hook_id=$1 AND id NOT IN (
SELECT id FROM traffic_tamper_hook_versions WHERE hook_id=$1 ORDER BY version DESC LIMIT $2
)`, h.ID, MaxTamperHookVersions)
return err
}
// ListTrafficTamperHooks returns all hooks in execution order (priority ASC, id ASC).
func (d *DB) ListTrafficTamperHooks() ([]TrafficTamperHook, error) {
rows, err := d.Query(`SELECT ` + tamperHookCols + ` FROM traffic_tamper_hooks ORDER BY priority, id`)
if err != nil {
return nil, err
}
defer rows.Close()
var out []TrafficTamperHook
for rows.Next() {
h, err := scanTamperHook(rows)
if err != nil {
return nil, err
}
out = append(out, h)
}
return out, rows.Err()
}
// GetTrafficTamperHook returns one hook, or sql.ErrNoRows when absent.
func (d *DB) GetTrafficTamperHook(id int64) (TrafficTamperHook, error) {
return scanTamperHook(d.QueryRow(`SELECT `+tamperHookCols+` FROM traffic_tamper_hooks WHERE id=$1`, id))
}
// CreateTrafficTamperHook inserts a new hook (always disabled, version 1) and
// records version 1 in traffic_tamper_hook_versions.
func (d *DB) CreateTrafficTamperHook(h TrafficTamperHook) (out TrafficTamperHook, err error) {
h.Enabled = false
h.Version = 1
h.SourceSHA256 = hookSourceSHA256(h.Source)
matchers, source, err := sealTamperHook(h)
if err != nil {
return out, err
}
err = d.tamperHookTx(func(tx *sql.Tx) error {
var n int
if err := tx.QueryRow(`SELECT count(*) FROM traffic_tamper_hooks`).Scan(&n); err != nil {
return err
}
if n >= MaxTrafficTamperHooks {
return ErrTrafficTamperHookLimit
}
out, err = scanTamperHook(tx.QueryRow(`
INSERT INTO traffic_tamper_hooks(name, enabled, phase, priority, matchers, source, source_sha256, version, note)
VALUES ($1, false, $2, $3, $4::jsonb, $5, $6, 1, $7)
RETURNING `+tamperHookCols, h.Name, h.Phase, h.Priority, matchers, source, h.SourceSHA256, h.Note))
if err != nil {
return err
}
return recordTamperHookVersionTx(tx, out)
})
return out, err
}
// UpdateTrafficTamperHook updates a hook, increments its version, and appends
// the new revision to traffic_tamper_hook_versions.
func (d *DB) UpdateTrafficTamperHook(id int64, edit func(stored TrafficTamperHook) (TrafficTamperHook, error)) (out TrafficTamperHook, err error) {
err = d.tamperHookTx(func(tx *sql.Tx) error {
stored, err := scanTamperHook(tx.QueryRow(`SELECT `+tamperHookCols+` FROM traffic_tamper_hooks WHERE id=$1`, id))
if err != nil {
return err
}
next, err := edit(stored)
if err != nil {
return err
}
if next.Enabled && !stored.Enabled {
if err := tamperHookEnabledRoom(tx, id); err != nil {
return err
}
}
next.Version = stored.Version + 1
next.SourceSHA256 = hookSourceSHA256(next.Source)
matchers, source, err := sealTamperHook(next)
if err != nil {
return err
}
out, err = scanTamperHook(tx.QueryRow(`
UPDATE traffic_tamper_hooks
SET name=$2, enabled=$3, phase=$4, priority=$5, matchers=$6::jsonb, source=$7, source_sha256=$8, version=$9, note=$10
WHERE id=$1
RETURNING `+tamperHookCols, id, next.Name, next.Enabled, next.Phase, next.Priority, matchers, source, next.SourceSHA256, next.Version, next.Note))
if err != nil {
return err
}
return recordTamperHookVersionTx(tx, out)
})
return out, err
}
// ToggleTrafficTamperHook sets the enabled state of a hook without creating a
// new source version.
func (d *DB) ToggleTrafficTamperHook(id int64, enabled bool) error {
return d.tamperHookTx(func(tx *sql.Tx) error {
if enabled {
if err := tamperHookEnabledRoom(tx, id); err != nil {
return err
}
}
return oneRow(tx.Exec(`UPDATE traffic_tamper_hooks SET enabled=$2 WHERE id=$1`, id, enabled))
})
}
// DeleteTrafficTamperHook removes a hook and cascades its version history.
func (d *DB) DeleteTrafficTamperHook(id int64) error {
return oneRow(d.Exec(`DELETE FROM traffic_tamper_hooks WHERE id=$1`, id))
}
// ListTrafficTamperHookVersions returns stored revisions of hookID newest-first.
func (d *DB) ListTrafficTamperHookVersions(hookID int64) ([]TrafficTamperHookVersion, error) {
rows, err := d.Query(`SELECT `+tamperHookVerCols+` FROM traffic_tamper_hook_versions WHERE hook_id=$1 ORDER BY version DESC`, hookID)
if err != nil {
return nil, err
}
defer rows.Close()
var out []TrafficTamperHookVersion
for rows.Next() {
v, err := scanTamperHookVersion(rows)
if err != nil {
return nil, err
}
out = append(out, v)
}
return out, rows.Err()
}
// RollbackTrafficTamperHook restores hookID to targetVersion's code, matchers,
// phase, priority, name, and note as a new monotonic version (preserving full
// append-only version history and keeping the current enabled flag).
func (d *DB) RollbackTrafficTamperHook(hookID int64, targetVersion int) (out TrafficTamperHook, err error) {
err = d.tamperHookTx(func(tx *sql.Tx) error {
stored, err := scanTamperHook(tx.QueryRow(`SELECT `+tamperHookCols+` FROM traffic_tamper_hooks WHERE id=$1`, hookID))
if err != nil {
return err
}
rev, err := scanTamperHookVersion(tx.QueryRow(`SELECT `+tamperHookVerCols+` FROM traffic_tamper_hook_versions WHERE hook_id=$1 AND version=$2`, hookID, targetVersion))
if err != nil {
return err
}
next := TrafficTamperHook{
ID: hookID,
Name: rev.Name,
Enabled: stored.Enabled,
Phase: rev.Phase,
Priority: rev.Priority,
Matchers: rev.Matchers,
Source: rev.Source,
SourceSHA256: hookSourceSHA256(rev.Source),
Version: stored.Version + 1,
Note: rev.Note,
}
matchers, source, err := sealTamperHook(next)
if err != nil {
return err
}
out, err = scanTamperHook(tx.QueryRow(`
UPDATE traffic_tamper_hooks
SET name=$2, phase=$3, priority=$4, matchers=$5::jsonb, source=$6, source_sha256=$7, version=$8, note=$9
WHERE id=$1
RETURNING `+tamperHookCols, hookID, next.Name, next.Phase, next.Priority, matchers, source, next.SourceSHA256, next.Version, next.Note))
if err != nil {
return err
}
return recordTamperHookVersionTx(tx, out)
})
return out, err
}
+100
View File
@@ -0,0 +1,100 @@
package db
import (
"database/sql"
"encoding/json"
"errors"
"strings"
"testing"
)
func TestTrafficTamperHookCRUDSealedAndVersions(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
SkipPGUnavailable(t, err)
}
t.Cleanup(func() { _ = d.Close() })
const srcV1 = `package hook
const apiSecret = "super-secret-hmac-key-v1"
func OnRequest(req *Request) error { req.SetHeader("X-V", "1"); return nil }`
const srcV2 = `package hook
const apiSecret = "super-secret-hmac-key-v2"
func OnRequest(req *Request) error { req.SetHeader("X-V", "2"); return nil }`
h, err := d.CreateTrafficTamperHook(TrafficTamperHook{
Name: "t-hook-sealed",
Enabled: true, // Create always forces disabled
Phase: "request",
Priority: 5,
Matchers: json.RawMessage(`{"host":"api.example.test"}`),
Source: srcV1,
Note: "v1",
})
if err != nil {
t.Fatalf("CreateTrafficTamperHook: %v", err)
}
t.Cleanup(func() { _ = d.DeleteTrafficTamperHook(h.ID) })
if h.Enabled || h.Version != 1 || h.Source != srcV1 {
t.Fatalf("created hook = %+v", h)
}
// Verify BOTH traffic_tamper_hooks AND traffic_tamper_hook_versions seal source & matchers at rest.
var rawSrc, rawMatchers string
if err := d.QueryRow(`SELECT source, matchers::text FROM traffic_tamper_hooks WHERE id=$1`, h.ID).Scan(&rawSrc, &rawMatchers); err != nil {
t.Fatal(err)
}
if !strings.HasPrefix(rawSrc, secretPrefix) || strings.Contains(rawSrc, "super-secret-hmac-key") {
t.Fatalf("traffic_tamper_hooks.source is not sealed at rest: %q", rawSrc)
}
if !strings.Contains(rawMatchers, sealedJSONKey) || strings.Contains(rawMatchers, "api.example.test") {
t.Fatalf("traffic_tamper_hooks.matchers is not sealed at rest: %q", rawMatchers)
}
var verRawSrc, verRawMatchers string
if err := d.QueryRow(`SELECT source, matchers::text FROM traffic_tamper_hook_versions WHERE hook_id=$1 AND version=1`, h.ID).Scan(&verRawSrc, &verRawMatchers); err != nil {
t.Fatal(err)
}
if !strings.HasPrefix(verRawSrc, secretPrefix) || strings.Contains(verRawSrc, "super-secret-hmac-key") {
t.Fatalf("traffic_tamper_hook_versions.source is not sealed at rest: %q", verRawSrc)
}
if !strings.Contains(verRawMatchers, sealedJSONKey) || strings.Contains(verRawMatchers, "api.example.test") {
t.Fatalf("traffic_tamper_hook_versions.matchers is not sealed at rest: %q", verRawMatchers)
}
// Update -> version 2 + toggle enabled.
v2, err := d.UpdateTrafficTamperHook(h.ID, func(stored TrafficTamperHook) (TrafficTamperHook, error) {
stored.Source = srcV2
stored.Note = "v2"
return stored, nil
})
if err != nil || v2.Version != 2 || v2.Source != srcV2 {
t.Fatalf("update = (%+v, %v)", v2, err)
}
if err := d.ToggleTrafficTamperHook(h.ID, true); err != nil {
t.Fatalf("toggle: %v", err)
}
got, err := d.GetTrafficTamperHook(h.ID)
if err != nil || !got.Enabled || got.Version != 2 {
t.Fatalf("get after toggle = (%+v, %v)", got, err)
}
// Rollback to version 1 -> creates version 3 with v1 source & keeps enabled=true.
v3, err := d.RollbackTrafficTamperHook(h.ID, 1)
if err != nil || v3.Version != 3 || v3.Source != srcV1 || !v3.Enabled {
t.Fatalf("rollback = (%+v, %v)", v3, err)
}
vers, err := d.ListTrafficTamperHookVersions(h.ID)
if err != nil || len(vers) != 3 || vers[0].Version != 3 || vers[2].Version != 1 {
t.Fatalf("versions = (%+v, %v)", vers, err)
}
// Delete cascades versions.
if err := d.DeleteTrafficTamperHook(h.ID); err != nil {
t.Fatalf("delete: %v", err)
}
if _, err := d.GetTrafficTamperHook(h.ID); !errors.Is(err, sql.ErrNoRows) {
t.Fatalf("after delete err = %v, want sql.ErrNoRows", err)
}
}
+2
View File
@@ -38,6 +38,8 @@ services:
ARTEX_LLM_MODEL: ${ARTEX_LLM_MODEL:-}
ARTEX_LLM_BASE_URL: ${ARTEX_LLM_BASE_URL:-}
ARTEX_LLM_PROXY: ${ARTEX_LLM_PROXY:-}
# Exact host:port list the model-list fetch may reach on private addresses (e.g. host.docker.internal:11434 for Ollama).
ARTEX_LLM_PRIVATE_ENDPOINTS: ${ARTEX_LLM_PRIVATE_ENDPOINTS:-}
ARTEX_JWT_KEY_DIR: /app/keys
# Optional: key for secrets at rest; empty = keys/secret.key (generated at first start).
ARTEX_SECRET_KEY: ${ARTEX_SECRET_KEY:-}
+63
View File
@@ -0,0 +1,63 @@
# Opt-in SOCKS5 UDP ASSOCIATE & Raw UDP Recording (P4.1c)
ARTEX extends the opt-in SOCKS5 inbound listener with **RFC 1928 `UDP ASSOCIATE` (`0x03`)**, **IPv4 first**, enforcing per-datagram destination policy and recording forwarded datagrams separately from HTTP traffic in SQLite. Transparent UDP (`IP_RECVORIGDSTADDR`) is out of scope here and planned separately (C2).
## Opt-in Configuration (Off by Default)
| Environment Variable | Default | Behavior |
|---|---|---|
| `ARTEX_SOCKS5_UDP_ENABLED` | unset (off) | Set to `1` / `true` / `on` / `yes` to enable RFC 1928 `UDP ASSOCIATE` on the SOCKS5 listener (starting the SOCKS5 listener on `ARTEX_SOCKS5_ADDR` or `127.0.0.1:1080` unless `ARTEX_SOCKS5_ENABLED` is explicitly `0`/`false`/`off`/`no`). |
| `ARTEX_SOCKS5_ENABLED` | unset (off) | Explicit `0` / `false` / `off` / `no` disables the entire SOCKS5 listener (TCP and UDP) even if `ARTEX_SOCKS5_UDP_ENABLED` is set. |
| `ARTEX_SOCKS5_ADDR` | `127.0.0.1:1080` | Bind address for the SOCKS5 TCP control listener; per-association IPv4 UDP relay sockets bind on the same local IPv4 interface on an ephemeral port (`:0`). |
- **Flag off means no listener**:
- With all SOCKS5 flags unset/off, no SOCKS5 listener and no UDP relay socket are started.
- With SOCKS5 TCP enabled and `ARTEX_SOCKS5_UDP_ENABLED` off, `UDP ASSOCIATE` (`0x03`) is refused with RFC 1928 reply `0x07` (*Command not supported*) and no UDP socket is opened.
- **Requires traffic recorder**: like P4.1a and P4.1b, the server only starts the SOCKS5 listener when the traffic recorder is enabled (inside the traffic proxy block in `server/manager.go`).
- **Non-loopback warning**: the same authentication caveat from [docs/traffic-socks5.md](traffic-socks5.md) applies—RFC 1929 username/password accepts any credentials, so keep the listener bound to loopback (`127.0.0.1`) or restrict access at the host firewall.
## Protocol Scope & Lifetime
- **IPv4 first**:
- `UDP ASSOCIATE` accepts IPv4 (`0x01`) and domain (`0x03`) requests (including `0.0.0.0:0` per RFC 1928 §4). IPv6 (`0x04`) `UDP ASSOCIATE` requests return `0x08` (*Address type not supported*); IPv6 UDP datagram destinations are dropped.
- Each client UDP datagram header (`RSV=0x0000`, `FRAG=0x00`, `ATYP=0x01` IPv4 or `ATYP=0x03` domain resolved to IPv4) is parsed individually.
- **No fragmentation reassembly**:
- Per RFC 1928 §7, datagrams with `FRAG != 0` are dropped without reassembly.
- Each forwarded `FRAG == 0` datagram (and each upstream reply datagram) is recorded as it arrives without cross-datagram reassembly.
- **Client source pinning**:
- Incoming client UDP datagrams on the ephemeral relay port are accepted only from the expected IPv4 client address (the `DST.ADDR`/`DST.PORT` given in `UDP ASSOCIATE`, or the TCP control connection's peer IP pinned on the first valid datagram).
- Upstream reply datagrams are accepted only from destinations (`ip:port`) to which the association previously forwarded an allowed datagram.
- **Tied to the TCP control connection**:
- Closing the SOCKS5 TCP control connection immediately closes both UDP sockets and terminates the association.
- Exceeding `UDPIdleTimeout`, `UDPMaxDatagrams`, or `UDPMaxBytes`, or calling `Traffic.Close()`, also closes the association and its TCP control connection cleanly.
## Policy Enforcement Per Datagram Destination
Before forwarding **every** client-to-server UDP datagram to `(host, port)`:
1. **Target gate (`intercept.Interceptor.ResolveUDP4` / `intercept.PinnedUDP4Resolver`)**: enforces global asset block rules (domain, IP, and CIDR, before and after fresh IPv4 DNS resolution) and any enabled `intercept.TargetScope` pins/exemptions, returning the verified IPv4 `*net.UDPAddr`.
2. **Egress governor (`egress.Do(egress.Current(), ...)`)**: enforces the active noise profile (`PaceTimeout`, default `30s`) before sending.
3. **Fail-closed drop (no silent passthrough)**: any datagram whose destination is denied by the target gate, fails DNS/IPv4 resolution, or is refused by the egress governor is **dropped** without sending bytes upstream and without recording a forwarded datagram. Subsequent allowed datagrams on the same association continue normally.
## Raw UDP Storage (SQLite)
Each forwarded datagram writes one row to the `raw_udp_datagrams` table in the SQLite traffic index (`traffic/traffic.go`, `indexSchema` — no PostgreSQL migration):
- Columns: `id` (`udp-<ms>-<seq>`), `association_id` (`udpa-<ms>-<seq>`), `protocol` (`'udp'`), `host`, `port`, `direction` (`'c2s'` | `'s2c'`), `ts` (unix milliseconds), `size`, `preview`, `blob`.
- **No HTTP exchange row**: raw UDP datagrams never insert into `exchanges`.
- **Preview & atomic blob spilling**:
- Payloads up to `UDPPreviewBytes` (default `8 KiB`) stay inline in `preview`.
- Payloads above `UDPPreviewBytes` keep the leading `UDPPreviewBytes` inline and spill the full datagram payload atomically (temp file + rename) into `_blobs/sha256/` with a reference registered in `blob_refs` under the datagram's `udp-*` ID.
## Operational Bounds
| Parameter | Default |
|---|---|
| `MaxConcurrent` | `64` active TCP streams + UDP associations combined |
| `UDPMaxDatagrams` | `1000` forwarded datagrams (`c2s` + `s2c`) per association |
| `UDPMaxBytes` | `4 MiB` forwarded payload bytes (`c2s` + `s2c`) per association |
| `UDPPreviewBytes` | `8 KiB` inline preview per datagram before blob spill |
| `UDPIdleTimeout` | `2m` inactivity timeout per association |
| `HandshakeTimeout` | `10s` for greeting, auth, and `UDP ASSOCIATE` request |
| `DialTimeout` | `30s` per-datagram target gate / DNS lookup bound |
| `PaceTimeout` | `30s` per-datagram egress governor wait bound |
+56
View File
@@ -0,0 +1,56 @@
# Opt-in SOCKS5 Inbound Proxy & Raw TCP Recording (P4.1a)
ARTEX ships an opt-in **RFC 1928 SOCKS5 `CONNECT`** inbound listener in `traffic/` that records raw TCP connections separately from HTTP traffic.
## Opt-in Configuration (Off by Default)
| Environment Variable | Default | Behavior |
|---|---|---|
| `ARTEX_SOCKS5_ENABLED` | unset (off) | Set to `1` / `true` / `on` / `yes` to start the SOCKS5 listener on `127.0.0.1:1080` (loopback). Explicit `0` / `false` / `off` / `no` forces it off even if `ARTEX_SOCKS5_ADDR` is set. |
| `ARTEX_SOCKS5_ADDR` | `127.0.0.1:1080` | Explicit TCP bind address; setting a non-empty value also enables the listener unless `ARTEX_SOCKS5_ENABLED` is explicitly false. |
- **Flag off**: no SOCKS5 listener is started and the HTTP MITM recording proxy is byte-identical.
- **Requires traffic recorder**: the server only starts the SOCKS5 listener when the traffic recorder is enabled (inside the traffic proxy block in `server/manager.go`). If traffic capture is disabled, setting `ARTEX_SOCKS5_ENABLED` / `ARTEX_SOCKS5_ADDR` does not open a listener.
- **Agents unchanged**: workers and tools keep `HTTP_PROXY`, `HTTPS_PROXY`, and `ALL_PROXY` pointing to the existing HTTP proxy; ARTEX does not silently switch agents to SOCKS5.
- **Non-loopback bind warning**: RFC 1929 username/password (`0x02`) accepts **any** username and password without verifying credentials (so the pace marker `artex-pace` can ride in the username). Binding `ARTEX_SOCKS5_ADDR` to a non-loopback address therefore exposes an **unauthenticated proxy** to anyone who can reach that port. The target gate and egress governor still apply to every connection, but keep the listener on loopback (`127.0.0.1`) or restrict access at the host firewall.
## Protocol Scope (P4.1a)
- **Commands**: `CONNECT` (`0x01`) by default. `BIND` (`0x02`) and unknown commands return RFC 1928 reply `0x07` (*Command not supported*). `UDP ASSOCIATE` (`0x03`) also returns `0x07` unless `ARTEX_SOCKS5_UDP_ENABLED=1` is set (see [docs/traffic-socks5-udp.md](traffic-socks5-udp.md)).
- **Addressing**: IPv4 (`0x01`), domain name (`0x03`), and IPv6 (`0x04`). Unknown address types return `0x08` (*Address type not supported*).
- **Authentication**:
- Loopback peers (`net.IP.IsLoopback()`) may connect with **No Auth** (`0x00`). Non-loopback peers offering only `0x00` are rejected with `0x05 0xFF`.
- **Username/Password** (`0x02`, RFC 1929) is accepted without requiring credentials so clients can pass the pace marker (`artex-pace`, `egress.PaceUser`) in the username.
- **Relay**: Full-duplex, half-close aware (`CloseWrite` on EOF in each direction).
## Policy Enforcement Before Dialing
Before opening any outbound TCP socket, the listener invokes the same controls used by the HTTP path:
1. **Egress governor (`egress.Do(egress.Current(), ...)`)**: enforces the active noise profile (`off` is a zero-delay passthrough). If waiting for a slot/token exceeds `PaceTimeout`, the connection is refused before dialing with SOCKS5 reply `0x02` (*Connection not allowed by ruleset*).
2. **Target gate (`intercept.Interceptor.DialSOCKS5` / `intercept.PinnedDialer`)**: enforces global asset block rules (before and after fresh DNS resolution) and any enabled `intercept.TargetScope` pins/exemptions, dialing only verified addresses. Blocked targets return `0x02` before dialing; DNS lookup failures return `0x04` (*Host unreachable*).
## Raw TCP Storage (SQLite)
Each completed relayed connection writes one row to the `raw_tcp_streams` table in the SQLite traffic index (`traffic/traffic.go`, `indexSchema` — no PostgreSQL migration):
- Columns: `id` (`tcp-<ms>-<seq>`), `protocol` (`'tcp'`), `host`, `port`, `started_at`, `ended_at`, `duration_ms`, `c2s_bytes`, `s2c_bytes`, `truncated`, `c2s_preview`, `c2s_blob`, `s2c_preview`, `s2c_blob`.
- **No HTTP exchange row**: raw TCP streams never insert into `exchanges`.
- **Preview & blob spilling**:
- Directional payloads up to `PreviewBytes` (default `8 KiB`) stay inline in `c2s_preview` / `s2c_preview`.
- Payloads above `PreviewBytes` keep the leading `PreviewBytes` inline and spill the captured bytes (up to `MaxBytesPerDir`) atomically (temp file + rename) into `_blobs/sha256/` with references registered in `blob_refs` under the stream's `tcp-*` ID.
- Exceeding `MaxBytesPerDir` sets `truncated = 1` while continuing to count exact total relayed `c2s_bytes` / `s2c_bytes`.
## Operational Bounds
| Parameter | Default |
|---|---|
| `MaxConcurrent` | `64` active streams (excess connections receive `0x01`) |
| `MaxBytesPerDir` | `4 MiB` captured per direction |
| `PreviewBytes` | `8 KiB` inline preview per direction |
| `IdleTimeout` | `2m` per-direction read/write deadline |
| `HandshakeTimeout` | `10s` for greeting, auth, and `CONNECT` request |
| `DialTimeout` | `30s` outbound TCP connect timeout |
| `PaceTimeout` | `30s` egress governor wait bound |
Closing `Traffic` stops accepting new SOCKS5 connections, closes active sockets, and waits for all handler goroutines to exit before closing SQLite.
+110
View File
@@ -0,0 +1,110 @@
# Constrained Go Tampering Hooks (P4.2 — PR1 Backend, API & Trace)
ARTEX supports opt-in, **operator-only** HTTP tampering hooks written in a constrained, deterministic subset of Go—with **no Python runtime** and **no external interpreter dependency**. Hooks run inside the capture proxy after declarative rewrite rules in each phase (`request` or `response`), fail open on any error, and record field-level diffs into SQLite `exchange_rewrites`.
## Kill Switch & Authority
- **Kill switch (`ARTEX_TAMPER_HOOKS_ENABLED=1`, off by default)**: when unset or false, **zero hooks are loaded** onto the capture proxy and the proxy follows the unchanged baseline path.
- **Operator-only**: hooks are global admin configuration managed only via `/api/traffic/hooks*` and are **never exposed as an agent tool**.
- **Created disabled**: every hook is created with `enabled: false` and must be explicitly enabled via toggle or update.
- **Sealed at rest**: `source` and `matchers` on both `traffic_tamper_hooks` and `traffic_tamper_hook_versions` (migration `0011_traffic_tamper_hooks.sql`) are encrypted at rest with `db/secrets.go` (AES-256-GCM) because a hook may contain hardcoded signing keys or tokens.
## Execution Order, Failure Mode & Limits
- **Order**: per phase (`priority ASC, id ASC`), **declarative rewrite rules run first**, then **tampering hooks** see the post-rule message.
- **Matchers prefilter**: hooks reuse the exact `traffic/rewrite` matchers (`methods`, `host`, `url_regex`, `headers`, `body_regex`, `status`, `resp_headers`, `resp_body_regex`). Non-matching exchanges never invoke the VM.
- **Fail-open only (0.7)**: any returned error, panic, timeout, step-limit, memory-limit, or forbidden HTTP mutation **rolls back all mutations of that hook atomically**, passes the pre-hook message unchanged, records an `outcome='error'` trace row in `exchange_rewrites` with the reason (`panic`, `timeout`, `step_limit`, `memory_limit`, `forbidden_mutation`, `forbidden_method`, `invalid_url`, `invalid_status`, `forbidden_header`, `invalid_header`, `body_too_large`, `hook_error`), and updates in-memory `last_error` (`class`, `at`, `count`).
- **Skipped messages**:
- **Binary bodies are not modified in 0.7** (`not rewritten: binary`).
- Bodies larger than **1 MiB** (`not rewritten: body too large`), compressed bodies (`Content-Encoding` other than `identity`), WebSocket upgrades, SSE response bodies, and responses ≥ 5 MiB (`StreamLargeBodies`) are skipped.
- **Tainted fields stay masked**: if a `sensitive: true` rewrite rule wrote a field earlier in the phase, any subsequent hook trace line for that field emits only keyed HMAC fingerprints and never stores plaintext `after_inline`/`after_blob`.
### Resource & Storage Bounds
| Limit | Default |
|---|---|
| Per-hook wall-clock timeout | `25 ms` |
| Per-phase cumulative hook timeout | `100 ms` |
| CPU step budget per invocation | `100,000` steps |
| Memory allocation budget per invocation | `4 MiB` |
| Call depth | `32` |
| Regexp pattern size | `1 KiB` (RE2) |
| Source size | `64 KiB` |
| Body size | `1 MiB` |
| Stored / enabled hooks | `50` total / `20` enabled |
| Retained version history | `20` newest versions per hook |
## Go Subset Specification
Hooks are parsed with Go's standard `go/parser` and must declare `package hook`. They are **not** full idiomatic Go; only the exact syntax, fields, and virtual stdlib functions below are supported.
### Entrypoints
- Request phase (`phase: "request"`):
```go
package hook
func OnRequest(req *Request) error
```
- Response phase (`phase: "response"`):
```go
package hook
func OnResponse(req *Request, resp *Response) error
```
In `OnResponse`, `req` holds an isolated copy of the request as sent to the target: field assignments (`req.Method`, `req.Path`, `req.RawQuery`, `req.Body`, `req.Headers`) and mutator methods (`req.SetHeader`, `req.AddHeader`, `req.DelHeader`) fail with `forbidden_mutation`, while direct map/slice element writes (such as `req.Headers[k] = ...`, `delete(req.Headers, k)`, or `req.Body[0] = ...`) mutate only the VM copy and are discarded without affecting the wire exchange or trace.
### Allowed Syntax
- Package-level `import`, `const` (basic literals / bool / unary `-`), and helper `func` definitions (no receivers, no `init()`, no package-level `var`, no `type` declarations).
- Statements: `:=`, `=`, `+=`, `-=`, `++`, `--`, local `var`, `if` / `else if` / `else`, `for` (C-style, condition-only, infinite `for {}`, and `for k, v := range ...` with **lexicographically sorted map keys**), `break`, `continue`, `return`.
- Expressions: literals (`int`, `float`, `string`, `rune`, `bool`, `nil`), unary (`!`, `-`, `+`), binary (`+`, `-`, `*`, `/`, `%`, `==`, `!=`, `<`, `<=`, `>`, `>=`, `&&`, `||`), indexing (`x[i]`, `m[k]`, comma-ok `v, ok := m[k]`), slicing (`x[lo:hi]`), composite literals (`[]byte{...}`, `[]any{...}`, `map[string]any{...}`), type conversions (`[]byte(s)`, `string(b)`, `int(x)`, `int64(x)`, `float64(x)`, `byte(x)`), type assertions (`v, ok := x.(T)` for `string`, `bool`, `int`/`int64`, `float64`, `[]byte`, `[]any`, `map[string]any`).
- Collections: `[]byte`, `[]any`, `map[string]any` (plus `map[string][]string` for `Headers` and `url.ParseQuery`).
- Allowed builtins: `len`, `cap`, `append`, `make`, `delete`, `string`, `int`, `int64`, `float64`, `byte`, `panic`.
### Forbidden Constructs (Rejected with HTTP 400 at Validation)
- Forbidden imports: `os`, `io`, `io/fs`, `net`, `net/http`, `os/exec`, `syscall`, `unsafe`, `reflect`, `time`, `math/rand`, `crypto/rand`, `fmt`, `sort`, or any package outside the closed allowlist below; dot (`.`) and blank (`_`) imports.
- Forbidden syntax: `go` (goroutines), `chan` / `select`, `defer`, `goto`, `switch`, `func(...)` anonymous literals, `&` (address-of), `init()`, package-level `var`, custom `type` / methods.
- Forbidden builtins: `recover`, `print`, `println`, `close`, `complex`, `real`, `imag`, `new`.
### `Request` and `Response` API
| Type | Field / Method | Access | Notes |
|---|---|---|---|
| `*Request` | `Scheme`, `Host`, `Port` (`string`) | **Read-only** | Attempting to assign fails atomically (`forbidden_mutation`) |
| `*Request` | `Method`, `Path`, `RawQuery` (`string`) | R/W (`OnRequest`), R/O (`OnResponse`) | `CONNECT` rejected; `Path` must start with `/` |
| `*Request` | `Headers` (`map[string][]string`) | R/W (`OnRequest`), R/O (`OnResponse`) | Forbidden headers (`Host`, `Content-Length`, `Transfer-Encoding`, `Connection`, `Keep-Alive`, `TE`, `Trailer`, `Expect`, `Upgrade`, `Proxy-*`, `X-ARTEX-Replay-Nonce`) and CRLF/NUL values rejected atomically |
| `*Request` | `Body` (`[]byte`) | R/W (`OnRequest`), R/O (`OnResponse`) | Capped at 1 MiB; mutating strips `Content-Length`, `ETag`, `Content-MD5`, `Content-Encoding` |
| `*Request` / `*Response` | `GetHeader(name) string`, `SetHeader(name, val)`, `AddHeader(name, val)`, `DelHeader(name)` | Methods | Canonicalizes header keys |
| `*Response` | `Status` (`int`) | R/W (`OnResponse`) | Must be `200..599` excluding `204` and `304` |
| `*Response` | `Headers` (`map[string][]string`), `Body` (`[]byte`) | R/W (`OnResponse`) | Same header & 1 MiB body invariants |
### Allowed Virtual Stdlib Packages & Functions
- `strings`: `Contains`, `HasPrefix`, `HasSuffix`, `Index`, `TrimPrefix`, `TrimSuffix`, `ToLower`, `ToUpper`, `TrimSpace`, `ReplaceAll`, `Split` (returns `[]any` of strings), `Join`, `Repeat`.
- `bytes`: `Contains`, `HasPrefix`, `HasSuffix`, `Equal`, `Index`, `TrimSpace`, `ToLower`, `ToUpper`, `ReplaceAll`, `Repeat`.
- `encoding/json`: `Decode(b []byte) (any, error)`, `Marshal(v any) ([]byte, error)` (sorts object keys deterministically).
- `encoding/base64`: `EncodeToString`, `DecodeString`, `URLEncodeToString`, `URLDecodeString`.
- `encoding/hex`: `EncodeToString`, `DecodeString`.
- `net/url`: `QueryEscape`, `QueryUnescape`, `ParseQuery`, `EncodeQuery`.
- `regexp`: `MatchString`, `FindString`, `ReplaceAllString` (RE2, pattern ≤ 1 KiB).
- `crypto/sha256`: `Sum256`, `Sum256Hex`.
- `crypto/hmac`: `SHA256(key, data)`, `SHA256Hex(key, data)`.
- `strconv`: `Atoi`, `Itoa`, `ParseBool`, `FormatBool`.
- `errors`: `New`.
## Admin API & SQLite Trace
All routes require the administrator token:
| Route | Behavior |
|---|---|
| `GET /api/traffic/hooks` | Lists hooks in execution order (`priority ASC, id ASC`) with `version`, `load_error`, `last_error`, and `enabled_by_env`. |
| `POST /api/traffic/hooks` | Validates AST + matchers (400 on error) and creates a disabled hook (`version: 1`). |
| `PUT /api/traffic/hooks/{id}` | Validates and updates the hook, incrementing `version` and appending to `traffic_tamper_hook_versions`. |
| `DELETE /api/traffic/hooks/{id}` | Deletes hook and cascades its version history. |
| `POST /api/traffic/hooks/{id}/toggle` | Body `{"enabled": true|false}`. |
| `GET /api/traffic/hooks/{id}/versions` | Lists stored revisions newest-first. |
| `POST /api/traffic/hooks/{id}/rollback` | Body `{"version": N}`; restores revision `N` as a new monotonic version. |
| `POST /api/traffic/hooks/dry-run` | Executes a stored (`hook_id`) or inline (`phase`, `matchers`, `source`) hook against synthetic `request`/`response` without touching live traffic. |
In SQLite, `exchange_rewrites` adds `source_kind` (`'rule'` | `'hook'`), `hook_id`, and `hook_version`. Hook trace rows store compact metadata JSON (`{"kind":"hook","id":...,"name":...,"version":...,"sha256":...}`) in `rule_snapshot` (never full source per exchange) and preserve original client/target data in `exchanges`/`exchange_bodies`.
+81
View File
@@ -0,0 +1,81 @@
# Opt-in Linux Transparent TCP Inbound & Raw TCP Recording (P4.1b)
ARTEX ships an opt-in **Linux-only IPv4 transparent TCP inbound listener** in `traffic/` that accepts connections redirected by `iptables` or `nftables` `REDIRECT` rules, recovers each socket's original IPv4 destination via `getsockopt(SOL_IP, SO_ORIGINAL_DST)`, enforces the existing target gate and egress governor before dialing, and records the connection in SQLite `raw_tcp_streams`.
## Opt-in Configuration (Off by Default)
| Environment Variable | Default | Behavior |
|---|---|---|
| `ARTEX_TRANSPARENT_TCP_ENABLED` | unset (off) | Set to `1` / `true` / `on` / `yes` to start the transparent TCP listener on `127.0.0.1:1081` (IPv4 loopback). Explicit `0` / `false` / `off` / `no` forces it off even if `ARTEX_TRANSPARENT_TCP_ADDR` is set. |
| `ARTEX_TRANSPARENT_TCP_ADDR` | `127.0.0.1:1081` | Explicit IPv4 TCP bind address; setting a non-empty value also enables the listener unless `ARTEX_TRANSPARENT_TCP_ENABLED` is explicitly false. Use `0.0.0.0:1081` only when redirecting traffic from other interfaces (`PREROUTING`) and protect the port with a host firewall. |
- **Flag off**: no transparent TCP listener is started, no firewall rules are touched, and the HTTP MITM proxy is unchanged.
- **Requires traffic recorder**: the server only starts the transparent TCP listener when the traffic recorder is enabled (inside the traffic proxy block in `server/manager.go`). If traffic capture is disabled, setting these environment variables does not open a listener.
- **Linux only**: on non-Linux operating systems (`windows`, `darwin`), leaving the flag off is a no-op; explicitly enabling it logs `ErrTransparentTCPNotLinux` and leaves the listener disabled.
- **IPv4 only (IPv6 not covered)**: P4.1b recovers `SO_ORIGINAL_DST` (`SOL_IP`, `AF_INET`) for IPv4 TCP sockets only. IPv6 (`IP6T_SO_ORIGINAL_DST`) is **not covered**; IPv6 bind addresses and IPv6 sockets are refused.
- **Firewall never touched by ARTEX**: ARTEX never installs, modifies, or deletes `iptables`/`nftables` rules. Root or `CAP_NET_ADMIN` is required **only** by the operator when installing and cleaning up the host redirect rules—never to run ARTEX itself.
## Firewall Rules & Cleanup (Operator-Managed)
Choose **either** `iptables` **or** `nftables`. Always exclude the UID running ARTEX (example: `artex`) from local `OUTPUT` redirect rules so ARTEX's own outbound dials do not loop back into the transparent listener.
### Option 1: `iptables` (IPv4 local `OUTPUT` REDIRECT)
Install into a dedicated chain so cleanup is atomic:
```bash
# Requires root or CAP_NET_ADMIN
sudo iptables -t nat -N ARTEX_TRANSPARENT
# Never redirect ARTEX's own outbound dials or loopback traffic
sudo iptables -t nat -A ARTEX_TRANSPARENT -m owner --uid-owner artex -j RETURN
sudo iptables -t nat -A ARTEX_TRANSPARENT -d 127.0.0.0/8 -j RETURN
# Example: redirect outbound TCP to lab target 198.51.100.0/24 into ARTEX on 127.0.0.1:1081
sudo iptables -t nat -A ARTEX_TRANSPARENT -p tcp -d 198.51.100.0/24 -j REDIRECT --to-ports 1081
sudo iptables -t nat -A OUTPUT -p tcp -j ARTEX_TRANSPARENT
```
Cleanup (exact removal):
```bash
sudo iptables -t nat -D OUTPUT -p tcp -j ARTEX_TRANSPARENT
sudo iptables -t nat -F ARTEX_TRANSPARENT
sudo iptables -t nat -X ARTEX_TRANSPARENT
```
*(For traffic arriving on another interface—for example a container or routed VM—bind `ARTEX_TRANSPARENT_TCP_ADDR=0.0.0.0:1081`, attach `ARTEX_TRANSPARENT` to `PREROUTING` instead of `OUTPUT`, and drop direct non-redirected packets to port 1081 at the host firewall.)*
### Option 2: `nftables` (IPv4 local `OUTPUT` REDIRECT)
Install into a dedicated table so cleanup is a single command:
```bash
# Requires root or CAP_NET_ADMIN
sudo nft -f - <<'NFT'
table ip artex_transparent {
chain output {
type nat hook output priority -100; policy accept;
meta skuid "artex" return
ip daddr 127.0.0.0/8 return
ip daddr 198.51.100.0/24 tcp redirect to :1081
}
}
NFT
```
Cleanup (exact removal):
```bash
sudo nft delete table ip artex_transparent
```
## Policy Enforcement, Loop Guard & Storage (Shared with P4.1a)
For every accepted TCP connection:
1. **Original destination recovery**: reads `getsockopt(SOL_IP, SO_ORIGINAL_DST)` under `HandshakeTimeout` (default `10s`), parses `struct sockaddr_in` (rejecting short buffers, non-`AF_INET` families including IPv6, port `0`, and `0.0.0.0`), and rejects **self-redirects** (direct non-redirected connections where `SO_ORIGINAL_DST` equals the listener's own address/port) before dialing.
2. **Egress governor (`egress.Do(egress.Current(), ...)`)**: enforces the active noise profile (`PaceTimeout`, default `30s`) before dialing.
3. **Target gate (`intercept.Interceptor.DialSOCKS5` / `intercept.PinnedDialer`)**: enforces global asset block rules and any enabled `intercept.TargetScope` pins/exemptions before opening any outbound socket. Because the transparent listener only knows the recovered destination IP (never a DNS hostname), hostname-based block or allow rules cannot match—IP and CIDR rules are the ones that apply. Refused connections are closed immediately without dialing and without writing a store row.
4. **Relay & bounds**: reuses the P4.1a full-duplex half-close-aware relay (`CloseWrite`) and defaults (`MaxConcurrent=64`, `MaxBytesPerDir=4 MiB`, `PreviewBytes=8 KiB`, `IdleTimeout=2m`, `HandshakeTimeout=10s`, `DialTimeout=30s`, `PaceTimeout=30s`).
5. **SQLite storage**: records one row per completed connection in `raw_tcp_streams` (`protocol='tcp'`, atomic temp+rename `_blobs/sha256/` spill + `blob_refs`), with **zero HTTP `exchanges` rows** and **no PostgreSQL migration**.
Closing `Traffic` stops accepting new transparent connections, closes active sockets, and waits for all handler goroutines to exit before closing SQLite.
-14
View File
@@ -281,20 +281,6 @@ func hostOf(rawURL string) string {
return u.Hostname()
}
func isBlank(v any) bool {
switch x := v.(type) {
case nil:
return true
case string:
return x == ""
case float64:
return x == 0
case int:
return x == 0
}
return false
}
func uniq(in []string) []string {
seen := map[string]struct{}{}
out := in[:0]
+9 -9
View File
@@ -1,6 +1,6 @@
module github.com/Autumn-27/artex
go 1.26.10
go 1.26.11
require (
github.com/Autumn-27/norma v0.4.11
@@ -13,19 +13,19 @@ require (
github.com/google/uuid v1.6.0
github.com/gorilla/websocket v1.5.3
github.com/jackc/pgx/v5 v5.10.0
github.com/klauspost/compress v1.18.6
github.com/klauspost/compress v1.20.2
github.com/lqqyt2423/go-mitmproxy v1.9.2
github.com/miekg/dns v1.1.72
github.com/projectdiscovery/dnsx v1.2.3
golang.org/x/crypto v0.58.0
golang.org/x/crypto v0.59.0
golang.org/x/net v0.62.0
golang.org/x/text v0.43.0
golang.org/x/text v0.44.0
modernc.org/sqlite v1.52.0
mvdan.cc/sh/v3 v3.14.1
)
require (
github.com/andybalholm/brotli v1.2.1 // indirect
github.com/andybalholm/brotli v1.2.7 // indirect
github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 // indirect
github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.25 // indirect
github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.20.5 // indirect
@@ -70,10 +70,10 @@ require (
go.uber.org/atomic v1.11.0 // indirect
go.uber.org/multierr v1.11.0 // indirect
golang.org/x/exp v0.0.0-20250106191152-7588d65b2ba8 // indirect
golang.org/x/mod v0.41.0 // indirect
golang.org/x/sync v0.24.0 // indirect
golang.org/x/sys v0.49.0 // indirect
golang.org/x/tools v0.51.0 // indirect
golang.org/x/mod v0.42.0 // indirect
golang.org/x/sync v0.25.0 // indirect
golang.org/x/sys v0.50.0 // indirect
golang.org/x/tools v0.52.0 // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect
modernc.org/libc v1.72.3 // indirect
modernc.org/mathutil v1.7.1 // indirect
+16 -16
View File
@@ -1,7 +1,7 @@
github.com/BaaRai/Norma v0.4.11 h1:Z5lSRFKBDI0EzAw1YDA5iQ5GXsa9e7J19YmIe0zaVcQ=
github.com/BaaRai/Norma v0.4.11/go.mod h1:BudWrf7iHl96FgHqFr/HwN3mKYmGjJDt+xL2ZHXfFZw=
github.com/andybalholm/brotli v1.2.1 h1:R+f5xP285VArJDRgowrfb9DqL18yVK0gKAW/F+eTWro=
github.com/andybalholm/brotli v1.2.1/go.mod h1:rzTDkvFWvIrjDXZHkuS16NPggd91W3kUSvPlQ1pLaKY=
github.com/andybalholm/brotli v1.2.7 h1:UgafRPGMam5ySHfRkhthMqOFA6IFoeF3D7mWIDLjG5A=
github.com/andybalholm/brotli v1.2.7/go.mod h1:rzTDkvFWvIrjDXZHkuS16NPggd91W3kUSvPlQ1pLaKY=
github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 h1:DklsrG3dyBCFEj5IhUbnKptjxatkF07cF2ak3yi77so=
github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2/go.mod h1:WaHUgvxTVq04UNunO+XhnAqY/wQc+bxr74GqbsZ/Jqw=
github.com/aws/aws-sdk-go-v2 v1.47.5 h1:5yA+A+BiXbDq1ZLbYwPViwhEGDMdR0MEhL8Jh2LnLS4=
@@ -81,8 +81,8 @@ github.com/jackc/pgx/v5 v5.10.0 h1:VhSvgU2jSli8o3AqIEOTJr7rZwAEUVo4E4XhR94Zfr0=
github.com/jackc/pgx/v5 v5.10.0/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4=
github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
github.com/klauspost/compress v1.18.6 h1:2jupLlAwFm95+YDR+NwD2MEfFO9d4z4Prjl1XXDjuao=
github.com/klauspost/compress v1.18.6/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ=
github.com/klauspost/compress v1.20.2 h1:v5tiZvm1KGLyg5d5oXdXe3lsSPrbEUiKoXGia//I7Qo=
github.com/klauspost/compress v1.20.2/go.mod h1:LUdAzn7YLVvxLpc7y3V1m40wESHTgc1422pwwBSKYuI=
github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
@@ -143,23 +143,23 @@ go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=
go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
golang.org/x/crypto v0.58.0 h1:COkYLr4k7nDI4r6QtMML2AfzeIswWHAJthLS6K/M/54=
golang.org/x/crypto v0.58.0/go.mod h1:Xh+kl5A+M0gMiWDytH2Hhr5Z7WbNCpv/eB/EFgfSk+w=
golang.org/x/crypto v0.59.0 h1:xS2jhqYbzNrpvkWP2YTDf4TJwBy3ykR03i8vFDxEc7c=
golang.org/x/crypto v0.59.0/go.mod h1:veDyUwATGs3c+vN3VfTbzViMGXeTBk3WyhBOkn+F/4U=
golang.org/x/exp v0.0.0-20250106191152-7588d65b2ba8 h1:yqrTHse8TCMW1M1ZCP+VAR/l0kKxwaAIqN/il7x4voA=
golang.org/x/exp v0.0.0-20250106191152-7588d65b2ba8/go.mod h1:tujkw807nyEEAamNbDrEGzRav+ilXA7PCRAd6xsmwiU=
golang.org/x/mod v0.41.0 h1:qJmnOUb4YB+FsEuM3HcWucdZASCPGhsX6uljO6pog0c=
golang.org/x/mod v0.41.0/go.mod h1:Ek9pY8RKWXwsWvd3rQiHYtMqkjSUV+s1Rj7j4H5Ur6o=
golang.org/x/mod v0.42.0 h1:ICeL3t2L30ljSPHHxDnR4fqVcBt/zR2zJAb9juavmQg=
golang.org/x/mod v0.42.0/go.mod h1:u5fzIrRInkL8MaO1cbRkUHT64v303YIT5KEqpNr7jRs=
golang.org/x/net v0.62.0 h1:18ELalfM5+XNRwzM2nYqXsZQ9ByS1uhj2O/U7+5jqRY=
golang.org/x/net v0.62.0/go.mod h1:WgDCOTH8iwtB66T4/GfI94AHo/hhdb7Hah9NDseQfiI=
golang.org/x/sync v0.24.0 h1:iqiDrGoDgyuvAKrhLQthUEzU/R378N78gXbBjxed7oA=
golang.org/x/sync v0.24.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
golang.org/x/sync v0.25.0 h1:dJnifr0nMV8/SBnBvdo4eSGGnrc3O4FFx6IqvtLcmRs=
golang.org/x/sync v0.25.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.49.0 h1:XbzkgYJHdqh/8m2Uu0W/dQv8nktxx4BFHp1M0gROTXA=
golang.org/x/sys v0.49.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
golang.org/x/text v0.43.0 h1:1QivrlhwAsnMOcqgOdl9my7s9OyZl8O5/UGUTJVXoWc=
golang.org/x/text v0.43.0/go.mod h1:hbSIYA/amXcRXTFSZqh8tWHEoqRvvbKPJ2uz/KU+a+s=
golang.org/x/tools v0.51.0 h1:k4Xc/1Om9jwkBJBo4NVLMSARBoWtK10mx+W5BnXCeAI=
golang.org/x/tools v0.51.0/go.mod h1:9eEncMayCV6zRMGhR5eZEC2iBx98qWcF1HZ9Z7wJOoA=
golang.org/x/sys v0.50.0 h1:dkKZEFTEKaLr1sjhs0WiKqoi8Jj5nHbS3Njmx1UoMJs=
golang.org/x/sys v0.50.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
golang.org/x/text v0.44.0 h1:YItdp/mQNGnsmrgpcdA5yQ3bnRxCfo/Tj/iByGW9GGo=
golang.org/x/text v0.44.0/go.mod h1:S4FR1waQ9LbjQTls97SyRjDaUUVkaM+cXwwuG/G+MwY=
golang.org/x/tools v0.52.0 h1:ryxg4U63oaUYk7uOLTF37n43f4qgtGvqV4Ioit1BaEs=
golang.org/x/tools v0.52.0/go.mod h1:ItcP5UNaVGG+Yc4eIYmaFLNJ4soEopkx5Y2d4lcEurs=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+40
View File
@@ -2,6 +2,7 @@ package guard
import (
"context"
"database/sql"
"encoding/json"
"strings"
"testing"
@@ -240,4 +241,43 @@ func TestShortBlockReasonUnchanged(t *testing.T) {
}
}
// A rule store that cannot be read blocks the call end to end, in the full guard
// (workers, chat) and in the target-only guard (planner, main agent), instead of
// letting it run unchecked. The handle is closed before its first query, so no
// server is contacted.
func TestUnreadableRuleStoreBlocksCalls(t *testing.T) {
closed := func() *intercept.Interceptor {
sqlDB, err := sql.Open("pgx", "postgres://u:p@127.0.0.1:1/unreachable")
if err != nil {
t.Fatal(err)
}
if err := sqlDB.Close(); err != nil {
t.Fatal(err)
}
return intercept.New(&db.DB{DB: sqlDB})
}
for name, g := range map[string]*Guard{
"full guard": NewWithInterceptor(closed()),
"target-only guard": NewTargetOnly(closed()),
} {
for _, call := range []struct{ tool, input string }{
{"Bash", `{"command":"ls -la"}`},
{"Monitor", `{"command":"tail -f /dev/null"}`},
{"create_mcp", `{"name":"x","command":"sh"}`},
} {
block, msg := pre(g, context.Background(), call.tool, call.input)
if !block || !strings.HasPrefix(msg, "[ARTEX platform control, not target defense]") ||
!strings.Contains(msg, "intercept rules could not be loaded") {
t.Errorf("%s: %s block=%v msg=%q, want a block that names the unreadable rule store", name, call.tool, block, msg)
}
}
}
// The blocked call is recorded as a block, never as an allow.
g := NewWithInterceptor(closed())
pre(g, context.Background(), "Bash", `{"command":"ls -la"}`)
if a := g.Audit(); len(a) != 1 || a[0].Action != "block" {
t.Errorf("audit = %+v, want one block entry", a)
}
}
var _ = hook.PreToolUse
+1 -1
View File
@@ -106,7 +106,7 @@ JSON
# embedding the frontend requires node to produce the static assets
if command -v npm >/dev/null 2>&1; then
info "building frontend static assets..."
( cd web && npm ci && npm run build:static )
( cd web && npm ci --ignore-scripts && npm run build:static )
rm -rf server/webui/dist && cp -r web/out server/webui/dist
info "compiling embedded single binary..."
CGO_ENABLED=0 go build -tags embedui -trimpath -o artex ./cmd/artex
+46 -12
View File
@@ -16,6 +16,7 @@ import (
"encoding/json"
"errors"
"fmt"
"log"
"net"
"regexp"
"strconv"
@@ -111,15 +112,17 @@ func TargetScopeFromContext(ctx context.Context) (s TargetScope, ok bool) {
}
// compiledRule is an InterceptRule with the regex pre-compiled (nil for string rules)
// and the argv tokens pre-parsed (nil for non-argv rules).
// and the argv tokens pre-parsed (nil for non-argv rules). bad marks a deny or
// ask rule whose pattern does not compile: it matches every call, as a deny.
type compiledRule struct {
db.InterceptRule
re *regexp.Regexp
argv []string
bad bool
}
// compileRule prepares a rule for matching. ok is false for a rule whose
// pattern does not compile; such a rule is skipped rather than crashing.
// pattern does not compile; see loadLocked for what happens to it.
func compileRule(r db.InterceptRule) (compiledRule, bool) {
cr := compiledRule{InterceptRule: r}
switch r.MatchType {
@@ -205,6 +208,7 @@ type Interceptor struct {
mu sync.RWMutex
cached []compiledRule // sorted by priority DESC; nil means not loaded yet
enabledTools map[string]bool // nil means not loaded yet
loadFailed bool // the last load failed; its error has been logged
pending *pendingManager
reviewer Reviewer // nil = freeform LLM fallback judge not wired
completer Completer // nil = closed-question judge not wired
@@ -289,11 +293,24 @@ func (i *Interceptor) Invalidate() {
i.mu.Unlock()
}
// loadLocked reads the rules and the enabled-tools setting. It installs both or,
// when either read fails, neither: the callers then fail closed (IsToolEnabled
// answers true, the matchers deny). The error is logged once per outage.
func (i *Interceptor) loadLocked() error {
rules, err := i.db.ListInterceptRules()
var val string
var ok bool
if err == nil {
val, ok, err = i.db.GetSetting("intercept_enabled_tools")
}
if err != nil {
if !i.loadFailed {
i.loadFailed = true
log.Printf("[intercept] the rule store cannot be read; every tool call is denied until it can: %v", err)
}
return err
}
i.loadFailed = false
var out []compiledRule
for _, r := range rules {
if !r.Enabled {
@@ -301,18 +318,28 @@ func (i *Interceptor) loadLocked() error {
}
cr, ok := compileRule(r)
if !ok {
continue // skip rules with a bad pattern rather than crashing
if r.Action != "deny" && r.Action != "ask" {
continue // an allow rule with a bad pattern allows nothing
}
// A deny or ask rule that cannot be evaluated must not fail open.
cr.bad, cr.Action = true, "deny"
cr.Message = "intercept rule [" + r.Name + "] has a pattern that does not compile; calls are blocked until the rule is fixed or disabled"
}
out = append(out, cr)
}
i.cached = out
// Load enabled-tools set from settings, falling back to hard-coded defaults.
val, ok, _ := i.db.GetSetting("intercept_enabled_tools")
// Enabled-tools set from settings, falling back to hard-coded defaults.
i.enabledTools = enabledToolsFromSetting(val, ok)
return nil
}
// storeUnreadableDecision is what the matchers answer when the rules cannot be
// loaded: a deny, so that a call is never let through unchecked.
func storeUnreadableDecision() Decision {
return Decision{Action: "deny", Message: "the intercept rules could not be loaded, so the call cannot be checked; it is blocked until the rule store is readable again"}
}
// enabledToolsFromSetting maps the stored intercept_enabled_tools value to the
// gate's set. A malformed value must not silently disable the gate, so it falls
// back to the same defaults as an unset setting.
@@ -357,7 +384,8 @@ func (i *Interceptor) rules() ([]compiledRule, error) {
// IsToolEnabled returns true if the named tool is in the intercept-enabled set
// (i.e. it should enter the rule-matching path). Uses the same double-check lock
// pattern as rules().
// pattern as rules(). When the set cannot be loaded it answers true for every
// tool, so the call reaches the rule path, where Match denies it.
func (i *Interceptor) IsToolEnabled(name string) bool {
i.mu.RLock()
if i.enabledTools != nil {
@@ -370,7 +398,9 @@ func (i *Interceptor) IsToolEnabled(name string) bool {
i.mu.Lock()
defer i.mu.Unlock()
if i.enabledTools == nil {
_ = i.loadLocked()
if err := i.loadLocked(); err != nil {
return true
}
}
return i.enabledTools[name]
}
@@ -676,11 +706,12 @@ func judgeActionLabel(action string) string {
// Match evaluates the rule list (priority DESC) against a tool call.
// Returns (Decision, true) for the first matching enabled rule, or
// (Decision{}, false) if no rule matches.
// (Decision{}, false) if no rule matches. When the rules cannot be loaded it
// returns a deny.
func (i *Interceptor) Match(toolName string, input []byte) (Decision, bool) {
rules, err := i.rules()
if err != nil || len(rules) == 0 {
return Decision{}, false
if err != nil {
return storeUnreadableDecision(), true
}
for _, r := range rules {
if ruleMatches(r, toolName, input) {
@@ -712,7 +743,7 @@ const builtinRulePrefix = "[built-in]"
// enter the rule system. It returns the first match in priority order. User rules,
// allow and ask rules, and the judge are not consulted. The planner and the main
// agent use it (#124, F11). An interceptor without a database and without loaded
// rules matches nothing.
// rules matches nothing. When the rules cannot be loaded it returns a deny.
func (i *Interceptor) MatchBuiltin(toolName string, input []byte) (Decision, bool) {
i.mu.RLock()
loaded := i.cached != nil
@@ -725,7 +756,7 @@ func (i *Interceptor) MatchBuiltin(toolName string, input []byte) (Decision, boo
}
rules, err := i.rules()
if err != nil {
return Decision{}, false
return storeUnreadableDecision(), true
}
for _, r := range rules {
if r.Action != "deny" || !strings.HasPrefix(r.Name, builtinRulePrefix) || !ruleMatches(r, toolName, input) {
@@ -772,6 +803,9 @@ func (i *Interceptor) SetRulesForTest(rules []db.InterceptRule) {
}
func ruleMatches(r compiledRule, toolName string, input []byte) bool {
if r.bad {
return true
}
if r.MatchType == "argv" {
// Bash only, on the parsed command; match_target is always tool_input.
// Allow rules stay strictly limited to a single simple command with
+1 -1
View File
@@ -38,7 +38,7 @@ func (i *Interceptor) MatchPersistence(toolName string, input []byte) (Decision,
}
rules, err := i.rules()
if err != nil {
return Decision{}, false
return storeUnreadableDecision(), true
}
var ask *compiledRule
for idx := range rules {
+132
View File
@@ -0,0 +1,132 @@
package intercept
import (
"bytes"
"database/sql"
"log"
"strings"
"testing"
"github.com/Autumn-27/artex/db"
)
// closedStore returns a store whose every read fails. No server is contacted:
// the handle is closed before its first query.
func closedStore(t *testing.T) *db.DB {
t.Helper()
sqlDB, err := sql.Open("pgx", "postgres://u:p@127.0.0.1:1/unreachable")
if err != nil {
t.Fatal(err)
}
if err := sqlDB.Close(); err != nil {
t.Fatal(err)
}
return &db.DB{DB: sqlDB}
}
// A rule store that cannot be read must not open the gate: every tool enters the
// rule path, and every matcher denies. The error is logged once, not per call.
func TestStoreErrorFailsClosed(t *testing.T) {
var logged bytes.Buffer
prev := log.Writer()
log.SetOutput(&logged)
t.Cleanup(func() { log.SetOutput(prev) })
ic := New(closedStore(t))
input := []byte(`{"command":"ls -la"}`)
for _, tool := range []string{"Bash", "ExecuteExtraTool", "Monitor", "Read", "my_custom_tool"} {
if !ic.IsToolEnabled(tool) {
t.Errorf("IsToolEnabled(%q) = false with an unreadable store, want true", tool)
}
}
for name, match := range map[string]func(string, []byte) (Decision, bool){
"Match": ic.Match,
"MatchBuiltin": ic.MatchBuiltin,
"MatchPersistence": ic.MatchPersistence,
} {
tool := "Bash"
if name == "MatchPersistence" {
tool = "create_mcp"
}
dec, ok := match(tool, input)
if !ok || dec.Action != "deny" || !strings.Contains(dec.Message, "could not be loaded") {
t.Errorf("%s with an unreadable store = %+v, %v; want a deny that names the cause", name, dec, ok)
}
}
if n := strings.Count(logged.String(), "rule store cannot be read"); n != 1 {
t.Errorf("the store error was logged %d times, want once:\n%s", n, logged.String())
}
if !strings.Contains(logged.String(), "sql: database is closed") {
t.Errorf("the log line does not carry the error:\n%s", logged.String())
}
}
// A malformed intercept_enabled_tools value read from the store keeps the
// defaults: ExecuteExtraTool and Monitor stay gated, read-only tools stay out.
func TestMalformedEnabledToolsSettingKeepsDefaults(t *testing.T) {
d := targetTestDB(t)
const key = "intercept_enabled_tools"
prev, had, err := d.GetSetting(key)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() {
if had {
_ = d.SetSetting(key, prev)
return
}
_, _ = d.Exec(`DELETE FROM settings WHERE key=$1`, key)
})
for _, val := range []string{"{not json", `"Bash"`, `{"Bash":true}`} {
if err := d.SetSetting(key, val); err != nil {
t.Fatal(err)
}
ic := New(d)
for _, tool := range defaultEnabledTools {
if !ic.IsToolEnabled(tool) {
t.Errorf("setting %q: default tool %q is not gated", val, tool)
}
}
if ic.IsToolEnabled("Read") {
t.Errorf("setting %q: Read is gated, want the defaults only", val)
}
}
}
// A deny or ask rule whose pattern does not compile cannot be evaluated; it
// matches as a deny instead of being skipped. A broken allow rule allows nothing.
func TestUncompilableRuleFailsClosed(t *testing.T) {
d := targetTestDB(t)
create := func(name, matchType, pattern, action string, priority int) db.InterceptRule {
t.Helper()
r, err := d.CreateInterceptRule(name, "tool_input", matchType, pattern, action, "", priority, true, false, 0, "deny")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = d.DeleteInterceptRule(r.ID) })
return r
}
input := []byte(`{"command":"ls -la"}`)
allow := create("broken allow", "regex", "(", "allow", 1000002)
if dec, ok := New(d).Match("Bash", input); ok && dec.RuleID == allow.ID {
t.Fatalf("a broken allow rule matched: %+v", dec)
}
for n, tc := range []struct{ matchType, pattern, action string }{
{"regex", "(", "ask"},
{"regex", "[z-a]", "deny"},
{"argv", `"unterminated`, "deny"},
} {
r := create("broken "+tc.action, tc.matchType, tc.pattern, tc.action, 1000001-n)
ic := New(d)
dec, ok := ic.Match("Bash", input)
if !ok || dec.Action != "deny" || dec.RuleID != r.ID || !strings.Contains(dec.Message, "does not compile") {
t.Errorf("%s %s rule %q: Match = %+v, %v; want a deny by rule %d", tc.matchType, tc.action, tc.pattern, dec, ok, r.ID)
}
// A user rule, broken or not, is not a built-in rule.
if dec, ok := ic.MatchBuiltin("Bash", input); ok {
t.Errorf("MatchBuiltin matched a broken user rule: %+v", dec)
}
_ = d.DeleteInterceptRule(r.ID)
}
}
+209
View File
@@ -3,12 +3,15 @@ package intercept
import (
"context"
"encoding/json"
"errors"
"fmt"
"net"
"net/netip"
"strconv"
"strings"
"time"
"github.com/Autumn-27/artex/db"
)
// The HTTP clients the platform owns (WebFetch and the custom http tool)
@@ -114,9 +117,23 @@ func (i *Interceptor) dialTarget(ctx context.Context, scope TargetScope, toolNam
func addrTarget(network, addr string) (Target, error) {
switch network {
case "tcp", "tcp4", "tcp6":
return parseTargetAddr(addr)
default:
return Target{}, fmt.Errorf("network %q is not tcp", network)
}
}
// addrTargetUDP reads the address a UDP relay datagram names.
func addrTargetUDP(network, addr string) (Target, error) {
switch network {
case "udp", "udp4", "udp6":
return parseTargetAddr(addr)
default:
return Target{}, fmt.Errorf("network %q is not udp", network)
}
}
func parseTargetAddr(addr string) (Target, error) {
host, port, err := net.SplitHostPort(addr)
if err != nil {
return Target{}, err
@@ -178,3 +195,195 @@ func (e *dialError) Error() string {
}
return msg + " Do not fetch the target with another tool or by its address."
}
// IsTargetBlocked reports whether err came from PinnedDialer / DialSOCKS5
// refusing a target before dialing (rule block, unpinned target, or unavailable
// target gate), returning its platform control code.
func IsTargetBlocked(err error) (string, bool) {
var de *dialError
if errors.As(err, &de) {
return de.code, true
}
return "", false
}
// DialSOCKS5 enforces the platform's target gate before dialing a SOCKS5
// CONNECT destination, reusing the same policy functions as PinnedDialer:
// - When ctx carries an enabled TargetScope, delegates directly to dialTarget
// (asset block rules, exemptions, fresh DNS resolution, and pin checks).
// - Otherwise enforces global asset block rules (domain, IP, and CIDR, before
// and after fresh DNS resolution) and dials only the resolved addresses that
// passed those rules.
func (i *Interceptor) DialSOCKS5(ctx context.Context, network, addr string) (net.Conn, error) {
if i == nil {
return baseDial(ctx, network, addr)
}
if scope, ok := TargetScopeFromContext(ctx); ok && scope.Enabled != nil && scope.Enabled() {
return i.dialTarget(ctx, scope, "socks5", network, addr)
}
t, err := addrTarget(network, addr)
if err != nil {
return nil, &dialError{code: TargetGateUnavailable, target: addr, reason: "the address of the connection could not be read (" + err.Error() + ")"}
}
if i.targets == nil {
return i.baseDialer()(ctx, network, addr)
}
rules, err := i.targets.BlockRules(db.TargetScopeRef{})
if err != nil {
return nil, &dialError{code: TargetGateUnavailable, target: t.String(), reason: "the asset rules could not be read: " + err.Error()}
}
ct := &checkedTarget{Target: t}
if t.Kind != TargetDomain {
ct.ips, ct.resolver, ct.resolvedAt = []string{t.Host}, literalResolver, time.Now().UTC()
}
if rule, hit := blockRule(rules, ct); hit {
return nil, &dialError{code: TargetRuleBlocked, target: t.String(), reason: fmt.Sprintf("%s is blocked by an asset rule. %s", t, rule.Reason())}
}
if t.Kind == TargetDomain {
c := &targetCheck{i: i, ctx: ctx, tool: "socks5", fresh: true}
c.resolve(ct, true)
if ct.err != nil {
return nil, ct.err
}
if rule, hit := blockRule(rules, ct); hit {
return nil, &dialError{code: TargetRuleBlocked, target: t.String(), reason: fmt.Sprintf("%s is blocked by an asset rule. %s", t, rule.Reason())}
}
}
return i.dialAddrs(ctx, network, ct.ips, t.Port)
}
// PinnedUDP4Resolver returns a per-datagram IPv4 destination resolver that
// enforces the platform's target gate identically to PinnedDialer. When scoped
// is true, a missing or incomplete TargetScope fails closed with
// TARGET_GATE_UNAVAILABLE.
func PinnedUDP4Resolver(toolName string, scoped bool) func(ctx context.Context, addr string) (*net.UDPAddr, error) {
return func(ctx context.Context, addr string) (*net.UDPAddr, error) {
scope, ok := TargetScopeFromContext(ctx)
switch {
case !ok && scoped:
return nil, &dialError{code: TargetGateUnavailable, target: addr, reason: "the target scope of the session did not reach the connection"}
case !ok:
return resolvePlainUDP4(ctx, addr)
case scope.Enabled == nil || !scope.Enabled():
if scope.Interceptor != nil {
return scope.Interceptor.ResolveUDP4(ctx, addr)
}
return resolvePlainUDP4(ctx, addr)
case scope.Interceptor == nil:
return nil, &dialError{code: TargetGateUnavailable, target: addr, reason: "the session's target scope carries no gate"}
}
return scope.Interceptor.resolveTargetUDP4(ctx, scope, toolName, addr)
}
}
// ResolveUDP4 enforces the platform's target gate before forwarding a SOCKS5
// UDP ASSOCIATE datagram, reusing the exact same asset block rules, fresh DNS
// resolution, and TargetScope pin/exemption logic as DialSOCKS5 / PinnedDialer.
// Returns the first verified IPv4 *net.UDPAddr.
func (i *Interceptor) ResolveUDP4(ctx context.Context, addr string) (*net.UDPAddr, error) {
if i == nil {
return resolvePlainUDP4(ctx, addr)
}
if scope, ok := TargetScopeFromContext(ctx); ok && scope.Enabled != nil && scope.Enabled() {
return i.resolveTargetUDP4(ctx, scope, "socks5-udp", addr)
}
t, err := addrTargetUDP("udp4", addr)
if err != nil {
return nil, &dialError{code: TargetGateUnavailable, target: addr, reason: "the address of the datagram could not be read (" + err.Error() + ")"}
}
if i.targets == nil {
return resolvePlainUDP4(ctx, addr)
}
rules, err := i.targets.BlockRules(db.TargetScopeRef{})
if err != nil {
return nil, &dialError{code: TargetGateUnavailable, target: t.String(), reason: "the asset rules could not be read: " + err.Error()}
}
ct := &checkedTarget{Target: t}
if t.Kind != TargetDomain {
ct.ips, ct.resolver, ct.resolvedAt = []string{t.Host}, literalResolver, time.Now().UTC()
}
if rule, hit := blockRule(rules, ct); hit {
return nil, &dialError{code: TargetRuleBlocked, target: t.String(), reason: fmt.Sprintf("%s is blocked by an asset rule. %s", t, rule.Reason())}
}
if t.Kind == TargetDomain {
c := &targetCheck{i: i, ctx: ctx, tool: "socks5-udp", fresh: true}
c.resolve(ct, true)
if ct.err != nil {
return nil, ct.err
}
if rule, hit := blockRule(rules, ct); hit {
return nil, &dialError{code: TargetRuleBlocked, target: t.String(), reason: fmt.Sprintf("%s is blocked by an asset rule. %s", t, rule.Reason())}
}
}
return firstIPv4UDPAddr(ct.ips, t.Port)
}
func (i *Interceptor) resolveTargetUDP4(ctx context.Context, scope TargetScope, toolName, addr string) (*net.UDPAddr, error) {
input, _ := json.Marshal(map[string]string{"udp": addr})
ctx = WithCall(ctx, toolName, input)
t, err := addrTargetUDP("udp4", addr)
if err != nil {
res := undeterminedTarget(ctx, scope, toolName, input, "the address of the datagram could not be read ("+err.Error()+")")
return nil, &dialError{code: res.Code, target: addr, reason: res.Reason}
}
blocked := func(res TargetResult) error {
return &dialError{code: res.Code, target: t.String(), reason: res.Reason}
}
c := &targetCheck{i: i, ctx: ctx, scope: scope, tool: toolName, input: input, fresh: true}
unpinned, res := c.run([]Target{t})
if res.Code != "" {
return nil, blocked(res)
}
if len(unpinned) > 0 {
scope.WaitBound = 0
res = i.RequestTargets(ctx, scope, toolName, input, unpinned, nil)
if res.Code == TargetApprovalPending {
res.Reason = notCovered(unpinned[0], scope)
}
return nil, blocked(res)
}
switch ct := c.checked[0]; ct.cover {
case coverDerived, coverNameOnly:
return resolvePlainUDP4(ctx, addr)
default:
return firstIPv4UDPAddr(ct.ips, t.Port)
}
}
func firstIPv4UDPAddr(ips []string, port int) (*net.UDPAddr, error) {
for _, raw := range ips {
a, err := netip.ParseAddr(raw)
if err == nil && a.Is4() {
return &net.UDPAddr{IP: net.IP(a.AsSlice()), Port: port}, nil
}
}
return nil, &net.AddrError{Err: "no IPv4 address found", Addr: strings.Join(ips, ", ")}
}
func resolvePlainUDP4(ctx context.Context, addr string) (*net.UDPAddr, error) {
host, portStr, err := net.SplitHostPort(addr)
if err != nil {
return nil, err
}
port, err := strconv.Atoi(portStr)
if err != nil || port <= 0 || port > 65535 {
return nil, fmt.Errorf("invalid udp port %q", portStr)
}
if ip := net.ParseIP(strings.Trim(host, "[]")); ip != nil {
ip4 := ip.To4()
if ip4 == nil {
return nil, &net.AddrError{Err: "IPv6 UDP destination not supported", Addr: addr}
}
return &net.UDPAddr{IP: ip4, Port: port}, nil
}
ips, err := net.DefaultResolver.LookupIP(ctx, "ip4", host)
if err != nil {
return nil, err
}
for _, ip := range ips {
if ip4 := ip.To4(); ip4 != nil {
return &net.UDPAddr{IP: ip4, Port: port}, nil
}
}
return nil, &net.AddrError{Err: "no IPv4 address found", Addr: addr}
}
+20
View File
@@ -6,6 +6,7 @@ package llmrec
import (
"context"
"encoding/json"
"errors"
"iter"
"log"
"strings"
@@ -16,6 +17,11 @@ import (
"github.com/Autumn-27/norma/transcript"
)
// errStreamAbandoned marks a stream whose consumer stopped reading before
// message_stop while its context was still live. The call did not complete,
// so it is metered as an error rather than inferred from ctx.Err().
var errStreamAbandoned = errors.New("llmrec: consumer stopped reading before message_stop")
type taskIDContextKey struct{}
type workerContextKey struct{}
@@ -190,6 +196,7 @@ func (r *Recorder) Stream(ctx context.Context, req llm.CompletionRequest) iter.S
usage llm.Usage
stopReason string
streamErr error
complete bool // message_stop was seen
)
finished := false
@@ -246,8 +253,21 @@ func (r *Recorder) Stream(ctx context.Context, req llm.CompletionRequest) iter.S
stopReason = ev.StopReason
}
usage.MergeEcho(ev.Usage)
case llm.SEMessageStop:
complete = true
}
if !yield(ev, err) {
// The consumer stopped early. Decide the status here from what
// is known, not later in the deferred finish: the call only
// counts as "ok" if message_stop arrived and ctx is live.
switch {
case ctx.Err() != nil:
finish(ctx.Err())
case !complete:
finish(errStreamAbandoned)
default:
finish(nil)
}
return
}
}
+12 -14
View File
@@ -151,15 +151,9 @@ func (meteredStreamProvider) Stream(context.Context, llm.CompletionRequest) iter
}
func TestSideUsageRecordedOnceOnConsumerCancellation(t *testing.T) {
// Timing-sensitive on 2-core CI runners (BaaRai/ARTEX#9). Repro:
// ARTEX_PG_DSN=postgres://artex:testpass@localhost:5432/artextest_race \
// go test ./llmrec -run TestSideUsageRecordedOnceOnConsumerCancellation -count=20 -race -v
// The `early=` t.Fatalf assertion below compares the single llm_usage row's
// count/input/output/worker/status; in the `early` branch the status
// occasionally comes back "ok" instead of "error" because the consumer's
// cancellation and the recorder's deferred finish race on a loaded runner.
// Keep the skip until the metering status is made cancellation-explicit.
t.Skip("timing-sensitive on CI runners; repro and failing assertion documented above; BaaRai/ARTEX#9")
// Previously skipped as timing-sensitive (BaaRai/ARTEX#9). The recorder now
// decides the status at the point the consumer stops, so the result no
// longer depends on when the deferred finish runs.
dsn := os.Getenv("ARTEX_PG_DSN")
if dsn == "" {
t.Skip("requires isolated ARTEX_PG_DSN")
@@ -169,7 +163,9 @@ func TestSideUsageRecordedOnceOnConsumerCancellation(t *testing.T) {
t.Fatal(err)
}
defer pg.Close()
for _, early := range []bool{false, true} {
// full: read to the end. cancel: cancel ctx, then stop reading.
// abandon: stop reading before message_stop with ctx still live.
for _, mode := range []string{"full", "cancel", "abandon"} {
profile := "btw-metering-" + uuid.NewString()
ctx, cancel := context.WithCancel(transcript.WithSessionID(t.Context(), "exp0-btw-test"))
recorder := Wrap(meteredStreamProvider{}, pg, "fixture", profile, "", "", func() bool { return false })
@@ -177,8 +173,10 @@ func TestSideUsageRecordedOnceOnConsumerCancellation(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if early && event.Type == llm.SEMessageDelta {
cancel()
if mode != "full" && event.Type == llm.SEMessageDelta {
if mode == "cancel" {
cancel()
}
break // Consumer exits before the provider can return a cancellation event.
}
}
@@ -192,11 +190,11 @@ FROM llm_usage WHERE profile_name=$1`, profile).Scan(&count, &input, &output, &w
t.Fatal(err)
}
wantStatus := "ok"
if early {
if mode != "full" {
wantStatus = "error"
}
if count != 1 || input != 23 || output != 5 || worker != "btw" || status != wantStatus {
t.Fatalf("early=%v: count=%d usage=%d/%d worker=%q status=%q", early, count, input, output, worker, status)
t.Fatalf("mode=%s: count=%d usage=%d/%d worker=%q status=%q", mode, count, input, output, worker, status)
}
}
}
+65 -2
View File
@@ -5,9 +5,11 @@ import (
"crypto/subtle"
"encoding/hex"
"fmt"
"io"
"log"
"math/big"
"net/http"
"net/url"
"os"
"path/filepath"
"strconv"
@@ -282,8 +284,55 @@ func extractToken(r *http.Request) string {
return r.URL.Query().Get("token")
}
// cookieAuthenticated reports whether extractToken takes the session from the
// artex_token cookie. The browser attaches that cookie on its own, to requests
// a foreign page makes as well; a bearer or query token is put there by the caller.
func cookieAuthenticated(r *http.Request) bool {
if strings.HasPrefix(r.Header.Get("Authorization"), "Bearer ") {
return false
}
c, err := r.Cookie("artex_token")
return err == nil && c.Value != ""
}
// sameOrigin reports whether the browser states that the request comes from a
// page of this server: Sec-Fetch-Site is same-origin, or Origin names the
// scheme, host and port the request was sent to. Scripts can set neither
// header. A request that carries neither is not same-origin.
func sameOrigin(r *http.Request) bool {
if r.Header.Get("Sec-Fetch-Site") == "same-origin" {
return true
}
o, err := url.Parse(r.Header.Get("Origin"))
if err != nil || o.Host == "" {
return false
}
scheme := "http"
if r.TLS != nil {
scheme = "https"
}
return o.Scheme == scheme && hostWithPort(o.Host, scheme) == hostWithPort(r.Host, scheme)
}
// hostWithPort returns host in lower case with its port, the scheme's default
// when host names none.
func hostWithPort(host, scheme string) string {
u := url.URL{Host: host}
port := u.Port()
if port == "" {
port = "80"
if scheme == "https" {
port = "443"
}
}
return strings.ToLower(u.Hostname()) + ":" + port
}
// requireAuth wraps h with JWT validation.
// /api/auth/*, /api/health and /api/ready are exempt.
// A state-changing request whose session is the cookie must be same-origin
// (see sameOrigin), so that a foreign page cannot act with the operator's
// session. Requests that carry a bearer token, and GET and HEAD, are not checked.
func (s *Server) requireAuth(h http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
p := r.URL.Path
@@ -300,6 +349,13 @@ func (s *Server) requireAuth(h http.Handler) http.Handler {
writeErr(w, 401, "token is invalid or expired")
return
}
switch r.Method {
case http.MethodPost, http.MethodPut, http.MethodPatch, http.MethodDelete:
if cookieAuthenticated(r) && !sameOrigin(r) {
writeErr(w, 403, "cross-origin request refused: a cookie session can change state only from the console's own origin; send the token as Authorization: Bearer instead")
return
}
}
h.ServeHTTP(w, r)
})
}
@@ -321,9 +377,15 @@ func (s *Server) authStatus(w http.ResponseWriter, r *http.Request) {
writeJSON(w, 200, map[string]any{"initialized": hash != ""})
}
// setupTokenOut is where the setup token is printed: the stderr of the process.
// It is a variable so that tests can capture it.
var setupTokenOut io.Writer = os.Stderr
// initSetupToken generates the one-time setup token when no admin password is set
// and writes it to the server log. Without it, anyone who can reach the port
// and prints it on the server console. Without it, anyone who can reach the port
// before the operator could claim the instance through POST /api/auth/init.
// The token goes to stderr directly, not through the standard logger: the log
// sink keeps every line for /api/logs and persists it.
func (s *Server) initSetupToken() {
if s.m == nil || s.m.pg == nil {
return
@@ -356,7 +418,8 @@ func (s *Server) initSetupToken() {
s.setupMu.Lock()
s.setupToken = token
s.setupMu.Unlock()
log.Printf("[auth] no admin password is set. Setup token for the /setup page: %s", token)
fmt.Fprintln(setupTokenOut, time.Now().Format("2006/01/02 15:04:05"), "[auth] no admin password is set. Setup token for the /setup page:", token)
log.Printf("[auth] no admin password is set. The setup token for the /setup page was printed on the server console (stderr); it is not kept in this log")
}
// loadPasswordVersion reads auth.password_version. A missing key leaves the
+2 -2
View File
@@ -16,7 +16,7 @@ func TestChatUnavailableReasonDistinguishesStates(t *testing.T) {
if err != nil {
db.SkipPGUnavailable(t, err)
}
defer m.Close()
t.Cleanup(func() { _ = m.Close() })
td := t.TempDir()
ctx, cancel := context.WithCancel(context.Background())
s := New(ctx, m, td, td, td)
@@ -68,7 +68,7 @@ func TestResolveChatAgentHonoursConversationProfile(t *testing.T) {
if err != nil {
db.SkipPGUnavailable(t, err)
}
defer m.Close()
t.Cleanup(func() { _ = m.Close() })
td := t.TempDir()
ctx, cancel := context.WithCancel(context.Background())
s := New(ctx, m, td, td, td)
+3
View File
@@ -73,6 +73,9 @@ func TestCoreTaskLifecyclePG(t *testing.T) {
if id == "" || expID == 0 {
t.Fatalf("bad task payload: %v", out)
}
defer func() {
_, _ = m.pg.Exec(`DELETE FROM assets WHERE type = 'ip' AND ip = '127.0.0.1'`)
}()
// the exploration owns goal node(s) — goal seeding is async, poll briefly
var goals []*db.Node
+223
View File
@@ -0,0 +1,223 @@
package server
import (
"context"
"crypto/tls"
"encoding/json"
"fmt"
"net/http"
"net/http/httptest"
"strings"
"testing"
"time"
"github.com/Autumn-27/artex/db"
)
// csrfRequest builds a request to http://example.com (the httptest default
// host) with the given headers. A "Cookie" value is the artex_token cookie.
func csrfRequest(method, path, body string, headers map[string]string) *http.Request {
r := httptest.NewRequest(method, path, strings.NewReader(body))
for k, v := range headers {
if k == "Cookie" {
r.AddCookie(&http.Cookie{Name: "artex_token", Value: v})
continue
}
r.Header.Set(k, v)
}
return r
}
// A session that arrives as the artex_token cookie is sent by the browser on
// its own, so a state-changing request that carries it must come from the
// console's own origin. requireAuth is exercised directly, without a database.
func TestCookieStateChangeNeedsSameOrigin(t *testing.T) {
s := &Server{jwtKey: []byte("0123456789abcdef0123456789abcdef")}
tok, err := signJWT(s.jwtKey)
if err != nil {
t.Fatal(err)
}
reached := false
h := s.requireAuth(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
reached = true
w.WriteHeader(204)
}))
// The request host is example.com over plain HTTP, so its origin is
// http://example.com (port 80).
for _, tc := range []struct {
name string
method string
headers map[string]string
want int
}{
{"cookie, matching Origin", "POST", map[string]string{"Cookie": tok, "Origin": "http://example.com"}, 204},
{"cookie, matching Origin with the default port written out", "POST", map[string]string{"Cookie": tok, "Origin": "http://EXAMPLE.com:80"}, 204},
{"cookie, Sec-Fetch-Site same-origin, no Origin", "POST", map[string]string{"Cookie": tok, "Sec-Fetch-Site": "same-origin"}, 204},
// A proxy that terminates TLS or rewrites Host changes what Origin is
// compared with; the browser's own same-origin statement still passes.
{"cookie, Origin differs, Sec-Fetch-Site same-origin", "POST", map[string]string{"Cookie": tok, "Origin": "https://console.example.org", "Sec-Fetch-Site": "same-origin"}, 204},
{"cookie, foreign Origin", "POST", map[string]string{"Cookie": tok, "Origin": "https://evil.example"}, 403},
{"cookie, foreign Origin, Sec-Fetch-Site cross-site", "POST", map[string]string{"Cookie": tok, "Origin": "https://evil.example", "Sec-Fetch-Site": "cross-site"}, 403},
{"cookie, same site on another port", "POST", map[string]string{"Cookie": tok, "Origin": "http://example.com:3000", "Sec-Fetch-Site": "same-site"}, 403},
{"cookie, same host over another scheme", "POST", map[string]string{"Cookie": tok, "Origin": "https://example.com"}, 403},
{"cookie, sibling subdomain", "POST", map[string]string{"Cookie": tok, "Origin": "http://a.example.com", "Sec-Fetch-Site": "same-site"}, 403},
{"cookie, host that only starts with the request host", "POST", map[string]string{"Cookie": tok, "Origin": "http://example.com.evil.example"}, 403},
{"cookie, opaque Origin", "POST", map[string]string{"Cookie": tok, "Origin": "null"}, 403},
{"cookie, neither header", "POST", map[string]string{"Cookie": tok}, 403},
{"cookie, Sec-Fetch-Site none", "POST", map[string]string{"Cookie": tok, "Sec-Fetch-Site": "none"}, 403},
{"cookie, foreign Origin, PUT", "PUT", map[string]string{"Cookie": tok, "Origin": "https://evil.example"}, 403},
{"cookie, foreign Origin, PATCH", "PATCH", map[string]string{"Cookie": tok, "Origin": "https://evil.example"}, 403},
{"cookie, foreign Origin, DELETE", "DELETE", map[string]string{"Cookie": tok, "Origin": "https://evil.example"}, 403},
{"cookie, neither header, DELETE", "DELETE", map[string]string{"Cookie": tok}, 403},
// Reads are not state changes.
{"cookie, foreign Origin, GET", "GET", map[string]string{"Cookie": tok, "Origin": "https://evil.example"}, 204},
{"cookie, neither header, GET", "GET", map[string]string{"Cookie": tok}, 204},
{"cookie, neither header, HEAD", "HEAD", map[string]string{"Cookie": tok}, 204},
// A bearer token is not sent by the browser on its own.
{"bearer, foreign Origin", "POST", map[string]string{"Authorization": "Bearer " + tok, "Origin": "https://evil.example"}, 204},
{"bearer, neither header", "POST", map[string]string{"Authorization": "Bearer " + tok}, 204},
{"bearer and cookie, foreign Origin", "DELETE", map[string]string{"Authorization": "Bearer " + tok, "Cookie": tok, "Origin": "https://evil.example"}, 204},
// A bad bearer token does not fall back to the cookie.
{"bad bearer and cookie, matching Origin", "POST", map[string]string{"Authorization": "Bearer nope", "Cookie": tok, "Origin": "http://example.com"}, 401},
{"no token", "POST", map[string]string{"Origin": "http://example.com"}, 401},
} {
reached = false
rec := httptest.NewRecorder()
h.ServeHTTP(rec, csrfRequest(tc.method, "/api/mcp", "", tc.headers))
if rec.Code != tc.want || reached != (tc.want == 204) {
t.Errorf("%s: status=%d handler reached=%v, want %d", tc.name, rec.Code, reached, tc.want)
}
}
// The token in the query string is a credential the caller holds, like the
// bearer token; with the cookie also present the cookie is the one used.
rec := httptest.NewRecorder()
h.ServeHTTP(rec, csrfRequest("POST", "/api/mcp?token="+tok, "", map[string]string{"Origin": "https://evil.example"}))
if rec.Code != 204 {
t.Errorf("query token, foreign Origin: status=%d, want 204", rec.Code)
}
rec = httptest.NewRecorder()
h.ServeHTTP(rec, csrfRequest("POST", "/api/mcp?token="+tok, "", map[string]string{"Cookie": tok, "Origin": "https://evil.example"}))
if rec.Code != 403 {
t.Errorf("query token and cookie, foreign Origin: status=%d, want 403", rec.Code)
}
// Over TLS on a non-default port the origin is https://host:port.
for origin, want := range map[string]int{
"https://console.test:8443": 204,
"http://console.test:8443": 403,
"https://console.test": 403,
"https://console.test:8444": 403,
} {
r := csrfRequest("POST", "https://console.test:8443/api/mcp", "", map[string]string{"Cookie": tok, "Origin": origin})
r.TLS = &tls.ConnectionState{}
rec := httptest.NewRecorder()
h.ServeHTTP(rec, r)
if rec.Code != want {
t.Errorf("TLS request, Origin %s: status=%d, want %d", origin, rec.Code, want)
}
}
// An IPv6 literal host.
r := csrfRequest("POST", "http://[::1]:8787/api/mcp", "", map[string]string{"Cookie": tok, "Origin": "http://[::1]:8787"})
rec = httptest.NewRecorder()
h.ServeHTTP(rec, r)
if rec.Code != 204 {
t.Errorf("IPv6 host, matching Origin: status=%d, want 204", rec.Code)
}
}
// The same rule through the real mux, on an endpoint that stores a command
// (POST /api/mcp): a foreign page must not be able to add an MCP server with
// the operator's cookie. Setup and login need no session and keep working.
func TestCookieCSRFThroughRealMux(t *testing.T) {
m, err := NewManager(t.TempDir(), "")
if err != nil {
db.SkipPGUnavailable(t, err)
}
if m.pg == nil {
db.SkipNoPG(t)
}
defer m.Close()
td := t.TempDir()
ctx, cancel := context.WithCancel(context.Background())
s := New(ctx, m, td, td, td)
defer stopTestServer(t, s, cancel)
stamp := time.Now().UnixNano()
s.authHashKey = fmt.Sprintf("test.password_hash.%d", stamp)
s.authVersionKey = fmt.Sprintf("test.password_version.%d", stamp)
prefix := fmt.Sprintf("csrf-%d-", stamp)
defer func() { // deferred, not t.Cleanup: it must run before m.Close
_, _ = m.pg.Exec(`DELETE FROM settings WHERE key=$1 OR key=$2`, s.authHashKey, s.authVersionKey)
_, _ = m.pg.Exec(`DELETE FROM mcp_servers WHERE name LIKE $1`, prefix+"%")
}()
s.setupMu.Lock()
s.setupToken = "setup-ok"
s.setupMu.Unlock()
h := s.Handler()
token := func(rec *httptest.ResponseRecorder) string {
t.Helper()
var out struct {
Token string `json:"token"`
}
if rec.Code != 200 || json.Unmarshal(rec.Body.Bytes(), &out) != nil || out.Token == "" {
t.Fatalf("status=%d body=%s, want a token", rec.Code, rec.Body.String())
}
return out.Token
}
// Setup from a client that sends neither Origin nor Sec-Fetch-Site (curl).
rec := httptest.NewRecorder()
h.ServeHTTP(rec, csrfRequest("POST", "/api/auth/init", `{"password":"correct-horse-1","setup_token":"setup-ok"}`, nil))
stale := token(rec)
// Login the same way, then from the browser: the login page posts from the
// console's own origin and may still hold the cookie of an earlier session.
login := `{"username":"ARTEX","password":"correct-horse-1"}`
rec = httptest.NewRecorder()
h.ServeHTTP(rec, csrfRequest("POST", "/api/auth/login", login, nil))
token(rec)
rec = httptest.NewRecorder()
h.ServeHTTP(rec, csrfRequest("POST", "/api/auth/login", login, map[string]string{"Cookie": stale}))
token(rec)
rec = httptest.NewRecorder()
h.ServeHTTP(rec, csrfRequest("POST", "/api/auth/login", login, map[string]string{"Cookie": stale, "Origin": "http://example.com", "Sec-Fetch-Site": "same-origin"}))
tok := token(rec)
for _, tc := range []struct {
name string
headers map[string]string
want int
}{
{"same-origin", map[string]string{"Cookie": tok, "Origin": "http://example.com", "Content-Type": "application/json"}, 200},
// What a foreign page can send without a preflight: a text/plain body.
{"cross-origin", map[string]string{"Cookie": tok, "Origin": "https://evil.example", "Content-Type": "text/plain"}, 403},
{"other-port", map[string]string{"Cookie": tok, "Origin": "http://example.com:3000", "Sec-Fetch-Site": "same-site", "Content-Type": "text/plain"}, 403},
{"no-headers", map[string]string{"Cookie": tok}, 403},
{"bearer-cross-origin", map[string]string{"Authorization": "Bearer " + tok, "Origin": "https://evil.example"}, 200},
} {
name := prefix + tc.name
body := fmt.Sprintf(`{"name":%q,"transport":"stdio","command":"sh","args":["-c","id"],"enabled":false}`, name)
rec := httptest.NewRecorder()
h.ServeHTTP(rec, csrfRequest("POST", "/api/mcp", body, tc.headers))
rows, err := m.pg.ListMCP()
if err != nil {
t.Fatal(err)
}
stored := false
for _, row := range rows {
stored = stored || row.Name == name
}
if rec.Code != tc.want || stored != (tc.want == 200) {
t.Errorf("%s: status=%d MCP server stored=%v, want %d (body %s)", tc.name, rec.Code, stored, tc.want, strings.TrimSpace(rec.Body.String()))
}
}
// Reads with the cookie alone still work (the log page and the event
// streams send nothing else).
rec = httptest.NewRecorder()
h.ServeHTTP(rec, csrfRequest("GET", "/api/mcp", "", map[string]string{"Cookie": tok}))
if rec.Code != 200 {
t.Errorf("GET /api/mcp with the cookie: status=%d, want 200", rec.Code)
}
}
+1 -1
View File
@@ -84,7 +84,7 @@ func TestResetSettledRunReseedsBudgetFromUsage(t *testing.T) {
if err != nil {
pgdb.SkipPGUnavailable(t, err)
}
defer m.Close()
t.Cleanup(func() { _ = m.Close() })
taskID := strconv.FormatInt(time.Now().UnixNano(), 10)
t.Cleanup(func() {
+13 -3
View File
@@ -5,13 +5,23 @@ import "os"
// secretEnv lists the credentials read from the environment only at startup:
// ARTEX_PG_DSN and ARTEX_SECRET_KEY by NewManager, the API keys by agent.FromEnv inside New.
// agent.FromEnv also reads ARTEX_LLM_PROXY and ARTEX_LLM_BASE_URL: both are URLs that
// can carry credentials in their userinfo (http://user:pass@proxy:3128). The ARTEX_ARCHIVE_S3_*
// keys are not read by the server, but the container may carry them and the agent's
// shells would inherit them.
// can carry credentials in their userinfo (http://user:pass@proxy:3128). The archive
// store also captures ARTEX_ARCHIVE_S3_* credentials during New, before the scrub,
// so the client can use them without passing them to agent child processes.
//
// Without that override the AWS SDK's default chain reads the AWS_* names below
// while the store is built (LoadDefaultConfig) and keeps what it needs: the static
// keys, or the container endpoint and token and the web-identity role and token
// file path it fetches credentials from later. Credentials that come from a shared
// credentials or config file, or from the instance metadata service, are not in
// the environment: the scrub does not hide them from child processes.
var secretEnv = []string{
"ARTEX_PG_DSN", "ARTEX_SECRET_KEY", "ANTHROPIC_API_KEY", "OPENAI_API_KEY",
"ARTEX_LLM_PROXY", "ARTEX_LLM_BASE_URL",
"ARTEX_ARCHIVE_S3_ACCESS_KEY_ID", "ARTEX_ARCHIVE_S3_SECRET_ACCESS_KEY", "ARTEX_ARCHIVE_S3_SESSION_TOKEN",
"AWS_ACCESS_KEY_ID", "AWS_ACCESS_KEY", "AWS_SECRET_ACCESS_KEY", "AWS_SECRET_KEY", "AWS_SESSION_TOKEN",
"AWS_CONTAINER_CREDENTIALS_FULL_URI", "AWS_CONTAINER_CREDENTIALS_RELATIVE_URI", "AWS_CONTAINER_AUTHORIZATION_TOKEN", "AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE",
"AWS_WEB_IDENTITY_TOKEN_FILE", "AWS_ROLE_ARN",
}
// ScrubSecretEnv removes secretEnv from the process environment once startup has
+12
View File
@@ -60,6 +60,18 @@ func TestSealedEnvironmentHandoff(t *testing.T) {
"ARTEX_ARCHIVE_S3_ACCESS_KEY_ID": "AKIATESTONLY",
"ARTEX_ARCHIVE_S3_SECRET_ACCESS_KEY": "s3-secret-test",
"ARTEX_ARCHIVE_S3_SESSION_TOKEN": "",
// Ambient AWS credentials the archive store reads when it has no override.
"AWS_ACCESS_KEY_ID": "AKIAAMBIENTTEST",
"AWS_ACCESS_KEY": "AKIAALTERNATETEST",
"AWS_SECRET_ACCESS_KEY": "ambient-secret-test",
"AWS_SECRET_KEY": "alternate-secret-test",
"AWS_SESSION_TOKEN": "",
"AWS_CONTAINER_CREDENTIALS_FULL_URI": "http://127.0.0.1:8080/credentials?id=1",
"AWS_CONTAINER_CREDENTIALS_RELATIVE_URI": "/v2/credentials/test",
"AWS_CONTAINER_AUTHORIZATION_TOKEN": "container-token-test",
"AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE": "/var/run/secrets/token-file",
"AWS_WEB_IDENTITY_TOKEN_FILE": "/var/run/secrets/token",
"AWS_ROLE_ARN": "arn:aws:iam::123456789012:role/test",
}
env := os.Environ()
for k, v := range want {
+117
View File
@@ -0,0 +1,117 @@
package server
import (
"crypto/sha256"
"encoding/hex"
"encoding/json"
"testing"
)
// The record_fact texts seeded by the releases v0.4.0 to v0.6.0, copied from
// agent/tools.go at those tags. They are kept here, apart from the agent
// package's list of known defaults, so the test fails when that list drifts
// from the released bytes.
const fix410ReleasedDescription = "Write an exploration [fact/conclusion] into the exploration graph, linked to the intent that produced it (intent_id). Used to record exploration results — both [positive conclusions] like fingerprinting/enumeration, and [negative conclusions] like 'port closed'/'parameter not injectable'/'no login entry found'.\n" +
"⚠️Multiple observations from one exploration must be [consolidated into ONE fact], not split into many; whenever they can be merged into one fact, use one: summary = a one-sentence summary of this conclusion, detail = the related details (may contain multiple concrete items). Example: a fingerprinting intent → one fact {summary:'identified the tech stack and response characteristics of site X', detail:'nginx 1.25 / Vue3 / 200 / title=.. / body_len=..'}, rather than one fact each for status code, fingerprint, and title. One intent usually produces exactly one fact; splitting too finely bloats the graph endlessly.\n" +
"★The facts array writes several [mutually distinct] conclusions at once (each may omit intent_id, defaulting to the top-level intent_id). Returns an ids array, same length and order as facts.\n" +
"⚠️Write only conclusions you [actually saw] in tool output — don't extrapolate. evidence and confidence keep inaccurate conclusions from polluting the graph:\n" +
" · evidence = [one line] of key evidence supporting this conclusion (the command + the one or two most proving output lines), **keep it brief** — details belong in detail; don't paste large output blocks here.\n" +
" · confidence = observed (seen directly in output) | inferred (inferred from phenomena).\n" +
" · **Negative conclusions** (not injectable / port closed / no entry found, etc.) state only \"observation + tentative reading\" — state what you actually saw; whether to abandon the direction is for the planner to decide globally; always provide evidence, mark inferred when the means weren't exhausted or the evidence is weak (including probed only once, looks-like), and mark observed only when truly exhausted and directly seen."
const fix410ReleasedFactsDescription = "[use when there are several distinct conclusions] array of facts; element fields same as the top-level fields below (summary/detail/evidence/confidence/intent_id/asset_ids); omitting intent_id falls back to the top-level intent_id. The returned ids match this array in length and order."
// A database seeded by a release stores the released record_fact description,
// the released facts property description and facts items without properties.
// The one-time refresh replaces both texts with the current ones and sets its
// flag; texts an operator edited match no known default and stay as stored.
func TestFix410ReleasedDefaultsRefreshed(t *testing.T) {
for _, c := range []struct {
name, text, sum string
size int
}{
{"description", fix410ReleasedDescription, "0da5cec5cde7f5e6f41343418fcc2a7d132d6520f336efb39fcbf1ab6ac51957", 2038},
{"facts description", fix410ReleasedFactsDescription, "eb054843a6b33dd39b94ba0648f292babb9cf9bdd106ee4eff6bf593d3f3edf4", 286},
} {
sum := sha256.Sum256([]byte(c.text))
if len(c.text) != c.size || hex.EncodeToString(sum[:]) != c.sum {
t.Fatalf("the released %s in this test is not the released text: %d bytes, sha256 %x", c.name, len(c.text), sum)
}
}
skipWithoutDSN(t)
m, err := NewManager(t.TempDir(), "")
if err != nil {
t.Fatal(err)
}
defer m.Close()
s := &Server{m: m}
const flag = "tool_schema_refresh_record_fact_facts_only"
seed := recordFactSeed(t)
seedSchema, _ := json.Marshal(seed.Schema)
seedAgents, _ := json.Marshal(seed.Agents)
defer func() {
_ = m.pg.UpsertToolForce("record_fact", seed.Desc, seedSchema, seedAgents)
_, _ = m.pg.Exec(`DELETE FROM settings WHERE key=$1`, flag)
}()
currentFacts := seed.Schema["properties"].(map[string]any)["facts"].(map[string]any)["description"]
// start stores the row as a release seeded it, with the given two texts,
// runs the startup steps and returns the two texts as stored afterwards.
start := func(desc, factsDesc string) (string, any) {
t.Helper()
str := func(d string) map[string]any { return map[string]any{"type": "string", "description": d} }
schema, _ := json.Marshal(map[string]any{"type": "object", "properties": map[string]any{
"facts": map[string]any{"type": "array", "description": factsDesc, "items": map[string]any{"type": "object"}},
"summary": str("a [one-sentence summary] of this exploration's conclusion (a condensation of detail)"),
"intent_id": map[string]any{"type": "integer", "description": "the id of the intent that produced this fact (the intent you claimed; the default for each item in batch mode)"},
"detail": str("details related to this fact: write all of this exploration's observations here"),
"evidence": str("[one line] of key evidence: the command + the one or two most proving output lines. Keep it brief; don't paste large output blocks (details go in detail)."),
"confidence": str("observed (seen directly in output) | inferred (inferred from phenomena). Always label negative conclusions honestly."),
"asset_ids": map[string]any{"type": "array", "items": map[string]any{"type": "integer"}, "description": "related asset ids (optional, 0/1/many): which assets this fact involves"},
}})
if err := m.pg.UpsertToolForce("record_fact", desc, schema, seedAgents); err != nil {
t.Fatal(err)
}
if _, err := m.pg.Exec(`DELETE FROM settings WHERE key=$1`, flag); err != nil {
t.Fatal(err)
}
s.seedFactInputSchema()
s.seedFactSourceSchema()
s.refreshRecordFactContract()
if v, _, _ := m.pg.GetSetting(flag); v != "true" {
t.Errorf("flag = %q after the refresh, want true", v)
}
row, err := m.pg.GetTool("record_fact")
if err != nil || row == nil {
t.Fatalf("row: %v", err)
}
var stored struct {
Properties map[string]map[string]any `json:"properties"`
}
if err := json.Unmarshal(row.Schema, &stored); err != nil {
t.Fatal(err)
}
if len(stored.Properties) != 1 || stored.Properties["facts"] == nil {
t.Fatalf("top level still holds fact fields: %s", row.Schema)
}
return row.Description, stored.Properties["facts"]["description"]
}
desc, factsDesc := start(fix410ReleasedDescription, fix410ReleasedFactsDescription)
if desc != seed.Desc {
t.Errorf("released description not replaced by the current one: %.60q", desc)
}
if factsDesc != currentFacts {
t.Errorf("released facts description not replaced by the current one: %v", factsDesc)
}
editedDesc := fix410ReleasedDescription + "\nOperator note: record every negative result."
editedFacts := fix410ReleasedFactsDescription + " Operator note: one fact per host."
desc, factsDesc = start(editedDesc, editedFacts)
if desc != editedDesc {
t.Errorf("operator description changed: %.60q", desc)
}
if factsDesc != editedFacts {
t.Errorf("operator facts description changed: %v", factsDesc)
}
}
+93
View File
@@ -9,6 +9,99 @@ import (
// SeedTool only inserts new rows. Repair existing built-ins too, while keeping
// descriptions, bindings, enabled/deferred flags and parameter annotations.
// refreshRecordFactContract brings an already-seeded record_fact row to the
// facts-only contract (one-time, settings flag). SeedTool is first-insert-only
// and ToolResolve serves the stored text, so without this an old database keeps
// describing the earlier contract (fact fields at the top level beside facts[])
// to the model. Only text equal to the previous code default is replaced:
// - the tool description;
// - the facts property and item descriptions that referred to the top level.
//
// Operator edits stay; a description that matches no known default is logged
// as such and left in place. The schema structure itself is repaired by
// seedFactInputSchema on every start (RepairRecordFactSchema).
//
// The flag is written only once the outcome is known: the UPDATE succeeded
// (also when it changed no row) or the row is not the built-in one. A failed
// read, decode or UPDATE leaves it unset, so the next start retries.
func (s *Server) refreshRecordFactContract() {
const flag = "tool_schema_refresh_record_fact_facts_only"
if v, _, _ := s.m.pg.GetSetting(flag); v == "true" {
return
}
done := func() { _ = s.m.pg.SetSetting(flag, "true") }
var seed *agent.ToolSeed
for _, sd := range agent.BuiltinToolSeeds() {
if sd.Key == "record_fact" {
seed = &sd
break
}
}
row, err := s.m.pg.GetTool("record_fact")
if err != nil {
log.Printf("[facts] read record_fact for the contract refresh: %v", err)
return
}
if row == nil || seed == nil {
return
}
if !row.System || row.Kind != "builtin" {
done()
return
}
legacyTool, legacyFacts, legacyItems := agent.RecordFactLegacyDescriptions()
desc := row.Description
switch {
case desc == seed.Desc:
case sliceHas(legacyTool, desc):
desc = seed.Desc
default:
log.Printf("[facts] record_fact description does not match a known default (operator edit or an older release); the facts-only schema is published anyway, review the text in the tool catalog")
}
var schema map[string]any
if err := json.Unmarshal(row.Schema, &schema); err != nil {
log.Printf("[facts] decode record_fact schema: %v", err)
return
}
repaired := agent.RepairRecordFactSchema(schema)
facts := repaired["properties"].(map[string]any)["facts"].(map[string]any)
canonFacts := seed.Schema["properties"].(map[string]any)["facts"].(map[string]any)
if d, ok := facts["description"].(string); ok && sliceHas(legacyFacts, d) {
facts["description"] = canonFacts["description"]
}
items := facts["items"].(map[string]any)["properties"].(map[string]any)
canonItems := canonFacts["items"].(map[string]any)["properties"].(map[string]any)
for name, old := range legacyItems {
prop, _ := items[name].(map[string]any)
want, _ := canonItems[name].(map[string]any)
if prop != nil && want != nil && prop["description"] == old {
prop["description"] = want["description"]
}
}
raw, err := json.Marshal(repaired)
if err != nil {
return
}
if _, err := s.m.pg.Exec(`UPDATE tools SET description=$1, schema=$2::jsonb, updated_at=now()
WHERE key='record_fact' AND system AND kind='builtin'
AND (description IS DISTINCT FROM $1 OR schema IS DISTINCT FROM $2::jsonb)`, desc, string(raw)); err != nil {
log.Printf("[facts] refresh record_fact contract: %v", err)
return
}
done()
log.Printf("[facts] record_fact now publishes the facts-only contract (one-time)")
}
func sliceHas(list []string, s string) bool {
for _, v := range list {
if v == s {
return true
}
}
return false
}
func (s *Server) seedFactInputSchema() {
row, err := s.m.pg.GetTool("record_fact")
if err != nil {
+228 -8
View File
@@ -3,6 +3,7 @@ package server
import (
"context"
"encoding/json"
"strings"
"testing"
"time"
@@ -42,10 +43,16 @@ func TestRecordFactInputSchemaUpgrade(t *testing.T) {
if err := pg.UpdateTool("record_fact", "operator tool", raw, bindings, old.Enabled); err != nil {
t.Fatal(err)
}
// Facts-only contract: the top level holds facts and
// nothing else; the earlier top-level fact fields and their operator
// annotations are dropped (the handler still accepts the legacy shapes),
// item annotations survive.
check := func(schema map[string]any) {
t.Helper()
if _, ok := schema["required"]; ok {
t.Fatal("top-level summary still required for batches")
if req, _ := schema["required"].([]any); len(req) != 1 || req[0] != "facts" {
if reqS, _ := schema["required"].([]string); len(reqS) != 1 || reqS[0] != "facts" {
t.Fatalf("facts must be the only required property: %v", schema["required"])
}
}
if _, ok := schema["anyOf"]; ok {
t.Fatal("root anyOf still present")
@@ -54,14 +61,13 @@ func TestRecordFactInputSchemaUpgrade(t *testing.T) {
t.Fatal("unknown fields allowed")
}
props := schema["properties"].(map[string]any)
if len(props) != 1 || props["facts"] == nil {
t.Fatalf("top level must hold facts only: %v", props)
}
items := props["facts"].(map[string]any)["items"].(map[string]any)
itemProps := items["properties"].(map[string]any)
if props["tested_asset_ids"] == nil || itemProps["tested_asset_ids"] == nil || itemProps["summary"] == nil {
t.Fatal("repaired schema missing alias or batch summary")
}
if props["summary"].(map[string]any)["description"] != "operator summary" ||
props["confidence"].(map[string]any)["default"] != "inferred" || props["custom"] != nil {
t.Fatal("operator annotations lost")
if itemProps["tested_asset_ids"] == nil || itemProps["summary"] == nil || itemProps["source"] == nil {
t.Fatal("repaired schema missing alias, batch summary or source")
}
if err := actool.ValidateInput(schema, json.RawMessage(`{"facts":[{"summary":"complete batch item"}]}`)); err != nil {
t.Fatal("valid batch rejected", err)
@@ -104,3 +110,217 @@ func TestRecordFactInputSchemaUpgrade(t *testing.T) {
t.Fatal("second migration changed the row")
}
}
// recordFactLegacySchema is the stored record_fact schema of the earlier
// contract: fact fields at the top level beside facts[], with the texts that
// referred to the top level, plus an operator annotation on an item field.
func recordFactLegacySchema(t *testing.T) (string, map[string]string) {
t.Helper()
_, legacyFacts, legacyItems := agent.RecordFactLegacyDescriptions()
item := map[string]any{"type": "object", "required": []string{"summary"}, "additionalProperties": false, "properties": map[string]any{
"summary": map[string]any{"type": "string", "minLength": 1, "description": legacyItems["summary"]},
"intent_id": map[string]any{"type": "integer", "description": legacyItems["intent_id"]},
"detail": map[string]any{"type": "string", "description": "Details of this fact, including all related observations."},
"confidence": map[string]any{"type": "string", "description": "operator confidence note", "default": "inferred"},
"source": map[string]any{"type": "string", "enum": []string{"target_response", "tool_output", "third_party_intel", "operator_input", "inference"}, "description": "where the content came from"},
}}
schema := map[string]any{"type": "object", "additionalProperties": false, "properties": map[string]any{
"summary": map[string]any{"type": "string", "minLength": 1, "description": legacyItems["summary"]},
"intent_id": map[string]any{"type": "integer", "description": legacyItems["intent_id"]},
"detail": map[string]any{"type": "string", "description": "Details of this fact, including all related observations."},
"source": map[string]any{"type": "string", "enum": []string{"inference"}},
"facts": map[string]any{"type": "array", "minItems": 1, "description": legacyFacts[0], "items": item},
}}
raw, _ := json.Marshal(schema)
return string(raw), legacyItems
}
func recordFactSeed(t *testing.T) agent.ToolSeed {
t.Helper()
for _, sd := range agent.BuiltinToolSeeds() {
if sd.Key == "record_fact" {
return sd
}
}
t.Fatal("record_fact seed missing")
return agent.ToolSeed{}
}
// A database that still stores the earlier record_fact contract (text and
// schema) is brought to the facts-only contract once: description replaced
// when it is the previous default, facts/item descriptions replaced when they
// are the earlier texts, operator annotations kept, top-level fact fields
// gone, source enum present on the items. A second run changes nothing, and
// an operator-edited description is left alone.
func TestRefreshRecordFactContract(t *testing.T) {
skipWithoutDSN(t)
m, err := NewManager(t.TempDir(), "")
if err != nil {
t.Skipf("postgres unavailable (%v)", err)
}
defer m.Close()
s := &Server{m: m}
seed := recordFactSeed(t)
seedSchema, _ := json.Marshal(seed.Schema)
seedAgents, _ := json.Marshal(seed.Agents)
restore := func() {
_ = m.pg.UpsertToolForce("record_fact", seed.Desc, seedSchema, seedAgents)
_, _ = m.pg.Exec(`DELETE FROM settings WHERE key='tool_schema_refresh_record_fact_facts_only'`)
}
defer restore()
legacyTool, _, legacyItems := agent.RecordFactLegacyDescriptions()
legacySchema, _ := recordFactLegacySchema(t)
run := func(desc string) {
t.Helper()
if err := m.pg.UpsertToolForce("record_fact", desc, json.RawMessage(legacySchema), seedAgents); err != nil {
t.Fatal(err)
}
if _, err := m.pg.Exec(`DELETE FROM settings WHERE key='tool_schema_refresh_record_fact_facts_only'`); err != nil {
t.Fatal(err)
}
s.seedFactInputSchema()
s.seedFactSourceSchema()
s.refreshRecordFactContract()
}
for _, desc := range legacyTool {
run(desc)
row, err := m.pg.GetTool("record_fact")
if err != nil || row == nil {
t.Fatalf("row: %v", err)
}
if row.Description != seed.Desc {
t.Fatalf("description not refreshed from a known default: %q", row.Description[:60])
}
var schema map[string]any
if err := json.Unmarshal(row.Schema, &schema); err != nil {
t.Fatal(err)
}
props := schema["properties"].(map[string]any)
if len(props) != 1 || props["facts"] == nil {
t.Fatalf("top level still holds fact fields: %v", props)
}
facts := props["facts"].(map[string]any)
items := facts["items"].(map[string]any)["properties"].(map[string]any)
canonItems := seed.Schema["properties"].(map[string]any)["facts"].(map[string]any)["items"].(map[string]any)["properties"].(map[string]any)
if facts["description"] != seed.Schema["properties"].(map[string]any)["facts"].(map[string]any)["description"] {
t.Fatalf("facts description not refreshed: %v", facts["description"])
}
for name := range legacyItems {
if items[name].(map[string]any)["description"] != canonItems[name].(map[string]any)["description"] {
t.Fatalf("item %s description not refreshed: %v", name, items[name])
}
}
if items["confidence"].(map[string]any)["description"] != "operator confidence note" || items["confidence"].(map[string]any)["default"] != "inferred" {
t.Fatalf("operator annotation lost: %v", items["confidence"])
}
if enum, _ := items["source"].(map[string]any)["enum"].([]any); len(enum) != 5 {
t.Fatalf("source enum missing on the items: %v", items["source"])
}
if v, _, _ := m.pg.GetSetting("tool_schema_refresh_record_fact_facts_only"); v != "true" {
t.Fatal("flag not set")
}
// Second start: nothing changes.
var updated1, updated2 string
_ = m.pg.QueryRow(`SELECT updated_at::text FROM tools WHERE key='record_fact'`).Scan(&updated1)
s.seedFactInputSchema()
s.seedFactSourceSchema()
s.refreshRecordFactContract()
_ = m.pg.QueryRow(`SELECT updated_at::text FROM tools WHERE key='record_fact'`).Scan(&updated2)
if updated1 != updated2 {
t.Fatal("second start rewrote the row")
}
}
// An operator-edited description is kept; the schema is still repaired.
run("my own record_fact text")
row, _ := m.pg.GetTool("record_fact")
if row == nil || row.Description != "my own record_fact text" {
t.Fatalf("operator description replaced: %v", row)
}
if !strings.Contains(string(row.Schema), `"facts"`) || strings.Contains(string(row.Schema), legacyItems["intent_id"]) {
t.Fatalf("schema not repaired beside an operator description: %s", row.Schema)
}
}
// A start on which the refresh fails must not spend the one-time flag: the
// next start retries and the stored default text is refreshed then.
func TestFix410RefreshFlagNotSetOnFailure(t *testing.T) {
skipWithoutDSN(t)
m, err := NewManager(t.TempDir(), "")
if err != nil {
t.Skipf("postgres unavailable (%v)", err)
}
defer m.Close()
s := &Server{m: m}
const flag = "tool_schema_refresh_record_fact_facts_only"
seed := recordFactSeed(t)
seedSchema, _ := json.Marshal(seed.Schema)
seedAgents, _ := json.Marshal(seed.Agents)
legacyTool, _, _ := agent.RecordFactLegacyDescriptions()
legacySchema, _ := recordFactLegacySchema(t)
exec := func(query string, args ...any) {
t.Helper()
if _, err := m.pg.Exec(query, args...); err != nil {
t.Fatal(err)
}
}
const dropTrigger = `DROP TRIGGER IF EXISTS fix410_fail_update ON tools`
defer func() {
_, _ = m.pg.Exec(dropTrigger)
_, _ = m.pg.Exec(`DROP FUNCTION IF EXISTS fix410_fail_update()`)
_ = m.pg.UpsertToolForce("record_fact", seed.Desc, seedSchema, seedAgents)
_, _ = m.pg.Exec(`DELETE FROM settings WHERE key=$1`, flag)
}()
exec(`CREATE OR REPLACE FUNCTION fix410_fail_update() RETURNS trigger LANGUAGE plpgsql AS
'BEGIN RAISE EXCEPTION ''fix410: simulated transient failure''; END'`)
start := func() {
s.seedFactInputSchema()
s.seedFactSourceSchema()
s.refreshRecordFactContract()
}
for _, tc := range []struct {
name string
fail, clear func()
}{
{"update fails", func() {
exec(`CREATE TRIGGER fix410_fail_update BEFORE UPDATE ON tools
FOR EACH ROW WHEN (OLD.key = 'record_fact') EXECUTE FUNCTION fix410_fail_update()`)
}, func() { exec(dropTrigger) }},
{"schema does not decode", func() {
exec(`UPDATE tools SET schema='[]'::jsonb WHERE key='record_fact'`)
}, func() {
exec(`UPDATE tools SET schema=$1::jsonb WHERE key='record_fact'`, legacySchema)
}},
} {
t.Run(tc.name, func(t *testing.T) {
// A database that stores the earlier default text and has not run the refresh.
if err := m.pg.UpsertToolForce("record_fact", legacyTool[0], json.RawMessage(legacySchema), seedAgents); err != nil {
t.Fatal(err)
}
exec(`DELETE FROM settings WHERE key=$1`, flag)
tc.fail()
start()
if v, ok, _ := m.pg.GetSetting(flag); ok {
t.Errorf("flag is %q after a failed refresh: later starts skip it", v)
}
if row, _ := m.pg.GetTool("record_fact"); row == nil || row.Description != legacyTool[0] {
t.Fatal("the simulated failure did not leave the earlier description in place")
}
tc.clear()
start()
row, err := m.pg.GetTool("record_fact")
if err != nil || row == nil {
t.Fatalf("row: %v", err)
}
if row.Description != seed.Desc {
t.Errorf("the next start did not refresh the description: %.60q", row.Description)
}
if v, _, _ := m.pg.GetSetting(flag); v != "true" {
t.Errorf("flag = %q after a successful refresh, want true", v)
}
})
}
}
+19 -8
View File
@@ -35,12 +35,13 @@ func TestRecordFactSourceSchemaUpgrade(t *testing.T) {
t.Cleanup(func() { pg.UpdateTool(old.Key, old.Description, old.Schema, bindings, old.Enabled) })
// Simulate a pre-provenance row customised by the operator: no source
// property, an edited description and an edited parameter description.
// property on the facts items, an edited description and an edited
// parameter description (facts-only contract: the items carry the fields).
var schema map[string]any
if err := json.Unmarshal(old.Schema, &schema); err != nil {
t.Fatal(err)
}
props := schema["properties"].(map[string]any)
props := schema["properties"].(map[string]any)["facts"].(map[string]any)["items"].(map[string]any)["properties"].(map[string]any)
delete(props, "source")
props["confidence"].(map[string]any)["description"] = "operator confidence text"
custom, _ := json.Marshal(schema)
@@ -72,16 +73,23 @@ func TestRecordFactSourceSchemaUpgrade(t *testing.T) {
t.Fatal(err)
}
var got struct {
Properties map[string]map[string]any `json:"properties"`
Properties struct {
Facts struct {
Items struct {
Properties map[string]map[string]any `json:"properties"`
} `json:"items"`
} `json:"facts"`
} `json:"properties"`
}
if err := json.Unmarshal(tool.Schema, &got); err != nil {
t.Fatal(err)
}
itemProps := got.Properties.Facts.Items.Properties
wantEnum := "[target_response tool_output third_party_intel operator_input inference]"
if src := got.Properties["source"]; src == nil || fmt.Sprint(src["enum"]) != wantEnum {
if src := itemProps["source"]; src == nil || fmt.Sprint(src["enum"]) != wantEnum {
t.Fatalf("upgrade did not add the source enum: %s", tool.Schema)
}
if tool.Description != "operator description" || got.Properties["confidence"]["description"] != "operator confidence text" || len(got.Properties) != len(props)+1 {
if tool.Description != "operator description" || itemProps["confidence"]["description"] != "operator confidence text" || len(itemProps) != len(props)+1 {
t.Fatalf("operator configuration overwritten: %q %s", tool.Description, tool.Schema)
}
@@ -92,15 +100,18 @@ func TestRecordFactSourceSchemaUpgrade(t *testing.T) {
}
}
// resolvedRecordFactProps returns the properties of record_fact as ToolResolve
// serves it to the worker.
// resolvedRecordFactProps returns the facts[] item properties of record_fact as
// ToolResolve serves it to the worker.
func resolvedRecordFactProps(t *testing.T) map[string]any {
t.Helper()
tools := agent.ToolResolve()(context.Background(), "worker", agent.NewToolSet(nil, "").WorkerTools())
for _, tl := range tools {
if tl.Name() == "record_fact" {
props, _ := tl.InputSchema()["properties"].(map[string]any)
return props
facts, _ := props["facts"].(map[string]any)
items, _ := facts["items"].(map[string]any)
itemProps, _ := items["properties"].(map[string]any)
return itemProps
}
}
t.Fatal("worker lost record_fact")
+6 -1
View File
@@ -38,7 +38,11 @@ func trafficEvidenceServer(t *testing.T) (*Server, *db.RecordedFinding, func(str
t.Fatal(err)
}
tid, _ := strconv.ParseInt(task.ID, 10, 64)
t.Cleanup(func() { m.pg.Exec(`DELETE FROM task_archives WHERE task_id=$1`, tid); m.pg.DeleteTask(tid) })
t.Cleanup(func() {
_, _ = m.pg.DeleteFindingsByTask(tid)
_, _ = m.pg.Exec(`DELETE FROM task_archives WHERE task_id=$1`, tid)
_ = m.pg.DeleteTask(tid)
})
ctx, cancel := context.WithCancel(context.Background())
cancel()
s := New(ctx, m, t.TempDir(), t.TempDir(), t.TempDir())
@@ -278,6 +282,7 @@ func TestFindingTrafficArchiveV3RoundTripAndRetry(t *testing.T) {
if err != nil {
t.Fatal(err)
}
defer s.m.pg.DeleteFinding(shared.FindingID)
if _, err = s.m.traffic.DeleteHost("evidence.local"); err != nil {
t.Fatal(err)
}
+5 -1
View File
@@ -286,15 +286,19 @@ func TestDeepenAdmissionFailureDiscardsFollowUpIntent(t *testing.T) {
t.Fatal(err)
}
taskID, _ := strconv.ParseInt(task.ID, 10, 64)
var findingID int64
defer func() {
_, _ = m.pg.Exec(`UPDATE tasks SET deleted_at=NULL WHERE id=$1`, taskID)
if findingID > 0 {
_, _ = m.pg.DeleteFinding(findingID)
}
_, _ = m.DeleteTask(task.ID, DeleteTaskOptions{})
}()
findingNodeID, err := task.Store.AddNode(db.KindFinding, map[string]any{"summary": "source"}, 5, "confirmed", "worker", nil)
if err != nil {
t.Fatal(err)
}
findingID, err := m.pg.AddFinding(taskID, findingNodeID, "test", "source", db.SeverityHigh, "source", "", "worker", nil)
findingID, err = m.pg.AddFinding(taskID, findingNodeID, "test", "source", db.SeverityHigh, "source", "", "worker", nil)
if err != nil {
t.Fatal(err)
}
+8 -2
View File
@@ -36,7 +36,10 @@ func TestTaskLessonsExtractionAndIdempotency(t *testing.T) {
t.Fatal(err)
}
taskID, _ := strconv.ParseInt(task.ID, 10, 64)
defer func() { _ = m.pg.DeleteTask(taskID) }()
defer func() {
_, _ = m.pg.DeleteFindingsByTask(taskID)
_ = m.pg.DeleteTask(taskID)
}()
defer func() { _, _ = m.pg.Exec(`DELETE FROM rsi_lessons`) }()
if _, err := m.pg.Exec(`
@@ -138,7 +141,10 @@ func TestTerminalStatusExtractsLessons(t *testing.T) {
t.Fatal(err)
}
taskID, _ := strconv.ParseInt(task.ID, 10, 64)
defer func() { _ = m.pg.DeleteTask(taskID) }()
defer func() {
_, _ = m.pg.DeleteFindingsByTask(taskID)
_ = m.pg.DeleteTask(taskID)
}()
if _, err := m.pg.Exec(`
INSERT INTO findings(task_id,vulnclass,name,summary,severity,status)
VALUES ($1,'xss','Reflected XSS','reflected in search','high','confirmed')`, taskID); err != nil {
+179
View File
@@ -0,0 +1,179 @@
package server
import (
"context"
"net"
"net/http"
"net/http/httptest"
"net/netip"
"sync/atomic"
"testing"
)
// A NAT64 address (64:ff9b::/96, the IPv4 address in the low 32 bits) and a
// 6to4 address (2002::/16, the IPv4 address in bits 16 to 47) reach the IPv4
// host they embed, so they are judged as that host is: a DNS64 resolver hands
// out 64:ff9b::/96 answers for every public IPv4-only provider.
func TestLLMModelsJudgesNAT64And6to4ByEmbeddedIPv4(t *testing.T) {
t.Setenv(LLMPrivateEndpointsEnv, "")
s := &Server{}
for _, tc := range []struct {
addr, what string
wantBlocked bool
}{
{"64:ff9b::a9fe:a9fe", "NAT64 of 169.254.169.254 (metadata)", true},
{"2002:a9fe:a9fe::1", "6to4 of 169.254.169.254 (metadata)", true},
{"64:ff9b::5db8:d822", "NAT64 of 93.184.216.34 (public)", false},
{"2002:5db8:d822::1", "6to4 of 93.184.216.34 (public)", false},
{"64:ff9b::7f00:1", "NAT64 of 127.0.0.1 (loopback)", true},
{"2002:7f00:1::", "6to4 of 127.0.0.1 (loopback)", true},
{"64:ff9b::a00:1", "NAT64 of 10.0.0.1 (private)", true},
{"2002:c0a8:101::1", "6to4 of 192.168.1.1 (private)", true},
{"64:ff9b::6440:1", "NAT64 of 100.64.0.1 (carrier-grade NAT)", true},
{"2002:c612:1::1", "6to4 of 198.18.0.1 (benchmarking)", true},
{"64:ff9b::6464:64c8", "NAT64 of 100.100.100.200 (metadata)", true},
{"2002:f000:1::1", "6to4 of 240.0.0.1 (reserved)", true},
{"64:ff9b::c000:1", "NAT64 of 192.0.0.1 (IETF protocol assignments)", true},
{"64:ff9b::", "NAT64 of 0.0.0.0 (unspecified)", true},
{"2002::1", "6to4 of 0.0.0.0 (unspecified)", true},
{"2002:0808:0808:ffff:ffff:ffff:ffff:ffff", "6to4 of 8.8.8.8 (public), any low bits", false},
{"2001:4860:4860::8888", "plain public IPv6", false},
{"2606:4700:4700::1111", "plain public IPv6", false},
// The digits 2002 a9fe a9fe appear, but the first 16 bits are not 2002.
{"200:2a9f:ea9f:e000::1", "2002 shifted by four bits, outside 2002::/16", false},
{"20:2a9:fea9:fe00::1", "2002 shifted by eight bits, outside 2002::/16", false},
{"2001:2002:a9fe:a9fe::1", "2002 in the second group, outside 2002::/16", false},
{"2003:a9fe:a9fe::1", "the prefix next to 2002::/16", false},
// Inside 64:ff9b::/64 but outside the /96 that carries an IPv4 address.
{"64:ff9b::1:a9fe:a9fe", "outside 64:ff9b::/96", false},
} {
t.Run(tc.addr, func(t *testing.T) {
if got := s.isBlockedModelAddr(netip.MustParseAddr(tc.addr), false); got != tc.wantBlocked {
t.Errorf("%s: blocked=%v, want %v", tc.what, got, tc.wantBlocked)
}
})
}
}
// The dial-time guard applies the same rule to the address it is handed.
func TestLLMModelsDialGuardJudgesEmbeddedIPv4(t *testing.T) {
t.Setenv(LLMPrivateEndpointsEnv, "")
g := newModelURLGuard(&Server{})
for a, wantRefused := range map[string]bool{
"64:ff9b::a9fe:a9fe": true,
"2002:a9fe:a9fe::1": true,
"64:ff9b::7f00:1": true,
"2002:7f00:1::": true,
"64:ff9b::5db8:d822": false,
"2002:5db8:d822::1": false,
} {
t.Run(a, func(t *testing.T) {
err := g.blockDial("tcp", net.JoinHostPort(a, "443"), nil)
if refused := err != nil; refused != wantRefused {
t.Errorf("dial to %s: refused=%v (%v), want %v", a, refused, err, wantRefused)
}
})
}
}
// The URL check runs on the endpoint and on every redirect target: a literal
// or a resolved NAT64 or 6to4 address passes when its IPv4 host is public and
// is refused when it is not.
func TestLLMModelsURLGuardJudgesEmbeddedIPv4(t *testing.T) {
t.Setenv(LLMPrivateEndpointsEnv, "")
answers := map[string][]netip.Addr{
"dns64.example": {netip.MustParseAddr("64:ff9b::5db8:d822")},
"metadata.example": {netip.MustParseAddr("93.184.216.34"), netip.MustParseAddr("64:ff9b::a9fe:a9fe")},
"loopback.example": {netip.MustParseAddr("2002:7f00:1::")},
}
g := newModelURLGuard(&Server{modelLookupIP: func(_ context.Context, host string) ([]netip.Addr, error) {
return answers[host], nil
}})
for _, role := range []string{"endpoint", "redirect"} {
for rawURL, wantRefused := range map[string]bool{
"https://[64:ff9b::5db8:d822]/v1": false,
"https://[2002:5db8:d822::1]/v1": false,
"https://dns64.example/v1": false,
"http://[64:ff9b::a9fe:a9fe]/latest/meta-data/": true,
"http://[2002:a9fe:a9fe::1]/latest/meta-data/": true,
"http://[64:ff9b::7f00:1]:8080/": true,
"http://[2002:7f00:1::]:8080/": true,
"https://metadata.example/v1": true,
"https://loopback.example/v1": true,
"https://[2001:4860:4860::8888]/v1": false,
"https://[200:2a9f:ea9f:e000::1]/latest/metadata": false,
} {
t.Run(role+" "+rawURL, func(t *testing.T) {
_, err := g.validateURL(context.Background(), rawURL, role)
if refused := err != nil; refused != wantRefused {
t.Errorf("refused=%v (%v), want %v", refused, err, wantRefused)
}
})
}
}
}
// End to end: a provider reached through a NAT64 address is listed, and a
// NAT64 address of the metadata host is refused before any request.
func TestLLMModelsListsThroughNAT64Address(t *testing.T) {
t.Setenv(LLMPrivateEndpointsEnv, "")
var hits atomic.Int32
upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
hits.Add(1)
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`{"data":[{"id":"gpt-test"}]}`))
}))
t.Cleanup(upstream.Close)
s := &Server{}
// The route is taken only for the NAT64 address itself; every other dial
// goes through the production guard.
s.modelDialContext = dialTestServerForHosts(
map[string]string{"[64:ff9b::5db8:d822]:80": upstream.Listener.Addr().String()},
(&net.Dialer{Control: newModelURLGuard(s).blockDial}).DialContext,
)
resp := postJSON(t, s.pgListModels, "/api/llm/models", map[string]any{
"provider": "openai", "base_url": "http://[64:ff9b::5db8:d822]/v1", "api_key": "sk-test",
})
rawModels, _ := resp["models"].([]any)
if resp["ok"] != true || hits.Load() != 1 || len(rawModels) != 1 || rawModels[0] != "gpt-test" {
t.Errorf("NAT64 address of a public host: answer %v after %d requests, want the model list", resp, hits.Load())
}
hits.Store(0)
resp = postJSON(t, s.pgListModels, "/api/llm/models", map[string]any{
"provider": "openai", "base_url": "http://[64:ff9b::a9fe:a9fe]/v1", "api_key": "sk-test",
})
if resp["ok"] != false || resp["error"] != "endpoint URL host is not allowed" || hits.Load() != 0 {
t.Errorf("NAT64 address of the metadata host: answer %v after %d requests, want a refusal and no request", resp, hits.Load())
}
}
// An endpoint listed in ARTEX_LLM_PRIVATE_ENDPOINTS gets, behind a NAT64 or
// 6to4 address, what it gets as a bare IPv4 address: private, loopback and
// shared ranges are allowed, link-local, metadata and reserved ones never.
func TestLLMModelsPrivateEndpointListCoversEmbeddedIPv4(t *testing.T) {
s := &Server{}
for _, tc := range []struct {
addr, what string
wantBlocked bool
}{
{"64:ff9b::a00:1", "NAT64 of 10.0.0.1", false},
{"2002:a00:1::1", "6to4 of 10.0.0.1", false},
{"64:ff9b::7f00:1", "NAT64 of 127.0.0.1", false},
{"64:ff9b::6440:1", "NAT64 of 100.64.0.1", false},
{"2002:c612:1::1", "6to4 of 198.18.0.1", false},
{"64:ff9b::a9fe:a9fe", "NAT64 of 169.254.169.254", true},
{"2002:a9fe:a9fe::1", "6to4 of 169.254.169.254", true},
{"64:ff9b::6464:64c8", "NAT64 of 100.100.100.200", true},
{"2002:f000:1::1", "6to4 of 240.0.0.1", true},
{"64:ff9b::c000:1", "NAT64 of 192.0.0.1", true},
{"64:ff9b::", "NAT64 of 0.0.0.0", true},
} {
t.Run(tc.addr, func(t *testing.T) {
if got := s.isBlockedModelAddr(netip.MustParseAddr(tc.addr), true); got != tc.wantBlocked {
t.Errorf("allow-listed %s: blocked=%v, want %v", tc.what, got, tc.wantBlocked)
}
})
}
}
+140
View File
@@ -0,0 +1,140 @@
package server
import (
"context"
"net"
"net/http"
"net/http/httptest"
"net/netip"
"strings"
"sync/atomic"
"testing"
)
// Ranges that are not public Internet addresses but are neither RFC 1918 nor
// loopback: carrier-grade NAT, the benchmarking range, the IETF protocol
// assignments, the reserved class E block, and NAT64 and 6to4 addresses that
// embed a non-public IPv4 address.
var reservedModelAddrs = map[string][]string{
"cgnat": {"100.64.0.1", "100.127.255.254", "::ffff:100.64.0.1"},
"benchmark": {"198.18.0.1", "198.19.255.254"},
"ietf_protocol": {"192.0.0.1", "192.0.0.170"},
"reserved": {"240.0.0.1", "250.1.2.3", "255.255.255.255"},
"nat64": {"64:ff9b::a9fe:a9fe", "64:ff9b::7f00:1"},
"six_to_four": {"2002:a9fe:a9fe::1", "2002:7f00:1::1"},
}
func TestLLMModelsRefusesReservedRanges(t *testing.T) {
t.Setenv(LLMPrivateEndpointsEnv, "")
s := &Server{}
for name, addrs := range reservedModelAddrs {
for _, a := range addrs {
addr := netip.MustParseAddr(a)
if !s.isBlockedModelAddr(addr, false) {
t.Errorf("%s: %s is allowed, want it blocked", name, a)
}
// As a literal host: refused before any request, without the address.
host := a
if addr.Is6() {
host = "[" + a + "]"
}
resp := postJSON(t, s.pgListModels, "/api/llm/models", map[string]any{
"provider": "openai", "base_url": "http://" + host + "/v1", "api_key": "sk-test",
})
if errMsg, _ := resp["error"].(string); resp["ok"] != false || errMsg == "" || strings.Contains(errMsg, a) {
t.Errorf("%s: base_url %s answered %v, want a refusal that does not echo the address", name, a, resp)
}
// As the address a public-looking name resolves to.
rs := &Server{modelLookupIP: func(context.Context, string) ([]netip.Addr, error) {
return []netip.Addr{netip.MustParseAddr("93.184.216.34"), addr}, nil
}}
resp = postJSON(t, rs.pgListModels, "/api/llm/models", map[string]any{
"provider": "openai", "base_url": "http://models.example/v1", "api_key": "sk-test",
})
if errMsg, _ := resp["error"].(string); resp["ok"] != false || errMsg != "endpoint URL host is not allowed" {
t.Errorf("%s: a name resolving to %s answered %v, want the host refused", name, a, resp)
}
}
}
// The addresses next to each range stay public.
for _, a := range []string{"100.63.255.255", "100.128.0.1", "198.17.255.255", "198.20.0.1", "192.0.1.1", "93.184.216.34", "64:ff9a::1", "2001:4860:4860::8888", "2003::1"} {
if s.isBlockedModelAddr(netip.MustParseAddr(a), false) {
t.Errorf("%s is blocked, want it allowed", a)
}
}
}
// The dial-time guard refuses the same ranges, so a name that changes its
// answer between the check and the connection gains nothing.
func TestLLMModelsDialGuardRefusesReservedRanges(t *testing.T) {
t.Setenv(LLMPrivateEndpointsEnv, "")
g := newModelURLGuard(&Server{})
for _, a := range []string{"100.64.0.1", "198.18.0.1", "192.0.0.1", "240.0.0.1", "64:ff9b::a9fe:a9fe", "2002:a9fe:a9fe::1"} {
if err := g.blockDial("tcp", net.JoinHostPort(a, "443"), nil); err == nil {
t.Errorf("dial to %s is allowed, want it refused", a)
}
}
if err := g.blockDial("tcp", "93.184.216.34:443", nil); err != nil {
t.Errorf("dial to a public address refused: %v", err)
}
}
// An endpoint the operator listed in ARTEX_LLM_PRIVATE_ENDPOINTS may sit in
// carrier-grade NAT space (an overlay network) or in the benchmarking range
// (a fake-IP resolver), as it may in RFC 1918 space. The other reserved ranges
// and the metadata address inside 100.64.0.0/10 are never allowed.
func TestLLMModelsPrivateEndpointListCoversSharedRanges(t *testing.T) {
s := &Server{}
for a, wantBlocked := range map[string]bool{
"100.64.0.1": false,
"198.18.0.1": false,
"10.0.0.1": false,
"100.100.100.200": true, // Alibaba Cloud metadata
"192.0.0.1": true,
"240.0.0.1": true,
"64:ff9b::a9fe:a9fe": true,
"2002:a9fe:a9fe::1": true,
"169.254.169.254": true,
} {
if got := s.isBlockedModelAddr(netip.MustParseAddr(a), true); got != wantBlocked {
t.Errorf("allow-listed %s: blocked=%v, want %v", a, got, wantBlocked)
}
}
}
// A non-200 answer is reported by its status alone. Echoing the body turned
// the endpoint into a reader of whatever the contacted host returns.
func TestLLMModelsDoesNotEchoUpstreamErrorBody(t *testing.T) {
t.Setenv(LLMPrivateEndpointsEnv, "")
const secret = "internal-admin-token-5f2c"
var hits atomic.Int32
upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
hits.Add(1)
w.WriteHeader(http.StatusForbidden)
_, _ = w.Write([]byte(`{"message":"denied","debug":"` + secret + `"}`))
}))
t.Cleanup(upstream.Close)
s := &Server{modelLookupIP: func(context.Context, string) ([]netip.Addr, error) {
return []netip.Addr{netip.MustParseAddr("93.184.216.34")}, nil
}}
s.modelDialContext = dialTestServerForHosts(
map[string]string{"api.public.example": upstream.Listener.Addr().String()},
(&net.Dialer{Control: newModelURLGuard(s).blockDial}).DialContext,
)
for _, provider := range []string{"openai", "anthropic", "ollama"} {
resp := postJSON(t, s.pgListModels, "/api/llm/models", map[string]any{
"provider": provider, "base_url": "http://api.public.example/v1", "api_key": "sk-public",
})
errMsg, _ := resp["error"].(string)
if resp["ok"] != false || !strings.Contains(errMsg, "403") {
t.Errorf("%s: answer %v, want ok=false with the status", provider, resp)
}
if strings.Contains(errMsg, secret) || strings.Contains(errMsg, "debug") || strings.Contains(errMsg, "denied") {
t.Errorf("%s: the upstream body was echoed: %q", provider, errMsg)
}
}
if hits.Load() == 0 {
t.Fatal("the upstream was never contacted, so the test proves nothing")
}
}
+1
View File
@@ -74,6 +74,7 @@ func TestRecorderPersistsRawWireBodies(t *testing.T) {
if _, err := pg.Exec(`DELETE FROM llm_records WHERE session_id = $1`, session); err != nil {
t.Logf("cleanup: %v", err)
}
_, _ = pg.Exec(`DELETE FROM llm_usage WHERE task_id = '999999' AND profile_name = 'raw-test-profile'`)
}()
ctx := transcript.WithSessionID(context.Background(), session)
+323
View File
@@ -0,0 +1,323 @@
package server
import (
"bytes"
"context"
"fmt"
"log"
"net/http/httptest"
"strings"
"sync"
"testing"
"time"
"github.com/Autumn-27/artex/db"
)
// lockedBuffer is a bytes.Buffer that goroutines still logging in the
// background can write to while the test reads it.
type lockedBuffer struct {
mu sync.Mutex
b bytes.Buffer
}
func (l *lockedBuffer) Write(p []byte) (int, error) {
l.mu.Lock()
defer l.mu.Unlock()
return l.b.Write(p)
}
func (l *lockedBuffer) String() string {
l.mu.Lock()
defer l.mu.Unlock()
return l.b.String()
}
// captureLogSink routes the standard logger through a fresh log sink for the
// test, as StartLogCapture does in the binary, and makes it the sink the
// /api/logs endpoints read. passthrough receives what the sink forwards to
// stderr.
func captureLogSink(t *testing.T) (sink *logSinkT, passthrough *lockedBuffer) {
t.Helper()
passthrough = &lockedBuffer{}
sink = &logSinkT{cap: 3000, subs: map[chan LogLine]struct{}{}, out: passthrough}
prevSink, prevOut := logSink, log.Writer()
logSink = sink
log.SetOutput(sink)
t.Cleanup(func() {
log.SetOutput(prevOut)
logSink = prevSink
})
return sink, passthrough
}
// sinkText is every line the sink holds, joined.
func sinkText(s *logSinkT) string {
lines, _ := s.recent(0, 0)
var b strings.Builder
for _, l := range lines {
b.WriteString(l.Text)
b.WriteByte('\n')
}
return b.String()
}
// The setup token claims the instance, and /api/logs serves the log sink to
// any session; the sink (ring, persisted rows, stream) must never hold it.
func TestSetupTokenStaysOutOfLogSink(t *testing.T) {
m, err := NewManager(t.TempDir(), "")
if err != nil {
db.SkipPGUnavailable(t, err)
}
defer m.Close()
sink, passthrough := captureLogSink(t)
console := &lockedBuffer{}
prevConsole := setupTokenOut
setupTokenOut = console
t.Cleanup(func() { setupTokenOut = prevConsole })
s := &Server{m: m, jwtKey: []byte("0123456789abcdef0123456789abcdef"),
authHashKey: fmt.Sprintf("test.password_hash.%d", time.Now().UnixNano())}
s.initSetupToken()
if s.setupToken == "" {
t.Fatal("no setup token generated while no password is set")
}
// The console line is the one the documented `grep "Setup token"` finds.
if got := console.String(); !strings.Contains(got, "Setup token for the /setup page: "+s.setupToken+"\n") {
t.Errorf("the server console does not show the setup token: %q", strings.ReplaceAll(got, s.setupToken, "<token>"))
}
if got := sinkText(sink); strings.Contains(got, s.setupToken) {
t.Errorf("the log sink holds the setup token:\n%s", got)
}
if got := passthrough.String(); strings.Contains(got, s.setupToken) {
t.Errorf("the sink forwarded the setup token:\n%s", got)
}
// The operator is still told where to find it.
if got := sinkText(sink); !strings.Contains(got, "[auth] no admin password is set") || !strings.Contains(got, "server console") {
t.Errorf("the log sink does not say where the setup token was printed:\n%s", got)
}
}
// A global proxy with user:password is a secret (GET /api/settings masks it).
// Setting it must not put the password into the log sink, the /api/logs and
// /api/logs/history output, the browser MCP row, or the MCP listing.
func TestGlobalProxyCredentialsStayOutOfLogsAndMCPRow(t *testing.T) {
m, err := NewManager(t.TempDir(), "")
if err != nil {
db.SkipPGUnavailable(t, err)
}
if m.pg == nil {
db.SkipNoPG(t)
}
defer m.Close()
sink, passthrough := captureLogSink(t)
td := t.TempDir()
ctx, cancel := context.WithCancel(context.Background())
s := New(ctx, m, td, td, td) // wires the fresh sink to this database
defer stopTestServer(t, s, cancel)
h := s.Handler()
tok, err := signJWT(s.jwtKey)
if err != nil {
t.Fatal(err)
}
do := func(method, path, body string) *httptest.ResponseRecorder {
r := httptest.NewRequest(method, path, strings.NewReader(body))
r.Header.Set("Authorization", "Bearer "+tok)
rec := httptest.NewRecorder()
h.ServeHTTP(rec, r)
return rec
}
// Unique per run, so rows an earlier run left in server_logs cannot match.
stamp := time.Now().UnixNano()
user, password := fmt.Sprintf("proxyuser%d", stamp), fmt.Sprintf("s3cr3t%d", stamp)
host := fmt.Sprintf("proxy-%d.test:3128", stamp)
defer func() { // deferred, not t.Cleanup: it must run before m.Close
if err := m.SetGlobalProxy(""); err != nil {
t.Errorf("clear the global proxy: %v", err)
}
}()
if rec := do("PUT", "/api/settings", fmt.Sprintf(`{"global_proxy":"http://%s:%s@%s"}`, user, password, host)); rec.Code != 200 {
t.Fatalf("PUT /api/settings: status=%d body=%s", rec.Code, rec.Body.String())
}
if got := m.GlobalProxy(); !strings.Contains(got, password) {
t.Fatalf("the global proxy was not stored with its credentials: %q", got)
}
// The browser MCP row carries the proxy, without the credentials.
browser := listMCPByName(t, m.pg, browserMCPName)
if args := decodeStrSlice(browser.Args); len(args) < 2 || args[len(args)-2] != "--proxy-server" || args[len(args)-1] != "http://"+host {
t.Errorf("browser MCP args = %s, want them to end with --proxy-server http://%s", browser.Args, host)
}
// The sync line is in the sink, and persisted, before the surfaces are read.
deadline := time.Now().Add(10 * time.Second)
for persisted := false; !persisted; {
rows, err := m.pg.RecentLogs(200)
if err != nil {
t.Fatal(err)
}
for _, row := range rows {
persisted = persisted || strings.Contains(row.Text, host)
}
if !persisted && time.Now().After(deadline) {
t.Fatalf("no log line that names %s was persisted", host)
}
time.Sleep(20 * time.Millisecond)
}
surfaces := map[string]string{
"log sink": sinkText(sink),
"stderr passthrough": passthrough.String(),
"GET /api/logs": do("GET", "/api/logs?limit=3000", "").Body.String(),
"GET /api/logs/history": do("GET", "/api/logs/history?limit=500", "").Body.String(),
"browser MCP row args": string(browser.Args),
"GET /api/mcp": do("GET", "/api/mcp", "").Body.String(),
}
for name, got := range surfaces {
if strings.Contains(got, password) {
t.Errorf("%s holds the proxy password", name)
}
if !strings.Contains(got, host) {
t.Errorf("%s does not name the proxy host %s, so this check proves nothing", name, host)
}
}
if args := string(browser.Args); strings.Contains(args, user) {
t.Errorf("browser MCP args hold the proxy user: %s", args)
}
}
// A stored global proxy that fails validation is reported at startup; the line
// must not quote the address with its credentials either.
func TestInvalidStoredGlobalProxyIsLoggedWithoutCredentials(t *testing.T) {
m, err := NewManager(t.TempDir(), "")
if err != nil {
db.SkipPGUnavailable(t, err)
}
defer m.Close()
stamp := time.Now().UnixNano()
password := fmt.Sprintf("s3cr3t%d", stamp)
prev, had, err := m.pg.GetSetting(settingGlobalProxy)
if err != nil {
t.Fatal(err)
}
defer func() { // deferred, not t.Cleanup: it must run before m.Close
var err error
if had {
err = m.pg.SetSetting(settingGlobalProxy, prev)
} else {
_, err = m.pg.Exec(`DELETE FROM settings WHERE key=$1`, settingGlobalProxy)
}
if err != nil {
t.Errorf("restore the global proxy setting: %v", err)
}
m.syncBrowserMCPProxy()
}()
for _, stored := range []string{
"ftp://proxyuser:" + password + "@badproxy.test:21", // unsupported scheme
"proxyuser:" + password + "@badproxy.test:3128", // no scheme: does not parse
} {
if err := m.pg.SetSetting(settingGlobalProxy, stored); err != nil {
t.Fatal(err)
}
sink, passthrough := captureLogSink(t)
// The recording proxy is on, so the stored value is validated at startup.
m2, err := NewManager(t.TempDir(), "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
got := sinkText(sink)
browser := listMCPByName(t, m.pg, browserMCPName)
m2.Close()
if !strings.Contains(got, "[proxy] global proxy") {
t.Errorf("stored %q: the invalid proxy was not reported:\n%s", strings.ReplaceAll(stored, password, "***"), got)
}
for name, text := range map[string]string{"log sink": got, "stderr passthrough": passthrough.String(), "browser MCP row args": string(browser.Args)} {
if strings.Contains(text, password) {
t.Errorf("stored %q: %s holds the proxy password", strings.ReplaceAll(stored, password, "***"), name)
}
}
}
}
func TestProxyWithoutCredentials(t *testing.T) {
for raw, want := range map[string]string{
"": "",
"http://127.0.0.1:8788": "http://127.0.0.1:8788",
"http://user:pass@proxy.test:3128": "http://proxy.test:3128",
"socks5://user@proxy.test:1080": "socks5://proxy.test:1080",
" https://u:p%40ss@proxy.test:8443/ ": "https://proxy.test:8443/",
"http://user:pa:ss@[2001:db8::1]:3128": "http://[2001:db8::1]:3128",
"user:pass@proxy.test:3128": "", // no scheme: does not parse
"http://user:pass@proxy.test:notaport": "",
"http://user:pa ss@proxy.test:3128": "",
"//user:pass@proxy.test:3128": "//proxy.test:3128",
} {
if got := proxyWithoutCredentials(raw); got != want {
t.Errorf("proxyWithoutCredentials(%q) = %q, want %q", raw, got, want)
}
}
}
func TestMaskURLCredentials(t *testing.T) {
for in, want := range map[string]string{
"plain line, no URL": "plain line, no URL",
"proxy http://user:pass@proxy.test:3128 attached": "proxy http://user:xxxxx@proxy.test:3128 attached",
`global proxy "socks5://u:p@h:1080" invalid`: `global proxy "socks5://u:xxxxx@h:1080" invalid`,
"dsn postgres://artex:pw@/db?host=/tmp/sock": "dsn postgres://artex:xxxxx@/db?host=/tmp/sock",
"a password with @ and : http://user:p@ss:w0rd@h:1/x": "a password with @ and : http://user:xxxxx@h:1/x",
"two http://a:b@h1 and https://c:d@h2/p": "two http://a:xxxxx@h1 and https://c:xxxxx@h2/p",
"an empty user http://:secret@h:1": "an empty user http://:xxxxx@h:1",
// No password: nothing to mask, and nothing mistaken for one.
"user only ssh://git@github.com/org/repo": "user only ssh://git@github.com/org/repo",
"host and port http://127.0.0.1:8787/api?mail=a@b.test": "host and port http://127.0.0.1:8787/api?mail=a@b.test",
"query without a path http://h:8787?mail=a@b.test": "query without a path http://h:8787?mail=a@b.test",
"IPv6 http://[::1]:8787/x@y": "IPv6 http://[::1]:8787/x@y",
"see https://docs.test:8443 or mail ops@corp.test": "see https://docs.test:8443 or mail ops@corp.test",
} {
if got := maskURLCredentials(in); got != want {
t.Errorf("maskURLCredentials(%q) = %q, want %q", in, got, want)
}
}
}
// The sink masks what it keeps and what it forwards to stderr.
func TestLogSinkMasksURLCredentials(t *testing.T) {
sink, passthrough := captureLogSink(t)
log.Printf("[proxy] upstream %s refused", "http://user:hunter2@proxy.test:3128")
for name, got := range map[string]string{"ring": sinkText(sink), "stderr passthrough": passthrough.String()} {
if strings.Contains(got, "hunter2") || !strings.Contains(got, "[proxy] upstream http://user:xxxxx@proxy.test:3128 refused") {
t.Errorf("%s = %q, want the password masked", name, got)
}
}
}
// Rows persisted before the sink masked credentials are masked when they are
// read back: by GET /api/logs/history and by the restore into the ring.
func TestLogsHistoryMasksCredentialsInOldRows(t *testing.T) {
m, err := NewManager(t.TempDir(), "")
if err != nil {
db.SkipPGUnavailable(t, err)
}
defer m.Close()
password := fmt.Sprintf("oldpw%d", time.Now().UnixNano())
id, err := m.pg.InsertLog("info", "mcp", "[mcp] browser MCP now has the capture proxy http://olduser:"+password+"@old.test:3128 attached (CA )")
if err != nil {
t.Fatal(err)
}
defer func() { _, _ = m.pg.Exec(`DELETE FROM server_logs WHERE id=$1`, id) }() // before m.Close
s := &Server{m: m}
rec := httptest.NewRecorder()
s.getLogsHistory(rec, httptest.NewRequest("GET", "/api/logs/history?limit=500", nil))
if body := rec.Body.String(); rec.Code != 200 || strings.Contains(body, password) || !strings.Contains(body, "http://olduser:xxxxx@old.test:3128") {
t.Errorf("GET /api/logs/history: status=%d, want the old row with its password masked; password present=%v", rec.Code, strings.Contains(body, password))
}
sink := &logSinkT{cap: 3000, subs: map[chan LogLine]struct{}{}, out: &lockedBuffer{}}
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
sink.SetDB(ctx, m.pg)
if got := sinkText(sink); strings.Contains(got, password) || !strings.Contains(got, "http://olduser:xxxxx@old.test:3128") {
t.Errorf("restored ring: want the old row with its password masked; password present=%v", strings.Contains(got, password))
}
}
+19 -3
View File
@@ -5,6 +5,7 @@ import (
"io"
"log"
"os"
"regexp"
"strings"
"sync"
"time"
@@ -75,7 +76,7 @@ func (s *logSinkT) SetDB(ctx context.Context, pg *db.DB) {
TS: l.CreatedAt.Format(time.RFC3339),
Level: l.Level,
Tag: l.Tag,
Text: l.Text,
Text: maskURLCredentials(l.Text), // rows written before the sink masked them
})
}
// Prepend history before any in-memory startup logs already in ring.
@@ -117,10 +118,25 @@ func (s *logSinkT) SetDB(ctx context.Context, pg *db.DB) {
})
}
// urlCredentials matches scheme://user:password@ up to the last @ of the
// authority.
var urlCredentials = regexp.MustCompile(`([a-zA-Z][a-zA-Z0-9+.-]*://[^/\s:@?#]*):[^/\s?#]*@`)
// maskURLCredentials replaces the password of every scheme://user:password@ in
// text. It is a second line of defence for the log sink, which /api/logs
// serves: a log call should not format a secret in the first place.
func maskURLCredentials(text string) string {
if !strings.Contains(text, "://") {
return text
}
return urlCredentials.ReplaceAllString(text, "${1}:xxxxx@")
}
// Write implements io.Writer for the log package: one call per log.Printf line.
func (s *logSinkT) Write(p []byte) (int, error) {
_, _ = s.out.Write(p) // keep the terminal output
line := strings.TrimRight(string(p), "\n")
text := maskURLCredentials(string(p))
_, _ = io.WriteString(s.out, text) // keep the terminal output
line := strings.TrimRight(text, "\n")
if strings.TrimSpace(line) != "" {
s.add(parseLog(line))
}
+44 -2
View File
@@ -7,6 +7,7 @@ import (
"errors"
"fmt"
"log"
"net/url"
"os"
"path/filepath"
"sort"
@@ -266,6 +267,10 @@ type Manager struct {
rewriteMu sync.Mutex
rewriteSet atomic.Pointer[rewrite.Set]
rewriteErrors rewrite.ErrorLog
// Capture-proxy constrained Go tampering hooks (P4.2), behind ARTEX_TAMPER_HOOKS_ENABLED.
hookMu sync.Mutex
hookSet atomic.Pointer[traffic.HookSet]
hookLoadErrs map[int64]string
companyMu sync.Mutex // serializes task/company-scope commits with live handle registration
// taskStateMu preserves commit order between PostgreSQL lifecycle writes and
@@ -463,6 +468,26 @@ func NewManager(dir, proxyAddr string) (*Manager, error) {
if tr != nil {
m.traffic = tr
m.reloadRewriteRules() // in place before the proxy accepts a connection
m.reloadTamperHooks() // opt-in behind ARTEX_TAMPER_HOOKS_ENABLED=1
if scfg, ok := traffic.SOCKS5ConfigFromEnv(); ok {
scfg.DialContext = m.interceptor.DialSOCKS5
scfg.ResolveUDP4 = m.interceptor.ResolveUDP4
if bound, serr := tr.StartSOCKS5(scfg); serr != nil {
log.Printf("[traffic/socks5] disabled: %v", serr)
} else if scfg.EnableUDP {
log.Printf("[traffic/socks5] opt-in SOCKS5 CONNECT + UDP ASSOCIATE listener on %s", bound)
} else {
log.Printf("[traffic/socks5] opt-in SOCKS5 CONNECT listener on %s", bound)
}
}
if tcfg, ok := traffic.TransparentTCPConfigFromEnv(); ok {
tcfg.DialContext = m.interceptor.DialSOCKS5
if bound, terr := tr.StartTransparentTCP(tcfg); terr != nil {
log.Printf("[traffic/transparent] disabled: %v", terr)
} else {
log.Printf("[traffic/transparent] opt-in transparent TCP listener on %s (Linux IPv4 SO_ORIGINAL_DST)", bound)
}
}
go func() {
log.Printf("[traffic] recording proxy on %s (set HTTP_PROXY=%s + trust _ca CA)", proxyAddr, tr.ProxyAddr())
if err := tr.Start(); err != nil {
@@ -503,7 +528,9 @@ func NewManager(dir, proxyAddr string) (*Manager, error) {
}
if m.traffic != nil {
if err := m.traffic.SetUpstreamProxy(m.globalProxy); err != nil {
log.Printf("[proxy] global proxy %q invalid, ignored: %v", m.globalProxy, err)
// Neither the stored value nor err (which quotes it) is logged: both
// can carry the proxy credentials.
log.Printf("[proxy] global proxy %q invalid, ignored; set it again in Settings (shown without credentials, empty when it cannot be parsed)", proxyWithoutCredentials(m.globalProxy))
}
}
m.enrich = enrich.New(m.assets, m.ProxyAddr, 4)
@@ -731,7 +758,10 @@ func (m *Manager) syncBrowserMCPProxy() {
return // user removed/renamed it — leave it alone
}
proxy := m.ProxyAddr() // "" when capture off
// "" when capture is off and no global proxy is set. The global proxy can
// carry user:password; the row is listed by GET /api/mcp and the address is
// logged below, so the credentials are left out of both.
proxy := proxyWithoutCredentials(m.ProxyAddr())
cert := m.ProxyCACert() // "" when capture off
args := stripProxyArgs(decodeStrSlice(srv.Args))
@@ -756,6 +786,18 @@ func (m *Manager) syncBrowserMCPProxy() {
}
}
// proxyWithoutCredentials returns a proxy URL without its user:password, for
// log lines and stored rows. An address that does not parse is returned as "":
// its credentials cannot be told apart from the rest.
func proxyWithoutCredentials(raw string) string {
u, err := url.Parse(strings.TrimSpace(raw))
if err != nil || u.Host == "" {
return ""
}
u.User = nil
return u.String()
}
// stripProxyArgs removes any --proxy-server/--proxy-bypass flags (both "--flag val"
// and "--flag=val" forms) so they can be re-added cleanly from current state,
// without mutating the input slice.
+1 -1
View File
@@ -18,7 +18,7 @@ func TestSeedAssociatesTargetAssetWithTask(t *testing.T) {
if err != nil {
pgdb.SkipPGUnavailable(t, err)
}
defer m.Close()
t.Cleanup(func() { _ = m.Close() })
task, err := m.CreateTask("seed ownership", "seed ownership", nil, 0, 0)
if err != nil {
t.Fatal(err)
+4 -1
View File
@@ -72,7 +72,10 @@ func newNotifyFixture(t *testing.T) *notifyFixture {
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { pg.Exec(`DELETE FROM tasks WHERE id=$1`, taskID) })
t.Cleanup(func() {
_, _ = pg.DeleteFindingsByTask(taskID)
_ = pg.DeleteTask(taskID)
})
var mark int64
if err := pg.QueryRow(`SELECT COALESCE(max(id),0) FROM notification_events`).Scan(&mark); err != nil {
+16 -3
View File
@@ -573,6 +573,7 @@ func (s *Server) seedOrchestrationTools() {
s.seedFindingEvidenceSchema() // optional counterevidence / confidence_rationale on report_finding, added once per DB
s.seedFactInputSchema() // restore record_fact single/batch contracts
s.seedFactSourceSchema() // source enum on record_fact, added once per DB
s.refreshRecordFactContract() // record_fact publishes the facts-only contract (one-time)
s.seedTaskScopeDescription() // add_task_scope: "coverage scope, not enforced" replaces the authorization-boundary text
// Note: pentest's default tool bindings need no migration — BuiltinToolSeeds already seeds
// list_assets/insert_assets/report_finding/list_findings/list_companies together with
@@ -602,11 +603,23 @@ func (s *Server) seedFactSourceSchema() {
if err := json.Unmarshal(obj["properties"], &properties); err != nil {
return
}
if len(properties["source"]) == 0 {
// The source enum lives on the facts[] items (facts-only contract); the
// top level has no fact fields any more.
var facts map[string]json.RawMessage
var items map[string]json.RawMessage
var itemProps map[string]json.RawMessage
if err := json.Unmarshal(properties["facts"], &facts); err != nil {
return
}
_, err = s.m.pg.Exec(`UPDATE tools SET schema=jsonb_set(schema,ARRAY['properties','source'],$1::jsonb,true),updated_at=now()
WHERE key='record_fact' AND system AND NOT(COALESCE(schema->'properties','{}'::jsonb) ? 'source')`, string(properties["source"]))
if err := json.Unmarshal(facts["items"], &items); err != nil {
return
}
if err := json.Unmarshal(items["properties"], &itemProps); err != nil || len(itemProps["source"]) == 0 {
return
}
_, err = s.m.pg.Exec(`UPDATE tools SET schema=jsonb_set(schema,ARRAY['properties','facts','items','properties','source'],$1::jsonb,true),updated_at=now()
WHERE key='record_fact' AND system AND (schema->'properties'->'facts'->'items') ? 'properties'
AND NOT(COALESCE(schema->'properties'->'facts'->'items'->'properties','{}'::jsonb) ? 'source')`, string(itemProps["source"]))
if err != nil {
log.Printf("[facts] upgrade record_fact.source: %v", err)
}
+2
View File
@@ -24,6 +24,7 @@ func TestPlannerQuietSkipEdge(t *testing.T) {
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _, _ = m.DeleteTask(created.ID, DeleteTaskOptions{}) })
tt, ok := m.Task(created.ID)
if !ok {
t.Fatal("task not found after creation")
@@ -93,6 +94,7 @@ func TestPlannerQuietModeToggleMidRun(t *testing.T) {
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _, _ = m.DeleteTask(created.ID, DeleteTaskOptions{}) })
tt, ok := m.Task(created.ID)
if !ok {
t.Fatal("task not found")
+119
View File
@@ -0,0 +1,119 @@
package server
import (
"context"
"strings"
"testing"
"github.com/Autumn-27/norma/harness"
"github.com/Autumn-27/norma/llm"
actool "github.com/Autumn-27/norma/tool"
"github.com/Autumn-27/artex/agent"
"github.com/Autumn-27/artex/db"
)
// acceptsRawInput is the assertion norma's harness makes before its schema
// check: only a tool that reports AcceptsRawInput skips it.
func acceptsRawInput(t actool.CoreTool) bool {
r, ok := t.(interface{ AcceptsRawInput() bool })
return ok && r.AcceptsRawInput()
}
// record_fact opts out of the harness schema check and validates its own
// input. Every wrapper between the handler and the harness has to forward
// that opt-out: an embedded CoreTool alone hides it from the harness's type
// assertion, and the stricter published schema then rejects the calls the
// handler exists to answer.
func TestFix410AcceptsRawInputSurvivesWrappers(t *testing.T) {
oldAugment, oldResolve := agent.ToolAugment(), agent.ToolResolve()
t.Cleanup(func() {
agent.SetToolAugment(oldAugment)
agent.SetToolResolve(oldResolve)
})
ctx := context.Background()
probe := func(raw bool) actool.CoreTool {
return actool.Build(actool.Spec{Name: "fix410_probe", Schema: map[string]any{"type": "object"}, RawInput: raw})
}
// AugmentTools without hooks applies guardPanic and nothing else.
t.Run("guardedTool", func(t *testing.T) {
agent.SetToolAugment(nil)
agent.SetToolResolve(nil)
for _, raw := range []bool{true, false} {
out, _, cleanup := agent.AugmentTools(ctx, "worker", []actool.CoreTool{probe(raw)})
cleanup()
if len(out) != 1 {
t.Fatalf("AugmentTools returned %d tools, want 1", len(out))
}
if got := acceptsRawInput(out[0]); got != raw {
t.Errorf("%T: AcceptsRawInput = %v, wrapped tool reports %v", out[0], got, raw)
}
}
})
t.Run("meteredTool", func(t *testing.T) {
for _, raw := range []bool{true, false} {
wrapped := meterTool(probe(raw), &recordingToolUsage{}, "fix410_probe", "worker", agent.RunInfo{})
if got := acceptsRawInput(wrapped); got != raw {
t.Errorf("%T: AcceptsRawInput = %v, wrapped tool reports %v", wrapped, got, raw)
}
}
})
// The chain a worker's record_fact goes through on the server: the catalog
// decorator and the usage meter (ToolResolve, wireTools), then guardPanic
// (AugmentTools), then the harness itself.
t.Run("server chain", func(t *testing.T) {
dsn, _, err := db.DSN()
if err != nil {
db.SkipPGUnavailable(t, err)
}
pg, err := db.Open(dsn)
if err != nil {
db.SkipPGUnavailable(t, err)
}
t.Cleanup(func() { _ = pg.Close() })
agent.SetToolAugment(nil)
wireTools(pg, nil)
task, err := pg.CreateTaskWithOptions("fix410", "record_fact through the wrapper chain", db.TaskCreateOptions{})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = pg.DeleteTask(task.ID) })
ts := agent.NewToolSet(pg.Exploration(task.ExplorationID), "worker")
tools, _, cleanup := agent.AugmentTools(ctx, "worker", ts.WorkerTools())
defer cleanup()
recordFact := names(tools)["record_fact"]
if recordFact == nil {
t.Fatal("worker has no record_fact")
}
if !acceptsRawInput(recordFact) {
t.Errorf("record_fact lost the harness opt-out behind %T", recordFact)
}
// The first call is malformed (facts is not an array): the harness
// schema check answers it with its generic error unless the tool opted
// out. The second is the legacy single fact, which the published
// schema does not describe and the handler still accepts.
p := &toolScript{results: make(chan string, 4), calls: []scriptedCall{
{"record_fact", `{"facts":{"summary":"not an array"}}`},
{"record_fact", `{"summary":"legacy single fact"}`},
}}
for _, err := range harness.Query(ctx, harness.QueryInput{
Provider: p,
Tools: actool.NewRegistry(recordFact),
Messages: []llm.Message{llm.UserText("record the facts")},
}, harness.QueryDeps{}) {
if err != nil {
t.Fatal(err)
}
}
if refusal := p.next(t); !strings.Contains(refusal, "invalid record_fact input: facts must be an array") {
t.Errorf("malformed call: want the handler's own refusal, not the SDK schema error, got: %s", refusal)
}
if legacy := p.next(t); strings.HasPrefix(legacy, "[error]") || ts.Writes().Facts != 1 {
t.Errorf("legacy single fact not written (facts=%d): %s", ts.Writes().Facts, legacy)
}
})
}
+21 -6
View File
@@ -24,6 +24,7 @@ import (
"time"
"github.com/Autumn-27/artex/agent"
"github.com/Autumn-27/artex/archivestore"
"github.com/Autumn-27/artex/db"
"github.com/Autumn-27/artex/egress"
"github.com/Autumn-27/artex/intercept"
@@ -158,9 +159,11 @@ type Server struct {
// Cold task archives run through one persistent FIFO worker. The buffered wake
// channel coalesces enqueue bursts; the database remains the source of truth.
archiveWake chan struct{}
archiveWG sync.WaitGroup
side *sideQuestionState
archiveWake chan struct{}
archiveWG sync.WaitGroup
archiveStore *archivestore.Store
archiveStoreErr error
side *sideQuestionState
}
// provEntry is a cached provider + its config for one LLM profile id.
@@ -302,8 +305,10 @@ func New(ctx context.Context, m *Manager, skillDir string, dataDir string, keyDi
} else {
log.Printf("[engine] no LLM provider configured — engine idle until set via /api/llm or env")
}
// Both env readers have now run (NewManager for the DSN, FromEnv above for the
// keys). Drop the secrets before anything below can spawn a child process:
s.initTaskArchiveStore()
// Startup env readers have now run (NewManager for the DSN, the LLM provider
// and archive store for their credentials). Drop the secrets before anything
// below can spawn a child process:
// restoring runtimes resumes workers that run shells, and MCP discovery starts
// stdio servers.
if s.scrubSecrets {
@@ -1033,6 +1038,16 @@ func (s *Server) Handler() http.Handler {
mux.HandleFunc("DELETE /api/traffic/rewrite-rules/{id}", s.rewriteDeleteRule)
mux.HandleFunc("POST /api/traffic/rewrite-rules/{id}/toggle", s.rewriteToggleRule)
// capture-proxy constrained Go tampering hooks (P4.2, operator-only, opt-in via ARTEX_TAMPER_HOOKS_ENABLED)
mux.HandleFunc("GET /api/traffic/hooks", s.tamperListHooks)
mux.HandleFunc("POST /api/traffic/hooks", s.tamperCreateHook)
mux.HandleFunc("PUT /api/traffic/hooks/{id}", s.tamperUpdateHook)
mux.HandleFunc("DELETE /api/traffic/hooks/{id}", s.tamperDeleteHook)
mux.HandleFunc("POST /api/traffic/hooks/{id}/toggle", s.tamperToggleHook)
mux.HandleFunc("GET /api/traffic/hooks/{id}/versions", s.tamperListHookVersions)
mux.HandleFunc("POST /api/traffic/hooks/{id}/rollback", s.tamperRollbackHook)
mux.HandleFunc("POST /api/traffic/hooks/dry-run", s.tamperDryRunHook)
// asset interception rule management (global blocklist: domains/IPs/URLs/CIDRs)
mux.HandleFunc("GET /api/asset-intercept/rules", s.assetInterceptListRules)
mux.HandleFunc("POST /api/asset-intercept/rules", s.assetInterceptCreateRule)
@@ -3332,7 +3347,7 @@ func (s *Server) getLogsHistory(w http.ResponseWriter, r *http.Request) {
TS: r.CreatedAt.Format(time.RFC3339),
Level: r.Level,
Tag: r.Tag,
Text: r.Text,
Text: maskURLCredentials(r.Text), // rows written before the sink masked them
})
}
writeJSON(w, 200, map[string]any{"items": items, "has_more": len(rows) == limit})
+54 -7
View File
@@ -2389,26 +2389,71 @@ func sameRedirectHost(a, b *url.URL) bool {
return ha != "" && ha == hb
}
// Ranges that are not public Internet addresses and that
// intercept.IsNonPublicAddr does not cover. The shared ones are in use on
// private networks (overlay networks, fake-IP resolvers), so an allow-listed
// endpoint may sit there; the reserved ones are never a model endpoint.
var (
modelSharedPrefixes = []netip.Prefix{
netip.MustParsePrefix("100.64.0.0/10"), // carrier-grade NAT (RFC 6598)
netip.MustParsePrefix("198.18.0.0/15"), // benchmarking (RFC 2544)
}
modelReservedPrefixes = []netip.Prefix{
netip.MustParsePrefix("192.0.0.0/24"), // IETF protocol assignments (RFC 6890)
netip.MustParsePrefix("240.0.0.0/4"), // reserved, and the limited broadcast address
}
// IPv6 prefixes whose addresses reach the IPv4 host they embed. A DNS64
// resolver answers with NAT64 addresses for every IPv4-only name, so the
// prefixes are not blocked as a whole: the embedded address is judged.
modelNAT64Prefix = netip.MustParsePrefix("64:ff9b::/96") // the low 32 bits name an IPv4 host
model6to4Prefix = netip.MustParsePrefix("2002::/16") // bits 16 to 47 name an IPv4 host
)
// modelEmbeddedIPv4 returns the IPv4 address a NAT64 or 6to4 address embeds.
func modelEmbeddedIPv4(addr netip.Addr) (netip.Addr, bool) {
b := addr.As16()
switch {
case modelNAT64Prefix.Contains(addr):
return netip.AddrFrom4([4]byte(b[12:16])), true
case model6to4Prefix.Contains(addr):
return netip.AddrFrom4([4]byte(b[2:6])), true
}
return netip.Addr{}, false
}
func prefixesContain(prefixes []netip.Prefix, addr netip.Addr) bool {
for _, p := range prefixes {
if p.Contains(addr) {
return true
}
}
return false
}
func (s *Server) isBlockedModelAddr(addr netip.Addr, allowPrivate bool) bool {
if !addr.IsValid() {
return true
}
addr = addr.Unmap().WithZone("")
if v4, ok := modelEmbeddedIPv4(addr); ok {
addr = v4
}
if s != nil && s.allowLoopbackModels && addr.IsLoopback() {
return false
}
if !intercept.IsNonPublicAddr(addr) {
shared := prefixesContain(modelSharedPrefixes, addr)
if !intercept.IsNonPublicAddr(addr) && !shared && !prefixesContain(modelReservedPrefixes, addr) {
return false
}
if allowPrivate {
// Allow-listed self-hosted endpoints may resolve to loopback or RFC1918 /
// unique-local private addresses, but never link-local, unspecified,
// multicast, or instance-metadata addresses (such as 169.254.169.254 or
// fd00:ec2::254).
// Allow-listed self-hosted endpoints may resolve to loopback, RFC1918 /
// unique-local private addresses, or the shared ranges above, but never
// link-local, unspecified, multicast, reserved, or instance-metadata
// addresses (such as 169.254.169.254, 100.100.100.200 or fd00:ec2::254).
if addr.IsLoopback() {
return false
}
if addr.IsPrivate() && intercept.ValidateExemptionHost(addr.String()) == nil {
if (addr.IsPrivate() || shared) && intercept.ValidateExemptionHost(addr.String()) == nil {
return false
}
}
@@ -2756,7 +2801,9 @@ func (s *Server) pgListModels(w http.ResponseWriter, r *http.Request) {
body, _ := io.ReadAll(io.LimitReader(resp.Body, 4<<20))
resp.Body.Close()
if resp.StatusCode != http.StatusOK {
lastErr = fmt.Sprintf("API returned %d: %s", resp.StatusCode, string(body[:min(len(body), 512)]))
// The status only: echoing the body would let the caller read what
// any host this endpoint can reach answers.
lastErr = fmt.Sprintf("API returned %d %s (the response body is not shown)", resp.StatusCode, http.StatusText(resp.StatusCode))
continue
}
// Both OpenAI and Anthropic return {"data": [{"id": "..."},...]}.
+108
View File
@@ -0,0 +1,108 @@
package server
import (
"encoding/binary"
"fmt"
"io"
"net"
"strconv"
"sync/atomic"
"testing"
"time"
"github.com/Autumn-27/artex/db"
"github.com/Autumn-27/artex/traffic"
)
func TestManagerSOCKS5OptInFlagAndAssetBlockRuleRefusal(t *testing.T) {
// 1. Flag off (default): Manager starts NO SOCKS5 listener.
t.Setenv(traffic.SOCKS5EnabledEnv, "")
t.Setenv(traffic.SOCKS5AddrEnv, "")
mOff, err := NewManager(t.TempDir(), "127.0.0.1:0")
if err != nil {
db.SkipPGUnavailable(t, err)
}
t.Cleanup(func() { _ = mOff.Close() })
if mOff.traffic == nil {
t.Fatal("expected HTTP recording proxy to start")
}
if got := mOff.traffic.SOCKS5Addr(); got != "" {
t.Fatalf("SOCKS5Addr with flag off = %q, want empty", got)
}
// 2. Flag on (ARTEX_SOCKS5_ADDR=127.0.0.1:0): listener starts and enforces
// global asset block rules via m.interceptor.DialSOCKS5 BEFORE dialing.
t.Setenv(traffic.SOCKS5AddrEnv, "127.0.0.1:0")
mOn, err := NewManager(t.TempDir(), "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = mOn.Close() })
socksAddr := mOn.traffic.SOCKS5Addr()
if socksAddr == "" {
t.Fatal("expected SOCKS5 listener when ARTEX_SOCKS5_ADDR is set")
}
// Add a global asset block rule for 127.0.0.1 and ensure cleanup.
rule, err := mOn.pg.CreateAssetInterceptRule(
"exact_ip",
"127.0.0.1",
fmt.Sprintf("p41a-block-test-%d", time.Now().UnixNano()),
true,
)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = mOn.pg.DeleteAssetInterceptRule(rule.ID) })
// Target TCP server on 127.0.0.1: must NEVER receive a connection.
targetLn, err := net.Listen("tcp4", "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
defer targetLn.Close()
var accepted atomic.Int32
go func() {
for {
c, err := targetLn.Accept()
if err != nil {
return
}
accepted.Add(1)
_ = c.Close()
}
}()
_, portStr, _ := net.SplitHostPort(targetLn.Addr().String())
port, _ := strconv.Atoi(portStr)
c, err := net.DialTimeout("tcp", socksAddr, 3*time.Second)
if err != nil {
t.Fatal(err)
}
defer c.Close()
_ = c.SetDeadline(time.Now().Add(5 * time.Second))
// Greeting: VER=5, NMETHODS=1, NO AUTH
if _, err := c.Write([]byte{0x05, 0x01, 0x00}); err != nil {
t.Fatal(err)
}
var sel [2]byte
if _, err := io.ReadFull(c, sel[:]); err != nil || sel != [2]byte{0x05, 0x00} {
t.Fatalf("method selection = %v err=%v", sel, err)
}
// CONNECT 127.0.0.1:<port>
req := []byte{0x05, 0x01, 0x00, 0x01, 127, 0, 0, 1, 0, 0}
binary.BigEndian.PutUint16(req[8:10], uint16(port))
if _, err := c.Write(req); err != nil {
t.Fatal(err)
}
var rep [10]byte
if _, err := io.ReadFull(c, rep[:]); err != nil {
t.Fatal(err)
}
if rep[1] != 0x02 {
t.Fatalf("blocked target SOCKS5 reply = 0x%02x, want 0x02 (not allowed by ruleset)", rep[1])
}
if accepted.Load() != 0 {
t.Fatalf("blocked target accepted %d connections, want 0", accepted.Load())
}
}
+180
View File
@@ -0,0 +1,180 @@
package server
import (
"encoding/binary"
"fmt"
"io"
"net"
"sync/atomic"
"testing"
"time"
"github.com/Autumn-27/artex/db"
"github.com/Autumn-27/artex/traffic"
)
func TestManagerSOCKS5UDPOptInAndAssetBlockRuleDropsDatagram(t *testing.T) {
// 1. Both flags off: NO SOCKS5 listener and UDP disabled.
t.Setenv(traffic.SOCKS5EnabledEnv, "")
t.Setenv(traffic.SOCKS5AddrEnv, "")
t.Setenv(traffic.SOCKS5UDPEnabledEnv, "")
mOff, err := NewManager(t.TempDir(), "127.0.0.1:0")
if err != nil {
db.SkipPGUnavailable(t, err)
}
t.Cleanup(func() { _ = mOff.Close() })
if mOff.traffic.SOCKS5Addr() != "" || mOff.traffic.SOCKS5UDPEnabled() {
t.Fatalf("flags off: addr=%q udp=%v, want empty/false", mOff.traffic.SOCKS5Addr(), mOff.traffic.SOCKS5UDPEnabled())
}
// 2. SOCKS5 on with UDP flag off: UDP ASSOCIATE refused with 0x07.
t.Setenv(traffic.SOCKS5AddrEnv, "127.0.0.1:0")
t.Setenv(traffic.SOCKS5UDPEnabledEnv, "")
mTCPOnly, err := NewManager(t.TempDir(), "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = mTCPOnly.Close() })
if mTCPOnly.traffic.SOCKS5UDPEnabled() {
t.Fatal("expected UDP disabled when ARTEX_SOCKS5_UDP_ENABLED is unset")
}
// 3. UDP flag on: listener accepts UDP ASSOCIATE and enforces global asset
// block rules per datagram destination (drop denied, forward allowed).
t.Setenv(traffic.SOCKS5AddrEnv, "127.0.0.1:0")
t.Setenv(traffic.SOCKS5UDPEnabledEnv, "1")
mOn, err := NewManager(t.TempDir(), "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = mOn.Close() })
socksAddr := mOn.traffic.SOCKS5Addr()
if socksAddr == "" || !mOn.traffic.SOCKS5UDPEnabled() {
t.Fatalf("expected SOCKS5+UDP enabled, got addr=%q udp=%v", socksAddr, mOn.traffic.SOCKS5UDPEnabled())
}
// Block 127.0.0.2 via global asset intercept rule; leave 127.0.0.1 allowed.
rule, err := mOn.pg.CreateAssetInterceptRule(
"exact_ip",
"127.0.0.2",
fmt.Sprintf("p41c-udp-block-%d", time.Now().UnixNano()),
true,
)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = mOn.pg.DeleteAssetInterceptRule(rule.ID) })
startEcho := func(bind string) (*net.UDPConn, *atomic.Int32) {
t.Helper()
ua, err := net.ResolveUDPAddr("udp4", bind)
if err != nil {
t.Fatal(err)
}
ln, err := net.ListenUDP("udp4", ua)
if err != nil {
t.Fatal(err)
}
var n atomic.Int32
go func() {
buf := make([]byte, 4096)
for {
rn, from, rerr := ln.ReadFromUDP(buf)
if rerr != nil {
return
}
n.Add(1)
_, _ = ln.WriteToUDP(append([]byte("OK:"), buf[:rn]...), from)
}
}()
t.Cleanup(func() { _ = ln.Close() })
return ln, &n
}
blockedLn, blockedCount := startEcho("127.0.0.2:0")
allowedLn, allowedCount := startEcho("127.0.0.1:0")
blockedAddr := blockedLn.LocalAddr().(*net.UDPAddr)
allowedAddr := allowedLn.LocalAddr().(*net.UDPAddr)
// Open SOCKS5 UDP ASSOCIATE control connection.
ctrl, err := net.DialTimeout("tcp4", socksAddr, 3*time.Second)
if err != nil {
t.Fatal(err)
}
defer ctrl.Close()
_ = ctrl.SetDeadline(time.Now().Add(5 * time.Second))
if _, err := ctrl.Write([]byte{0x05, 0x01, 0x00}); err != nil {
t.Fatal(err)
}
var sel [2]byte
if _, err := io.ReadFull(ctrl, sel[:]); err != nil || sel != [2]byte{0x05, 0x00} {
t.Fatalf("method selection = %v err=%v", sel, err)
}
// CMD=0x03 (UDP ASSOCIATE), ATYP=0x01, 0.0.0.0:0
if _, err := ctrl.Write([]byte{0x05, 0x03, 0x00, 0x01, 0, 0, 0, 0, 0, 0}); err != nil {
t.Fatal(err)
}
var rep [10]byte
if _, err := io.ReadFull(ctrl, rep[:]); err != nil {
t.Fatal(err)
}
if rep[1] != 0x00 {
t.Fatalf("UDP ASSOCIATE rep = 0x%02x, want 0x00", rep[1])
}
relayAddr := &net.UDPAddr{
IP: net.IPv4(rep[4], rep[5], rep[6], rep[7]),
Port: int(binary.BigEndian.Uint16(rep[8:10])),
}
_ = ctrl.SetDeadline(time.Time{})
cliUDP, err := net.ListenUDP("udp4", &net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 0})
if err != nil {
t.Fatal(err)
}
defer cliUDP.Close()
buildPkt := func(dst *net.UDPAddr, msg string) []byte {
p := make([]byte, 10+len(msg))
p[3] = 0x01
copy(p[4:8], dst.IP.To4())
binary.BigEndian.PutUint16(p[8:10], uint16(dst.Port))
copy(p[10:], msg)
return p
}
// Send datagram to blocked 127.0.0.2 (must be dropped by asset rule), then to allowed 127.0.0.1.
_, _ = cliUDP.WriteToUDP(buildPkt(blockedAddr, "blocked-udp"), relayAddr)
_, _ = cliUDP.WriteToUDP(buildPkt(allowedAddr, "allowed-udp"), relayAddr)
_ = cliUDP.SetReadDeadline(time.Now().Add(2 * time.Second))
buf := make([]byte, 2048)
rn, _, err := cliUDP.ReadFromUDP(buf)
if err != nil {
t.Fatalf("read allowed udp reply: %v", err)
}
if got := string(buf[10:rn]); got != "OK:allowed-udp" {
t.Fatalf("reply = %q, want OK:allowed-udp", got)
}
if blockedCount.Load() != 0 {
t.Fatalf("blocked 127.0.0.2 received %d datagrams, want 0", blockedCount.Load())
}
if allowedCount.Load() != 1 {
t.Fatalf("allowed 127.0.0.1 received %d datagrams, want 1", allowedCount.Load())
}
// Wait briefly for SQLite writes and verify raw_udp_datagrams has 127.0.0.1 only, 0 HTTP exchanges.
deadline := time.Now().Add(2 * time.Second)
for time.Now().Before(deadline) {
n, err := mOn.traffic.CountRawUDPDatagrams("", "127.0.0.1")
if err == nil && n >= 2 {
break
}
time.Sleep(20 * time.Millisecond)
}
if nBlocked, err := mOn.traffic.CountRawUDPDatagrams("", "127.0.0.2"); err != nil || nBlocked != 0 {
t.Fatalf("blocked host recorded %d rows (err=%v), want 0", nBlocked, err)
}
if nAllowed, err := mOn.traffic.CountRawUDPDatagrams("", "127.0.0.1"); err != nil || nAllowed != 2 {
t.Fatalf("allowed host recorded %d rows (err=%v), want 2", nAllowed, err)
}
}
+8
View File
@@ -0,0 +1,8 @@
//go:build !unix
package server
// syncDir does nothing here: Windows does not support fsync on a directory
// handle (FlushFileBuffers fails on it), and the contents of the file written in
// the directory are already synced by the caller.
func syncDir(path string) error { return nil }
+18
View File
@@ -0,0 +1,18 @@
//go:build unix
package server
import (
"errors"
"os"
)
// syncDir flushes a directory, so that an entry just created or renamed in it
// survives a crash.
func syncDir(path string) error {
d, err := os.Open(path)
if err != nil {
return err
}
return errors.Join(d.Sync(), d.Close())
}
+18
View File
@@ -0,0 +1,18 @@
//go:build unix
package server
import (
"path/filepath"
"testing"
)
func TestSyncDir(t *testing.T) {
dir := t.TempDir()
if err := syncDir(dir); err != nil {
t.Fatalf("sync of an existing directory: %v", err)
}
if err := syncDir(filepath.Join(dir, "missing")); err == nil {
t.Fatal("sync of a missing directory must fail")
}
}
+1
View File
@@ -83,6 +83,7 @@ func (g *gateServer) cleanupTask(t *testing.T, id string) {
_ = g.m.pg.DeleteTask(n)
_, _ = g.m.pg.Exec(`DELETE FROM target_pins WHERE task_id=$1`, n)
_, _ = g.m.pg.Exec(`DELETE FROM intercept_pending WHERE task_id=$1`, id)
_, _ = g.m.pg.Exec(`DELETE FROM assets WHERE type = 'ip' AND ip = '127.0.0.1'`)
})
}
+1
View File
@@ -174,6 +174,7 @@ func (f *targetScopeFixture) newTask(t *testing.T) *Task {
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _, _ = f.m.DeleteTask(created.ID, DeleteTaskOptions{}) })
task, ok := f.m.Task(created.ID)
if !ok {
t.Fatal("task not found after creation")
+9
View File
@@ -650,6 +650,15 @@ func TestTaskLLMResolutionReportsDatabaseFailure(t *testing.T) {
if err != nil {
t.Fatal(err)
}
taskID := mustTaskID(t, task.ID)
t.Cleanup(func() {
if dsn, _, err := db.DSN(); err == nil {
if pg, err := db.Open(dsn); err == nil {
_ = pg.DeleteTask(taskID)
_ = pg.Close()
}
}
})
if err := m.pg.Close(); err != nil {
t.Fatal(err)
}
+403
View File
@@ -0,0 +1,403 @@
package server
import (
"context"
"fmt"
"io"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strconv"
"sync"
"testing"
"github.com/Autumn-27/artex/archivestore"
pgdb "github.com/Autumn-27/artex/db"
)
// Recreate persisted states at operation boundaries, then run the same recovery
// functions used at startup. PostgreSQL, files, and HTTP object storage are real
// isolated fixtures; no production failpoint hooks are needed.
func TestRemoteArchiveInterruptionRecovery(t *testing.T) {
if os.Getenv("ARTEX_PG_DSN") == "" {
t.Skip("requires isolated PostgreSQL")
}
phases := []string{
"staged_before_compression", "compression_partial", "compressed_before_journal", "journal_before_upload",
"uploaded_before_verification", "verified_before_database",
"database_before_local_cleanup", "package_cleaned_before_stage_cleanup",
"restore_download_before_install", "restore_files_before_database", "restore_database_before_object_delete", "restore_object_deleted_before_stub",
"delete_journal_before_database", "delete_database_before_object",
}
for _, phase := range phases {
t.Run(phase, func(t *testing.T) {
m, err := NewManager(t.TempDir(), "")
if err != nil {
t.Fatal(err)
}
defer m.Close()
store, objects := newRecoveryObjectStore(t)
s := &Server{ctx: context.Background(), m: m, archiveStore: store}
task, err := m.CreateTask("interruption "+phase, "preserve source", nil, 0, 0)
if err != nil {
t.Fatal(err)
}
id, _ := strconv.ParseInt(task.ID, 10, 64)
defer func() { _, _ = m.pg.Exec("DELETE FROM task_archives WHERE task_id=$1", id); _ = m.pg.DeleteTask(id) }()
if err := m.pg.SetPaused(id, true); err != nil {
t.Fatal(err)
}
job, err := m.pg.QueueTaskArchive(id)
if err != nil {
t.Fatal(err)
}
if _, err := m.pg.Exec("UPDATE task_archives SET state=$2 WHERE id=$1", job.ID, pgdb.Archiving); err != nil {
t.Fatal(err)
}
source := filepath.Join(m.dir, "tasks", task.ID, "workspace", "source.txt")
if err := os.MkdirAll(filepath.Dir(source), 0700); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(source, []byte("original task data"), 0600); err != nil {
t.Fatal(err)
}
snapshot, err := m.pg.SnapshotTaskArchive(id)
if err != nil {
t.Fatal(err)
}
stage, err := stageTaskArchiveFiles(m.dir, job.ID, task.ID, snapshot.ExplorationID)
if err != nil {
t.Fatal(err)
}
packagePath := taskArchivePath(m.dir, job.ID, task.ID)
if phase == "compression_partial" {
if err := os.MkdirAll(filepath.Dir(packagePath), 0700); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(packagePath+".partial", []byte("incomplete compressed package"), 0600); err != nil {
t.Fatal(err)
}
}
var original, compressed int64
var checksum, uri, journal string
if phase != "staged_before_compression" && phase != "compression_partial" {
original, compressed, checksum, err = writeTaskArchivePackage(packagePath, stage.payload, snapshot)
if err != nil {
t.Fatal(err)
}
uri = store.URI(id, job.ID, checksum)
}
if phase != "staged_before_compression" && phase != "compression_partial" && phase != "compressed_before_journal" {
journal, err = s.writeRemoteArchiveJournal(remoteArchiveJournal{ArchiveID: job.ID, URI: uri, LocalPath: packagePath, Operation: "upload"})
if err != nil {
t.Fatal(err)
}
}
committed := phase != "staged_before_compression" && phase != "compression_partial" && phase != "compressed_before_journal" &&
phase != "journal_before_upload" && phase != "uploaded_before_verification" && phase != "verified_before_database"
if phase == "uploaded_before_verification" {
data, err := os.ReadFile(packagePath)
if err != nil {
t.Fatal(err)
}
objects.put(uri, data)
} else if phase == "verified_before_database" || committed {
if err := store.Upload(s.ctx, uri, packagePath, checksum); err != nil {
t.Fatal(err)
}
}
if committed {
if err := m.pg.CompleteTaskArchive(job.ID, snapshot, uri, checksum, original, compressed); err != nil {
t.Fatal(err)
}
}
afterArchive := phase == "restore_download_before_install" || phase == "restore_files_before_database" || phase == "restore_database_before_object_delete" ||
phase == "restore_object_deleted_before_stub" || phase == "delete_journal_before_database" || phase == "delete_database_before_object"
if phase == "package_cleaned_before_stage_cleanup" || afterArchive {
if err := os.Remove(packagePath); err != nil {
t.Fatal(err)
}
if err := os.Remove(journal); err != nil {
t.Fatal(err)
}
}
if afterArchive {
if err := stage.commit(); err != nil {
t.Fatal(err)
}
}
restored := false
remoteDeleted := false
if phase == "restore_download_before_install" || phase == "restore_files_before_database" || phase == "restore_database_before_object_delete" || phase == "restore_object_deleted_before_stub" {
if _, err := m.pg.Exec("UPDATE task_archives SET state=$2 WHERE id=$1", job.ID, pgdb.Restoring); err != nil {
t.Fatal(err)
}
parent := filepath.Join(taskArchiveRoot(m.dir), ".restore")
if err := os.MkdirAll(parent, 0700); err != nil {
t.Fatal(err)
}
extracted, err := os.MkdirTemp(parent, "interrupted-")
if err != nil {
t.Fatal(err)
}
downloaded := filepath.Join(extracted, "download.tar.zst")
if err := store.Download(s.ctx, uri, downloaded, checksum, compressed); err != nil {
t.Fatal(err)
}
if err := extractTaskArchivePackage(downloaded, checksum, extracted); err != nil {
t.Fatal(err)
}
if phase != "restore_download_before_install" {
if _, err := installTaskArchiveFiles(m.dir, extracted, task.ID, job.ID, s.execPriv); err != nil {
t.Fatal(err)
}
}
if phase == "restore_database_before_object_delete" || phase == "restore_object_deleted_before_stub" {
if _, err := m.pg.RestoreTaskArchive(job.ID, snapshot, 0); err != nil {
t.Fatal(err)
}
restored = true
}
if phase == "restore_object_deleted_before_stub" {
if err := store.Delete(s.ctx, uri); err != nil {
t.Fatal(err)
}
remoteDeleted = true
}
}
deleting := phase == "delete_journal_before_database" || phase == "delete_database_before_object"
if deleting {
if _, err := m.pg.Exec("UPDATE task_archives SET state=$2 WHERE id=$1", job.ID, pgdb.Deleting); err != nil {
t.Fatal(err)
}
if _, err := s.writeRemoteArchiveJournal(remoteArchiveJournal{ArchiveID: job.ID, URI: uri, Operation: "delete"}); err != nil {
t.Fatal(err)
}
if phase == "delete_database_before_object" {
if err := m.pg.DeleteTaskArchiveStub(job.ID); err != nil {
t.Fatal(err)
}
remoteDeleted = true
}
}
if err := m.pg.RecoverTaskArchiveJobs(); err != nil {
t.Fatal(err)
}
if err := recoverTaskArchiveStages(m.dir, m.pg); err != nil {
t.Fatal(err)
}
if err := recoverTaskArchiveRestoreStages(m.dir, m.pg); err != nil {
t.Fatal(err)
}
if err := s.recoverRemoteArchiveJournals(); err != nil {
t.Fatal(err)
}
wantSource := !committed || restored
data, fileErr := os.ReadFile(source)
if wantSource && (fileErr != nil || string(data) != "original task data") {
t.Fatalf("source data lost: %v", fileErr)
}
if !wantSource && !os.IsNotExist(fileErr) {
t.Fatalf("archived source resurrected: %v", fileErr)
}
if _, err := os.Stat(packagePath); !os.IsNotExist(err) {
t.Fatalf("temporary package remains: %v", err)
}
if _, err := os.Stat(packagePath + ".partial"); !os.IsNotExist(err) {
t.Fatalf("partial package remains: %v", err)
}
if got, want := objects.has(uri), committed && !remoteDeleted; got != want {
t.Fatalf("remote object exists=%v, want=%v", got, want)
}
if committed && !deleting {
actual, err := m.pg.IsTaskArchiveRestored(job.ID)
if err != nil || actual != restored {
t.Fatalf("restored=%v want=%v err=%v", actual, restored, err)
}
}
// A second startup must be harmless at every boundary.
if err := recoverTaskArchiveStages(m.dir, m.pg); err != nil {
t.Fatal(err)
}
if err := recoverTaskArchiveRestoreStages(m.dir, m.pg); err != nil {
t.Fatal(err)
}
if err := s.recoverRemoteArchiveJournals(); err != nil {
t.Fatal(err)
}
})
}
}
type recoveryObjects struct {
mu sync.Mutex
data map[string][]byte
}
func (o *recoveryObjects) put(uri string, data []byte) {
o.mu.Lock()
defer o.mu.Unlock()
// Test URIs always use the fixture bucket with path-style addressing.
o.data["/test/"+uri[len("s3://test/"):]] = append([]byte(nil), data...)
}
func (o *recoveryObjects) has(uri string) bool {
o.mu.Lock()
defer o.mu.Unlock()
if uri == "" {
return false
}
_, ok := o.data["/test/"+uri[len("s3://test/"):]]
return ok
}
func newRecoveryObjectStore(t *testing.T) (*archivestore.Store, *recoveryObjects) {
t.Helper()
objects := &recoveryObjects{data: map[string][]byte{}}
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
objects.mu.Lock()
defer objects.mu.Unlock()
data, exists := objects.data[r.URL.Path]
w.Header().Set("ETag", `"recovery-etag"`)
switch r.Method {
case "PUT":
if r.Header.Get("X-Amz-Server-Side-Encryption") != "AES256" {
t.Error("missing SSE")
}
objects.data[r.URL.Path], _ = io.ReadAll(r.Body)
case "HEAD":
if !exists {
w.WriteHeader(404)
return
}
w.Header().Set("Content-Length", strconv.Itoa(len(data)))
w.Header().Set("X-Amz-Server-Side-Encryption", "AES256")
case "GET":
if !exists {
w.WriteHeader(404)
return
}
var start, end int
if n, err := fmt.Sscanf(r.Header.Get("Range"), "bytes=%d-%d", &start, &end); err != nil || n != 2 || start < 0 || end >= len(data) || r.Header.Get("If-Match") != `"recovery-etag"` {
w.WriteHeader(416)
return
}
w.Header().Set("Content-Length", strconv.Itoa(end-start+1))
w.Header().Set("Content-Range", fmt.Sprintf("bytes %d-%d/%d", start, end, len(data)))
w.WriteHeader(206)
_, _ = w.Write(data[start : end+1])
case "DELETE":
delete(objects.data, r.URL.Path)
w.WriteHeader(204)
default:
t.Errorf("unexpected object request %s", r.Method)
w.WriteHeader(400)
}
}))
t.Cleanup(srv.Close)
store, err := archivestore.New(archivestore.Config{Endpoint: srv.URL, Bucket: "test", Prefix: "tasks", AccessKey: "test", SecretKey: "test", PathStyle: true})
if err != nil {
t.Fatal(err)
}
return store, objects
}
// Neither a rollback conflict nor a temporary-file cleanup failure may discard
// the staging journal: recovery must be safe to retry after the obstruction ends.
func TestArchivePartialRecoveryRetainsJournalOnFailure(t *testing.T) {
if os.Getenv("ARTEX_PG_DSN") == "" {
t.Skip("requires isolated PostgreSQL")
}
for _, failure := range []string{"rollback-conflict", "cleanup-failure"} {
t.Run(failure, func(t *testing.T) {
m, err := NewManager(t.TempDir(), "")
if err != nil {
t.Fatal(err)
}
defer m.Close()
task, err := m.CreateTask("partial recovery "+failure, "retain source", nil, 0, 0)
if err != nil {
t.Fatal(err)
}
id, _ := strconv.ParseInt(task.ID, 10, 64)
defer func() { _, _ = m.pg.Exec("DELETE FROM task_archives WHERE task_id=$1", id); _ = m.pg.DeleteTask(id) }()
if err := m.pg.SetPaused(id, true); err != nil {
t.Fatal(err)
}
job, err := m.pg.QueueTaskArchive(id)
if err != nil {
t.Fatal(err)
}
source := filepath.Join(m.dir, "tasks", task.ID, "workspace", "source.txt")
if err := os.MkdirAll(filepath.Dir(source), 0700); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(source, []byte("original"), 0600); err != nil {
t.Fatal(err)
}
snapshot, err := m.pg.SnapshotTaskArchive(id)
if err != nil {
t.Fatal(err)
}
stage, err := stageTaskArchiveFiles(m.dir, job.ID, task.ID, snapshot.ExplorationID)
if err != nil {
t.Fatal(err)
}
partial := taskArchivePath(m.dir, job.ID, task.ID) + ".partial"
if err := os.MkdirAll(filepath.Dir(partial), 0700); err != nil {
t.Fatal(err)
}
var obstruction string
if failure == "rollback-conflict" {
if len(stage.journal.Moves) == 0 {
t.Fatal("no staged source")
}
obstruction = stage.journal.Moves[0].Source
if err := os.MkdirAll(obstruction, 0700); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(partial, []byte("partial"), 0600); err != nil {
t.Fatal(err)
}
} else {
if err := os.Mkdir(partial, 0700); err != nil {
t.Fatal(err)
}
obstruction = filepath.Join(partial, "block-remove")
if err := os.WriteFile(obstruction, []byte("fixture"), 0600); err != nil {
t.Fatal(err)
}
}
if err := recoverTaskArchiveStages(m.dir, m.pg); err == nil {
t.Fatal("expected recovery obstruction")
}
if _, err := os.Stat(filepath.Join(stage.root, "journal.json")); err != nil {
t.Fatal("lost retry journal", err)
}
if _, err := os.Stat(partial); err != nil {
t.Fatal("removed partial before successful recovery", err)
}
if failure == "cleanup-failure" {
if got, err := os.ReadFile(source); err != nil || string(got) != "original" {
t.Fatal("source was not rolled back", err)
}
}
if err := os.RemoveAll(obstruction); err != nil {
t.Fatal(err)
}
if err := recoverTaskArchiveStages(m.dir, m.pg); err != nil {
t.Fatal(err)
}
if got, err := os.ReadFile(source); err != nil || string(got) != "original" {
t.Fatal("source lost on retry", err)
}
for _, path := range []string{stage.root, partial} {
if _, err := os.Stat(path); !os.IsNotExist(err) {
t.Fatalf("recovery left %s: %v", path, err)
}
}
if err := recoverTaskArchiveStages(m.dir, m.pg); err != nil {
t.Fatal(err)
}
})
}
}
+27
View File
@@ -0,0 +1,27 @@
package server
import (
"encoding/json"
"os"
"testing"
)
// Writing the journal must succeed on every platform the server builds for. It
// needs no database: on Windows the directory sync it ended with failed, so no
// remote archive or remote deletion could start.
func TestRemoteArchiveJournalWrite(t *testing.T) {
s := &Server{m: &Manager{dir: t.TempDir()}}
want := remoteArchiveJournal{ArchiveID: 7, URI: "s3://bucket/tasks/package.tar.zst", LocalPath: "package.tar.zst", Operation: "upload"}
name, err := s.writeRemoteArchiveJournal(want)
if err != nil {
t.Fatal(err)
}
raw, err := os.ReadFile(name)
if err != nil {
t.Fatal(err)
}
var got remoteArchiveJournal
if err := json.Unmarshal(raw, &got); err != nil || got != want {
t.Fatalf("journal content %q: %v", raw, err)
}
}
+29 -10
View File
@@ -193,6 +193,16 @@ func (s *taskArchiveFileStage) rollback() error {
if s == nil || s.done {
return nil
}
err := s.rollbackFiles()
if err == nil {
err = os.RemoveAll(s.root)
}
s.done = true
return err
}
// Keep the journal until the caller has also cleaned temporary packages.
func (s *taskArchiveFileStage) rollbackFiles() error {
var errs []error
for i := len(s.journal.Moves) - 1; i >= 0; i-- {
move := s.journal.Moves[i]
@@ -218,12 +228,6 @@ func (s *taskArchiveFileStage) rollback() error {
errs = append(errs, err)
}
}
if len(errs) == 0 {
if err := os.RemoveAll(s.root); err != nil {
errs = append(errs, err)
}
}
s.done = true
return errors.Join(errs...)
}
@@ -464,18 +468,33 @@ func recoverTaskArchiveStages(dataDir string, pg *pgdb.DB) error {
errs = append(errs, getErr)
continue
}
if archive != nil && archive.State == pgdb.ArchiveReady {
if archive != nil && archive.ArchivePath != "" && archive.SHA256 != "" {
if err := os.RemoveAll(root); err != nil {
errs = append(errs, err)
}
continue
}
stage := &taskArchiveFileStage{root: root, payload: filepath.Join(root, "payload"), journal: journal}
if err := stage.rollback(); err != nil {
if err := stage.rollbackFiles(); err != nil {
errs = append(errs, err)
continue
}
if archive != nil && archive.ArchivePath != "" {
_ = os.Remove(archive.ArchivePath)
// The process can exit after compression but before an upload journal or
// database location exists. Remove that temporary package only after the
// source-file rollback succeeds, for both local and remote backends.
packagePath := taskArchivePath(dataDir, journal.ArchiveID, journal.TaskID)
if err := validateArchivePath(dataDir, packagePath); err != nil {
errs = append(errs, err)
continue
}
// A crash inside compression leaves .partial, before any upload journal.
// Retain this staging journal on cleanup failure so startup can retry.
if err := errors.Join(removeLocalArchivePackage(packagePath), removeLocalArchivePackage(packagePath+".partial")); err != nil {
errs = append(errs, err)
continue
}
if err := os.RemoveAll(root); err != nil {
errs = append(errs, err)
}
}
return errors.Join(errs...)
+131
View File
@@ -0,0 +1,131 @@
package server
import (
"context"
"crypto/rand"
"crypto/sha256"
"io"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strconv"
"strings"
"sync/atomic"
"testing"
"time"
"github.com/Autumn-27/artex/archivestore"
pgdb "github.com/Autumn-27/artex/db"
)
// An S3-compatible endpoint that answers CreateMultipartUpload with 200 and no
// UploadId makes the SDK's upload manager dereference a nil pointer. The panic
// happens in the archive worker goroutine: it must fail that one job like any
// other upload error, keep the source data, and leave the process running.
func TestReview318ArchiveWorkerSurvivesUploadPanic(t *testing.T) {
skipWithoutDSN(t)
t.Setenv("ARTEX_ARCHIVE_STORAGE", "local")
m, err := NewManager(t.TempDir(), "")
if err != nil {
t.Fatal(err)
}
defer m.Close()
ctx, cancel := context.WithCancel(context.Background())
cancel()
s := New(ctx, m, t.TempDir(), t.TempDir(), t.TempDir())
s.archiveWG.Wait()
var creates, unexpected atomic.Int32
remote := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
_, _ = io.Copy(io.Discard, r.Body)
switch {
case r.Method == http.MethodPost && r.URL.Query().Has("uploads"):
creates.Add(1)
w.Header().Set("Content-Type", "application/xml")
_, _ = io.WriteString(w, `<?xml version="1.0" encoding="UTF-8"?><InitiateMultipartUploadResult xmlns="http://s3.amazonaws.com/doc/2006-03-01/"><Bucket>test</Bucket></InitiateMultipartUploadResult>`)
case r.Method == http.MethodDelete:
// The worker's deferred cleanup of the upload that never committed.
w.WriteHeader(http.StatusNoContent)
default:
unexpected.Add(1)
w.WriteHeader(http.StatusBadRequest)
}
}))
defer remote.Close()
s.archiveStore, err = archivestore.New(archivestore.Config{Endpoint: remote.URL, Bucket: "test", Prefix: "tasks", AccessKey: "test", SecretKey: "test", PathStyle: true})
if err != nil {
t.Fatal(err)
}
task, err := m.CreateTask("multipart panic", "keep the source", nil, 0, 0)
if err != nil {
t.Fatal(err)
}
id, _ := strconv.ParseInt(task.ID, 10, 64)
defer func() { _, _ = m.pg.Exec(`DELETE FROM task_archives WHERE task_id=$1`, id); _ = m.pg.DeleteTask(id) }()
if err := m.pg.SetPaused(id, true); err != nil {
t.Fatal(err)
}
// The package must exceed the 8 MiB part size of archivestore.Upload for the
// upload manager to choose multipart: 9 MiB of random bytes do not compress.
source := make([]byte, 9<<20)
if _, err := rand.Read(source); err != nil {
t.Fatal(err)
}
file := filepath.Join(m.dir, "tasks", task.ID, "workspace", "large.bin")
if err := os.MkdirAll(filepath.Dir(file), 0700); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(file, source, 0600); err != nil {
t.Fatal(err)
}
job, err := m.pg.QueueTaskArchive(id)
if err != nil {
t.Fatal(err)
}
// Run the server's own worker goroutine, as New starts it.
workerCtx, stopWorker := context.WithCancel(context.Background())
s.ctx = workerCtx
s.startTaskArchiveWorker()
defer func() { stopWorker(); s.archiveWG.Wait() }()
deadline := time.Now().Add(2 * time.Minute)
var item *pgdb.TaskArchive
for {
item, err = m.pg.GetTaskArchive(job.ID)
if err != nil {
t.Fatal(err)
}
if item == nil {
t.Fatal("archive job disappeared")
}
if item.State != pgdb.ArchiveQueued && item.State != pgdb.Archiving {
break
}
if time.Now().After(deadline) {
t.Fatalf("archive job still %s (%s)", item.State, item.Phase)
}
time.Sleep(50 * time.Millisecond)
}
if creates.Load() != 1 {
t.Fatalf("expected one CreateMultipartUpload, got %d: the package did not take the multipart path", creates.Load())
}
if item.State != pgdb.ArchiveFailed || !strings.Contains(item.Error, "panic") {
t.Fatalf("job must be archive_failed with the panic as its error: state=%s error=%q", item.State, item.Error)
}
if item.ArchivePath != "" || item.SHA256 != "" || item.ArchivedAt != nil {
t.Fatalf("a location was committed for a failed archive: path=%q sha256=%q archived_at=%v", item.ArchivePath, item.SHA256, item.ArchivedAt)
}
got, err := os.ReadFile(file)
if err != nil || sha256.Sum256(got) != sha256.Sum256(source) {
t.Fatalf("source file lost or changed after the panic: %v", err)
}
if pgTask, err := m.pg.GetTask(id); err != nil || pgTask == nil {
t.Fatalf("task lost after the panic: %v", err)
}
if unexpected.Load() != 0 {
t.Fatalf("%d unexpected S3 requests", unexpected.Load())
}
}
+163
View File
@@ -0,0 +1,163 @@
package server
import (
"encoding/json"
"errors"
"fmt"
"log"
"os"
"path/filepath"
"strings"
pgdb "github.com/Autumn-27/artex/db"
)
// An outbox bridges the local PostgreSQL transaction and object storage. Never
// delete the only package before metadata permits it. Unfinished cleanup is
// retried after a restart (and before subsequent jobs).
type remoteArchiveJournal struct {
ArchiveID int64 `json:"archive_id"`
URI string `json:"uri"`
LocalPath string `json:"local_path,omitempty"`
Operation string `json:"operation"`
}
func (s *Server) validateStoredArchive(uri string) error {
if strings.HasPrefix(uri, "s3://") {
return s.archiveStore.Validate(uri)
}
return validateArchivePath(s.m.dir, uri)
}
func removeLocalArchivePackage(filename string) error {
if err := os.Remove(filename); err != nil && !os.IsNotExist(err) {
return err
}
return nil
}
func (s *Server) removeStoredArchive(uri string) error {
if err := s.validateStoredArchive(uri); err != nil {
return err
}
if strings.HasPrefix(uri, "s3://") {
return s.archiveStore.Delete(s.ctx, uri)
}
return removeLocalArchivePackage(uri)
}
func (s *Server) writeRemoteArchiveJournal(j remoteArchiveJournal) (string, error) {
dir := filepath.Join(taskArchiveRoot(s.m.dir), ".remote")
if err := os.MkdirAll(dir, archiveDirMode); err != nil {
return "", err
}
f, err := os.CreateTemp(dir, ".journal-")
if err != nil {
return "", err
}
tmp := f.Name()
defer os.Remove(tmp)
encodeErr := json.NewEncoder(f).Encode(j)
syncErr := f.Sync()
if err := errors.Join(encodeErr, syncErr, f.Close()); err != nil {
return "", err
}
name := tmp + ".json"
if err := os.Rename(tmp, name); err != nil {
return "", err
}
// Persist the directory entry before an upload or database deletion starts.
if err := syncDir(dir); err != nil {
return "", err
}
// The .remote directory itself may have just been created.
return name, syncDir(filepath.Dir(dir))
}
func (s *Server) recoverRemoteArchiveJournals() error {
dir := filepath.Join(taskArchiveRoot(s.m.dir), ".remote")
entries, err := os.ReadDir(dir)
if os.IsNotExist(err) {
return nil
}
if err != nil {
return err
}
var errs []error
for _, entry := range entries {
if entry.IsDir() || !strings.HasSuffix(entry.Name(), ".json") {
continue
}
name := filepath.Join(dir, entry.Name())
if err := s.recoverRemoteArchiveJournal(name); err != nil {
errs = append(errs, err)
}
}
return errors.Join(errs...)
}
func (s *Server) recoverRemoteArchiveJournal(name string) error {
raw, err := os.ReadFile(name)
if err != nil {
return err
}
var j remoteArchiveJournal
if err := json.Unmarshal(raw, &j); err != nil {
return err
}
if j.ArchiveID <= 0 {
return errors.New("invalid remote archive journal ID")
}
if err := s.archiveStore.Validate(j.URI); err != nil {
return err
}
item, err := s.m.pg.GetTaskArchive(j.ArchiveID)
if err != nil {
return err
}
switch j.Operation {
case "upload":
if item == nil || item.ArchivePath != j.URI {
if err := s.archiveStore.Delete(s.ctx, j.URI); err != nil {
return err
}
}
if err := validateArchivePath(s.m.dir, j.LocalPath); err != nil {
return err
}
// An old failed upload may outlive a retry after switching back to
// local storage. The retry reuses this pathname: keep its committed
// package instead of treating it as the old upload's temporary copy.
if item == nil || item.ArchivePath != j.LocalPath {
if err := removeLocalArchivePackage(j.LocalPath); err != nil {
return err
}
}
case "delete":
if item == nil {
if err := s.archiveStore.Delete(s.ctx, j.URI); err != nil {
return err
}
}
default:
return fmt.Errorf("unknown remote archive operation %q", j.Operation)
}
return os.Remove(name)
}
func (s *Server) deleteRemoteTaskArchive(job *pgdb.TaskArchive) error {
journal, err := s.writeRemoteArchiveJournal(remoteArchiveJournal{ArchiveID: job.ID, URI: job.ArchivePath, Operation: "delete"})
if err != nil {
return err
}
if err := s.m.pg.DeleteTaskArchiveStub(job.ID); err != nil {
// A connection failure can leave the transaction's commit ambiguous.
// Recovery consults PostgreSQL before deciding whether to delete.
return err
}
if err := s.recoverRemoteArchiveJournal(journal); err != nil {
// The task is gone; the durable outbox retries the remaining object cleanup.
log.Printf("[task-archive] archive %d deleted; remote cleanup pending: %v", job.ID, err)
}
return nil
}
+419
View File
@@ -0,0 +1,419 @@
package server
import (
"bytes"
"context"
"errors"
"fmt"
"io"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strconv"
"strings"
"sync"
"sync/atomic"
"testing"
"github.com/Autumn-27/artex/archivestore"
pgdb "github.com/Autumn-27/artex/db"
)
func TestRemoteArchiveLifecycle(t *testing.T) {
if os.Getenv("ARTEX_PG_DSN") == "" {
t.Skip("requires isolated PostgreSQL")
}
t.Setenv("ARTEX_ARCHIVE_STORAGE", "local")
m, err := NewManager(t.TempDir(), "")
if err != nil {
t.Fatal(err)
}
defer m.Close()
ctx, cancel := context.WithCancel(context.Background())
cancel()
s := New(ctx, m, t.TempDir(), t.TempDir(), t.TempDir())
s.archiveWG.Wait()
s.ctx = context.Background()
var mu sync.Mutex
objects := map[string][]byte{}
corrupt, failDelete := false, false
remote := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
mu.Lock()
defer mu.Unlock()
switch r.Method {
case "PUT":
objects[r.URL.Path], _ = io.ReadAll(r.Body)
w.Header().Set("ETag", `"test"`)
case "HEAD":
w.Header().Set("X-Amz-Server-Side-Encryption", "AES256")
w.Header().Set("ETag", `"test"`)
w.Header().Set("Content-Length", strconv.Itoa(len(objects[r.URL.Path])))
case "GET":
data := objects[r.URL.Path]
if corrupt && len(data) > 0 {
data = bytes.Clone(data)
data[0] ^= 0xff
}
var start, end int64
if n, err := fmt.Sscanf(r.Header.Get("Range"), "bytes=%d-%d", &start, &end); err != nil || n != 2 || start < 0 || end < start || end >= int64(len(data)) || r.Header.Get("If-Match") != `"test"` {
w.WriteHeader(http.StatusRequestedRangeNotSatisfiable)
return
}
w.Header().Set("ETag", `"test"`)
w.Header().Set("Content-Length", strconv.FormatInt(end-start+1, 10))
w.Header().Set("Content-Range", fmt.Sprintf("bytes %d-%d/%d", start, end, len(data)))
w.WriteHeader(http.StatusPartialContent)
_, _ = w.Write(data[start : end+1])
case "DELETE":
if failDelete {
w.WriteHeader(403)
return
}
delete(objects, r.URL.Path)
w.WriteHeader(204)
default:
w.WriteHeader(400)
}
}))
defer remote.Close()
s.archiveStore, err = archivestore.New(archivestore.Config{Endpoint: remote.URL, Bucket: "test", Prefix: "tasks", AccessKey: "test", SecretKey: "test", PathStyle: true})
if err != nil {
t.Fatal(err)
}
task, err := m.CreateTask("S3 round trip", "preserve data", nil, 0, 0)
if err != nil {
t.Fatal(err)
}
id, _ := strconv.ParseInt(task.ID, 10, 64)
defer func() { _, _ = m.pg.Exec(`DELETE FROM task_archives WHERE task_id=$1`, id); _ = m.pg.DeleteTask(id) }()
if err := m.pg.SetPaused(id, true); err != nil {
t.Fatal(err)
}
file := filepath.Join(m.dir, "tasks", task.ID, "workspace", "important.txt")
if err := os.MkdirAll(filepath.Dir(file), 0700); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(file, []byte("keep this content"), 0600); err != nil {
t.Fatal(err)
}
pgTask, err := m.pg.GetTask(id)
if err != nil {
t.Fatal(err)
}
if _, err := m.pg.Exploration(pgTask.ExplorationID).AppendActivity(pgdb.Activity{Worker: "system", Kind: "system", Summary: "archive proof"}); err != nil {
t.Fatal(err)
}
job, err := m.pg.QueueTaskArchive(id)
if err != nil {
t.Fatal(err)
}
// A configured-but-invalid backend must fail before moving any source data.
s.archiveStoreErr = errors.New("invalid fixture configuration")
if err := s.runOneTaskArchiveJob(); !errors.Is(err, s.archiveStoreErr) {
t.Fatalf("configuration error was not returned: %v", err)
}
if got, err := os.ReadFile(file); err != nil || string(got) != "keep this content" {
t.Fatalf("bad configuration lost source: %v", err)
}
if pgTask, err := m.pg.GetTask(id); err != nil || pgTask == nil {
t.Fatal("bad configuration lost task", err)
}
s.archiveStoreErr = nil
if _, err := m.pg.QueueTaskArchive(id); err != nil {
t.Fatal(err)
}
// A corrupt readback must roll back filesystem staging and leave PG intact.
mu.Lock()
corrupt = true
mu.Unlock()
if err := s.runOneTaskArchiveJob(); err == nil {
t.Fatal("expected integrity failure")
}
if got, _ := os.ReadFile(file); string(got) != "keep this content" {
t.Fatal("upload failure lost source")
}
if task, err := m.pg.GetTask(id); err != nil || task == nil {
t.Fatal("upload failure lost task")
}
mu.Lock()
corrupt = false
mu.Unlock()
if err := s.recoverRemoteArchiveJournals(); err != nil {
t.Fatal(err)
}
if _, err := m.pg.QueueTaskArchive(id); err != nil {
t.Fatal(err)
}
if err := s.runOneTaskArchiveJob(); err != nil {
t.Fatal(err)
}
job, err = m.pg.GetTaskArchive(job.ID)
if err != nil {
t.Fatal(err)
}
if job.State != pgdb.ArchiveReady || job.Storage != "s3" || !strings.HasPrefix(job.ArchivePath, "s3://") {
t.Fatalf("unexpected archive %+v", job)
}
if _, err := os.Stat(file); !os.IsNotExist(err) {
t.Fatal("workspace not released")
}
if _, err := os.Stat(taskArchivePath(m.dir, job.ID, task.ID)); !os.IsNotExist(err) {
t.Fatal("local package retained")
}
// Simulate the crash window after commit: cleanup keeps the remote object.
journal, err := s.writeRemoteArchiveJournal(remoteArchiveJournal{ArchiveID: job.ID, URI: job.ArchivePath, LocalPath: taskArchivePath(m.dir, job.ID, task.ID), Operation: "upload"})
if err != nil {
t.Fatal(err)
}
if err := s.recoverRemoteArchiveJournal(journal); err != nil {
t.Fatal(err)
}
// A corrupted download must leave the archive and its remote package intact.
mu.Lock()
corrupt = true
mu.Unlock()
if _, err := m.pg.QueueTaskArchiveRestore(job.ID); err != nil {
t.Fatal(err)
}
if err := s.runOneTaskArchiveJob(); err == nil {
t.Fatal("expected corrupted restore to fail")
}
if _, err := os.Stat(file); !os.IsNotExist(err) {
t.Fatal("corrupted archive installed workspace files")
}
if restored, err := m.pg.IsTaskArchiveRestored(job.ID); err != nil || restored {
t.Fatalf("corrupted archive restored database: %v %v", restored, err)
}
mu.Lock()
if len(objects) == 0 {
t.Error("corrupted restore deleted the only remote package")
}
corrupt = false
mu.Unlock()
// Restoration commits files and PG first. Failed remote deletion is retryable.
mu.Lock()
failDelete = true
mu.Unlock()
if _, err := m.pg.QueueTaskArchiveRestore(job.ID); err != nil {
t.Fatal(err)
}
if err := s.runOneTaskArchiveJob(); err == nil {
t.Fatal("expected remote delete failure")
}
if got, _ := os.ReadFile(file); string(got) != "keep this content" {
t.Fatal("restored content differs")
}
if restored, err := m.pg.IsTaskArchiveRestored(job.ID); err != nil || !restored {
t.Fatalf("PG restore %v %v", restored, err)
}
mu.Lock()
failDelete = false
mu.Unlock()
if _, err := m.pg.QueueTaskArchiveRestore(job.ID); err != nil {
t.Fatal(err)
}
if err := s.runOneTaskArchiveJob(); err != nil {
t.Fatal(err)
}
if item, err := m.pg.GetTaskArchive(job.ID); err != nil || item != nil {
t.Fatal("restore did not consume stub")
}
var count int
if err := m.pg.QueryRow(`SELECT count(*) FROM activity WHERE exploration_id=$1 AND summary='archive proof'`, pgTask.ExplorationID).Scan(&count); err != nil || count != 1 {
t.Fatalf("activity restore count=%d err=%v", count, err)
}
// Re-archive, then crash/retry the deletion outbox after PG removed its stub.
job, err = m.pg.QueueTaskArchive(id)
if err != nil {
t.Fatal(err)
}
if err := s.runOneTaskArchiveJob(); err != nil {
t.Fatal(err)
}
mu.Lock()
failDelete = true
mu.Unlock()
if _, err := m.pg.QueueTaskArchiveDelete(job.ID); err != nil {
t.Fatal(err)
}
if err := s.runOneTaskArchiveJob(); err != nil {
t.Fatal(err)
}
mu.Lock()
failDelete = false
mu.Unlock()
if err := s.recoverRemoteArchiveJournals(); err != nil {
t.Fatal(err)
}
mu.Lock()
remaining := len(objects)
mu.Unlock()
if remaining != 0 {
t.Fatalf("left %d objects", remaining)
}
}
// Once PostgreSQL has committed an archive location and checksum, a subsequent
// queued operation must not make startup recovery resurrect the old workspace.
func TestTaskArchiveStageRecoveryAfterCommit(t *testing.T) {
if os.Getenv("ARTEX_PG_DSN") == "" {
t.Skip("requires isolated PostgreSQL")
}
m, err := NewManager(t.TempDir(), "")
if err != nil {
t.Fatal(err)
}
defer m.Close()
task, err := m.CreateTask("remote stage recovery", "test", nil, 0, 0)
if err != nil {
t.Fatal(err)
}
taskID, _ := strconv.ParseInt(task.ID, 10, 64)
defer func() {
_, _ = m.pg.Exec("DELETE FROM task_archives WHERE task_id=$1", taskID)
_ = m.pg.DeleteTask(taskID)
}()
if err := m.pg.SetPaused(taskID, true); err != nil {
t.Fatal(err)
}
job, err := m.pg.QueueTaskArchive(taskID)
if err != nil {
t.Fatal(err)
}
pgTask, err := m.pg.GetTask(taskID)
if err != nil {
t.Fatal(err)
}
for _, backend := range []string{"local", "s3"} {
for _, state := range []string{pgdb.ArchiveReady, pgdb.RestoreQueued, pgdb.DeleteQueued, pgdb.ArchiveQueued} {
t.Run(backend+"/"+state, func(t *testing.T) {
committed := state != pgdb.ArchiveQueued
checksum := ""
if committed {
checksum = strings.Repeat("a", 64)
}
packagePath := taskArchivePath(m.dir, job.ID, task.ID)
if err := os.MkdirAll(filepath.Dir(packagePath), 0700); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(packagePath, []byte("verified package"), 0600); err != nil {
t.Fatal(err)
}
location := packagePath
if backend == "s3" {
location = "s3://test/tasks/package.tar.zst"
}
if _, err := m.pg.Exec("UPDATE task_archives SET state=$2,archive_path=$3,sha256=$4 WHERE id=$1", job.ID, state, location, checksum); err != nil {
t.Fatal(err)
}
file := filepath.Join(m.dir, "tasks", task.ID, "workspace", "remaining.txt")
if err := os.MkdirAll(filepath.Dir(file), 0700); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(file, []byte("retain until commit"), 0600); err != nil {
t.Fatal(err)
}
stage, err := stageTaskArchiveFiles(m.dir, job.ID, task.ID, pgTask.ExplorationID)
if err != nil {
t.Fatal(err)
}
if err := recoverTaskArchiveStages(m.dir, m.pg); err != nil {
t.Fatal(err)
}
if _, err := os.Stat(stage.root); !os.IsNotExist(err) {
t.Fatalf("staging cleanup incomplete: %v", err)
}
if backend == "local" && committed {
if data, err := os.ReadFile(packagePath); err != nil || string(data) != "verified package" {
t.Fatal("committed local package lost", err)
}
} else if !committed {
if _, err := os.Stat(packagePath); !os.IsNotExist(err) {
t.Fatal("uncommitted temporary package retained", err)
}
}
if committed {
if _, err := os.Stat(file); !os.IsNotExist(err) {
t.Fatalf("resurrected committed workspace: %v", err)
}
} else if data, err := os.ReadFile(file); err != nil || string(data) != "retain until commit" {
t.Fatalf("uncommitted archive lost source: %v", err)
}
})
}
}
}
// Failed remote cleanup can survive switching to local storage and retrying the
// same archive ID. Its journal must never remove the newly committed local copy.
func TestRemoteArchiveJournalPreservesLocalRetry(t *testing.T) {
if os.Getenv("ARTEX_PG_DSN") == "" {
t.Skip("requires isolated PostgreSQL")
}
m, err := NewManager(t.TempDir(), "")
if err != nil {
t.Fatal(err)
}
defer m.Close()
task, err := m.CreateTask("local retry", "test", nil, 0, 0)
if err != nil {
t.Fatal(err)
}
taskID, _ := strconv.ParseInt(task.ID, 10, 64)
defer func() {
_, _ = m.pg.Exec("DELETE FROM task_archives WHERE task_id=$1", taskID)
_ = m.pg.DeleteTask(taskID)
}()
if err := m.pg.SetPaused(taskID, true); err != nil {
t.Fatal(err)
}
job, err := m.pg.QueueTaskArchive(taskID)
if err != nil {
t.Fatal(err)
}
filename := taskArchivePath(m.dir, job.ID, task.ID)
if err := os.MkdirAll(filepath.Dir(filename), 0700); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filename, []byte("committed local archive"), 0600); err != nil {
t.Fatal(err)
}
if _, err := m.pg.Exec("UPDATE task_archives SET state=$2,archive_path=$3,sha256=$4 WHERE id=$1", job.ID, pgdb.ArchiveReady, filename, strings.Repeat("a", 64)); err != nil {
t.Fatal(err)
}
var deletes atomic.Int32
remote := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodDelete {
w.WriteHeader(http.StatusMethodNotAllowed)
return
}
deletes.Add(1)
w.WriteHeader(http.StatusNoContent)
}))
defer remote.Close()
store, err := archivestore.New(archivestore.Config{Endpoint: remote.URL, Bucket: "test", Prefix: "tasks", AccessKey: "test", SecretKey: "test", PathStyle: true})
if err != nil {
t.Fatal(err)
}
s := &Server{ctx: context.Background(), m: m, archiveStore: store}
journal, err := s.writeRemoteArchiveJournal(remoteArchiveJournal{
ArchiveID: job.ID, URI: store.URI(taskID, job.ID, strings.Repeat("b", 64)),
LocalPath: filename, Operation: "upload",
})
if err != nil {
t.Fatal(err)
}
if err := s.recoverRemoteArchiveJournal(journal); err != nil {
t.Fatal(err)
}
if data, err := os.ReadFile(filename); err != nil || string(data) != "committed local archive" {
t.Fatalf("old upload cleanup removed local retry: %v", err)
}
if deletes.Load() != 1 {
t.Fatal("uncommitted remote object was not removed")
}
if _, err := os.Stat(journal); !os.IsNotExist(err) {
t.Fatalf("finished journal remains: %v", err)
}
}

Some files were not shown because too many files have changed in this diff Show More