Files
xieyi-weixin-/wecom_native_sender.py
T
2026-09-28 10:02:07 +08:00

337 lines
21 KiB
Python

"""Version-pinned original-account WeCom text transport.
Uses the existing MessageService, without UI automation or replacing client code.
Only temporary allocations are written. Diagnostic discovery remains read-only.
"""
from __future__ import annotations
import ctypes as c
from ctypes import wintypes as w
import hashlib
import json
import os
from pathlib import Path
import sqlite3
import struct
import time
from contextlib import contextmanager
from contextvars import ContextVar
from wecom_native_stub import relocate
from wecom_native_evidence import send_authorized
from wecom_native_builds import build_for_hash
SUPPORTED_VERSION = '5.0.10.6023'
SUPPORTED_SHA256 = '47b5dfafc8def0b41a648610f1ba08bbf15f710c6f81c08d36c485bd82ce2842'
MAX_TEXT_BYTES = 4096
class NativeUnavailable(RuntimeError): pass
class DeliveryUnknown(RuntimeError): pass
class DeliveryFailed(RuntimeError): pass
class SendCancelled(RuntimeError): pass
class Module(c.Structure):
_fields_=[('dwSize',w.DWORD),('th32ModuleID',w.DWORD),('th32ProcessID',w.DWORD),('GlblcntUsage',w.DWORD),('ProccntUsage',w.DWORD),('modBaseAddr',c.c_void_p),('modBaseSize',w.DWORD),('hModule',w.HMODULE),('szModule',w.WCHAR*256),('szExePath',w.WCHAR*260)]
def kernel():
if os.name != 'nt': raise NativeUnavailable('原账号协议通道仅支持 Windows')
k=c.WinDLL('kernel32',use_last_error=True)
declarations=[
('CreateToolhelp32Snapshot',w.HANDLE,[w.DWORD,w.DWORD]),('Module32FirstW',w.BOOL,[w.HANDLE,c.POINTER(Module)]),('Module32NextW',w.BOOL,[w.HANDLE,c.POINTER(Module)]),
('OpenProcess',w.HANDLE,[w.DWORD,w.BOOL,w.DWORD]),('CloseHandle',w.BOOL,[w.HANDLE]),('ReadProcessMemory',w.BOOL,[w.HANDLE,c.c_void_p,c.c_void_p,c.c_size_t,c.POINTER(c.c_size_t)]),
('WriteProcessMemory',w.BOOL,[w.HANDLE,c.c_void_p,c.c_void_p,c.c_size_t,c.POINTER(c.c_size_t)]),('VirtualAllocEx',c.c_void_p,[w.HANDLE,c.c_void_p,c.c_size_t,w.DWORD,w.DWORD]),
('VirtualFreeEx',w.BOOL,[w.HANDLE,c.c_void_p,c.c_size_t,w.DWORD]),('VirtualProtectEx',w.BOOL,[w.HANDLE,c.c_void_p,c.c_size_t,w.DWORD,c.POINTER(w.DWORD)]),
('CreateRemoteThread',w.HANDLE,[w.HANDLE,c.c_void_p,c.c_size_t,c.c_void_p,c.c_void_p,w.DWORD,c.POINTER(w.DWORD)]),('WaitForSingleObject',w.DWORD,[w.HANDLE,w.DWORD]),
('FlushInstructionCache',w.BOOL,[w.HANDLE,c.c_void_p,c.c_size_t]),('CreateMutexW',w.HANDLE,[c.c_void_p,w.BOOL,w.LPCWSTR]),('ReleaseMutex',w.BOOL,[w.HANDLE]),
('GetExitCodeThread',w.BOOL,[w.HANDLE,c.POINTER(w.DWORD)]),
('GetProcessTimes',w.BOOL,[w.HANDLE,c.POINTER(w.FILETIME),c.POINTER(w.FILETIME),c.POINTER(w.FILETIME),c.POINTER(w.FILETIME)])]
for name,ret,args in declarations:
f=getattr(k,name);f.restype=ret;f.argtypes=args
return k
@contextmanager
def sender_mutex():
k=kernel();h=k.CreateMutexW(None,False,'Local\\ZhenAIWeComNativeSender')
if not h:raise NativeUnavailable('无法创建协议发送锁')
acquired=False
try:
acquired=k.WaitForSingleObject(h,0) in (0,0x80)
if not acquired:raise NativeUnavailable('另一个协议发送任务正在运行')
yield
finally:
if acquired:k.ReleaseMutex(h)
k.CloseHandle(h)
_readonly_build_validation = ContextVar('wecom_readonly_build_validation', default=None)
@contextmanager
def readonly_build_validation_scope():
"""Reuse only file hashes within one probe, never live account/send readiness."""
state={'entries':{},'hashedFiles':0,'reusedFiles':0,'bytesHashed':0}
token=_readonly_build_validation.set(state)
try:yield state
finally:_readonly_build_validation.reset(token)
def _file_identity(info):
return (info.st_dev,info.st_ino,info.st_size,info.st_mtime_ns,info.st_ctime_ns)
def _path_file_identity(path):
"""Use the same metadata provider for both path and hash-handle checks.
On Windows/Python 3.12, Path.stat().st_ctime_ns can be birth time while
os.fstat().st_ctime_ns is change time. Comparing those reports a stable
installed executable as changed. Reopen the path and fstat that handle;
retain volume/file ID, size and timestamps to detect real replacement.
"""
with Path(path).open('rb') as handle:
return _file_identity(os.fstat(handle.fileno()))
def _hash_client_file(path):
"""Bound memory and reject a replacement/change during the complete hash."""
with Path(path).open('rb') as handle:
before=_file_identity(os.fstat(handle.fileno()))
digest=hashlib.sha256()
while chunk:=handle.read(1024*1024):digest.update(chunk)
after=_file_identity(os.fstat(handle.fileno()))
if before!=after or before!=_path_file_identity(path):
raise NativeUnavailable('企业微信文件在校验期间发生变化,请重新检测')
return digest.hexdigest(),before
def _process_creation_id(pid,kernel32):
"""PID reuse must not reuse the earlier process's build validation."""
handle=kernel32.OpenProcess(0x1000,False,int(pid))
if not handle:return None
try:
created=w.FILETIME();exited=w.FILETIME();system=w.FILETIME();user=w.FILETIME()
if not kernel32.GetProcessTimes(handle,c.byref(created),c.byref(exited),c.byref(system),c.byref(user)):
return None
return (created.dwHighDateTime<<32)|created.dwLowDateTime
finally:kernel32.CloseHandle(handle)
def _client_file_digest(path,pid,kernel32,*,readonly):
state=_readonly_build_validation.get() if readonly else None
if state is None:
return _hash_client_file(path)[0]
created=_process_creation_id(pid,kernel32)
before=_path_file_identity(path)
identity=(int(pid),created,os.path.normcase(os.path.abspath(path)),before)
if created is not None and identity in state['entries']:
state['reusedFiles']+=1
return state['entries'][identity]
digest,verified=_hash_client_file(path)
state['hashedFiles']+=1
state['bytesHashed']+=verified[2]
if before!=verified:
raise NativeUnavailable('企业微信文件在校验期间发生变化,请重新检测')
if created is not None:state['entries'][identity]=digest
return digest
class NativeClient:
def __init__(self,pid,*,write=False,allow_unverified=False):
self.k=kernel();self.pid=int(pid);self.handle=None
snap=self.k.CreateToolhelp32Snapshot(0x18,self.pid)
if snap==c.c_void_p(-1).value:raise NativeUnavailable('企业微信进程不可读取')
m=Module();m.dwSize=c.sizeof(m);found=None
try:
ok=self.k.Module32FirstW(snap,c.byref(m))
while ok:
if m.szModule.lower()=='wxwork.exe':found=(int(m.modBaseAddr),Path(m.szExePath));break
ok=self.k.Module32NextW(snap,c.byref(m))
finally:self.k.CloseHandle(snap)
if found is None:raise NativeUnavailable('未找到企业微信主模块')
self.base,self.path=found
self.profile=build_for_hash(_client_file_digest(self.path,self.pid,self.k,readonly=not write))
if self.profile is None:
raise NativeUnavailable('当前企业微信文件未适配;请导出检测报告核对版本与构建')
self.handle=self.k.OpenProcess(0x410,False,self.pid)
if not self.handle:raise NativeUnavailable('无法访问企业微信进程,请以相同权限运行')
try:
initial_account=self.validate()
if write:
if not allow_unverified and not send_authorized(self.profile,initial_account):
raise NativeUnavailable('此账号尚未完成当前构建的首次发送及回执验证,禁止自动回复')
writable=self.k.OpenProcess(0x43a,False,self.pid)
if not writable:raise NativeUnavailable('无法访问企业微信进程,请以相同权限运行')
self.k.CloseHandle(self.handle);self.handle=writable
if self.validate()!=initial_account:
raise NativeUnavailable('获取发送权限期间账号已变化,停止发送')
except Exception:self.close();raise
def at(self,va):return self.base+va-0x400000
def addr(self,name):return self.at(getattr(self.profile,name))
def read(self,addr,size):
if not addr or not 0<=size<=65536:raise NativeUnavailable('客户端对象地址或长度无效')
buf=c.create_string_buffer(size);n=c.c_size_t()
if not self.k.ReadProcessMemory(self.handle,addr,buf,size,c.byref(n)) or n.value!=size:
raise NativeUnavailable('客户端状态已变化,请重新检测')
return buf.raw
def u32(self,addr):return struct.unpack('<I',self.read(addr,4))[0]
def u64(self,addr):return struct.unpack('<Q',self.read(addr,8))[0]
def string(self,addr):
size=self.u32(addr+16);cap=self.u32(addr+20)
if size>4096:raise NativeUnavailable('客户端返回字符串超过限制')
return self.read(self.u32(addr) if cap>15 else addr,size).decode('utf-8','replace') if size else ''
def validate(self):
root=self.u32(self.addr('service_root'));service=self.u32(root+0x30);profile=self.u32(root+0x18)
if self.u32(service)!=self.addr('message_vtable') or self.u32(profile)!=self.addr('login_vtable'):
raise NativeUnavailable('当前登录消息服务尚未就绪')
owner=self.u32(profile-8)
if owner!=self.u32(service-8):raise NativeUnavailable('账号与消息服务不一致')
state=self.u32(owner+0x44);user=self.u32(state+8);data=self.u32(user+4)
identity_at=data+0x70;account=str(self.u64(identity_at))
if account=='0':raise NativeUnavailable('企业微信尚未登录')
for name,expected in (('factory','6690558bec'),('send','6690558bec'),('release','568b710485')):
if self.read(self.addr(name),5)!=bytes.fromhex(expected):raise NativeUnavailable('客户端入口校验失败')
if self.u32(self.u32(service)+20)!=self.addr('send'):raise NativeUnavailable('发送接口不匹配')
self.service=service;self.account=account;self.identity_at=identity_at
return account
def close(self):
if self.handle:self.k.CloseHandle(self.handle);self.handle=None
def __enter__(self):return self
def __exit__(self,*args):self.close()
def _write(self,addr,raw):
n=c.c_size_t();buf=c.create_string_buffer(raw)
if not self.k.WriteProcessMemory(self.handle,addr,buf,len(raw),c.byref(n)) or n.value!=len(raw):
raise NativeUnavailable('无法写入临时消息缓冲区')
def _thread(self,code,timeout):
tid=w.DWORD();thread=self.k.CreateRemoteThread(self.handle,None,0,code,None,0,c.byref(tid))
if not thread:raise DeliveryUnknown('调用线程未建立;请核对记录,禁止自动重试')
try:
if self.k.WaitForSingleObject(thread,timeout)!=0:raise DeliveryUnknown('发送调用超时,结果待核对,禁止自动重试')
status=w.DWORD()
if not self.k.GetExitCodeThread(thread,c.byref(status)) or status.value!=0:
raise DeliveryUnknown('客户端调用异常,结果待核对,禁止自动重试')
finally:self.k.CloseHandle(thread)
def send(self,account,conversation,text,*,guard=lambda:True):
from conversation_blacklist import blocked_reason
reason = blocked_reason(account, conversation)
if reason: raise SendCancelled(reason)
original_guard = guard
guard = lambda: not blocked_reason(account, conversation) and original_guard()
payload=text.encode('utf-8');conv=conversation.encode('utf-8')
if not text.strip() or len(payload)>MAX_TEXT_BYTES or '\0' in text:raise ValueError('回复文本为空、过长或包含空字符')
if not 0<len(conv)<200 or '\0' in conversation:raise ValueError('会话 ID 无效')
if self.validate()!=account:raise NativeUnavailable('当前账号已切换,停止发送')
mem=self.k.VirtualAllocEx(self.handle,None,0x7000,0x3000,4)
if not mem or mem+0x7000>=0x100000000:raise NativeUnavailable('无法分配客户端临时缓冲区')
started=False;completed=False;cleaned=False;promise=mem+0x90
try:
values={'state':mem,'identity':self.identity_at,'identity_hi':self.identity_at+4,'account_lo':int(account)&0xffffffff,'account_hi':int(account)>>32,
'service':self.service,'vtable':self.addr('message_vtable'),'text':mem+0x100,'message':mem+0x80,'message_control':mem+0x84,
'factory':self.addr('factory'),'send':self.addr('send'),'conversation':mem+0x140,'promise':promise,'release':self.addr('release'),'options':mem+0x180}
for st,dt,raw in ((mem+0x100,mem+0x1000,payload),(mem+0x140,mem+0x3000,conv)):
if len(raw)<=15:self._write(st,raw.ljust(16,b'\0')+struct.pack('<II',len(raw),15))
else:self._write(st,struct.pack('<IIIIII',dt,0,0,0,len(raw),len(raw)));self._write(dt,raw+b'\0')
if self.profile.send_argument_bytes==16:
# Empty optional<string>: disengaged flag at +24; no borrowed string data.
self._write(values['options'],b'\0'*32)
code=mem+0x5000;cleanup=code+0x800
self._write(code,relocate(self.profile.send_stub,values));self._write(cleanup,relocate('cleanup',values));old=w.DWORD()
if not self.k.VirtualProtectEx(self.handle,code,0x1000,0x20,c.byref(old)):raise NativeUnavailable('临时调用页不可执行')
self.k.FlushInstructionCache(self.handle,code,0x1000)
if self.validate()!=account or self.service!=values['service'] or self.identity_at!=values['identity'] or not guard():
raise SendCancelled('发送前账号、服务或会话已更新,取消本次调用')
started=True;self._thread(code,10000);completed=True
stage=self.u32(mem);p=self.u32(promise)
if stage in (90,91,92):raise DeliveryFailed('客户端身份或消息构造校验未通过,未执行发送')
if stage!=4 or not p:raise DeliveryUnknown('未取得发送结果,禁止自动重试')
deadline=time.monotonic()+25
while time.monotonic()<deadline:
state=self.u32(p+8)
if state==2 and (error:=self.u32(p+0x2c)):
raise DeliveryFailed(f'客户端拒绝发送:{struct.unpack("<i",self.read(error+24,4))[0]} {self.string(error+28)}')
if state==1 and (value:=self.u32(p+0x28)) and (result:=self.u32(value)):
message_id=self.u64(result);server_id=self.u64(result+8)
if message_id and server_id:return {'messageId':message_id,'serverId':server_id,'accountId':account,'conversationId':conversation,'nativeCallback':'success','clientVersion':self.profile.version,'clientSha256':self.profile.sha256,'adapterRevision':self.profile.adapter_revision}
time.sleep(.1)
raise DeliveryUnknown('未收到明确的服务器消息编号,禁止自动重试')
finally:
# In-flight code must keep its allocation. Cleanup only our owned objects.
if completed:
try:
if self.u32(promise):self._thread(mem+0x5800,5000)
cleaned=True
except Exception:pass
if not started or cleaned:self.k.VirtualFreeEx(self.handle,mem,0,0x8000)
def discover(clients=None):
if clients is None:
from wxwork_protocol_probe import running_clients
clients=running_clients()
matches=[];errors=[]
for item in clients:
# Version metadata is only a fast hint. NativeClient hashes the live
# image and selects the exact layout, so formatting/localization changes
# in the Windows version resource do not disable a known build.
if item.get('architecture')!='x86':continue
try:
with NativeClient(item['pid']) as client:matches.append({'pid':client.pid,'accountId':client.account,'clientVersion':client.profile.version,'clientSha256':client.profile.sha256,'nativeAdapter':client.profile.adapter_id,'buildVerified':client.profile.verified})
except (OSError,NativeUnavailable,ValueError) as exc:errors.append(str(exc))
if len(matches)!=1:raise NativeUnavailable('多个企业微信账号同时运行,请保留一个主客户端' if len(matches)>1 else (errors[0] if errors else '没有已适配且登录的企业微信主进程'))
return matches[0]
class NativeSender:
"""Durable at-most-once invocation per incoming event, with DB receipt verification."""
def __init__(self,db,journal_path,*,client_factory=NativeClient,mutex=sender_mutex):
self.db=db;self.client_factory=client_factory;self.mutex=mutex
path=Path(journal_path);path.parent.mkdir(parents=True,exist_ok=True)
self.origin_root=Path(path).resolve().parent
self.journal=sqlite3.connect(path,timeout=5)
self.journal.execute('PRAGMA synchronous=FULL')
self.journal.execute('CREATE TABLE IF NOT EXISTS sends(request_id TEXT PRIMARY KEY, fingerprint TEXT NOT NULL, status TEXT NOT NULL, result TEXT NOT NULL, created REAL NOT NULL)')
self.journal.commit()
def close(self):self.journal.close()
def lookup(self,request_id):
row=self.journal.execute('SELECT status,result FROM sends WHERE request_id=?',(request_id,)).fetchone()
return {'status':row[0],'result':json.loads(row[1])} if row else None
def send(self,request_id,pid,account,conversation,text,*,guard=lambda:True):
from conversation_blacklist import blocked_reason
reason = blocked_reason(account, conversation)
if reason: raise SendCancelled(reason)
original_guard = guard
guard = lambda: not blocked_reason(account, conversation) and original_guard()
if not request_id:raise ValueError('发送请求缺少去重标识')
if not isinstance(text,str) or not text.strip() or len(text.encode())>MAX_TEXT_BYTES or '\0' in text:raise ValueError('回复文本无效')
fingerprint=hashlib.sha256(json.dumps([account,conversation,text],ensure_ascii=False).encode()).hexdigest()
with self.mutex():
old=self.journal.execute('SELECT fingerprint,status,result FROM sends WHERE request_id=?',(request_id,)).fetchone()
if old:
if old[0]!=fingerprint:raise DeliveryUnknown('同一客户消息的发送内容已变化,请人工核对原结果')
if old[1]=='confirmed':return json.loads(old[2])
raise DeliveryUnknown('此客户消息已有发送尝试,禁止自动重发:'+old[1])
context=self.db.get_conversation_context_by_id(account,conversation,limit=1)
if not context or context['account']!=account or context['conv_id']!=conversation:raise NativeUnavailable('现有单聊会话无法按 ID 核对')
with self.client_factory(pid,write=True) as client:
if client.account!=account:raise NativeUnavailable('发送账号与会话所属账号不一致')
if not guard():raise SendCancelled('会话已变化,取消发送')
from message_origin import record_attempt, finish
record_attempt(request_id, account, conversation, text,
'system' if str(request_id).startswith('review-assistant:') else 'ai', root=self.origin_root)
self.journal.execute('INSERT INTO sends VALUES(?,?,?,?,?)' ,(request_id,fingerprint,'unknown','{}',time.time()));self.journal.commit()
try:
receipt=client.send(account,conversation,text,guard=guard)
deadline=time.monotonic()+12
while time.monotonic()<deadline:
context=self.db.get_conversation_context_by_id(account,conversation,limit=100)
found=[m for m in (context or {}).get('messages',[]) if str(m.get('server_id'))==str(receipt['serverId']) and m.get('sender_id')==account and m.get('content','').strip()==text.strip()]
if len(found)==1:
receipt.update(status='confirmed',senderVerified=True,textVerified=True,confirmedAt=time.time());break
time.sleep(.25)
else:raise DeliveryUnknown('发送回调成功,但本地会话回执尚未核对;禁止自动重发')
except SendCancelled:
finish(request_id, 'cancelled', root=self.origin_root)
self.journal.execute('DELETE FROM sends WHERE request_id=?',(request_id,));self.journal.commit();raise
except DeliveryFailed as exc:
self._record(request_id,'failed',{'error':str(exc)});raise
except Exception as exc:
self._record(request_id,'unknown',{'error':str(exc)})
if isinstance(exc,DeliveryUnknown):raise
raise DeliveryUnknown('发送尝试后结果不明确,禁止自动重发') from exc
self._record(request_id,'confirmed',receipt)
finish(request_id, 'confirmed', receipt.get('serverId'), root=self.origin_root)
return receipt
def _record(self,request_id,status,result):
self.journal.execute('UPDATE sends SET status=?,result=? WHERE request_id=?',(status,json.dumps(result,ensure_ascii=False),request_id));self.journal.commit()