2026-10-26
Day 26: Crash Course
Lane: Binary reverse engineering. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
binary-reverse-engineering-day-26-crash-triage - Prompt: "It crashed. That's the good news — the dump is a confession. Unwind the stack, find the faulting instruction, and triage what went wrong from the wreckage."
What we were given
- One
evidence.zip(SHA-256fd52a098241e1d9b99c54da530b9185a29dc8269ee56edc3d36c237f2381b1e3). AES encrypted, passwordinfected. It was not saved in this folder. - The earlier files again:
d01tod25. - New today:
d26, a Groovy program packed as a JAR (manifest:Created-By: Huntress deterministic Groovy factory). It holds: Day26Variant000.class(the main class) andDay26Variant000$_main_closure1.class;crash/trace.json, a saved crash:{"schema":"huntress.synthetic_crash.v1","kind":"IllegalStateException","frames":["stageThree","stageTwo","stageOne"]}.- The d26 JAR is byte-identical (SHA-256
cb614301…) to thed26JAR saved in the Day 29 folder, so it can still be checked.
What was asked
- 312 questions in Single Solve and Time Trial. Mastery had ten deliveries, so 3,120.
- Question types:
- Hashes: SHA-256 of each member.
- d01 to d25: the same questions as Day 25, including the d24/d25
corrected_…/vulnerable_…fields. - d26 (new):
- format token, XOR key,
HCFGversion, the config fields and the CRC32 (config from a Base64 constant in the main class); method_count: how many methods the main class has;crash_fault_method: the first name in theframeslist ofcrash/trace.json;crash_frames_match_methods: true when every frame name is a method of the main class.
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). A helper agent then took the binary lane. - Extended
solve_tm.py(commitb1e1234: "Adds corrected/vulnerable variant handling and crash triage fields (crash_fault_method, crash_frames_match_methods) to solve_tm.py"):
- Selectors:
correctedandvulnerablewere added to the field-name selectors. Fields liked25_analysis_corrected_config_campaignnow use the matching JAR on their own. This closed the gap that needed hand work on Days 24 and 25. - Crash fault method: open the JAR, parse
crash/trace.json, returnframes[0]. - Frames match: read the main class's method table with the class-file parser and check that every frame name is in it.
- 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. - 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.
- Submitted all 312 answers (
answers.json). Result:CORRECT. - Time Trial: a fresh variant with random-style config values (campaign
BR26-28A9CA8B, XOR key0xeb). The crash answers were the same (stageThree,true,10). Result:CORRECT. - Mastery: ten deliveries (3,120 answers), same steps. Result:
CORRECT.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 3337ff19975d604eabe9028e0cb479c7 |
| Time Trial | CORRECT | 0563cda7be20a70abb9654cfa12e0d02 |
| Mastery | CORRECT | 298942b79d0625051372b6fd0dbc9109 |
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
- ID:
metadata-forensics-day-26-before-you-go - Prompt: "Prefetch evidence records what Windows prepared to execute even after filenames changed. Recover executable identities and connect execution traces to the correct hosts."
What we were given
- Single Solve:
metadata-day-26-evidence.zip(SHA-256de23c0842380e7db67a452debc91d6732d0e34072dd5f9bd4db8a7f07538eb0a) withtrace-001.pf. - Time Trial:
evidence.zip(SHA-2569bc391698e62bfe21a46e496452cb6dae76f3d7ab667f5b4c406fe4052d31af2). One file of each type so far, now includingtrace-001.pf. - Mastery:
metadata-forensics-day-26-before-you-go-mastery.zip. One outer zip with ten inner zips,evidence-01.ziptoevidence-10.zip. - New today: Windows Prefetch files (
.pf).
What was asked
- Single Solve: 1 question:
prefetch.executable_namefortrace-001.pf(answer IDd26-prefetch-001-prefetch-executable-name). - Time Trial: 31 questions. Mastery: 310 (10 sets × 31).
- Question types: everything from Day 25 (file identity, headers, PE/.NET/MSI/LNK/DOCX/EML, media, ELF/Mach-O/APK/JAR, SQLite, EVTX count, registry root, SHA-256 ordering), plus the new Prefetch executable name.
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.
- Prefetch format.
- Windows 10 and later can store
.pffiles compressed. A compressed file starts withMAM; the data after the first 8 bytes is LZXPRESS Huffman. - The plain format starts with a 4-byte version (30 = Windows 10) and the signature
SCCAat offset 4. - The executable name is UTF-16LE text at offset
0x10, 60 bytes long, ended by a NUL.
- 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]
- Single Solve.
trace-001.pf→CMD.EXE.CORRECT. - Time Trial (31 fields). The fork ran
run_meta.pyfirst. 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:
- EVTX: count of the record signature
2a2a0000. - Registry: the
nkroot key name (offset at0x24, cell at0x1000 + offset, name atnk + 0x4C). - Prefetch: its sample began
1e 00 00 00 53 43 43 41(version 30,SCCA, not compressed); name at offset 16.
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.
- Gotchas the fork hit:
run_meta.pycallsop=retryitself for timed modes. That made a new Time Trial attempt with different files (the note changed fromevidence-note-3cd316.txttoevidence-note-c82eeb.txt), so answers worked out on the first download no longer fit.- In Mastery, the zip it had downloaded (SHA-256
22e4ba9b…) did not match the attempt's current artifact (700bfaca…). It downloaded again fromop=statusand recomputed all 310 answers.
- 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
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 02963fc62fa1d5d153076cc29132f3f5 |
| Time Trial | CORRECT | b47eb52c0a30de19cc96a4c672f9fec6 |
| Mastery | CORRECT | 7b21facbe98c52c3b4ede5129095509f |
- Each mode folder has
answers.jsonand a shortsubmit-response.jsonwith the result and flag. Single Solve and Time Trial also havestart-response.json. - This folder had no README before; this one was written from the saved files and logs.
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
- ID:
mobile-android-day-26-split-decision - Prompt: "Reassemble evidence distributed across base and configuration splits."
What we were given
- New today: a split APK bundle (
.apks). It is a zip with two APKs inside: base.apk: the DEX code andassets/huntress_puzzle.json.feature.apk: the extra piece of evidence.- Mastery: ten deliveries. Nine were regular single APKs and one (set 10) was a
.apkssplit bundle. - The bundles were not saved in this folder. Only
answers.jsonandsubmit-response.jsonwere kept per mode.
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.answertoset10.answerfor Mastery.
How it was solved, start to finish
No app was installed or run.
- The driver failed at the drop. The watcher ran
run_mode.pyfor Single Solve at 07:00 local time. It loggedsingle=no-output -> NEEDS MANUAL SOLVER (new wrinkle). The second session (below) found why on its bundle: the driver looks forassets/huntress_puzzle.jsonat the top of the zip, but in a.apksbundle it sits insidebase.apk. - The headless day agent took over and solved all three modes. Two puzzle variants were seen:
- v1 (
splitcodec):base.apkhashuntress_puzzle.jsonwith a partialparts[]list and anorder[]list.feature.apkhashuntress_feature.jsonwith the missing part and its index. Fill in the missing part, then rebuild the code with the order mapping (as on Day 5:order[i]is the output position ofparts[i]). - v2 (
analysiscodec):base.apkhas the DEX and the puzzle.feature.apkhas a 16-byte binary asset. Disassemble the DEX with baksmali and evaluate the static chain. It XORs, multiplies and rotates constants and uses the feature bytes as key material.
- Mastery mixed single-APK
analysisvariants (direct smali analysis), reflection-based dispatch (packed-switch+Class.forName→Method.invoke), and the split bundle. - 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:
feature.apkheldassets/huntress_feature.bin(16 bytes). The puzzle washuntress.mobile.puzzle.v2with codecanalysis.- DEX strings included
KBase47,KFeature21,KPart23,SplitDecision,Mix,CoreandProbe. token(): a constant →Guard.mixPart96()→Util.scanBaseba()→Guard.mergeFeatured4(), which readsfeature.bin.code():token()→Mix.f1()→Core.finFeatureea()→ XOR with a constant → hex →ANS-….- Constants change per variant, so it used the smali interpreter (
smali_analysis.py). The interpreter did not modelAssets.readSplit, which reads from the split. It was taught to return the split's asset bytes for that call. - It solved a fresh Time Trial variant (case
MOB-26-85FE119B6E) asANS-08906538086278AE, gradedCORRECT. Mastery was already solved by then.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | ad8de19f08bc8f82ab1baac588f4689b |
| Time Trial | CORRECT | 07191fd87dc721d581edacda925442ea |
| Mastery | CORRECT | 3bd172e8385b964192929558d580c389 |
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):
tools/dex_answer_vm.pyopensbase.apkwhen the delivery is a bundle.tools/smali_analysis.pyreturns asset bytes frombase.apk/feature.apkforAssets.readandAssets.readSplit.run_mode.pystill readsassets/huntress_puzzle.jsonfrom the top of the zip, so it does not open a.apksbundle by itself.
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
- ID:
script-analysis-day-26-beam-message-flow - Prompt: "An Erlang escript passes messages between processes, and some of its indicators look suspiciously familiar. Trace the message flow, and separate the true cross-language indicators from deterministic collision decoys planted to look like old friends."
What we were given
- Single Solve: one
evidence.zip(149,814 bytes, SHA-256f2c857779744caf0a2f99191e3bce6795ee8e839241a121e468fac48d7c8dce5). Password:infected. - The role-named layout from
Day 24. - New today: 4 Erlang escript polyglots (
polyglot-erlang-*.escript). - Also present: the Elixir files first seen on Day 25 (
host-elixir-phoenix-elixir.exsandpolyglot-elixir-*.exs). - Time Trial:
evidence.zip(SHA-25643c32da333e88f9ee1a84ea384c93a5b4374f9f812a3f1ebff85ed3b93f6df1d), in the hash-named layout fromDay 23. - Mastery:
script-analysis-day-26-beam-message-flow-mastery.zip(SHA-25632e9c5ccd67f9026c1e64bcfa46e470e15fa6b8d23f9c284e8d78340210df5fb), also hash-named. - The archives were not kept in this folder, only the JSON files.
What was asked
- Single Solve: 1,615 questions. By family: PowerShell 15, JScript 72, Batch 72, VBScript 72, Python 126, Bash 168, Node.js 56, host 154, polyglot 880. Field types are the same as on Day 24.
- Time Trial: 1,677 questions in the Day 23 format (
powershell-<hash>-url,jscript-<hash>-style,polyglot-<lang>-<hash>-url-host, ...). - Mastery: 16,770 questions in 10 sets of 1,677.
How it was solved, start to finish
- 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".
- Single Solve.
solve_day26.pyis 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:
- one marker decoder for every
HUNTRESS_ANALYSIS_V1form:B64,HEX,FRAG,HB64,SPLITand the layeredLYR; - the per-language decoders for behavioral scripts, with role and ATT&CK from the steps;
- a field map from answer suffixes (
-host-profile,-next-language,-cron-path, ...) to config keys.
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"}
- 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.pyis the one written for that format.solve_day26.pydoes not handlepowershell-<hash>IDs or thestyle,indicatorandcampaign-tokenfields. - The saved submit files: Single Solve and Time Trial say
already_solved(they were re-submitted after the first solve). Mastery'ssubmit-response.jsonis the short{"result": "CORRECT", "flag": ...}reply.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 6a5603fb62c9599b796f3fa974a5f83b |
| Time Trial | CORRECT | 92b931d5d77cb984c510ff6c4bd1e4e8 |
| Mastery | CORRECT | 59d0f02626c00a92f6f5859fa8cb6816 |
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
- ID:
warmups-day-26 - Prompt: "Eight symbols, infinite loops. Feed the brain."
- New encoding: Brainfuck
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. Brainfuck esoteric language. Interpret the
><+-.,[]program; the output is the plaintext. - 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. - 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:happy-comet-blossom-79. Flag:4ffddc74d8d8ed4457bd510c70356736. - Time Trial:
CORRECT. slug:nimble-sailor-bridge-52. Flag:4f466faa0709f4b72a42016e26ba949b. - Mastery:
CORRECT. 128 slugs.
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.
- Queried
/api/clues. It disclosed the dispatch route (e.g./dispatch-3940be), the expected event type (case.promoted), and the owner scope (executive). - The key insight was the field name mismatch:
/api/cluesdescribes the event asevent_typeand scope asowner_scope, but the actual dispatch handler expectsevent,owner, androle. Using the clue field names in the POST body gets rejected — you need the handler's actual schema. - Sent the forged webhook event:
POST /dispatch-3940be
Content-Type: application/json
{"event": "case.promoted", "owner": "executive", "role": "executive"}
- The handler consumed the forged event without signature verification and returned
effect: forged_event_consumedwith 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)
| Target | Vulnerability |
|---|---|
| 1 | Archive/backup disclosure via robots.txt |
| 2 | IDOR — reference-only case accessible via session |
| 3 | SQL injection in search form |
| 4 | Webhook forgery (same technique as above) |
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 2e0be98399b1e48732ae381f459de1fc |
| Time Trial | CORRECT | a666fb2257846c064801893a3d198b8e |
| Mastery (4/4) | CORRECT | 824b76f9a95586af9b7d4e10b80e3bb9 |
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.
- Queried
/api/state-format— it documented the session state format: base64url-encoded JSON containing user identity and role. - Decoded the current session state:
{"user": "analyst", "role": "analyst"}. - Forged a new state with elevated privileges:
{"user": "analyst", "role": "administrator"}. - Base64url-encoded the forged JSON and POSTed it to the feature route.
- The server deserialized and trusted the forged state without verifying a signature. It accepted the
administratorrole 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)
| Target | App | Vulnerability |
|---|---|---|
| 1 | Tiny Uptime | Backup disclosure — robots.txt → /snapshots-*/ → .json.bak |
| 2 | Incident Picnic | IDOR — /api/timeline leaks foreign case ID |
| 3 | Signal Shelf | SQL injection — /explore?q= injectable |
| 4 | Object Post (Quarkus) | Insecure deserialization of forged session state |
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | fa9aa82decda8976c31a921d7f4d7b22 |
| Time Trial | CORRECT | 99b3ca4d55f6947c5920636a84653054 |
| Mastery (4/4) | CORRECT | 52385ffb169435aa51365a7be71ac244 |
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.