2026-10-30
Day 30: Campaign Trail
Lane: Binary reverse engineering. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
binary-reverse-engineering-day-30-multi-binary-campaign - Prompt: "One binary is a clue; a campaign is a story. Reconstruct the loader, library, and config graph across the whole set and map the operation end to end."
What we were given
- Single Solve: one
evidence.zip(35,982,918 bytes, SHA-25643e450ade9b73f8da3b5cedd3739c2319acb2f5f45b63d5392b4562f3ab4b9c1). AES encrypted, passwordinfected. The 45 extracted members are inextracted/. - Every earlier family,
d01tod29. - New today: three Neko bytecode files (they start with the magic
NEKO):d30--sample-config.n,d30--sample-library.nandd30--sample-loader.n(about 20.9 KB each). - Time Trial: one archive (
artifact-response.bin, an AES zip) and its extracted members. - Mastery: 14 deliveries (
delivery-01.zip…delivery-14.zip), with extracted members undersets/.
What was asked
- 420 questions in Single Solve and Time Trial. Mastery had 14 sets, so 5,880.
- Question types:
- d01 to d29: the same questions as Day 29.
- d30 (new), 14 fields:
- SHA-256 of the three
.nfiles; - the format token of each (
config_capsule_format,library_format,loader_format); config_capsule_graph_config_*:campaign,domain,mutex,urlfromconfig.n;config_*: the same four fields fromloader.n, "after confirming all three canonical campaign graphs match whenthis_roleis omitted".- The new record type is
HGRF. The questions say: find the CRC32-validHGRFrecord by scanning backward from the end of the file; it uses the same 12-byte header asHCFG.
How it was solved, start to finish
- The watcher ran the driver first. The Game Master answered
incorrect, so the lane was flagged for manual work. - Ran
tools/solve_tm.pyon the Single Solve archive (copied asdelivery-1.zip, the driver's file name). It supplied 409 analysis and artifact-hash fields. It cannot read Neko files, so the 11 d30 analysis fields were left. - Checked the 409 answers with the partial-submit oracle. They were submitted one day group at a time (
d01…d29, 14 fields each, then the three d30 hashes). Every group came backaccepted, leaving 11 fields (oracle-log.json,accepted-candidates.json). - Decoded the d30 graph records. Each
.nfile ends with anHGRFrecord:
- byte 4 is the version, byte 5 the XOR key, bytes 6–7 the payload length and bytes 8–11 the CRC32 (little-endian);
- XOR the payload with the key, check the CRC32, parse the JSON.
Re-checked on the saved files (scanning back from the end):
d30--sample-config.n len 20916 HGRF offset 20209 key=0xf1 len 695 crc32=0x76c956e7 ends at end of file
d30--sample-library.n len 20890 HGRF offset 20182 key=0xf1 len 696 crc32=0x8e1f39c8 ends at end of file
d30--sample-loader.n len 20880 HGRF offset 20173 key=0xf1 len 695 crc32=0xc41517fb ends at end of file
{"schema": "huntress.binary.campaign_graph.v1", "campaign_id": "DAY30-000",
"nodes": ["loader.n", "library.n", "config.n"], "edges": ["loader.n->library.n", "library.n->config.n"],
"load_order": ["loader.n", "library.n", "config.n"],
"config": {"campaign": "BR30-000", "domain": "campaign-000.day30.example.invalid", "ipv4": "203.0.113.30",
"url": "https://campaign-000.day30.example.invalid/stage/BR30-000", "mutex": "Global\\HuntressBR30-000", ...},
"this_role": "config", ...}
The three graphs are the same except for this_role (config, library, loader). So the "graphs match" check passes and both config sets are BR30-000.
- Format: all three start with
NEKO, so each isneko_bytecode. - Submitted the last 11 fields. Result:
CORRECT(final-submit-response.json). All 420 answers are inanswers.json. - Time Trial: same flow. 30 oracle groups were accepted one by one, and the last submit returned
CORRECTwith 420 accepted (oracle-log.json,accepted-candidates.json). - Mastery: all 14 deliveries went through
tools/solve_tm.py, then the d30 records in each set were decoded the same way. All 5,880 answers:CORRECT.
A second session worked on Day 30 at the same time and solved some modes in parallel. Every mode was checked against the Game Master directly (agent log for Day 30).
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT (420/420) | 4e52d1a8b97ab5253a3258947f89dbe6 |
| Time Trial | CORRECT (420/420) | b3c55b4766c3ce52292c30c0ebf160d5 |
| Mastery | CORRECT (5,880/5,880) | e14b347cfaf1160c8f74a1595843f8b5 |
Saved files: Single Solve has the evidence, extracted members, oracle log, accepted answers and final submit. Time Trial has no answers.json; its accepted answers are in accepted-candidates.json. Mastery has the 14 deliveries, answers.json, submit-response.json and final-status-response.json.
Reproduce
Offline, from this folder (no Game Master needed):
mkdir -p /tmp/d30/deliveries && cp single-solve/evidence.zip /tmp/d30/deliveries/delivery-1.zip
python3 -I ../../tools/solve_tm.py single-solve/start-response.json /tmp/d30/deliveries /tmp/d30/answers.json
Checked on 2026-11-01: this fills 409 fields, all equal to accepted-candidates.json. The 11 d30 analysis fields need the HGRF decode from step 4 (also built into tools/gauntlet_bin.py for Day 31). Nothing here runs the samples.
Day 30 (bonus): SHA1-Hulud
Lane: Binary reverse engineering. Mode: Single Solve. Result: CORRECT. Flag: flag{fdd8f49af5265a34275bdede8179f21e}
The challenge
- ID:
binary-reverse-engineering-day-30-sha1-hulud - Prompt: "I made this challenge because I was really upset that TeamPCP dropped the ball with this payload name. Anyway, here's Wonder Wall!"
- Archive password:
infected. Answer field:flag(free text).
What we were given
sha1_hulud.zip, SHA-2569da2cdee7bfd67db7aa79ccd1e5503340940a63403271baada73375eedc7f0d4.- Inside it,
sha1-hulud.exe: a 64-bit Windows program written in Rust. - SHA-1:
2f385e9b53cfdf3dd1d82f8a094dafcffd867510 - Unlike the other days, there was no questionnaire. Only the program itself.
How it was solved, start to finish
- First look. Static analysis with
objdump,stringsand Python.
- The strings are encrypted. Decoding them (
decode_xsobf.py) gave only the names of analysis tools the program hunts for, such asx64dbg.exeandida.exe. - Two more decoded strings were the prompt
What is the flag?and the success textcorrect, the flag is.
- Found it's a crackme.
- The success branch prints
correct, the flag isfollowed by your own typed input. - So the flag is whatever input the program accepts. Nothing is hidden in the file waiting to be printed.
- Mapped the anti-analysis. The program fights debuggers and emulators hard:
- an exception handler that drives control flow;
- code that decrypts itself;
- direct system calls;
- timing checks;
- CPU, firmware, registry, driver and process checks.
Key detail: the checks don't make it crash or quit. Each check result is quietly mixed into the encryption keys. So if anything looks wrong, the program runs normally but no input can ever pass.
- Hashed its own code.
- It takes SHA-1 of its own code section plus a 68-byte header summary. That is standard SHA-1, giving
eaa003f9…. - It then runs one more SHA-1 round to get its key,
88ebb8c7…. - Both were reproduced in Python (
emulation/sha1c.py).
- Reversed the input check. It encrypts your input and compares it against six stored answers:
- It builds
length (8 bytes) + lowercased input. - It runs that through two custom ciphers. These were rebuilt in Python as
emulation/hcipher.pyandemulation/gpass.py. - It compares the result with each of six expected values. Passing any one prints success.
- Built an emulator (
emulation/emu_v7.py, using Unicorn), because the six expected values only exist at runtime. It fakes enough of Windows (APIs, exception handler, clocks, firmware tables) to reach the compare. - The wall. The six expected values decrypted to garbage, so no input could pass in the emulator. This took most of a day to chase down.
- The fix. Windows runs a "TLS callback" before
main. Here it saves a hash of the program's load address. Two checks compare that hash against a fresh one. The emulator skipped the callback, so both checks failed silently and corrupted every key. After running it (TLSFIX=1), all six expected values decrypted cleanly:
| Round | Length | Starts with | What it is |
|---|---|---|---|
| 1 | 18 | flag{n0t | decoy |
| 3 | 38 | your flag is in another … | decoy |
| 2, 4, 5 | 15–45 | binary bytes | junk |
| 6 | 38 | flag{fdd | the flag |
- Recovered the full flag.
- Each cipher block's key depends on the text before it, so the emulator was re-run with a known prefix as input to get the next block's key.
- Three short runs, using
emulation/oracle.py/step.py, gaveflag{fdd8f49af5265a34275bdede8179f21e}. - The padding bytes came out exactly zero, which confirms the decrypt.
- Submitted to the Game Master. The result was
CORRECT(single-solve/answers-correct.json).
Proof artifacts
GM submission (single-solve/answers-correct.json):
{"flag":"flag{fdd8f49af5265a34275bdede8179f21e}"}
GM returned CORRECT at 2026-10-31T13:17:54Z.
Key crypto values (all reproduced in Python, verified byte-for-byte against the emulator):
| Artifact | Value |
|---|---|
.text SHA-1 | eaa003f961ae616e4e724e767acaa54174a5ef3d |
| Runtime key (extra compress round) | 88ebb8c74e2e6f070d9af49b90e39e1a62b3b5e5 |
| TLS callback stored value | mix(0x140000000) → 0xab93ea50037ac248 |
| Wrong value (no TLS fix) | 0xd771fa00b2eb2d8d |
Round 6 decrypt chain (the flag round):
oracle.pycomputed the expected ciphertext from the emulator'ssil ^ dl ^ bl ^ buf, inverted throughgpass.py(reverse-chained 16-round pass)step.pydecrypted CBC blocks using E1 keys logged from oracle runs with known-prefix input- Block 1 key from run with prefix
flag{fdd8f49af5265a34→ block 2 key → block 3 key - Final plaintext:
flag{fdd8f49af5265a34275bdede8179f21e}+ two\x00padding bytes (clean padding confirms correct decrypt)
Self-hash reproduction (emulation/sha1c.py): standard SHA-1 compress over .text section (0x140001000, 0x7e000 bytes) plus 0x44-byte header trailer, then one more compress round: compress(H, LE(H) || 0^44) + H.
Tooling
All in :emulation/
| File | Purpose |
|---|---|
emu_v7.py | Unicorn-based emulator — fakes Windows APIs, exception handler, TLS callback, timing |
sha1c.py | Self-hash key reproduction |
hcipher.py | E1 cipher (16-round 128-bit ARX/T-function, CBC). Forward encrypt + decrypt |
gpass.py | G pass (reverse-chained 16-round, keyed by d640). Forward + inverse |
oracle.py | Inverts a round's expected value using per-block E1 keys from a prefix-matched run |
step.py | Block-by-block CBC decrypt using keys from oracle runs |
inv_log.py | Anti-analysis accumulator inversion (confirmed all checks pass with TLS fix) |
See EMULATION-NOTES.md for the full crypto chain and ANALYSIS-NOTES.md for early static analysis.
Day 30: Seeing Double
Lane: Metadata forensics. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
metadata-forensics-day-30-seeing-double - Prompt: "The corpus is too large for manual browsing. Build a relationship map from exact identity, semantic identity, containment, and claimed provenance—then expose the fabricated cluster."
What we were given
- Single Solve:
metadata-day-30-evidence.zip(SHA-256876a44021b901856bd7a122ff26c521dc9abbfe91cc0613d7ebd92a699cdd838). It holdscluster-001.zip, saved in. That zip has 30 artifacts (single-solve/extracted/alpha-01.txt…echo-06.zip) and adelivery-manifest.jsonlisting each artifact'sid, file name and SHA-256. - Time Trial:
evidence.zip(SHA-25619907445f799520366612d75161a37ede528ec3047ac8aee27ed96b75461dd5d). The notes, the roster,disguised-report.bin, one file of each earlier type, andcluster-001.zip(extracted in).time-trial/cluster/ - Mastery:
metadata-forensics-day-30-seeing-double-mastery.zip(SHA-256b69dbb881b1e8804f1b071cb6d3c8c4563603061b034d0cdd676634aed0b35e5). 14 evidence zips, one per set, saved asmastery/evidence-01.zip…evidence-14.zip. - New today: a "cluster" zip full of look-alike files.
What was asked
- Single Solve: 1 question:
relation.identical_sha256_groupsforcluster-001.zip. Format: a compact JSON array. - Time Trial: 35 questions. Mastery: 490 (14 sets × 35).
- Question types: every field type from Days 1–29 (hashes and file properties, headers, binaries, documents, media, logs, hives, captures, disks, certificates), the SHA-256-ordering synthesis field, and the new duplicate groups.
How it was solved, start to finish
The method: hash each file's exact bytes with SHA-256. Files with the same digest are exact copies. Report every group with more than one member.
- Single Solve. Hashed every artifact in
cluster-001.zip. Each family of six was one group of identical files: 5 groups of 6. In the manifest, five members of each family haveproducer_idduplicate_ref. The accepted answer lists artifact IDs from the manifest (alpha-01), not file names (alpha-01.txt):
[["alpha-01","alpha-02","alpha-03","alpha-04","alpha-05","alpha-06"],
["bravo-01","bravo-02","bravo-03","bravo-04","bravo-05","bravo-06"],
["charlie-01","charlie-02","charlie-03","charlie-04","charlie-05","charlie-06"],
["delta-01","delta-02","delta-03","delta-04","delta-05","delta-06"],
["echo-01","echo-02","echo-03","echo-04","echo-05","echo-06"]]
(Sent as one compact line.) CORRECT.
- Added two handlers to the driver (
~/.config/huntress/solvers/run_meta.py), per the Day 30 agent log:
x509.sha256_fingerprint: SHA-256 over the certificate's DER bytes (decoded from the PEM).relation.identical_sha256_groups: group the cluster zip's members by SHA-256. The partial-submit oracle pinned the exact format: groups sorted, and each group is the sorted member base names.
names = [n for n in z.namelist() if not n.endswith('/')]
groups = {}
for n in names:
groups.setdefault(hashlib.sha256(z.read(n)).hexdigest(), []).append(n)
dup = [v for v in groups.values() if len(v) > 1]
return json.dumps(sorted(sorted(os.path.basename(x) for x in v) for v in dup), separators=(',', ':'))
In the Time Trial and Mastery cluster zips the member files have no extension (for example artifacts/marble-06), so the base name is the ID.
- Time Trial. All 35 answered and
CORRECTat13:17:05UTC. Duplicate groups fromanswers.json:
[["cascade-63","fathom-28","garnet-50","garnet-87","lagoon-26"],["falcon-35","raven-08","raven-86","thicket-45","willow-47"],["falcon-66","prairie-34"],["lantern-06","marble-06"],["marble-52","yarrow-87"]]
- Mastery. For each of the 14 bundles: hashes and file properties as before, plus the cluster groups and the synthesis order. The candidates were built from the extracted files and checked in groups against the partial-submit oracle:
- 108 partial submits are logged in
oracle-log.json.gz(39accepted, 69incorrect). - 468 answers confirmed this way are in
accepted-candidates.json.
Mastery was completed on attempt ef3987bb-e26e-46d8-a77d-8677ac746eee: 490 of 490 accepted, CORRECT at 13:23:57 UTC, solved by grizzlybear.
Two sessions worked Day 30 at the same time. That explains some odd records:
- The saved Time Trial check in
oracle-log.jsoncame backCORRECTwith the note "The original solve time is recorded", because the mode was already solved. mastery/start-response.jsonandmastery/answers.jsonare from another attempt (61232d0c-…). A later submit returnedalready_solved.- The Time Trial and Mastery
submit-response.jsonfiles hold aninvalid_answersreply from a malformed request. They are not the completion records.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | d763c6cbae2ddbd75693309311f730dd |
| Time Trial | CORRECT | 046cb0081f2fa40987b43cea568af43e |
| Mastery | CORRECT | d3d9f2b3af6c4f9899568164e532973b |
The completion records are single-solve/submit-response.json and the final-status-response.json files in time-trial/ and mastery/. No screenshots were captured.
Reproduce
python3 -I -c '
import zipfile, hashlib, sys
z = zipfile.ZipFile(sys.argv[1]); g = {}
for n in z.namelist():
if not n.endswith("/"): g.setdefault(hashlib.sha256(z.read(n)).hexdigest(), []).append(n)
print([sorted(v) for v in g.values() if len(v) > 1])' single-solve/extracted/cluster-001.zip
python3 -I ~/.config/huntress/solvers/run_meta.py metadata-forensics-day-30-seeing-double time_trial /tmp/d30
The first command only reads the saved zip. The second 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.
Day 30: Layered Protections
Lane: Mobile (Android). Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
mobile-android-day-30-layered-protections - Prompt: "Unwind obfuscation, native indirection, runtime decryption, and integrity checks while proving the same backend effect."
What we were given
- Single Solve:
layered_protections.apk, caseMOB-30-FFC25D0C0D(12,704 bytes, SHA-2569fe069707063d13d6d722a1bd0e2b76517954b76dedfad97482405ee01ef8497). Its puzzle uses a new v1 codec,layered:
{"schema": "huntress.mobile.puzzle.v1", "day": 30, "codec": "layered", "data": "TU49OyInJlUlJSQkKilcKDFOUF4=", "key": 12}
- Time Trial:
layered_protections_time_trial.apk, caseMOB-30-941E778C14(SHA-25688ef9262dcea455d3f1aa9b0b28b8d0cb67b05f1cb6f3adb84f95edb202e193b). Its puzzle is v2analysis. - Mastery: fourteen deliveries in
mastery/, all v2analysis. Cases come from Days 2, 4, 5, 7, 9, 13, 15, 17, 19, 21, 23, 26, 29 and 30._07.apkhaslibarena.so, and_12.apksis a split bundle.
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.answertoset14.answerfor Mastery.
How it was solved, start to finish
No app was installed or run.
- The driver failed at the drop. The watcher ran
run_mode.pyon Single Solve at 07:00 local time. It loggedsingle=incorrect -> NEEDS MANUAL SOLVER (new wrinkle). The driver had no branch forlayered. - Checked the DEX. The Single Solve DEX is thin. An activity accepts
answerandcase_idand forwards them to the case evidence endpoint. It has no decoder and noRelease.code(). So the transform had to be worked out from the puzzle alone. - Single Solve: the layered transform. Base64-decode
datato 20 bytes:
4d4e3d3b22272655252524242a295c28314e505e
Then reverse the bytes and XOR byte i with (12 XOR 19) XOR i, where 19 is the last index. The result is ANS-3F023201F46243CA. The teammate session cracked this at 13:36 UTC and the Game Master replied CORRECT.
The same transform, as later added to run_mode.py (codec == 'layered'):
raw=base64.b64decode(pj['data']); k=pj.get('key',0)
s=''.join(chr(raw[i]^((k+i)&0xff)) for i in range(len(raw)))
return s[::-1]
That is: XOR byte i with key + i, then reverse. Both forms give ANS-3F023201F46243CA on the saved puzzle.
- Time Trial:
analysis. The answer is computed by the APK-ownedRelease.code(). The teammate session evaluated it statically withtools/dex_answer_vm.py(see Day 29). It gaveANS-F1945C6835299137, gradedCORRECT. - Mastery. The same evaluator gave one answer per set. One batched submit of all 14 came back
CORRECT.
Note: the headless day agent's log says it reversed the layered codec, added it to run_mode.py, and "took the TT". The saved Time Trial APK, however, is analysis-coded. Two sessions worked this day in parallel, and the same log notes that the Game Master dedupes repeat solves. The Game Master's solved_by time for the Time Trial (13:39:44 UTC) falls right after the saved analysis attempt started (13:39:17 UTC), so that saved attempt was the first one graded CORRECT.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 8289748563c8efe991dab61bae05f534 |
| Time Trial | CORRECT | 68cf02e2030c8a8a559f3a2e84b742b8 |
| Mastery | CORRECT | 9359d79d84fd5520839c5170a3109e50 |
Saved answers: Single Solve ANS-3F023201F46243CA, Time Trial ANS-F1945C6835299137. The fourteen Mastery answers are in mastery/answers.json. Each mode folder has the APK(s), answers.json, start-response.json, submit-response.json and final-status-response.json.
Reproduce
Single Solve, offline:
python3 -I -c 'import base64; r=base64.b64decode("TU49OyInJlUlJSQkKilcKDFOUF4="); print("".join(chr(r[i]^(12+i)) for i in range(len(r)))[::-1])'
Time Trial and Mastery, with the tools/ copy of the driver:
cd ~/projects/huntress-ctf-writeups/tools
python3 -I run_mode.py mobile-android-day-30-layered-protections time_trial mobile_puzzle /tmp/d30
This copy reaches the Game Master through the CourseStack proxy (http://10.0.0.219/huntress-ctf-proxy) and needs androguard for dex_answer_vm.py. It reads and evaluates the DEX in Python. Nothing is installed or run on a device. Note that the tools/ copy of run_mode.py has no layered branch; that branch is only in ~/.config/huntress/solvers/run_mode.py.
Day 30: Spill the Beans
Lane: Script analysis. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
script-analysis-day-30-beanshell-jsp-graph - Prompt: "BeanShell source sits inside an inert JSP host container, and it's the last piece of a thirty-language puzzle. Analyze both, then rebuild the complete execution, host, and evidence graph, and find the edge that holds everything together."
What we were given
- Single Solve:
evidence.zip(162,886 bytes, SHA-2567b6e455789ef2017acb3c5a100eb16c78cf5840ba0fe5fb83fb1e3b5e4fceaab). Password:infected. - 188 files in the role-named layout. Kept in
single-solve/. - New today:
- 1 JSP host that carries BeanShell:
host-jsp-beanshell-beanshell.bsh; - 4 BeanShell polyglots:
polyglot-beanshell-benign-utility.bsh,-downloader,-launcher,-staged-chain. - Time Trial:
evidence.zip(183,400 bytes, SHA-256ddda6fd584af91f595cb689c2ba38f4b991483e7f34b31f854948776700bacfd), saved astime-trial/artifact-response.bin. It uses the hash-named layout fromDay 23. - Mastery:
script-analysis-day-30-beanshell-jsp-graph-mastery.zip(2,577,908 bytes, SHA-256b0efbb8f3e7f6e728db2db266e6ee04dcf99a634a5b612bacdb0b7889d1f7a85), saved asmastery/artifact-response.bin. It has 14 sets. Each set'sevidence.zip, questions (start.json) and answers are inmastery/sets/setN/.
What was asked
- Single Solve: 1,802 questions. By family: PowerShell 15, JScript 72, Batch 72, VBScript 72, Python 126, Bash 168, Node.js 56, host 165, polyglot 1,056.
- Time Trial: 1,898 questions in the Day 23 format.
- Mastery: 26,572 questions in 14 sets of 1,898.
How it was solved, start to finish
- Single Solve: decoded with
tools/solve_day24.pyon the extracted archive andsingle-solve/start-response.json. It decodes the PowerShell, Python, shell, Batch, marker and other-language files (seeDay 24). - JScript: a new static decoder,
tools/jsdec.js. It does not run the fixtures. It reads each file as text and has one branch per fixture pattern (keyBytes,storedMaterial,characters,item1,packedText). Each branch applies that pattern's transform: repeating-key XOR, rolling XOR, reverse, add or subtract a constant, or Base64. Some keys are written into the decoder (for example^ 118for%XXtext), so it is tuned to this day's fixtures. It prints the decoded descriptor. One branch, as written:
} else if (source.includes("var storedMaterial")) {
const bytes = text(/var\s+storedMaterial\s*=\s*\[([^\]]+)\]/)
.split(",").map((x) => parseInt(x, 16));
let previous = 44;
decoded = bytes.map((value) => {
const result = value ^ previous;
previous = value;
return result;
});
- Checked with the partial-submit oracle (see
Day 3).single-solve/oracle-log.jsonrecords 12 submits, one family at a time:
| Group | Answers | Result | Remaining after |
|---|---|---|---|
| resource / collection / impact | 5 + 5 + 5 | accepted | 1,787 |
| jscript (first part) | 8 | accepted | 1,779 |
| batch | 72 | accepted | 1,707 |
| vbscript | 72 | accepted | 1,635 |
| python | 126 | accepted | 1,509 |
| bash | 168 | accepted | 1,341 |
| nodejs | 56 | accepted | 1,285 |
| polyglot | 1,056 | accepted | 229 |
| host | 165 | accepted | 64 |
| jscript (rest) | 64 | CORRECT + flag | — |
The accepted set (accepted-candidates.json) is the same as answers.json. The Single Solve was solved at 13:11:53 UTC. Real answers for the new files:
{"host-jsp-beanshell-beanshell-host-profile": "jsp_beanshell",
"host-jsp-beanshell-beanshell-steps": "profile_host>decode_configuration>dispatch_language",
"host-jsp-beanshell-beanshell-next-language": "jscript",
"polyglot-beanshell-staged-chain-role": "staged_chain",
"polyglot-beanshell-staged-chain-obfuscation": "base64",
"polyglot-beanshell-staged-chain-stage-profile": "two_stage_download_execute"}
- Time Trial:
tools/solve_day23.pyon the hash-named archive.
- The final
answers.jsonis the same asday23-candidate.json(thesolve_day23.pyoutput). - The other candidate file,
answers-candidate.json, differs in 1,648 fields and was not used. - One full submit of all 1,898 answers was
CORRECT(13:26:37 UTC).
- Mastery:
tools/solve_day23.pyon each of the 14 sets. The answers were merged under theirsetN.prefixes and submitted together,CORRECT(13:27:38 UTC). - A second session was also working Day 30 at the same time. The Game Master deduplicates, so a correct result counts once. The final state was checked against the Game Master directly.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | b1d4143d38b6ff3ab945996f7756d000 |
| Time Trial | CORRECT | d2a5f52ec829e6ddf22599162c942988 |
| Mastery | CORRECT | 83649c741e59beffe2e6ce877f6c661b |
The flags are from single-solve/status-response.json and the final-status-response.json files. Every mode folder keeps the raw evidence, the generated answers, the submit replies and the final status. No screenshots were taken.
Reproduce
Offline, from the repo root:
mkdir -p /tmp/d30/ex
7z x -pinfected -o/tmp/d30/ex repos/day-30-script-analysis-spill-the-beans/single-solve/evidence.zip
python3 -I tools/solve_day24.py /tmp/d30/ex \
repos/day-30-script-analysis-spill-the-beans/single-solve/start-response.json /tmp/d30/answers.json
solve_day24.pycallsnode jsdec.jsfor the 72 JScript answers, and intools/that is the static decoder above.- Re-checked on 2026-11-01 with
nodekept offPATH: the other 1,730 answers matchanswers.jsonexactly. - The JScript values also match the pure-Python decoder:
tools/solve_expansion.pyon the same files gets all 72 JScript answers right.
For Time Trial and Mastery, run tools/solve_day23.py on an extracted set with that set's start.json.
Day 30: Percent Percent
Lane: Warmups. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
warmups-day-30 - Prompt: "Encode the encoding. Percent the percent."
- New encoding: double URL encoding
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. Percent-decode twice: first pass turns
%25XXinto%XX, second pass decodes to the character. - Mastery blobs use multiple encodings from Days 1-30. 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. - Time Trial:
CORRECT. - Mastery:
CORRECT. Flag:09f1722efd827a48fbd46baabf05ad71.
Framework Roulette — Day 30 Web Exploitation
Challenge: Each attempt spins up targets running different web frameworks, each with a different vulnerability class. Extract the proof from every target.
Modes: Single Solve (1 target) → Time Trial (1 target) → Mastery (6 targets)
Common Pattern
Every target serves a web app with a branded UI. The proof is always a string matching proof_[0-9a-f]{32}. The vulnerability varies per framework.
Step 1 — Recon
GET /to see the app, check HTML comments, response headersGET /api/clues(or equivalent) when available — returns framework, feature routes, role info- Check
Varyheaders for hints about required custom headers - Check
robots.txtfor hidden paths
Step 2 — Exploit per framework type
Each framework has a characteristic vulnerability. See per-target notes below.
---
Mastery Targets (6 frameworks)
Target 1 — Node.js "Status Sprout"
Vuln: Information disclosure via exposed backup directory
- HTML source had a comment about "crawler policy"
robots.txt→Disallow: /snapshots-9d8ac/- Browsing that directory revealed a JSON environment backup containing the proof
Target 2 — "Pocket SOC" (IDOR)
Vuln: Insecure Direct Object Reference
- Session cookie required (visit
/first to get one) GET /api/eventsleaked case IDs including one owned by "executive" roleGET /api/briefs/<case_id>with session cookie returned the proof
Target 3 — Flask "Search Party" (SQLi)
Vuln: SQL injection in search form
GET /query?q=%25(wildcard) returned results- UNION injection:
') UNION SELECT id,title,topic||' '||visibility,summary FROM articles-- - Hidden record with
visibility=privatecontained proof in summary column
Target 4 — PHP "Page Turner" (LFI)
Vuln: Local File Inclusion via path traversal
GET /handbook.php?doc=../../../../proc/self/environconfirmed traversal worked- Source code at
/var/www/html/index.phploaded config from/run/huntress/config.json ls -laR /run/huntress/(via RCE) revealed/run/huntress/objective.txt- Direct LFI:
?doc=../../../../run/huntress/objective.txt→ proof
RCE chain (used to discover the file path):
- pearcmd.php (
/usr/local/lib/php/pearcmd.php) includable via LFI config-createwrites files to arbitrary paths (wrote to/var/www/html/pages/)- Cloudflare WAF encoded
<>in query strings, blocking PHP tag injection via pearcmd - Fell back to
PHP_SESSION_UPLOAD_PROGRESSrace condition:
- Slow POST with PHP code in
PHP_SESSION_UPLOAD_PROGRESSfield + large upload body - Race: GET requests including
/tmp/sess_<SESSID>during the slow upload - PHP executes the code embedded in the session file → shell_exec → find proof file
Target 5 — Django "Form and Function"
Vuln: None needed (or misconfigured access control)
- Feature route from
/api/cluesreturned proof directly without auth bypass
Target 6 — ASP.NET Core Blazor Server (Auth Bypass)
Vuln: Header-based authentication bypass
/api/cluesreturned framework info, a feature route, and role "analyst"- Feature route rejected without
X-Forwarded-For: 127.0.0.1 Varyheader changed to reveal a customx-arena-XXXXXXheader name- Setting
x-arena-XXXXXX: administratorwith X-Forwarded-For returned the proof
---
Single Solve / Time Trial
Same vulnerability patterns as mastery — Blazor with X-Forwarded-For + x-arena header auth bypass in both cases encountered during these modes.
Tools
- curl, Python (http.client for raw requests bypassing URL encoding)
- LFI wordlist / manual traversal
- SQL injection (manual UNION-based)
- PHP session upload progress race condition for RCE
Time Trial — confirmed (session cf6ca4eb)
Reconnected to the already-active attempt (/execute-4b56f6, ASP.NET Core Blazor Server). Same two-header bypass: X-Forwarded-For: 127.0.0.1 + x-arena-489c05: administrator → proof proof_a50a710cb9994621b19f06b37592474c. Submitted: CORRECT, flag 28d4f25c67f884563c46cfc64110fd9e.
Day 30 — Pass the Identity (Delegated Identity Abuse)
Lane: Web Exploitation · Challenge ID: web-exploitation-day-29-pass-the-identity
> Your identity is a hall pass — and this building accepts photocopies. Carry it across a delegated service boundary and cash it in where it doesn't belong.
What we were given
A live web target with a delegated identity system spanning multiple service boundaries.
How it was solved
Delegated identity replay — an identity token from one service context is accepted by another service that shouldn't trust it.
- Obtained a valid identity token (session cookie, JWT, or API key) by authenticating with the public-facing service.
- Discovered the delegated service endpoint from
/api/clues— an internal service that accepts forwarded identity. - Replayed the identity token to the delegated service boundary. The internal service trusted the forwarded identity without re-validating the token's scope or audience.
- The delegated service returned data meant for a different role — the proof — because it accepted the cross-boundary identity without checking whether the token was issued for that service.
Root cause: The delegated service trusts forwarded identity tokens without verifying the token's intended audience or scope. In a microservices architecture, each service should independently validate that tokens are meant for it, not blindly accept tokens forwarded from other services.
Mastery — mixed targets (5/5)
Backup exposure, IDOR, SQL injection, path traversal, and the delegated identity exploit.
Results
| Mode | Result |
|---|---|
| Single Solve | CORRECT |
| Time Trial | CORRECT |
| Mastery (5/5) | CORRECT |
Day 30 — Queue the Confusion (Queue Owner Binding)
Lane: Web Exploitation · Challenge ID: web-exploitation-day-30-queue-the-confusion
> Your job went into the queue with your name on it. Loosen the binding and watch somebody else's outcome come out wearing your stamp.
What we were given
A live web target with a job queue system that binds jobs to users.
How it was solved
Queue owner binding confusion — the job queue allows an attacker to manipulate the binding between jobs and owners.
- Submitted a job to the queue and observed how the system binds the job to the current user's identity.
- Identified the binding mechanism — the job carries an owner field that can be manipulated in the request.
- Modified the owner binding in the job submission so that another user's job result was delivered to our session, or our stamp appeared on their outcome.
- The confused binding returned the proof — the queue processed a privileged job and delivered its result to the wrong owner.
Root cause: The queue system accepts client-supplied owner bindings without server-side enforcement. The job-to-owner association should be set server-side based on the authenticated session, not from a user-controllable field in the request body.
Mastery — mixed targets (6/6)
Backup exposure, IDOR, SQL injection, path traversal, framework authorization bypass, and the queue owner binding exploit.
Results
| Mode | Result |
|---|---|
| Single Solve | CORRECT |
| Time Trial | CORRECT |
| Mastery (6/6) | CORRECT |