2026-10-26

Day 26: Crash Course

Lane: Binary reverse engineering. 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. The watcher ran the driver first. run_tm.py got accepted (partial), so the watcher flagged the lane: NEEDS MANUAL SOLVER (new wrinkle). A helper agent then took the binary lane.
  2. Extended solve_tm.py (commit b1e1234: "Adds corrected/vulnerable variant handling and crash triage fields (crash_fault_method, crash_frames_match_methods) to solve_tm.py"):
  1. d26 config and method count used code that already existed: the JAR constant-pool / Base64 search for the config, and the Day 7 method-count handler for method_count.
  2. Re-checked on the Day 29 copy of the d26 JAR (static parse only):
Day26Variant000.class constant pool #10, 508-char Base64 -> HCFG key=0xb1 crc32=0xfd5b48eb campaign BR26-000
method_count 10: ['<init>', 'stageThree', 'stageTwo', 'stageOne', 'main', '$getStaticMetaClass',
                  'getMetaClass', 'setMetaClass', '$getLookup', 'getEncodedConfig']
frames: stageThree, stageTwo, stageOne  -> all are methods

Answers: d26_analysis_crash_fault_method = stageThree, d26_analysis_crash_frames_match_methods = true, d26_analysis_method_count = 10, XOR key 0xb1, CRC32 0xfd5b48eb.

  1. Submitted all 312 answers (answers.json). Result: CORRECT.
  2. Time Trial: a fresh variant with random-style config values (campaign BR26-28A9CA8B, XOR key 0xeb). The crash answers were the same (stageThree, true, 10). Result: CORRECT.
  3. Mastery: ten deliveries (3,120 answers), same steps. Result: CORRECT.

Results

ModeResultFlag
Single SolveCORRECT3337ff19975d604eabe9028e0cb479c7
Time TrialCORRECT0563cda7be20a70abb9654cfa12e0d02
MasteryCORRECT298942b79d0625051372b6fd0dbc9109

Each mode folder has the raw start-response.json, answers.json, submit-response.json and final-status-response.json. The evidence zips were not saved.

Note: single-solve/final-status-response.json is a copy of the start response (no result field). The Single Solve result and flag are in single-solve/submit-response.json.

Reproduce

The Day 26 bundles were not saved. The d26 JAR can be checked from the Day 29 folder (from this folder):

X=../day-29-binary-reverse-engineering-fraternal-twins/single-solve/extracted
sha256sum $X/d26--sample.jar      # cb614301…, same as d26_artifact_sha256_1
unzip -p $X/d26--sample.jar crash/trace.json

(The JAR itself is a normal zip; only the outer evidence.zip uses AES.)

Live driver:

python3 -I ~/.config/huntress/solvers/run_tm.py binary-reverse-engineering-day-26-crash-triage single_solve /tmp/d26

This needs a Game Master token in ~/.config/huntress/gm-token. Nothing here runs the samples.

Day 26: Before You Go

Lane: Metadata forensics. 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

Two agents worked this lane at the same time: the watcher's headless agent and a fork from the main session. The headless agent's log (agent-day26.log) only says the metadata lane finished 3/3; its step-by-step transcript is not among the saved logs. The steps below follow the Prefetch parser saved in the solvers folder that morning (prefetch_solve.py) and the main-session fork's notes. The fork computed the same answers in parallel, but by the time it submitted, the Game Master said already_solved.

  1. Prefetch format.
  1. The parser, prefetch_solve.py (saved that morning in ~/.config/huntress/solvers/):
if data[:3] == b'MAM':
    data = lzxpress_huffman.decompress(data[8:])          # from dissect.util
if struct.unpack('<I', data[4:8])[0] != 0x41434353:        # 'SCCA'
    return None
exe = data[16:76].decode('utf-16le', errors='replace').split('\x00')[0]
  1. Single Solve. trace-001.pf → CMD.EXE. CORRECT.
  2. Time Trial (31 fields). The fork ran run_meta.py first. It answered 28; it had no handler yet for the EVTX count, the registry root or the Prefetch name. Those three were computed with small parsers:

Saved Time Trial answers include trace-001.pf = UPDATER.EXE, EVTX count 60, registry root X5cVJDCagE55vnY, LNK target E:\Program Files\Common Files\nectar-82kvv8.exe and APK package io.delta.batch.

  1. Gotchas the fork hit:
  1. Mastery (310 fields). Prefetch names per set, from answers.json: COBALT10.EXE, FALCON35.EXE, NECTAR72.EXE, TUNDRA95.EXE, CACHESVC.EXE, SYNCAGENT.EXE, MEADOW7.EXE, MAILCLIENT.EXE, EMBER74.EXE, SESSIONHOST.EXE. CORRECT.

Results

ModeResultFlag
Single SolveCORRECT02963fc62fa1d5d153076cc29132f3f5
Time TrialCORRECTb47eb52c0a30de19cc96a4c672f9fec6
MasteryCORRECT7b21facbe98c52c3b4ede5129095509f

Reproduce

python3 -I ~/.config/huntress/solvers/prefetch_solve.py trace-001.pf
python3 -I ~/.config/huntress/solvers/run_meta.py metadata-forensics-day-26-before-you-go single_solve /tmp/d26

The first line only needs the extracted .pf; it prints every parsed field as JSON. The second needs a Game Master token in ~/.config/huntress/gm-token; the current driver calls prefetch_solve for this field. For time_trial and mastery it calls op=retry first, which spends one of the unique attempts.

Day 26: Split Decision

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.

  1. The driver failed at the drop. The watcher ran run_mode.py for Single Solve at 07:00 local time. It logged single=no-output -> NEEDS MANUAL SOLVER (new wrinkle). The second session (below) found why on its bundle: the driver looks for assets/huntress_puzzle.json at the top of the zip, but in a .apks bundle it sits inside base.apk.
  2. The headless day agent took over and solved all three modes. Two puzzle variants were seen:
  1. Mastery mixed single-APK analysis variants (direct smali analysis), reflection-based dispatch (packed-switch + Class.forName → Method.invoke), and the split bundle.
  2. Results: all three modes came back CORRECT. The agent committed the answers and responses at 07:10 local time.

Same day, second session

A second session worked on the Time Trial in parallel. Its notes show the v2 chain in detail:

Results

ModeResultFlag
Single SolveCORRECTad8de19f08bc8f82ab1baac588f4689b
Time TrialCORRECT07191fd87dc721d581edacda925442ea
MasteryCORRECT3bd172e8385b964192929558d580c389

Saved answers: Single Solve ANS-7E37D134754DEA01, Time Trial ANS-2DF27FDEEFEF5A67. The ten Mastery answers are in mastery/answers.json. Each submit-response.json holds only the result and flag.

Reproduce

Not recorded. The Day 26 split handling was not saved as its own tool, and no saved command replays this day end to end.

What the later tools/ copies do for bundles (read from the code):

None of these tools install or run an app on a device.

Day 26: Mixed Signals

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. The lane ran as a parallel fork. That day the main session launched one fork per lane. Each fork started the Single Solve, solved it, then did the Time Trial and Mastery. The day log records: "Script Analysis 'Mixed Signals' done — 3/3".
  2. Single Solve. solve_day26.py is named for this day. Its header calls it the "Day-26 'Mixed Signals' comprehensive solver" for all question families: PowerShell samples, JScript, Batch, VBScript, Python, Bash (including advanced files), Node.js, host and polyglot. It combines the earlier pieces:

The Single Solve was solved at 13:09:50 UTC. Real answers for one of the new Erlang files:

{"polyglot-erlang-launcher-role": "launcher", "polyglot-erlang-launcher-attack": "T1059",
 "polyglot-erlang-launcher-adapter": "process_builder", "polyglot-erlang-launcher-campaign": "ERLANG-f282709b",
 "polyglot-erlang-launcher-obfuscation": "plain_hex",
 "polyglot-erlang-launcher-stage-profile": "single_descriptor",
 "polyglot-erlang-launcher-next-language": "batch",
 "host-elixir-phoenix-elixir-role": "staged_chain"}
  1. Time Trial (solved 13:10:47 UTC) and Mastery used the Day 23 hash-named format. The record does not say which solver produced these answers. In the toolchain, solve_day23.py is the one written for that format. solve_day26.py does not handle powershell-<hash> IDs or the style, indicator and campaign-token fields.
  2. The saved submit files: Single Solve and Time Trial say already_solved (they were re-submitted after the first solve). Mastery's submit-response.json is the short {"result": "CORRECT", "flag": ...} reply.

Results

ModeResultFlag
Single SolveCORRECT6a5603fb62c9599b796f3fa974a5f83b
Time TrialCORRECT92b931d5d77cb984c510ff6c4bd1e4e8
MasteryCORRECT59d0f02626c00a92f6f5859fa8cb6816

Flag sources: Single Solve from single-solve/final-status-response.json, Mastery from mastery/submit-response.json. The Time Trial flag is not in this folder. It comes from the progress record shown in session d263b3bc (script-analysis → time_trial). This folder had no README before this one. No screenshots were taken.

Reproduce

The archives were not kept, so the saved answers cannot be rebuilt offline. On a fresh attempt, extract the archive and run:

# role-named layout (Single Solve)
python3 -I tools/solve_day26.py /tmp/d26/ex start-response.json /tmp/d26/answers.json
# hash-named layout (Time Trial, or one Mastery set)
python3 -I tools/solve_day23.py /tmp/d26tt/ex start-response.json /tmp/d26tt/answers.json

Then submit with a Game Master token. Both solvers try node jsdec.js first (the jsdec.js next to them) and fall back to jsdec_py_emu.py. The tools/jsdec.js copy decodes statically. The ~/.config/huntress/solvers/ copy runs the fixture in a Node vm sandbox.

Day 26: Food for Thought

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. Brainfuck esoteric language. Interpret the ><+-.,[] program; the output is the plaintext.
  2. Mastery blobs use multiple encodings from Days 1-26. 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 26 — Trust the Webhook (Webhook Forgery)

Lane: Web Exploitation · Challenge ID: web-exploitation-day-19-trust-the-webhook

> The app believes every event it's told about. Tell it a convincing enough story and watch it act on your forged news.

What we were given

A live Starlette web target with a webhook dispatch endpoint.

How it was solved

Webhook forgery — the application's event handler accepts and processes forged webhook events without verifying their authenticity.

  1. Queried /api/clues. It disclosed the dispatch route (e.g. /dispatch-3940be), the expected event type (case.promoted), and the owner scope (executive).
  2. The key insight was the field name mismatch: /api/clues describes the event as event_type and scope as owner_scope, but the actual dispatch handler expects event, owner, and role. Using the clue field names in the POST body gets rejected — you need the handler's actual schema.
  3. Sent the forged webhook event:
POST /dispatch-3940be
Content-Type: application/json

{"event": "case.promoted", "owner": "executive", "role": "executive"}
  1. The handler consumed the forged event without signature verification and returned effect: forged_event_consumed with the proof.

Root cause: The webhook endpoint has no request authentication — no HMAC signature, no shared secret, no IP allowlist. Any HTTP client can POST events that the application trusts and acts on. The field name mismatch between the clue API and the handler is a red herring that slows down attackers who don't fuzz the actual schema.

Mastery — mixed targets (4/4)

TargetVulnerability
1Archive/backup disclosure via robots.txt
2IDOR — reference-only case accessible via session
3SQL injection in search form
4Webhook forgery (same technique as above)

Results

ModeResultFlag
Single SolveCORRECT2e0be98399b1e48732ae381f459de1fc
Time TrialCORRECTa666fb2257846c064801893a3d198b8e
Mastery (4/4)CORRECT824b76f9a95586af9b7d4e10b80e3bb9

Day 26 — Serialized Offender (Insecure Deserialization)

Lane: Web Exploitation · Challenge ID: web-exploitation-day-20-serialized-offender

> The session cookie remembers too much — and trusts what it remembers. Tamper with the serialized state and make it execute your version of events.

What we were given

A live Quarkus (Java) web target with client-side session state.

How it was solved

Insecure deserialization — the application stores session state client-side as a serialized object and trusts it without integrity verification.

  1. Queried /api/state-format — it documented the session state format: base64url-encoded JSON containing user identity and role.
  2. Decoded the current session state: {"user": "analyst", "role": "analyst"}.
  3. Forged a new state with elevated privileges: {"user": "analyst", "role": "administrator"}.
  4. Base64url-encoded the forged JSON and POSTed it to the feature route.
  5. The server deserialized and trusted the forged state without verifying a signature. It accepted the administrator role and returned the proof.

Root cause: Client-side session state is stored as unsigned serialized data. Without an HMAC or digital signature, an attacker can decode, modify, and re-encode the state to escalate privileges. The /api/state-format endpoint documents the encoding, making the attack trivial.

Mastery — mixed targets (4/4)

TargetAppVulnerability
1Tiny UptimeBackup disclosure — robots.txt → /snapshots-*/ → .json.bak
2Incident PicnicIDOR — /api/timeline leaks foreign case ID
3Signal ShelfSQL injection — /explore?q= injectable
4Object Post (Quarkus)Insecure deserialization of forged session state

Results

ModeResultFlag
Single SolveCORRECTfa9aa82decda8976c31a921d7f4d7b22
Time TrialCORRECT99b3ca4d55f6947c5920636a84653054
Mastery (4/4)CORRECT52385ffb169435aa51365a7be71ac244

Day 26 — Trust the Webhook

See the full writeup at ../day-26-web-exploitation-trust-the-webhook/.

This folder is a duplicate. The canonical writeup and data are in the linked folder.