2026-10-23
Day 23: Trust Issues
Lane: Binary reverse engineering. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
binary-reverse-engineering-day-23-anti-analysis-recognition - Prompt: "This binary doesn't trust you. It checks the clock, sniffs the environment, and takes different branches when it thinks it's being watched. Spot every predicate and force the truth out."
What we were given
- One
evidence.zip(35,675,756 bytes, SHA-256e47cb97a509b9af4ced1ecc242f72ecd561b03d7d0f2300fe61965a7d4a0e924). AES encrypted, passwordinfected. It was not saved in this folder. - The earlier files again:
d01tod22. - New today: a
d23group: a .NET DLL and itsruntimeconfig.json. - The DLL has anti-analysis checks. Its names include
Debugger,GetEnvironmentVariable,Stopwatch/get_ElapsedTicks,branch,decoy,sandboxandvbnet_anti_analysis_predicate_trace(the last name suggests a VB.NET build). Seen in thed23copy saved in the Day 29 folder.
What was asked
- 276 questions in Single Solve and Time Trial. Mastery had seven deliveries, so 1,932.
- Question types:
- Hashes: SHA-256 of both d23 members (and all older members).
- d01 to d22: the same questions as Day 22.
- d23 (new): for the main DLL: machine, format token, CLR metadata version, XOR key,
HCFGversion, the config fields and the CRC32. - No question asked about the anti-analysis branches. Only the static facts were scored.
How it was solved, start to finish
- The watcher fired the driver automatically.
watcher.pyranrun_tm.pyfor the binary lane in all three modes. Its log for Day 23 reads:[OK] binary-reverse-engineering single=CORRECT(542285673c2cb963352606e415d91056) TT=CORRECT mastery=CORRECT. - No new code was needed. d23 is read like d03 and d22:
- Pick the main DLL (the member that carries an
HCFGrecord). - Format
pe_cli, machine from the PE header, CLR version fromBSJB. - Config from a plain
HCFGscan. The program never runs, so its clock and environment checks never matter.
- Time Trial files: the Time Trial files in this folder come from a later run of
run_tm.pythat day (commit640f3cf: "binary Trust Issues time-trial: full solve via run_tm.py"). Its d23 answers (answers.json):
- format
pe_cli, machinei386, metadata versionv4.0.30319; - XOR key
0xba, version1, CRC320x72693d08; - campaign
BR23-6876FA07, domainsync-9b743879.day23.example.invalid, mutexGlobal\Huntress47A993FC99AE. - This variant used random-looking names instead of the usual
BR23-000pattern. The solver reads whatever the record holds, so it did not matter.
- Re-check of the d23 DLL saved in the Day 29 folder, with
hcfg.py:
=== HCFG valid records in d23--sample.dll ===
offset=0x1e00 version=1 xor_key=0x81 plen=368 crc32=0xeb13668a
JSON: {"campaign":"BR23-000","domain":"node-000.day23.example.invalid","ipv4":"198.51.100.190","url":"https://node-000.day23.example.invalid/api/BR23-000","mutex":"Global\\HuntressBR23_000", ...}
=== CLR metadata version (BSJB+16, len=12) ===
version: 'v4.0.30319'
=== PE/COFF Machine ===
machine: 0x014c (332)
- Result: all three modes
CORRECT. A later check by a helper agent found all three already solved; it made no solver edits.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 542285673c2cb963352606e415d91056 |
| Time Trial | CORRECT | 40f2e53713d8eb721d39292d5bef0c14 |
| Mastery | CORRECT | 55bb5ee5482259de9fe785b2420c4c40 |
What is saved:
- Single Solve and Mastery: only
final-status-response.json. The watcher's per-answer files were not copied here. - Time Trial: the full set (
start-response.json,answers.json,submit-response.json,final-status-response.json).
Reproduce
The Day 23 bundles were not saved, so a full offline re-run is not possible. The d23 DLL can be checked from the Day 29 folder (from this folder):
python3 -I ~/.config/huntress/solvers/hcfg.py ../day-29-binary-reverse-engineering-fraternal-twins/single-solve/extracted/d23--sample.dll
Live driver:
python3 -I ~/.config/huntress/solvers/run_tm.py binary-reverse-engineering-day-23-anti-analysis-recognition time_trial /tmp/d23
This needs a Game Master token in ~/.config/huntress/gm-token. Both only parse the files and never run them.
Day 23: Page Me Maybe
Lane: Metadata forensics. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
metadata-forensics-day-23-page-me-maybe - Prompt: "Application databases have been copied, truncated, embedded, and mislabeled. Validate page geometry, connect databases to parent applications, and find the impossible claim."
What we were given
- Single Solve:
metadata-day-23-evidence.zip(SHA-256f2540b81c5f76f7467452c021d3b84363185525ae894134ee13da209146781f2) withdatabase-001.sqlite. - Time Trial:
evidence.zip(SHA-25648f1ce3674a403ff7aeb1160502b49b041a8c5c6791133a5b3d112be388d8668). One file of each type so far, now includingdatabase-001.sqlite. - Mastery:
metadata-forensics-day-23-page-me-maybe-mastery.zip(SHA-256d92e607ceeeeb140d23d80191d3eed281ff5e8a289e81fe05b76fd21cadb5141). One outer zip with seven inner zips,evidence-01.ziptoevidence-07.zip. - New today: SQLite database files.
What was asked
- Single Solve: 1 question:
sqlite.page_size_bytesfordatabase-001.sqlite. - Time Trial: 28 questions. Mastery: 196 (7 sets × 28).
- Question types: everything from Day 22, plus the SQLite page size.
How it was solved, start to finish
A helper agent solved this lane. It had to fix four separate problems.
- Single Solve: wrong handler. The first run returned
12288. The answer ID ends in-size-bytes, so the generic "file size" handler caught it and returned the file length. - Added a SQLite header handler before the generic one. The page size is a 2-byte big-endian number at offset 16 of the header; the value
1means 65536. The handler also covers other header fields (page count, encoding, user version and so on) in case later rounds ask for them.
if 'sqlite' in aid and fb[:16] == b'SQLite format 3\x00':
if 'page-size' in aid or 'page_size' in aid:
ps = struct.unpack_from('>H', fb, 16)[0]
return str(65536 if ps == 1 else ps)
Result: 4096. CORRECT.
- Time Trial:
incorrectwith no hint which field was wrong. Every byte-based answer checked out against other tools, so the problem had to be the format of some answers. The attempt was untimed, with 32 attempts left. The agent:
- ran the driver once, then kept submitting to that same live attempt, changing only the fields whose format was unclear;
- saw that changing one field at a time never worked, so at least two fields were wrong at once;
- tried the combinations of those fields. One combination returned
CORRECT.
One detour: an op=start call during testing brought back a different variant, so the answers computed earlier no longer matched. Lesson: stay on one attempt while testing formats.
- The format rules it found (the driver was patched to follow them):
- MSI
ProductCode: keep the stored form, with braces and capitals. - Mach-O
cpu_type_set: sort the list. .docxexternal targets: sort the list.- ZIP central-directory names: sort the list (not central-directory order).
- Mastery problem 1: set mapping. All 7 sets came in one outer zip. The driver expected one download per set and crashed. It was patched to read the inner zips
evidence-01.zip…evidence-07.zipfrom the single outer zip and map them toset1…set7. - Mastery problem 2: synthesis bug. The answers were
incorrectas a whole. A full re-check found that the SHA-256 ordering question used the wrong file list. The driver stored each question's text under the ID with thesetN.prefix removed, so every set overwrote the same key. Every set was solved with the last set's file list, and 5 of 7 were wrong. Fix: set that key to the current set's own text right before solving:
stripped = aid[len('set%d.' % sn):]
QTEXT[stripped] = QTEXT.get(aid, '') # per-set question text
ans[aid] = compute(stripped, qart.get(aid, ''), bundles[sn])
Then CORRECT.
- Answers. Page sizes: Single Solve
4096, Time Trial32768, mastery sets 1–41024,8192,4096,512. Example synthesis answer (Time Trial):["evidence-note.txt","database-001.sqlite","panel-001.png","installer-001.msi","video-001.mp4"].
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 6075d3ae962e25feebfa774f9a869636 |
| Time Trial | CORRECT | 7c7fe393397c06effb784562fda6fb0f |
| Mastery | CORRECT | 67015b884943026c82e10b792a972dd1 |
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-23-page-me-maybe single_solve /tmp/d23
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 reads the SQLite fields from the header bytes.
Day 23: Hook Line and Signal
Lane: Mobile (Android). Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
mobile-android-day-23-hook-line-and-signal - Prompt: "Separate real instrumentation signals from generated false positives."
What we were given
- One Android APK per case. The APKs were not saved in this folder.
- Single Solve:
hook_line_and_signal.apk, caseMOB-23-40D151C015. - Time Trial:
hook_line_and_signal_time_trial.apk, caseMOB-23-7545AAF090in the saved attempt. - Mastery: seven APKs. In the saved attempt the cases come from Days 3, 4, 9, 12, 16, 22 and 23. In the first Mastery attempt, one APK (set 5) also carried a native library,
lib/x86_64/libarena.so. - New today: a v2 puzzle format with no answer data in it:
{"schema": "huntress.mobile.puzzle.v2", "day": 23, "codec": "analysis", "build": "a63a821a9b58"}
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.answertoset7.answerfor Mastery (all-or-nothing).
How it was solved, start to finish
No APK was installed or run. Everything was done on the DEX bytecode and the .so file as data.
- Single Solve at the drop. The watcher ran
run_mode.pyat 07:00 local time. Single Solve came backCORRECT. The driver had noanalysissupport yet, so this APK used one of the older codecs. Time Trial and Mastery gave no output: the driver crashed withKeyError: 'data'on the new v2 puzzle. - Found where the answer lives. A helper agent unpacked one of the new APKs. The code is computed by the DEX. A static method
Release.code()runstoken()→Mix.f1→fin*()→ XOR with a constant. Then it formats the 64-bit result asANS-plus 16 uppercase hex digits, most significant first. - Ported it by hand first. A Python port of the chain gave
ANS-DB5F19F53E2C42AFfor the first variant. But each attempt changes the package, case, constants and method names. So hard-coding would not work. - Built a small smali interpreter,
smali_analysis.py:
- Disassemble
classes.dexwithbaksmali.jar(v2.5.2). - Find the static method that returns a
Stringand contains"ANS-"(that isRelease.code()). - Run it and every method it calls, with exact Java 64-bit and 32-bit math (wrap-around multiply and add, rotates, Java-style
rem/div, sign extension), plus smallStringBuilder,String.charAtandLong.toHexStringmodels.
- Wired it into the driver:
if codec=='analysis':
import smali_analysis
return smali_analysis.solve_analysis(b)
- Time Trial, first try: rejected. The answer for a fresh variant (
ANS-04AAC150F90FD16F) was wrong. Cause: the interpreter silently skippedrem-int/lit8,shl-int,ushr-int/2addrandor-int/2addr. After adding them, the live variant gaveANS-1449CDA4659B4147. That wasCORRECT. - Mastery: the native wrinkle. In set 5 of the first Mastery attempt, the token chain calls a native method,
NativeLibrarySecrets.nativeShare, insidelibarena.so. That function is straight-line x86-64 math. So the interpreter got a small native path:
- Find the JNI symbol with
nm. - Disassemble it with
objdump -M intel. - Step through the ALU instructions in Python (
mov,add,xor,imul,rol,shrand so on). The firstjlongargument goes inrdx. The result israx.
- Mastery, first submit: rejected. Arrays (
new-array,aget,aput) were being skipped. They pick the real value over the decoy values inside the mix. After adding array support, four of the seven answers changed. Unknown opcodes now raise an error instead of being skipped. The resubmit wasCORRECT. - What the "false positives" were. Decoy methods named
seal*that are never on the call graph, and decoy entries in the int arrays. - Re-run for the records (later that day). Re-running Mastery to save its files hit a new native pattern: anti-analysis guards. They are
cmp/ conditional-jump checks with a decoyxor eax,eax; retpath. The emulator was patched to:
- map 32/16/8-bit register names (
ecx,cx,cl) to their 64-bit parent, - treat
cmp,testand all jumps as no-ops, so it falls through to the real math, - handle
movzx/movsx.
The re-run came back CORRECT with the same flag. The files in this folder come from that re-run.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 1893abb04c7f3d6453a5ea3648774f93 |
| Time Trial | CORRECT | e6dd7928930a6a4eebdc1b920aca8039 |
| Mastery | CORRECT | 6437ee9b6559895bf6115d129f6e4df8 |
Saved answers: Single Solve ANS-75C47B4BF8B5B1C1, Time Trial ANS-F7A3D341BED5FF79. The seven Mastery answers are in mastery/answers.json. 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 flag.
Reproduce
python3 -I ~/.config/huntress/solvers/run_mode.py mobile-android-day-23-hook-line-and-signal single_solve mobile_puzzle /tmp/d23
This needs a Game Master token in ~/.config/huntress/gm-token, plus Java (for baksmali.jar) and binutils (nm, objdump). It disassembles the DEX and the .so and evaluates them in Python. It never installs or runs the app on a device.
Day 23: Press Start to Decode
Lane: Script analysis. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
script-analysis-day-23-game-resource-loader - Prompt: "A GDScript resource loader builds its strings in layers, one power-up at a time. Undo the construction, recover the exact indicators, and correlate its stage relationships with the rest of the corpus to find the level that doesn't belong."
What we were given
- Single Solve: one
evidence.zip(139,343 bytes, SHA-2560e6b2bb25abd2bbf6e42fc8620b9dd8a5dc07118e9d84bd308347679c62d5e55). Password:infected. - Same role-named layout as Day 22, plus 4 GDScript polyglots:
polyglot-gdscript-benign-utility.gd,-downloader,-launcher,-staged-chain. - Markers use the four Day 8 forms. The saved obfuscation answers are only
plain_hex,base64,hex_base64andfragmented_hex. - Time Trial and Mastery: a new layout.
- Files have hash names instead of role names, for example
3bad9c.ps1,9a6714.js,10c7ec.php. - Polyglot markers are now layered:
HUNTRESS_ANALYSIS_V1:LYR-<codec>-<data>, where the codec lists the layers, for exampleb32_rev_fragorhex_b64_hex. - Time Trial:
evidence.zip, 155,914 bytes, SHA-256f03aeb81d4a6c5f1bd31e2b4857b38de4984e1a67f70d66f6bccdd89f0e7a715. - Mastery:
script-analysis-day-23-game-resource-loader-mastery.zip, 1,086,009 bytes, one inner zip per set. - The archives were not kept in this folder, only the JSON files.
What was asked
- Single Solve: 1,461 questions, same types as Day 22.
- Time Trial: 1,495 questions with new IDs and new question types:
- PowerShell (
powershell-<hash>-...):url,secondaryandtertiary. Secondary is the wallet (resource), staged file name (collection) or recovery note (impact). Tertiary is the mutex, user agent or encrypted-file extension. - Script files (
jscript-,batch-,vbscript-,python-,bash-,nodejs-<hash>-...): - role, ATT&CK and steps;
- campaign, and campaign-token (the part after the first hyphen);
- indicator: the first one present, in a fixed order (URL, upload URL, next stage, file path, schedule path, ...);
- style: three labels joined by
|. JScript: function / invocation / property. VBScript: representation / transform / control. Batch: graph / control / expansion. - Python also gets
carrier|windows_chainandsyntax|obfuscation. Advanced Bash files get feature and primitive. - Polyglot (
polyglot-<lang>-<hash>-...): role, ATT&CK, steps, stage count, stage profile, obfuscation (the layer list), next language, campaign, campaign-token, URL, file path, plus url-host and path-leaf. - Mastery: 10,465 questions in 7 sets of 1,495, all-or-nothing.
How it was solved, start to finish
- Single Solve. A sub-agent was put on this lane at unlock and told to use
run_expansion.py. It solved the Single Solve at 13:02:33 UTC. Which solver produced those answers is not recorded. - Time Trial: wrote
solve_day23.pyfor the hash-named layout. Its header says it handles "hash-named multi-language fixtures ... and polyglot (layered LYR codecs, many langs)".
- Each question's
artifactfield (evidence.zip -> 9a6714.js) gives the file. - The old per-language decoders (
batchdec,vbsdec,pydec,bashdec,nodedec) and the JScript decoder recover each config. - Role and ATT&CK come from the steps. The question text spells out the same rules.
- LYR markers are undone layer by layer, last layer first. Simplified from
poly_cfg():
m = re.search(r'HUNTRESS_ANALYSIS_V1:LYR-([a-z0-9_]+)-([A-Za-z0-9+/=._-]+)', text)
codec, data = m.groups() # e.g. "b64_b32"
cur = data.encode()
for layer in reversed(codec.split('_')): # b32 first, then b64
cur = {'b64': b64, 'b32': b32, 'hex': unhex,
'rev': lambda b: b[::-1], 'frag': lambda b: b.replace(b'.', b'')}[layer](cur)
cfg = dict(p.split('=', 1) for p in cur.decode().split('|'))
A real line in this format (from a Day 29 Mastery file kept in this repo, 026aa6.csx), and what it decodes to:
HUNTRESS_ANALYSIS_V1:LYR-b64_b32-MRVDA6TGI54GQYTNMQYVSV3ENRIFOTT2MFDUM6LDIY4XUWJT...
v=3|language=csharp_script|role=stager|verdict=suspicious|attack=T1105|adapter=runtime_loader|host_profile=aspx_inline_csharp|obfuscation_profile=b64_b32|stage_profile=ruby_ladder|next_language=fish|stage_count=7|...
- The derived fields are simple string cuts:
url-hostis the host part of the URL,path-leafis the last path segment, andcampaign-tokenis the text after the first hyphen. - The Time Trial was
CORRECTat 13:12:30 UTC.run_expansion.pywas also changed to send any question set withpolyglot-IDs tosolve_day23.py.
- Mastery failed at first. Mastery is all-or-nothing and gives no per-answer feedback. The sub-agent kept resubmitting for about an hour, so the main session stopped it and took over.
- Found the bug with the Time Trial oracle. A fresh Time Trial variant also came back
incorrect, which proved the solver was wrong, not unlucky. Partial submits on that Time Trial accept or reject each group (seeDay 3). Onlysecondary(3 questions) was rejected.
- The two wrong ones were collection samples. The solver returned the
stage-*.zipvalue. - The grader wants the staged file name: the first item of the descriptor's list,
update-<token>.dat.
- One-line fix in
solve_day23.py. After it, the Time Trial check passed and Mastery came backCORRECT(14:33:39 UTC). - Real Time Trial answers from
time-trial/answers.json:
{"powershell-3bad9c-secondary": "wallet_5b9fc9a207fa0efecbe73194a6898de2",
"powershell-3bad9c-tertiary": "Global\\HuntressLab_6bc61730dda3",
"jscript-9a6714-role": "stager", "jscript-9a6714-steps": "acquire_remote>dispatch_memory",
"jscript-9a6714-style": "named_expression|call|bracket_literal",
"jscript-9a6714-campaign-token": "3fa5812555",
"polyglot-gdscript-a2bd79-obfuscation": "b32_hex", "polyglot-gdscript-a2bd79-stage-count": "7",
"polyglot-gdscript-a2bd79-next-language": "beanshell",
"polyglot-gdscript-a2bd79-path-leaf": ".552979ac4bba4c4c.stage"}
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | b024fdc1c9602dc7d7cb2945c13150f1 |
| Time Trial | CORRECT | d3dd09058d8b5c8fd6071bb131fd2551 |
| Mastery | CORRECT | b24a078d9295618b2689fcef9e4d5dc2 |
Each mode folder has answers.json, submit-response.json and final-status-response.json. Single Solve and Time Trial also have start-response.json. Time Trial and Mastery had no deadline (run_for_time: false). No screenshots were taken.
Reproduce
The archives were not kept, so the saved answers cannot be rebuilt offline. For a fresh hash-named attempt:
mkdir -p /tmp/d23/ex
7z x -pinfected -o/tmp/d23/ex evidence.zip
python3 -I tools/solve_day23.py /tmp/d23/ex start-response.json /tmp/d23/answers.json
Then submit answers.json (needs a Game Master token). solve_day23.py first tries node jsdec.js for JScript, using the jsdec.js next to it, and falls back to jsdec_py_emu.py. The tools/jsdec.js copy decodes statically. The ~/.config/huntress/solvers/jsdec.js copy runs the fixture in a Node vm sandbox. For Mastery, run it once per extracted set with that set's questions, then add the setN. prefixes.
Day 23: Eighty-Five Alive
Lane: Warmups. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
warmups-day-23 - Prompt: "Eighty-five printable characters. Adobe might recognize the neighbors."
- New encoding: ASCII85 (Adobe variant)
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. Adobe ASCII85 encoding, delimited by
<~and~>. Decode with the ascii85 / base85 algorithm. - Mastery blobs use multiple encodings from Days 1-23. 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:crisp-starfish-quartz-70. Flag:eb58099d74b7332db7dafb20ada2128b. - Time Trial:
CORRECT. slug:proud-canyon-wagon-60. Flag:3e700042478cb717d8ba151f91e89961. - Mastery:
CORRECT. 113 slugs. Flag:4ef4eeb60190c2045e26bdcf0fb18f89.
Day 23 — Ask Again Later (Delayed Echo / Second-Order Injection)
Lane: Web Exploitation · Challenge ID: web-exploitation-day-12-ask-again-later
> No answer right now? Fine. Plant your question inside the data and come back later — the delayed echo tells all.
What we were given
A live web target where inputs aren't immediately reflected — they're stored and processed later.
How it was solved
Second-order data injection — plant a payload in the stored data, then trigger its evaluation when the application processes it later.
- Examined the target application. It accepts user input and stores it without immediate feedback.
- Planted data containing the injection payload into the storage mechanism (database, queue, or similar).
- Triggered the delayed processing — when the application later retrieves and processes the stored data, it evaluates the injected content in a privileged context.
- The "delayed echo" response contained the proof.
The challenge teaches that sanitizing input at the point of entry isn't enough — data must also be treated safely when it's read back and processed later (second-order vulnerability).
Mastery mixed 3 targets with different vulnerability types.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 511b55674dd9c70ff276b171ba0564fa |
| Time Trial | CORRECT | a8f1b4991de574c8bb5d7ec7307a7fd7 |
| Mastery (3/3) | CORRECT | aaacc516524ce7f1be47f9bd2f57e9ba |
Day 23 — Posted Too Much (Mass Assignment)
Lane: Web Exploitation · Challenge ID: web-exploitation-day-13-posted-too-much
> The form only asked for your name. But the API binds whatever you hand it — so hand it a promotion.
What we were given
A live web target with a form/API that accepts user profile data.
How it was solved
Mass assignment — the API binds all submitted fields to the internal model, including privileged fields the form doesn't expose.
- Queried
/api/cluesto discover the feature route and secondary route. - The visible form only asks for basic fields (e.g.
display_name). But the API endpoint accepts any JSON field and binds it directly to the user model. - Submitted a request with an extra privileged field:
{"role": "administrator"}(or{"isAdmin": true}depending on the target variant). - The server accepted the field, promoted the account, and the secondary route (or audit endpoint) returned the proof with
effectconfirming the privilege escalation.
Root cause: The API uses automatic model binding without a whitelist of allowed fields. The client-side form only shows safe fields, but the server-side handler accepts and processes any field present in the request body — including role, isAdmin, or similar privileged attributes.
Automated with web_solve.py (ex_mass_assignment): tries multiple privilege escalation payloads (role: administrator, isAdmin: true, etc.) against discovered routes.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 1a94eea94f9537a0bc4f14f18fbcd565 |
| Time Trial | CORRECT | cb933a4de005aec5a09dc525c7eca2b1 |
| Mastery (3/3) | CORRECT | 3711dffe5f7b250fcea3f876e58774a9 |
Day 23 — Template Temper (SSTI)
Lane: Web Exploitation · Challenge ID: web-exploitation-day-11-template-temper
> The template engine is feeling expressive today — it evaluates everything it hears. Whisper the right incantation and make the server speak in expressions.
What we were given
A live Java/Spring web target with a template rendering endpoint.
How it was solved
Server-Side Template Injection — the app passes user input directly into a template engine that evaluates expressions, allowing arbitrary code execution.
- Queried
/api/cluesto discover the feature route and framework info. - The feature route accepts a
templateparameter via POST. Sent{{7*7}}as a probe — the response contained49, confirming the template engine evaluates expressions. - Constructed a Java reflection chain to execute system commands through the template engine. The chain uses
Runtime.getRuntime().exec()to run shell commands, with aScannerto capture output:
- Ran
cat /run/huntress/objective.txtto read the proof file
- The template engine evaluated the expression and returned the file contents containing the proof.
Root cause: User input is passed directly to the Java template engine (Spring Expression Language or similar) without sandboxing. The template context has access to Java reflection, allowing arbitrary class loading and command execution — SSTI to RCE.
Automated with web_solve.py (ex_ssti): discovers the template parameter name, confirms expression evaluation with {{7*7}}, then executes file-read commands via Java reflection chains.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | c6ccb8f65eb16934dd327a1a969be6ba |
| Time Trial | CORRECT | 486bc732a1f386672b6f32cb71f52f71 |
| Mastery (3/3) | CORRECT | f332effeb1912c4b15451d1b08759b2e |