2026-10-29
Day 29: Fraternal Twins
Lane: Binary reverse engineering. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
binary-reverse-engineering-day-29-variant-diffing - Prompt: "Two binaries, same source, different compiler moods. Diff the variants, account for every optimization, and prove they're semantically the same program."
What we were given
- Single Solve: one archive,
artifact.zip(35,956,121 bytes, SHA-25654198f2cc3fd2f8f00bee312366a5c9832956aff82ad0c5e653399a64d2fdc24). AES encrypted, passwordinfected. The 42 extracted members are inextracted/. - Every earlier family: ELF, PE/.NET, JAR, WebAssembly and packed-overlay specimens,
d01tod28. - New today:
d29--sample-O0.elfandd29--sample-O3.elf(43,931 bytes each), the same program built without (-O0) and with (-O3) optimization. - Mastery: 13 deliveries, saved under
mastery/deliveries/.
What was asked
- 406 questions in Single Solve and Time Trial. Mastery had 13 sets, so 5,278.
- Question types:
- d01 to d28: the same questions as Day 28 (hashes, headers, symbols, structure hashes, runtime checks, configs, overlays).
- d29 (new):
optimized_format,optimized_machine(fromO3.elf) andunoptimized_format,unoptimized_machine(fromO0.elf);config_*: decode both builds, check they match, report the commoncampaign,domain,mutex,url;optimized_config_*: the same four fields from theO3build.
How it was solved, start to finish
- The watcher ran the driver first. The Game Master answered
incorrect, so the lane was flagged for manual work. - Ran
tools/solve_tm.pyon the Single Solve archive. Its first output covered 355 of 406 fields. A full partial submit of those came backincorrect. - Used the partial-submit oracle. Submitting the answers in day groups (
d01…d29) accepted every group exceptd20. Testing the d20 fields one by one showedd20_analysis_overlay_sizewas wrong. - Fixed d20. The member length is 1,201,351 bytes and the
RS20magic is at offset 1,200,888, so the size is 463.
- The d20 size question does not name the magic.
solve_tm.pynow borrows the magic from the matching…_overlay_offsetquestion (which namesRS20), instead of guessingPK20.
- Added the missing handlers to
solve_tm.py(commit99da660), for the question types first seen on Day 28 and the new d29 roles:
- structure count and ordered-set SHA-256;
host_model/ipv4; vtable symbol; CLI runtime anddecoycheck; - class count, class name and method-names SHA-256; symbol counts; Nim / FPC / GNAT runtime checks;
- section count and the conditional-branch opcode count;
PK19packing keys; - role members picked by file name:
gcc.elf,tcc.elf,false-friend.elf,family-a.elf,family-b.elf,O3.elf,O0.elf.
- d29 config check. Both builds end with the same record. Re-checked on the saved files:
d29--sample-O0.elf length 43931 HCFG offset=43544 key=0xe1 len=375 crc32=0x78a90ef3
d29--sample-O3.elf length 43931 HCFG offset=43544 key=0xe1 len=375 crc32=0x78a90ef3
JSON (both): {"campaign":"BR29-000","domain":"variant-000.day29.example.invalid","ipv4":"198.51.100.90","url":"https://variant-000.day29.example.invalid/v/BR29-000","mutex":"Global\\HuntressBR29-000_000", ...}
Both builds: format elf, machine 62. The configs match, so the common and the optimized_config_* answers are the same.
- Submitted the corrected answers in per-day groups. All 29 groups were accepted, and the last group (
d29) completed the attempt:CORRECT.validation-observations.jsonrecords each oracle step. - Time Trial: all 406 fields from the assigned archive. Result:
CORRECT. - Mastery:
- Downloaded each of the 13 deliveries through its start-response capability and checked the SHA-256 the API gave.
- Two more fixes in
solve_tm.py(commite03a109): section count also works for PE files, and the role handlers acceptsetN.-prefixed field IDs. tools/solve_tm.pythen built the full 5,278-answer map. Result:CORRECT.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT (406/406) | 577e5da68e5b369b4d24a81d0d373b12 |
| Time Trial | CORRECT (406/406) | 67274a0aaf33bdcd4d105ad9e4dfab36 |
| Mastery | CORRECT (5,278/5,278) | 110b25d935f0ebbefe2e282729a9370f |
Each mode folder has the archive(s), the answers, submit-response.json and final-status-response.json. Single Solve also keeps partial-submit-response.json (the first incorrect try) and validation-observations.json.
Reproduce
Offline, from this folder (no Game Master needed):
mkdir -p /tmp/d29/deliveries && cp single-solve/artifact.zip /tmp/d29/deliveries/delivery-1.zip
python3 -I ../../tools/solve_tm.py single-solve/start-response.json /tmp/d29/deliveries /tmp/d29/answers.json
Checked on 2026-11-01: this answers 406/406, and every answer matches answers.json. It only parses the samples and never runs them.
Day 29: Trust Issues
Lane: Metadata forensics. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
metadata-forensics-day-29-trust-issues - Prompt: "Certificates appear in binaries, packages, mail, captures, and disk images. Fingerprint each one, collapse duplicates, and identify the trust claim unsupported by evidence."
What we were given
- Single Solve:
artifact.zip(metadata-day-29-evidence.zip, SHA-2567e100a9dadaca752a47a6599af7b0b0bbeab734c3140276e8c375f9b5abde3d9). It containscertificate-001.pem, saved in.single-solve/extracted/ - Time Trial:
artifact.zip(evidence.zip, SHA-2569e5c728db4344a610abf1798a0a8c5e2f149b3fc33a1e1644944e2388c605202). The notes, the roster,disguised-report.binand one file of each type so far, now includingcertificate-001.pem. - Mastery:
artifact.zip(metadata-forensics-day-29-trust-issues-mastery.zip, SHA-2562ca059797db6e83eafdc032a6ba22996072a1133206dd0bf38afd3f47ce85cb2). It contains 13 evidence zips, one per set. - New today: X.509 certificates in PEM form.
What was asked
- Single Solve: 1 question:
x509.sha256_fingerprintforcertificate-001.pem(answer IDd29-x509-001-x509-sha256-fingerprint). Format: exactly 64 hex characters, no prefix or spaces. - Time Trial: 34 questions. Mastery: 442 (13 sets × 34).
- Question types: every field type from Days 1–28, plus the certificate fingerprint and the SHA-256-ordering synthesis field.
How it was solved, start to finish
The method: a certificate's SHA-256 fingerprint is the SHA-256 of its DER bytes. A PEM file is that DER, Base64-encoded between BEGIN/END CERTIFICATE lines.
- Single Solve. Started the untimed attempt and downloaded
artifact.zip. Ran OpenSSL on the PEM:
openssl x509 -in certificate-001.pem -noout -fingerprint -sha256
Removed the colon separators and lowercased the 64 hex digits to match the answer format. Submitted under d29-x509-001-x509-sha256-fingerprint. CORRECT.
Re-checking the saved PEM without OpenSSL gives a 483-byte DER with SHA-256 b466fdbf8b8b8cb2d0b632bd24eb875576b44edb85f18f90f53dcdea1a0ec781.
- Added the same rule to the driver. The
tools/run_meta.pycopy got anx509handler:
m = re.search(rb'-----BEGIN CERTIFICATE-----\s*(.*?)\s*-----END CERTIFICATE-----', fb, re.S)
der = base64.b64decode(re.sub(rb'\s+', b'', m.group(1)))
return hashlib.sha256(der).hexdigest()
This copy talks to the Game Master through the CourseStack proxy and reads the mode's artifact.zip from its work folder, which is why each mode folder here has one.
- Time Trial. The 34-field bundle was solved from its downloaded archive. Examples from
answers.json: fingerprint97b70bca945248acf0555404206ff36db0b91b93da7c4d2607d9621ef513c6b2, audio codecopus, partitions[242,300]. The final status reportsCORRECT. - Mastery, first pass.
tools/run_meta.pyanswered all 442 fields. Six of them turned out to be wrong. - Found the wrong fields with the partial-submit oracle. Submitting part of the answers returns
acceptedif all of them are right, orincorrectif any is wrong. Halving the fields of each set narrowed it down. For set 1:
- first 17 fields →
accepted; the other 17 →incorrect; - then 8 →
incorrect, then 4 →incorrect; - LNK + OOXML →
accepted; email + audio →incorrect; email alone →accepted; audio alone →incorrect.
So the audio codec was wrong. The same search found one wrong field in six sets, always media.primary_audio_codec_name: sets 1, 2, 5, 7, 12 and 13. All 60 oracle calls are in oracle-localization.json.
- Fixed the six codecs. They were checked on the assigned WAV files with MediaInfo and mapped to the stream codec names the grader uses:
mp3(sets 1, 12, 13) andpcm_s16le(sets 2, 5, 7). - Mastery, final submit. The corrected map returned
CORRECT.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | ff8d0ef20b51e6f47ed7a49abc46e66d |
| Time Trial | CORRECT | 2af7973863eafc15a2f9f129393ac42c |
| Mastery | CORRECT | 163f0ac6ad6f1d991575444e3de25357 |
Each mode folder has the downloaded artifact.zip, start-response.json, submit-response.json and final-status-response.json. Time Trial and Mastery also have answers.json; Mastery has the oracle record. No screenshots were captured.
Reproduce
openssl x509 -in single-solve/extracted/certificate-001.pem -noout -fingerprint -sha256
python3 -I ~/.config/huntress/solvers/run_meta.py metadata-forensics-day-29-trust-issues single_solve /tmp/d29
The first line only needs the saved PEM. The second needs a Game Master token in ~/.config/huntress/gm-token; this copy of the driver also has an x509 handler (SHA-256 over the DER). For time_trial and mastery it calls op=retry first, which spends one of the unique attempts.
Day 29: White Box Key Recovery
Lane: Mobile (Android). Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
mobile-android-day-29-white-box-key-recovery - Prompt: "Recover an equivalent key operation from challenge-owned table transformations, not a third-party protected binary."
What we were given
- Single Solve:
white_box_key_recovery.apk, caseMOB-29-2898E911C6. Saved assingle-solve/artifact.zip(12,704 bytes, SHA-2560d6896623fa3755fcc48b67f6c9a72cfcda9baaa75d10794c0b94e0d1c25d532) and unpacked insingle-solve/extracted/. Its puzzle uses a new v1 codec,table:
{"schema":"huntress.mobile.puzzle.v1","day":29,"codec":"table","data":"6a7a825f767a6c82787c8b8d8592948a9d9597a5","key":41}
- Time Trial:
white_box_key_recovery_time_trial.apk, caseMOB-29-2F150B1E8B. Saved astime-trial/artifact.zip. Its puzzle is v2analysis. - Mastery: thirteen deliveries in
mastery/deliveries/, all v2analysis. Cases come from Days 1, 3, 7, 9, 10, 13, 15, 18, 19, 23, 24, 26 and 29. Three are different:delivery-05has a network security config,delivery-07haslibarena.so, anddelivery-12is a split bundle (base.apk+feature.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.answertoset13.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 fortable. - Single Solve: the table transform. The 20 data bytes and the key (41 =
0x29) are enough. Byteiof the answer isdata[i] - (key + 3 × i), modulo 256. For example0x6a(106) − 41 = 65 =A.
import json
p = json.load(open('single-solve/extracted/assets/huntress_puzzle.json'))
d, k = bytes.fromhex(p['data']), p['key']
print(''.join(chr((b - (k + 3 * i)) % 256) for i, b in enumerate(d)))
Output: ANS-AB1D78DC8BA4D98C. It was submitted under answer and graded CORRECT. (The DEX of this APK has no Release class. It only has MainActivity, ChallengeActivity and WhiteBoxKeyRecovery.)
- Time Trial: the
analysischain. The answer comes fromRelease.code()in the DEX. A helper agent rebuilt the chain from the baksmali output:
Release.token(): seed0x1b24ce55086d6ca9→mixTable5d→walkSbox52→mixRound49.Release.code():token()→Mix.f1→Util.finBox5b→ XOR0x134485d7e0c85444→ANS-plus 16 hex digits.ChallengeActivitychecks aproofvalue (Release.proof(), the hex oftoken()) before it callsRelease.code().- The DEX also has
seal…methods (sealLookup8c,sealRoundd5,sealTable4c) that are not part of this chain.
Its Python port printed ANS-3F3675ECB5A05D1F, the same as the saved answer. The Time Trial was already graded CORRECT by the teammate session. Both constants above are present in the saved Time Trial DEX.
- Mastery: a DEX evaluator. Local attempts hit two gaps. Delivery 9 uses Java reflection (
Class.forName+Method.invoke), and the simple interpreter could not run thewalkSboxloop and arrays. Both local sessions then stopped on a usage limit. The teammate session finished Mastery withtools/dex_answer_vm.py:
- It reads each
classes*.dexwithandroguard(from the innerbase.apkwhen the delivery is a bundle). - It turns the bytecode into the text form that
tools/smali_analysis.pyruns: branch labels,packed-switchtables, and input registers asp0,p1, …. - It calls every method named
codethat returns aString, and keeps the first result that matchesANS-plus 16 hex digits. tools/smali_analysis.pygained Java reflection into challenge-owned methods (Class.forName,getDeclaredMethod,Method.invoke) and asset reads from split APKs.
The 13-answer map came back CORRECT at 13:34 UTC.
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 09b0023ca2df2d778f45003930e47761 |
| Time Trial | CORRECT | 2c8e2c9b6610de6ebca25cd04b8e5ceb |
| Mastery | CORRECT | 6da46735fb0f1cf603ffc120e66c5132 |
Saved answers: Single Solve ANS-AB1D78DC8BA4D98C, Time Trial ANS-3F3675ECB5A05D1F. The thirteen Mastery answers are in mastery/answers.json. Each mode folder has the artifact(s), answers.json, start-response.json, submit-response.json and final-status-response.json.
Reproduce
Single Solve, offline: run the Python snippet above from this folder.
Mastery, with the tools/ copy of the driver:
cd ~/projects/huntress-ctf-writeups/tools
python3 -I run_mode.py mobile-android-day-29-white-box-key-recovery mastery mobile_puzzle /tmp/d29
This copy reaches the Game Master through the CourseStack proxy (http://10.0.0.219/huntress-ctf-proxy) and needs androguard for dex_answer_vm.py. It reads and evaluates the DEX in Python. Nothing is installed or run on a device.
Note from the code: run_mode.py reads the puzzle from the top of the zip, so it cannot open the split bundle (delivery-12). dex_answer_vm.answer() can, because it opens base.apk itself. How the bundle was fed in on the day was not recorded.
Day 29: Make It Make Sense
Lane: Script analysis. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
script-analysis-day-29-makefile-variant-diff - Prompt: "Unseen Makefile variants and their prior-language build chains differ in layered variables and target flow. Diff them carefully, and keep only the tradecraft conclusions that hold up across every variant."
What we were given
- Single Solve:
artifact.zip(159,137 bytes, SHA-2560ba75808186d63e2269cd7d69f2d6d2835cd6425300ce2aa9a389204218a1525). Password:infected. - 183 files in the role-named layout. The archive and the extracted files are kept in
single-solve/. - New today: 4 Makefile polyglots (
polyglot-makefile-benign-utility.mk,-downloader,-launcher,-staged-chain). - Time Trial:
artifact.zip(181,206 bytes, SHA-256885c048332e09a1e82dcf59f11f929bb8630e9189b0d567fd8e2c93ab8ae35a5) in the hash-named layout fromDay 23. - Mastery:
artifact.zip(2,329,998 bytes, SHA-2561c26028e1459b5ee323ecef40431df001a5741294f9bd6177c4fffb81e6548e7). It holds 13 encrypted evidence zips, one per set. The extracted sets are inmastery/extracted/set-01…set-13.
What was asked
- Single Solve: 1,747 questions. By family: PowerShell 15, JScript 72, Batch 72, VBScript 72, Python 126, Bash 168, Node.js 56, host 154, polyglot 1,012.
- Time Trial: 1,833 questions in the Day 23 format.
- Mastery: 23,829 questions in 13 sets of 1,833.
How it was solved, start to finish
- Single Solve. Started the untimed attempt and downloaded
artifact.zip. Decoded the PowerShell, JScript, Batch, VBScript, Python, Bash, Node.js, host and polyglot files with the repo's expansion solver (tools/solve_expansion.py).
- JScript went through the static Python decoder
jsdec_py_emu.py(seeDay 28), so no script was run. - The Makefile files carry the usual
HUNTRESS_ANALYSIS_V1marker. - The solver filled all 1,747 fields, and the submit was
CORRECT(13:08:22 UTC).
Real answers for a new Makefile file:
{"polyglot-makefile-staged-chain-role": "staged_chain", "polyglot-makefile-staged-chain-attack": "T1059",
"polyglot-makefile-staged-chain-campaign": "MAKEFILE-0854134e",
"polyglot-makefile-staged-chain-obfuscation": "plain_hex",
"polyglot-makefile-staged-chain-stage-profile": "single_descriptor",
"polyglot-makefile-staged-chain-next-language": "vbscript"}
- Time Trial. Decoded the 1,833-field bundle with
tools/solve_day23.py. The submit wasCORRECT(13:16:17 UTC). Example answers (layeredLYRobfuscation):
{"polyglot-makefile-d7e615-role": "persistence_descriptor", "polyglot-makefile-d7e615-attack": "T1053",
"polyglot-makefile-d7e615-obfuscation": "b32_b32", "polyglot-makefile-d7e615-stage-profile": "onyx_weave",
"polyglot-makefile-d7e615-next-language": "xslt"}
- Mastery.
- Extracted each of the 13 evidence zips with the password
infected. - Ran the existing solver on each set with that set's exact question mapping.
- Merged the answers under their
setN.prefixes. - The full answer map was accepted,
CORRECT(13:28:50 UTC).
Results
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT | 648f8d36d2c6563bb90bc09620914861 |
| Time Trial | CORRECT | 05b66114766be0730363eb9b6eb09016 |
| Mastery | CORRECT | b43a836b24c84be185cf41bad998c9e4 |
The flags are from each mode's final-status-response.json. Each mode folder keeps its archive, the extracted files, answers.json and the Game Master JSON. No screenshots were taken.
Reproduce
Offline, from the repo root:
mkdir -p /tmp/d29/ex
7z x -pinfected -o/tmp/d29/ex repos/day-29-script-analysis-make-it-make-sense/single-solve/artifact.zip
python3 -I tools/solve_expansion.py /tmp/d29/ex \
repos/day-29-script-analysis-make-it-make-sense/single-solve/start-response.json /tmp/d29/answers.json
This rebuilds all 1,747 saved Single Solve answers (re-checked on 2026-11-01). It only parses the files.
Mastery check: run tools/solve_day23.py on mastery/extracted/set-01 with set 1's questions (the set1. prefix removed), with node off PATH. It rebuilds all 1,833 saved set 1 answers (re-checked on 2026-11-01). With node on PATH, solve_day23.py first calls the jsdec.js next to it; the tools/ copy of that file is a static decoder.
Day 29: Rotten Base
Lane: Warmups. Modes: Single Solve, Time Trial, Mastery. Result: all CORRECT.
The challenge
- ID:
warmups-day-29 - Prompt: "Rot it, then base it. Two familiar transforms in sequence."
- New encoding: ROT13 then base64
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. Apply ROT13 letter rotation to the text, then base64-decode the result.
- Mastery blobs use multiple encodings from Days 1-29. 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. Flag:f616a2d7e79b168846bb52757d301ad8. - Time Trial:
CORRECT. Flag:31a219cf1706814b0d7d7a0f47bf0fc8. - Mastery:
CORRECT. Flag:c696aacfdb593e48be11baceb466a4d0.
Day 29 — Internal Affairs (SSRF + IDOR Chain)
Lane: Web Exploitation · Challenge ID: web-exploitation-day-27-internal-affairs
> Two service boundaries, one hallway. Use the public fetch to knock on the internal door, then borrow somebody else's records on the way out.
What we were given
A live web target with a public-facing fetch endpoint and an internal service.
How it was solved
SSRF chained with IDOR — the public fetch endpoint reaches an internal service, and the internal service has broken object-level authorization.
- Explored the target application.
/api/topologydisclosed the architecture: a public-facing app and an internal case service running on loopback (127.0.0.1:8080), not exposed to the internet. - The public app has a fetch/proxy endpoint (the feature route from
/api/clues) that accepts atargetURL parameter. - The internal service has an account/case endpoint with an IDOR — you can access any record by ID without ownership checks.
- Chained the two weaknesses:
GET /action-*?url=http://127.0.0.1:8080/account-*?id=13465— the public fetch proxied the request to the internal service, which returned the restricted record containing the proof witheffect: ssrf_then_object_authorization.
Root cause: Two independent weaknesses combine into a critical chain: (1) the public fetch endpoint doesn't restrict target URLs, allowing SSRF to internal services; (2) the internal service trusts all requests from localhost and doesn't enforce per-object authorization.
Mastery — mixed targets (5/5)
| Target | Vulnerability |
|---|---|
| 1 | Backup exposure — exposed archive file |
| 2 | IDOR — reference-only case accessible via session |
| 3 | SQL injection — /explore endpoint injectable |
| 4 | LFI — handbook viewer traversal to /run/huntress/objective.txt |
| 5 | SSRF → internal service IDOR chain |
Results
| Mode | Result |
|---|---|
| Single Solve | CORRECT |
| Time Trial | CORRECT |
| Mastery (5/5) | CORRECT |
Day 29 — Trust the Build (Dependency Confusion / Supply Chain)
Lane: Web Exploitation · Challenge ID: web-exploitation-day-26-trust-the-build
> The updater trusts its packages like old friends. Slip a tampered dependency into the build and watch it install your version of the truth.
What we were given
A live web target with a package update mechanism.
How it was solved
Supply chain attack via dependency confusion — the update mechanism verifies some package fields but not all, allowing a tampered dependency to be accepted.
- Read
/api/updatesto see the current package manifest — names, versions, hashes, and signatures. - Read
/api/update-policyto understand the verification process — which fields are checked and which aren't. - Discovered the verification gap: the updater checks
package,version,hash, andsignaturebut does not verify theartifact_hookfield. - Submitted an update with all the original verified fields intact but changed the
artifact_hookfrompassive_health(benign) toprivileged_export(escalated). - The endpoint accepted the tampered package — verification passed on the checked fields — and returned
effect: unverified_update_activatedwith the proof.
Root cause: The update verification is incomplete. It validates package identity and integrity (name, version, hash, signature) but ignores the behavioral hook field. An attacker who can submit update requests can change what the package does while passing all integrity checks.
Mastery — mixed targets (5/5)
| Target | Vulnerability |
|---|---|
| 1 | Backup exposure — robots.txt → release archive → JSON backup |
| 2 | IDOR — activity feed leaks executive incident → direct access |
| 3 | SQL injection — /search endpoint injectable |
| 4 | LFI — handbook viewer traversal to /run/huntress/objective.txt |
| 5 | Dependency confusion — tampered artifact hook in update payload |
Results
| Mode | Result |
|---|---|
| Single Solve | CORRECT |
| Time Trial | CORRECT |
| Mastery (5/5) | CORRECT |