under pressure: a compressed line inside a familiar wrapper

huntress ctf 2026, day 21 · warmups · all three modes

tools used: decoding search engine and timed-attempt pipeline.

the prompt said it in two sentences: "a familiar wrapper. something compressed inside." the wrapper is base64, the oldest encoding of the event, and inside it is a gzip member. the single and the time trial are one such blob each; the mastery is a zip of 103 blobs of twenty-one numbered lines, one line per day of the event, whose newest line is the same base64-of-gzip.

the key insight: compression under a text encoding is one more step in the same search, not a new kind of problem. the search already knew a base64-then-decompress step; the day's work was naming it as the line schedule's twenty-first row so the next day's line is again the only unknown.

challenge shape

single         1 field    the slug one blob's decoded text instructs
time trial     1 field    the same, a fresh blob
mastery      103 fields   one slug per blob, 103 blobs of 21 numbered lines

the field is message (setK.message in mastery).

artifact anatomy

the single's blob is base64; decoded, it starts with 1f 8b 08 (a gzip member: magic, then method 8, deflate) and ends with the crc-32 and the length of the decompressed text. the text is one instruction line. in the mastery, each blob is NN<tab>chunk lines; line k is encoded by day k's encoding, and line 21 is the same base64-of-gzip around one chunk of the message.

extraction method

the decoding engine peels a whole blob step by step (the single, the time trial) and, for numbered lines, reads line k by day k's row first and searches only a line past the schedule. both try the cheapest readings first, scored against the slug the question describes. the reading that matched is b64inflate: a strict base64 decode, then each decompressor in turn (zlib first, then gzip, then the rarer wrappers), the first that decompresses cleanly read as text. the stdlib equivalent for the two framings that mattered on days 21 and 22:

import base64, zlib

raw = base64.b64decode("".join(chunk.split()), validate=True)
for wbits in (15, 31):     # zlib header, then gzip; wbits=47 takes either in one call
    try:
        text = zlib.decompress(raw, wbits).decode("utf-8")
        break
    except zlib.error:
        continue

validation and answer formatting

gzip carries its own checksum and length: a member that decompresses and passes its crc-32 is the payload, one that does not is not a reading. the slug shape the question states ("three lowercase words separated by hyphens, followed by a hyphen and a two-digit number; submit the slug only") then decides which reading is the message.

failed approaches and pivots

none on the day. the schedule had read line 21 by search, which is correct but leaves the row unnamed; a line read by anything but its row is flagged, so the row is now b64inflate, and the prompt's words (compressed, inflate, deflate, zlib, pressure) hint it first.

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.

lessons

solve times

public scoreboard · day 21 finish: below top 10

  • 0:02.5single#2 of 179 solvers
  • 0:04.1time trial#2 of 171 solvers
  • 0:06.6mastery#2 of 167 solvers
  • #36team day finishof 146 teams that cleared it, in 27:16.2
  • #2single orderof the day's 8, 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.1s 1 0
time trial 0.5s 1 0
mastery 1.3s 1 0

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 0.5s 29.5s
mastery 120.0s 1.3s 118.7s

where we got stuck

flags: single, time trial, and mastery [redacted].

{generated by a clanker}