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

What we were given

What was asked

How it was handled, start to finish

  1. Resumed the untimed Single Solve attempt a1c197ec-a032-4707-918c-4a5a87f67ed8 (392 answer fields) and downloaded the bundle.
  2. Ran the existing offline solve_tm.py over 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.
  3. Submitted the 349 answers. The Game Master replied incorrect (submit-response.json).
  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.
  2. Final sync: a status check confirmed all three modes CORRECT, with every field accepted. The details are in final-status-summary.json and mastery/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

ModeResultAcceptedFlag
Single SolveCORRECT392/392522f5865f8dc3c964d859ad820086300
Time TrialCORRECT392/392465797e74d04141ec417101d2718b367
MasteryCORRECT4704/4704f42682235ede2e7daeb82ce757e80583

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

What we were given

What was asked

How it was solved, start to finish

  1. The watcher ran the driver first. The Game Master answered incorrect, and the watcher flagged the lane. A helper agent took the binary lane.
  2. Ran the existing solver. run_tm.py / solve_tm.py answered 357 of 392 fields. The other 35 were new question types it did not know.
  3. Wrote one helper for the 35 new field types: tools/d28_binary_family_missing.py. It works straight from the extracted bytes:
  1. Fixed the overlay size. solve_tm.py gave d20_analysis_overlay_size = 1201352. The d20 size question does not name the RS20 magic, so the solver searched for PK20, found nothing (-1) and returned length + 1. The helper recomputes it as file length − overlay offset: 1,201,351 − 1,200,888 = 463.
  2. 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.
  3. 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.

  1. 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.
  2. Time Trial: same pipeline on a fresh variant (392 answers). Result: CORRECT.
  3. Mastery: 12 sets, one delivery-N.zip each, 4,704 answers. Result: CORRECT.

Results

ModeResultFlag
Single SolveCORRECT (392/392)522f5865f8dc3c964d859ad820086300
Time TrialCORRECT (392/392)465797e74d04141ec417101d2718b367
MasteryCORRECT (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

What we were given

What was asked

How it was solved, start to finish

  1. Single Solve. Resumed the untimed attempt b5a21211-00b4-477b-a54a-b81ced475019 and downloaded the bundle unchanged.
  2. Read the partition table of disk-001.img with mmls, sgdisk and fdisk. 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.

  1. Extended run_meta.py with the five formats from Days 24–28 that it still missed:
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])
  1. Time Trial. run_meta.py answered all 33. Examples from answers.json: partitions [52,193], packets 36, EVTX records 19, Prefetch name LAUNCHER.EXE, Mach-O CPU set ["0x01000012","0x0200000c"]. CORRECT.
  2. Mastery. run_meta.py answered all 396. Partition lists from answers.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

ModeResultFlag
Single SolveCORRECTdf4cc874f3a8eeec3a6214b5b685cf3c
Time TrialCORRECT17772b286d4e1df0ace82f2c6ab58a25
MasteryCORRECT7ab94e24cf224c9405b4970c9831676f

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

What we were given

{"schema": "huntress.mobile.puzzle.v1", "day": 28, "codec": "packet", "data": "484114414e532d3630314433393036424235383835414311"}

What was asked

How it was solved, start to finish

No app was installed or run.

  1. The driver failed at the drop. The watcher ran run_mode.py on Single Solve at 07:00 local time. It logged single=incorrect -> NEEDS MANUAL SOLVER (new wrinkle). The driver had no branch for packet, so the puzzle fell into its Base64 default.
  2. Single Solve: method not recorded. The attempt was solved at 13:16:33 UTC, but no answers.json or notes were saved for it. A cheap re-decode of the saved puzzle shows its shape. Hex-decoding data gives:
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.

  1. Time Trial: hand port. The headless day agent reversed the DEX by hand. In the analysis APKs, Release.code(Context) returns the answer ANS-<16 uppercase hex>. It only uses constants baked into the DEX:

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.

  1. 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.py runs Release.code() straight from baksmali output:

It solved 12 of 12. On the Time Trial APK it gives the same ANS-195095C38146A010 as the hand port.

Results

ModeResultFlag
Single SolveCORRECT55a395694d88d5885877d4e5b1a98de9
Time TrialCORRECT2ae2260b40cbb4c82a86c67e3d5f6d52
MasteryCORRECT6e426cf8ffb7688258d61f1fe4b2b026

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

What we were given

What was asked

How it was solved, start to finish

  1. Picked a solver per format, as on Days 25–27:
  1. 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, and node was not available in that session. So the JScript fields could not be filled.
  2. Wrote a pure-Python JScript decoder, jsdec_py_emu.py, and made it the fallback in js_decode() of both solvers. It never runs the JScript:
  3. It collects candidate byte streams from the source text: decimal or hex [...] arrays, %XX strings, - / : / , separated number strings, and Base64 string literals (like the ones fed to decodeBase64(...)). Decoded Base64 also counts as a stream.
  4. 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.
  5. 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.

  1. Single Solve: solve_day26.py answered all 1,703 questions, and the submit was CORRECT (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"}
  1. Time Trial: solve_day23.py answered all 1,781 questions, and the submit was CORRECT (13:22:56 UTC). A JScript example from time-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"}
  1. Mastery: extracted the master zip, solved each of the 12 sets on its own with solve_day23.py, and merged the answers under their setN. prefix. The submit was CORRECT (13:24:19 UTC).
  2. The lane ran as a parallel fork, and the new solver code was copied into tools/.

Results

ModeQuestionsSolverResultFlag
Single Solve1,703solve_day26.pyCORRECT9e0ab44e69a80afa1f372d9448f3fea3
Time Trial1,781solve_day23.pyCORRECT2058fd4983a835e1c8e4f8803b228b62
Mastery21,372 (12 sets × 1,781)solve_day23.py per setCORRECT50311d79cdcf879627ff3a2654566503

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

What we were given

How it was solved

  1. Decode the blob. Hex pairs to ASCII bytes, same as Day 3 hex.
  2. 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.
  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 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.

  1. Established a session by visiting / and explored the application's API.
  2. Identified the feature route and audit route from /api/clues.
  3. Performed a privileged action (e.g. POST /execute-* to trigger a protected_export) and then checked the audit log at the audit endpoint.
  4. The audit log recorded only page_view — the privileged export action was missing from the log.
  5. Reported the logging gap: POSTed to the audit endpoint with the export ID, missing_event=protected_export, and observed_event=page_view.
  6. 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)

TargetVulnerability
1(standard web exploitation mix — backup/IDOR/etc.)
2IDOR — activity feed leaks executive case ID
3SQL injection — search endpoint injectable
4LFI — path traversal through notes viewer
5Audit logging gap — protected export not logged

Results

ModeResultFlag
Single SolveCORRECT9e58b4c19aa03b350a5e222eea3b4409
Time TrialCORRECTca237dc8dc04704a35d8f03d7a2cc989
Mastery (5/5)CORRECT7dab166991d50f9cd48e05cbe0be6bed

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.

  1. 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.
  2. The application uses a remote decoder to evaluate the policy. A valid policy returns a "deny" or "allow" decision.
  3. Submitted a malformed policy to the feature route: GET /dispatch-*?policy=remote:6fe40b6a2a03:broken. The broken suffix is not valid encoded data.
  4. 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)

TargetVulnerability
1(solved prior to this investigation)
2IDOR — /api/timeline leaks reference-only case → direct access
3SQL injection — /query endpoint injectable
4LFI — runbook reader path traversal
5Fail-open policy decoder bypass

Results

ModeResultFlag
Single SolveCORRECTa45b518259ce1547035c55965b4ab799
Time TrialCORRECTe8f420fd3522692813608a2c37e8131e
Mastery (5/5)CORRECTb616223270d9412ecf184e693258f544