2026-10-22

Day 22: Bridge Troll

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

The challenge

What we were given

  1. The main .NET DLL, written in F# (SHA-256 1ebccc9936901e808463f080e31c0ad79fa6dd4d9f3c9627059d9c485ac95ead).
  2. Its runtimeconfig.json (the same bytes as the d03 one).
  3. FSharp.Core.dll, the F# library it depends on (SHA-256 65b2ceb9bbef399efb507a7782093108bf6dbfe749096c44996af41b7577938c).

What was asked

How it was solved, start to finish

  1. The watcher fired the driver automatically. watcher.py polls for a new day and runs run_tm.py for the binary lane in all three modes. Its log for Day 22 reads: [OK] binary-reverse-engineering single=CORRECT(6eaf8b6f…) TT=CORRECT mastery=CORRECT.
  2. No new code was needed. The existing handlers covered every d22 field:
  1. Re-checked on the Day 29 copy of the main DLL with hcfg.py:
=== HCFG valid records in d22--sample.dll ===
offset=0x3e13 version=1 xor_key=0x71 plen=368 crc32=0x1704bcdf
  JSON: {"campaign":"BR22-000","domain":"node-000.day22.example.invalid","ipv4":"198.51.100.170","url":"https://node-000.day22.example.invalid/api/BR22-000","mutex":"Global\\HuntressBR22_000", ...}
offset=0x4800 version=1 xor_key=0x71 plen=368 crc32=0x1704bcdf
  (same JSON)
=== CLR metadata version (BSJB+16, len=12) ===
  version: 'v4.0.30319'
=== PE/COFF Machine ===
  machine: 0x014c (332)

The record appears twice with the same content. The first valid one wins.

  1. Answers for d22: format pe_cli, machine i386, metadata version v4.0.30319, version 1, CRC32 0x1704bcdf, campaign BR22-000 (answers.json).
  2. Result: all three modes CORRECT on the first run.

Results

ModeResultFlag
Single SolveCORRECT6eaf8b6fe51ea35f1e5dc911576e1da2
Time TrialCORRECT519bf131c14f34163872991237c99339
MasteryCORRECT6f8127965288312407b8a6298ba3a98f

Each mode folder has the raw start-response.json, answers.json, submit-response.json and final-status-response.json. The evidence zips were not saved for this day.

Note: an earlier version of this page said d22 came "paired with a native bridge library". The saved hashes show the third file is FSharp.Core.dll, a managed library. The native side is the kernel32.dll import.

Reproduce

The Day 22 bundle was not saved, so a full offline re-run is not possible. The d22 files can be checked from the Day 29 folder (from this folder):

X=../day-29-binary-reverse-engineering-fraternal-twins/single-solve/extracted
sha256sum $X/d22--*            # same hashes as d22_artifact_sha256_1..3
python3 -I ~/.config/huntress/solvers/hcfg.py $X/d22--sample.dll

Live driver:

python3 -I ~/.config/huntress/solvers/run_tm.py binary-reverse-engineering-day-22-managed-native-bridge single_solve /tmp/d22

This needs a Game Master token in ~/.config/huntress/gm-token. Both only parse the files and never run them.

Day 22: Main Character Energy

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: unzip the JAR, read META-INF/MANIFEST.MF, and return the Main-Class attribute (value trimmed). If the manifest has no Main-Class line, the answer is none.

  1. The automatic run flagged a new type. A helper agent ran run_meta.py on the Single Solve. It answered nothing: missing: ["d22-jar-001-jar-main-class"]. The agent stopped and reported "needs manual solver". It did not touch the timed modes.
  2. Wrote the JAR-manifest reader by hand and added it to run_meta.py. JAR manifests wrap long lines at 72 bytes; a line that starts with a space continues the line before it. So the reader joins those lines first:
z = zipfile.ZipFile(io.BytesIO(fb))
mf = next((n for n in z.namelist() if n.upper() == 'META-INF/MANIFEST.MF'), None)
if mf is None: return 'none'
text = z.read(mf).decode('utf-8', 'replace').replace('\r\n', '\n').replace('\r', '\n')
unfolded = []
for line in text.split('\n'):
    if line.startswith(' ') and unfolded: unfolded[-1] += line[1:]
    else: unfolded.append(line)
for line in unfolded:
    if line.lower().startswith('main-class:'): return line.split(':', 1)[1].strip()
return 'none'
  1. Ran all three modes with the fixed driver. A second helper agent ran run_meta.py for Single Solve, Time Trial and Mastery:

The Main-Class was arena.evidence.ArtifactMain in every set. Example synthesis answer (Time Trial): ["panel-001.png","evidence-note.txt","installer-001.msi","audio-001.wav","application-001.jar"].

Results

ModeResultFlag
Single SolveCORRECT981d0c80405dceee14eef2dc88b1c5da
Time TrialCORRECT96830c3b24014449f642a4151143805f
MasteryCORRECT97181abd3530752b1e35fb60f5aef06c

Each mode folder has answers.json, start-response.json, submit-response.json and final-status-response.json. No screenshots were captured.

Reproduce

python3 -I ~/.config/huntress/solvers/run_meta.py metadata-forensics-day-22-main-character-energy single_solve /tmp/d22

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 only reads the manifest text inside the JAR. It never runs Java.

Day 22: Root of Trust

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

No hand work was needed. The existing mobile solver handled this day with no new wrinkle.

  1. The watcher fired at the drop. watcher.py polls the Game Master. When Day 22 appeared (07:09:47 local), it ran the mobile lane driver for Single Solve:
python3 -I ~/.config/huntress/solvers/run_mode.py mobile-android-day-22-root-of-trust single_solve mobile_puzzle <workdir>
  1. The driver solved it. run_mode.py downloads the APK, reads assets/huntress_puzzle.json, decodes it by its codec field, and submits. Single Solve came back CORRECT.
  2. The watcher then ran Time Trial and Mastery the same way. Its log line, 12 seconds after the drop:
[OK] mobile-android single=CORRECT(1682d7a681b962ebb7b3fc9c593ae946) TT=CORRECT mastery=CORRECT
  1. Saved the records. A helper agent ran the same driver again for each mode to capture the JSON files kept here. Single Solve answered already_solved. Time Trial and Mastery came back CORRECT.

Answers in the saved files: Single Solve ANS-725991794E5E611F, Time Trial ANS-3F7D5404CD10DD34. The six Mastery answers are in mastery/answers.json.

Results

ModeResultFlag
Single SolveCORRECT1682d7a681b962ebb7b3fc9c593ae946
Time TrialCORRECT0b8c4fc99f15480671b5190af81c5b51
MasteryCORRECTee7bb55267be50905b8f0af691d03e73

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. Its final-status-response.json holds the CORRECT result and flag. No screenshots were taken.

Reproduce

python3 -I ~/.config/huntress/solvers/run_mode.py mobile-android-day-22-root-of-trust single_solve mobile_puzzle /tmp/d22

This needs a Game Master token in ~/.config/huntress/gm-token. The driver reads the APK as a zip file. It never installs or runs the app on a device. (Today's version also handles the analysis codec added on Day 23.)

Day 22: Next, Next, Finish

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 NSIS files carry the usual marker.
  1. Fired at unlock. Day 22 was seen live at 13:09 UTC on 2026-10-22, and every lane was launched at once. The Single Solve was solved 2 seconds after its start (13:09:47 → 13:09:49 UTC). The solved_by times for Time Trial and Mastery are 13:09:55 and 13:10:03 UTC. The saved Time Trial and Mastery start responses are from a later run at about 13:12 UTC.
  1. Real answers from single-solve/answers.json:
{
 "polyglot-nsis-launcher-role": "launcher",
 "polyglot-nsis-launcher-attack": "T1059",
 "polyglot-nsis-launcher-adapter": "process_builder",
 "polyglot-nsis-launcher-campaign": "NSIS-1c660784",
 "polyglot-nsis-launcher-url": "https://nsis-1c66078413.example.invalid/stage",
 "polyglot-nsis-launcher-stage-count": "2",
 "polyglot-nsis-launcher-steps": "decode_configuration>return_configuration",
 "polyglot-nsis-launcher-host-profile": "standalone"
}
  1. Time Trial and Mastery used the same solver on fresh variants.

Results

ModeResultFlag
Single SolveCORRECT64b9e6104ffd97a84f2f3081e0afb7e0
Time TrialCORRECTdf2cd8a4a8b406c9a15f1605a7b5f1d1
MasteryCORRECTd96f30a64f2dfcc879144e389a03cbc5

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/d22/ex
7z x -pinfected -o/tmp/d22/ex evidence.zip
python3 -I tools/solve_expansion.py /tmp/d22/ex start-response.json /tmp/d22/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 22: Deflated Ego

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 zlib-decompress the result.
  2. Mastery blobs use multiple encodings from Days 1-22. 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 22 — Forged With Care (CSRF)

Lane: Web Exploitation · Challenge ID: web-exploitation-day-09-forged-with-care

> The form trusts its origin a little too much. Forge a cross-site request and change what shouldn't be changeable.

What we were given

A live ASP.NET Core web target. All requests required a browser User-Agent header or Cloudflare returned a 1010 block.

How it was solved

Cross-Site Request Forgery — the app's state-changing endpoint doesn't properly validate the origin of requests.

  1. Queried /api/clues to get the feature_route (the CSRF-vulnerable endpoint).
  2. Visited /preferences with the arena_session cookie. The page contained a hidden csrf_token and a review destination address (review-####@outside.example.invalid).
  3. Sent the forged cross-site request: GET {feature_route}?destination={addr}&csrf_token={tok} with the arena_session cookie and cross-site context headers (Origin/Referer set to a foreign origin, Sec-Fetch-Site: cross-site).
  4. Checked /api/preferences — it confirmed changed_across_sites: true and returned the proof.

Root cause: The endpoint accepts the CSRF token from query parameters and doesn't validate the request origin. A real browser's SameSite cookie policy would block this, but the token is accepted regardless of where the request originates.

Mastery — mixed targets

Mastery bundled 3 different vulnerability types:

Results

ModeResultFlag
Single SolveCORRECT2b25b28ec028f820ef87c352c568608d
Time TrialCORRECTd577f071df614f541a49a2b492f06559
Mastery (3/3)CORRECT035a388f35f3d37fb12301e44cf3e0d5

Day 22 — Uploading Expectations (File-Upload SSTI)

Lane: Web Exploitation · Challenge ID: web-exploitation-day-10-uploading-expectations

> Upload a note, preview it, and watch the server fill in the blanks.

What we were given

A live Go (net/http + html/template) web target. Required browser User-Agent header.

How it was solved

Server-Side Template Injection via file upload — the server renders uploaded .html files through Go's template engine.

  1. Queried /api/clues to get feature_route (upload endpoint) and render_route (preview endpoint).
  2. Uploaded a file with an .html extension and Go template syntax as the body:
POST {feature_route}
{"filename": "x.html", "content": "{{objective}}", "content_type": "text/html"}

The key insight: the file extension determines whether the server processes template directives, not the content_type. A .txt upload is returned verbatim; .html is rendered through html/template.

  1. Requested GET {render_route}?file=x.html. The server evaluated {{objective}} and the rendered page body was the proof string.

Root cause: The render endpoint processes uploaded files through Go's template engine based on file extension. The objective variable is bound in the template context, so {{objective}} resolves to the proof. An attacker controlling the filename and content can inject arbitrary template expressions.

Mastery — mixed targets

Results

ModeResultFlag
Single SolveCORRECTd788991988c4dd25b7a0d35dabb4121f
Time TrialCORRECTc2b8bab5b5f313cc5f118ced3eb75f06
Mastery (3/3)CORRECT9ad18a25190fed0523b1c8201e738ffd