2026-10-25
Day 25: Out of Bounds
Lane: Binary reverse engineering. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT (300/300, 300/300, 2,700/2,700).
The challenge
- ID:
binary-reverse-engineering-day-25-synthetic-vulnerability-root-cause - Name: ⚙️ Out of Bounds
- Prompt: "Somewhere in here, the code reaches where it shouldn't. Prove the bounds error is real, trace its reachability, and compare against the corrected twin that learned its limits."
What we were given
- One
evidence.zipper set. AES encrypted, passwordinfected. None were saved in this folder. - The bundle mixes ELF, PE, .NET, WebAssembly and JAR samples: the files
d01tod24again, plus the newd25pair. - New today: two builds of a Clojure program, as JARs (manifest:
Created-By: Huntress deterministic Clojure factory): …vulnerable.jarand…corrected.jar.- Each holds
day25/<name>__init.class,$_main,$fn__269,$loading__6812__auto____267,$parse_frameand the main class. - Each sample hides an
HCFGconfig record (XOR-encoded, CRC32-checked).
What was asked
- 300 questions in Single Solve and Time Trial. Mastery had nine sets, so 2,700.
- Question types:
- Format and metadata: format tokens, machine, CLR version, and so on for
d01tod24. - Config:
campaign,domain,mutex,url(and CRC32 / key where asked) for every specimen. - d25 (new), like d24 on Day 24:
vulnerable_format,corrected_format, the commonconfig_*fields, andcorrected_config_*. - No question scored the bounds bug itself.
How it was solved, start to finish
- The watcher ran the driver first.
run_tm.pygotaccepted(partial), so the watcher flagged the lane:NEEDS MANUAL SOLVER (new wrinkle). - Ran
solve_tm.pyby hand on the Single Solve zip (copied asdelivery-1.zip). It answered 288 of 300. The 12 it could not handle were thecorrected_…/vulnerable_…fields for d24 and d25 (4 formats + 8 corrected-config fields). The solver did not know those selectors yet. - Found the d25 config. In each JAR the
…__init.classconstant pool holds a 508-character Base64 string that startsSENGRwGh…. That is Base64 forHCFG, version 1, key0xa1.
- The manual decode brute-forced the XOR key (0–255) and kept the one that gave
{"campaign". That key is0xa1, the same as byte 5 of the record. - Decoded: campaign
BR25-000, domainnode-000.day25.example.invalid.
- Filled the 12 fields: format
jarfor all four, and the decoded configs for the corrected builds. Submitted all 300. Result:CORRECT. - Time Trial:
solve_tm.pyagain gave 288. The first quick extraction of the JAR blobs failed ("no HCFG blob found"). It searched for printable strings, and a printable byte in front of the Base64 spoils the match. In the d25 JAR the byte just before the Base64 is the length byte0x24($), so the string came out as$SENGR…. The Game Master answeredaccepted(partial) twice.- The fix: parse the class-file constant pool properly. The entry count is at bytes 8–9 and the entries start at byte 10. Walk them by tag and read each UTF-8 entry by its length.
- With the parser, the d24 and d25 configs decoded (this variant used random-style values, such as campaign
BR25-8DD4428A). All 300 answers:CORRECT.
- Mastery: a helper agent ran
solve_tm.pyon the nine deliveries (2,592 base answers), then used the constant-pool parser for the d24/d25 JAR fields in every set. All 2,700:CORRECT. - Solver update (commit
8e86ef2, "fix solve_tm.py constant pool offset for HCFG extraction from JARs"):solve_tm.pynow walks each class's constant pool from byte 10 and Base64-decodes UTF-8 constants longer than 80 that start withSENGRorHCFG\x01. Day 24's blob sits in the Scala$.class; Day 25's sits in the__init.class.
Re-check of the d25 JARs saved in the Day 29 folder (byte-identical to the d25 JARs in the Day 26 bundle), with the parser from step 5:
d25--sample-vulnerable.jar day25/vulnerable000__init.class cp#66 len=508 key=0xa1 crc32=0xeeaafb35 BR25-000
d25--sample-corrected.jar day25/corrected000__init.class cp#66 len=508 key=0xa1 crc32=0xeeaafb35 BR25-000
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT (300/300) | 424d1cf674a6a94c1925b99f3a4228dd |
| Time Trial | CORRECT (300/300) | 351af52b1a175dc2ba642ca3ec105bf1 |
| Mastery | CORRECT (2,700/2,700) | 9e42b0ac6cba41cb2c3a33877e381dae |
No Game Master files were saved in this folder. The flags come from the Game Master status calls recorded by checkpoint.py (sync_from_gm) in ~/.config/huntress/progress.json. The steps above come from the session log, the watcher log and commit 8e86ef2.
Reproduce
The Day 25 bundles were not saved. The d25 JARs can be checked from the Day 29 folder. The parser used for the re-check is short:
SKIP = {3: 4, 4: 4, 9: 4, 10: 4, 11: 4, 12: 4, 17: 4, 18: 4, 7: 2, 8: 2, 16: 2, 19: 2, 20: 2, 15: 3, 5: 8, 6: 8}
count = struct.unpack_from('>H', cf, 8)[0] # cf = bytes of one .class file; count at bytes 8-9
off, i = 10, 1 # entries start at byte 10
while i < count:
tag = cf[off]; off += 1
if tag == 1: # UTF-8 entry: 2-byte length + bytes
ln = struct.unpack_from('>H', cf, off)[0]; s = cf[off+2:off+2+ln]; off += 2 + ln
if ln > 80 and s[:5] == b'SENGR': # Base64 text that decodes to b'HCFG...'
rec = base64.b64decode(s + b'=' * (-len(s) % 4))
key = rec[5]; plen, crc = struct.unpack_from('<HI', rec, 6)
payload = bytes(b ^ key for b in rec[12:12+plen])
if zlib.crc32(payload) == crc: print(json.loads(payload)['campaign'])
else:
off += SKIP[tag]
if tag in (5, 6): i += 1 # long/double use two slots
i += 1
Live driver:
python3 -I ~/.config/huntress/solvers/run_tm.py binary-reverse-engineering-day-25-synthetic-vulnerability-root-cause single_solve /tmp/d25
This needs a Game Master token in ~/.config/huntress/gm-token. Nothing here runs the samples.
Day 25: Hive Mind
Lane: Metadata forensics. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT (3/3).
The challenge
- ID:
metadata-forensics-day-25-hive-mind - Prompt: "Registry hives from multiple systems have been renamed and separated from host labels. Identify each true root, regroup the systems, and isolate the planted hive."
What we were given
- Single Solve: one zip with
hive-001.hiv(8,192 bytes). - Time Trial:
evidence.zipwith one file of each type so far: notes and roster, JPEG, PNG, PDF, zip, PE, .NET DLL, MSI, LNK, DOCX, EML, WAV, MP4, ELF, Mach-O, APK, JAR, SQLite, EVTX and, new today,hive-001.hiv. - Mastery:
metadata-forensics-day-25-hive-mind-mastery.zip(SHA-256a92607d2ad3f8bfce02362d27aed27821aaaa53150998169be4d7ca6ee1e9c1c). Nine inner zips,evidence-01.ziptoevidence-09.zip. - New today: Windows registry hive files.
What was asked
- Single Solve: 1 question:
registry.hive_root_nameforhive-001.hiv(answer IDd25-registry-001-registry-hive-root-name). - Time Trial: 30 questions. Mastery: 270 (9 sets × 30).
- Question types: file identity, image/PDF/ZIP headers, PE fields, .NET MVID, MSI
ProductCode, LNK target, DOCX external links, emailMessage-ID, audio codec, video size, ELF machine, Mach-O CPU set, APK package, JARMain-Class, SQLite page size, EVTX record count, SHA-256 ordering, plus the new registry root key name.
How it was solved, start to finish
- Single Solve: read the root key by hand. A hive starts with
regf. The offset of the root key cell is a 4-byte value at0x24. Cells start at0x1000, so the cell is at0x1000 + 0x20. Its size is-112(negative means "in use"). Thenkkey record starts 4 bytes into the cell.
- First try read the name at the wrong offset and got
\x00\x00HuntressArtifactAssemblyLi. - Fixed: the name length is the 2-byte value at
nk + 0x48(here 28). The name starts atnk + 0x4C.
root = struct.unpack_from('<I', data, 0x24)[0]
nk = 0x1000 + root + 4
n = struct.unpack_from('<H', data, nk + 0x48)[0]
name = data[nk + 0x4c : nk + 0x4c + n].decode('ascii') # HuntressArtifactAssemblyLine
Submitted HuntressArtifactAssemblyLine. CORRECT.
- Time Trial, first try: answers lost.
run_meta.pyanswered 28 of 30. It had no EVTX or registry handler. The two missing answers were computed by hand and sent, but they landed on the wrong attempt. Root cause: for timed modesrun_meta.pycallsop=retryitself, which creates a new attempt. So answers sent to the earlier attempt were orphaned. - Time Trial fix: one script, one attempt. A helper agent wrote one self-contained script that does
op=retryonce, downloads and extracts the evidence, computes all 30 answers and submits them together. It reusedrun_meta.py's handlers and added two:
- EVTX, chunk-aware: skip the 4,096-byte file header. Each 64 KiB chunk starts with
ElfChnk. Records start at chunk + 512. Each record starts with2a2a0000; its size is the next 4 bytes, so step from record to record.
pos = 0x1000
while data[pos:pos+7] == b'ElfChnk':
rpos = pos + 512
while rpos < pos + 65536 and data[rpos:rpos+4] == b'\x2a\x2a\x00\x00':
size = struct.unpack_from('<I', data, rpos + 4)[0]
if size < 24 or size > 65536: break
count += 1; rpos += size
pos += 65536
- Registry root name: the reader from step 1.
Attempt 93fa1ba9-48de-4c14-acc3-0fd932d17e41: 30 of 30 answered, CORRECT on the first submit.
- Mastery, first try. A helper agent built the same kind of self-contained solver for 9 sets (attempt
8ed20849-edbc-4363-894a-e03ba1f605a7). All 270 were computed, but the Game Master saidincorrect. - Found the bad field with the partial-submit oracle. Submitting part of the answers returns
acceptedif all of those are right, orincorrectif any is wrong.
- Per set: sets 1, 4 and 7 were
incorrect; the restaccepted. - Halving inside those sets pointed to one field:
evidence-note-filename. It returned the copy's name, for exampleevidence-note-copy-ffbcb3.txtinstead ofevidence-note-f7448a.txt. - Fix: for that field, match names with "note" but not "copy".
- Mastery, second try. Retried for a fresh attempt (
711c737c-3066-4376-b563-867c6ea46689), recomputed all 270 and submitted.CORRECT.
Example mastery answers from answers.json: set 1 d25-registry-001-registry-hive-root-name = Nc4AhSLBRWvCqH1HcmkuRvrR9J, set 1 d24-evtx-001-evtx-record-count = 47, set 1 synthesis = ["evidence-note-f7448a.txt","macos-001.bin","evidence-drop-001.zip","hive-001.hiv","document-15-001.docx"].
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | a4b4ba6b954337ebf838ee4b4b749df1 |
| Time Trial | CORRECT | 29ee8ce64f9bd1e5883af37518dcee39 |
| Mastery | CORRECT | 8164617104482861c095168414aa6840 |
- This folder only has
mastery/start-response.json(from the first mastery attempt) and the finalmastery/answers.json. - The flags come from the Day 25 summary in this repo (
day-25/results.jsonat the repo root) and the solve logs. - No screenshots were captured.
Reproduce
The Day 25 one-off scripts are not in this repo or in tools/. Their handlers were later added to the main driver (Day 28), so the current driver covers every Day 25 field:
python3 -I ~/.config/huntress/solvers/run_meta.py metadata-forensics-day-25-hive-mind single_solve /tmp/d25
This needs a Game Master token in ~/.config/huntress/gm-token. For time_trial and mastery it calls op=retry first, which spends one of the unique attempts, so don't start a separate attempt by hand. Note: the driver's EVTX handler is the plain 2a2a0000 count, not the chunk-aware walk above. It only parses the files.
Day 25: Integrity Signals
Lane: Mobile (Android). Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
mobile-android-day-25-integrity-signals - Prompt: "Forge or replay a bounded challenge-owned integrity statement and explain the missing binding."
What we were given
- Android APKs (about 12 KB each) that implement challenge-response integrity attestation.
- Single Solve: case
MOB-25-EBF6E537E5, packagecom.huntress.mobile.d25.vebf6e537e531. - Time Trial: one APK.
- Mastery: nine APKs, one per case, from Days 1, 4, 7, 10, 14, 16, 19, 22 and 25.
- No files were saved in this folder. The facts here come from the session logs, the watcher log and the checkpoint file.
What was asked
- One question per case: return the exact backend answer code for that case.
- Answer format:
ANS-plus exactly 16 uppercase hex characters. - Answer IDs:
answerfor Single Solve and Time Trial.set1.answertoset9.answerfor Mastery.
How it was solved, start to finish
No app was installed or run. The run_mode.py + smali_analysis.py pipeline did all three modes.
- Single Solve and Time Trial at the drop. The watcher saw Day 25 at 07:00:12 local time and ran the mobile lane driver. Its log line:
[OK] mobile-android single=CORRECT(f8a977885e564cd30a1e6a8f483a8ed8) TT=CORRECT mastery=no-output
So Single Solve and Time Trial were CORRECT 12 seconds after the drop. The Mastery run gave no output (the cause was not recorded).
- Looked inside a Mastery APK. A helper agent read the strings in the set 1 DEX. It found:
- a local evidence URL (
http://127.0.0.1:19090/mobile/attempt/.../evidence?case_id=) withclient_secretandproof=parameters, - classes
Release,Mix,Core,Guard,ProbeandUtil, - method names such as
finTrust60,gateReachf5,mixGrant01andsealCaller90, - the string
ANS-and the codec nameanalysis.
That is the same Release.code() pattern as Day 23, which the existing tools already handle.
- Ran the driver on Mastery:
cd ~/.config/huntress/solvers
python3 -I run_mode.py mobile-android-day-25-integrity-signals mastery mobile_puzzle /tmp/huntress-day25/mobile/mastery-solve/
For each of the nine APKs it disassembles the DEX with baksmali, interprets Release.code() in the small smali VM, and collects the ANS- code. Then it submits all nine at once.
- Result. The driver printed:
{"mode": "mastery", "n": 9, "result": "CORRECT", "flag": "e4be18012a6a93c42f8819ed68d23892", "remaining": null, "missing": []}
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | f8a977885e564cd30a1e6a8f483a8ed8 |
| Time Trial | CORRECT | 7a93055d3e4ae2f50b799b5f3f1bd543 |
| Mastery | CORRECT | e4be18012a6a93c42f8819ed68d23892 |
The flags were not saved in this folder. They come from the repo file day-25/results.json and the checkpoint file ~/.config/huntress/progress.json (they match). No answer codes were saved.
Reproduce
python3 -I ~/.config/huntress/solvers/run_mode.py mobile-android-day-25-integrity-signals single_solve mobile_puzzle /tmp/d25
This needs a Game Master token in ~/.config/huntress/gm-token, plus Java (for baksmali.jar) and binutils. It disassembles the DEX and evaluates Release.code() in Python. It never installs or runs the app on a device.
Day 25: Ashes to Assets
Lane: Script analysis. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
script-analysis-day-25-phoenix-stage-chain(the folder name comes from this ID; the Game Master title is "📜 Ashes to Assets"). - Prompt: "Configuration starts out in Elixir source and has changed shape by the time an inert Phoenix-hosted stage picks it up. Follow every transformation, reconcile each one with earlier campaign artifacts, and find the setting that didn't survive the rebirth."
What we were given
- One password-protected
evidence.zipper mode (passwordinfected). - Two layouts, both seen before:
- Single Solve: the role-named layout from
Day 24: PowerShell*-sample.ps1files, the per-language behavioral scripts, and host and polyglot files. New today: Elixir, including an Elixir host for the "Phoenix-hosted stage". - Time Trial and Mastery: the hash-named layout from
Day 23(powershell-<hash>-...IDs, layeredLYRmarkers). - Only
mastery/answers.jsonwas kept in this folder. The archives and Game Master JSON were not.
What was asked
- Single Solve: 1,571 questions.
- Time Trial: 1,625 questions.
- Mastery: 14,625 questions in 9 sets of 1,625. Per set: PowerShell 9, JScript 63, Batch 63, VBScript 63, Python 107, Bash 102, Node.js 48, polyglot 1,170 (from the saved
mastery/answers.json). - Polyglot questions per file: role, ATT&CK, steps, stage count, stage profile, obfuscation, next language, campaign, campaign token, URL, file path, URL host and path leaf.
How it was solved, start to finish
- Matched the format to a solver. The Single Solve questions follow the Day 24 layout, and the Time Trial questions follow Day 23. The first idea was the Day 23 solver plus the Day 24 one for descriptors. In the end
solve_day24.pyanswered all 1,571 Single Solve questions by itself, and the submit wasCORRECT(13:12:21 UTC). - Time Trial:
solve_day23.pyanswered all 1,625 questions, and the submit wasCORRECT(13:13:46 UTC). - Mastery ran in a parallel fork. Each set was routed to a solver by its question-ID format. All 9 saved sets use the Day 23 format. The 14,625 answers were submitted together, and the submit was
CORRECT(13:26:57 UTC). - What the two solvers do (from their code):
solve_day24.py: decodesHUNTRESS_ANALYSIS_V1markers (B64,HEX,FRAG,HB64,SPLIT), reads the PowerShell Base64 JSON descriptors, and runs the per-language decoders for behavioral scripts. Role and ATT&CK come from the steps.solve_day23.py: the same per-language decoders for hash-named files, plus the layeredLYRmarker decode (b64,b32,hex,rev,frag, undone last layer first) and the derived fields (URL host, path leaf, campaign token).
- Real Mastery answers for one Elixir polyglot (
mastery/answers.json):
{"set1.polyglot-elixir-a7470f-role": "dropper",
"set1.polyglot-elixir-a7470f-attack": "T1140",
"set1.polyglot-elixir-a7470f-steps": "transmit_remote>dispatch_process",
"set1.polyglot-elixir-a7470f-stage-count": "2",
"set1.polyglot-elixir-a7470f-stage-profile": "amber_braid",
"set1.polyglot-elixir-a7470f-obfuscation": "b32_rev",
"set1.polyglot-elixir-a7470f-next-language": "swift",
"set1.polyglot-elixir-a7470f-campaign": "ELIXIR-d495187f",
"set1.polyglot-elixir-a7470f-campaign-token": "d495187f"}
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | e5fc0cdc4af6fd6e2f214f49e27dc44d |
| Time Trial | CORRECT | eaa4e2abb13bae841fb6633950d64142 |
| Mastery | CORRECT | 4e1e01c55a2f041fc8e8175b9a951152 |
The flags and solve times come from the day summary at day-25/results.json in this repo. This folder only keeps mastery/answers.json. No screenshots were taken.
Reproduce
The archives were not kept, so nothing here can be rebuilt offline. On a fresh attempt, extract the archive and run the solver that matches the question format:
# role-named layout (Single Solve)
python3 -I tools/solve_day24.py /tmp/d25/ex start-response.json /tmp/d25/answers.json
# hash-named layout (Time Trial, or one Mastery set)
python3 -I tools/solve_day23.py /tmp/d25tt/ex start-response.json /tmp/d25tt/answers.json
Then submit with a Game Master token. Both solvers call node jsdec.js for JScript, using the jsdec.js next to them. The tools/ copy of jsdec.js decodes statically. The ~/.config/huntress/solvers/ copy runs the fixture in a Node vm sandbox.
Day 25: You Have a Point
Lane: Warmups. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
warmups-day-25 - Prompt: "Every character has a point. A code point, anyway."
- New encoding: Unicode code points
What we were given
- One blob file per mode (Single Solve and Time Trial), or a zip of multiple blobs (Mastery).
- Each blob has numbered lines (
NN<TAB>fragment). Each line is independently encoded. - The decoded text ends with a slug like
word-word-word-NNto submit.
How it was solved
- Decode the blob. Space-separated
U+XXXXtokens. Convert each hex code point to its character. - Mastery blobs use multiple encodings from Days 1-25. The solver (
warmup_decode.py) tries every known decoder on each line and picks the one producing printable text. - Concatenate all decoded lines. The text contains a message ending in the answer slug.
- Submit the slug to the Game Master.
Results
- Single Solve:
CORRECT. slug:brave-beacon-wizard-34. Flag:99dba443b9767bd8b4b6a5d5f054328b. - Time Trial:
CORRECT. slug:droll-sparrow-badger-61. Flag:a8638c4c2e7fabb191c76dd11da32101. - Mastery:
CORRECT. 123 slugs. Flag:04e42156bf4f83d3dbd78afb491f48a4.
Day 25 — Reset Expectations (Password Reset Exploitation)
Lane: Web Exploitation · Challenge ID: web-exploitation-day-16-reset-expectations
> The password reset form trusts you to tell it where to send things. Redirect the reset where it shouldn't go.
What we were given
A live web target with a password reset flow.
How it was solved
Password reset host header injection — the application uses the HTTP Host header to build the reset URL, letting an attacker redirect the token to a controlled domain.
- Located the password reset endpoint and triggered a reset for the target account.
- The application constructs the reset link using the
Hostheader from the incoming request. By injecting a controlled hostname (e.g.Host: attacker.example.com), the generated reset email/link pointed to the attacker's domain instead of the real app. - In the CTF context, the application simulated a victim clicking the attacker-controlled link, leaking the reset token. Using that token completed the password reset and granted access to the proof.
Root cause: The password reset endpoint trusts the Host header (or X-Forwarded-Host) to construct outgoing URLs without hardcoding or validating the application's own hostname. This is a well-known vulnerability class (CWE-601 / password reset poisoning).
Mastery — mixed targets (4/4)
Mastery bundled different vulnerability types: IDOR, grep injection, SQL injection, and the password reset exploitation.
Results
| Mode | Result |
|---|---|
| Single Solve | CORRECT |
| Time Trial | CORRECT |
| Mastery (4/4) | CORRECT |
Day 25 — Resolver Revolt (GraphQL Exploitation)
Lane: Web Exploitation · Challenge ID: web-exploitation-day-17-resolver-revolt
> The API spoke too freely about its own schema. Ask the right questions and it'll hand over what it shouldn't.
What we were given
A live web target with a GraphQL API endpoint.
How it was solved
GraphQL introspection and excessive data exposure — the schema is fully discoverable and resolvers lack authorization.
- Located the GraphQL endpoint (via
/api/cluesor common paths like/graphql). - Sent an introspection query:
{ __schema { types { name fields { name } } } }. Introspection was enabled, returning the complete API schema — every type, field, and relationship. - The schema revealed fields not exposed through the normal UI, including ones containing sensitive data.
- Queried the hidden fields directly. The resolvers returned the data without checking permissions — the proof was in a restricted field accessible to any query.
Root cause: GraphQL introspection is enabled in production, revealing the full attack surface. Resolver functions don't enforce per-field authorization, so any field present in the schema is queryable by any client regardless of role.
Mastery — mixed targets (4/4)
| Target | App | Vulnerability |
|---|---|---|
| 1 | Status Sprout | robots.txt → directory listing → backup file |
| 2 | Pocket SOC | IDOR via session cookie on executive case |
| 3 | Search Party | SQL injection in search form |
| 4 | Query Constellation | GraphQL introspection on hidden endpoint |
Results
| Mode | Result |
|---|---|
| Single Solve | CORRECT |
| Time Trial | CORRECT |
| Mastery (4/4) | CORRECT |
Day 25 — Shell Company (Command Injection)
Lane: Web Exploitation · Challenge ID: web-exploitation-day-18-shell-company
> The web form runs your input a little too literally. Inject a command and read what you shouldn't.
What we were given
A live web target with input fields that pass data to OS commands.
How it was solved
OS command injection — user input is concatenated into a shell command without sanitization, allowing arbitrary command execution.
- Identified the injection point — a form parameter or API field that the server passes to a system command.
- The application executes something like
grep <user_input> /path/to/dataor similar. No escaping or quoting of the input. - Injected a command separator followed by a file-read command: e.g.
; cat /run/huntress/objective.txtappended to the input field. - The server executed both the intended command and the injected one, returning the proof file contents in the response.
Root cause: The application constructs shell commands by string concatenation of user input. Without input validation, escaping, or use of parameterized command execution (e.g. subprocess with a list instead of a shell string), attackers can chain arbitrary commands.
Mastery — mixed targets (4/4)
| Target | App | Vulnerability |
|---|---|---|
| 1 | Green Light | robots.txt → exposed archive → env backup with proof |
| 2 | Pocket SOC | IDOR on restricted case via activity feed |
| 3 | Archive Atlas | Grep injection via search parameter |
| 4 | Command Counter | Path traversal + command injection via Gin /execute endpoint |
Results
| Mode | Result |
|---|---|
| Single Solve | CORRECT |
| Time Trial | CORRECT |
| Mastery (4/4) | CORRECT |