you have a point: a message spelled as unicode code points
huntress ctf 2026, day 25 · warmups · all three modes
tools used: decoding search engine and timed-attempt pipeline.
"every character has a point. a code point, anyway." day 24's newest line was a run of netstrings; day 25's spelled every character of the message as a unicode code point, U+ followed by four hex digits, one token per character, separated by spaces. the single and the time trial were one such line each; the mastery was a zip of 123 blobs of twenty-five numbered lines, whose twenty-fifth line was the same notation.
the key insight: U+0041 is not two hex bytes and not a word. it is the scalar value of one character written the way the unicode standard writes it, and the reading is chr(int(digits, 16)) per token with the space after each token consumed as part of the token. the reader for that notation has existed since day 8, written for browser-side escapes; the line search found it, so the day cost no new reading.
challenge shape
single 1 field the slug one blob's decoded text instructs
time trial 1 field the same, a fresh blob
mastery 123 fields one slug per blob, 123 blobs of 25 numbered lines
the field is message (setK.message in mastery).
artifact anatomy
the single's blob is one line of space-separated tokens, each U+ and exactly four hex digits, one token for each character of the sentence that names the slug. every character is in the basic multilingual plane, so four digits suffice; the notation allows up to six (U+1F600), and a reader that accepts only four would break on the first astral character.
in the mastery each blob is NN<tab>chunk lines: one message split over twenty-five lines, line k encoded by day k's encoding, from base64 on line 1 through day 24's netstrings on line 24 to code points on line 25. the twenty-fifth chunk is short: the message's last few characters, one U+ token each.
extraction method
the decoding engine keeps a registry of readings and searches them breadth-first over a blob until english comes out. one reading, uniesc, covers three spellings of a code point that the general escape reader does not: javascript's \u{...} with one to six hex digits, the %uXXXX form older web servers emit, and the standard's own U+XXXX. a space right after a U+ token belongs to the token, so a whole line of them joins into text rather than into text with a space between every letter.
UNICODE_ESCAPE = re.compile(
r"\\u\{([0-9a-fA-F]{1,6})\}|%u([0-9a-fA-F]{4})|U\+([0-9a-fA-F]{4,6})\s?"
)
def _codepoint(m: re.Match[str]) -> str:
return chr(int(next(g for g in m.groups() if g), 16))
def unicode_escapes(text: str) -> str:
out = UNICODE_ESCAPE.sub(_codepoint, text)
if out == text:
raise ValueError("noop")
return out
the noop error matters: text with no code points in it is refused instead of returned unchanged, so this reading never claims a line it did not decode. (the whole-blob search also keeps a set of the texts it has already seen, so an unchanged text is never expanded twice.)
for the mastery the per-line reader runs each numbered line through the schedule's reading for that day and the search for a line the schedule does not name. line 25 was not in the schedule, so the search read it; the schedule now names the code-point reading as row 25, so that line is read by its row before any search runs.
validation and answer formatting
the decoded sentence must contain a slug of the question's shape, three lowercase words joined by hyphens and a two-digit number; the slug is submitted alone, brave-beacon-wizard-34 for the single, zesty-piano-flint-41 for the time trial and proud-banner-pepper-19, speedy-button-mosaic-37, jaunty-tent-onyx-93 and 120 more for the mastery's 123 blobs. a reading whose output has no such slug is discarded, which is what keeps a false decode (hex digits that happen to be valid base64, say) from being submitted.
failed approaches and pivots
none on day 25.
automation across modes
the same reading answered the single, the time trial and all 123 mastery blobs; the mastery's decode took 0.7 seconds for the 123 blobs.
lessons
- a notation written for humans (
U+XXXX) is a codec like any other; register it with its neighbours (\u{...},%uXXXX) the first time one of them appears, and the others cost nothing later. - a reading that finds nothing to decode should refuse, not return its input: an unchanged line passed off as a reading competes with the real ones.
solve times
public scoreboard · day 25 finish: below top 10
- 0:02.6single#4 of 163 solvers
- 0:05.4time trial#4 of 158 solvers
- 0:08.6mastery#3 of 154 solvers
- #11team day finishof 138 teams that cleared it, in 6:15.3
- #1single 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. attempts counts our solver runs.
| mode | work to flag | attempts | wrong submits |
|---|---|---|---|
| single | 1.1s | 1 | 0 |
| time trial | 0.6s | 1 | 0 |
| mastery | 1.4s | 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.6s | 29.4s |
| mastery | 140.0s | 1.4s | 138.6s |
where we got stuck
- nowhere on day 25: the code-point reading existed since the browser escapes were added, and the line search reached it on the first try.
flags: single, time trial, and mastery [redacted].
{generated by a clanker}