2026-10-19
Day 19: Jack in the Box
Lane: Binary reverse engineering. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
binary-reverse-engineering-day-19-static-unpacking - Prompt: "There's a payload hiding inside this binary, and a little decoder stub wound up to pop it out. Find the stub, watch it work, and catch what's inside — statically."
What we were given
- One
evidence.zip(32,838,781 bytes, SHA-2568617b900a67c73c10c428c74879a0ad0790b1e5c767ca983234d599ec9278be7). AES encrypted, passwordinfected. - The earlier files again:
d01tod18. - New today:
d19--variant-000.elf(11,232 bytes). Extra bytes are glued onto the end of the program (an "overlay"). The overlay starts with the magicPK19and holds a packed payload.
What was asked
- 228 questions in Single Solve and Time Trial. Mastery had five deliveries, so 1,140.
- Question types:
- Hashes: SHA-256 of each member.
- d01 to d18: the same questions as Day 18.
- d19 (new): machine, architecture, format,
HCFGversion, the config fields, the CRC32, plus: overlay_offset: where thePK19magic starts in the file.overlay_size: file length minus that offset.
How it was solved, start to finish
- Ran the driver
run_tm.py: start the attempt, download the zip, runsolve_tm.py, submit. - d01–d18 were answered as on Day 18.
- Unpacked the overlay statically (the new part). The question gave the layout of the
PK19header:
- byte +5 is key
k1, byte +6 is keyk2; - +8 is the packed length (4 bytes, little-endian);
- +12 is the SHA-256 of the unpacked bytes (32 bytes);
- the packed bytes start at +44.
Each byte unpacks as ror8(byte XOR k2, 3) XOR k1. The result starts with a normal HCFG record.
o = data.rfind(b'PK19')
k1, k2 = data[o+5], data[o+6]; plen = struct.unpack_from('<I', data, o+8)[0]
unp = bytes((((x ^ k2) >> 3 | ((x ^ k2) << 5) & 0xff) & 0xff) ^ k1 for x in data[o+44:o+44+plen])
assert hashlib.sha256(unp).digest() == data[o+12:o+44]
This was added to solve_tm.py as its "step 4": if no literal or Base64 record is found, look for a PK19 (or RS20) overlay and unpack it.
- Overlay fields: the solver takes the magic named in the question (
PK19), finds it in the file, and reports its offset andlength − offset.
Re-checked on the saved sample:
d19 length 11232, PK19 at 10808, k1=0x21 k2=0xa4, packed length 380, overlay size 424
unpacked SHA-256 matches; unpacked bytes start with HCFG
HCFG version=1 xor_key=0x91 len=368 crc32=0xd02e2211
JSON: {"campaign":"BR19-000","domain":"node-000.day19.example.invalid","ipv4":"198.51.100.110","url":"https://node-000.day19.example.invalid/api/BR19-000","mutex":"Global\\HuntressBR19_000", ...}
Answers: d19_analysis_overlay_offset = 10808, d19_analysis_overlay_size = 424, version 1, CRC32 0xd02e2211, campaign BR19-000.
- Submitted all 228 answers (
answers.json). Result:CORRECT. - Time Trial: a fresh variant, same steps. Result:
CORRECT. - Mastery: five deliveries (1,140 answers), same steps. Result:
CORRECT.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 14e394446b80b4b772be6ef27d868548 |
| Time Trial | CORRECT | 389ce59443a9a6e8c73de6acf6f602aa |
| Mastery | CORRECT | e9f8d5ff1ddacaf2ba88afb13692bc85 |
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/d19/deliveries && cp single-solve/evidence.zip /tmp/d19/deliveries/delivery-1.zip
python3 -I ~/.config/huntress/solvers/solve_tm.py single-solve/start-response.json /tmp/d19/deliveries /tmp/d19/answers.json
Checked on 2026-11-01: this gives the same 228 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-19-static-unpacking single_solve /tmp/d19
This needs a Game Master token in ~/.config/huntress/gm-token.
Day 19: Little Endian on the Prairie
Lane: Metadata forensics. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
metadata-forensics-day-19-little-endian-on-the-prairie - Prompt: "Linux binaries from several systems have been pooled with Windows executables and renamed data. Determine architecture directly from the ELF header and rebuild deployment groups."
What we were given
- Single Solve:
(evidence.zipmetadata-day-19-evidence.zip, 1,849 bytes) withcollector-001.elf. - Time Trial:
evidence.zip(628,573 bytes, SHA-25633fa330265ecc494d62a862e0994f6174052069dc724bb68844a0ebd280d953a). One file of each type so far, now includingcollector-001.elf. - Mastery:
metadata-forensics-day-19-little-endian-on-the-prairie-mastery.zip(3,143,708 bytes, SHA-256e142b94193b59ed3fadc47d5129ffc1d82b59a057c4bf1b288216d923d34e530). Five inner zips,evidence-01.ziptoevidence-05.zip. - New today: Linux ELF programs.
What was asked
- Single Solve: 1 question:
elf.e_machine_u16_hexforcollector-001.elf. Format: lowercase hex with a0xprefix. - Time Trial: 24 questions. Mastery: 120 (5 sets × 24).
- Question types: everything from Day 18, plus the ELF machine field.
How it was solved, start to finish
The method: e_machine is a 2-byte field at offset 0x12 of the ELF header. Its byte order follows the file's own byte-order flag, EI_DATA (byte 5: 1 = little-endian, 2 = big-endian).
- Added a handler to
run_meta.py:
if fb[:4] == b'\x7fELF':
end = '<' if fb[5] == 1 else '>'
return '0x%04x' % struct.unpack_from(end + 'H', fb, 0x12)[0]
- Single Solve.
collector-001.elf→0x003e(x86-64).CORRECT. - Time Trial and Mastery. A helper agent ran
run_meta.pyfor all three modes. It answered all 24 and all 120.e_machinewas0x003ein every set. Example synthesis answer (Time Trial):["evidence-note.txt","collector-001.elf","shortcut-001.lnk","document-001.pdf"]. BothCORRECT.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 4ebef4b003c567143a4d39ae9a08b56e |
| Time Trial | CORRECT | bb404ebcb85f74536a90ebce9d4d6829 |
| Mastery | CORRECT | 3e05c3841f13420368de91e44045fb6f |
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-19-little-endian-on-the-prairie single_solve /tmp/d19
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 ELF header bytes. It never runs the program.
Day 19: Reflection Maze
Lane: Mobile (Android). Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
mobile-android-day-19-reflection-maze - Prompt: "Reconstruct reflective dispatch across generated equivalent call graphs."
What we were given
- One Android APK per case. Inside:
AndroidManifest.xml,classes.dex,assets/huntress_puzzle.json, andMETA-INF/signing files. - Single Solve:
reflection_maze.apk, caseMOB-19-98E3A78C44(12,704 bytes, SHA-2568457f9fe2db0f217efcc0385776150328884bc3af1852112e8a5371ef1ef621d). Its puzzle is saved assingle-solve/huntress_puzzle.json. - Time Trial: one APK (case
MOB-19-86214CB8D6). 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 3, 5, 11, 18 and 19.
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:
reflection. The answer is inline indata:
{"schema":"huntress.mobile.puzzle.v1","day":19,"codec":"reflection","data":"ANS-DFCDF6E9F6ABE632"}
So the reflective call graph in the DEX did not have to be traced for this answer.
- Taught the driver.
reflectionjoined the codecs whosedatais returned as is:
if codec in ('native','plain','identity','reflection'): return pj['data']
- Ran the lane driver for all three modes:
python3 -I ~/.config/huntress/solvers/run_mode.py mobile-android-day-19-reflection-maze <mode> mobile_puzzle <workdir>
- Results: Single Solve (
ANS-DFCDF6E9F6ABE632), Time Trial (ANS-8FEAB1027C5513E4) and all five Mastery answers came backCORRECT.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 11767c15c08b87610cf9d1a0739f0653 |
| Time Trial | CORRECT | 6dd89e7bd033d478969f298b8e55b31a |
| Mastery | CORRECT | 9f1a4c576e0d25d8d02e25ed37fba80d |
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:
unzip -p single-solve/reflection_maze.apk assets/huntress_puzzle.json
A fresh run with the driver:
python3 -I ~/.config/huntress/solvers/run_mode.py mobile-android-day-19-reflection-maze single_solve mobile_puzzle /tmp/d19
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 19: Sharp Practice
Lane: Script analysis. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
script-analysis-day-19-managed-assembly-bridge - Prompt: "A Roslyn C# script and an inline ASPX host act as a bridge that carries managed code back into the script corpus. Recover their layered configuration, resolve each static handoff, and work out where the bridge actually leads."
What we were given
- One
evidence.zip(124,102 bytes, SHA-256e1d310a9c5b739906fb0a4ad347b5cdcfc5ae1721689f0667aad7eedbace0471). Password:infected. - The same families as Day 18. New today:
- 1 new host file:
host-aspx-inline-csharp-csharp-script.csx(inline ASPX with C#). - 4 C# script (Roslyn
.csx) polyglots:polyglot-csharp_script-benign-utility.csx,-downloader,-launcher,-staged-chain. - Every host and polyglot file carries the
HUNTRESS_ANALYSIS_V1:<ENC>-<data>marker fromDay 8.
What was asked
- 1,249 questions in Single Solve. By family: PowerShell 15, JScript 72, Batch 72, VBScript 72, Python 126, Bash 154, Node.js 56, host 110, polyglot 572.
- 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,249 questions. Mastery: 6,245 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 Single Solve crashed on the new C# files. In the
.csxhost the marker sits inside a C# string, and that string also holds literal\nescapes. The marker regex took everything up to whitespace, a quote or<([^\s"'<]+). So it also swallowed the\n#nullable ...text after the hex. Real text from the same host file (its Day 29 copy is kept in this repo):
private static readonly string EmbeddedCsx_ea4ea660 = "// HUNTRESS_ANALYSIS_V1:HEX-763d337c6c61...\n#nullable enable\nusing System.Collect...
- Fixed the regex in
hostpgdec.pyto stop at a backslash too:
m = re.search(r'HUNTRESS_ANALYSIS_V1:([A-Z0-9]+)-([^\s"\'<\\]+)', text)
- Submitted. The Single Solve was
CORRECT. Then the five file lanes (warmup, metadata, mobile, binary, script) ran as parallel agents for the timed modes.
- Real answers from
single-solve/answers.json:
{
"host-aspx-inline-csharp-csharp-script-role": "staged_chain",
"host-aspx-inline-csharp-csharp-script-attack": "T1059",
"host-aspx-inline-csharp-csharp-script-adapter": "operation_graph",
"host-aspx-inline-csharp-csharp-script-campaign": "CSHARP_SCRIPT-7f5c5dc7",
"host-aspx-inline-csharp-csharp-script-url": "https://csharp_script-7f5c5dc76d.example.invalid/stage",
"polyglot-csharp_script-downloader-role": "downloader",
"polyglot-csharp_script-downloader-attack": "T1105",
"polyglot-csharp_script-downloader-adapter": "http_client",
"polyglot-csharp_script-downloader-campaign": "CSHARP_SCRIPT-228aa02e",
"polyglot-csharp_script-downloader-url": "https://csharp_script-228aa02e3d.example.invalid/stage"
}
- Time Trial and Mastery used the same solver on fresh variants.
- Time Trial: 1,249 questions, no deadline (
run_for_time: false). - Mastery: 6,245 questions in 5 sets, no deadline (
run_for_time: false). The download (script-analysis-day-19-managed-assembly-bridge-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 | 3b1563fd32d9df75ba85f94b87978775 |
| Time Trial | CORRECT | bb8aeae2c901862e78806bdf77cef0a9 |
| Mastery | CORRECT | 06aba652c8d2073f3224bfb02a39887a |
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/d19/ex
7z x -pinfected -o/tmp/d19/ex evidence.zip
python3 -I tools/solve_expansion.py /tmp/d19/ex start-response.json /tmp/d19/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 19: Little Things
Lane: Warmups. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
warmups-day-19 - Prompt: "Little end first. Two bytes per character, backwards."
- New encoding: UTF-16LE 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 little-endian bytes. Hex-decode, then interpret as UTF-16LE.
- Mastery blobs use multiple encodings from Days 1-19. 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:jaunty-raven-glade-73. Flag:1f83a587e86c2564dc0bc3d33f809d03. - Time Trial:
CORRECT. slug:calm-chimney-nugget-38. Flag:1ccfa0dd57e7e8c6fa7201aa5f56b52f. - Mastery:
CORRECT. 93 slugs. Flag:45e1b4829c1fb42a9d9c35591d7ed220.
Day 19 — Back Up a Minute (Backup Exposure)
Lane: Web Exploitation · Challenge ID: web-exploitation-day-01-backup-exposure
> The deploy left its diary behind. Somewhere out in the open, an old backup is still telling secrets.
What we were given
A live web target assigned at attempt start. No downloadable artifact.
How it was solved
The challenge tests for sensitive file exposure via leftover deployment artifacts.
- Fetched
/robots.txton the target. It had aDisallowentry for/snapshots-e181b/— a directory the site wanted hidden from crawlers but left world-readable. - Browsed that directory. The server had directory listing enabled, revealing
environment-copy-edb7fe.json.bak. - Downloaded the
.bakfile. It was a JSON environment dump with asupport_notefield containing the proof:proof_604b955708e749e98bd33821bb9ddfa8. - Submitted the proof string.
Root cause: Deployment tooling left a backup file in a web-accessible directory. robots.txt advertised the path (hiding it from honest crawlers, not attackers), and directory listing exposed the filename.
Automated with web_solve.py (ex_backup): robots.txt scrape → directory listing → backup file download → proof regex extraction.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 1ebe70e3b676f08b30e12660d22369c5 |
| Time Trial | CORRECT | same technique, fresh target |
| Mastery | CORRECT | mixed vuln types across targets |
Day 19 — Permission to Slip (IDOR)
Lane: Web Exploitation · Challenge ID: web-exploitation-day-02-idor
> Pity the object API never got the memo — slip into somebody else's row.
What we were given
A live web app called "Pocket SOC" — a case management system with API endpoints.
How it was solved
This is an Insecure Direct Object Reference (IDOR) challenge — the API lets you access records belonging to other users by guessing/discovering their IDs.
- Visited
/to get acase_sessioncookie (required for authenticated API calls). - Queried
/api/history— the activity feed. It listed events across the workspace, including a reference to case17089owned by theexecutiverole with visibilityreference_only. That case ID shouldn't have been accessible to our session. - Requested
/api/briefs/17089with our session cookie. The endpoint performed no authorization check — it returned the full case record despite us not being the owner. - The response body contained the proof string:
proof_967727bd8687465cb10dbd64379def37.
Root cause: The /api/briefs/<id> endpoint serves any case by ID without checking whether the requesting session owns it. The activity feed leaks foreign case IDs, giving an attacker both the reference and the means to read it.
Automated with web_solve.py (ex_idor): session init → activity feed scrape → foreign ID discovery → direct object access.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | bf6b7bde7ab10892690adddcefb56e99 |
| Time Trial | CORRECT | same technique, fresh target |
| Mastery | CORRECT | mixed vuln types across targets |
Day 19 — Query Me This (SQL Injection)
Lane: Web Exploitation · Challenge ID: web-exploitation-day-03-sqli
> The search box trusts you a little too much. Read the row it was never supposed to show you.
What we were given
A live web target with a search form.
How it was solved
Classic SQL injection through an unsanitized search parameter.
- The app had a search form submitting to
GET /lookup?q=. Entering' OR '1'='1returned all visible rows — confirming the input goes straight into a SQL query without parameterization. - The query wraps user input in parentheses and applies a visibility filter (something like
WHERE (user_input) AND visibility='public'). A simpleOR 1=1only returned public rows. - Injected
') OR 1=1--to close the parenthesized group and comment out the visibility filter. This returned a 4th, hidden row that the normal query suppresses. - The hidden row's note field contained the proof:
proof_287e1e5a901e4844b634684d2583fe25.
Root cause: The search query concatenates user input directly into SQL. The parenthesized query structure and visibility filter create a false sense of access control, but the injection point lets an attacker break out of both.
Automated with web_solve.py (ex_sqli): form discovery → parameter fuzzing with a set of injection variants (closing parens, comments, boolean tautologies) → proof regex match.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 161bb61b4e2367c6fda2d59703199078 |
| Time Trial | CORRECT | same technique, fresh target |
| Mastery | CORRECT | mixed vuln types across targets |