deflated ego: a zlib line, and a slug that ran past its shape
huntress ctf 2026, day 22 · warmups · all three modes
tools used: decoding search engine, replay and analysis and timed-attempt pipeline.
"another familiar wrapper. this one needs a little inflation." day 21 hid the message in base64 of a gzip member; day 22 hid it in base64 of a zlib stream. the single and the time trial are one such blob each; the mastery is a zip of 108 blobs of twenty-two numbered lines, one line per day of the event, whose newest line is the same base64-of-zlib.
the key insight: a reading that a checksum verifies must never lose to a reading that merely fits the answer's expected shape. one mastery blob's message ran past the slug shape the question describes, and a search that wanted that shape picked a garbage reading of the last line to get it.
challenge shape
single 1 field the slug one blob's decoded text instructs
time trial 1 field the same, a fresh blob
mastery 108 fields one slug per blob, 108 blobs of 22 numbered lines
the field is message (setK.message in mastery).
artifact anatomy
the single's blob is base64; decoded, it starts with 78 9c (a zlib header: deflate, a 32k window, check bits that make the first two bytes a multiple of 31) and ends with the adler-32 of the decompressed text. in the mastery each blob is NN<tab>chunk lines: one message of about 110 characters split evenly over 22 lines, line k encoded by day k's encoding. line 21 is base64 of gzip, line 22 base64 of zlib.
extraction method
the decoding engine reads line k by day k's row first and searches only a line past the schedule. the zlib line needed no new transform: b64inflate, added for day 21's gzip line, does a strict base64 decode and then tries the decompressors in turn, zlib first, then gzip, reading the first clean result as text. in stdlib terms:
raw = base64.b64decode("".join(chunk.split()), validate=True)
text = zlib.decompress(raw).decode("utf-8") # zlib header; wbits=31 for gzip
validation and answer formatting
the question states the slug's shape ("three lowercase words separated by hyphens, followed by a hyphen and a two-digit number; submit the slug only"), and the search used that shape to tell a right reading of the newest line from a wrong one. that worked for 107 of 108 mastery blobs. in one, the decoded message ran on past the slug for a few more characters, all of it from a zlib stream whose adler-32 checked. the shape check (nothing may follow the slug but a word boundary) refused that reading, and the next search tier read line 22 as reversed base64, which left a shaped slug followed by = and garbage. that shaped slug was rejected in every form.
the fix: a slug followed by more -token groups counts as found, so the verified reading wins; the answer goes out as two candidates, the whole token first and its shaped prefix second, both tried in the same attempt. a timed attempt later on day 22 held two such blobs, and the grader took the whole token both times.
core = shape.pattern.removesuffix(r"(?![A-Za-z0-9-])")
extended = re.compile(core + r"(?:-[a-z0-9]+)+(?![A-Za-z0-9-])")
failed approaches and pivots
the first fix was a handler that appended the whole token to the candidates for that one challenge; the tier was flagged on the next attempt, whose fresh bytes had no such blob, so the handler's candidate was never graded. the general rule replaced it the same day, and the later timed attempt confirmed it. the pattern showed up only in timed attempts, 3 of the 432 timed mastery blobs we saw on day 22, and in none of the 3,706 untimed blobs we pulled for testing that day: testing on untimed variants alone would not have found it.
automation across modes
the same engine reads the single and time-trial blobs and every mastery blob; in the mastery only a line past the schedule is searched, and now a message that runs past the expected shape is answered with both readings.
lessons
- a checksum (adler-32, crc-32) is evidence; a regular expression is a hypothesis. when they disagree, keep the verified bytes and offer the shaped form second.
- an answer that does not fit the question's own shape is not "low quality": it is information the shape did not anticipate.
solve times
public scoreboard · day 22 finish: below top 10
- 0:03.4single#3 of 177 solvers
- 0:06.6time trial#3 of 170 solvers
- 3:59.6mastery#42 of 166 solvers
- #26team day finishof 145 teams that cleared it, in 10:39.5
- #2single orderof the day's 7, by our flag time
from the public scoreboard: 09:00 et release to our flag; the table below counts from our attempt's start.
from when we started working on the mode to its flag.
| mode | work to flag | attempts | wrong submits |
|---|---|---|---|
| single | 1.5s | 1 | 0 |
| time trial | 1.1s | 1 | 0 |
| mastery | 231.9s | 2 | 18 |
the clock
server timer of the winning attempt; used is attempt start to flag, left is what remained on the clock.
| mode | time available | time used | time left |
|---|---|---|---|
| time trial | 30.0s | 1.1s | 28.9s |
| mastery | 125.0s | 0.9s | 124.1s |
where we got stuck
- mastery: 107 of 108 blobs were accepted in the first attempt; the one blob whose message ran past the slug shape was rejected in every form of the shaped slug. finding the cause took minutes of looking at that blob by hand, because the solver had reported its wrong reading as confident. a second attempt on fresh bytes flagged in 0.9s; the mastery's 231.9s runs from the first attempt's start to that flag. the 18 wrong submits all belong to the first attempt and that one blob, whose shaped slug was rejected in 10 written forms.
flags: single, time trial, and mastery [redacted].
{generated by a clanker}