2026-10-24

Day 24: Spot the Difference

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 ran the driver first. run_tm.py answered most fields, but the Game Master replied accepted (partial), not CORRECT. The watcher log flagged it: single=accepted -> NEEDS MANUAL SOLVER (new wrinkle).
  2. Found the gap. Six d24 fields were missing. At that time solve_tm.py only knew the selectors stripped, symbolized, compact, direct, loader and plugin. Fields with corrected_ or vulnerable_ in the name were not handled. The common d24_analysis_config_* fields did work.
  3. Looked inside the JARs (extracted with 7z):

Re-checked on the Day 29 copies:

for m in re.finditer(rb'[A-Za-z0-9+/]{80,}={0,2}', z.read(name)):
    rec = base64.b64decode(m.group() + b'=' * (-len(m.group()) % 4))
    if rec[:4] != b'HCFG': continue
    key = rec[5]; plen, crc = struct.unpack_from('<HI', rec, 6)
    payload = bytes(b ^ key for b in rec[12:12+plen])
    if zlib.crc32(payload) == crc: print(name, hex(key), hex(crc), json.loads(payload)['campaign'])
d24--sample-vulnerable.jar Day24Vulnerable000$.class key=0x91 crc32=0x2316c89d BR24-000 b64 starts SENGRwGRcAGd
d24--sample-corrected.jar  Day24Corrected000$.class  key=0x91 crc32=0x2316c89d BR24-000 b64 starts SENGRwGRcAGd

Both builds carry the same config, so the "byte-for-byte equal" check passes.

  1. Submitted the six missing fields on top of the accepted ones:
  1. Time Trial: the driver's answers plus the same six fields, built from that variant's common config. Result: CORRECT.
  2. Mastery: eight sets. The same six fields per set (48 in total), each from that set's own config. Result: CORRECT.
  3. Later fix: on Day 26 the selectors corrected and vulnerable were added to solve_tm.py (commit b1e1234), so these fields are now answered automatically.

What changed between the builds (not scored): a name diff of the two $ classes shows the corrected build adds a filter call and three lambdas in score ($anonfun$score$1 to $anonfun$score$3).

Results

ModeResultFlag
Single SolveCORRECTebd0eb16d7441a3b77d390b6254b67c4
Time TrialCORRECTbaa304c40b57deaa44c2f4c94a6e31ba
MasteryCORRECTa1f3fa1eb3b8e0db91ee6982eb9be626

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.

Reproduce

The Day 24 bundles were not saved. The two JARs can be checked from the Day 29 folder with the snippet above (it only reads the JARs):

X=../day-29-binary-reverse-engineering-fraternal-twins/single-solve/extracted
sha256sum $X/d24--*     # same hashes as d24_artifact_sha256_1 and _2

Live driver:

python3 -I ~/.config/huntress/solvers/run_tm.py binary-reverse-engineering-day-24-patch-diffing single_solve /tmp/d24

This needs a Game Master token in ~/.config/huntress/gm-token. Nothing here runs the samples.

Day 24: Event Horizon

Lane: Metadata forensics. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.

The challenge

What we were given

What was asked

How it was solved, start to finish

The method: every EVTX event record starts with the 4-byte signature 2a 2a 00 00 (**\0\0). Count real records in the file, not what a header or the file size suggests.

  1. Single Solve. Downloaded and extracted the zip. Looked at events-001.evtx:
d = open('events-001.evtx', 'rb').read()
print(d.count(b'ElfChnk\x00'))          # 1
print(d.count(b'\x2a\x2a\x00\x00'))     # 3

Submitted 3. CORRECT.

  1. Time Trial. run_meta.py answered 28 of 29. It had no EVTX handler yet, so the record count was missing. Downloaded the Time Trial evidence, counted 2a2a0000 in its events-001.evtx (14), added it, and submitted all 29. CORRECT.
  2. Mastery. run_meta.py answered everything except the 8 EVTX counts (one per set). Extracted the outer zip and each evidence-0N.zip, then counted each set's events-001.evtx:
Set12345678
Records113765560118775916

Filled them in and submitted all 232. CORRECT.

Later notes:

Results

ModeResultFlag
Single SolveCORRECTe17daaad656b21750e1c5c8f9ca80c98
Time TrialCORRECT5d91cc1cdb2e398930fa781fa334227b
MasteryCORRECT26f6a8d6a24b1b773baa76d58a2efe9d

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

Reproduce

python3 -I -c 'import sys; print(open(sys.argv[1],"rb").read().count(bytes.fromhex("2a2a0000")))' events-001.evtx
python3 -I ~/.config/huntress/solvers/run_meta.py metadata-forensics-day-24-event-horizon single_solve /tmp/d24

The first line only needs the extracted .evtx. The second needs a Game Master token in ~/.config/huntress/gm-token; the current driver includes the EVTX handler. For time_trial and mastery it calls op=retry first, which spends one of the unique attempts.

Day 24: Emulator Alibi

Lane: Mobile (Android). Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.

The challenge

What we were given

What was asked

How it was solved, start to finish

No hand work was needed. The reused mobile driver solved all three modes at the drop. No app was installed or run, so the app's emulator checks never came into play.

  1. The watcher fired at the drop. watcher.py saw Day 24 at 07:00:10 local time. It ran the mobile lane driver for Single Solve:
python3 -I ~/.config/huntress/solvers/run_mode.py mobile-android-day-24-emulator-alibi single_solve mobile_puzzle <workdir>
  1. The driver solved it. run_mode.py downloads each APK, reads assets/huntress_puzzle.json, and decodes it by its codec field. For analysis APKs it runs the smali interpreter from Day 23 on Release.code(). Then it submits.
  2. The watcher ran Time Trial and Mastery the same way. Its log line, 16 seconds after the drop:
[OK] mobile-android single=CORRECT(9f32f8d256faadcc936a42c2b33fd6c3) TT=CORRECT mastery=CORRECT
  1. Saved the records. Later, op=status was called for each mode and the replies were saved as final-status-response.json.

Results

ModeResultFlag
Single SolveCORRECT9f32f8d256faadcc936a42c2b33fd6c3
Time TrialCORRECTe0fd3cd8b9205b4fe5e4d08cf981cc5a
MasteryCORRECT33ce17c71cef5386f3046d4db8893822

Each mode folder has only final-status-response.json. The answer codes were not saved.

Reproduce

python3 -I ~/.config/huntress/solvers/run_mode.py mobile-android-day-24-emulator-alibi single_solve mobile_puzzle /tmp/d24

This needs a Game Master token in ~/.config/huntress/gm-token, plus Java (for baksmali.jar) and binutils for analysis APKs. It never installs or runs the app on a device. The solver toolchain is mirrored in tools/.

Day 24: Web of Lies

Lane: Script analysis. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.

The challenge

What we were given

What was asked

How it was solved, start to finish

  1. Started the Single Solve and looked at the questions. They mix the Day 23 PowerShell questions with descriptor questions for the many polyglot and host files. The question IDs did not match the Day 23 solver, so every question was mapped to its file through the artifact field.
  2. Wrote solve_day24.py, with three families:
  3. Marker files. Decode HUNTRESS_ANALYSIS_V1 (B64, HEX, FRAG, HB64). A SPLIT array is joined first, and here it wraps a FRAG payload. Every answer is read straight from the decoded config.
  4. PowerShell samples. The Day 23 logic: scenario, ATT&CK, URL, wallet, mutex, first list item, user agent, extension, note.
  5. Behavioral scripts. The per-language decoders (Days 3–7), then role and ATT&CK from the steps. JScript went through jsdec.js (the Node vm sandbox).
  6. First run: 1,468 of 1,516 answered. The 48 empty ones were JScript sub-fields: function, invocation and property style, next stage, and the impact extension and note. The JScript source-style rules from Day 3 and the extra config keys were added. Then all 1,516 were filled.
  7. The full submit came back incorrect, with no detail. So the partial-submit oracle was used, one field class per submit (see Day 3). Three groups failed:

After these three fixes, the last probe returned CORRECT (solved 14:07:45 UTC). Real answers from single-solve/answers.json:

{"host-jsp-webshell-jsp-role": "staged_chain", "host-jsp-webshell-jsp-host-profile": "jsp_webshell",
 "host-jsp-webshell-jsp-steps": "acquire_remote>dispatch_process",
 "host-jsp-webshell-jsp-stage-profile": "two_stage_download_execute",
 "polyglot-jsp-downloader-role": "downloader", "polyglot-jsp-downloader-attack": "T1105",
 "bash-advanced-indirect-role": "advanced_syntax",
 "bash-chain-cron-path": "/etc/cron.d/update-e1c8a1c276",
 "vbscript-uploader-upload-url": "https://8159ab62ae.example.invalid/upload/bfc6c547"}
  1. Time Trial. It used the Day 23 hash-named format, so solve_day23.py was the right solver. It answered 1,560/1,560, and the submit was CORRECT (14:20:10 UTC).
  2. Mastery. 8 sets, each in the Day 23 format. solve_day23.py ran on each set, the answers were merged under setN., and the submit was CORRECT (14:21:28 UTC).

run_day24_script.py is the driver for the Single Solve format: start → download → 7z → solve_day24.py → submit → status.

Results

ModeResultFlag
Single SolveCORRECT60ca14c87d46cd315fd468ae70e41dac
Time TrialCORRECTdca497e1072495096a0d6e47d52691fc
MasteryCORRECTea5ffba3c94356579e21a29796d12cd3

Each mode folder has 4 files: start-response.json, answers.json, submit-response.json and final-status-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. On a fresh attempt:

# Single Solve format (needs a Game Master token in ~/.config/huntress/gm-token)
python3 -I ~/.config/huntress/solvers/run_day24_script.py single_solve /tmp/d24

# Hash-named format (Time Trial, or one Mastery set), on an extracted archive
python3 -I tools/solve_day23.py /tmp/d24tt/ex start-response.json /tmp/d24tt/answers.json

Note: solve_day24.py calls node jsdec.js for JScript with no fallback. With the ~/.config/huntress/solvers/ copy, that runs each fixture in a Node vm sandbox. The tools/jsdec.js copy decodes the same fixtures statically.

Day 24: String Theory

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. Format: count:char,count:char,.... Repeat each character by its count and concatenate.
  2. Mastery blobs use multiple encodings from Days 1-24. 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 24 — Fetch Quest (SSRF)

Lane: Web Exploitation · Challenge ID: web-exploitation-day-15-fetch-quest

> The app fetches URLs on your behalf. Point it somewhere it shouldn't go.

What we were given

A live web target with a server-side URL fetch feature.

How it was solved

Server-Side Request Forgery (SSRF) — the app's fetch endpoint can be directed to internal services that aren't exposed to the internet.

  1. Queried /api/clues to discover the feature route (e.g. /action-66cfe3) and internal service details.
  2. The feature route accepts a url parameter and fetches it server-side. It's intended for external URLs, but doesn't restrict the target.
  3. Directed the fetch to the internal loopback service: GET /action-66cfe3?url=http://127.0.0.1:8080/account-e149c9
  4. The server fetched the internal endpoint on our behalf and returned the response, which contained the proof.

Root cause: The server-side fetch endpoint doesn't validate or restrict the target URL. An attacker can point it at internal services (127.0.0.1, internal hostnames, cloud metadata endpoints) that are otherwise unreachable from the internet. The internal service trusts requests from localhost and returns privileged data.

Results

ModeResultFlag
Single SolveCORRECT67f478b11dff347c07bbf0b3f0fd4842
Time TrialCORRECT1e975c4e7fe9ad50316a5294138d29a1
MasteryCORRECT2b176c3c7d6217392bc05ebe209bf1b2

Day 24 — The API Has Opinions (BOLA / Field-Action Auth Bypass)

Lane: Web Exploitation · Challenge ID: web-exploitation-day-14-the-api-has-opinions

> The API respects your role — until you ask it nicely with the right parameters.

What we were given

A live web target with an API that exposes object-level operations.

How it was solved

Broken Object Level Authorization (BOLA) combined with a field/action bypass — the API lets you access restricted records by specifying the right query parameters.

  1. Queried the target to discover the API structure and available endpoints.
  2. Found a protected record (e.g. ID 15564) that belongs to a privileged user. Normal access is denied.
  3. The API endpoint accepts fields and action query parameters that override the default access control:

GET /execute-8fcc90?id=15564&fields=note&action=export

  1. By requesting a specific field (note) with an export action, the authorization check is bypassed and the restricted record's content is returned, containing the proof.

Root cause: The API implements object-level authorization for default operations but has a separate code path for export actions that doesn't enforce the same access checks. The fields parameter further narrows the response, but the authorization gap exists regardless.

Results

ModeResultFlag
Single SolveCORRECTf9c343ebc1e6ef50df56a79dc648433c
Time TrialCORRECT37cf8acafc600aaf09d331418d99a40d
MasteryCORRECT7ecd28d3ea33aa54d324662f411d2c9e