a little based: deterministic base64 peeling
huntress ctf 2026, day 1 · warmups · all three modes
tools used: decoding engine and timed-attempt pipeline.
the first warmup delivered a blob.txt whose visible content looked like a conventional base64 string. decoding exposed prose ending in a value of the form word-word-word-NN; that slug, not the prose around it, was the answer.
the key insight was to detect the answer by its structure and to peel until that structure appears, rather than assuming a fixed number of layers.
artifact anatomy
the single's blob.txt is one line of standard base64, padded with =. one decode yields the sentence every warmup of the event carries, with the slug as its last word:
Nice work decoding this warmup! To solve, submit this exact answer to the Game Master: <slug>
the prompt named the encoding: "everyone has to start somewhere. i hear sixty-four is a good base." our solver also peels further base64 layers in case a variant stacked them; no day-1 blob did.
extraction method
the manual check is one command:
base64 -D < blob.txt
the automated version repeatedly applies strict base64 decoding and stops when the next layer is no longer valid, then searches for the slug:
import base64
import binascii
import re
SLUG = re.compile(rb"[a-z]+-[a-z]+-[a-z]+-\d{2}")
def b64_decode_all(data: bytes) -> bytes:
current = data.strip()
for _ in range(10):
try:
current = base64.b64decode(current, validate=True)
except binascii.Error:
break
if not re.fullmatch(rb"[A-Za-z0-9+/=\s]+", current.strip() or b"x"):
break # plaintext reached: stop peeling
return current
slug = SLUG.search(b64_decode_all(open("blob.txt", "rb").read())).group().decode()
validation and answer formatting
the question's syntax text states the form: "three lowercase words separated by hyphens, followed by a hyphen and a two-digit number; submit the slug only", with trim normalization. the answer is that slug with nothing around it, copied as decoded. strict validation matters for the decode loop too. a permissive decoder can discard punctuation and produce plausible garbage, so the loop would travel past the real plaintext; the decoder therefore rejects malformed input, requires non-empty text, and limits depth.
failed approaches and pivots
nothing failed on the single, but the slug regex alone is a weak goal: on day 2 a rot13 layer produced text that also matched it. the decoder's goal later became "a slug on the final line of text that reads as english", which is the version every later warmup uses.
automation across modes
the timed modes changed delivery rather than the encoding. starting the attempt selects the timed artifact, so the solver starts before fetching. mastery assigned three fields, set1.message to set3.message, one blob per set, and each blob was a single numbered line: 01<TAB> followed by the base64. the number and tab must come off before decoding (a strict decoder rejects the tab); that NN<TAB>chunk line is the format every later mastery grew one line a day. every slug was computed locally and the set answered in one submit. the parser itself stayed a pure function of the blob.
lessons
- detect the answer by structure, not by copying a particular specimen.
- keep transport and parsing separate: a pure parser is deterministic and testable; timing, retries and set mapping belong to the pipeline.
solve times
public scoreboard · day 1 finish: below top 10
- 2h28msingle#110 of 741 solvers
- 2h48mtime trial#97 of 627 solvers
- 2h56mmastery#97 of 592 solvers
- #54team day finishof 358 teams that cleared it, in 3h04m
- #1single orderof the day's 5, 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 our first start of the mode to its flag; earlier preparation was not recorded.
| mode | work to flag | attempts | wrong submits |
|---|---|---|---|
| single | 2m47s | 1 | - |
| time trial | 1s on the clock (prep not logged) | 1 | - |
| mastery | 5s on the clock (prep not logged) | 1 | - |
the clock
server timer of the winning attempt; used is attempt start to flag, left is what remained on the clock. day 1-2 deadlines were not logged per attempt.
| mode | time available | time used | time left |
|---|---|---|---|
| time trial | not recorded | 1.1s | not recorded |
| mastery | not recorded | 5.2s | not recorded |
where we got stuck
- day 1 was our first contact with the platform: the team started several hours after release because the tooling was still being built, so these times measure work, not the race.
- nothing in the decode itself stalled us; the single took longest because the slug convention (
word-word-word-NN) had to be learned before it could be automated.
flags: single, time trial, and mastery [redacted].
{generated by a clanker}