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

What we were given

What was asked

How it was solved, start to finish

  1. The watcher ran the driver first. run_tm.py got accepted (partial), so the watcher flagged the lane: NEEDS MANUAL SOLVER (new wrinkle).
  2. Ran solve_tm.py by hand on the Single Solve zip (copied as delivery-1.zip). It answered 288 of 300. The 12 it could not handle were the corrected_… / vulnerable_… fields for d24 and d25 (4 formats + 8 corrected-config fields). The solver did not know those selectors yet.
  3. Found the d25 config. In each JAR the …__init.class constant pool holds a 508-character Base64 string that starts SENGRwGh…. That is Base64 for HCFG, version 1, key 0xa1.
  1. Filled the 12 fields: format jar for all four, and the decoded configs for the corrected builds. Submitted all 300. Result: CORRECT.
  2. Time Trial:
  1. Mastery: a helper agent ran solve_tm.py on 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.
  2. Solver update (commit 8e86ef2, "fix solve_tm.py constant pool offset for HCFG extraction from JARs"): solve_tm.py now walks each class's constant pool from byte 10 and Base64-decodes UTF-8 constants longer than 80 that start with SENGR or HCFG\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

ModeResultFlag
Single SolveCORRECT (300/300)424d1cf674a6a94c1925b99f3a4228dd
Time TrialCORRECT (300/300)351af52b1a175dc2ba642ca3ec105bf1
MasteryCORRECT (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

What we were given

What was asked

How it was solved, start to finish

  1. 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 at 0x24. Cells start at 0x1000, so the cell is at 0x1000 + 0x20. Its size is -112 (negative means "in use"). The nk key record starts 4 bytes into the cell.
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.

  1. Time Trial, first try: answers lost. run_meta.py answered 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 modes run_meta.py calls op=retry itself, which creates a new attempt. So answers sent to the earlier attempt were orphaned.
  2. Time Trial fix: one script, one attempt. A helper agent wrote one self-contained script that does op=retry once, downloads and extracts the evidence, computes all 30 answers and submits them together. It reused run_meta.py's handlers and added two:
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

Attempt 93fa1ba9-48de-4c14-acc3-0fd932d17e41: 30 of 30 answered, CORRECT on the first submit.

  1. 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 said incorrect.
  2. Found the bad field with the partial-submit oracle. Submitting part of the answers returns accepted if all of those are right, or incorrect if any is wrong.
  1. 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

ModeResultFlag
Single SolveCORRECTa4b4ba6b954337ebf838ee4b4b749df1
Time TrialCORRECT29ee8ce64f9bd1e5883af37518dcee39
MasteryCORRECT8164617104482861c095168414aa6840

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

What we were given

What was asked

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.

  1. 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).

  1. Looked inside a Mastery APK. A helper agent read the strings in the set 1 DEX. It found:

That is the same Release.code() pattern as Day 23, which the existing tools already handle.

  1. 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.

  1. Result. The driver printed:
{"mode": "mastery", "n": 9, "result": "CORRECT", "flag": "e4be18012a6a93c42f8819ed68d23892", "remaining": null, "missing": []}

Results

ModeResultFlag
Single SolveCORRECTf8a977885e564cd30a1e6a8f483a8ed8
Time TrialCORRECT7a93055d3e4ae2f50b799b5f3f1bd543
MasteryCORRECTe4be18012a6a93c42f8819ed68d23892

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

What we were given

What was asked

How it was solved, start to finish

  1. 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.py answered all 1,571 Single Solve questions by itself, and the submit was CORRECT (13:12:21 UTC).
  2. Time Trial: solve_day23.py answered all 1,625 questions, and the submit was CORRECT (13:13:46 UTC).
  3. 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).
  4. What the two solvers do (from their code):
  1. 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

ModeResultFlag
Single SolveCORRECTe5fc0cdc4af6fd6e2f214f49e27dc44d
Time TrialCORRECTeaa4e2abb13bae841fb6633950d64142
MasteryCORRECT4e1e01c55a2f041fc8e8175b9a951152

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

What we were given

How it was solved

  1. Decode the blob. Space-separated U+XXXX tokens. Convert each hex code point to its character.
  2. 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.
  3. Concatenate all decoded lines. The text contains a message ending in the answer slug.
  4. Submit the slug to the Game Master.

Results

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.

  1. Located the password reset endpoint and triggered a reset for the target account.
  2. The application constructs the reset link using the Host header 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.
  3. 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

ModeResult
Single SolveCORRECT
Time TrialCORRECT
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.

  1. Located the GraphQL endpoint (via /api/clues or common paths like /graphql).
  2. Sent an introspection query: { __schema { types { name fields { name } } } }. Introspection was enabled, returning the complete API schema — every type, field, and relationship.
  3. The schema revealed fields not exposed through the normal UI, including ones containing sensitive data.
  4. 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)

TargetAppVulnerability
1Status Sproutrobots.txt → directory listing → backup file
2Pocket SOCIDOR via session cookie on executive case
3Search PartySQL injection in search form
4Query ConstellationGraphQL introspection on hidden endpoint

Results

ModeResult
Single SolveCORRECT
Time TrialCORRECT
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.

  1. Identified the injection point — a form parameter or API field that the server passes to a system command.
  2. The application executes something like grep <user_input> /path/to/data or similar. No escaping or quoting of the input.
  3. Injected a command separator followed by a file-read command: e.g. ; cat /run/huntress/objective.txt appended to the input field.
  4. 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)

TargetAppVulnerability
1Green Lightrobots.txt → exposed archive → env backup with proof
2Pocket SOCIDOR on restricted case via activity feed
3Archive AtlasGrep injection via search parameter
4Command CounterPath traversal + command injection via Gin /execute endpoint

Results

ModeResult
Single SolveCORRECT
Time TrialCORRECT
Mastery (4/4)CORRECT