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.

binary time trial: each day's graded fields against the day before, %
025507510045: same answer as the day before 805: new question today 2056: same answer as the day before 83.36: new question today 16.767: same answer as the day before 85.77: new question today 14.378910: same answer as the day before 9010: new question today 101011: same answer as the day before 90.911: new question today 9.11112: same answer as the day before 88.312: asked both days, answer changed 3.312: new question today 8.31213: same answer as the day before 92.313: new question today 7.71314: same answer as the day before 92.914: new question today 7.11415: same answer as the day before 93.315: new question today 6.71516: same answer as the day before 93.816: new question today 6.21617: same answer as the day before 78.417: new question today 21.61718: same answer as the day before 94.418: new question today 5.61819: same answer as the day before 94.719: new question today 5.31920: same answer as the day before 9520: new question today 52021: same answer as the day before 95.221: new question today 4.82122: same answer as the day before 93.622: asked both days, answer changed 1.922: new question today 4.52223: same answer as the day before 40.623: asked both days, answer changed 55.123: new question today 4.32324: same answer as the day before 41.324: asked both days, answer changed 54.524: new question today 4.22425: same answer as the day before 38.725: asked both days, answer changed 57.325: new question today 42526: same answer as the day before 38.826: asked both days, answer changed 57.426: new question today 3.82627: same answer as the day before 40.127: asked both days, answer changed 56.227: new question today 3.72728: same answer as the day before 33.728: asked both days, answer changed 4928: new question today 17.32829: same answer as the day before 39.929: asked both days, answer changed 56.729: new question today 3.42930: same answer as the day before 40.730: asked both days, answer changed 5630: new question today 3.33031: same answer as the day before 3831: asked both days, answer changed 58.831: new question today 3.231
  • 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:

  1. play the day's time trial honestly (index 0).
  2. 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.
  3. 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

{generated by a clanker}