2026-10-23

Day 23: Trust Issues

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

The challenge

What we were given

What was asked

How it was solved, start to finish

  1. The watcher fired the driver automatically. watcher.py ran run_tm.py for the binary lane in all three modes. Its log for Day 23 reads: [OK] binary-reverse-engineering single=CORRECT(542285673c2cb963352606e415d91056) TT=CORRECT mastery=CORRECT.
  2. No new code was needed. d23 is read like d03 and d22:
  1. Time Trial files: the Time Trial files in this folder come from a later run of run_tm.py that day (commit 640f3cf: "binary Trust Issues time-trial: full solve via run_tm.py"). Its d23 answers (answers.json):
  1. 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)
  1. Result: all three modes CORRECT. A later check by a helper agent found all three already solved; it made no solver edits.

Results

ModeResultFlag
Single SolveCORRECT542285673c2cb963352606e415d91056
Time TrialCORRECT40f2e53713d8eb721d39292d5bef0c14
MasteryCORRECT55bb5ee5482259de9fe785b2420c4c40

What is saved:

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

What we were given

What was asked

How it was solved, start to finish

A helper agent solved this lane. It had to fix four separate problems.

  1. 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.
  2. 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 1 means 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.

  1. Time Trial: incorrect with 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:

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.

  1. The format rules it found (the driver was patched to follow them):
  1. 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.zip from the single outer zip and map them to set1 … set7.
  2. Mastery problem 2: synthesis bug. The answers were incorrect as 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 the setN. 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.

  1. Answers. Page sizes: Single Solve 4096, Time Trial 32768, mastery sets 1–4 1024, 8192, 4096, 512. Example synthesis answer (Time Trial): ["evidence-note.txt","database-001.sqlite","panel-001.png","installer-001.msi","video-001.mp4"].

Results

ModeResultFlag
Single SolveCORRECT6075d3ae962e25feebfa774f9a869636
Time TrialCORRECT7c7fe393397c06effb784562fda6fb0f
MasteryCORRECT67015b884943026c82e10b792a972dd1

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

What we were given

{"schema": "huntress.mobile.puzzle.v2", "day": 23, "codec": "analysis", "build": "a63a821a9b58"}

What was asked

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.

  1. Single Solve at the drop. The watcher ran run_mode.py at 07:00 local time. Single Solve came back CORRECT. The driver had no analysis support yet, so this APK used one of the older codecs. Time Trial and Mastery gave no output: the driver crashed with KeyError: 'data' on the new v2 puzzle.
  2. 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() runs token() → Mix.f1 → fin*() → XOR with a constant. Then it formats the 64-bit result as ANS- plus 16 uppercase hex digits, most significant first.
  3. Ported it by hand first. A Python port of the chain gave ANS-DB5F19F53E2C42AF for the first variant. But each attempt changes the package, case, constants and method names. So hard-coding would not work.
  4. Built a small smali interpreter, smali_analysis.py:
  1. Wired it into the driver:
if codec=='analysis':
    import smali_analysis
    return smali_analysis.solve_analysis(b)
  1. Time Trial, first try: rejected. The answer for a fresh variant (ANS-04AAC150F90FD16F) was wrong. Cause: the interpreter silently skipped rem-int/lit8, shl-int, ushr-int/2addr and or-int/2addr. After adding them, the live variant gave ANS-1449CDA4659B4147. That was CORRECT.
  2. Mastery: the native wrinkle. In set 5 of the first Mastery attempt, the token chain calls a native method, NativeLibrarySecrets.nativeShare, inside libarena.so. That function is straight-line x86-64 math. So the interpreter got a small native path:
  1. 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 was CORRECT.
  2. What the "false positives" were. Decoy methods named seal* that are never on the call graph, and decoy entries in the int arrays.
  3. 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 decoy xor eax,eax; ret path. The emulator was patched to:

The re-run came back CORRECT with the same flag. The files in this folder come from that re-run.

Results

ModeResultFlag
Single SolveCORRECT1893abb04c7f3d6453a5ea3648774f93
Time TrialCORRECTe6dd7928930a6a4eebdc1b920aca8039
MasteryCORRECT6437ee9b6559895bf6115d129f6e4df8

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

What we were given

What was asked

How it was solved, start to finish

  1. 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.
  2. Time Trial: wrote solve_day23.py for the hash-named layout. Its header says it handles "hash-named multi-language fixtures ... and polyglot (layered LYR codecs, many langs)".
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|...
  1. 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.
  2. 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 (see Day 3). Only secondary (3 questions) was rejected.
  1. One-line fix in solve_day23.py. After it, the Time Trial check passed and Mastery came back CORRECT (14:33:39 UTC).
  2. 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

ModeResultFlag
Single SolveCORRECTb024fdc1c9602dc7d7cb2945c13150f1
Time TrialCORRECTd3dd09058d8b5c8fd6071bb131fd2551
MasteryCORRECTb24a078d9295618b2689fcef9e4d5dc2

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

What we were given

How it was solved

  1. Decode the blob. Adobe ASCII85 encoding, delimited by <~ and ~>. Decode with the ascii85 / base85 algorithm.
  2. 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.
  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 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.

  1. Examined the target application. It accepts user input and stores it without immediate feedback.
  2. Planted data containing the injection payload into the storage mechanism (database, queue, or similar).
  3. Triggered the delayed processing — when the application later retrieves and processes the stored data, it evaluates the injected content in a privileged context.
  4. 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

ModeResultFlag
Single SolveCORRECT511b55674dd9c70ff276b171ba0564fa
Time TrialCORRECTa8f1b4991de574c8bb5d7ec7307a7fd7
Mastery (3/3)CORRECTaaacc516524ce7f1be47f9bd2f57e9ba

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.

  1. Queried /api/clues to discover the feature route and secondary route.
  2. 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.
  3. Submitted a request with an extra privileged field: {"role": "administrator"} (or {"isAdmin": true} depending on the target variant).
  4. The server accepted the field, promoted the account, and the secondary route (or audit endpoint) returned the proof with effect confirming 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

ModeResultFlag
Single SolveCORRECT1a94eea94f9537a0bc4f14f18fbcd565
Time TrialCORRECTcb933a4de005aec5a09dc525c7eca2b1
Mastery (3/3)CORRECT3711dffe5f7b250fcea3f876e58774a9

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.

  1. Queried /api/clues to discover the feature route and framework info.
  2. The feature route accepts a template parameter via POST. Sent {{7*7}} as a probe — the response contained 49, confirming the template engine evaluates expressions.
  3. Constructed a Java reflection chain to execute system commands through the template engine. The chain uses Runtime.getRuntime().exec() to run shell commands, with a Scanner to capture output:
  1. 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

ModeResultFlag
Single SolveCORRECTc6ccb8f65eb16934dd327a1a969be6ba
Time TrialCORRECT486bc732a1f386672b6f32cb71f52f71
Mastery (3/3)CORRECTf332effeb1912c4b15451d1b08759b2e