2026-10-21

Day 21: Shared Custody

Lane: Binary reverse engineering. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.

The challenge

What we were given

What was asked

How it was solved, start to finish

  1. Ran the driver run_tm.py: start the attempt, download the zip, run solve_tm.py, submit.
  2. d01–d20 were answered as on Day 20.
  3. 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", ...}
  1. Changed the default file choice in solve_tm.py (the fix for this day).
  1. Machine fields: both files are x86-64, so loader_machine = 62 and plugin_machine = 62 (decimal, as on Day 15).
  2. Submitted all 252 answers (answers.json). Both config sets were BR21-000. Result: CORRECT.
  3. Time Trial: a fresh variant, same steps. Result: CORRECT.
  4. Mastery: five deliveries (1,260 answers), same steps. Result: CORRECT.

Results

ModeResultFlag
Single SolveCORRECT51f78500e27597b672caab6076bc9558
Time TrialCORRECT162fde8cafe897f8cf81025914aebce4
MasteryCORRECT3e41901abec2cfb1e66568750b2064af

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

What we were given

What was asked

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.

  1. Added an APK handler to run_meta.py. It writes the APK bytes to a temp file and asks the Android SDK tool apkanalyzer for 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
  1. Single Solve. mobile-001.apk → com.huntress.arena.p08281778. CORRECT.
  2. Time Trial and Mastery. run_meta.py answered all 26 and all 130. The package name was com.huntress.arena.p08281778 in every set. Example synthesis answer (Time Trial): ["message-001.eml","managed-001.dll","panel-001.png","evidence-note.txt","mobile-001.apk"]. Both CORRECT.

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

ModeResultFlag
Single SolveCORRECT5c5c3745b55108831a7fb37fd3f82141
Time TrialCORRECT02999cbc0873f03b6dd8e3794818456d
MasteryCORRECTff9ac6070630397fefb3f831664df5a7

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

What we were given

What was asked

How it was solved, start to finish

The app was never installed or run, so its anti-debug checks never came into play.

  1. Started the Single Solve and downloaded the APK.
  2. 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"}
  1. Decoded it. Reverse the string:
import json
p = json.load(open('single-solve/huntress_puzzle.json'))
print(p['data'][::-1])

Output: ANS-B40FD52516FEF25A.

  1. 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>
  1. Results: Single Solve (ANS-B40FD52516FEF25A), Time Trial (ANS-32E791ED34910BC3) and all five Mastery answers came back CORRECT.

Results

ModeResultFlag
Single SolveCORRECTfd8dab8dd1534637de38f9ed3ca3824a
Time TrialCORRECT86d924d87e24e7bbcc9e7ecd33645c04
MasteryCORRECT68b74944a7880bdd1814e1c249209cda

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

What we were given

What was asked

How it was solved, start to finish

  1. Started the untimed Single Solve and downloaded evidence.zip. Extracted it with 7z x -pinfected.
  2. Ran the existing solver (solve_expansion.py, driven by run_expansion.py). Each family has its own decoder:
FamilyFilesHow the config is recoveredFirst seen
PowerShell*-sample.ps1Base64 JSON inside FromBase64String('...')Day 1
JScript*.jsjsdec.js loads the fixture in a Node vm sandbox (pure-computation globals only) and calls its decode functionsDay 3
Batch*.bat, *.cmdjoins the :HUNTRESS_INSPECT fragments and drops ^ caretsDay 3
VBScript*.vbsMaterial_ + Codec_, transform search until the text starts `v=1\steps=`Day 4
Python*.pyMATERIAL_ read with ast.literal_eval, same transform searchDay 5
Bash*.shquoted Material_ + Codec_; "advanced" files start `v=1\feature=`Day 6, Day 7
Node.jsnode-*.mjsMaterial_ + Codec_ with \x, \u and hex-array formatsDay 7
host, polyglothost-*, 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.

  1. No new code was needed. The workflow .yml files carry the usual marker.
  1. Ran all three modes (as a parallel agent, one per lane). All three came back CORRECT.
  1. 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"
}
  1. Time Trial and Mastery used the same solver on fresh variants.

Results

ModeResultFlag
Single SolveCORRECTc19dec0e49bf4d41fdbc48617ba30764
Time TrialCORRECT45a2d3e8fb7fd2a923b1fdfa96ef93cd
MasteryCORRECT3431fa10f2aef7d9e7f9f9ea6e826c80

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

What we were given

How it was solved

  1. Decode the blob. Base64-decode the blob, then gzip-decompress the result.
  2. 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.
  3. Concatenate all decoded lines. The text contains a message ending in the answer slug.
  4. Submit the slug to the Game Master.

Results

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.

  1. Queried /api/clues. It disclosed three things:
  1. The callback endpoint verifies that the request came from a browser context on the same origin. It checks Referer, Sec-Fetch-Mode, and Sec-Fetch-Site headers — not an actual browser.
  2. Sent GET {callback}?nonce={nonce} with headers:
  1. The callback accepted the request and returned effect: isolated_browser_callback with 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

ModeResult
Single SolveCORRECT
Time TrialCORRECT
MasteryCORRECT — 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.

  1. Queried /api/clues. It disclosed:
  1. 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}.
  2. 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).
  3. 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 returned effect: fixed_session_privilege_transfer and 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

ModeResult
Single SolveCORRECT
Time TrialCORRECT
MasteryCORRECT — 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.

  1. Queried /api/clues. It disclosed:
  1. The message board renders submitted content as raw HTML — no sanitization or encoding. Anything posted is stored and displayed verbatim, including script tags.
  2. Posted a message containing a script payload via POST /api/{feature}. The script, when executed by the moderator bot's browser:
  1. 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.
  2. 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

ModeResult
Single SolveCORRECT
Time TrialCORRECT
MasteryCORRECT — mixed vuln types across targets