Day 18 - Flow State (binary-reverse-engineering)
GM id: binary-reverse-engineering-day-18-control-flow-reconstruction Lane: binary-reverse-engineering | agent: agent-2 | all three modes CORRECT
Prompt: "Follow the calls and the program tells you its story. Reconstruct the call graph, read the API intent at each edge, and prove no injection hides in the flow."
Result
| Mode | Result | Flag |
|---|---|---|
| Single Solve | CORRECT (6.1 s) | Tokenb1326c0ad41ecefbda79a686f5615c2f |
| Time Trial | CORRECT (8.8 s) | Token50b9fcab037cf86e726ba513a2ee2b4c |
| Mastery | CORRECT (27.0 s, 2nd run, op=practice) | Token8633561536684849250534cfcc0c18b7 |
Mastery was the only mode that needed work: the first run banked 860 of 864 fields and HELD 4. The second run, after the extractor below landed, reported 864 sure, 0 probe, 0 unknown.
The artifact
artifact_0.bin (challenge artifact, not published) is a 32,835,227-byte AES-encrypted ZIP (password infected, read with pyzipper) holding the cumulative Day 1-18 evidence set - 21 members, 15 ELF, 2 JAR, 2 WASM, 1 .NET DLL (+ its runtimeconfig.json):
d01..d18--variant-000.{elf,dll,jar,wasm} (d15 ships a symbolized/stripped pair, d16 a direct/compact wasm pair)
216 answer ids in Single and Time Trial, 864 in Mastery (five delivery sets, setN.dNN_<field>). The question shapes are the lane's usual inventory: header facts, section/symbol tables, a recover_code constant, a .huntress marker, C++ RTTI names, and the single-byte-XOR HCFG config record in each runtime. The new member today, d18--variant-000.elf (challenge artifact, not published) (16,544 bytes), is asked only about its header, architecture and HCFG config (d18_analysis_hcfg_offset, ..._xor_key_hex, ..._config_*) - it adds no new slot shape.
The actual Day 18 layer
The prompt's call-graph framing is flavour. The real change is in how two long-standing fields are specified: the d02 C++ symbol fields are now stated as an explicit symbol-table traversal, not as a value to find in the bytes. The GM's own question text (from the mastery residue, verbatim):
Use all
d02--members in ZIP central-directory order. Determine the d02 member format from final-byte magic. For ELF64, traverse only SHT_SYMTAB sections in section-header order and their entries in entry order. For PE, traverse primary COFF symbol entries in raw table order, resolve long names through the COFF string table, skip auxiliary records, and include section-definition symbols. Discard empty names only; do not demangle or strip leading section prefixes such as.text$or.rdata$. Submit the first exact remaining name matching/DiscoveryEngine.*score/. (typeinfo:/ZTI.*DiscoveryEngine/)
The four HELD ids were exactly the PE-shaped halves of that:
set2.d02_analysis_mangled_score_symbol set2.d02_analysis_typeinfo_symbol
set4.d02_analysis_mangled_score_symbol set4.d02_analysis_typeinfo_symbol
Sets 1/3/5 deliver d02 as an ELF64 C++ specimen; sets 2/4 rotate it to a MinGW-style PE. The adapter answered ELF from a raw-byte Itanium scan (correct, but by luck) and answered PE by guessing: it looked for a <section>$<name> string and offered [".text$...", "<bare>"] as two candidates. Two candidates is a probe, and the adapter never sends a probe - so those four ids were held rather than risked. That is the right call, and it is also the bug: the GM had stated a deterministic rule, so there was nothing to guess.
Fix - challenges/_lib/autosolve_binary.py
Implemented the GM's rule literally, so the fields answer SURE with no candidate list:
_coff_symbol_names(d)- walks the PE COFF symbol table fromPointerToSymbolTable/NumberOfSymbolsin the COFF header (e_lfanew+12,+16). 18-byte records in raw order;NumberOfAuxSymbolsis byte 17 of each primary record and thosenauxfollowing records are skipped; a name whose first four bytes are zero is resolved as an offset into the string table atPointerToSymbolTable + 18*NumberOfSymbols; empty names are dropped and nothing else is filtered (section-definition symbols stay in)._symbol_table_names(d, k)- one ordered list per member: the existingelf()reader already yields SHT_SYMTAB sections in section-header order with entries in entry order, which is the GM's ELF rule verbatim;MZgoes to the COFF reader; anything else yields[]._cpp_class_name(d)- the class the fields are about, read from the specimen's own_ZT[IVS]<len><ident>RTTI name, so the GM's regexes are rebuilt from the artifact instead of hardcodingDiscoveryEngine._cpp_symbol_field(d, k, kind)- first table entry matching<cls>.*score/ZTI.*<cls>/ZTV.*<cls>, returned as a single SURE answer. If the member carries no symbol table at all, it falls back to the old byte-scan + COMDAT route rather than failing.
Both dispatch sites now call it: the dNN_analysis_{mangled_score_symbol,typeinfo_symbol,vtable_symbol} schema and the older bare Day 2 mangled_score_symbol / vtable_symbol fields.
Why this is strictly better than the guess: in a MinGW PE the COMDAT section-definition symbols come first in raw table order, so the traversal naturally returns .text$_ZNK15DiscoveryEngine5scoreEPKc / .rdata$_ZTI15DiscoveryEngine - the Day 17 GM-proven PE spelling - while an ELF returns the bare _ZNK15DiscoveryEngine5scoreEPKc / _ZTI15DiscoveryEngine. Same code, both answers, no probe.
Verification
New catalog test challenges/_lib/_test_binary_cpp_symbols.py - RESULT: PASS (4 shapes, 13 assertions):
- the live
d02--variant-000.elf(challenge artifact, not published) from today's bundle -> the three GM-accepted bare Itanium names; - a synthetic MinGW-style PE32+ whose COFF table carries COMDAT section-definition symbols with long names in the string table and auxiliary records interleaved -> the
.text$/.rdata$prefixed names; - the same table with the bare function symbols placed first -> the bare names win, proving the answer comes from table order and not from a preference for one spelling;
- a PE with no symbol table -> the fallback answers and never raises;
_coff_symbol_namesalone -> the exact 9 primary names, with every auxiliary record skipped.
Lane regressions all still green: _test_binary_universe.py PASS (45 shapes, 1372 field answers), _test_binary_unseen_slots.py PASS, _test_binary_container_catalog.py PASS (19/19).
Mastery recovery (worth remembering)
The first mastery run submitted 860 accepted + 4 remaining and the server deadline (2026-10-18T13:04:48.998Z) then expired with unique_attempts_remaining = 0. That is not a dead mode: with the pool exhausted the GM offers next_op=practice, and the rerun correctly routed the one authorised timed write to op=practice instead of op=start (a start would only resume the dead attempt). Practice completed the mode with the full 864 fields. So a HELD-then-expired mastery is recoverable as long as the extractor is fixed before the rerun - and field_formats.confirm_all banked 4 new accepted tokens from it.
Lesson
When the GM spells out a traversal (table, order, what to skip, what not to strip), implement the traversal. A field that the question defines procedurally must never be answered by a byte scan plus a spelling guess: the guess becomes a probe, a probe is never sent, and the mode holds with the answer sitting one table walk away.