full stack incident: an unsigned worker walks the whole stack
huntress ctf 2026, day 31 · web exploitation · three modes
tools used: live web target capture, saved web inspection, and timed attempt pipeline.
the target presented itself as an actix web analyst workspace with a request log, a dispatch route, an audit route, a worker route and a response route. its clue document named every route and the field names that matter. the request log carried one fetch that was queued and unsigned, and the whole solution was to reproduce that fetch, dispatch the worker it named, read the incident it produced, and post a detector and repair in the shape the target's own schema described.
challenge shape
single and time trial each assigned one temporary target and one answer. mastery assigned several targets and answer ids. each assignment rotated every route suffix and the host. the answer for each target was the proof string the target's response route returned once the detector and repair were posted in the disclosed shape.
artifact anatomy
the useful artifact was the saved sequence of http responses. the clue document named the feature route (/dispatch-087881 on the captured instance), a request log route, a secondary audit route (/audit-cd855d), an evidence route, a response route, a final worker route (/worker-c5716b), and the field names fetch_query_field, worker_query_field and event_json_field — target, command and token.
the request log held three records: two signed fetches allowed for public targets, and one fetch queued with signed: false and a target of 38fa9180e8d4. the evidence route answered 409 until the incident it described had been reproduced, and the response route answered 409 until a detector and repair were posted.
extraction method
the unsigned queued record is the incident. its target value is the event token.
def capture(c):
c.get("/api/clues")
clues = c.rows[-1].json
c.get(clues["request_log_route"])
tok = next(r["target"] for r in c.rows[-1].json["records"]
if r["signed"] is False)
c.get(clues["feature_route"], params={"target": tok}) # 202 fetch_event_created
c.post_json(clues["secondary_route"], {"token": tok}) # 202 worker_dispatched
c.get(clues["final_route"], params={"command": "status"})
c.get(clues["final_route"], params={"command": "cat objective"})
c.get(clues["evidence_route"]) # 200: the schema
c.post_json(clues["response_route"], {
"detector": {"kind": "worker.dispatch", "signed": False},
"repair": {"block_internal_fetch": True,
"require_signed_event": True,
"worker_allowlist": ["status"]},
})
the dispatch route creates the fetch event for the queued target. the audit route verifies the event — it accepts exactly {"token": <the queued fetch's target>} and answers 202 with the worker's available commands (status, cat <resource>) and its resources (objective). the worker route answers status as a signed, allowed check, and cat objective as an unsigned dispatch: that is the incident. the evidence route then answers 200 with the event list, a regression goal, and a response schema (detector: {kind, signed}, repair: {block_internal_fetch, require_signed_event, worker_allowlist}). posting a detector for the unsigned worker dispatch and a repair that blocks internal fetches, requires signed events and allows the benign status command answers 200 with the proof and every regression check true: attack detected, benign status excluded, internal fetch blocked, status still allowed, unsigned event rejected.
validation and answer formatting
every request stayed on the assigned origin. the field names come from the clue document and rotate with the assignment, so nothing carries forward. the audit route rejects any payload with more than the token key, answering event_not_verified, which separates the verification step from the remediation step. the response route answers incident_not_ready until the worker has run the unsigned command, so a 409 names the missing step. the proof had to appear in this target's response before it was submitted for this target's answer id.
failed approaches and pivots
the forwarding-header sweep was a dead end: the dispatch route answered signed_fetch_required for every spoofed address header. posting detector and repair payloads to the audit route failed as event_not_verified, because that route verifies the event and never accepts a remediation. the worker rejected help, list and other guessed commands with 403; only the commands the audit response disclosed are real. the target also keeps state between runs, so a capture that starts with the evidence route already at 200 is a resumed instance; a fresh target serves the 409s until the incident is reproduced.
automation across modes
the solver walks the clue document's field names, picks the unsigned queued record from the request log, dispatches and audits it, harvests the worker's command set from the audit response, runs each concrete command and each <resource> substitution on the worker route, reads the evidence route's schema, and posts the detector and repair in that shape. the same code resolved single, time trial and mastery targets without a per-instance edit, because every route and field name is read from the current target.
lessons
- a request log's unsigned queued record is the incident to reproduce, and its target value is the token the rest of the flow verifies.
- a route that answers 409 until a step completes is a state machine that names its own next step; read the error, not a guess.
- when a route discloses a response schema, the winning payload is the schema's shape filled with the incident you just read.
solve times
public scoreboard · day 31 finish: below top 10
- 6:23.2single#48 of 118 solvers
- 6:30.2time trial#43 of 113 solvers
- 6:45.9mastery#19 of 98 solvers
- #14team day finishof 90 teams that cleared it, in 10:51.3
- #6single orderof the day's 7, by our flag time
from the public scoreboard: 09:00 et release to our flag; the table below counts from our attempt's start.
the table measures from the first local work on the mode to recorded team completion.
| mode | work to flag | local attempts | wrong submits |
|---|---|---|---|
| single | about 380s | 1 | 0 |
| time trial | about 5s | 1 | 0 |
| mastery | about 14s | 1 | 0 |
the clock
the winning timed attempts' assignment deadlines were not preserved in the local record.
| mode | time available | time used | time left |
|---|---|---|---|
| time trial | not recorded | not recorded | not recorded |
| mastery | not recorded | not recorded | not recorded |
where we got stuck
- the audit route was treated as the remediation route for several rounds of probes, because its 403 named the event and not the payload shape; its 202 disclosed the worker's command set, which was the actual next step.
- the chain looked like a header-trust problem at first, since the dispatch route's 403 named a signed fetch; the signature was in the request log record, not a header.
flags: single, time trial, and mastery [redacted].
{generated by a clanker}