2026-10-12
Day 12: Pascal's Wager
Lane: Binary reverse engineering. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
binary-reverse-engineering-day-12-pascal-archive-stager - Prompt: "Pascal is betting you won't read its record layouts. Take the wager: unpack the archive stager's structures and read the configuration straight from memory's own filing cabinet."
What we were given
- One
evidence.zip(31,930,924 bytes, SHA-256261fb7a322704944b2dba6d8638b9dc2913e0f91c1905bd2764fccc5c06582fc). AES encrypted, passwordinfected. - The earlier files again:
d01tod11. - New today:
d12--variant-000.elf(100,976 bytes), a 64-bit Linux program written in Pascal (FPC).
What was asked
- 120 questions in Single Solve and Time Trial. Mastery had three deliveries, so 360.
- Question types:
- Hashes: SHA-256 of each member.
- d01 to d11: the same questions as Day 11.
- d12 (new): machine, architecture, the config fields, the CRC32,
hcfg_offset, and the format as a lowercase token: one ofelf,pe,pe_cli,jar,wasm,neko_bytecode.
How it was solved, start to finish
- Ran the driver
run_tm.py: start the attempt, download the zip, runsolve_tm.py, submit. - d01–d11 were answered as on Day 11.
- d12 format (the twist): earlier format questions accepted labels like
ELF64. This one only accepts a lowercase token.
solve_tm.pynow reads the question text. If it says "lowercase token" (or "elf for ELF"), it answers with the token:elf,pe,pe_cli(a PE with a CLR header),jarorwasm.- Otherwise it keeps the old label form, so older questions still get
ELF64orPE32/.NET. - Answer for d12:
elf.
- d12 config: the question said to scan for a literal
HCFGand accept the first valid record. The offset is whereHCFGstarts. Re-checked on the saved sample:
HCFG offset=82928 version=1 xor_key=0x81 len=368 crc32=0xe4fc81f8
section of match: .data
JSON: {"campaign":"BR12-000","domain":"node-000.day12.example.invalid","ipv4":"198.51.100.230","url":"https://node-000.day12.example.invalid/api/BR12-000","mutex":"Global\\HuntressBR12_000", ...}
Answers: d12_analysis_hcfg_offset = 82928, CRC32 0xe4fc81f8, campaign BR12-000.
- Submitted all 120 answers (
answers.json). Result:CORRECT. - Time Trial: a fresh variant, same steps. Result:
CORRECT. - Mastery: three deliveries (360 answers), same steps. Result:
CORRECT.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 986b8f546ed5eac11c6cc89ad42acf7b |
| Time Trial | CORRECT | add234c992bc28660a08418a81bd8e3e |
| Mastery | CORRECT | 990b9df627fb66a0a921393c0c745ee9 |
Each mode folder has the raw start-response.json, answers.json, submit-response.json and final-status-response.json. The downloaded zips are under deliveries/.
Reproduce
Offline, from this folder (no Game Master needed):
mkdir -p /tmp/d12/deliveries && cp single-solve/evidence.zip /tmp/d12/deliveries/delivery-1.zip
python3 -I ~/.config/huntress/solvers/solve_tm.py single-solve/start-response.json /tmp/d12/deliveries /tmp/d12/answers.json
Checked on 2026-11-01: this gives the same 120 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-12-pascal-archive-stager single_solve /tmp/d12
This needs a Game Master token in ~/.config/huntress/gm-token.
Day 12: Managed Expectations
Lane: Metadata forensics. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
metadata-forensics-day-12-managed-expectations - Prompt: "The .NET assemblies share names, versions, and source ancestry—but their module identities remain distinct. Separate rebuilds from renames."
What we were given
- Single Solve:
(evidence.zipmetadata-day-12-evidence.zip, 2,038 bytes, SHA-2569d3b4fc5a4894914b9e4598b8d3deaa501849486f755bec61b1e60ff24d8335d) withmanaged-001.dll. - Time Trial:
metadata-day-12-evidence.zip(2,039 bytes, SHA-256d8766f9e0de676d4a691d28df99a14440dc97cbc0b8eb16f57eb6ca72680bbd8) withmanaged-002.dll. - Mastery:
metadata-forensics-day-12-managed-expectations-mastery.zip(4,373 bytes, SHA-256ff1847604dc4afa18288f04b25f393203b8e5787dec29cfea545ecd88eba9eca). Two inner zips withmanaged-003.dllandmanaged-004.dll. - New today: .NET assemblies (managed DLLs).
What was asked
- One field type:
dotnet.mvid_guid, the module version ID (MVID) of a .NET DLL. - Format: "canonical GUID text in 8-4-4-4-12 hexadecimal form, including hyphens".
- Single Solve and Time Trial: 1 question. Mastery: 2 questions. Timers: Time Trial 50 seconds, Mastery 80 seconds.
How it was solved, start to finish
The method: the MVID lives in the CLR metadata, in the #GUID heap. Rebuilds get a new MVID. Renamed copies keep the old one.
- Wrote an MVID reader and checked it on the Single Solve DLL, then added it to
run_meta.py: - Find the metadata root signature
BSJB. - Read the version-string length at
BSJB + 12. Skip the version string (padded to 4 bytes). - Read the stream count. Walk the stream headers: offset (4 bytes), size (4 bytes), NUL-ended name padded to 4 bytes.
- At the
#GUIDstream, take the first 16 bytes. - Print it as a GUID. The first three parts are little-endian.
if name == b'#GUID':
g = b[i+off : i+off+16] # i = offset of 'BSJB'
return '%08x-%04x-%04x-%04x-%012x' % (
struct.unpack('<I', g[0:4])[0], struct.unpack('<H', g[4:6])[0],
struct.unpack('<H', g[6:8])[0], struct.unpack('>H', g[8:10])[0],
int.from_bytes(g[10:16], 'big'))
- Single Solve.
managed-001.dll→21e410f3-c977-465c-80eb-6890ddd3085c.CORRECT. - Time Trial.
managed-002.dll→9e0e197f-d610-4ec9-bd1c-d28da985893a.CORRECT. - Mastery.
managed-003.dll→2658bcc7-f07c-48b1-8cb9-2bb645f8680e,managed-004.dll→ecc37f87-9668-43c5-b9f4-011ee0d07c7c.CORRECT.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 3730fd111f2f272740d3eb0799a96ca0 |
| Time Trial | CORRECT | e11b227c3b1709eb339085723afba36f |
| Mastery | CORRECT | cdd3449477126525d063f46c62a7015b |
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-12-managed-expectations single_solve /tmp/d12
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 parses the DLL bytes. It never loads or runs them.
Day 12: SQLite Assumptions
Lane: Mobile (Android). Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
mobile-android-day-12-sqlite-assumptions - Prompt: "Reconstruct authorization from a synthetic SQLite cache and prove server-side impact."
What we were given
- One Android APK per case. Inside:
AndroidManifest.xml,classes.dex,assets/huntress_puzzle.json, andMETA-INF/signing files. - Single Solve:
sqlite_assumptions.apk, caseMOB-12-4B4FA1A323(12,704 bytes, SHA-256dc892f6eb26966909fcfbfe26bd21dff96723ee5bace2e99dc0a0813e0d0e8d1). Its puzzle is saved assingle-solve/huntress_puzzle.json. - Time Trial: one APK (case
MOB-12-8D9A4D87D5). Mastery: three 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.answertoset3.answerfor Mastery. - Time limit: Mastery 110 seconds.
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
hex(also used on Day 6).
{"schema":"huntress.mobile.puzzle.v1","day":12,"codec":"hex","data":"414e532d30333946304439303731313131303530"}
- Decoded it. Each pair of hex digits is one ASCII character:
import json
p = json.load(open('single-solve/huntress_puzzle.json'))
print(bytes.fromhex(p['data']).decode())
Output: ANS-039F0D9071111050.
- Ran the lane driver for all three modes:
python3 -I ~/.config/huntress/solvers/run_mode.py mobile-android-day-12-sqlite-assumptions <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-039F0D9071111050), Time Trial (ANS-668B39E20D9A458F) and all three Mastery answers came backCORRECT.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 2e1400512f174a77409341aea09848b7 |
| Time Trial | CORRECT | 65a16fa4819e3f76c51a7fdfbcb4c854 |
| Mastery | CORRECT | 0df1f9bf63c6c4677372bc4e8a343068 |
Each mode folder has answers.json, start-response.json, submit-response.json and final-status-response.json. The saved Time Trial start-response.json also carries a start_required error message, but its submit-response.json is CORRECT. 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-12-sqlite-assumptions single_solve mobile_puzzle /tmp/d12
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 12: AutoIt Takes Two
Lane: Script analysis. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
script-analysis-day-12-autoit-workflow-pair - Prompt: "Two inert AutoIt workflows arrived as a matched set, and each one carries half the story. Correlate them with everything you've proven so far, and decide which pairing is genuine and which is just going through the motions."
What we were given
- One
evidence.zip(93,075 bytes, SHA-2568fc31386a080f336c60844a0bc7a47fb3a8fe168d67a1756dc3cbf2b1b6c1215). Password:infected. - The same families as Day 11. New today:
- 4 AutoIt polyglots:
polyglot-autoit-benign-utility.au3,-downloader,-launcher,-staged-chain. - Every host and polyglot file carries the
HUNTRESS_ANALYSIS_V1:<ENC>-<data>marker fromDay 8.
What was asked
- 855 questions in Single Solve. By family: PowerShell 15, JScript 72, Batch 72, VBScript 72, Python 126, Bash 112, Node.js 56, host 66, polyglot 264.
- 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: 855 questions. Mastery: 1,710 questions in 2 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.
- Checked whether AutoIt was a new family. It was not: the files are
polyglot-autoit-*.au3with the usual marker, so the existing polyglot path handled them.
- Submitted. The Single Solve was
CORRECT(855/855).
- Real answers from
single-solve/answers.json:
{
"polyglot-autoit-launcher-role": "launcher",
"polyglot-autoit-launcher-attack": "T1059",
"polyglot-autoit-launcher-adapter": "process_builder",
"polyglot-autoit-launcher-campaign": "AUTOIT-02a74447",
"polyglot-autoit-launcher-url": "https://autoit-02a744470e.example.invalid/stage",
"polyglot-autoit-launcher-stage-count": "3",
"polyglot-autoit-launcher-steps": "decode_embedded>write_file>dispatch_process",
"polyglot-autoit-launcher-host-profile": "standalone"
}
- Time Trial and Mastery used the same solver on fresh variants.
- Time Trial: 855 questions, deadline 50 seconds after the start.
- Mastery: 1,710 questions in 2 sets, deadline 80 seconds after the start. The download (
script-analysis-day-12-autoit-workflow-pair-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 | 4bb887a602c4fe4b704fe49fac17770f |
| Time Trial | CORRECT | 1e04c64e531777019c267a857ad8a919 |
| Mastery | CORRECT | d2659c3b7978a4b6b48246c3dc815114 |
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/d12/ex
7z x -pinfected -o/tmp/d12/ex repos/day-12-script-analysis-autoit-takes-two/single-solve/evidence.zip
python3 -I tools/solve_expansion.py /tmp/d12/ex \
repos/day-12-script-analysis-autoit-takes-two/single-solve/start-response.json /tmp/d12/answers.json
This rebuilds all 855 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 12: Back at You
Lane: Warmups. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
warmups-day-12 - Prompt: "Read it the other way. Some answers are staring you in the face — backwards."
- New encoding: reversed string
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. The entire text is reversed. Read it backwards.
- Mastery blobs use multiple encodings from Days 1-12. 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:zesty-sunset-quartz-65. Flag:aae46443efee308f38abac808be35c4b. - Time Trial:
CORRECT. slug:jaunty-banner-dune-97. Flag:699cc0d2d57c48f66f619f6faaedacb8. - Mastery:
CORRECT. 58 slugs. Flag:9416f28cebdf611de3dd6bf0cb0e18ec.