2026-10-21
Day 21: Shared Custody
Lane: Binary reverse engineering. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
binary-reverse-engineering-day-21-shared-library-boundaries - Prompt: "No binary is an island — this one leans on shared libraries for everything. Trace the exports, the imports, and the loader's handshake, and mind the boundaries."
What we were given
- One
evidence.zip(33,477,071 bytes, SHA-2562ecbedd8939df63f3dad1a97d8945e5f8b4fac41f4de7d59e6d6cb46b0f3102b). AES encrypted, passwordinfected. - The earlier files again:
d01tod20. - New today: a pair of OCaml files that work together:
d21--variant-000-loader.elf(780,008 bytes): the main program (64-bit ELF executable). It has manycaml…andDynlinknames.d21--variant-000-plugin.cmxs(9,120 bytes): an OCaml native plugin (an ELF shared object).
What was asked
- 252 questions in Single Solve and Time Trial. Mastery had five deliveries, so 1,260.
- Question types:
- Hashes: SHA-256 of both d21 members (and all older members).
- d01 to d20: the same questions as Day 20.
- d21 (new):
loader_machineandplugin_machine: the decimale_machineof each file.config_*andplugin_config_*:campaign,domain,mutexandurl. The question says the loader has no scored config, so both sets come from the plugin.
How it was solved, start to finish
- Ran the driver
run_tm.py: start the attempt, download the zip, runsolve_tm.py, submit. - d01–d20 were answered as on Day 20.
- Found where the config lives. Re-checked on the saved samples:
d21--variant-000-loader.elf (no record found)
d21--variant-000-plugin.cmxs HCFG offset=4364 version=1 xor_key=0x61 len=368 crc32=0x8a28b6cd section .data
JSON: {"campaign":"BR21-000","domain":"node-000.day21.example.invalid","ipv4":"198.51.100.150","url":"https://node-000.day21.example.invalid/api/BR21-000","mutex":"Global\\HuntressBR21_000", ...}
- Changed the default file choice in
solve_tm.py(the fix for this day).
- Before, a field with no selector (like
d21_analysis_config_campaign) used the first binary in the group, which is the loader. The loader has no config. - Now the solver first picks the member that actually carries an
HCFGrecord (literal or Base64), and falls back to the first binary only if none does. The code comment says it: "d21 config lives in the plugin, not the loader". - Fields with a selector (
loader_…,plugin_…) still use the member whose name contains that word.
- Machine fields: both files are x86-64, so
loader_machine=62andplugin_machine=62(decimal, as on Day 15). - Submitted all 252 answers (
answers.json). Both config sets wereBR21-000. Result:CORRECT. - Time Trial: a fresh variant, same steps. Result:
CORRECT. - Mastery: five deliveries (1,260 answers), same steps. Result:
CORRECT.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 51f78500e27597b672caab6076bc9558 |
| Time Trial | CORRECT | 162fde8cafe897f8cf81025914aebce4 |
| Mastery | CORRECT | 3e41901abec2cfb1e66568750b2064af |
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/d21/deliveries && cp single-solve/evidence.zip /tmp/d21/deliveries/delivery-1.zip
python3 -I ~/.config/huntress/solvers/solve_tm.py single-solve/start-response.json /tmp/d21/deliveries /tmp/d21/answers.json
Checked on 2026-11-01: this gives the same 252 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-21-shared-library-boundaries single_solve /tmp/d21
This needs a Game Master token in ~/.config/huntress/gm-token.
Day 21: Package Deal
Lane: Metadata forensics. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
metadata-forensics-day-21-package-deal - Prompt: "Mobile packages have been mirrored under friendly filenames. Recover Android package identities, distinguish rebuilds from clones, and expose the borrowed product name."
What we were given
- Single Solve:
(evidence.zipmetadata-day-21-evidence.zip, 4,436 bytes) withmobile-001.apk. - Time Trial:
evidence.zip(633,294 bytes, SHA-25622eabba5e80290120951354b127986de399f7c82093715b5623df6e8de8d322b). One file of each type so far, now includingmobile-001.apk. - Mastery:
metadata-forensics-day-21-package-deal-mastery.zip(3,166,538 bytes, SHA-256789eb34f9dce49b5566731723e4960d9111b794d7402f4ecd7269de242471a0c). Five inner zips,evidence-01.ziptoevidence-05.zip. - New today: Android packages (
.apk).
What was asked
- Single Solve: 1 question:
apk.package_nameformobile-001.apk. - Time Trial: 26 questions. Mastery: 130 (5 sets × 26).
- Question types: everything from Day 20, plus the Android package name.
How it was solved, start to finish
The method: the package name is the package attribute in AndroidManifest.xml. Inside an APK that file is in Android's binary XML format, so it needs a parser, not a text search.
- Added an APK handler to
run_meta.py. It writes the APK bytes to a temp file and asks the Android SDK toolapkanalyzerfor the application ID:
r = subprocess.run(['/home/user/Android/Sdk/cmdline-tools/latest/bin/apkanalyzer',
'manifest', 'application-id', tf.name],
capture_output=True, text=True, timeout=90)
return r.stdout.strip() or None
- Single Solve.
mobile-001.apk→com.huntress.arena.p08281778.CORRECT. - Time Trial and Mastery.
run_meta.pyanswered all 26 and all 130. The package name wascom.huntress.arena.p08281778in every set. Example synthesis answer (Time Trial):["message-001.eml","managed-001.dll","panel-001.png","evidence-note.txt","mobile-001.apk"]. BothCORRECT.
Later note: the copy in tools/run_meta.py falls back to a small pure-Python binary-XML reader (axml_package_name) when apkanalyzer is missing or prints nothing. It walks the string pool and returns the package attribute of the <manifest> element.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 5c5c3745b55108831a7fb37fd3f82141 |
| Time Trial | CORRECT | 02999cbc0873f03b6dd8e3794818456d |
| Mastery | CORRECT | ff9ac6070630397fefb3f831664df5a7 |
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
~/Android/Sdk/cmdline-tools/latest/bin/apkanalyzer manifest application-id mobile-001.apk
python3 -I ~/.config/huntress/solvers/run_meta.py metadata-forensics-day-21-package-deal single_solve /tmp/d21
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. apkanalyzer only reads the package. Nothing installs or runs the app.
Day 21: Debug Me If You Can
Lane: Mobile (Android). Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
mobile-android-day-21-debug-me-if-you-can - Prompt: "Neutralize a clean-room anti-debug state machine while retaining the intended app flow."
What we were given
- One Android APK per case. Inside:
AndroidManifest.xml,classes.dex,assets/huntress_puzzle.json, andMETA-INF/signing files. - Single Solve: case
MOB-21-2943307F87. The APK (debug_me_if_you_can.apk) is saved assingle-solve/debug_me.apk(12,704 bytes, SHA-256ef187c93e27df27525db3b23e6d8201160c0495d345424cb243d4390cb194d1d). Its puzzle is saved assingle-solve/huntress_puzzle.json. - Time Trial: one APK (case
MOB-21-A6745E56D3). 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, 10, 13, 19 and 21.
How it was solved, start to finish
The app was never installed or run, so its anti-debug checks never came into play.
- Started the Single Solve and downloaded the APK.
- Read the puzzle asset. The codec is
reverse(also used on Days 2 and 8).
{"schema":"huntress.mobile.puzzle.v1","day":21,"codec":"reverse","data":"A52FEF61525DF04B-SNA"}
- Decoded it. Reverse the string:
import json
p = json.load(open('single-solve/huntress_puzzle.json'))
print(p['data'][::-1])
Output: ANS-B40FD52516FEF25A.
- Ran the lane driver for all three modes. It already handled
reverse:
python3 -I ~/.config/huntress/solvers/run_mode.py mobile-android-day-21-debug-me-if-you-can <mode> mobile_puzzle <workdir>
- Results: Single Solve (
ANS-B40FD52516FEF25A), Time Trial (ANS-32E791ED34910BC3) and all five Mastery answers came backCORRECT.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | fd8dab8dd1534637de38f9ed3ca3824a |
| Time Trial | CORRECT | 86d924d87e24e7bbcc9e7ecd33645c04 |
| Mastery | CORRECT | 68b74944a7880bdd1814e1c249209cda |
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-21-debug-me-if-you-can single_solve mobile_puzzle /tmp/d21
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 21: Actions Speak Louder
Lane: Script analysis. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
script-analysis-day-21-github-actions-persistence - Prompt: "A GitHub Actions workflow decides who can trigger it and which runner inherits the trust. Identify each trigger and trust boundary, follow the static handoff into the next language, and find the job that keeps coming back."
What we were given
- One
evidence.zip(133,401 bytes, SHA-256e005f70c2a553e72ce46d151f6aaa431f2b7b71719910072b7643c971c19d046). Password:infected. - The same families as Day 20. New today:
- 4 GitHub Actions workflow polyglots:
polyglot-github_actions-benign-utility.yml,-downloader,-launcher,-staged-chain. - Every host and polyglot file carries the
HUNTRESS_ANALYSIS_V1:<ENC>-<data>marker fromDay 8.
What was asked
- 1,373 questions in Single Solve. By family: PowerShell 15, JScript 72, Batch 72, VBScript 72, Python 126, Bash 168, Node.js 56, host 132, polyglot 660.
- 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,373 questions. Mastery: 6,865 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 workflow
.ymlfiles carry the usual marker.
- Ran all three modes (as a parallel agent, one per lane). All three came back
CORRECT.
- Real answers from
single-solve/answers.json:
{
"polyglot-github_actions-staged-chain-role": "staged_chain",
"polyglot-github_actions-staged-chain-attack": "T1059",
"polyglot-github_actions-staged-chain-adapter": "operation_graph",
"polyglot-github_actions-staged-chain-campaign": "GITHUB_ACTIONS-e261e317",
"polyglot-github_actions-staged-chain-url": "https://github_actions-e261e3177e.example.invalid/stage",
"polyglot-github_actions-staged-chain-stage-count": "2",
"polyglot-github_actions-staged-chain-steps": "decode_configuration>return_configuration",
"polyglot-github_actions-staged-chain-host-profile": "standalone"
}
- Time Trial and Mastery used the same solver on fresh variants.
- Time Trial: 1,373 questions, no deadline (
run_for_time: false). - Mastery: 6,865 questions in 5 sets, no deadline (
run_for_time: false). The download (script-analysis-day-21-github-actions-persistence-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 | c19dec0e49bf4d41fdbc48617ba30764 |
| Time Trial | CORRECT | 45a2d3e8fb7fd2a923b1fdfa96ef93cd |
| Mastery | CORRECT | 3431fa10f2aef7d9e7f9f9ea6e826c80 |
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/d21/ex
7z x -pinfected -o/tmp/d21/ex evidence.zip
python3 -I tools/solve_expansion.py /tmp/d21/ex start-response.json /tmp/d21/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 21: Under Pressure
Lane: Warmups. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
warmups-day-21 - Prompt: "Squeeze, then encode. Reverse the order to decode."
- New encoding: base64 then gzip
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. Base64-decode the blob, then gzip-decompress the result.
- Mastery blobs use multiple encodings from Days 1-21. 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:eager-compass-mosaic-50. Flag:4660df9b2b5254868f5943ba6eb6668f. - Time Trial:
CORRECT. slug:silly-crater-boulder-37. Flag:64a32520a04381cc2a0cb2bca8f62303. - Mastery:
CORRECT. 103 slugs. Flag:1dd21babcd7ae93a186307f1eca7ead5.
Day 21 — Reflect Upon This (Reflected XSS)
Lane: Web Exploitation · Challenge ID: web-exploitation-day-06-reflect-upon-this
> Make it repeat something that talks back — land the isolated callback and watch it reflect.
What we were given
A live Fastify web target with a reflected input and a callback endpoint.
How it was solved
This is a reflected XSS challenge, but the actual exploit path doesn't require injecting script tags — the "callback" endpoint proves the XSS by checking browser-context headers.
- Queried
/api/clues. It disclosed three things:
feature_route(e.g./execute-*) — reflects theqparameter raw into the page (the XSS sink)secondary_route(e.g./callback-*) — an isolated callback endpointcallback_nonce— a one-time token for the callback
- The callback endpoint verifies that the request came from a browser context on the same origin. It checks
Referer,Sec-Fetch-Mode, andSec-Fetch-Siteheaders — not an actual browser. - Sent
GET {callback}?nonce={nonce}with headers:
Referer: {target_url}{feature_route}Sec-Fetch-Mode: no-corsSec-Fetch-Site: same-origin
- The callback accepted the request and returned
effect: isolated_browser_callbackwith the proof.
Root cause: The callback endpoint trusts Fetch metadata headers as proof of browser-context execution. These headers are trivially spoofable from any HTTP client — they're only reliable when enforced by browser Same-Origin Policy, not as standalone authentication.
Automated with web_solve.py (ex_reflected_xss): clues scrape → header-spoofed callback request.
Results
| Mode | Result |
|---|---|
| Single Solve | CORRECT |
| Time Trial | CORRECT |
| Mastery | CORRECT — mixed vuln types across targets |
Day 21 — Session Impression (Session Fixation)
Lane: Web Exploitation · Challenge ID: web-exploitation-day-08-session-impression
> Plant your session on the welcome mat, then stroll in wearing somebody else's credentials.
What we were given
A live Laravel web target with session management.
How it was solved
Session fixation — we choose the session ID before the victim authenticates, then reuse it after they do.
- Queried
/api/clues. It disclosed:
feature_route(e.g./action-*) — the session planting endpointsecondary_route(e.g./status-*) — the privileged status checksession_hint— the session ID to plant
- Sent
GET {feature_route}?sid={session_hint}. The server accepted the attacker-supplied session ID and set a session cookie in the response. Response:{"session_established": true}. - The server simulates a victim authenticating on that same fixed session (in a real attack, the victim would click a link with the attacker's session ID embedded).
- Using the same cookie jar (still holding the planted session), requested
GET {secondary_route}. Since the victim's authentication was bound to our session ID, the server returnedeffect: fixed_session_privilege_transferand the proof.
Root cause: The application accepts externally supplied session identifiers without regenerating the session ID after authentication. This lets an attacker pre-set a session ID, wait for a victim to authenticate on it, then hijack the authenticated session.
Automated with web_solve.py (ex_session): clues scrape → plant session via query param → read privileged endpoint with the same cookie jar.
Results
| Mode | Result |
|---|---|
| Single Solve | CORRECT |
| Time Trial | CORRECT |
| Mastery | CORRECT — mixed vuln types across targets |
Day 21 — Stored for Later (Stored XSS)
Lane: Web Exploitation · Challenge ID: web-exploitation-day-07-stored-xss
> Leave a little present in the guestbook. It only goes off when the reviewer stops by.
What we were given
A live FastAPI web target with a message board and a moderator review bot.
How it was solved
Stored XSS — inject persistent script content that executes when a privileged user (the moderator bot) views it, then exfiltrate data from their session.
- Queried
/api/clues. It disclosed:
feature_route— the message board section (e.g./messagesor/feedback)moderator_data_route— a privileged endpoint (e.g./support-*) only the moderator can access
- The message board renders submitted content as raw HTML — no sanitization or encoding. Anything posted is stored and displayed verbatim, including script tags.
- Posted a message containing a script payload via
POST /api/{feature}. The script, when executed by the moderator bot's browser:
- Fetches the privileged
moderator_data_route - Re-posts the response content as a new public message
- The moderator bot visits new messages within ~1 second and executes the stored script. It reads the privileged data and posts it back as a new public message.
- Polled
/{feature}/{id}for new message IDs. The exfiltrated message contained the proof string.
Root cause: User-submitted content is rendered as raw HTML without escaping. Combined with a bot that reviews messages with an authenticated session, this enables data exfiltration from privileged endpoints via stored XSS.
Automated with web_solve.py (ex_stored_xss): clues scrape → script injection via message API → poll for bot-posted exfiltration message.
Results
| Mode | Result |
|---|---|
| Single Solve | CORRECT |
| Time Trial | CORRECT |
| Mastery | CORRECT — mixed vuln types across targets |