dot com: morse that spells hex, and a schedule with a hole
huntress ctf 2026, day 16 · warmups · all three modes
tools used: decoding engine, replay fixtures and regression tests and timed-attempt pipeline.
the prompt: "sixteen little symbols are calling. dot dot dot." the single and the time trial were one line of morse code; the mastery was a zip of 78 blobs, each with sixteen numbered lines, the sixteenth in the same form.
the key insight: the sixteen symbols are the hex digits, and morse has a code for each of them, ten digits and the letters a to f. the line is morse whose text is hex, so decoding is two steps: morse, then hex. the mastery failed for a reason that had nothing to do with the day's codec: day 15's codec had never been written into the decoder's line schedule, so each sixteen-line blob had two lines the schedule did not cover, and the decoder handles one.
challenge shape
single 1 field one morse line
time trial 1 field one morse line
mastery 78 fields 78 blobs of 16 numbered lines, line k in day k's form
the field is message (setK.message in mastery): "decode the assigned blob completely. what exact answer slug does its final non-empty decoded line instruct you to submit?" the question's own syntax: "three lowercase words separated by hyphens, followed by a hyphen and a two-digit number; submit the slug only", so word-word-word-NN, trimmed.
artifact anatomy
a hex digit is one of sixteen symbols, and international morse has a code for every one of them: five-symbol codes for the digits, short codes for the six letters.
0 ----- 1 .---- 2 ..--- 3 ...-- 4 ....-
5 ..... 6 -.... 7 --... 8 ---.. 9 ----.
a .- b -... c -.-. d -.. e . f ..-.
the text is written as hex, two digits a byte, and every hex digit is written as its morse code, separated by single spaces. a five-letter word becomes fifty symbols of morse.
each mastery blob is the message cut into sixteen chunks, one per day so far:
01<TAB>chunk in base64 (day 1)
02<TAB>chunk in rot13 (day 2)
...
14<TAB>chunk in caesar +7 (day 14)
15<TAB>chunk in rot47 (day 15)
16<TAB>chunk in morse of hex (day 16)
extraction method
the one-line modes need nothing new. the breadth-first peel tries every transform on the text; morse yields a string of hex digits that reads as nothing, and the goal (english with a slug on the last line) rejects it, so the search goes one level deeper and hex yields the sentence.
the mastery reads by position. line k has been in day k's codec on every day so far, so the engine keeps that schedule as a table, reads every line the table covers by its row, and searches only the one line past it. as of day 16 a row can name a chain of steps:
DAY_CODECS = (
"b64", "rot13", "hex", "bin", "dec", "oct", "url", "escapes", "jsonstr",
"b32", "b64url", "reverse", "atbash", "rot19", "rot47", "morse>hex",
)
def day_codec(name, chunk):
for step in name.split(">"):
chunk = transform(step)(chunk)
return chunk
the table the day started with ended at rot19: fourteen rows. day 15's rot47 line had been the one line past the table, and the new-line search found it on every blob, so every day 15 mode passed and nothing failed that would have forced the row in. on day 16 the same line was no longer the last one. two lines past the table is more than the positional reading accepts, so it returned nothing and the whole-message beam (day 8) took over.
validation and answer formatting
the positional reading is accepted only when the joined text ends in a dictionary slug. the beam scores letter pairs across the whole message and has no such anchor per line: it misread short chunks (line 14's rot19 among them) and glued the pieces into slugs that were not words. 16 of the 78 blobs raised "no per-line decoding meets the goal"; most of the slugs it did produce were flagged low confidence and were wrong.
the answer is the slug as written in the decoded sentence.
failed approaches and pivots
the cause was found from the saved run: lines 14 to 16 of a failing blob, read one by one, were rot19, rot47 and morse spelling hex, and only the last two were outside the table. the fix was the two missing rows, rot47 and morse then hex as one transform (the a>b chain form above came the same day), made while the attempt's clock was still running; the corrected decoder read all 78 blobs in a third of a second and the attempt passed.
the lasting fix is not the two rows but a check that makes a missing row fail. every search that stands in for a table row now records the row it replaced, and the end-of-day regression replay fails on any such record (see the table check). had the check existed on day 15, that day's own mastery fixture would have failed with exactly the missing rot47 row: replayed against the morning's table, it does.
automation across modes
the single and the time trial went through the whole-line peel. the mastery reads all 78 blobs by position with the sixteen-row table. with only the rot47 row added and line 16 left to the search, the saved run's 78 blobs decode in half a second; with both rows nothing is searched. a seventeenth line on the next day will be about six characters long, so the new-line search now ranks its readings by the words earlier slugs used and goes on past the first match until a reading's slug is made of them (see day 16 additions).
lessons
- a lookup table that a search fallback quietly covers is a table nobody maintains. make the fallback record the row it stood in for, and fail a regression run on that record.
- "the search found it" and "the table has it" are different facts; the first stops being true the day another line is added after it.
- sixteen symbols is hex, and morse has a code for each one.
- a failure report cut to a fixed length should lead with the lines the fast path did not read; listing lines in order buried the three that mattered.
solve times
public scoreboard · day 16 finish: 1st
- 0:04.1single#2 of 189 solvers
- 0:06.6time trialfirst blood, +0.71 s
- 1:02.1mastery#7 of 176 solvers
- #1team day finishof 162 teams that cleared it, in 1:02.1
- #2single 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 | 1.5s | 1 | 0 |
| time trial | 0.9s | 1 | 0 |
| mastery | 54.4s | 1 | 87 |
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.9s | 29.1s |
| mastery | 95.0s | 54.4s | 40.6s |
where we got stuck
- the mastery: the solver spent 17.6 seconds on the beam, crashed on 16 of 78 blobs and answered most of the others wrongly; the 87 wrong submits were those slugs and their other written forms. the fixed table read every blob, and the attempt passed 54.4 seconds in with 40.6 seconds left.
- the failure report lists each line's best reading in line order and is cut at a fixed length; the cut fell after line 10 of 16, so the three lines that mattered were not in it, and seeing them took a replay of the saved run, about 14 seconds. the report now leads with the lines the table did not read.
- the real stall was a day earlier: the day 15 line never became a table row, because nothing failed without it.
flags: single, time trial, and mastery [redacted].
{generated by a clanker}