2026-10-20
Day 20: Resourceful
Lane: Binary reverse engineering. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
binary-reverse-engineering-day-20-resources-and-overlays - Prompt: "Binaries have attics: resources, overlays, bytes past the end of the sections. Rummage through this one's hidden storage and map every boundary."
What we were given
- One
evidence.zip(33,207,971 bytes, SHA-256cfc4f3e2213afdd913e403ecdc9cded5610474b7aa24367a017344acb4ab7da5). AES encrypted, passwordinfected. - The earlier files again:
d01tod19. - New today:
d20--variant-000.elf(1,201,351 bytes). Like Day 19 it has bytes glued onto the end, but this overlay starts with the magicRS20(a "resource" record).
What was asked
- 240 questions in Single Solve and Time Trial. Mastery had five deliveries, so 1,200.
- Question types:
- Hashes: SHA-256 of each member.
- d01 to d19: the same questions as Day 19.
- d20 (new): machine, architecture, format,
HCFGversion, the config fields, the CRC32, plus: overlay_offset: where the finalRS20magic starts.hcfg_resource_size: the little-endian size field in theRS20header.
How it was solved, start to finish
- Ran the driver
run_tm.py: start the attempt, download the zip, runsolve_tm.py, submit. - d01–d19 were answered as on Day 19.
- Read the
RS20header. The question gave the layout:
- +8: size of the
HCFGresource (4 bytes, little-endian); - +12: size of a "scratch" block (2 bytes, little-endian);
- +16 to +47: SHA-256 of the scratch block;
- +48: the
HCFGresource, then the scratch block, which must end exactly at the end of the file.
- Config: the resource at +48 is a normal
HCFGrecord.solve_tm.pyfinds it with its first step, the plainHCFGscan.
- The old note for this day said the
RS20payload is packed likePK19(theror8unpack). The re-check below shows the record at +48 is plain.solve_tm.pywould only try the unpack if the plain scan failed.
- Overlay fields: both overlay questions name
PK19andRS20. The solver picks the magic whose number matches the day (RS20for d20), finds it, and reads the size field at +8.
Re-checked on the saved sample:
d20 length 1201351, RS20 at 1200888
resource size (u32 at +8) = 380, scratch size (u16 at +12) = 35, ends at end of file: True
scratch SHA-256 matches; bytes at +48 = b'HCFG'
HCFG offset=1200936 version=1 xor_key=0x51 len=368 crc32=0x570dddce
JSON: {"campaign":"BR20-000","domain":"node-000.day20.example.invalid","ipv4":"198.51.100.130","url":"https://node-000.day20.example.invalid/api/BR20-000","mutex":"Global\\HuntressBR20_000", ...}
Answers: d20_analysis_overlay_offset = 1200888, d20_analysis_hcfg_resource_size = 380, CRC32 0x570dddce, campaign BR20-000.
- Submitted all 240 answers (
answers.json). Result:CORRECT. - Time Trial: a fresh variant, same steps. Result:
CORRECT. - Mastery: five deliveries (1,200 answers), same steps. Result:
CORRECT.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | d682a3eda342c249a3666a3134edd492 |
| Time Trial | CORRECT | 557935f78feafd5d2e13f6bbd06c6d39 |
| Mastery | CORRECT | bc62211f26677a7746208165568b2d95 |
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/d20/deliveries && cp single-solve/evidence.zip /tmp/d20/deliveries/delivery-1.zip
python3 -I ~/.config/huntress/solvers/solve_tm.py single-solve/start-response.json /tmp/d20/deliveries /tmp/d20/answers.json
Checked on 2026-11-01: this gives the same 240 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-20-resources-and-overlays single_solve /tmp/d20
This needs a Game Master token in ~/.config/huntress/gm-token.
Day 20: Universal Appeal
Lane: Metadata forensics. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
metadata-forensics-day-20-universal-appeal - Prompt: "A macOS deployment includes thin and universal binaries mixed with archives. Enumerate every CPU type and identify what truly supports the advertised fleet."
What we were given
- Single Solve:
(evidence.zipmetadata-day-20-evidence.zip, 203 bytes) withmacos-001.bin. - Time Trial:
evidence.zip(628,759 bytes, SHA-256fdd06df803d76e06c330815280b6615db05e953443efa4981728c9c273d45cec). One file of each type so far, now includingmacos-001.bin. - Mastery:
metadata-forensics-day-20-universal-appeal-mastery.zip(3,144,536 bytes, SHA-256cc4842a049ff29b8bed57887aeb55cee122f86f024104a5fcd43f6eb5a67846f). Five inner zips,evidence-01.ziptoevidence-05.zip. - New today: macOS Mach-O programs, either "thin" (one CPU) or "universal"/fat (several CPUs).
What was asked
- Single Solve: 1 question:
macho.cpu_type_setformacos-001.bin. Format: "compact valid JSON array with exact values and order". The format text does not say how to write each CPU type. - Time Trial: 25 questions. Mastery: 125 (5 sets × 25).
- Question types: everything from Day 19, plus the Mach-O CPU type set.
How it was solved, start to finish
- Wrote a Mach-O parser. Read the magic number first:
- Fat/universal (
cafebabe, orcafebabffor 64-bit tables): the header is big-endian. The arch count is at +4. Each arch entry starts at +8 (20 bytes each, 32 for the 64-bit table) and begins with itscputype. - Thin (
feedface/feedfacfbig-endian,cefaedfe/cffaedfelittle-endian):cputypeis at +4, in the file's byte order.
- First answer was wrong. The first version mapped CPU numbers to names. It returned
["arm64"]and the Game Master saidincorrect. - Found the format by testing one value at a time on the Single Solve. These were all
incorrect:arm64,ARM64,16777228,0x0100000c,CPU_TYPE_ARM64,arm64 (0x0100000c),["arm64"],arm64,x86_64,["x86_64","arm64"],12,MACH64 ARM64,[16777228],["16777228"],[12]. This one wasCORRECT:
["0x0100000c"]
So the grader wants each cputype as an 8-digit hex string with 0x, inside a JSON array. (0x0100000c is ARM64.)
- Fixed the handler in
run_meta.py:
seen = set(); names = []
for t in types: # header order, no duplicates
h = '0x%08x' % t
if h not in seen: seen.add(h); names.append(h)
return json.dumps(names, separators=(',', ':'))
- Time Trial and Mastery.
run_meta.pyanswered all 25 and all 125. Everymacos-001.bintoday gave["0x0100000c"]. Example synthesis answer (Time Trial):["shortcut-001.lnk","macos-001.bin","document-001.pdf","evidence-note.txt"]. BothCORRECT.
Later note: on Day 23, fat files with several CPU types appeared. A format search there showed the grader wants the list sorted, so the handler now returns sorted(names).
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | e426ff4805f25d881886829b48115ec0 |
| Time Trial | CORRECT | 07fe4cc090cfb448ee34f23a4e9a7932 |
| Mastery | CORRECT | 69f95042538542df7dc6448cc4a4fcbf |
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
python3 -I ~/.config/huntress/solvers/run_meta.py metadata-forensics-day-20-universal-appeal single_solve /tmp/d20
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 Mach-O header bytes. It never runs the program.
Day 20: Loaded Later
Lane: Mobile (Android). Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
mobile-android-day-20-loaded-later - Prompt: "Analyze a challenge-signed secondary DEX and recover the module contract."
What we were given
- One Android APK per case. New today: a second DEX file,
assets/payload.dex(508 bytes in the Single Solve APK). The APK is 12,768 bytes. - Single Solve:
loaded_later.apk, caseMOB-20-6AE5A9BC36, SHA-256e870c4e7a7a438df46a56216a0ca04fca21042637f2347e4b98b226859a622ea. Its puzzle is saved assingle-solve/huntress_puzzle.json. - Time Trial: one APK (case
MOB-20-5A5C3DF811). 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 2, 9, 11, 18 and 20.
How it was solved, start to finish
The app was never installed or run. The secondary DEX was never loaded or run either.
- Started the Single Solve and downloaded the APK.
- Read the puzzle asset. New codec today:
dynamic.datais not the code. It is a path inside the APK:
{"schema":"huntress.mobile.puzzle.v1","day":20,"codec":"dynamic","data":"assets/payload.dex"}
- Followed the path. Read the bytes of
assets/payload.dexfrom the APK zip and searched them for the answer pattern:
import json, re, zipfile
z = zipfile.ZipFile('single-solve/loaded_later.apk')
p = json.loads(z.read('assets/huntress_puzzle.json'))
m = re.search(rb'ANS-[A-Fa-f0-9]{8,}', z.read(p['data']))
print(m.group().decode())
Output: ANS-ED497119EFACC9FF.
- Taught the driver. The same
dynamicbranch 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-20-loaded-later <mode> mobile_puzzle <workdir>
- Results: Single Solve (
ANS-ED497119EFACC9FF), Time Trial (ANS-43ED6F08E3A1A6E2) and all five Mastery answers came backCORRECT.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 2e2ea5a3263099379f0fc73ddf80ad53 |
| Time Trial | CORRECT | d493fdbfb2ceb42571efb5ccfc8d34b5 |
| Mastery | CORRECT | aea22fb7ba9a94326bac22f938b7f263 |
Each mode folder has answers.json, start-response.json, submit-response.json and final-status-response.json. The Single Solve submit-response.json says already_solved because it is a resubmit. Its final-status-response.json holds the CORRECT result and flag. 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-20-loaded-later single_solve mobile_puzzle /tmp/d20
This needs a Game Master token in ~/.config/huntress/gm-token. It only unzips the APK and reads files inside it. It never installs or runs the app.
Day 20: The Butler Did It
Lane: Script analysis. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
script-analysis-day-20-jenkins-pipeline-intrusion - Prompt: "A Jenkins Pipeline splits its Groovy stages between controller and agent, and not every step runs where it appears to. Recover the pipeline's intent, separate controller semantics from agent semantics, and trace the modeled build into its prior-language stages."
What we were given
- One
evidence.zip(130,248 bytes, SHA-256b43ad00571c6597bd3266d38feea1416c80a41da9f39eb16123024e3c1690f3a). Password:infected. - The same families as Day 19. New today:
- 2 new host files:
host-jenkins-pipeline-groovy.groovy(Jenkins Pipeline) andhost-classic-asp-vbscript.vbs(Classic ASP). - 4 Groovy polyglots:
polyglot-groovy-benign-utility.groovy,-downloader,-launcher,-staged-chain. - 2 more advanced Bash files:
coprocess-block.sh,mapfile-process.sh. - Every host and polyglot file carries the
HUNTRESS_ANALYSIS_V1:<ENC>-<data>marker fromDay 8.
What was asked
- 1,329 questions in Single Solve. By family: PowerShell 15, JScript 72, Batch 72, VBScript 72, Python 126, Bash 168, Node.js 56, host 132, polyglot 616.
- 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,329 questions. Mastery: 6,645 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 Jenkins, Classic ASP and Groovy files carry the usual marker. A pre-check of the Single Solve came back
CORRECT.
- Then the five file lanes ran as parallel agents for the timed modes. The script lane came back
CORRECTin all three modes.
- Real answers from
single-solve/answers.json:
{
"host-jenkins-pipeline-groovy-role": "staged_chain",
"host-jenkins-pipeline-groovy-attack": "T1059",
"host-jenkins-pipeline-groovy-adapter": "operation_graph",
"host-jenkins-pipeline-groovy-campaign": "GROOVY-49671532",
"host-jenkins-pipeline-groovy-url": "https://groovy-49671532e9.example.invalid/stage",
"host-jenkins-pipeline-groovy-stage-count": "3",
"host-jenkins-pipeline-groovy-steps": "decode_embedded>write_file>dispatch_process",
"host-jenkins-pipeline-groovy-host-profile": "jenkins_pipeline"
}
- Time Trial and Mastery used the same solver on fresh variants.
- Time Trial: 1,329 questions, no deadline (
run_for_time: false). - Mastery: 6,645 questions in 5 sets, no deadline (
run_for_time: false). The download (script-analysis-day-20-jenkins-pipeline-intrusion-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 | 154d4259f651eb0ff758369fdc1e71f5 |
| Time Trial | CORRECT | 547a9df584ff76d9c40d7feb17d118bf |
| Mastery | CORRECT | f1de734232c93d9540fe2ea89281819f |
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/d20/ex
7z x -pinfected -o/tmp/d20/ex evidence.zip
python3 -I tools/solve_expansion.py /tmp/d20/ex start-response.json /tmp/d20/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 20: Big Entrance
Lane: Warmups. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
warmups-day-20 - Prompt: "Big end first. Two bytes per character, forwards."
- New encoding: UTF-16BE hex
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. Hex string representing UTF-16 big-endian bytes. Hex-decode, then interpret as UTF-16BE.
- Mastery blobs use multiple encodings from Days 1-20. 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:deft-blanket-clover-43. Flag:7025c949eef37dc001f6f4932ad6a2a2. - Time Trial:
CORRECT. slug:crisp-compass-coral-68. Flag:c671df8c523ecf60198d759ca6d1a724. - Mastery:
CORRECT. 98 slugs. Flag:4d398a629126a79997e85146fbb727ce.
Day 20 — Administratively Speaking (Missing Authorization)
Lane: Web Exploitation · Challenge ID: web-exploitation-day-05-administratively-speaking
> A staff-only door with no lock on it — just a sign.
What we were given
A live Django web target with API endpoints.
How it was solved
The challenge demonstrates a missing authorization check on a privileged endpoint.
- Queried
/api/clues— a recon endpoint present on most Web Exploitation targets. It returned the framework (Django), afeature_route(/dispatch-fa3df6), and the current role (analyst). - The route name suggests an admin dispatch function. Navigated to
/dispatch-fa3df6directly — no authentication token, no role escalation, no header spoofing needed. - The endpoint returned a success response with
effect: framework_authorization_bypassedand the proof:proof_cfcd5162b3f942558ec35aa13c2cc4d3.
Root cause: The admin route exists and is functional but has no authorization middleware. The /api/clues endpoint helpfully discloses the route path. Any unauthenticated request to the dispatch endpoint succeeds.
Automated with web_solve.py (ex_auth): /api/clues scrape → follow feature_route → extract proof.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | c6eb94b0e87ca2fda3c524d08f2cec81 |
| Time Trial | CORRECT | same technique, fresh target |
| Mastery | CORRECT | mixed vuln types across targets |
Day 20 — Stay in Your Directory (LFI / Path Traversal)
Lane: Web Exploitation · Challenge ID: web-exploitation-day-04-lfi
> The viewer should stay inside its pages directory; proof is mounted at /run/huntress/objective.txt.
What we were given
A live PHP web target with a document viewer.
How it was solved
The challenge is local file inclusion via path traversal — the viewer includes whatever file path you give it.
- The app has a viewer at
/reader.php?doc=<name>that loads documents from a pages directory. - The
docparameter has no path confinement. The prompt tells us the proof is at/run/huntress/objective.txt. - Requested
GET /reader.php?doc=../../../../../run/huntress/objective.txt— the traversal sequence escapes the pages directory and reaches the absolute path. - The server included the file contents in the response, revealing the proof:
proof_1415dbfdece14135ac9246cbf064051e.
Root cause: The PHP include/readfile call uses the doc parameter without sanitizing ../ sequences or restricting to a directory. An attacker can read any file the web server process can access.
Automated with web_solve.py (ex_lfi): discovers viewer endpoints from the HTML, fuzzes parameter names (doc, page, file, path), and tries traversal prefixes to reach the known proof path.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 25279d7513cf80cd3b01a75b740461d8 |
| Time Trial | CORRECT | same technique, fresh target |
| Mastery | CORRECT | mixed vuln types across targets |