2026-10-17
Day 17: Decoder Ring
Lane: Binary reverse engineering. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
binary-reverse-engineering-day-17-encoded-configuration-recovery - Prompt: "The configuration is encoded, but the decoder ships with the binary — a ring waiting for its secret. Recover the reversible decoder and read what it was hiding."
What we were given
- One
evidence.zip(32,831,470 bytes, SHA-256cdbe7f081670e4bf6164bc4a1bb60b4c671da60bb1a47499df538fdacef5434f). AES encrypted, passwordinfected. - The earlier files again:
d01tod16. - New today:
d17--variant-000.elf(1,393,288 bytes), a 64-bit Linux program. Its strings and symbols are full of__gnat/ada_names, so it is an Ada (GNAT) build.
What was asked
- 204 questions in Single Solve and Time Trial. Mastery had five deliveries, so 1,020.
- The big change today: many new, deeper questions about the older specimens, one or two per language:
- d01 (C): the
.huntressmarker text, and therecover_codeconstant (ornoneif there is norecover_codeFUNC symbol in.symtab). - d02 (C++): the first symbol matching
/DiscoveryEngine.*score/, and the first matching/ZTI.*DiscoveryEngine/. For a PE, use the COFF symbol table and keep prefixes like.text$. - d03 (.NET): the XOR key and the
HCFGversion. - d04 (Go): section names, and whether the bytes contain
runtime.main. - d05 (Rust): section names, and whether any symbol starts with
_ZNor_R. - d06 (Java): the
Main-Classmethod names in table order, and the classaccess_flags. - d07 (Kotlin): whether the JAR contains
kotlin/coroutines/Continuation.class, and the method count. - d08 to d14:
hcfg_offset,hcfg_version, and a newhcfg_storagelabel (see step 4). - d15 / d16: the remaining config fields of the stripped / direct builds.
- d17 (new): machine, architecture, format, XOR key,
HCFGversion,hcfg_offset, the config fields and the CRC32.
How it was solved, start to finish
- Ran the driver
run_tm.py: start the attempt, download the zip, runsolve_tm.py, submit. - Added one handler per new question type to
solve_tm.py. Each reads the bytes directly:
.huntressmarker: the section bytes as UTF-8, trailing NULs removed. AnswerBR01-CATALOG-000.recover_code: find the FUNC symbol, map its address to a file offset through its section, and decodeb8 imm32(mov eax, imm32). Answer8100.- C++ symbols: walk
.symtab(or the PE COFF table) in order and return the first regex match. Answers_ZNK15DiscoveryEngine5scoreEPKcand_ZTI15DiscoveryEngine. - Go:
runtime.mainis in the bytes, sotrue. Section names start["",".text",".rodata",".typelink",".itablink",".gosymtab",".gopclntab",…]. - Rust: a symbol starts with
_ZN, sotrue. - Java: a small class-file parser walks the constant pool, then the fields and methods. Methods:
["<init>","decodeConfig","campaign","evaluate","main"].access_flags=49. - Kotlin: the JAR has
kotlin/coroutines/…entries, sotrue. Method count7.
- Offsets: the solver reports where the winning record starts. For Base64 that is the start of the Base64 string. Examples: d08
18366768, d11368272, d1282928, d144000. hcfg_storage(new): the question gave ordered rules. The solver remembers how it found each record and maps that to a label:
- Found only after Base64 decoding →
base64. - Literal
HCFGinside a section named exactly.hcfg→raw_hcfg_section. - Literal
HCFGinside a WebAssembly data segment →wasm_data_segment. - Literal
HCFGin any other ELF section →raw_const_array. - Answers: d08, d09, d11, d13
base64; d12raw_const_array(its record is in.data); d14raw_hcfg_section.
- d17 config: a literal record. Re-checked on the saved sample:
HCFG offset=207432 version=1 xor_key=0x73 len=367 crc32=0x265cc435
section of match: .rodata
JSON: {"campaign":"BR17-000","domain":"node-000.day17.example.invalid","ipv4":"198.51.100.70","url":"https://node-000.day17.example.invalid/api/BR17-000","mutex":"Global\\HuntressBR17_000", ...}
Answers: format elf, XOR key 0x73, version 1, hcfg_offset 207432, campaign BR17-000.
- Submitted all 204 answers (
answers.json). Result:CORRECT. - Time Trial: a fresh variant, same steps. Result:
CORRECT. - Mastery: five deliveries (1,020 answers), same steps. Result:
CORRECT.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 2b2e663fe01c717c3f15c16f580f5612 |
| Time Trial | CORRECT | dc17792a53355d0e48c65ea2868638a9 |
| Mastery | CORRECT | d16a2d986626d89a7c13cd2bda45cf8d |
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/d17/deliveries && cp single-solve/evidence.zip /tmp/d17/deliveries/delivery-1.zip
python3 -I ~/.config/huntress/solvers/solve_tm.py single-solve/start-response.json /tmp/d17/deliveries /tmp/d17/answers.json
Checked on 2026-11-01: this gives the same 204 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-17-encoded-configuration-recovery single_solve /tmp/d17
This needs a Game Master token in ~/.config/huntress/gm-token.
Day 17: Hear Me Out
Lane: Metadata forensics. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
metadata-forensics-day-17-hear-me-out - Prompt: "Voice notes have been transcoded, renamed, and embedded in mail. Determine the actual codecs, connect equivalent recordings, and find the stream that breaks the sender’s story."
What we were given
- Single Solve:
(evidence.zipmetadata-day-17-evidence.zip, 1,323 bytes) withaudio-001.wav. - Time Trial:
evidence.zip(608,107 bytes, SHA-256f9b81191675fda501924d55625aef8efe4f9fc121eab692e8f6edb4a72bf74cf). One file of each type so far, now includingaudio-001.wav. - Mastery:
metadata-forensics-day-17-hear-me-out-mastery.zip(3,041,301 bytes, SHA-256498e556977fcc6082b06ed6d67c4f446dcd6a8a01d58f23ee024613f140aff71). Five inner zips,evidence-01.ziptoevidence-05.zip. - New today: audio files.
What was asked
- Single Solve: 1 question:
media.primary_audio_codec_nameforaudio-001.wav. - Time Trial: 22 questions. Mastery: 110 (5 sets × 22).
- Question types: everything from Day 16, plus the codec name of the first audio stream.
How it was solved, start to finish
The method: the file extension says .wav, but the codec must come from the stream itself. ffprobe reads the container and reports the codec without playing anything.
- Checked the Single Solve file with
ffprobe. It reportedpcm_s16le(16-bit little-endian PCM). - Added an
ffprobehandler torun_meta.py. It writes the bytes to a temp file and asks for the codec of audio stream 0:
r = subprocess.run(['ffprobe', '-v', 'quiet', '-select_streams', 'a:0',
'-show_entries', 'stream=codec_name', '-of', 'csv=p=0', tf.name],
capture_output=True, text=True, timeout=30)
return r.stdout.strip() or None
- Single Solve. Submitted
pcm_s16le.CORRECT. - Time Trial and Mastery. Helper agents ran
run_meta.pyfor each lane. It answered all 22 and all 110. The codec waspcm_s16lein every set. Example synthesis answer (Time Trial):["managed-001.dll","evidence-note.txt","panel-001.png","audio-001.wav"]. BothCORRECT.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 93951605ab6c2622720720f0b4329257 |
| Time Trial | CORRECT | d513d60db37e4442e23a8d568b861bcf |
| Mastery | CORRECT | e33de67dafb180b78ee04f1a23dc66b5 |
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; its saved submit says already_solved because it is a re-run, and the final status shows CORRECT. No screenshots were captured.
Reproduce
ffprobe -v quiet -select_streams a:0 -show_entries stream=codec_name -of csv=p=0 audio-001.wav
python3 -I ~/.config/huntress/solvers/run_meta.py metadata-forensics-day-17-hear-me-out single_solve /tmp/d17
The second line 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. ffprobe only reads the container headers.
Day 17: Name Collapse
Lane: Mobile (Android). Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
mobile-android-day-17-name-collapse - Prompt: "Restore behavior after deterministic identifier shrinking and decoy insertion."
What we were given
- One Android APK per case. Inside:
AndroidManifest.xml,classes.dex,assets/huntress_puzzle.json, andMETA-INF/signing files. - Single Solve:
name_collapse.apk, caseMOB-17-7A748BA6F3(12,704 bytes, SHA-256358a788a99058fcd82b457257e7738cf11b4e3965ee0093281e023feb714bf01). Its puzzle is saved assingle-solve/huntress_puzzle.json. - Time Trial: one APK (case
MOB-17-35A0C75513). 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. - Mastery mixed cases from Days 4, 8, 12, 14 and 17.
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. New codec today:
indexed. Each character of the code is shuffled to a new place.
{"schema":"huntress.mobile.puzzle.v1","day":17,"codec":"indexed","data":"-2FE1A2D163AA1N51SC0",
"order":[3,10,17,4,11,18,5,12,19,6,13,0,7,14,1,8,15,2,9,16]}
- Put the characters back.
order[i]is the output position ofdata[i]. For exampledata[0]is-, andorder[0]is 3, so-goes to position 3.
import json
p = json.load(open('single-solve/huntress_puzzle.json'))
out = [None] * len(p['order'])
for i, pos in enumerate(p['order']):
out[pos] = p['data'][i]
print(''.join(out))
Output: ANS-E26A5C21D3110FA1.
- Taught the driver. The same
indexedlogic went intomobile_puzzle()inrun_mode.py. - Ran the lane driver for all three modes:
python3 -I ~/.config/huntress/solvers/run_mode.py mobile-android-day-17-name-collapse <mode> mobile_puzzle <workdir>
- Results: Single Solve (
ANS-E26A5C21D3110FA1), Time Trial (ANS-C30EEFE8AD4BFA35) and all five Mastery answers came backCORRECT.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 67b61cdbd582ff52468fc2bd760a1cf7 |
| Time Trial | CORRECT | 499a2b7dfeb34fa590c20ffe24c3caf3 |
| Mastery | CORRECT | 55a3083d5eaeded27af5134556cac1cd |
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-17-name-collapse single_solve mobile_puzzle /tmp/d17
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 17: Fetch Quest
Lane: Script analysis. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
script-analysis-day-17-download-graph - Prompt: "The source code says where it would fetch from, and the generated network evidence says where the requests actually went. Reconcile both into one download graph, and find the indicator that shows up on only one side of the story."
What we were given
- One
evidence.zip(114,808 bytes, SHA-256fe5c28a3276922d02e6db9106ade56b0037dbdcccdec2ceab2793eb0b6e50867). Password:infected. - The same families as Day 16. New today:
- 4 AutoHotkey polyglots:
polyglot-auto_hotkey-benign-utility.ahk,-downloader,-launcher,-staged-chain. - Every host and polyglot file carries the
HUNTRESS_ANALYSIS_V1:<ENC>-<data>marker fromDay 8.
What was asked
- 1,139 questions in Single Solve. By family: PowerShell 15, JScript 72, Batch 72, VBScript 72, Python 126, Bash 154, Node.js 56, host 88, polyglot 484.
- 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: 1,139 questions. Mastery: 5,695 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.
- No new code was needed. The AutoHotkey files carry the usual marker.
- A sub-agent ran all three modes (one agent per lane that day). It reported all three
CORRECT.
- Real answers from
single-solve/answers.json:
{
"polyglot-auto_hotkey-staged-chain-role": "staged_chain",
"polyglot-auto_hotkey-staged-chain-attack": "T1059",
"polyglot-auto_hotkey-staged-chain-adapter": "operation_graph",
"polyglot-auto_hotkey-staged-chain-campaign": "AUTO_HOTKEY-d950bfce",
"polyglot-auto_hotkey-staged-chain-url": "https://auto_hotkey-d950bfcec0.example.invalid/stage",
"polyglot-auto_hotkey-staged-chain-stage-count": "2",
"polyglot-auto_hotkey-staged-chain-steps": "decode_configuration>return_configuration",
"polyglot-auto_hotkey-staged-chain-host-profile": "standalone"
}
- Time Trial and Mastery used the same solver on fresh variants.
- Time Trial: 1,139 questions, no deadline (
run_for_time: false). - Mastery: 5,695 questions in 5 sets, no deadline (
run_for_time: false). The download (script-analysis-day-17-download-graph-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 | b6a64386dafa6bd292f301db4c3b7704 |
| Time Trial | CORRECT | 15627e030030f7c6653af8c6cef93e52 |
| Mastery | CORRECT | 2972bddae28cb029d938956e4ac16c0e |
Each mode folder has answers.json and the Game Master JSON (start-, submit-, final-status-response.json). The evidence archives were not kept. No screenshots were taken.
Reproduce
The evidence archive was not kept, so the saved answers cannot be rebuilt offline. For a fresh attempt of this format:
mkdir -p /tmp/d17/ex
7z x -pinfected -o/tmp/d17/ex evidence.zip
python3 -I tools/solve_expansion.py /tmp/d17/ex start-response.json /tmp/d17/answers.json
Then submit answers.json to the Game Master (needs a token in ~/.config/huntress/gm-token). 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 17: Bacon Bits
Lane: Warmups. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
warmups-day-17 - Prompt: "Five bits of bacon, nibbled into hex. Francis would approve."
- New encoding: Baconian cipher to hex to ASCII
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. Groups of 5
a/bletters each map to a 4-bit hex nibble, then hex-decode to ASCII. - Mastery blobs use multiple encodings from Days 1-17. 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:tidy-rocket-harbor-20. Flag:dd0df151af7f6598742f54c3c8365606. - Time Trial:
CORRECT. slug:witty-comet-whale-48. Flag:9ad86c7af0425ba02c49ce2d7f719f78. - Mastery:
CORRECT. 83 slugs. Flag:b8b96f3471131bfbfa35ccc640613ccb.