find-CNetChan_SendMessages-inlined
Final-guarantee fallback for the find-CNetChan_SendMessages-inlined preprocessor. Recovers CNetChan::SendMessages (its func_va/func_rva/func_size/func_sig plus CNetChan vtable slot) in CS2 networksyst
SKILL.md.claude/skills/find-CNetChan_SendMessages-inlined/SKILL.md
GitHubFind CNetChan_SendMessages (final-guarantee fallback)
Recover CNetChan::SendMessages in CS2 networksystem.dll / libnetworksystem.so using IDA Pro MCP tools.
This is the Agent fallback for the find-CNetChan_SendMessages-inlined skill. It runs only when the
preprocessor returned failure. The preprocessor's inlined path locates the target by the xref string
"SendMessage reliable failed AllocateMessage (%d).", which actually lives inside the shared helper
CNetChan_SendMessages_Internal — so that anchor identifies the helper's callers, two of which exist
(CNetChan::SendMessages and CNetChan::Transmit). When the sibling -noinline path cannot disambiguate them,
this fallback is what resolves the real target.
Realworld Function References
Read the platform-relevant real-world YAMLs before searching in IDA. They provide concrete disassembly and
semantic anchors for the neighbouring CNetChan vfuncs and document the decoy. Treat their addresses and
offsets as reference-build values only; verify every result against the current binary.
ida_preprocessor_scripts/references/networksystem/CNetChan_ParseMessagesDemo.windows.yamlida_preprocessor_scripts/references/networksystem/CNetChan_ParseMessagesDemo.linux.yamlida_preprocessor_scripts/references/networksystem/CNetChan_ParseMessagesDemoInternal.windows.yamlida_preprocessor_scripts/references/networksystem/CNetChan_ParseMessagesDemoInternal.linux.yamlida_preprocessor_scripts/references/networksystem/CNetChan_ParseNetMessageShowFilter.windows.yamlida_preprocessor_scripts/references/networksystem/CNetChan_ParseNetMessageShowFilter.linux.yamlbin_artifacts/14191/networksystem/CNetChan_SendMessages.windows.yamlbin_artifacts/14191/networksystem/CNetChan_SendMessages.linux.yamlbin_artifacts/14191/networksystem/CNetChan_SendMessages_Internal.windows.yamlbin_artifacts/14191/networksystem/CNetChan_SendMessages_Internal.linux.yamlbin_artifacts/14191/networksystem/CNetChan_Transmit.windows.yamlbin_artifacts/14191/networksystem/CNetChan_Transmit.linux.yamlbin_artifacts/14191/networksystem/CNetChan_vtable.windows.yamlbin_artifacts/14191/networksystem/CNetChan_vtable.linux.yaml
Background — CNetChan::SendMessages and its two-caller trap
CNetChan::SendMessages is the CNetChan virtual that drains the channel's outbound message queue. It is a
thin wrapper: it acquires the channel's CAtomicMutex and then calls the standalone helper
CNetChan_SendMessages_Internal, which does the real work (allocating and transmitting each queued message and
logging "SendMessage reliable failed AllocateMessage (%d)." on failure).
All member accesses are relative to this (arg1: rcx on Windows, rdi on Linux). The vtable is CNetChan;
the function has a body, so its YAML carries both func_* fields and the vtable slot fields.
Decoy — this is the trap that matters.
CNetChan::Transmitalso callsCNetChan_SendMessages_Internal(it flushes the queue as part of suppressing transmit). SoCNetChan_SendMessages_Internalhas exactly two callers, and the shared xref string cannot tell them apart. The preprocessor's-noinlinepath resolves this withexclude_funcs: ["CNetChan_Transmit"]; when that path is unavailable, you must disambiguate here. Use Step 2.
Robustness principle — anchor semantically, not by signature
The old func_sig and the old vtable slot are both rebuild-fragile. Do not rely on either to find the
function. Instead:
- Resolve the helper
CNetChan_SendMessages_Internal(it does own the unique string). - Enumerate the helper's callers — there will be two.
- Separate the real target from
CNetChan_Transmitby the structural fingerprint in Step 2. - Only once the function is confirmed, derive the vtable slot by matching the resolved address against the
CNetChanvtable entries — never by trusting the previousvfunc_index.
Output inventory
struct_name is not used (this is a real vtable vfunc, not an interface indirect vcall). Addresses, offsets and
sizes are reference values from build 14191 — verify against the binary, do not assume.
| # | Output symbol | Kind | Windows | Linux | Writer skill |
|---|---|---|---|---|---|
| 1 | CNetChan_SendMessages |
real vtable vfunc | func_va 0x1800bf650, size 0xad, vtable CNetChan slot 43 / 0x158 |
func_va 0x291cd0, size 0xcb, vtable CNetChan slot 44 / 0x160 |
/write-vfunc-as-yaml |
Platform gating: the symbol is produced on both platforms. The slot differs per platform (Windows 43, Linux 44) — resolve it from the vtable, do not carry a number across platforms.
Step 0. Skip targets already produced
If CNetChan_SendMessages.<platform>.yaml already exists in the analyzer-reported artifact module
directory and parses to a non-empty mapping, skip it — the preprocessor or an earlier fallback wrote it.
Never derive the artifact path from the binary directory; use the directory reported by the analyzer (also
readable as CS2VIBE_ARTIFACT_DIR).
/get-func-from-yaml reports existence for the function (returns an error when absent).
Step 1. Resolve the helper and the candidate set
ALWAYS Use SKILL /get-func-from-yaml with func_name=CNetChan_SendMessages_Internal to get its func_va.
If it errors, the helper has not been produced yet: resolve it first with the sibling
find-CNetChan_SendMessages_Internal skill (its own anchor is the same unique string), because this fallback
depends on it as expected_input. Do not guess.
Then enumerate the helper's callers — the candidate set for the target:
mcp__ida-pro-mcp__py_eval code="""
import idautils, ida_funcs
INTERNAL = 0x290c10 # <-- CNetChan_SendMessages_Internal.func_va
seen = []
for x in idautils.XrefsTo(INTERNAL, 0):
f = ida_funcs.get_func(x.frm)
if f and f.start_ea not in seen:
seen.append(f.start_ea)
for a in sorted(seen):
print(hex(a), ida_funcs.get_func_name(a))
"""
On 14191 this yields exactly two entries (Windows 0x1800bf650 / 0x1800be510; Linux 0x291cd0 / 0x29d1e0).
If more than two appear, still apply Step 2 to each — the fingerprint, not the count, decides.
Step 2. Disambiguate the real target from CNetChan_Transmit (do not skip)
The real CNetChan::SendMessages and the decoy CNetChan::Transmit differ structurally. Verified on 14191:
CNetChan::SendMessagesis the small wrapper (Windows0xad, Linux0xcbbytes). On Windows it callsGetCurrentThreadIdand, only on lock contention, the importedCAtomicMutex::AcquireLock, then calls the helper; on Linux it uses an inlinelock cmpxchg [this+9008h]spin on the same mutex and calls the helper.CNetChan::Transmitis substantially larger (Windows0x1d0, Linux0x2debytes) and is the only one of the two that references the string"%s: CNetChan::Transmit( %s ) while suppressing transmit".
Disambiguate by size and the mutex-acquire prologue, not by a captured address:
- Of the two candidates, the one that is the thinner wrapper — its only call reachable on the non-contended
path is the helper, and its body is dominated by the
CAtomicMutexacquire/release around that call — is the real target. - Positively confirm by checking that the candidate does not reference the
"while suppressing transmit"string. A candidate that does isCNetChan::Transmit.
mcp__ida-pro-mcp__py_eval code="""
import idautils, ida_funcs, idc
TRANSMIT_NEEDLE = "while suppressing transmit"
cands = [0x0, 0x0] # <-- the two candidate starts from Step 1
for addr in cands:
f = ida_funcs.get_func(addr)
has_needle = False
for head in idautils.Heads(f.start_ea, f.end_ea):
for x in idautils.XrefsFrom(head, 0):
try:
tgt = x.to
except Exception:
continue
txt = idc.get_strlit_contents(tgt) if tgt else None
if txt and TRANSMIT_NEEDLE in txt.decode('utf-8', 'replace'):
has_needle = True
print(hex(addr), "size", hex(f.end_ea - f.start_ea), "transmit_string", has_needle)
"""
Scan the whole function body (ida_funcs.Heads over [start_ea, end_ea)), not just the entry
instruction — XrefsFrom at the entry point alone does not see string references made deeper in the body.
The real CNetChan::SendMessages is the candidate with a small size and transmit_string = False.
If both candidates reference the transmit string, or neither is a thin helper wrapper, the build has been restructured beyond these anchors — STOP and report, so the references can be extended. Do not guess.
Step 3. Assign the vtable fields
Once the function start is resolved, look it up in the CNetChan vtable entries:
mcp__ida-pro-mcp__py_eval code="""
import yaml, os, idaapi
d = os.environ.get('CS2VIBE_ARTIFACT_DIR') or os.path.dirname(idaapi.get_input_file_path())
plat = 'windows' if idaapi.get_input_file_path().endswith('.dll') else 'linux'
v = yaml.safe_load(open(os.path.join(d, 'CNetChan_vtable.%s.yaml' % plat), encoding='utf-8'))
ents = {}
for k, x in v['vtable_entries'].items():
ents[int(k)] = int(str(x), 16)
tgt = 0x0 # <-- resolved CNetChan_SendMessages start
idx = []
for k, a in ents.items():
if a == tgt:
idx.append(k)
print('vtable_class', v['vtable_class'])
print('match index', idx, 'offset', [hex(i*8) for i in idx])
"""
Use explicit for loops, not comprehensions: inside py_eval a comprehension body cannot see the enclosing
locals (it raises NameError), whereas a plain loop can.
Set:
vtable_name = CNetChanvfunc_index = <the matching entry index>vfunc_offset = vfunc_index * 8
If the resolved start matches no vtable entry, the function is not the vtable target — return to Step 2. Do not emit the previous build's slot.
The legacy artifact key CNetChan_SendMessages identifies the checkpoint-bounded
sender CNetChan::TransmitUpToCheckpoint. Rename the function accordingly:
mcp__ida-pro-mcp__rename batch={"func":[{"addr":"<start>","name":"CNetChan_TransmitUpToCheckpoint"}]}
Step 4. Generate the signature and write the YAML
ALWAYS Use SKILL
/generate-signature-for-functionwithaddr=<resolved start>to obtain a fresh, validatedfunc_sig. (This is a real function with a body — unlike an interface indirect vcall.)ALWAYS Use SKILL
/write-vfunc-as-yamlwith:artifact_name:CNetChan_SendMessagesfunc_name:CNetChan_TransmitUpToCheckpointfunc_addr: the resolved function startfunc_sig: the signature from step 1vtable_name:CNetChanvfunc_offset:vfunc_index * 8(from Step 3)vfunc_index: from Step 3
If
/write-vfunc-as-yamlcannot take both afunc_addrand vtable fields in one call, use/write-func-as-yamlfor thefunc_*fields and then add the vtable fields, matching the field set of the 14191 ground-truth YAML (func_name,func_va,func_rva,func_size,func_sig,vtable_name,vfunc_offset,vfunc_index). Do not omit the vtable fields — downstream consumers readvfunc_index.
Do not write a partial YAML: all eight fields above are required, and the writer must produce them for the platform being processed only.
Failure handling
CNetChan_SendMessages_InternalYAML missing → STOP and report (this skill'sexpected_inputis absent).CNetChan_vtable.<platform>.yamlmissing → STOP and report.- The helper has zero callers, or the two candidates cannot be separated by Step 2 → STOP and report which check failed. Do not guess an address.
- Never emit the symbol on the wrong platform, and never reuse a previous build's
func_va/vfunc_index.
Output YAML filenames
Written under the analyzer-reported artifact module directory, one file per platform:
- Windows (
networksystem.dll):CNetChan_SendMessages.windows.yaml - Linux (
libnetworksystem.so):CNetChan_SendMessages.linux.yaml
Why this is robust
- The helper
CNetChan_SendMessages_Internalowns the unique"SendMessage reliable failed AllocateMessage (%d)."string, so it is always locatable; the ambiguity is confined to its two callers. - Those callers are separated by a structural fingerprint (thin mutex-wrapper vs. the large Transmit body
that owns the
"while suppressing transmit"string), which does not depend on a struct displacement — that displacement shifted from0x70(14181) to0x8C(14191) and is exactly what made the original fixed-offset exclusion fragile. - The vtable slot is derived from the resolved address, so a vtable reorder is absorbed instead of repeated.
- A fresh
func_sigis generated from the located function, so a rewritten prologue is absorbed too.