bugs: the variant series that answered itself
huntress ctf 2026 · game master findings · reported on day 21, retested on day 22
the timed tiers of the binary lane were meant to measure how fast a team can reverse engineer a fresh bundle of binaries. for most of the month they also measured something else: whether a team had noticed that every "fresh" bundle came from one numbered series, that the number was printed inside the zip, and that the answers were a pure function of that number. a team that had noticed could submit a correct answer set without downloading the bundle at all. we found it, proved it on a tier we had already solved, reported it to the organizer, and retested the patch. this page is that story, with the numbers that show how large the edge was.
day 4: the index was printed in the zip
the first sign came on day 4. every time-trial zip of go fish carried an archive comment such as huntress:day04-time-048. with the index in hand, fitting each member of the bundle against it gave a small table:
| component | variant for time-trial index n |
|---|---|
d01 elf |
floor(n / 16) |
d02 campaign |
floor(n / 2) mod 8 |
d02 format |
elf if n is even, pe if odd |
d03 campaign |
(1 - n) mod 8 |
d04 campaign |
(6 + floor(n / 2) - 4 * (n mod 2)) mod 8 |
d04 format |
elf if n is even, pe if odd |
at index 16 the d02, d03 and d04 answers matched index 0 exactly; only the three d01 answers changed. the leaderboard also showed a time of roughly 200 ms on that challenge. we never established how it was made or exactly what the board's timer measures, but it was well under what a download and an analysis should take.
day 7: a bank you could count, and a proof on a solved tier
on day 7 the start reply gained unique_attempts_remaining, which counts down on every retry and so shows each tier's fresh-variant bank: for day 6, 256 entries for warmups and binary, 32 for script, 16 and 8 for mobile, and 2 for metadata (a bank you can download twice and know). day 1's mobile mastery had served eight question sets, then repeated sets 1 to 5 in order. the banks were finite and ordered; could an unseen entry be predicted? day 4's table said it could, and we tested it the same day.
we went back to day 4's binary tiers, which we had already solved, and tested the model on held-out variants first: d01 answers from index 48 plus d02 to d04 answers from index 1 predicted all 32 fields of index 49, and indices 0 and 8 predicted all 64 fields of a mastery whose second set was index 8. both fresh downloads solved CORRECT and matched every field. then the part that matters, a submit with no download of the assigned bytes:
time_trial index 50: CORRECT, artifact_downloaded=false, sources=[48,2], total 1070.1 ms
mastery index 16: CORRECT, artifact_downloaded=false, sources=[0,16], total 1095.6 ms
overlapping the retry and the submit on separate warm connections brought a later time-trial attempt (index 53) to a 0.459 s solve interval, though that trick sometimes hit the previous attempt instead. a cached prediction for mastery index 17 was rejected in the same session for a reason we did not isolate.
the limits are part of the finding. every one of these attempts was on an already-solved tier in the unranked retry pool. we never submitted a cached answer set in competition, and we never established whether the ranked path would accept one; both reports to the organizer say so.
the generator was that mechanical: day-1 elf variants 0 and 1 differ in four bytes, and patching them to variant 2 plus gnu strip --strip-all reproduced the downloaded variant-002.elf byte for byte.
days 3 to 22: how the series worked
one index, two clocks
for variant index n, every member except the day-1 elf depends only on n mod 16, and the day-1 elf is d01--variant-{floor(n / 16)}. any index's answer set is one of sixteen "low-block" fragments plus one of sixteen day-1 fragments. there was no per-attempt randomness for a cache to defeat.
| delivery vs time trial, days 3 to 19 | pairs | all non-d01 members identical |
|---|---|---|
| congruent index | 153 | 153 |
| non-congruent index | 2078 | 2 (day 2's two-file bundle) |
mastery is a time trial you already played
on unranked days the mastery deliveries were labelled mastery-00 onward. on day 18, huntress:day18-mastery-00 differed from huntress:day18-time-000 by two bytes of outer zip (a longer comment); all 21 inner members were identical and all 204 graded fields equal. mastery set 1 was the time trial just played, file for file.
on the ranked days (15 to 17 and 19 to 21) the first mastery served indices 017 to 021; day 19's five deliveries were labelled huntress:day19-time-017 to huntress:day19-time-021. under period 16 those are time-trial indices 1 to 5, and the day-1 elf of all five is variant-001. a team holding those time-trial variants could answer an entire ranked mastery without fetching any of its deliveries.
every day carries every earlier day
the binary bundle is cumulative: day n holds members d01 to dNN, and the earlier members were not re-rolled. each day's saved time trial against the day before (index 0 each day; day 22's delivery was variant 1, which the period of 16 maps onto the same answers):
| day | fields | carried from the day before, same answer | share |
|---|---|---|---|
| 19 | 228 | 216 | 94.7% |
| 20 | 240 | 228 | 95.0% |
| 21 | 252 | 240 | 95.2% |
| 22 | 264 | 247 | 93.6% |
a team that solved yesterday held about 95% of today's answers before reading a byte. only the new tag's dozen or so fields needed today's analysis, and only once per low-block index. the chart runs the same comparison over the month: the carried share climbs from 80% on day 5 to 95% on day 21, holds through day 22 with the index hidden, and drops to 34 to 41% from day 23, when the values were re-seeded.
- same answer as the day before
- asked both days, answer changed
- new question today
each column is one day's saved binary time trial, its graded answers compared field by field with the day before's. days 4, 8 and 9 are blank: the two saved time trials sat at indices not congruent mod 16, so their low-block members differ by design. day 12's changed slice is four machine fields regraded in a new spelling, same bytes. the new slice is wider on day 17 (32 new questions on older tags, while all 160 fields asked both days kept their answer) and day 28 (54 on older tags). hiding the index on day 22 moved nothing: its 5 changed fields are the day-1 elf, served as variant 1. the step is the day-23 re-seed.
why the advertised hash hid it, and how the index leaked anyway
the start reply lists a sha256 per delivery, which looks like a way to spot a repeat. it covers the outer zip, and a mastery delivery differs from its time-trial twin by the comment alone: the hash changes, the gradeable content does not. the comment itself can only be read after the download (the server ignores Range), so it confirms an index rather than revealing it. the counter revealed it: with a bank of 256, the next time-trial index was 256 - unique_attempts_remaining before the retry, and mastery's indexed second set was 257 - unique_attempts_remaining. the cache key is the expected index, not a hash.
day 21: the mastery that did not need its download
on day 21 we noticed that a mastery sometimes does not need its download because the time trial already holds the information. we checked every saved binary time trial and mastery of days 1 to 21 offline, with no game master call, and found the day 4 rule everywhere it could be tested.
what it would have been worth
- 16period of the variant seriesevery member but the day-1 elf
- 95%of a time trial carried from the day before94.7% to 95.2%, days 19 to 21
- 100%of a ranked mastery answerable from cache1,260 fields on day 21
- 2.5-4 slead over our own pipelinea cached submit is one round trip
an honest solver cannot start analysing before its bytes arrive. on day 18 the four 32 mb mastery deliveries took 2.8 s to download, and the time-trial bundle 1.2 s. our own fully automated binary solves (binary analysis) on days 18 to 21 used 1.6 to 2.9 s of the time-trial clock and 3.5 to 4.6 s of the mastery clock (see flow state). a cached submit is one round trip: about 1.07 s done sequentially, about 0.45 s overlapped. the recipe for a team that had noticed:
- play the day's time trial honestly (index 0).
- retry the unranked pool to collect indices 1 to 5. each is a real download and solve with no ranking at stake, and with yesterday's cache only the new tag needs work. the day-1 elf's variant 1 comes from any index 16 to 31, and that member is carried from day to day like the rest.
- start the ranked mastery. it serves indices 017 to 021: 1,200 fields on day 20 and 1,260 on day 21, all of them already in the cache.
that is 100% of a ranked mastery answered from cache, and a lead of roughly 2.5 to 4 s over our own pipeline. faster reverse engineering cannot close that gap, because the cached submit never does any. the edge grew with the bundle: on day 4, with a small artifact, our honest time trial took 0.9 s and the cached submit 1.07 s, so there was nothing to gain; by day 18 the bundle was 32 mb.
it also compounded. the cache never went stale because carried members were never re-rolled, so each day added about twelve fields to learn and kept the other 95%. for anyone who had noticed, the binary ranked board measured cache coverage and network round trip. we never reached that position in the race: on days 20 and 21 we played only time-000, which none of the first three ranked masteries (indices 017 to 031) reuses.
what we reported that day
our day 21 report named the three properties (the printed index, mastery as time trial, the cumulative carry) and proposed three fixes. fix a: embed a random per-attempt nonce in the delivery, store it server side, and require it back as one extra answer. fix b: stop printing the index, and generate each pool from a fresh seed keyed on day, tier and attempt. fix c: refuse a timed submit whose attempt never redeemed its download capability. fix a is the cheapest and leaves the puzzle untouched; a cached set from another attempt carries the wrong nonce:
def grade(attempt_id: str, answers: dict[str, str]) -> str:
# the nonce was random per attempt (never f(index)) and lives in the delivery
if answers.get("attempt_nonce") != load_expected_nonce(attempt_id):
return "incorrect" # not derived from this delivery
return grade_real_fields(attempt_id, answers)
day 22: the index went dark
we retested on day 22. across 42 day-22 deliveries (6 time trial, 36 mastery), every archive comment was empty and member names had lost their index (d01--variant-000.elf became d01--sample.elf). that was the "stop printing the index" half of fix b. the rest stood: keyed by slot rather than filename, all 25 of day 21's slots reappeared on day 22 holding a day-21 byte value; 30 delivery pairs were byte-identical outside d01, with all 252 non-d01 graded fields equal; and there was no nonce. the pool was small, too: in 42 draws d01 showed 14 distinct values, d02, d04 and d10 15, and every other carried slot 8. ignoring d01, the 42 deliveries held 21 distinct answer sets, each repeating up to four times. hiding the label did not change what was behind it.
day 23: the values were re-seeded
the next day the timed tiers changed again, and our saved answers show it. config values that read BR02-000 in each of our index-0 time trials through day 22 became seeded hex (BR02-7E52B17C on day 23), and the share of fields matching the day before fell from 93.6% to 40.6% (the carry chart above follows it to day 31). what still matched was structural (format, machine, architecture); every carried member's main sha256 and every config value changed, so no cached set could pass. on day 28, more than 600 answer hex tokens matched no hash of the attempt id, artifact hash, capability, start time or deadline (a server-secret seed), and no ranked variant repeated across 3,009 saved assignments. we did not rerun the mastery-versus-time-trial check on any later day, so that half is not re-established either way.
smaller lookaheads
an enum that listed tomorrow's roles
the script lane's role questions offered their answer vocabulary as an enum. on day 2 it already held eleven roles, including relay, persistence_descriptor and advanced_syntax. none was graded yet: relay first appeared as an answer on day 5, the other two on day 7. an offered value that had never been graded was a forecast, and we prepared for it as one.
the opposite bug: a label nothing could derive
on day 17 the binary single asked where two older tags stored their configuration (hcfg_storage). we had 202 of 204 fields by +175 s; the last two took until +6067.5 s and 1,839 rejected values, because nothing in the artifact named the expected word. the organizer confirmed a challenge bug and turned the free text into an enum with published rules (base64, raw_hcfg_section, wasm_data_segment, raw_const_array, raw); see decoder ring. prediction is a shortcut when the answer is derivable; when it is not, it is a slow way to find a bug.
template answers on the single, through day 31
the untimed single always served variant 000, and its config fields followed a template the day number fills in. day 31's binary single (final boss) accepted BR31-000, gauntlet-000.day31.example.invalid, Global\HuntressBR31-000 and https://gauntlet-000.day31.example.invalid/final/BR31-000. the template drifts: the host word and path follow the theme (node and api, campaign and stage, gauntlet and final), older tags join the mutex with an underscore (Global\HuntressBR02_000), and day 28 added an FF prefix (FF28-000). on day 28, 136 binary single fields matched it with no miss. day 31's single had 434 fields: 420 carried unchanged from day 30's, and 8 of the 14 new ones were template-shaped. it stayed open to the last day and gained little: every tier kept fields only the bytes answer (each member's sha256) and the timed tiers used seeded values (BR31-A722A4BE).
lessons for challenge designers
- bind the answer to the download. one random per-attempt value read out of the bytes kills every cache and costs an honest solver one field; or refuse a timed submit whose attempt never pulled its bytes.
- seed per day, tier and attempt from a server secret, and re-roll carried members. day 23 shows it works.
- never print the index: not in a comment, a filename, or a counter that maps to it (
unique_attempts_remainingwas one). - hash what is graded. a hash over the wrapper hid the reuse.
- every answer from the source. an enum ahead of grading is a forecast; a label nothing in the artifact names is a guessing contest.
{generated by a clanker}