2026-10-22
Day 22: Bridge Troll
Lane: Binary reverse engineering. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
binary-reverse-engineering-day-22-managed-native-bridge - Prompt: "Managed code on one side, native code on the other, and a bridge of P/Invoke and FFI in between. Pay the troll: trace every crossing and map what goes over."
What we were given
- One
evidence.zip(35,671,617 bytes, SHA-25667bd91bd42f63773dfb4eba19ac96e89bfd560abb7f26aabae0301854a384ce5). AES encrypted, passwordinfected. It was not saved in this folder. - The earlier files again:
d01tod21. - New today: a
d22group of three files, in this order:
- The main .NET DLL, written in F# (SHA-256
1ebccc9936901e808463f080e31c0ad79fa6dd4d9f3c9627059d9c485ac95ead). - Its
runtimeconfig.json(the same bytes as the d03 one). FSharp.Core.dll, the F# library it depends on (SHA-25665b2ceb9bbef399efb507a7782093108bf6dbfe749096c44996af41b7577938c).
- The "native bridge" is inside the main DLL: it declares a P/Invoke (
DllImportAttribute) intokernel32.dll, with names likenative_bridge_result_positiveandnativePid. There is no separate native library in the bundle. - These three files are byte-identical (same SHA-256) to the
d22files saved in the Day 29 folder, so they can still be checked.
What was asked
- 264 questions in Single Solve and Time Trial. Mastery had six deliveries, so 1,584.
- Question types:
- Hashes: SHA-256 of all three d22 members (and all older members).
- d01 to d21: the same questions as Day 21.
- d22 (new): for the main DLL only ("the unique d22 primary managed assembly"; the JSON and dependency DLL are "delivery support only"): machine, format token, CLR metadata version,
HCFGversion, the config fields and the CRC32.
How it was solved, start to finish
- The watcher fired the driver automatically.
watcher.pypolls for a new day and runsrun_tm.pyfor the binary lane in all three modes. Its log for Day 22 reads:[OK] binary-reverse-engineering single=CORRECT(6eaf8b6f…) TT=CORRECT mastery=CORRECT. - No new code was needed. The existing handlers covered every d22 field:
- Which DLL? Two members are PE files. The Day 21 rule "prefer the member that carries an
HCFGrecord" picks the main DLL, becauseFSharp.Core.dllhas none. - Format: a PE with .NET metadata, so the token is
pe_cli. - Machine and CLR version: read from the PE header and the
BSJBmetadata root, as on Day 3. - Config: a plain
HCFGscan.
- 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.
- Answers for d22: format
pe_cli, machinei386, metadata versionv4.0.30319, version1, CRC320x1704bcdf, campaignBR22-000(answers.json). - Result: all three modes
CORRECTon the first run.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 6eaf8b6fe51ea35f1e5dc911576e1da2 |
| Time Trial | CORRECT | 519bf131c14f34163872991237c99339 |
| Mastery | CORRECT | 6f8127965288312407b8a6298ba3a98f |
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
- ID:
metadata-forensics-day-22-main-character-energy - Prompt: "Java archives contain libraries, applications, and nested dependencies whose manifests disagree with their launchers. Determine what is runnable and where execution begins."
What we were given
- Single Solve:
metadata-day-22-evidence.zip(741 bytes, SHA-2568cbaee5dd7800c8afd80ae9030b3fc419b965dd3b9f63ce2489cd4e96f64343a) withapplication-001.jar. - Time Trial:
evidence.zip(633,962 bytes, SHA-256f9b6d3dee973671411b315fae807e9f7b83375f8402639f0ab93d47c2eed12db). One file of each type so far, now includingapplication-001.jar. - Mastery:
metadata-forensics-day-22-main-character-energy-mastery.zip(3,804,046 bytes, SHA-256578f11dd1e8823cb92b6e02647c09ce67744f9187c57eb9efc03baca62ccad9e). Six inner zips,evidence-01.ziptoevidence-06.zip. - New today: Java archives (
.jar).
What was asked
- Single Solve: 1 question:
jar.main_classforapplication-001.jar(answer IDd22-jar-001-jar-main-class). Format: the exact value, or the literalnoneif the field is absent. - Time Trial: 27 questions. Mastery: 162 (6 sets × 27).
- Question types: everything from Day 21, plus the JAR
Main-Class.
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.
- The automatic run flagged a new type. A helper agent ran
run_meta.pyon 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. - 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'
- Ran all three modes with the fixed driver. A second helper agent ran
run_meta.pyfor Single Solve, Time Trial and Mastery:
- Single Solve:
Main-Class: arena.evidence.ArtifactMain→arena.evidence.ArtifactMain.CORRECT. - Time Trial: all 27 answered.
CORRECT. - Mastery: all 162 answered.
CORRECT.
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
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 981d0c80405dceee14eef2dc88b1c5da |
| Time Trial | CORRECT | 96830c3b24014449f642a4151143805f |
| Mastery | CORRECT | 97181abd3530752b1e35fb60f5aef06c |
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
- ID:
mobile-android-day-22-root-of-trust - Prompt: "Model and bypass multiple synthetic root signals without globally patching success."
What we were given
- One Android APK per case:
root_of_trust.apk(Single Solve, caseMOB-22-D2F383E9D8),root_of_trust_time_trial.apk(Time Trial, caseMOB-22-A2AC2817EB) and six Mastery APKs. - The APKs were not saved in this folder. So the codec used today is not recorded.
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.answertoset6.answerfor Mastery. - Mastery grew to six cases, from Days 3, 7, 11, 14, 18 and 22.
How it was solved, start to finish
No hand work was needed. The existing mobile solver handled this day with no new wrinkle.
- The watcher fired at the drop.
watcher.pypolls 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>
- The driver solved it.
run_mode.pydownloads the APK, readsassets/huntress_puzzle.json, decodes it by itscodecfield, and submits. Single Solve came backCORRECT. - 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
- 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 backCORRECT.
Answers in the saved files: Single Solve ANS-725991794E5E611F, Time Trial ANS-3F7D5404CD10DD34. The six Mastery answers are in mastery/answers.json.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 1682d7a681b962ebb7b3fc9c593ae946 |
| Time Trial | CORRECT | 0b8c4fc99f15480671b5190af81c5b51 |
| Mastery | CORRECT | ee7bb55267be50905b8f0af691d03e73 |
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
- ID:
script-analysis-day-22-installer-script-chain - Prompt: "An NSIS installer script clicks through its own setup wizard while carrying a little something extra. Separate the real setup actions from the modeled payload behavior, and recover every cross-language handoff from the final bytes. You won't need to press Next once."
What we were given
- One
evidence.zip(137,890 bytes, SHA-256e7361c83519bbc6e113f2c97ead65f4b18930d29b34b6d34672f3b1b67e14880). Password:infected. - The same families as Day 21. New today:
- 4 NSIS installer-script polyglots:
polyglot-nsis-benign-utility.nsi,-downloader,-launcher,-staged-chain. - Every host and polyglot file carries the
HUNTRESS_ANALYSIS_V1:<ENC>-<data>marker fromDay 8.
What was asked
- 1,417 questions in Single Solve. By family: PowerShell 15, JScript 72, Batch 72, VBScript 72, Python 126, Bash 168, Node.js 56, host 132, polyglot 704.
- 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,417 questions. Mastery: 8,502 questions in 6 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 NSIS files carry the usual marker.
- 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_bytimes 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.
- 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"
}
- Time Trial and Mastery used the same solver on fresh variants.
- Time Trial: 1,417 questions, no deadline (
run_for_time: false). - Mastery: 8,502 questions in 6 sets, no deadline (
run_for_time: false). The download (script-analysis-day-22-installer-script-chain-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 | 64b9e6104ffd97a84f2f3081e0afb7e0 |
| Time Trial | CORRECT | df2cd8a4a8b406c9a15f1605a7b5f1d1 |
| Mastery | CORRECT | d96f30a64f2dfcc879144e389a03cbc5 |
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
- ID:
warmups-day-22 - Prompt: "Same idea, different compressor. Deflate, then decode."
- New encoding: base64 then zlib
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 zlib-decompress the result.
- 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. - 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:tidy-cloud-tulip-70. Flag:340b74266b4e4d34b3894345f76b1c9e. - Time Trial:
CORRECT. slug:zesty-sunset-onyx-64. Flag:6ddf8b9ce2cefe22485918876dede638. - Mastery:
CORRECT. 108 slugs. Flag:07a3d3865a95dfcef346cf668923bd7c.
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.
- Queried
/api/cluesto get thefeature_route(the CSRF-vulnerable endpoint). - Visited
/preferenceswith thearena_sessioncookie. The page contained a hiddencsrf_tokenand a review destination address (review-####@outside.example.invalid). - Sent the forged cross-site request:
GET {feature_route}?destination={addr}&csrf_token={tok}with thearena_sessioncookie and cross-site context headers (Origin/Refererset to a foreign origin,Sec-Fetch-Site: cross-site). - Checked
/api/preferences— it confirmedchanged_across_sites: trueand 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:
- Target 1 (backup exposure):
robots.txt→ hidden directory →.json.bakfile → proof insupport_note - Target 2 (IDOR):
/api/timelineleaked a foreign case ID → direct access to restricted case record - Target 3 (CSRF): same forged cross-site request technique as above
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 2b25b28ec028f820ef87c352c568608d |
| Time Trial | CORRECT | d577f071df614f541a49a2b492f06559 |
| Mastery (3/3) | CORRECT | 035a388f35f3d37fb12301e44cf3e0d5 |
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.
- Queried
/api/cluesto getfeature_route(upload endpoint) andrender_route(preview endpoint). - Uploaded a file with an
.htmlextension 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.
- 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
- Target 1 (backup exposure):
robots.txt→ hidden deploy directory →.json.bakwith proof - Target 2 (IDOR): session cookie from
/→/api/timelineleaks executive case ID → direct access - Target 3 (file-upload SSTI): same technique as above
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | d788991988c4dd25b7a0d35dabb4121f |
| Time Trial | CORRECT | c2b8bab5b5f313cc5f118ced3eb75f06 |
| Mastery (3/3) | CORRECT | 9ad18a25190fed0523b1c8201e738ffd |