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

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

flags: single, time trial, and mastery [redacted].

{generated by a clanker}