2026-10-09
Day 9: Nimble
Lane: Binary reverse engineering. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
binary-reverse-engineering-day-09-nim-generated-runtime - Prompt: "Nim compiles down to C, but the generated names give it away. Learn to spot Nim's runtime fingerprints hiding inside C-shaped clothing."
What we were given
- One
evidence.zip(31,479,856 bytes, SHA-256a2b66b969c7689123ec624cf620932f0de6c90dc6f494e428d660dfed2f3cc22). AES encrypted, passwordinfected. - The earlier files again:
d01tod08. - New today:
d09--variant-000.elf(60,672 bytes), a 64-bit Linux program written in Nim.
What was asked
- 90 questions in Single Solve and Time Trial. Mastery had five deliveries, so 450.
- Question types:
- Hashes: SHA-256 of each member.
- d01 to d08: the same questions as Day 8.
- d09 (new): machine, format, architecture, the config fields, the CRC32, and a new field:
hcfg_offset, the byte offset in the file where the winning config starts.
How it was solved, start to finish
- Ran the driver
run_tm.py: start the attempt, download the zip, runsolve_tm.py, submit. - d01–d08 were answered as on Day 8.
- d09 config: the question said to Base64-decode every run of 100+ Base64 characters, and accept the first one that decodes to a CRC32-valid
HCFGrecord.
- The saved Nim sample also contains the text
HCFGtwice in plain bytes. Neither is a valid record, so the CRC32 check throws them away. - The real record is Base64 in
.rodata.
- d09 offset (new): for a Base64 config, the offset is where the Base64 string starts in the file (for a raw record it would be where
HCFGstarts).solve_tm.pyalready returned the match position from its Base64 scan, so it answeredhcfg_offsetwith that number.
Re-checked on the saved sample:
[base64 run at file offset 30696, run length 508]
HCFG version=1 xor_key=0x51 len=368 crc32=0x9614e1a8
section of match: .rodata
JSON: {"campaign":"BR09-000","domain":"node-000.day09.example.invalid","ipv4":"198.51.100.180","url":"https://node-000.day09.example.invalid/api/BR09-000","mutex":"Global\\HuntressBR09_000", ...}
Answers: d09_analysis_hcfg_offset = 30696, CRC32 0x9614e1a8, campaign BR09-000, format ELF64.
- Submitted all 90 answers (
answers.json). Result:CORRECT. - Time Trial: a fresh variant, same steps. Result:
CORRECT. - Mastery: five deliveries (450 answers), same steps. Result:
CORRECT.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 8e66d681780cc49c103f5fbc868d339e |
| Time Trial | CORRECT | 167789090a984d148551749a1c78d81a |
| Mastery | CORRECT | 1d8cfbfdf1875b3790f04a187db958a8 |
Each mode folder has the raw start-response.json, answers.json, submit-response.json and final-status-response.json.
Reproduce
Offline, from this folder (no Game Master needed):
mkdir -p /tmp/d09/deliveries && cp single-solve/evidence.zip /tmp/d09/deliveries/delivery-1.zip
python3 -I ~/.config/huntress/solvers/solve_tm.py single-solve/start-response.json /tmp/d09/deliveries /tmp/d09/answers.json
Checked on 2026-11-01: this gives the same 90 answers as answers.json. It only parses the samples and never runs them.
Live driver:
python3 -I ~/.config/huntress/solvers/run_tm.py binary-reverse-engineering-day-09-nim-generated-runtime single_solve /tmp/d09
This needs a Game Master token in ~/.config/huntress/gm-token.
Day 9: Built Different
Lane: Metadata forensics. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
metadata-forensics-day-09-built-different - Prompt: "A software drop contains executables for several architectures, plus decoys wearing executable extensions. Determine what can actually run where."
What we were given
- Single Solve:
(evidence.zipmetadata-day-09-evidence.zip, 598,758 bytes, SHA-256fc8a6bedcc7ff8bd8826fd81e8aa1ecb3b82adcdcf441a7c07a8fd76b8a54962). - Time Trial:
metadata-day-09-evidence.zip(598,757 bytes, SHA-256e528ccd92042c1edc30f4c3b7e8a867107b4e0d1ab80bc6c8b7afd5a6efd84ec). - Mastery:
metadata-forensics-day-09-built-different-mastery.zip(2,994,490 bytes, SHA-256e55656679781599b0f8e01fe10dc43d389074f4ec0669648e7f8ba8c3628b7a6). It holds five inner zips,metadata-day-09-evidence-01.zipto-05.zip. - Each evidence zip holds six files:
evidence-note.txt,camera-001.jpg,panel-001.png,document-001.pdf,evidence-drop-001.zipand, new today,telemetry-agent-001.exe.
What was asked
- Single Solve: 13 questions. Time Trial: 13. Mastery: 65 (5 sets × 13).
- Question types:
- File identity (evidence note): filename, size, MD5, SHA-1, SHA-256, first 16 bytes as hex, UTF-8 BOM present.
- Headers: JPEG SOF size, PNG IHDR size, PDF header version, ZIP EOCD total entries, ZIP member names.
- New today:
pe.coff_machine_u16_hexfortelemetry-agent-001.exe. Format: lowercase hex with a0xprefix.
How it was solved, start to finish
- Read the new question. It asks for the CPU type field of a Windows PE file. That is the 2-byte
Machinefield in the COFF header. - Added a handler to
run_meta.py. The PE header offset (e_lfanew) is the 4-byte value at0x3C. The header starts withPE\0\0, soMachineis at that offset + 4:
if 'pe-coff-machine' in aid:
pe = struct.unpack_from('<I', fb, 0x3c)[0]
return '0x%04x' % struct.unpack_from('<H', fb, pe + 4)[0]
- Ran
run_meta.pyfor all three modes (a helper agent ran the metadata lane). Every other field used the handlers from Days 7–8. - Answers.
telemetry-agent-001.exegave0x014c(x86) in the Single Solve, the Time Trial and all five mastery sets. - Submitted all answers in one JSON object per mode. The Game Master replied
CORRECTand returned the flag.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 9cc376d12c158369ca7e25281e10b837 |
| Time Trial | CORRECT | 5a1873f08b5871768d3be26aada54110 |
| Mastery | CORRECT | baadf6dc65205496afe0ea1d7b07a004 |
Each mode folder has answers.json, start-response.json, submit-response.json and final-status-response.json. The Single Solve folder also has the zip. No screenshots were captured.
Reproduce
python3 -I ~/.config/huntress/solvers/run_meta.py metadata-forensics-day-09-built-different single_solve /tmp/d09
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. It reads the PE header bytes. It never runs the .exe.
Day 9: Trust Everyone
Lane: Mobile (Android). Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
mobile-android-day-09-trust-everyone - Prompt: "Exploit a challenge CA accepted by a permissive trust implementation."
What we were given
- One Android APK per case. Inside:
AndroidManifest.xml,classes.dex,assets/huntress_puzzle.json, andMETA-INF/signing files. - Single Solve:
trust_everyone.apk, caseMOB-09-FA83E02832(12,704 bytes, SHA-2567c1f182a03ec7852f49d8ed138457d62d122f0cbe17babe217a5fb35a3060a0a). Its puzzle is saved assingle-solve/huntress_puzzle.json. - Time Trial: one APK (case
MOB-09-74BF46D97A). Mastery: five APKs. These APKs were not saved in the repo.
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.answertoset5.answerfor Mastery.
How it was solved, start to finish
The app was never installed or run.
- Started the Single Solve and downloaded the APK.
- Read the puzzle asset. The codec is
base64(also used on Day 3).
{"schema":"huntress.mobile.puzzle.v1","day":9,"codec":"base64","data":"QU5TLTNEM0I4MDM5NTI0MEI4RUU="}
- Decoded it:
import json, base64
p = json.load(open('single-solve/huntress_puzzle.json'))
print(base64.b64decode(p['data']).decode())
Output: ANS-3D3B80395240B8EE.
- Ran the lane driver for all three modes. A helper agent ran it once per mode:
python3 -I ~/.config/huntress/solvers/run_mode.py mobile-android-day-09-trust-everyone <mode> mobile_puzzle <workdir>
The driver downloads each APK, reads its puzzle, decodes it by its codec, and submits all answers at once.
- Results: Single Solve (
ANS-3D3B80395240B8EE), Time Trial (ANS-31B3DA8804F7211C) and all five Mastery answers came backCORRECT.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 492626431b00af6000167c720d9a296d |
| Time Trial | CORRECT | e6fd3ecd2e57a363cd0963d5bec39178 |
| Mastery | CORRECT | 18015a829f1112b61d38a3d4fcbae877 |
Each mode folder has answers.json, start-response.json, submit-response.json and final-status-response.json. No screenshots were taken.
Reproduce
Offline: run the Python snippet above from this folder.
A fresh run with the driver:
python3 -I ~/.config/huntress/solvers/run_mode.py mobile-android-day-09-trust-everyone single_solve mobile_puzzle /tmp/d09
This needs a Game Master token in ~/.config/huntress/gm-token. It only unzips the APK and reads the asset. It never installs or runs the app.
Day 9: All the World's a Stager
Lane: Script analysis. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
script-analysis-day-09-stager-relationships - Prompt: "Every stager claims to know who came before it and who comes next. Build the relationship graph from final-byte evidence alone, and expose the stage whose claimed family tree is impossible."
What we were given
- One
evidence.zip(82,338 bytes, SHA-256770311a8a2f653916aa9c636e8ae9112a40c1115beeae026971d4a407a3a15db). Password:infected. - The same families as Day 8. New today:
- 2 new host files:
host-sct-scriptlet-jscript.js(a JScript scriptlet) andhost-lua-openresty-lua.lua(Lua under OpenResty). - 4 Lua polyglots:
polyglot-lua-benign-utility.lua,-downloader,-launcher,-staged-chain. - 2 more advanced Bash files:
recursive-walk.sh,trap-handler.sh. - Every host and polyglot file carries the
HUNTRESS_ANALYSIS_V1:<ENC>-<data>marker fromDay 8.
What was asked
- 695 questions in Single Solve. By family: PowerShell 15, JScript 72, Batch 72, VBScript 72, Python 126, Bash 84, Node.js 56, host 66, polyglot 132.
- The question types are the same as before. Host and polyglot files get 11 questions each (role, ATT&CK, adapter, campaign, URL or path, host profile, obfuscation, stage profile, next language, stage count, steps).
- Time Trial: 695 questions. Mastery: 3,475 questions in 5 sets.
How it was solved, start to finish
- Started the untimed Single Solve and downloaded
evidence.zip. Extracted it with7z x -pinfected. - Ran the existing solver (
solve_expansion.py, driven byrun_expansion.py). Each family has its own decoder:
| Family | Files | How the config is recovered | First seen | |
|---|---|---|---|---|
| PowerShell | *-sample.ps1 | Base64 JSON inside FromBase64String('...') | Day 1 | |
| JScript | *.js | jsdec.js loads the fixture in a Node vm sandbox (pure-computation globals only) and calls its decode functions | Day 3 | |
| Batch | *.bat, *.cmd | joins the :HUNTRESS_INSPECT fragments and drops ^ carets | Day 3 | |
| VBScript | *.vbs | Material_ + Codec_, transform search until the text starts `v=1\ | steps=` | Day 4 |
| Python | *.py | MATERIAL_ read with ast.literal_eval, same transform search | Day 5 | |
| Bash | *.sh | quoted Material_ + Codec_; "advanced" files start `v=1\ | feature=` | Day 6, Day 7 |
| Node.js | node-*.mjs | Material_ + Codec_ with \x, \u and hex-array formats | Day 7 | |
| host, polyglot | host-*, polyglot-* | HUNTRESS_ANALYSIS_V1:<ENC>-<data> marker (B64, HEX, HB64, FRAG) | Day 8 |
Role comes from the ordered steps, and ATT&CK from the role and the language (rules in Day 3). Host and polyglot configs already contain their role and ATT&CK ID.
- The new files needed no new code. The Lua and SCT files carry the same
HUNTRESS_ANALYSIS_V1marker as Day 8, sohostpgdec.pydecoded them as-is. The new Bash files are more "advanced" files (Day 7 rules).
- Submitted. The Single Solve was
CORRECTwith all 695 answers on the first run.
- The other four lanes of the day were solved in parallel by sub-agents while this lane ran.
- Real answers from
single-solve/answers.json:
{
"host-sct-scriptlet-jscript-role": "launcher",
"host-sct-scriptlet-jscript-attack": "T1059",
"host-sct-scriptlet-jscript-adapter": "process_builder",
"host-sct-scriptlet-jscript-campaign": "JSCRIPT-6d31f81b",
"host-sct-scriptlet-jscript-url": "https://jscript-6d31f81bec.example.invalid/stage",
"polyglot-lua-downloader-role": "downloader",
"polyglot-lua-downloader-attack": "T1105",
"polyglot-lua-downloader-adapter": "http_client",
"polyglot-lua-downloader-campaign": "LUA-4dafa916",
"polyglot-lua-downloader-url": "https://lua-4dafa91644.example.invalid/stage"
}
- Time Trial and Mastery used the same solver on fresh variants.
- Time Trial: 695 questions, no deadline (
run_for_time: false). - Mastery: 3,475 questions in 5 sets, no deadline (
run_for_time: false). The download (script-analysis-day-09-stager-relationships-mastery.zip) holds one inner zip per set. The driver solves each set and adds thesetN.prefix. - Both came back
CORRECT.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | ab97d26f81ba912ac4de743f02ee1eff |
| Time Trial | CORRECT | 04aba00d2b995c023bf7306e5aa408a3 |
| Mastery | CORRECT | 54d244888d245b5519d8147e3edcb7d0 |
Each mode folder has answers.json and the Game Master JSON. The Single Solve folder also keeps evidence.zip. No screenshots were taken.
Reproduce
Offline, from the repo root:
mkdir -p /tmp/d09/ex
7z x -pinfected -o/tmp/d09/ex repos/day-09-script-analysis-all-the-worlds-a-stager/single-solve/evidence.zip
python3 -I tools/solve_expansion.py /tmp/d09/ex \
repos/day-09-script-analysis-all-the-worlds-a-stager/single-solve/start-response.json /tmp/d09/answers.json
This rebuilds all 695 saved answers (re-checked on 2026-11-01). It only parses the files. The tools/ copy decodes JScript with the pure-Python jsdec_py_emu.py, not the Node sandbox.
On the day, run_expansion.py drove the live modes. Since Day 23 that driver sends any question set with polyglot- IDs to solve_day23.py, which does not handle this format's host- and resource- IDs. So use solve_expansion.py directly, as above.
Day 9: Escape Room
Lane: Warmups. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
warmups-day-09 - Prompt: "Sometimes the escape is the destination. Unicode knows."
- New encoding: Unicode escape sequences
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. JSON-style
\uXXXXescapes. Decode as unicode_escape. - Mastery blobs use multiple encodings from Days 1-9. 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-piano-whale-26. Flag:626a29b586b524fb33d18473759c8a5d. - Time Trial:
CORRECT. slug:witty-summit-cider-70. Flag:b9cf58d50d7897b89433394afe61d776. - Mastery:
CORRECT. 43 slugs. Flag:d0e241b4dd85364156bc0fe24fa45467.