2026-10-27
Day 27: Compiler Says What
Lane: Binary reverse engineering. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
binary-reverse-engineering-day-27-compiler-attribution - Prompt: "Every compiler signs its work. Compare the runtime and linker fingerprints across builds and name the toolchain — attribute this binary to its maker."
What we were given
- One
evidence.zip(SHA-2561e70c3609f6e77d406f0b23f55dd68b9a9ca09b5950fc1e8ec3478037327fbb0). AES encrypted, passwordinfected. It was not saved in this folder. - About 30 specimens per set: ELF, PE, .NET, JAR and WebAssembly files from
d01tod26. - New today: the same program built by two compilers:
…gcc.elf(108,155 bytes in the saved copy), built with GCC;…tcc.elf(462,379 bytes in the saved copy), built with TCC.- Both are byte-identical to the
d27files saved in the Day 29 folder.
What was asked
- 324 questions in Single Solve and Time Trial. Mastery had eleven deliveries, so 3,564.
- Question types:
- Hashes: SHA-256 of each member.
- d01 to d26: the same questions as Day 26.
- d27 (new):
gcc_format,gcc_machine,tcc_format,tcc_machine: format token and decimale_machineof each build;config_*: decode both builds, check the configs are byte-for-byte equal, report the commoncampaign,domain,mutex,url;gcc_config_campaignandgcc_config_domain: from the GCC build.- The config questions said: "scan backward from the end of the member for literal HCFG".
How it was solved, start to finish
- The watcher ran the driver first. The Game Master answered
accepted: 318 of 324 correct, 6 missing. The watcher flagged the lane:NEEDS MANUAL SOLVER (new wrinkle). - Found the gap. The six missing fields were exactly the new selectors:
d27_analysis_gcc_format,gcc_machine,tcc_format,tcc_machine,gcc_config_campaignandgcc_config_domain.solve_tm.pydid not knowgccortccas file selectors. - Patched
solve_tm.py(the copy in~/.config/huntress/solvers/):gcc|tccwere added to the selector list, next tostripped|symbolized|compact|direct|loader|plugin|corrected|vulnerable. Nowd27_analysis_gcc_machineuses the member whose name containsgcc, and so on. The existing handlers do the rest:
- format token
elf; - machine as a decimal number, because the question says "base-10":
62; - config from the plain
HCFGscan.
- Config check. In both builds the record is the last 379 bytes of the file, so a scan from the end finds it first. Re-checked on the Day 29 copies:
gcc.elf length 108155 HCFG offset=107776 version=1 xor_key=0xc1 len=367 crc32=0x577e10d4 (after all sections)
tcc.elf length 462379 HCFG offset=462000 version=1 xor_key=0xc1 len=367 crc32=0x577e10d4 (after all sections)
JSON (both): {"campaign":"BR27-000","domain":"node-000.day27.example.invalid","ipv4":"198.51.100.30","url":"https://node-000.day27.example.invalid/api/BR27-000","mutex":"Global\\HuntressBR27_000", ...}
The two configs are equal, as the question requires.
- Single Solve: the six missing answers were filled in (see
answers.json: both formatself, both machines62, GCC campaignBR27-000). The attempt was then solved. - Time Trial and Mastery: a second watcher run with the patched solver solved both on the first try. Its log:
single=already_solved(None) TT=CORRECT mastery=CORRECT.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | a4207a63fac38ce746896f17dde8a3c7 |
| Time Trial | CORRECT | 28c97e744f41bd43868e6f778bf1a814 |
| Mastery | CORRECT | 574bb5439b35b217de3cd7512742b72d |
Each mode folder has the raw start-response.json, answers.json, submit-response.json and final-status-response.json.
Notes on the saved files:
single-solve/submit-response.jsonis the partial submit (accepted, 6 remaining).single-solve/final-status-response.jsonis a copy of the start response.- So the Single Solve flag is not in this folder. It comes from the Game Master status recorded by
checkpoint.py(sync_from_gm) in~/.config/huntress/progress.json. - The
tools/copy ofsolve_tm.pyhandles these fields with a separategcc_…/tcc_…handler that was added on Day 29.
Reproduce
The Day 27 bundles were not saved. The two builds can be checked from the Day 29 folder (from this folder):
X=../day-29-binary-reverse-engineering-fraternal-twins/single-solve/extracted
sha256sum $X/d27--* # same hashes as d27_artifact_sha256_1 and _2
python3 -I ~/.config/huntress/solvers/hcfg.py $X/d27--sample-gcc.elf
python3 -I ~/.config/huntress/solvers/hcfg.py $X/d27--sample-tcc.elf
Live driver:
python3 -I ~/.config/huntress/solvers/run_tm.py binary-reverse-engineering-day-27-compiler-attribution single_solve /tmp/d27
This needs a Game Master token in ~/.config/huntress/gm-token. Nothing here runs the samples.
Day 27: Packet Loss Prevention
Lane: Metadata forensics. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT (3/3).
The challenge
- ID:
metadata-forensics-day-27-packet-loss-prevention - Prompt: "Packet captures, exports, and host artifacts describe the same incident from different angles. Count traffic, reject malformed captures, and find the host narrative missing network evidence."
What we were given
- Single Solve:
metadata-day-27-evidence.zip(SHA-2563aff14dbde990236abbb1cc9ffb5f71a96b910070e1854037854336fdddc5e32) withcapture-001.pcap. - Time Trial:
evidence.zip(SHA-2566e998f475b1806b68a17505e956a0ede5d3d392e526f602cedc61b5a64d357f8). 24 files: the notes, the roster and one file of each type so far, now includingcapture-001.pcap. - Mastery:
metadata-forensics-day-27-packet-loss-prevention-mastery.zip(SHA-25617e925c6674becf2b9ba667fa04f4e54c314323756b99bcb3ada959d2292036f). Eleven inner zips,evidence-01.ziptoevidence-11.zip, each with its own unique evidence. - New today: packet captures (
.pcap).
What was asked
- Single Solve: 1 question:
pcap.packet_countforcapture-001.pcap. Format: a base-10 integer. - Time Trial: 32 questions. Mastery: 352 (11 sets × 32).
- Question types: everything from Day 26, plus the packet count.
How it was solved, start to finish
The step-by-step log for this lane is not among the saved logs. It was solved and committed early that day (commit be8afde, 07:09 local time). The steps below are the techniques recorded for this day, with the parser code that was later merged into run_meta.py (Day 28).
- Packet count. A classic pcap file has a 24-byte global header. Then each packet has a 16-byte record header followed by its data. The captured length (
incl_len) is at +8 in the record header. Walk the records and count them:
magic = fb[:4]
end = '<' if magic in (b'\xd4\xc3\xb2\xa1', b'\x4d\x3c\xb2\xa1') else '>'
off = 24; cnt = 0
while off + 16 <= len(fb):
incl = struct.unpack_from(end + 'I', fb, off + 8)[0]
off += 16 + incl; cnt += 1
The merged handler also counts packet blocks (types 6, 3 and 2) in pcapng files.
- The other new-ish fields were computed next to
run_meta.py, which did not have them yet:
- EVTX record count: count the
\x2a\x2a\x00\x00record signature. - Registry hive root name: the
nkrecord at the root cell offset. - Prefetch executable name: UTF-16LE, 60 bytes at offset
0x10.
- All other fields came from
run_meta.py. - Single Solve.
capture-001.pcaphad 3 packets. Submitted3.CORRECT. - Time Trial. 32 fields. Examples from
answers.json: packets7, EVTX records46, registry rootXipmRgJ7zXCG2zxZKlaKworah, Prefetch nameNOTIFIER.EXE.CORRECT. - Mastery. 352 fields across 11 sets. Packet counts per set:
6, 7, 18, 11, 18, 37, 23, 20, 11, 10, 30.CORRECT.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 3849c7ab2d1db424ef200e138e5f2b9a |
| Time Trial | CORRECT | 0be43c643029d868a77b218656476379 |
| Mastery | CORRECT | bb6c7751ab492f43dc89007707932744 |
Each mode folder has answers.json, start-response.json and a short submit-response.json with the result and flag. No screenshots were captured.
Reproduce
python3 -I ~/.config/huntress/solvers/run_meta.py metadata-forensics-day-27-packet-loss-prevention single_solve /tmp/d27
This needs a Game Master token in ~/.config/huntress/gm-token. The current driver has the pcap, EVTX, registry and Prefetch handlers. For time_trial and mastery it calls op=retry first, which spends one of the unique attempts. It only parses the capture; nothing is replayed.
Day 27: Dependency Surface
Lane: Mobile (Android). Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
mobile-android-day-27-dependency-surface - Prompt: "Prove which generated dependency flaw is reachable from an exported mobile surface."
What we were given
- Single Solve and Time Trial: one APK each. Nothing from these two modes was saved in the repo.
- Mastery: eleven deliveries, one per case, from Days 2, 3, 6, 9, 12, 15, 16, 19, 23, 26 and 27. Ten are
.apkfiles. Set 10 (dependency_surface_mastery_10.apks, a Day 26 case) is a split bundle. Names and hashes are inmastery/start-response.json. The APKs themselves were not saved.
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.answertoset11.answerfor Mastery.
How it was solved, start to finish
No app was installed or run. The working notes for this day were thin, so some steps are marked as not recorded.
- Single Solve and Time Trial at the drop. The watcher saw Day 27 at 07:00:06 local time and ran the mobile lane driver:
python3 -I ~/.config/huntress/solvers/run_mode.py mobile-android-day-27-dependency-surface <mode> mobile_puzzle <workdir>
Its log line, 16 seconds later:
[OK] mobile-android single=CORRECT(fbc104ca150259ca0364471a842d0267) TT=CORRECT mastery=no-output
So the existing driver covered both modes. The Mastery run gave no output.
- Mastery. At 07:01:15 the watcher launched a headless day agent. The Mastery attempt (
68022dd3-0806-4ba1-8e1b-31733394c702) was started at 13:05:31 UTC (07:05 local) and gradedCORRECTat 13:07:20 UTC. The files inmastery/were committed at 07:07 local time ("Day 27: mobile android Dependency Surface mastery 3/3"). That agent's log file was later overwritten by a second agent run at 07:30, so how it handled the eleven sets, including the split bundle, is not recorded. - Watcher re-run. The watcher was restarted and fired again at 07:28 local time. For mobile it logged
single=already_solved(None) TT=CORRECT mastery=CORRECT.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | fbc104ca150259ca0364471a842d0267 |
| Time Trial | CORRECT | 854599061c9ecb45900b5782052b1a8e |
| Mastery | CORRECT | a6e7916177bfaa9ee059089352d7c3bd |
- Mastery:
mastery/hasanswers.json(eleven codes),start-response.json,submit-response.jsonandfinal-status-response.json. - Single Solve and Time Trial files were not saved. Their flags come from the checkpoint file
~/.config/huntress/progress.json. The Single Solve flag also appears in the watcher log.
Reproduce
python3 -I ~/.config/huntress/solvers/run_mode.py mobile-android-day-27-dependency-surface single_solve mobile_puzzle /tmp/d27
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. It does not open .apks bundles (see Day 26).
Day 27: FROM Whence It Came
Lane: Script analysis. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
script-analysis-day-27-docker-build-attribution - Prompt: "A Dockerfile and several earlier specimens share strings, but sharing strings doesn't mean sharing parents. Attribute each specimen using build-stage, semantic, and static-handoff evidence, and expose the resemblance that's only skin-deep."
What we were given
- Single Solve: one
evidence.zip(SHA-25658ac2b361a86d5404d074c52cb37d82c349b254080a4e734726f0d86480a529e). Password:infected. - The role-named layout used since
Day 24. The questions name 174 files. - New today: 4 Dockerfile polyglots (
polyglot-dockerfile-benign-utility.dockerfile,-downloader,-launcher,-staged-chain). - Time Trial:
evidence.zip(SHA-2569f9e7a8b491a4747607697496a3293e18d05ed6995d6401902c8d27bd26a06be). Unlike Days 23–26, it uses the same role-named layout as the Single Solve. - Mastery:
script-analysis-day-27-docker-build-attribution-mastery.zip(SHA-25675819f93325b3c12b7e1aba45d43c50551964423fa595ced21b0dbba505dcd4f). - Only the start responses and the Single Solve and Time Trial answers were kept. The archives, Mastery answers and submit/status files were not.
What was asked
- Single Solve: 1,659 questions. By family: PowerShell 15, JScript 72, Batch 72, VBScript 72, Python 126, Bash 168, Node.js 56, host 154, polyglot 924.
- Time Trial: 1,659 questions, same IDs and types.
- Mastery: 18,249 questions in 11 sets of 1,659.
- Field types are the same as on Day 24. Each host or polyglot file gets 11 questions: role, ATT&CK, adapter, campaign, URL or path, host profile, obfuscation, stage profile, next language, stage count and steps.
How it was solved, start to finish
- Started each mode and downloaded its archive (Single Solve at 13:00:07 UTC; Time Trial and Mastery at 13:07 UTC).
- Used
solve_day26.py, theDay 26solver, for every mode. It covers all the question families in this layout:
- PowerShell
*-sample.ps1files: Base64 JSON descriptor, scenario and ATT&CK, IOC by shape. - Behavioral scripts (JScript, Batch, VBScript, Python, Bash, Node.js): per-language decoders, then role and ATT&CK from the steps.
- Host and polyglot files:
HUNTRESS_ANALYSIS_V1markers inB64,HEX,FRAG,HB64,SPLITorLYRform. Answers are read straight from the decoded config.
- The Dockerfile files needed no new code. They carry the same marker. Real answers from
single-solve/answers.json:
{"polyglot-dockerfile-downloader-role": "downloader", "polyglot-dockerfile-downloader-attack": "T1105",
"polyglot-dockerfile-downloader-adapter": "http_client",
"polyglot-dockerfile-downloader-campaign": "DOCKERFILE-b78f0a1d",
"polyglot-dockerfile-downloader-obfuscation": "plain_hex",
"polyglot-dockerfile-downloader-stage-profile": "single_descriptor",
"polyglot-dockerfile-downloader-next-language": "jscript"}
- Mastery has 11 sets in the same layout. Its answers were not kept, and the record does not say how the sets were split up.
- All three modes were
CORRECT. The session's day summary listsscript-analysisas done in all three modes.
Results
| Mode | Questions | Result | Flag |
|---|---|---|---|
| Single Solve | 1,659 | CORRECT | 395916a7e7339c9ebe6429933f80a5d5 |
| Time Trial | 1,659 | CORRECT | 07024d4a478fd030e6a0fcee5e12c961 |
| Mastery | 18,249 (11 sets × 1,659) | CORRECT | 7bea9bc396f521e486458605611a582b |
The flags are not in this folder. They come from the local progress record ~/.config/huntress/progress.json (days.27.script-analysis), which stores the Game Master result and flag per mode. No screenshots were taken.
Reproduce
The archives were not kept, so the saved answers cannot be rebuilt offline. On a fresh attempt, extract the archive and run:
python3 -I tools/solve_day26.py /tmp/d27/ex start-response.json /tmp/d27/answers.json
Then submit with a Game Master token. For Mastery, run it once per extracted set, using that set's questions with the setN. prefix removed, then put the prefixes back. solve_day26.py tries node jsdec.js first (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/ copy runs the fixture in a Node vm sandbox.
Day 27: Monkey Business
Lane: Warmups. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
warmups-day-27 - Prompt: "Primates in the interpreter. Ook! Ook! Ook?"
- New encoding: Ook!
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. Ook! esoteric language. Pairs of
Ook./Ook!/Ook?tokens map to Brainfuck commands. Translate and interpret. - Mastery blobs use multiple encodings from Days 1-27. 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:hearty-castle-fern-71. Flag:58107e83a924e5a993d5cbe3ced71151. - Time Trial:
CORRECT. slug:gentle-rocket-glade-49. Flag:7ad3398d7d3355c48b5f95dd8ccfe096. - Mastery:
CORRECT. 133 slugs. Flag:1dc47f75c3be9fb2050ad95a1b5c23ba.
Day 27 — Double Spent (Race Condition)
Lane: Web Exploitation · Challenge ID: web-exploitation-day-21-double-spent
> One credit, two purchases. The ledger can't count what it can't see coming — race it and spend the same credit twice.
What we were given
A live Rails web target with a credit system — the account starts with exactly one credit.
How it was solved
Race condition / TOCTOU — the credit redemption endpoint doesn't use atomic transactions, so two simultaneous requests can both succeed before the balance is decremented.
- Queried
/api/clues— got the feature route (e.g./execute-bdb3f6), the audit route (e.g./audit-ad790f), and roleanalyst. - Checked the audit endpoint:
credits: 1. The account has a single spendable credit. - Sent two simultaneous empty JSON POSTs to the feature route. Both arrived before the server could decrement the balance from the first request.
- Both requests returned
200witheffect: credit_redeemed. The reported balances were0and-1— the second request succeeded despite the credit already being spent. - The audit endpoint now returned
effect: single_credit_spent_twiceand the proof.
Gotcha: depleted targets
The first assigned target was already depleted (credits at 0) before we touched it — a previous test had spent the credit. The Game Master supports op: reset to tear down and prepare a fresh target on the same attempt. After resetting, the race worked on the first try.
Root cause: The credit check and decrement aren't atomic. Between "check balance >= 1" and "balance -= 1", a second request can pass the same check. This is a classic TOCTOU (Time-of-Check-Time-of-Use) race condition.
Mastery — mixed targets (4/4)
| Target | Vulnerability |
|---|---|
| 1 | Backup exposure — robots.txt → directory listing → .json.bak |
| 2 | IDOR — /api/history leaks reference-only case → direct access |
| 3 | SQL injection — search injectable with ') OR 1=1-- |
| 4 | Race condition — two simultaneous POSTs spend one credit twice |
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | badec8d731b9a1d58cbd1aa2014e8225 |
| Time Trial | CORRECT | 53e35b6d5644ddba75d717902c51533c |
| Mastery (4/4) | CORRECT | 35da7f17ae29b5ab05117fe2e767452d |
Day 27 — Socket to Me (WebSocket Event Stream)
Lane: Web Exploitation · Challenge ID: web-exploitation-day-22-socket-to-me
> The chat upgraded to websockets and left its manners at the HTTP door. Ride the upgrade into an event stream that was never meant for you.
What we were given
A live web target with a WebSocket-based event streaming endpoint.
How it was solved
WebSocket authorization bypass — the event stream endpoint grants access to restricted data through the WebSocket upgrade without proper authentication.
- Queried
/api/clues— got the feature route (e.g./inspect-f8a2c6) and a stream reference ID (e.g.14862). - The correct query parameter matters:
reference=14862andstream_reference=14862both returned403. The correct parameter wasstream=14862. - Initiated a WebSocket handshake:
GET /inspect-f8a2c6?stream=14862withUpgrade: websocketheaders. The server responded with101 Switching Protocols. - The WebSocket event frame delivered the proof — the server streamed restricted event data to any client that completed the upgrade with the right parameter name.
Root cause: The WebSocket endpoint accepts connections without verifying authorization. Once the protocol upgrade succeeds, the event stream delivers sensitive data. The only "protection" is obscurity — the parameter name isn't documented, but /api/clues provides the route and reference ID.
Mastery — mixed targets (5/5)
| Target | Vulnerability |
|---|---|
| 1 | Backup exposure — robots.txt → directory listing → .json.bak |
| 2 | IDOR — session cookie + activity feed → restricted case access |
| 3 | SQL injection — search injectable with ') OR 1=1-- |
| 4 | LFI — /notes.php?doc=../../../../run/huntress/objective.txt |
| 5 | WebSocket event stream — upgrade with ?stream={ref} |
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | b11248f07613464c4b746288e3775ffb |
| Time Trial | CORRECT | 6df38f6118062420f3e3fc4538adf396 |
| Mastery (5/5) | CORRECT | bfd91098a26fad49c2d2dc0ece3ebfe3 |
Day 27 — Forwarded Misgivings (Proxy Header Trust)
Lane: Web Exploitation · Challenge ID: web-exploitation-day-23-forwarded-misgivings
> The app trusts the proxy to say who's calling. Tell it you're calling from inside the house.
What we were given
A live Micronaut web target ("Forward Desk") deployed behind a reverse proxy.
How it was solved
X-Forwarded-For header spoofing — the application trusts the proxy-supplied client IP without validation.
- Queried
/api/clues— got the feature route (e.g./inspect-2d6a00) anddeployment: trusted_reverse_proxy. - Requested the feature route normally. Got
403witherror: loopback_onlyand the evaluated client IP (e.g.10.1.0.0) — the endpoint only serves requests from localhost. - Added
X-Forwarded-For: 127.0.0.1to the request headers. The app trusts this header as the real client IP. - The endpoint accepted the spoofed loopback address and returned
effect: proxy_trust_admin_bypasswith the proof.
Root cause: The application reads client IP from X-Forwarded-For without verifying that the header was set by a trusted proxy. Any client can spoof this header. The endpoint restricts access to loopback addresses but checks the spoofable header instead of the actual connection IP.
Mastery — mixed targets (5/5)
| Target | App | Vulnerability |
|---|---|---|
| 1 | Status Sprout | Backup exposure — robots.txt → directory → .json.bak |
| 2 | Incident Picnic | IDOR — activity feed leaks case ID → direct access |
| 3 | Signal Shelf | SQL injection — /lookup?q=') OR 1=1-- |
| 4 | Stay in Your Directory | LFI — /handbook.php?doc=../../../../../run/huntress/objective.txt |
| 5 | Forward Desk | X-Forwarded-For spoofing to bypass loopback-only check |
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 625ae93221791e469403e9a04c47fb9f |
| Time Trial | CORRECT | d9aeef39919a8455a964f9b029be0a3b |
| Mastery (5/5) | CORRECT | df1a97d44a0c76de8043fd8a6adb7fb8 |