350 lines
22 KiB
Python
350 lines
22 KiB
Python
"""Build-validated 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,expected_sha256=""):
|
|
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
|
|
digest = _client_file_digest(self.path, self.pid, self.k, readonly=not write)
|
|
self.profile = build_for_hash(digest)
|
|
if self.profile is None:
|
|
from wecom_native_adaptation import resolve_build, AdaptationUnavailable
|
|
try:
|
|
self.profile = resolve_build(self.path, digest)
|
|
except (AdaptationUnavailable, OSError, ValueError) as exc:
|
|
raise NativeUnavailable('自动适配未通过:' + str(exc)) from exc
|
|
if expected_sha256 and digest != expected_sha256:
|
|
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):
|
|
if self.profile.automatic:
|
|
from wecom_native_adaptation import validate_live_layout, AdaptationUnavailable
|
|
try:
|
|
validate_live_layout(self.profile, self.base, self.read)
|
|
except AdaptationUnavailable as exc:
|
|
raise NativeUnavailable(str(exc)) from exc
|
|
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,'autoAdapted':client.profile.automatic})
|
|
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() |