2026-10-11
Day 11: D-Day
Lane: Binary reverse engineering. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
binary-reverse-engineering-day-11-d-collection-planner - Prompt: "D templates generate code the way a printing press generates pages — fast, and everywhere. Trace the runtime's template expansions back to the collection config they built."
What we were given
- One
evidence.zip. The files inside use AES encryption with the passwordinfected. Python'szipfilecan't open AES, so extract it with7z x -pinfected evidence.zip. - 12 sample programs, one per day of the series so far:
d01throughd11. They include Linux ELF programs, a .NET DLL with itsruntimeconfig.json, and Java JARs. - New today:
d11--variant-000.elf, a 64-bit Linux program written in the D language.
What was asked
- 110 questions. Every answer had to match an exact format, which the Game Master states for each question.
- Question types:
- Hashes: the SHA-256 of each sample.
- Header facts: ELF32 or ELF64, byte order, file type, CPU architecture, and entry point.
- Structure: section names in order, symbol names, and whether a
.symtabsection exists. - Code: disassemble the function
recover_codeand list its instructions. - Config (new for d11): find the program's hidden "collection config" and report its fields.
How it was solved, start to finish
- Started an attempt with the Game Master (
op=start). It returned the prompt and all 110 questions as JSON. - Downloaded the artifact (
op=artifact) and extracted it with 7z. - Answered the routine questions with the binary solver built up over Days 1–10 (
solve_tm.py):
- Hashes: SHA-256 over each extracted file's bytes.
- Header facts: read directly from the header bytes. For an ELF file, byte 4 is the class, byte 5 is the byte order, and
e_type,e_machineande_entrysit at fixed offsets. - Sections and symbols: walk the section header table, then read the names out of
.symtab. - Disassembly: look up
recover_codein the symbol table, runobjdump -dfrom its start address, and keep only the instruction text.
- Solved the new d11 part. The question spelled out the record layout, so it could be followed step by step:
- Search the d11 file for long Base64 strings (100 or more characters).
- Decode each one. One decodes to bytes that start with
HCFG. - Read the record header: version (1 byte), XOR key (1 byte), payload length (2 bytes), CRC32 (4 bytes). The payload follows.
- XOR the payload with the key, check the CRC32, and parse the result as JSON.
for m in re.finditer(rb'[A-Za-z0-9+/]{100,}={0,2}', data):
dec = base64.b64decode(m.group(0))
if dec[:4] != b'HCFG': continue
key = dec[5]; plen, crc = struct.unpack_from('<HI', dec, 6)
payload = bytes(b ^ key for b in dec[12:12+plen])
assert zlib.crc32(payload) == crc
print(m.start(), json.loads(payload))
Output: the Base64 string starts at offset 368272, the XOR key is 0x71, and the CRC32 is 0x03663005. The decoded config:
{"campaign": "BR11-000", "domain": "node-000.day11.example.invalid",
"ipv4": "198.51.100.220", "url": "https://node-000.day11.example.invalid/api/BR11-000",
"mutex": "Global\\HuntressBR11_000", "service": "HuntressLab-Day11-000", "host_model": "workstation"}
The config answers were these fields, plus the CRC32 and the offset.
- Submitted all 110 answers as one JSON object. The Game Master replied
CORRECTand returned the flag. - Time Trial and Mastery: these use the same steps on freshly generated samples, under a timer. The driver
run_tm.pydoes start → download → solve → submit in one go.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 6f8200a3c64a9105417bb8ae0ede01e1 |
| Time Trial | CORRECT | 0505ed29e6337f05a4ba90a746dbda8d |
| Mastery | CORRECT | e809e64c678a068057b3c0e7d2d91c16 |
Each mode folder has the raw start-response.json, answers.json, submit-response.json and final-status-response.json.
Reproduce
python3 -I ~/.config/huntress/solvers/run_tm.py binary-reverse-engineering-day-11-d-collection-planner single_solve /tmp/d11
This needs a Game Master token in ~/.config/huntress/gm-token. It only parses the samples and never runs them.
Day 11: What's My Name Again?
Lane: Metadata forensics. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
metadata-forensics-day-11-whats-my-name-again - Prompt: "Filenames have been randomized, but Windows version resources remember what the binaries called themselves. Recover the original identities and expose the impersonator."
What we were given
- Single Solve:
(evidence.zipmetadata-day-11-evidence.zip, 595,471 bytes, SHA-256aadf2e31e4b4f6ef17927e90c9a46ba01e13468f99a4fd8a46706ae1b6055031) withtelemetry-agent-001.exe. - Time Trial:
metadata-day-11-evidence.zip(611,883 bytes, SHA-2561e13dccafef800ae71e10d7ed996428bf58c789758efa5553b60c9f17b559892) withtelemetry-agent-002.exe. - Mastery:
metadata-forensics-day-11-whats-my-name-again-mastery.zip(1,166,795 bytes, SHA-2566c987123542378ba38982865b89cf049fb18c3ab63a857a6c39fd28b1d3ba5d0). Two inner zips withtelemetry-agent-003.exeandtelemetry-agent-004.exe.
What was asked
- One field type:
pe.version_original_filename. This is theOriginalFilenamestring in the PE version resource (VS_VERSION_INFO). - Answer ID:
d09-pe-001-pe-version-original-filename(it reuses the Day 9 prefix). - Format: "exact ordered artifact-derived text requested by the question; preserve punctuation and separators and add no explanation".
- 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: version resource strings are stored as UTF-16LE. The key name OriginalFilename is followed by NUL padding and then the value.
- Added a UTF-16 version-string reader to
run_meta.py:
def version_string(fb, field): # field = 'OriginalFilename'
key = field.encode('utf-16le')
i = fb.find(key)
if i < 0: return None
j = i + len(key)
while j + 1 < len(fb) and fb[j:j+2] == b'\x00\x00': j += 2 # skip NUL + padding
out = bytearray()
while j + 1 < len(fb):
ch = fb[j:j+2]
if ch == b'\x00\x00': break
out += ch; j += 2
return out.decode('utf-16le', 'replace') or None
The handler picks the field from the answer ID: ...-version-original-filename → OriginalFilename. The same table also maps company-name, product-name, file-version, product-version, internal-name and file-description.
- Single Solve.
telemetry-agent-001.exe→pe-base-386.exe.CORRECT. - Time Trial.
telemetry-agent-002.exe→pe-base-amd64.exe.CORRECT. - Mastery.
telemetry-agent-003.exe→pe-base-arm64.exe,telemetry-agent-004.exe→pe-base-386.exe.CORRECT.
So the random file names hide builds whose own resources say pe-base-386.exe, pe-base-amd64.exe and pe-base-arm64.exe.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | fd93317313ad8ac8165614af09fd059c |
| Time Trial | CORRECT | 1e48bc2d930807b22e9c3a46546ff9f9 |
| Mastery | CORRECT | dfdbd47b28834174d2073c7e9986e4fd |
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-11-whats-my-name-again single_solve /tmp/d11
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 searches the .exe bytes. It never runs them.
Day 11: Local Secrets
Lane: Mobile (Android). Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
mobile-android-day-11-local-secrets - Prompt: "Separate active credentials from decoys across generated local stores."
What we were given
- One Android APK per case. Inside:
AndroidManifest.xml,classes.dex,assets/huntress_puzzle.json, andMETA-INF/signing files. - Single Solve:
local_secrets.apk, caseMOB-11-4049003462(12,704 bytes, SHA-256e049a89781d24c62cdb6b83c6a2d202810088f22c27d00f1951bbc091fc78cbd). Its puzzle is saved assingle-solve/huntress_puzzle.json. - Time Trial: one APK (case
MOB-11-5CAFBD2A72). 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 limits: Time Trial 50 seconds, 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
xorwith key 81 (Day 4 usedxorwith key 29).
{"schema":"huntress.mobile.puzzle.v1","day":11,"codec":"xor","data":"EB8CfGkXY2NkZmVmYBUXZWkVYGU=","key":81}
- Decoded it: Base64-decode
data, then XOR every byte withkey.
import json, base64
p = json.load(open('single-solve/huntress_puzzle.json'))
print(bytes(b ^ p['key'] for b in base64.b64decode(p['data'])).decode())
Output: ANS-8F2257471DF48D14.
- 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-11-local-secrets <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-8F2257471DF48D14), Time Trial (ANS-57678213871E17EC) and all three Mastery answers came backCORRECT.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 47d93eb4877742ff8631ac176deea554 |
| Time Trial | CORRECT | 744b8f9456b9c93300f5f6cf70b6482d |
| Mastery | CORRECT | 5a02d337ee2a83fa7754c5f17065d066 |
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-11-local-secrets single_solve mobile_puzzle /tmp/d11
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 11: By Any Other Name
Lane: Script analysis. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
script-analysis-day-11-native-api-semantics - Prompt: "These scripts reach for native APIs by name, but a name isn't a behavior. Map each reference to the receipt-backed action it models, and flag the call whose claimed purpose the evidence doesn't support."
What we were given
- One
evidence.zip(90,782 bytes, SHA-2566488fdbba520b4c959216273bd629e25c71d2af329c7cb697ee014136b0056c6). Password:infected. - The same families as Day 10. New today:
- 4 TypeScript polyglots:
polyglot-typescript-benign-utility.ts,-downloader,-launcher,-staged-chain. - 2 more advanced Bash files:
dynamic-file-descriptor.sh,nameref-dispatch.sh. - Every host and polyglot file carries the
HUNTRESS_ANALYSIS_V1:<ENC>-<data>marker fromDay 8.
What was asked
- 811 questions in Single Solve. By family: PowerShell 15, JScript 72, Batch 72, VBScript 72, Python 126, Bash 112, Node.js 56, host 66, polyglot 220.
- 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: 811 questions. Mastery: 1,622 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.
- No new code was needed. The TypeScript files carry the usual marker. The only new work that day was in the metadata lane.
- Submitted. The Single Solve was
CORRECT(811/811).
- Real answers from
single-solve/answers.json:
{
"polyglot-typescript-staged-chain-role": "staged_chain",
"polyglot-typescript-staged-chain-attack": "T1059",
"polyglot-typescript-staged-chain-adapter": "operation_graph",
"polyglot-typescript-staged-chain-campaign": "TYPESCRIPT-aa5043eb",
"polyglot-typescript-staged-chain-url": "https://typescript-aa5043eb9b.example.invalid/stage",
"polyglot-typescript-staged-chain-stage-count": "3",
"polyglot-typescript-staged-chain-steps": "decode_embedded>write_file>dispatch_process",
"polyglot-typescript-staged-chain-host-profile": "standalone"
}
- Time Trial and Mastery used the same solver on fresh variants.
- Time Trial: 811 questions, deadline 50 seconds after the start.
- Mastery: 1,622 questions in 2 sets, deadline 80 seconds after the start. The download (
script-analysis-day-11-native-api-semantics-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 | 167c4e9dc20bc56b6f7a7bff930a50a2 |
| Time Trial | CORRECT | 796d90e7836b88013cdae94225ae6243 |
| Mastery | CORRECT | 2a963cf2f2851f2b9530d1a94eed0b06 |
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/d11/ex
7z x -pinfected -o/tmp/d11/ex repos/day-11-script-analysis-by-any-other-name/single-solve/evidence.zip
python3 -I tools/solve_expansion.py /tmp/d11/ex \
repos/day-11-script-analysis-by-any-other-name/single-solve/start-response.json /tmp/d11/answers.json
This rebuilds all 811 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 11: Safe Travels
Lane: Warmups. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
warmups-day-11 - Prompt: "A safe base for a URL-friendly vacation."
- New encoding: base64url
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. URL-safe base64 variant (
-and_instead of+and/). Standard base64url decode. - Mastery blobs use multiple encodings from Days 1-11. 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:crisp-starfish-petal-89. Flag:a7b64664359552ba59c9edcf03d88a47. - Time Trial:
CORRECT. slug:quick-puzzle-tiger-30. Flag:97f3c2c1ed8c6d404397b7a39bd33331. - Mastery:
CORRECT. 53 slugs. Flag:00b25b47474fcbadb34c4026611a8230.