find-CNetChan_CanPacket
Final-guarantee fallback for the find-CNetChan_CanPacket preprocessor. Recovers CNetChan::CanPacket (its func_va/func_rva/func_size/func_sig plus CNetChan vtable slot) in CS2 networksystem.dll / libne
SKILL.md.claude/skills/find-CNetChan_CanPacket/SKILL.md
GitHubFind CNetChan_CanPacket (final-guarantee fallback)
Recover CNetChan::CanPacket in CS2 networksystem.dll / libnetworksystem.so using IDA Pro MCP tools.
This is the Agent fallback for the find-CNetChan_CanPacket skill: it runs only when the preprocessor
returned failure. The preprocessor tries two things and either can miss on a new build:
- reuse the previous build's
func_sig— breaks when the prologue is rewritten; - reuse the
"%s: !CanPacket() - m_bSuppressingTransmit."xref string — breaks when the single call site moves or the string literal relocates.
Your job is to locate the function by semantic anchors that survive those changes, then emit the YAML.
Realworld Function References
Read the platform-relevant real-world YAMLs before searching in IDA. They provide concrete disassembly, decompiler output, and semantic anchors, and they document the neighbouring functions you must distinguish the target from. 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_CanPacket.windows.yamlbin_artifacts/14191/networksystem/CNetChan_CanPacket.linux.yamlbin_artifacts/14191/networksystem/CNetChan_SetTimeout.windows.yamlbin_artifacts/14191/networksystem/CNetChan_SetTimeout.linux.yamlbin_artifacts/14191/networksystem/CNetChan_UpdateMessageStats.windows.yamlbin_artifacts/14191/networksystem/CNetChan_UpdateMessageStats.linux.yamlbin_artifacts/14191/networksystem/CNetChan_vtable.windows.yamlbin_artifacts/14191/networksystem/CNetChan_vtable.linux.yaml
Background — CNetChan::CanPacket and its decoys
CNetChan::CanPacket is the CNetChan virtual that reports whether the channel may send right now:
- returns false while the channel is suppressed (
m_bSuppressingTransmit), logging"%s: !CanPacket() - m_bSuppressingTransmit.\n"; - otherwise consults the outstanding message/byte budget and the channel's timeout state.
All member accesses are relative to this (the first argument — 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.
CanPackethas a small, generic prologue (55 48 89 E5 41 54 53 48 89 FB 48 83 EC ?? 80 BF ...on Linux) that is shared with several other smallCNetChanmembers. In particular a stalefind-CNetChan_UpdateMessageStatsanchor once matched this exact prologue template and mislabelledCanPacketasUpdateMessageStats, producing a duplicate artifact that collided at the other symbol's slot. The reverse confusion is equally possible here: if your prologue search lands on a function that references the"UpdateMessageStats, bit counter about to roll over"string, it isUpdateMessageStats, notCanPacket. Use the string anchor in Step 2, not the prologue.
Robustness principle — anchor semantically, not by signature
The old func_sig and the old vtable slot are both rebuild-fragile — that is exactly what failed. Do not rely
on either to find the function. Instead:
- Find the function by its semantic fingerprint (the
!CanPacket()suppression log and the budget/timeout checks). - Disambiguate against its vtable neighbours (Step 2b) — several small
CNetChanmembers share the prologue. - 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_CanPacket |
real vtable vfunc | func_va 0x1800bd150, size 0x285, vtable CNetChan slot 47 / 0x178 |
func_va 0x286b20, size 0x197, vtable CNetChan slot 48 / 0x180 |
/write-vfunc-as-yaml |
Platform gating: the symbol is produced on both platforms. Note the slot differs per platform (Windows 47, Linux 48) — resolve it from the vtable, do not carry a number across platforms.
Step 0. Skip targets already produced
If CNetChan_CanPacket.<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).
Step 1. Load the CNetChan vtable and confirm the platform
ALWAYS Use SKILL /get-vtable-from-yaml with class_name=CNetChan to obtain the authoritative
vtable_va, vtable_symbol, and vtable_entries for the current build. You need this to assign the vtable
fields in Step 3; do not reuse the old vfunc_offset/vfunc_index.
The expected_input for this skill is exactly this CNetChan_vtable.{platform}.yaml, so it must already exist
when the fallback runs. If /get-vtable-from-yaml errors, STOP and report to user.
Step 2. Locate CNetChan::CanPacket by its unique anchor
Use IDA string xrefs. Enumerate strings exactly as the preprocessor does (C strings, minlen = the
CS2VIBE_STRING_MIN_LENGTH in effect, 4 in CI):
mcp__ida-pro-mcp__py_eval code="""
import idautils, ida_nalt, idc
strings = idautils.Strings(default_setup=False)
strings.setup(strtypes=[ida_nalt.STRTYPE_C], minlen=4)
needle = "!CanPacket() - m_bSuppressingTransmit."
for s in strings:
if needle in str(s):
ea = s.ea
print('string', hex(ea), str(s)[:70])
for xr in idautils.XrefsTo(ea, 0):
print(' xref', hex(xr.frm), 'in', hex(idc.get_func_attr(xr.frm, idc.FUNCATTR_START)),
idc.get_func_name(idc.get_func_attr(xr.frm, idc.FUNCATTR_START)))
"""
Anchor that is unique to the real target — "%s: !CanPacket() - m_bSuppressingTransmit." is referenced by
CNetChan::CanPacket and by nothing else (verified on 14191, both platforms).
Resolve each xref frm to its containing function. The required containing function start is
CNetChan_CanPacket.
If the string is unavailable (e.g. logging compiled out), fall back to the semantic fingerprint: a boolean
virtual on CNetChan that (a) reads a suppression byte at this+0x..., and (b) is immediately adjacent in the
vtable to UpdateMessageStats/IsOverflowed. Confirm the candidate by Step 3 before emitting.
Step 2b. Disambiguate against sibling CNetChan members (do not skip)
Several small CNetChan members share the generic Linux prologue
55 48 89 E5 41 54 53 48 89 FB 48 83 EC ?? 80 BF .... A candidate is not CanPacket if it references the
"UpdateMessageStats, bit counter about to roll over" string or any ParseMessagesDemo string. Confirm
positively by scanning the candidate's own strings:
mcp__ida-pro-mcp__py_eval code="""
import idautils, ida_funcs
f = ida_funcs.get_func(0x286b20) # candidate
strings = idautils.Strings(default_setup=False)
hits = []
for s in strings:
for x in idautils.XrefsTo(s.ea, 0):
if f.start_ea <= x.frm < f.end_ea:
hits.append((hex(x.frm), str(s)[:60])); break
for h in sorted(hits): print(h)
"""
The real target must contain the !CanPacket() suppression string. If none of the candidates do, STOP and
report — the build has been restructured beyond these anchors and the references need extending.
Step 3. Assign the vtable fields
Look the resolved start up in the CNetChan vtable entries obtained in Step 1:
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, f'CNetChan_vtable.{plat}.yaml'), encoding='utf-8'))
ents = {int(str(x),16): int(k) for k, x in v['vtable_entries'].items()}
tgt = 0x0 # <-- resolved CNetChan_CanPacket start
print('vtable_class', v['vtable_class'])
print('match index', [k for k,a in ents.items() if a == tgt])
"""
Set:
vtable_name = CNetChan_vtablevfunc_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 2b. Do not emit the previous build's slot.
Rename the function to CNetChan_CanPacket if the database does not already name it that way:
mcp__ida-pro-mcp__rename batch={"func":[{"addr":"<start>","name":"CNetChan_CanPacket"}]}
Step 4. Generate the signature and write the YAML
- ALWAYS Use SKILL
/generate-signature-for-functionwithaddr=<resolved start>to obtain a fresh, validatedfunc_sig. - ALWAYS Use SKILL
/write-vfunc-as-yamlwith:func_name:CNetChan_CanPacketfunc_addr: the resolved function startfunc_sig: the signature from step 1vtable_name:CNetChan_vtablevfunc_offset:vfunc_index * 8(from Step 3)vfunc_index: from Step 3
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_vtable.<platform>.yamlmissing → STOP and report (the skill'sexpected_inputis absent).- The
!CanPacket()anchor resolves to no function → STOP and report which anchor failed, so the references can be extended. Do not guess an address. - The resolved target equals
CNetChan_UpdateMessageStats(i.e. it references the bit-counter string) → STOP; the search has drifted onto a sibling. - 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_CanPacket.windows.yaml - Linux (
libnetworksystem.so):CNetChan_CanPacket.linux.yaml
Why this is robust
- The function is located by its
!CanPacket()suppression string, which its vtable neighbours do not reference — so the shared generic prologue cannot mislead the search. - The vtable slot is derived from the resolved address, so a vtable reorder is absorbed instead of repeated.
- The cross-check against
UpdateMessageStatsprevents the exact collision that a prologue-anchored search previously produced between these two adjacent slots.