huntress ctf 2026

read this first: clankers wrote this. every page on this site, the writeups, the tool articles, the tables and the numbers, was generated by clankers (ai), drafted from our logs, solver code and saved runs. they make mistakes and say them confidently. don't trust any of it to be true or accurate because it is written here: check a claim against the artifact before you build on it.

final standings

final · huntress ctf 2026 is over

finished 13th overall

of 1580 teams · 1885 points

  • #1of 1,580155first bloods
    1. 2ndWizdumb127
    2. 3rdsecretNinja52
  • #1of 1,5809days finished 1st
    1. 2ndWizdumb7
    2. 3rdsecretNinja4
  • #1of 1,58014days finished in the top 3
    1. 2ndsecretNinja10
    2. 3rdOscarsWorld9
  • #1of 1,58018days finished in the top 10
    1. 2ndOscarsWorld17
    2. 3rdIntegris15
  • #1of 1,5800:10.1fastest full-day clear (day 11)
    1. 2ndXyanthius0:13.6 (day 14)
    2. 3rdOscarsWorld0:26.1 (day 14)
  • #1of 13614.1mean finish rank, 25+ days cleared
    1. 2ndIntegris19.0
    2. 3rdsecretNinja19.2

51 teams cleared all 31 days and every one of them finished on 1,885 points. the board breaks that tie by the time of each team's last score, and the web lane's late finishes put ours 13th.

as of 2026-10-31 18:23 et, from the public scoreboard; generated at every build.

  1. mon
  2. tue
  3. wed
  4. thu
  5. fri
  6. sat
  7. sun
  8. 1#54 of 358
  9. 2#2 of 264
  10. 3#1 of 199
  11. 4#1 of 192
  12. 5#1 of 188
  13. 6#1 of 182
  14. 7#3 of 179
  15. 8#7 of 177
  16. 9#7 of 173
  17. 10#2 of 173
  18. 11#1 of 164
  19. 12#1 of 166
  20. 13#4 of 165
  21. 14#18 of 165
  22. 15#4 of 163
  23. 16#1 of 162
  24. 17#15 of 162
  25. 18#1 of 155
  26. 19#3 of 153
  27. 20#25 of 150
  28. 21#36 of 146
  29. 22#26 of 145
  30. 23#1 of 140
  31. 24#3 of 139
  32. 25#11 of 138
  33. 26#32 of 135
  34. 27#38 of 127
  35. 28#49 of 122
  36. 29#61 of 116
  37. 30#14 of 52
  38. 31#14 of 90
  • 1st
  • top 3
  • top 10
  • below top 10
  • not cleared

a day's finish is the time from its 09:00 et release to the team's last solve of that day; each cell is our rank among the teams that cleared the day.

these are the long-form technical writeups for our huntress ctf 2026 run. the posts explain how the artifacts were analyzed, how our custom parsers work, what failed, and which details generalize to future samples.

the posts show how to reach every answer: the graded labels, the exact values the grader accepted and the forms it rejected; only the flags themselves are [redacted]. the web posts are still the redacted versions.

the event uses three modes. single_solve is the untimed specimen used to learn the format. time_trial rotates the data under a short clock. mastery packs several variants into the same clock. consequently, each post treats the answer as a parsing problem rather than a one-off flag hunt.

start here

the words these pages share (single, fixer, gaps row, schedule row and the rest) are defined in the glossary.

results

bugs

coordination

the human's calls

game master

lanes

night shift

coverage

tips & tricks

day 1 — establishing the five lanes

the two welcome-lane posts distinguish what we actually preserved from what would have to be reconstructed; neither invents a flag or a solve.

day 2 — variants, misleading surfaces, and native formats

day 3 — cumulative formats under a seven-second clock

day 4 — one new family per lane, again

day 5 — familiar questions, new carriers

day 6 — containers that are the evidence

day 7 — one more runtime per lane, and making the unknown loud

day 8 — known encodings in new places, and answers that changed kind

day 9 — escaped characters, header fields by name, and answers that admit doubt

day 10 — a smaller alphabet, names that leave parts out, and questions the prompts never asked

day 11 — a url-friendly base, one version string, and old questions in new carriers

day 12 — a reversed message, a module's identity, and old fields in new carriers

day 13 — atbash, a windows installer database, and stories that asked nothing new

day 14 — caesar +7, windows shortcuts, and msbuild as one more carrier

day 15 — rot47, ooxml relationships, and one program built twice

day 16 — morse spelling hex, a message id, and one function compiled twice

day 17 — bacon over hex, an audio codec, a per-character permutation, and where a configuration is stored

day 18 — a rail fence, a video's dimensions, a keyed xor, google apps script, and a fortran tag

day 19 — packed bytes, new carriers, and a live web track

day 20 — the other byte order, a set over records, a second dex, and scratch after the data

day 21 — a compressed line, an apk's identity, an ocaml plugin, and web callbacks

day 22 — a zlib line, a jar's entry point, modeled root checks, an nsis carrier, a managed bridge, and two live web targets

day 23 — an ascii85 line, a sqlite page size, layered analysis headers, a computed answer code, anti-analysis predicates, and three clue-directed live web families

day 24 — a netstring line, an event log's record count, emulator checks inside a computed code, a jsp carrier, and a patched scala pair

day 25 — code points, a registry hive, integrity, elixir, clojure, and three web paths

the day-25 web challenge held for the day-28 release is covered in if a breach falls in a log.

day 26 — brainfuck, prefetch, split apks, an erlang carrier, a groovy crash dump, and two held web paths

day 27 — ook!, packet counts, a mobile code, a dockerfile, two builds, and three web paths

day 28 — reversed hex, a disk image's partitions, a framed packet, terraform, recipe questions, and two held web challenges

day 29 — a build's hooked signature, a loopback fetch, rot13 over base64, a certificate's fingerprint, one program built twice, a byte table keyed by its index, and a makefile carrier

day 30 — url encoding twice, a layered walk, beanshell in a jsp, identical-file groups, a config record under a new magic, and a self-modifying validator

day 31 — the last day: base32 inside gzip inside base64, a computed code across a month of mobile primitives, xslt read as text, an execution chain through six formats, and one more config record

tools we built

the challenge posts refer to a small analysis framework we wrote during the event. these articles document that code and its design so every writeup is understandable without access to our private project:

how the tooling grew

day added
before challenge scaffolding, a flag-pattern scanner, a generic decode peeler
1 game-master client, per-challenge solvers, elf and powershell parsers, base64 peeling
2 the shared library and the solve_set runner (delivery layouts, retries, saved runs); decoding registry with english scoring; jscript sandbox; c++/coff symbols and hcfg; magic prefixes; apk codec chains
3 batch reconstruction; numbered-line decoding; bom properties; .net metadata and ecma-335 tables; apk/axml/dex readers; cumulative dNN dispatch; fixtures, benchmark, labels, triage, mutation tests; readers for capture, event-log, hive, office, mail, pdf, media and windows artifacts
4 vbscript and language-agnostic material decoding with a generic control-flow guess; binary groups and ten more decoders; keyed, rc4, vigenere and compressed apk codecs; jpeg frame dimensions and image dimensions for png/gif/bmp/webp; the field-producer registry with build facts; crash-time run capture
5 literal reading for any value form and descriptor version, multi-word field stems; png chunk walk with crc, trailing-data and geometry checks; rust demangling and program-crate producers; the split apk codec; single-byte xor decoding; a language-agnostic script descriptor finder (any carrier, key recovered from the known prefix, json descriptors), verb-based roles for unseen step graphs, leave-one-out and out-of-sample carrier tests; ranked single-byte xor candidates for goal-driven decoding
6 jar members and a class-file constant-pool reader feeding the hcfg search; pdf header version and prepared pdf structure readers; unknown metadata field ids split structurally, with an exiftool word-overlap fallback; bash through the generic descriptor finder; ordered_tokens answers formatted from the question; statement-level guards in the generic control-flow guess; bounded external tools
7 raw header-field registry matched by name, zip census and nested archives as members; base36/62/91 and a1z26, cached line scores; keyed apk steps on raw text and codec aliases; fields placed by the question's file, roles from the question's enum with history, labels read both ways, a 1008-case label grid, split literals joined outside strings, compiled applescript / lua / autoit carriers; formats named from bytes, dex constants, mach-o and webassembly readers, tool failures raise; nested archives kept per set
8 html references to a fixed point, deduplicated line readings with search budgets, a whole-message line decoder scored by letter pairs, unicode / css / nato / seven-bit readings; central-directory and local-header names, full-word coverage for guessed properties, bounded decompression for every reader; analysis headers under any codec, stated descriptor values used verbatim; hcfg in base64 literals, producers chosen by answer kind, header-only elf fields; answer-format syntax read with negations
9 json-string and wrapper-stripping line readings, a literal-escape family, rot-n and two-step line repair, keyed line recovery with keys from the prompt, per-line failure reports and low-confidence answers; header fields resolved by structured name over 23 structs; every decode transform as an apk codec under every data and key reading; ranked candidate labels, relations read by field grammar and an impossible-family-tree check; a config-carrier search over every member with decoys rejected by checksum and content; failures recorded per set and prompt hints for parsers
10 padding-tolerant base32 and its other alphabets, a faster failing line search; structured names without struct or width, the pe version resource, executable labels and zip provenance; split variants and a network security config reader; mof carriers and a wmi subscription model; section-table questions, zig and c++ runtime markers that survive strip, class-file, kotlin and swift metadata readers, and the dynamic trace; a confirmed candidate first
11 base64's and base58's other alphabets, base92, base100, xxencode and ebcdic hex as line readings; url-safe base64 under keyed apk steps; escaped bash material and typescript carriers; pe table properties, in-memory winzip-aes and one zip index per member; the section and load address of a file offset
12 inverted case and a keyless rail fence, named codecs ranked over shift searches in line repair; cross-lane field resolution (any category's parser by exact field name); .net module and assembly columns, attributes and references by name
13 affine, keyboard-shift and progressive readings of whole messages, polybius and tap-code lines; windows installer databases and fields computed across named members; aes apk codecs; an additive byte shift for batch material
14 numbered lines read by their day's codec with the new line searched prompt-first, yenc, rot8000, dna, ternary, esolangs, base65536 and base2048; one-record readers for shortcuts, mail, office, ole2, event logs, hives, captures, sqlite, plists, disk images, torrents and certificates, mapped to a property by its words; columnar, rail fence, alphanumeric caesar and substitution apk codecs with keys from the app; index, bit and two-step script material transforms and header-less constants
15 office package relationships read as xml (targets, types, internal and external references); a field routed to the member its role word names; a c build's function count from its symbols, else its unwind table, stripped too; a two-part xor key header for script material; a field a reader already outputs answered by its words
16 rot47 and morse-then-hex schedule rows as step chains, morse hint words and slug-word ranking for a short new line; a table check that fails a regression replay when a search stood in for a table row; saved runs keep the accepted answers; mail thread fields; every webassembly door, with call counts from an instruction decoder
17 bacon groups as hex nibbles as the seventeenth schedule row; media stream and container properties by ffprobe's keys; a per-character permutation apk codec; the configuration blob's storage form from its carrier and section, c++ type, vtable and member names on pe builds, runtime markers and a class's access word
19 packed overlays located at executable boundaries, sha256-validated byte-operation search and overlay producers; a bounded live-target collector with same-origin enforcement, persistent per-target sessions, backup, idor and sql-injection recipes, concurrent heterogeneous mastery capture, offline answer mapping and failure fingerprints; utf-16 and utf-32 text read by a byte-order mark or zero bytes under every decoding step; a header field named without a format word; an analysis header inside a string literal
20 target-local web route discovery and applicability guards in mixed bundles; partial web response capture on read failure with unaffected proofs validated separately
21 the apk manifest and first signer as named values and a metadata record family; role pairs compared on file stems; base64 of gzip as a schedule row; clue-selected reflected callback, moderator receipt, and session-hint flows; bounded asynchronous receipt polling and a case-portal fallback for heterogeneous mastery targets
23 ascii85 as a schedule row and a short new line read as written; field ids split at their stem, the sqlite header record, embedded databases and member-name lists in two orders; the layered analysis header, random-stem specimen names and composite answers; a dalvik interpreter for computed answer codes, native pieces under an emulator and a dex loaded from assets; a digit width stated by the question; clue-selected template expression, stored report condition, and guarded profile update; first-capture inspection and release-day fixture selection
24 netstrings as a schedule row, with bencode, hexdump listings, roman numerals, spelled-out numbers and bounded run-length pairs beside it, each behind a shape gate; a member resolved by the leading tokens of its stem and an ordinal in the question; whole-log event-log keys; clue-driven api inventory requests, evidence-gated internal fetch, ordered web target mapping, and a sparse moderator-note cue; crash reports that carry each field's question; a readiness pass keyed on the code it checked
25 code points as a schedule row; the registry hive record's whole-tree keys and base block checksum; a property's one-word-over synonym among a record's fields and readings one word over in the reader inventory
26 brainfuck as a schedule row; windows 10 prefetch decompressed in python (lzxpress huffman) and the whole prefetch record; split apk bundles read as one app, with splitSourceDirs and ZipFile over a split in the dalvik interpreter and a split puzzle's empty part filled from a feature json; a jar's crash json and its fault, frame and method-table producers; clue-derived webhook event aliases and encoded state-format web flows
27 guarded websocket upgrade and fragmented-frame reading for clue-directed web streams
28 reversed hex as a schedule row, no beam after a dictionary slug, a per-blob budget and seven more readings; a disk record for guid partition tables and mbr disks, the partition an offset in the question names, filesystem magic and header records for crash dumps, hibernation files, volume boot records, ext, qcow2, vmdk and ewf; the packet codec with checksum-chosen frame layouts, an answer-shape scan and a framework layer for the dalvik interpreter; questions read as recipes, format-dispatching binary readers and the family cluster as a producer; bare encoded runs as a last-resort script carrier; the end-of-day regression gate as one command and field rules carried into the next day's solver; guarded policy-format, export-audit and upload-preview clue flows in the live web collector; bounded clue-route body summaries in saved web inspection
29 rot13 over base64 as the twenty-ninth schedule row; the table apk codec (a byte table keyed by its index) and the index-key schedule family; six more record readers (pdf, png, 7z, mft, journal, pst) so a first question on those formats no longer goes to a fixer; a field rule that raises falls back to the lane reader instead of sinking the set; pre-release fixer waits capped under the shell's 180 s background limit; an is yours row that always carries a handler draft with its dispatch guard; named the update-inspector and case-fetch web clue flows, a generic bounded fallback that follows every clue-named route and sends what their bodies disclose through the feature route in ranked shapes, and a compact clue-route disclosure in the no-proof packet
30 url twice as the thirtieth row, chains of the day table's codecs, a line nothing reads sent unsure; the layered apk codec (reversed bytes under a walking key) and a bounded peel over two to four layers with the answer prefix as oracle; the metadata relation family (copied, repackaged, transcoded, cropped) with semantic and near keys, capture hosts and digest-keyed memos; a configuration record under a renamed magic found by crc scan, magic-free carrier stages, producers for techniques never asked by name and the call graph inside a timed set; a miss report that always ends in a handler draft, other lanes' readers as relation keys; a guessed script label goes out unsure, three readers of the descriptor graph; the winning candidate position carried to the timed tiers; a far edge drops the pin; families named in advance, the forward matrix and the next-day model; base32 inside gzip inside base64 as the last schedule row; the delegated-identity sweep and queue-then-audit web families named deterministic with capture-faithful local fixtures, a record-based liveness classifier for the capture loop (heartbeats and transcript lines, never a target request, never under a live attempt), a fail-soft readiness check on proofless non-graded sets, and handoff-record heartbeats in saved web inspection

these are implementation notes, not downloadable software documentation. code snippets are included to make the algorithms and assumptions explicit.

{generated by a clanker}