2026-10-24
Day 24: Spot the Difference
Lane: Binary reverse engineering. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
binary-reverse-engineering-day-24-patch-diffing - Prompt: "Two builds, one fix. Diff the vulnerable function against its corrected twin and pinpoint exactly what changed — then prove the old one was really broken."
What we were given
- One
evidence.zip(35,684,100 bytes, SHA-25634d32411f3103f9e3dcd36ac768ceeb34b27a66785c3fd6a6a5f6cb6efcb6628). AES encrypted, passwordinfected. It was not saved in this folder. unzipcannot open it ("need PK compat. v5.1").7z x -pinfectedcan.- The earlier files again:
d01tod23. - New today: two builds of the same Scala program, as JARs:
…vulnerable.jar(4,054 bytes):Day24Vulnerable000$.classandDay24Vulnerable000.class.…corrected.jar(4,422 bytes):Day24Corrected000$.classandDay24Corrected000.class.- Both are byte-identical (same SHA-256) to the
d24JARs saved in the Day 29 folder.
What was asked
- 288 questions in Single Solve and Time Trial. Mastery had eight deliveries, so 2,304.
- Question types:
- Hashes: SHA-256 of both JARs (and all older members).
- d01 to d23: the same questions as Day 23.
- d24 (new):
vulnerable_formatandcorrected_format: the format token of each JAR.config_*: decode the config from both JARs, check they are byte-for-byte equal, then reportcampaign,domain,mutex,url.corrected_config_*: the same four fields from the corrected JAR.- No question scored the diff itself (what changed between the builds).
How it was solved, start to finish
- The watcher ran the driver first.
run_tm.pyanswered most fields, but the Game Master repliedaccepted(partial), notCORRECT. The watcher log flagged it:single=accepted -> NEEDS MANUAL SOLVER (new wrinkle). - Found the gap. Six d24 fields were missing. At that time
solve_tm.pyonly knew the selectorsstripped,symbolized,compact,direct,loaderandplugin. Fields withcorrected_orvulnerable_in the name were not handled. The commond24_analysis_config_*fields did work. - Looked inside the JARs (extracted with 7z):
- Each
$class (the Scala companion object) holds a long Base64 constant,encodedConfig. It startsSENGRwGR…, which is Base64 forHCFG+ version 1 + key0x91. - Base64-decode it, then decode the
HCFGrecord as usual: XOR with0x91, check the CRC32, parse the JSON. - The classes also hold a trace template:
{"schema":"huntress.binary.dynamic_trace.v1", … "family":"scala_patch_diff_trace","effects":"benign_control_and_reversion_only","network":"none", …}.
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.
- Submitted the six missing fields on top of the accepted ones:
d24_analysis_corrected_config_campaign/_domain/_mutex/_url: the same values as the common config (BR24-000,node-000.day24.example.invalid,Global\HuntressBR24_000,https://node-000.day24.example.invalid/api/BR24-000).d24_analysis_corrected_format=jar,d24_analysis_vulnerable_format=jar.- Result:
CORRECT.
- Time Trial: the driver's answers plus the same six fields, built from that variant's common config. Result:
CORRECT. - Mastery: eight sets. The same six fields per set (48 in total), each from that set's own config. Result:
CORRECT. - Later fix: on Day 26 the selectors
correctedandvulnerablewere added tosolve_tm.py(commitb1e1234), 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
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | ebd0eb16d7441a3b77d390b6254b67c4 |
| Time Trial | CORRECT | baa304c40b57deaa44c2f4c94a6e31ba |
| Mastery | CORRECT | a1f3fa1eb3b8e0db91ee6982eb9be626 |
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
- ID:
metadata-forensics-day-24-event-horizon - Prompt: "Windows event logs from several hosts have been duplicated, truncated, and bundled with reports. Count records accurately and find the selectively shortened timeline."
What we were given
- Single Solve:
metadata-day-24-evidence.zip(1,452 bytes, SHA-2566ded154983b3595bb2afa2112d1431a6895da7fbfd51d624ec0631f6b3db8841) withevents-001.evtx(69,632 bytes). - Time Trial:
evidence.zip(SHA-256afd951bda233b3f959839f791246b73106c65a37319d6d51acc85cc739f36b91). One file of each type so far, now includingevents-001.evtx. From today the note and roster names carry random suffixes, for exampleevidence-note-08be5f.txt. - Mastery:
metadata-forensics-day-24-event-horizon-mastery.zip(SHA-256064afc1a402e67c93c0058f57db2414a5fb10834c2316e3d58ad55c14f2a095a). Eight inner zips,evidence-01.ziptoevidence-08.zip. - New today: Windows event logs (
.evtx).
What was asked
- Single Solve: 1 question:
evtx.record_countforevents-001.evtx. Format: a base-10 integer. - Time Trial: 29 questions. Mastery: 232 (8 sets × 29).
- Question types: everything from Day 23, plus the EVTX record count.
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.
- Single Solve. Downloaded and extracted the zip. Looked at
events-001.evtx:
- size 69,632 bytes, one
ElfChnkchunk; **\x00\x00record signatures: 3;- the chunk header's first and last record numbers: 1 and 3, so a span of 3.
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.
- Time Trial.
run_meta.pyanswered 28 of 29. It had no EVTX handler yet, so the record count was missing. Downloaded the Time Trial evidence, counted2a2a0000in itsevents-001.evtx(14), added it, and submitted all 29.CORRECT. - Mastery.
run_meta.pyanswered everything except the 8 EVTX counts (one per set). Extracted the outer zip and eachevidence-0N.zip, then counted each set'sevents-001.evtx:
| Set | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
|---|---|---|---|---|---|---|---|---|
| Records | 113 | 76 | 55 | 60 | 118 | 77 | 59 | 16 |
Filled them in and submitted all 232. CORRECT.
Later notes:
- On Day 25 a chunk-aware counter was written (walk each 64 KiB
ElfChnkchunk and step from record to record by size). Unlike a plain byte search, it ignores2a2a0000bytes that are not at a record start. - On Day 28 the plain
2a2a0000count was added torun_meta.pyas theevtxhandler.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | e17daaad656b21750e1c5c8f9ca80c98 |
| Time Trial | CORRECT | 5d91cc1cdb2e398930fa781fa334227b |
| Mastery | CORRECT | 26f6a8d6a24b1b773baa76d58a2efe9d |
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
- ID:
mobile-android-day-24-emulator-alibi - Prompt: "Defeat app-owned environment checks on the same pinned emulator used by the solve oracle."
What we were given
- Single Solve:
emulator_alibi.apk, caseMOB-24-D222D6F58D(12,704 bytes, SHA-256bd3e6f02601670af5d131cc240d7f0dde177b0751464180598a1d18943291c52). - Time Trial:
emulator_alibi_time_trial.apk, caseMOB-24-4000D43543(12,704 bytes, SHA-256ddc850616a3b1403d650a9829c43ebce3698730e787fb106b5e227c25c7a040b). - Mastery: eight APKs, cases from Days 3, 6, 9, 10, 15, 17, 23 and 24. Two have other sizes: set 4 is 12,845 bytes and set 5 is 12,772 bytes. All names, sizes and hashes are in
mastery/final-status-response.json. - The APKs themselves were not saved. So the codecs used today are not recorded.
What was asked
- One question per case: return the exact backend answer code for that case.
- Answer format:
ANS-plus exactly 16 uppercase hex characters. - Answer IDs:
answerfor Single Solve and Time Trial.set1.answertoset8.answerfor Mastery.
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.
- The watcher fired at the drop.
watcher.pysaw 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>
- The driver solved it.
run_mode.pydownloads each APK, readsassets/huntress_puzzle.json, and decodes it by itscodecfield. ForanalysisAPKs it runs the smali interpreter from Day 23 onRelease.code(). Then it submits. - 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
- Saved the records. Later,
op=statuswas called for each mode and the replies were saved asfinal-status-response.json.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 9f32f8d256faadcc936a42c2b33fd6c3 |
| Time Trial | CORRECT | e0fd3cd8b9205b4fe5e4d08cf981cc5a |
| Mastery | CORRECT | 33ce17c71cef5386f3046d4db8893822 |
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
- ID:
script-analysis-day-24-jsp-webshell-source - Prompt: "This JSP source is shaped like a webshell: it reads requests and stages server-side work. Recover the order of requests and stages, then separate the inert fixture behavior from the lines that would be real execution primitives in the wild."
What we were given
- Single Solve: one
evidence.zip(144,836 bytes, SHA-2566239594b109301fa09b96af0ff3665ae13f262447f08b0d5129178aacd3c712f). Password:infected. - 162 fixture files in the role-named layout (as on Day 22). New today: 1 JSP host (
host-jsp-webshell-jsp.jsp) and 4 JSP polyglots (polyglot-jsp-*.jsp). - Two kinds of files:
- files with a
HUNTRESS_ANALYSIS_V1marker in any of theB64,HEX,FRAG,HB64orSPLITforms; - behavioral scripts without a marker (JScript, Node, Batch, VBScript, Python, Bash).
- Time Trial and Mastery: the hash-named layout from
Day 23. - Time Trial:
evidence.zip, 159,137 bytes, SHA-25674a92264bb00a6aa8b44c74063f514d9cab30a0e6fb0075bcffdaabc9e61b55f. - Mastery:
script-analysis-day-24-jsp-webshell-source-mastery.zip, 1,281,899 bytes, with 8 inner set zips. - The archives were not kept in this folder, only the JSON files.
What was asked
- Single Solve: 1,516 questions. By family: PowerShell 15, JScript 72, Batch 72, VBScript 72, Python 126, Bash 168, Node.js 56, host 143, polyglot 792. Same field types as before.
- Time Trial: 1,560 questions in the Day 23 hash-named format.
- Mastery: 12,480 questions in 8 sets of 1,560.
How it was solved, start to finish
- 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
artifactfield. - Wrote
solve_day24.py, with three families: - Marker files. Decode
HUNTRESS_ANALYSIS_V1(B64,HEX,FRAG,HB64). ASPLITarray is joined first, and here it wraps aFRAGpayload. Every answer is read straight from the decoded config. - PowerShell samples. The Day 23 logic: scenario, ATT&CK, URL, wallet, mutex, first list item, user agent, extension, note.
- Behavioral scripts. The per-language decoders (Days 3–7), then role and ATT&CK from the steps. JScript went through
jsdec.js(the Nodevmsandbox). - 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.
- The full submit came back
incorrect, with no detail. So the partial-submit oracle was used, one field class per submit (seeDay 3). Three groups failed:
bashrole (24): the advanced-syntax Bash files need the roleadvanced_syntax.bashpath (3): thecron-pathfield returnedfile_pathinstead ofcron_path.vbscriptURL (3): theupload-urlfield returnedurlinstead ofupload_url.
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"}
- Time Trial. It used the Day 23 hash-named format, so
solve_day23.pywas the right solver. It answered 1,560/1,560, and the submit wasCORRECT(14:20:10 UTC). - Mastery. 8 sets, each in the Day 23 format.
solve_day23.pyran on each set, the answers were merged undersetN., and the submit wasCORRECT(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
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 60ca14c87d46cd315fd468ae70e41dac |
| Time Trial | CORRECT | dca497e1072495096a0d6e47d52691fc |
| Mastery | CORRECT | ea5ffba3c94356579e21a29796d12cd3 |
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
- ID:
warmups-day-24 - Prompt: "Repeat yourself efficiently. Count and character."
- New encoding: run-length 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. Format:
count:char,count:char,.... Repeat each character by its count and concatenate. - 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. - 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:jaunty-compass-mosaic-76. Flag:ccac24be57b14d3a8a2438a55a28f048. - Time Trial:
CORRECT. slug:daring-island-quill-99. Flag:f9ad54b063d81d902a633e104e276319. - Mastery:
CORRECT. 118 slugs. Flag:eee20c861def6ffdf6f52cd481e36153.
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.
- Queried
/api/cluesto discover the feature route (e.g./action-66cfe3) and internal service details. - The feature route accepts a
urlparameter and fetches it server-side. It's intended for external URLs, but doesn't restrict the target. - Directed the fetch to the internal loopback service:
GET /action-66cfe3?url=http://127.0.0.1:8080/account-e149c9 - 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
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 67f478b11dff347c07bbf0b3f0fd4842 |
| Time Trial | CORRECT | 1e975c4e7fe9ad50316a5294138d29a1 |
| Mastery | CORRECT | 2b176c3c7d6217392bc05ebe209bf1b2 |
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.
- Queried the target to discover the API structure and available endpoints.
- Found a protected record (e.g. ID
15564) that belongs to a privileged user. Normal access is denied. - The API endpoint accepts
fieldsandactionquery parameters that override the default access control:
GET /execute-8fcc90?id=15564&fields=note&action=export
- 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
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | f9c343ebc1e6ef50df56a79dc648433c |
| Time Trial | CORRECT | 37cf8acafc600aaf09d331418d99a40d |
| Mastery | CORRECT | 7ecd28d3ea33aa54d324662f411d2c9e |