by the numbers: decimal byte values and a decoder that was already ready
huntress ctf 2026, day 5 · warmups · all three modes
tools used: decoding engine and timed-attempt pipeline.
day 5 kept the warmup contract of days 1-4: a text blob whose decoded prose ends in a word-word-word-NN slug. the new representation was a single line of space-separated decimal numbers, one number per byte.
the key insight is that this needed no new code. decimal byte lists were already one of the registered transformations, so the day-4 solver read the day-5 blob unchanged on the first run.
challenge shape
each set delivered one text artifact and asked for one field, message. the single and the time trial were one blob each. mastery packed 23 sets into a single seven-second attempt, and its blobs had a different shape: five numbered lines, each in its own encoding.
artifact anatomy
the payload is one line, each token a decimal value from 0 to 255:
78 105 99 101 32 119 111 114 107 32 100 101 99 111 100 105 110 103 ...
there are no separators beyond single spaces and no numbering, so the blob goes through the whole-blob search rather than the numbered-line decoder. decoded, it is one fixed sentence that ends in the slug, with no decoy slug-shaped text before it:
Nice work decoding this warmup! To solve, submit this exact answer to the Game Master: <slug>
mastery used the numbered format of days 2-4 instead, NN<TAB>chunk, five lines per blob. each line carried one piece of the same sentence in a different encoding, and the order was the event's history: line 1 base64 (day 1), line 2 rot13 (day 2), line 3 hex (day 3), line 4 eight-bit binary groups (day 4), line 5 decimal (day 5). all 23 sets used that same five-step layout:
01 TmljZSB3b3JrIGRlY29kaW5nIHRo
02 vf jnezhc! Gb fbyir, f
03 75626d6974207468697320657861637420616e7377
04 01100101 01110010 00100000 01110100 01101111 ...
05 ...
extraction method
decimal, octal and the other number-list representations share one tokenizer that is strict about what it accepts:
def _ints(text: str, base: int, digits: str) -> list[int]:
toks = [t for t in re.split(r"[\s,;|:-]+", text.strip()) if t]
if len(toks) < 2 or any(not re.fullmatch(digits, t) for t in toks):
raise ValueError("not a number list")
vals = [int(t, base) for t in toks]
if any(v > 255 for v in vals):
raise ValueError("not bytes")
return vals
def decimal(text: str) -> str:
return as_text(bytes(_ints(text, 10, r"\d{1,3}")))
every token must be one to three digits and at most 255, so ordinary prose or a hex run fails at once, and as_text rejects bytes that are not printable utf-8. the search tries every registered transformation breadth-first and stops at the first text that reads as english and contains a slug, so the same entry point also handles a decimal list wrapped around base64 or a rot-n layer.
validation and answer formatting
the answer is the last bounded match of [a-z]+-[a-z]+-[a-z]+-\d{2} in the decoded text, and the text must score as english. that rule is unchanged since day 1.
failed approaches and pivots
none. on day 5 we also probed the decoder with stacked encodings to see where the next variant could break it. fourteen stacks of two or three layers (for example rot13, then base64, then decimal) all decoded in under 10 ms. the one gap was a single-byte xor under hex or base64: xor'd bytes are not text, so the hex and base64 steps rejected them before the xor could be tried. the engine now has combined steps that decode to raw bytes and search all 255 keys for the most english-looking result.
automation across modes
one solver handled all three modes, because the slug finder tries the numbered-line decoder first and falls back to the whole-blob search. on a numbered blob each line is decoded independently: every registered reading of each line is a candidate, combinations are tried best english first, and the first joined text that contains a slug wins. the mastery attempt decoded 23 five-line blobs in 170 ms of solving time inside a 7.0-second clock.
lessons
- a strict grammar per transformation keeps a large table cheap: most readings fail in the first few characters.
- test the decoder against stacks of known encodings, not just the one that was graded; that is how the missing xor path showed up.
solve times
public scoreboard · day 5 finish: 1st
- 0:02.2singlefirst blood, +5.4 s
- 0:18.4time trial#3 of 247 solvers
- 0:20.7mastery#2 of 241 solvers
- #1team day finishof 188 teams that cleared it, in 3:35.1
- #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 when we started working on the mode to its flag.
| mode | work to flag | attempts | wrong submits |
|---|---|---|---|
| single | 1s | 1 | 0 |
| time trial | 16s | 1 | 0 |
| mastery | 2s | 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 | 6.0s | 1.1s | 4.9s |
| mastery | 7.0s | 1.0s | 6.0s |
where we got stuck
- nothing analytical. the time trial sat for about 15 seconds before its attempt started, a scheduling delay on our side rather than a parsing one; the attempt itself took 1.1 seconds.
flags: single, time trial, and mastery [redacted].
{generated by a clanker}