feat(login): update register to SsoInfoSync

Author: wyapx

lagrange/client/base.py

@@ -29,6 +29,8 @@
     build_register_request,
     build_sso_heartbeat_request,
     parse_register_response,
+    build_sso_info_sync,
+    parse_sso_info_sync_rsp,
 )
 from .wtlogin.tlv import CommonTlvBuilder, QrCodeTlvBuilder
 
@@ -407,6 +409,18 @@ async def register(self) -> bool:
         log.login.error("Register failure")
         return False
 
+    async def register_new(self) -> bool:
+        response = await self.send_uni_packet(
+            "trpc.msg.register_proxy.RegisterProxy.SsoInfoSync",
+            build_sso_info_sync(self.app_info, self.device_info),
+        )
+        if parse_sso_info_sync_rsp(response.data):
+            self._online.set()
+            log.login.info("Register(new) successful")
+            return True
+        log.login.error("Register(new) failure")
+        return False
+
     async def sso_heartbeat(self, calc_latency=False, timeout=10) -> float:
         start_time = time.time()
         await self.send_uni_packet(

lagrange/client/client.py

@@ -105,7 +105,7 @@ def push_deliver(self) -> PushDeliver:
         return self._push_deliver
 
     async def register(self) -> bool:
-        if await super().register():
+        if await super().register_new():
             self._events.emit(ClientOnline(), self)
             return True
         self._events.emit(ClientOffline(recoverable=False), self)

lagrange/client/server_push/binder.py

@@ -21,6 +21,6 @@ def subscribe(self, cmd: str, func: Callable[["Client", SSOPacket], Coroutine[No
 
     async def execute(self, cmd: str, sso: SSOPacket):
         if cmd not in self._handle_map:
-            logger.warning(f"Unsupported command: {cmd}")
+            logger.warning(f"Unsupported command: {cmd}({len(sso.data)})")
         else:
             return await self._handle_map[cmd](self._client, sso)

lagrange/client/wtlogin/status_service.py

@@ -1,14 +1,24 @@
 from lagrange.info import AppInfo, DeviceInfo
-from lagrange.pb.login.register import PBRegisterRequest, PBRegisterResponse
 from lagrange.utils.binary.protobuf import proto_encode
 from lagrange.utils.log import log
+from lagrange.pb.login.register import (
+    PBRegisterRequest,
+    PBRegisterResponse,
+    PBSsoInfoSyncRequest,
+    PBSsoInfoSyncResponse,
+)
 
 
 # trpc.qq_new_tech.status_svc.StatusService.Register
 def build_register_request(app: AppInfo, device: DeviceInfo) -> bytes:
     return PBRegisterRequest.build(app, device).encode()
 
 
+# trpc.msg.register_proxy.RegisterProxy.SsoInfoSync
+def build_sso_info_sync(app: AppInfo, device: DeviceInfo) -> bytes:
+    return PBSsoInfoSyncRequest.build(app, device).encode()
+
+
 # trpc.qq_new_tech.status_svc.StatusService.SsoHeartBeat
 def build_sso_heartbeat_request() -> bytes:
     return proto_encode({1: 1})
@@ -20,3 +30,15 @@ def parse_register_response(response: bytes) -> bool:
         return True
     log.network.error("register fail, reason: %s", pb.message)
     return False
+
+
+def parse_sso_info_sync_rsp(response: bytes) -> bool:
+    pb = PBSsoInfoSyncResponse.decode(response)
+    if pb.reg_rsp:
+        if pb.reg_rsp.message == "register success":
+            return True
+        else:
+            log.network.error("register fail, reason: %s", pb.reg_rsp.message)
+    else:
+        log.network.error("register fail, reason: WrongRsp")
+    return False

lagrange/pb/login/register.py

@@ -1,7 +1,11 @@
+import random
+
 from lagrange.info import AppInfo, DeviceInfo
+from lagrange.pb.message.msg_push import MsgPushBody
 from lagrange.utils.binary.protobuf import proto_field, ProtoStruct
 
 
+# trpc.qq_new_tech.status_svc.StatusService.Register
 class _DeviceInfo(ProtoStruct):
     device_name: str = proto_field(1)
     vendor_os: str = proto_field(2)
@@ -12,9 +16,9 @@ class _DeviceInfo(ProtoStruct):
 
 class PBRegisterRequest(ProtoStruct):
     guid: str = proto_field(1)
-    field_2: int = proto_field(2, default=0)
+    kick_pc: int = proto_field(2, default=0)  # ?
     current_version: str = proto_field(3)
-    field_4: int = proto_field(4, default=0)
+    field_4: int = proto_field(4, default=0)  # IsFirstRegisterProxyOnline
     locale_id: int = proto_field(5, default=2052)
     device_info: _DeviceInfo = proto_field(6)
     set_mute: int = proto_field(7, default=0)  # ?
@@ -38,3 +42,80 @@ def build(cls, app: AppInfo, device: DeviceInfo) -> "PBRegisterRequest":
 class PBRegisterResponse(ProtoStruct):
     message: str = proto_field(2)
     timestamp: int = proto_field(3)
+
+
+# trpc.msg.register_proxy.RegisterProxy.SsoInfoSync
+class C2cMsgCookie(ProtoStruct):
+    last_msg_time: int = proto_field(1)
+
+
+class SsoC2cInfo(ProtoStruct):
+    msg_cookie: C2cMsgCookie = proto_field(1)
+    last_msg_time: int = proto_field(2)
+    last_msg_cookie: C2cMsgCookie = proto_field(3)
+
+    @classmethod
+    def build(cls, last_msg_time=0) -> "SsoC2cInfo":
+        return cls(
+            msg_cookie=C2cMsgCookie(last_msg_time=last_msg_time),
+            last_msg_cookie=C2cMsgCookie(last_msg_time=last_msg_time),
+            last_msg_time=last_msg_time,
+        )
+
+
+class NormalCfg(ProtoStruct):
+    int_cfg: dict = proto_field(1, default=None)  # dict[int, int]
+
+
+class CurrentAppState(ProtoStruct):
+    is_delay_request: bool = proto_field(1)
+    app_state: int = proto_field(2)
+    silence_state: int = proto_field(3)
+
+    @classmethod
+    def build(cls) -> "CurrentAppState":
+        return cls(
+            is_delay_request=False,
+            app_state=0,
+            silence_state=0,
+        )
+
+
+class UnknownInfo(ProtoStruct):
+    grp_code: int = proto_field(1, default=0)
+    f2: int = proto_field(2, default=2)
+
+
+class PBSsoInfoSyncRequest(ProtoStruct):
+    sync_flag: int = proto_field(1)
+    req_rand: int = proto_field(2)
+    current_active_stats: int = proto_field(4)
+    grp_last_msg_time: int = proto_field(5)
+    c2c_info: SsoC2cInfo = proto_field(6)
+    normal_cfg: NormalCfg = proto_field(8)
+    register_info: PBRegisterRequest = proto_field(9)
+    unknown_f10: UnknownInfo = proto_field(10)
+    app_state: CurrentAppState = proto_field(11)
+
+    @classmethod
+    def build(cls, app: AppInfo, device: DeviceInfo) -> "PBSsoInfoSyncRequest":
+        return cls(
+            sync_flag=735,
+            req_rand=random.randint(114, 514),  # ?
+            current_active_stats=2,
+            grp_last_msg_time=0,
+            c2c_info=SsoC2cInfo.build(),
+            normal_cfg=NormalCfg(int_cfg=dict()),
+            register_info=PBRegisterRequest.build(app, device),
+            unknown_f10=UnknownInfo(),
+            app_state=CurrentAppState.build()
+        )
+
+
+class PBSsoInfoSyncResponse(ProtoStruct):
+    # f3: int = proto_field(3)
+    # f4: int = proto_field(4)
+    # f6: int = proto_field(6)
+    reg_rsp: PBRegisterResponse = proto_field(7)
+    # f9: int = proto_field(9)
+