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

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

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

{generated by a clanker}