stripped: one program built twice, and a role in the field name
huntress ctf 2026, day 15 · binary reverse engineering · all three modes
tools used: binary analysis toolkit and timed-attempt pipeline.
the prompt: "no symbols. no names. just raw assembly and the calling conventions it can't hide. reconstruct the stripped functions from the instructions alone — the stack never lies." the cumulative bundle gained a fifteenth day tag, and this time the tag held two files: the same c program linked once with its symbol table and once without.
the key insight: nothing about either elf was new. every value the day asked for was a field our readers already produced; what was new was that the field name chose the file. d15_analysis_stripped_machine is the ordinary machine of the member whose name says stripped.
challenge shape
single 150 fields one bundle, tags d01-d15
time trial 150 fields a fresh bundle
mastery 750 fields five bundles
the day 15 fields:
d15_artifact_sha256_1, d15_artifact_sha256_2
d15_analysis_stripped_{architecture,format,machine}
d15_analysis_symbolized_{architecture,format,machine}
d15_analysis_stripped_config_{campaign,domain}
artifact anatomy
d15--variant-NNN-symbolized.elf 64-bit elf, .symtab + .strtab present
d15--variant-NNN-stripped.elf the same code, no .symtab
both keep .eh_frame_hdr and .eh_frame, and both carry the configuration section the lane has read since day 2. stripping removes names, not the unwind table: every function with unwind info still has its start address in .eh_frame_hdr.
extraction method
a field dNN_analysis_<role>_<field> is routed when three things hold: the full name is not a field a producer answers by itself, <field> is one, and <role> names exactly one member of the tag that has a sibling whose name differs by that word alone.
def _role(files, tag, name): # the day-15 form: a one-word role
head, _, rest = name.partition("_")
if not rest or _named(name) or not _named(rest):
return None
tagged = {rel: b for rel, b in files.items() if _tag_of(rel) == tag}
found = roles(head, tagged) # one member named by the word,
return (rest, tagged[found[0].member]) if found else None # with a sibling
roles compares file stems without their extensions: d15--variant-000 plus stripped and the same stem plus symbolized are siblings, so the word stripped names one member. a later day extended the rule to roles of two or three words.
the sibling test is what keeps ordinary names safe: main_class with members Main.class and Other.class would otherwise read as role main plus field class, so a name a producer already answers is never a role.
validation and answer formatting
the machine fields were asked as integer ("base-10 integer with no units"), so they are the elf header's e_machine number (struct.unpack_from("<H", b, 18)[0] on a little-endian elf, the value readelf -h prints as "advanced micro devices x86-64"), not the architecture label earlier days graded. the label spellings were rejected on both machine fields: x86-64, x86_64, EM_X86_64 and eight more case and separator variants each. the architecture and format fields stayed exact_text and took the labels x86-64 and elf for both members. the two sha-256 fields follow archive order, not the role words: on the single the symbolized build came first. the role words are read from the member names, never from the archive order or the variant number, and a word that names no single member raises instead of picking one.
failed approaches and pivots
on the day the routing did not exist: the eight fields crashed, and values read by hand won the single a minute in. label spellings of the machine went to the integer fields first, all rejected; the integer won. the timed modes then waited for the solver to learn the routing.
automation across modes
the time trial and the mastery carry other variant numbers and the members in other orders; the role word picks the same member in each. the same rule covers any pair of builds told apart by one word in their names.
lessons
- when a bundle holds two builds of one program, read the field name for which one it means before reading anything else.
- a question's answer kind outranks the vocabulary of earlier days: an
integermachine is the header number. - stripping removes symbols, not unwind tables:
.eh_frame_hdrstill lists every function start.
solve times
public scoreboard · day 15 finish: top 10
- 1:02.7single#2 of 180 solvers
- 2:23.8time trial#12 of 173 solvers
- 2:31.2mastery#12 of 173 solvers
- #4team day finishof 163 teams that cleared it, in 2:31.2
- #5single 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 | 1m00s | 1 | 22 |
| time trial | 2.2s | 1 | 0 |
| mastery | 6.1s | 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 | 80.0s | 2.2s | 77.8s |
| mastery | 320.0s | 6.1s | 313.9s |
where we got stuck
- the single: the automated run answered all but eight of 150 fields and crashed on the eight role fields; reading each member by hand and sending the machine as an integer won it after a minute. the 22 wrong submits were label spellings of the machine sent to the integer fields.
- the timed modes started 78 seconds after the single's flag: that is how long the routing took to reach the solver. each timed mode then took a few seconds.
flags: single, time trial, and mastery [redacted].
{generated by a clanker}