2026-10-28
Day 28: Family Resemblance (parallel session record)
Lane: Binary reverse engineering. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT (solved in the sibling folder).
This folder is the record of a second session that worked on the same Day 28 attempt at the same time. The full solve, with the method that worked, is in day-28-binary-reverse-engineering-family-clustering.
The challenge
- ID:
binary-reverse-engineering-day-28-family-clustering - Prompt: "These binaries might be related — or they might just look alike. Cluster them by behavior, watch out for false friends, and sort the family from the strangers."
What we were given
- Single Solve:
bundle.zip, the attempt'sevidence.zipsaved unchanged (SHA-256891cf4ebc9c0e8867641ad376c29f79a59a19781876d6ebad17b14c124e6ee5d). AES encrypted, passwordinfected. - It holds every binary family from
d01tod27, plus the newd28trio:family-a.elf,family-b.elfandfalse-friend.elf. - Mastery:
delivery-1.zip(SHA-2566c8ecdc289f2e23f0256abeb75b598fa00aff6300253fc01d18ca4f2b88af677), the first of the 12 Mastery deliveries.
What was asked
- 392 questions in Single Solve and Time Trial. Mastery had 12 sets, so 4,704.
- The same question list as the sibling folder: all earlier per-day fields, about 35 new field types (structure hashes, symbol counts, runtime checks, branch-opcode counts, packing keys, overlay sizes and more), and the new d28 family / false-friend questions.
How it was handled, start to finish
- Resumed the untimed Single Solve attempt
a1c197ec-a032-4707-918c-4a5a87f67ed8(392 answer fields) and downloaded the bundle. - Ran the existing offline
solve_tm.pyover the bundle. It produced 349 candidate answers and left 43 fields it could not handle, mostly the new structure, runtime and Day 28 clustering questions. - Submitted the 349 answers. The Game Master replied
incorrect(submit-response.json).
- Comparing them with the final accepted answers (sibling folder) shows exactly one wrong value:
d20_analysis_overlay_size=1201352. The accepted value is463. - Cause: the d20 size question does not name the
RS20magic, so the solver searched forPK20, found nothing (-1), and returned file length + 1.
- Meanwhile the other session solved the same attempt. It added handlers for the missing field types and fixed the overlay size. See the sibling folder for every step.
- Final sync: a status check confirmed all three modes
CORRECT, with every field accepted. The details are infinal-status-summary.jsonandmastery/start-response.json(which holds the Mastery status:CORRECT, 4,704 accepted).
This session did not capture the other session's full derivation. It is recorded in the sibling folder.
Results
| Mode | Result | Accepted | Flag |
|---|---|---|---|
| Single Solve | CORRECT | 392/392 | 522f5865f8dc3c964d859ad820086300 |
| Time Trial | CORRECT | 392/392 | 465797e74d04141ec417101d2718b367 |
| Mastery | CORRECT | 4704/4704 | f42682235ede2e7daeb82ce757e80583 |
CORRECT and the accepted counts come from the live Game Master status. final-status-summary.json has the attempt IDs, times, accepted IDs and flags.
Reproduce
Use the steps in the sibling folder's README. They run offline against this folder's single_solve/bundle.zip and reproduce all 392 accepted answers. Nothing there runs the samples.
Day 28: Family Resemblance
Lane: Binary reverse engineering. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
binary-reverse-engineering-day-28-family-clustering - Prompt: "These binaries might be related — or they might just look alike. Cluster them by behavior, watch out for false friends, and sort the family from the strangers."
What we were given
- A mega-bundle: every earlier binary-lane family (
d01tod27) plus the newd28, in oneevidence.zip(AES, passwordinfected). - The Single Solve bundle is saved in the sibling folder
day-28-binary-family-resemblanceassingle_solve/bundle.zip(SHA-256891cf4ebc9c0e8867641ad376c29f79a59a19781876d6ebad17b14c124e6ee5d). - New today: three small ELF files in the
d28group: …family-a.elf(22,922 bytes) and…family-b.elf(22,922 bytes): the real family;…false-friend.elf(22,923 bytes): looks the same, but is not.
What was asked
- 392 questions in Single Solve and Time Trial. Mastery had 12 sets, so 4,704.
- Questions are keyed
dNN_<class>and say "use alldNN--members in ZIP central-directory order". - About 35 question types per set were new. Examples:
- Structure: member count and an "ordered-set" SHA-256 (hash each member, join the hex digests with
:, hash again). - Symbols: the d02 vtable symbol; symbol counts for d05 (all), d11 (D symbols) and d13 (Crystal symbols); d18 handler symbols (
event_success|decoy|failure), as a count and a SHA-256. - Runtimes: yes/no for the Nim, Free Pascal and GNAT runtimes (d09, d12, d17); .NET CLI runtime
major.minor(d03, d22, d23); adecoystring in d03/d23. - Code: in d17's
.text, count every0x70..0x7fbyte and every0x0f 0x80..0x8fpair (conditional jumps). - Containers: d06/d26 class count, class name and a SHA-256 of the sorted method names; d10 section count; d19 packing keys; d20 overlay size.
- Config:
host_modelandipv4, more XOR keys, and the d24/d25vulnerable_config_*fields. - d28 (new): format and decimal machine of all three files; the family config (decode
family-aandfamily-b, they must match, do not use the false friend); the false friend's own campaign.
How it was solved, start to finish
- The watcher ran the driver first. The Game Master answered
incorrect, and the watcher flagged the lane. A helper agent took the binary lane. - Ran the existing solver.
run_tm.py/solve_tm.pyanswered 357 of 392 fields. The other 35 were new question types it did not know. - Wrote one helper for the 35 new field types:
. It works straight from the extracted bytes:tools/d28_binary_family_missing.py
dNN_structural_artifact_count,dNN_structural_ordered_set_sha256;d02_vtable_symbol(/ZTV.*DiscoveryEngine/in the ELF.symtabor the PE COFF symbols);host_model,ipv4andcampaignfrom the decodedHCFGrecords;- CLI runtime
major.minorfrom the .NET COR20 (CLI) header; - the
has_*_runtimeanddecoychecks (byte and symbol-name searches); - symbol counts by regex, working for ELF and PE;
d10_section_count(ELFe_shnumor PENumberOfSections);d17_conditional_branch_opcode_countover the.textbytes;d18_handler_symbols_sha256(sorted ELF symbol names) andd26_method_names_sha256(class-file parser);d19_packing_key_1/2_hexfrom thePK19header bytes +5 and +6;- the d28 formats, machines and false-friend campaign.
- Fixed the overlay size.
solve_tm.pygaved20_analysis_overlay_size=1201352. The d20 size question does not name theRS20magic, so the solver searched forPK20, found nothing (-1) and returned length + 1. The helper recomputes it as file length − overlay offset: 1,201,351 − 1,200,888 = 463. - Found wrong answers with the partial-submit oracle. Submitting one group of fields at a time (grouped by field type) shows which group still holds a wrong answer.
- The d28 family check. Re-checked on the d28 files saved in the Day 29 folder (byte-identical to this bundle's d28 members):
family-a.elf HCFG offset=22536 key=0xd1 len=374 crc32=0xa0bf57f1 campaign BR28-000, domain node-000.day28.example.invalid
family-b.elf HCFG offset=22536 key=0xd1 len=374 crc32=0xa0bf57f1 campaign BR28-000 (same record)
false-friend.elf HCFG offset=22536 key=0xd9 len=375 crc32=0xdbaacf1c campaign FF28-000, domain decoy-000.day28.example.invalid
The record is at the end of each file, so "scan backward from the end" finds it first. Family config: BR28-000. False friend: FF28-000. All three are ELF, machine 62.
- Submitted all 392 answers (
answers.json). More examples:d01_structural_artifact_count=1,d03_analysis_cli_runtime=2.5,d05_analysis_symbol_count=1222,d17_analysis_conditional_branch_opcode_count=7145,d18_analysis_handler_symbol_count=3,d19_analysis_packing_key_1_hex=0x21. Result:CORRECT. - Time Trial: same pipeline on a fresh variant (392 answers). Result:
CORRECT. - Mastery: 12 sets, one
delivery-N.zipeach, 4,704 answers. Result:CORRECT.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT (392/392) | 522f5865f8dc3c964d859ad820086300 |
| Time Trial | CORRECT (392/392) | 465797e74d04141ec417101d2718b367 |
| Mastery | CORRECT (4,704/4,704) | f42682235ede2e7daeb82ce757e80583 |
Each mode folder has the raw start-response.json, answers.json, submit-response.json and final-status-response.json. A second session worked on the same attempt in parallel; its record is in day-28-binary-family-resemblance.
Reproduce
Offline, from this folder (no Game Master needed), using the saved Single Solve bundle:
mkdir -p /tmp/d28/deliveries
cp ../day-28-binary-family-resemblance/single_solve/bundle.zip /tmp/d28/deliveries/delivery-1.zip
python3 -I ~/.config/huntress/solvers/solve_tm.py single-solve/start-response.json /tmp/d28/deliveries /tmp/d28/base.json
python3 -I ../../tools/d28_binary_family_missing.py /tmp/d28/deliveries/delivery-1.zip /tmp/d28/ev /tmp/d28/base.json /tmp/d28/extra.json
python3 -I -c "import json; a={k:v for k,v in json.load(open('/tmp/d28/base.json')).items() if v}; a.update(json.load(open('/tmp/d28/extra.json'))); json.dump(a, open('/tmp/d28/answers.json','w'))"
Checked on 2026-11-01: solve_tm.py answers 357/392, the helper computes 37 fields (the 35 missing ones plus two overlay sizes), and the merged 392 answers match answers.json exactly. This only parses the samples and never runs them.
Day 28: Where It All Began
Lane: Metadata forensics. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT (3/3).
The challenge
- ID:
metadata-forensics-day-28-where-it-all-began - Prompt: "Disk images hold every previous artifact family in context. Recover partition layouts, locate evidence by offset, and prove which image was rebuilt from an incomplete source."
What we were given
- Single Solve:
bundle.zip(SHA-2561b305bfd7e3fb5cc679b65fd8c8ac2e6344135064f6b4b70c7fa6c3c82753ce6). It containsdisk-001.img(131,072 bytes). - Time Trial:
bundle.zip(evidence.zip, 682,756 bytes). The notes, the roster and one file of each type so far, now includingdisk-001.img. - Mastery:
metadata-forensics-day-28-where-it-all-began-mastery.zip(SHA-2561f0aa7a3375d2b002ea310230ffbc9b4b4389bcbe3b8fa4a57e9b46fb408b993). Twelve inner zips,evidence-01.ziptoevidence-12.zip. - New today: raw disk images (
.img).
What was asked
- Single Solve: 1 question:
disk.partition_start_lba_sequencefordisk-001.img, as a compact JSON array. - Time Trial: 33 questions. Mastery: 396 (12 sets × 33).
- Question types: a composite of every metadata day so far: d04 JPEG SOF, d05 PNG IHDR, d06 PDF, d07 ZIP EOCD, d09 PE, d12 .NET MVID, d13 MSI, d14 LNK, d15 OOXML rels, d16 EML, d17/18 media, d19 ELF, d20 Mach-O, d21 APK, d22 JAR, d23 SQLite, d24 EVTX, d25 registry, d26 prefetch, d27 pcap, d28 disk. Plus the file-identity fields and a SHA-256-ordering synthesis field.
How it was solved, start to finish
- Single Solve. Resumed the untimed attempt
b5a21211-00b4-477b-a54a-b81ced475019and downloaded the bundle unchanged. - Read the partition table of
disk-001.imgwithmmls,sgdiskandfdisk. The only partition begins at LBA 34. Submitted[34].CORRECT.
A byte-level check of the saved image gives the same result: the MBR has a protective entry of type 0xEE, the GPT header (EFI PART) is at byte 512, the entry table starts at LBA 2 (128 entries × 128 bytes), and one entry is in use with first LBA 34.
- Extended
run_meta.pywith the five formats from Days 24–28 that it still missed:
- EVTX record count: occurrences of the record magic
2a2a0000. - Registry hive root name: the
nkkey name at theregfroot cell (0x1000 + root cell offset, name length at+0x48). - Prefetch executable name:
prefetch_solve.parse_prefetch, with MAM/LZXPRESS decompression. - PCAP packet count: walk the record headers. Added the nanosecond magics
4d3cb2a1/a1b23c4dnext to the microsecond ones. - Disk partition start LBAs: for GPT, list each used entry's first LBA; otherwise fall back to the 4 MBR entries.
if fb[512:520] == b'EFI PART': # GPT header at LBA 1
part_lba = struct.unpack_from('<Q', fb, 512 + 0x48)[0]
num = struct.unpack_from('<I', fb, 512 + 0x50)[0]
esz = struct.unpack_from('<I', fb, 512 + 0x54)[0]
for i in range(num):
o = part_lba * 512 + i * esz
if fb[o:o+16] == b'\x00' * 16: continue # unused entry
starts.append(struct.unpack_from('<Q', fb, o + 0x20)[0])
- Time Trial.
run_meta.pyanswered all 33. Examples fromanswers.json: partitions[52,193], packets36, EVTX records19, Prefetch nameLAUNCHER.EXE, Mach-O CPU set["0x01000012","0x0200000c"].CORRECT. - Mastery.
run_meta.pyanswered all 396. Partition lists fromanswers.json: set 1[47,75,141,153,158,223], set 2[160,308,324,459], set 3[34,64,295,361,375,475].CORRECT.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | df4cc874f3a8eeec3a6214b5b685cf3c |
| Time Trial | CORRECT | 17772b286d4e1df0ace82f2c6ab58a25 |
| Mastery | CORRECT | 7ab94e24cf224c9405b4970c9831676f |
final-status-summary.jsonhas the live status of all three modes. Mastery was solved on attempt94e073ea-231b-4876-8e12-f258aab68dfd.mastery/start-response.jsonis from an earlier attempt (f64bd3cb-…), so it does not line up withmastery/answers.json. For example, its set 1 synthesis question namesevidence-note-2701a8.txt, while the saved answer usesevidence-note-cdb28b.txt.- Mode folders here use
single_solve/andtime_trial/(underscores).
Reproduce
python3 -I ~/.config/huntress/solvers/run_meta.py metadata-forensics-day-28-where-it-all-began single_solve /tmp/d28
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 disk image as bytes. Nothing is mounted.
Day 28: Protocol Reconstruction
Lane: Mobile (Android). Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
mobile-android-day-28-protocol-reconstruction - Prompt: "Reconstruct the app-to-backend protocol and preserve nonce and ordering semantics."
What we were given
- Single Solve:
protocol_reconstruction.apk, caseMOB-28-3EBDABD670(12,704 bytes, SHA-2561146daecc34e9b3cd727c7a83f135091dc10b01c4081e430d7b4f6bb4a4efbd5). Its puzzle uses a new v1 codec,packet:
{"schema": "huntress.mobile.puzzle.v1", "day": 28, "codec": "packet", "data": "484114414e532d3630314433393036424235383835414311"}
- Time Trial: saved as
time_trial/protocol_reconstruction.apk, caseMOB-28-839BF49C69. Its puzzle is v2analysis(no answer data). - Mastery: twelve deliveries in
mastery/deliveries/, all v2analysis. Cases come from Days 1, 4, 7, 8, 11, 14, 17, 18, 22, 24, 26 and 28. Set 11 was delivered as a.apkssplit bundle (base.apk+feature.apk); it is saved asdelivery-11.apk.mastery/bundle.zipis the same file asdelivery-1.apk.
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.answertoset12.answerfor Mastery.
How it was solved, start to finish
No app was installed or run.
- The driver failed at the drop. The watcher ran
run_mode.pyon Single Solve at 07:00 local time. It loggedsingle=incorrect -> NEEDS MANUAL SOLVER (new wrinkle). The driver had no branch forpacket, so the puzzle fell into its Base64 default. - Single Solve: method not recorded. The attempt was solved at 13:16:33 UTC, but no
answers.jsonor notes were saved for it. A cheap re-decode of the saved puzzle shows its shape. Hex-decodingdatagives:
48 41 | 14 | 41 4e 53 2d ... 43 | 11
"HA" | 20 | "ANS-601D3906BB5885AC" | 0x11
That is the two bytes HA, the byte 0x14 (20, the length of the code that follows), a 20-character code, and one trailing byte 0x11. The submitted answer was not saved, so this README does not confirm which value was sent.
- Time Trial: hand port. The headless day agent reversed the DEX by hand. In the
analysisAPKs,Release.code(Context)returns the answerANS-<16 uppercase hex>. It only uses constants baked into the DEX:
token()runs a fixed start value through 64-bit mixing functions:FrameKit.mixPacket02→Util.sessionSession08→FrameKit.mixNonce57. The names vary per variant.code()appliesMix.f1→Util/Core.finXxx→xorwith a constant, then prints 16 hex digits, most significant first.
The port is tools/day28_mobile_solve_proto.py. Its two top functions:
def token():
t=mixPacket02(u(-0x65b4e5cdc59dfaef))
t=sessionSession08(t)
t=mixNonce57(t)
return t
def code():
t=token()
x=f1(t)
x=finSession63(x)
x^=u(-0x65512d66bb86672f)
HEX="0123456789ABCDEF"
s="ANS-"
v4=60
while v4>=0:
s+=HEX[(x>>v4)&0xf]
v4-=4
return s
It gave ANS-195095C38146A010. The Game Master replied CORRECT.
- Mastery: generic smali VM. All twelve APKs have the same shape, but each one names its mix functions differently and uses different constants. So instead of one hand port per APK,
tools/day28_mobile_smali_vm.pyrunsRelease.code()straight from baksmali output:
- 64-bit ALU ops, rotates built from
shl/ushr/or, arrays, - the
frame()helper,StringBuilder.appendandString.charAt.
It solved 12 of 12. On the Time Trial APK it gives the same ANS-195095C38146A010 as the hand port.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 55a395694d88d5885877d4e5b1a98de9 |
| Time Trial | CORRECT | 2ae2260b40cbb4c82a86c67e3d5f6d52 |
| Mastery | CORRECT | 6e426cf8ffb7688258d61f1fe4b2b026 |
final-status-summary.json(top level) lists all three modes with their flags and solve times.single_solve/has the APK and the start, submit and final-status responses. Noanswers.json.time_trial/andmastery/have the APKs,answers.jsonand the Game Master responses.
Reproduce
From the repo root. Time Trial, offline (a pure Python port of that one variant):
python3 -I tools/day28_mobile_solve_proto.py
Mastery, one APK at a time (example: delivery 1):
unzip -o repos/day-28-mobile-protocol-reconstruction/mastery/deliveries/delivery-1.apk classes.dex -d /tmp/d28
java -jar ~/.config/huntress/solvers/baksmali.jar d /tmp/d28/classes.dex -o /tmp/d28/smali
python3 -I tools/day28_mobile_smali_vm.py /tmp/d28/smali
For delivery-11.apk, take classes.dex from the inner base.apk first. These steps only disassemble the DEX and evaluate it in Python. Nothing is installed or run on a device.
Day 28: Out of Order
Lane: Script analysis. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
script-analysis-day-28-terraform-cloud-timeline - Prompt: "Terraform HCL describes cloud resources, expressions, and dependencies that change over time. Assemble the timeline from resources, prior scripts, and relationship evidence — without planning or applying anything — and find the change that happened out of order."
What we were given
- Single Solve: one
evidence.zip, saved assingle_solve/bundle.zip(SHA-2562c039db463069de65cf7e6f30afdc1be7381c34e6586333cd7b95d84f2af8f4f, 179 files). Password:infected. - It holds every earlier family in the role-named layout: PowerShell, JScript, Batch, VBScript, Python, Bash, Node.js, host and polyglot.
- New today: 4 Terraform polyglots (
polyglot-terraform_hcl-benign-utility.tf,-downloader,-launcher,-staged-chain). - Time Trial:
evidence.zip(SHA-256578ecf7cca4a19b36122e6d0009a1203f92b21443671d2faf940b425df3832d2) in the hash-named layout fromDay 23. Not kept. - Mastery: one master zip with 12 inner
evidence-NN.zipfiles, saved asmastery/bundle.zip(SHA-2565e3c83d0f8402bb80a922c7e80973edb3652ed232e8910b2f5955c6256e3bfdb).
What was asked
- Single Solve: 1,703 questions. By family: PowerShell 15, JScript 72, Batch 72, VBScript 72, Python 126, Bash 168, Node.js 56, host 154, polyglot 968.
- Time Trial: 1,781 questions in the Day 23 format.
- Mastery: 21,372 questions in 12 sets of 1,781.
How it was solved, start to finish
- Picked a solver per format, as on Days 25–27:
- role-named layout (Single Solve):
solve_day26.py; - hash-named layout (Time Trial, each Mastery set):
solve_day23.py.
- Found the one gap: JScript. The JScript config is rebuilt at run time by the fixture's own code. Both solvers got it by calling
node jsdec.js, andnodewas not available in that session. So the JScript fields could not be filled. - Wrote a pure-Python JScript decoder,
jsdec_py_emu.py, and made it the fallback injs_decode()of both solvers. It never runs the JScript: - It collects candidate byte streams from the source text: decimal or hex
[...]arrays,%XXstrings,-/:/,separated number strings, and Base64 string literals (like the ones fed todecodeBase64(...)). Decoded Base64 also counts as a stream. - It tries each stream forwards and reversed, with single-byte XOR, add and subtract (every key 0–255), chained-feedback XOR, and short repeating keys found in the file.
- It keeps the first result that parses as the descriptor JSON (
{steps, adapter, values, stageCount}).
for stream in streams: # arrays, packed strings, base64 payloads
for order in (stream, stream[::-1]):
for out in transforms(order, shorts): # XOR/add/sub K, chained XOR, short keys
d = valid(out) # JSON with steps / adapter / values?
if d:
return d
This recovered every JScript field with no JS engine.
- Single Solve:
solve_day26.pyanswered all 1,703 questions, and the submit wasCORRECT(13:20:40 UTC). Real answers for a new Terraform file:
{"polyglot-terraform_hcl-downloader-role": "downloader", "polyglot-terraform_hcl-downloader-attack": "T1105",
"polyglot-terraform_hcl-downloader-steps": "acquire_remote>dispatch_process",
"polyglot-terraform_hcl-downloader-obfuscation": "base64",
"polyglot-terraform_hcl-downloader-stage-profile": "two_stage_download_execute",
"polyglot-terraform_hcl-downloader-next-language": "jscript"}
- Time Trial:
solve_day23.pyanswered all 1,781 questions, and the submit wasCORRECT(13:22:56 UTC). A JScript example fromtime-trial/answers.json:
{"jscript-9fff58-role": "launcher", "jscript-9fff58-attack": "T1059.007",
"jscript-9fff58-style": "declaration|apply|dot", "jscript-9fff58-steps": "locate_local>dispatch_process"}
- Mastery: extracted the master zip, solved each of the 12 sets on its own with
solve_day23.py, and merged the answers under theirsetN.prefix. The submit wasCORRECT(13:24:19 UTC). - The lane ran as a parallel fork, and the new solver code was copied into
tools/.
Results
| Mode | Questions | Solver | Result | Flag |
|---|---|---|---|---|
| Single Solve | 1,703 | solve_day26.py | CORRECT | 9e0ab44e69a80afa1f372d9448f3fea3 |
| Time Trial | 1,781 | solve_day23.py | CORRECT | 2058fd4983a835e1c8e4f8803b228b62 |
| Mastery | 21,372 (12 sets × 1,781) | solve_day23.py per set | CORRECT | 50311d79cdcf879627ff3a2654566503 |
final-status-summary.json holds all three final statuses. Each mode folder has answers.json and the Game Master JSON. No screenshots were taken.
Reproduce
Offline, from the repo root, with node kept off PATH so the pure-Python JScript decoder is used:
mkdir -p /tmp/d28/ex
7z x -pinfected -o/tmp/d28/ex repos/day-28-script-analysis-out-of-order/single_solve/bundle.zip
env PATH=/usr/bin:/bin python3 -I tools/solve_day26.py /tmp/d28/ex \
repos/day-28-script-analysis-out-of-order/single-solve/start-response.json /tmp/d28/answers.json
This rebuilds all 1,703 saved Single Solve answers (re-checked on 2026-11-01).
The same check on Mastery set 1 also matches. Extract mastery/bundle.zip, then evidence-01.zip with -pinfected. Run tools/solve_day23.py on it with that set's questions (the set1. prefix removed). It rebuilds all 1,781 saved set 1 answers.
Day 28: Back in Sixteen
Lane: Warmups. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
warmups-day-28 - Prompt: "Back to basics. Sixteen values, two per byte."
- New encoding: plain hex (base16)
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. Hex pairs to ASCII bytes, same as Day 3 hex.
- Mastery blobs use multiple encodings from Days 1-28. 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. - Time Trial:
CORRECT. - Mastery:
CORRECT. 138 slugs. Flag:827c008d94cab8e1a8371c48a0a421cb.
Day 28 — If a Breach Falls in a Log (Logging Gap Detection)
Lane: Web Exploitation · Challenge ID: web-exploitation-day-25-if-a-breach-falls-in-a-log
> You broke in, and nobody wrote it down. Find the decisive moment the logs missed — if a breach falls in the forest, did it make a sound?
What we were given
A live web target with an audit logging system. The application logs actions but has gaps.
How it was solved
Audit log gap analysis — the application logs most actions but fails to record a privileged operation, and proving you found the gap is the objective.
- Established a session by visiting
/and explored the application's API. - Identified the feature route and audit route from
/api/clues. - Performed a privileged action (e.g.
POST /execute-*to trigger aprotected_export) and then checked the audit log at the audit endpoint. - The audit log recorded only
page_view— the privileged export action was missing from the log. - Reported the logging gap: POSTed to the audit endpoint with the export ID,
missing_event=protected_export, andobserved_event=page_view. - The application confirmed the gap detection and returned the proof.
Root cause: The audit logging middleware doesn't cover all privileged operations. The export action bypasses the logging pipeline, creating a blind spot. An attacker who discovers this gap can perform sensitive operations undetected.
Mastery — mixed targets (5/5)
| Target | Vulnerability |
|---|---|
| 1 | (standard web exploitation mix — backup/IDOR/etc.) |
| 2 | IDOR — activity feed leaks executive case ID |
| 3 | SQL injection — search endpoint injectable |
| 4 | LFI — path traversal through notes viewer |
| 5 | Audit logging gap — protected export not logged |
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 9e58b4c19aa03b350a5e222eea3b4409 |
| Time Trial | CORRECT | ca237dc8dc04704a35d8f03d7a2cc989 |
| Mastery (5/5) | CORRECT | 7dab166991d50f9cd48e05cbe0be6bed |
Day 28 — Fail Open Friday
See the full writeup at .../day-28-web-fail-open-friday/
This folder contains mastery working data. The canonical writeup is in the parent folder.
Day 28 — If a Breach Falls in a Log
See the full writeup at .../day-28-web-breach-falls-in-a-log/
This folder contains mastery working data. The canonical writeup is in the parent folder.
Day 28 — Fail Open Friday (Policy Decoder Bypass)
Lane: Web Exploitation · Challenge ID: web-exploitation-day-24-fail-open-friday
> The remote policy decoder is part of an access decision. A valid public decision is documented in the application; investigate what happens when that decision cannot be decoded.
What we were given
A live web target with a remote policy-based access control system.
How it was solved
Fail-open logic — the access control system defaults to "allow" when the policy decoder encounters an error.
- Queried
/api/policy-format— it documented the policy format. Policies are prefixed with a format identifier (e.g.remote:6fe40b6a2a03:), followed by the encoded policy data. - The application uses a remote decoder to evaluate the policy. A valid policy returns a "deny" or "allow" decision.
- Submitted a malformed policy to the feature route:
GET /dispatch-*?policy=remote:6fe40b6a2a03:broken. Thebrokensuffix is not valid encoded data. - The remote decoder failed to parse the malformed input. Instead of denying the request on failure, the system failed open — it defaulted to "allow" and returned the proof.
Root cause: The access control system's error handling defaults to "allow" instead of "deny". When the policy decoder throws an exception (malformed input, timeout, unreachable decoder), the application grants access. This is a textbook fail-open vulnerability — security-critical decisions should always fail closed.
Mastery — mixed targets (5/5)
| Target | Vulnerability |
|---|---|
| 1 | (solved prior to this investigation) |
| 2 | IDOR — /api/timeline leaks reference-only case → direct access |
| 3 | SQL injection — /query endpoint injectable |
| 4 | LFI — runbook reader path traversal |
| 5 | Fail-open policy decoder bypass |
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | a45b518259ce1547035c55965b4ab799 |
| Time Trial | CORRECT | e8f420fd3522692813608a2c37e8131e |
| Mastery (5/5) | CORRECT | b616223270d9412ecf184e693258f544 |