from __future__ import annotations import base64 from dataclasses import dataclass from datetime import datetime, timedelta, timezone from email.utils import parsedate_to_datetime import hashlib import json import re import threading import time from urllib.parse import urlsplit from cryptography.hazmat.primitives import padding from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes import requests DEFAULT_KEY = "O/UT+WpvDymb26pF485QOA==" def encode(data, key): raw = json.dumps(data, ensure_ascii=False, separators=(",", ":")).encode() padder = padding.PKCS7(128).padder() raw = padder.update(raw) + padder.finalize() cipher = Cipher(algorithms.AES(base64.b64decode(key, validate=True)), modes.ECB()).encryptor() return base64.b64encode(cipher.update(raw) + cipher.finalize()) def decode(raw, key): if isinstance(raw, str): raw = raw.encode() if raw.lstrip().startswith(b"{"): return json.loads(raw) data = base64.b64decode(raw, validate=True) cipher = Cipher(algorithms.AES(base64.b64decode(key, validate=True)), modes.ECB()).decryptor() padded = cipher.update(data) + cipher.finalize() unpadder = padding.PKCS7(128).unpadder() return json.loads(unpadder.update(padded) + unpadder.finalize()) class ApiError(RuntimeError): pass def server_id(server): """Resolve wire/ServerVo identifiers without guessing a server number.""" if not isinstance(server, dict): raise ApiError("区服列表含有无法识别的条目") identifiers = set() for key in ("id", "serverId"): value = server.get(key) if type(value) is int and value >= 0: identifiers.add(value) elif isinstance(value, str) and value.strip().isascii() and value.strip().isdigit(): identifiers.add(int(value.strip())) if len(identifiers) > 1: raise ApiError("区服编号字段不一致(id/serverId),未进入区服") if not identifiers: fields = ", ".join(sorted(str(k) for k in server)[:20]) or "无字段" raise ApiError(f"缺少有效区服编号(id/serverId);返回字段:{fields}") return identifiers.pop() def server_entries(response, platform="ANDROID"): if not isinstance(response, dict) or not isinstance(response.get("servers"), list): raise ApiError("登录响应中的 servers 不是区服列表") source = response["servers"] servers, by_id = [], {} for row in source: # Some responses serialize duplicate server objects as Fastjson $ref aliases. # Resolve only references into this server array; this never fetches a URL. visited = set() while isinstance(row, dict) and "$ref" in row: reference = row["$ref"] match = re.fullmatch(r"\$\.servers\[([0-9]+)\]", reference) if isinstance(reference, str) else None if set(row) != {"$ref"} or not match: raise ApiError("区服引用格式无法识别,未进入区服") index = int(match[1]) if index >= len(source) or index in visited: raise ApiError("区服引用越界或存在循环,未进入区服") visited.add(index) row = source[index] if not isinstance(row, dict): raise ApiError("区服列表含有无法识别的条目") if str(row.get("platform") or platform).upper() != platform.upper(): continue identifier = server_id(row) if identifier in by_id: previous_address = by_id[identifier].get("gameServerAddress") address = row.get("gameServerAddress") if previous_address and address and previous_address != address: raise ApiError("同一区服编号对应不同游戏服地址,未进入区服") continue normalized = row | {"id": identifier, "serverName": row.get("serverName") or f"区服 {identifier}"} by_id[identifier] = normalized servers.append(normalized) return servers @dataclass class Session: server_url: str = "" token: str = "" key: str = DEFAULT_KEY reqid: int = 0 reqsid: int = 0 account_id: str = "" server_id: int = 0 role_id: int = 0 channel: str = "DYD" platform: str = "ANDROID" account_name: str = "" @classmethod def imported(cls, value, key=DEFAULT_KEY): if "log" not in value: fields = {k: value[k] for k in cls.__dataclass_fields__ if k in value} return cls(**fields) for entry in reversed(value["log"].get("entries", [])): request = entry.get("request", {}) if "masterService/masterQueryDetail" not in request.get("url", ""): continue post = request.get("postData", {}) raw = post.get("text", "") if post.get("encoding") == "base64": raw = base64.b64decode(raw).decode() payload = decode(raw, key) server = request["url"].split("masterService/masterQueryDetail", 1)[0] return cls(server, str(payload["token"]), key, int(payload.get("reqid", 0)) + 1, int(payload.get("reqsid", 0)) + 1) raise ValueError("HAR 中未找到角色详情请求。请在手机刷新牧场后导出抓包。") class Client: def __init__(self, session, trace=None, on_session_change=None): self.session = session self.trace = trace self.on_session_change = on_session_change self.http = requests.Session() self.http.trust_env = False self.lock = threading.Lock() self.server_offset = 0 self.last_receive = 0 def persist_session(self): if self.on_session_change: try: self.on_session_change(self.session) except (OSError, ValueError, TypeError): if self.trace: self.trace.emit("error", "保存会话", scope="local", message="会话未能保存到本机,请检查本地状态目录") def call(self, path, payload=None, base_url=None): with self.lock: base = (base_url or self.session.server_url).strip() parsed = urlsplit(base) if parsed.scheme not in ("http", "https") or not parsed.netloc or parsed.username: raise ApiError("请填写有效的游戏服务器地址") data = dict(payload or {}) | {"token": self.session.token, "reqid": int(self.session.reqid), "reqsid": int(self.session.reqsid)} self.session.reqid += 1 self.session.reqsid += 1 # Persist advanced counters before sending, including an unconfirmed request. self.persist_session() operation = {"userServerService/loginUser": "获取官方区服", "userServerService/enterGame": "进入选中区服", "masterService/masterQueryDetail": "读取角色"}.get(path, path) url = base.rstrip("/") + "/" + path headers = {"Content-Type": "application/x-www-form-urlencoded"} identifier = self.trace.begin(operation, method="POST", url=url, headers=headers, body=data, encoding="AES-ECB / PKCS7 / Base64(body 展示解密 JSON)") if self.trace else None started = time.monotonic() try: result = self.http.post(url, data=encode(data, self.session.key), headers=headers, timeout=(5, 15), allow_redirects=False) try: response = decode(result.content.strip(), self.session.key) except (ValueError, TypeError): if self.trace: self.trace.emit("response", operation, request_id=identifier, url=url, http_status=result.status_code, headers=dict(result.headers), elapsed_ms=round((time.monotonic() - started) * 1000), body_preview=result.content[:4000].decode("utf-8", errors="replace"), bytes_received=len(result.content), decoded=False) if result.status_code != 200: raise ApiError(f"HTTP {result.status_code},响应无法解码,请查看调试窗口") raise if self.trace: self.trace.emit("response", operation, request_id=identifier, url=url, http_status=result.status_code, headers=dict(result.headers), elapsed_ms=round((time.monotonic() - started) * 1000), body=response, decoded=True) if result.status_code != 200: raise ApiError(f"HTTP {result.status_code},请求已停止") if not isinstance(response, dict): raise ApiError("游戏接口响应不是 JSON 对象,请查看调试窗口") code = response.get("resCode") if code not in (0, "0"): if str(code) == "408": raise ApiError("会话已失效,请重新登录或导入有效会话") raise ApiError(f"游戏接口返回 {code},已停止本轮操作") except ApiError as error: if self.trace: self.trace.emit("error", operation, request_id=identifier, url=url, message=str(error)) raise except requests.RequestException as error: if self.trace: self.trace.emit("error", operation, request_id=identifier, url=url, exception_type=type(error).__name__, message=str(error)) raise ApiError("网络请求未确认完成;已停止执行,请刷新状态后再启动") from error except (ValueError, TypeError) as error: if self.trace: self.trace.emit("error", operation, request_id=identifier, url=url, exception_type=type(error).__name__, message=str(error)) raise ApiError("响应无法解码,请核对会话密钥和服务器地址") from error self.last_receive = time.time() if result.headers.get("Date"): try: self.server_offset = parsedate_to_datetime(result.headers["Date"]).timestamp() - self.last_receive except (ValueError, TypeError): pass return response def snapshot(self): from .model import Snapshot snapshot = Snapshot(self.call("masterService/masterQueryDetail"), server_offset=self.server_offset) role_id = int(snapshot.raw["master"]["id"]) if self.session.role_id and self.session.role_id != role_id: raise ApiError("会话返回了其他角色,已停止;请重新登录并选择区服") self.session.role_id = role_id self.persist_session() return snapshot def settle_growth(self): return self.call("stackService/stackCheckProcess") def sdk_login(self, center_url, uid, sdk_token, channel="DYD", platform="ANDROID", device_id="pc", *, tj_channel="unknow"): result = self.call("userServerService/loginUser", {"sdkUid": uid, "sdkToken": sdk_token, "deviceId": device_id, "channel": channel, "platform": platform, "loginType": "player", "imei": "", "osType": platform, "network": "unknow", "isp": "unknow", "tjChannel": tj_channel}, center_url) try: result["servers"] = server_entries(result, platform) except ApiError as error: if self.trace: self.trace.emit("error", "本地区服整理", scope="local", message=str(error)) raise player = result.get("playerInfo") if not isinstance(player, dict) or not player.get("token"): raise ApiError("游戏登录响应缺少玩家会话,未进入区服") self.session.token = str(player["token"]) self.session.account_id, self.session.channel, self.session.platform = str(uid), channel, platform self.session.server_id = self.session.role_id = 0 return result def enter_server(self, center_url, server, uid, catalog, channel="DYD", platform="ANDROID", device_id="pc"): identifier = server_id(server) address = server.get("gameServerAddress") parsed = urlsplit(address) if isinstance(address, str) else None if not parsed or parsed.scheme not in ("http", "https") or not parsed.netloc or parsed.username: raise ApiError("所选区服缺少有效的 gameServerAddress,未发送进入请求") settings = catalog.data["game_setting"] parts = settings.get(f"{platform}_{channel}_xyz", settings["xyz"]).split("|") tail_uid = uid[int(len(uid) / int(parts[0])):] token = self.session.token tail_token = token[int(len(token) / int(parts[1])):] # Paster.timestampFormat("yyMMdd") uses Date.fullYear, not a two-digit year. date = datetime.now(timezone(timedelta(hours=8))).strftime("%Y%m%d") tracking_channel = catalog.data.get("tjchannel", {}).get("tjchannel", "unknow") values = {"1": tail_uid, "2": tail_token, "3": date} random = hashlib.md5("".join(values[p] for p in parts[2:5]).encode()).hexdigest() if self.trace: self.trace.emit("info", "进入参数检查", scope="local", sign_date=date, date_format="yyyyMMdd", signature_rule="|".join(parts), tj_channel=tracking_channel, platform=platform, channel=channel, uid_length=len(uid), token_length=len(token)) self.call("userServerService/enterGame", {"serverId": identifier, "deviceId": device_id, "network": "unknow", "isp": "unknow", "imei": "", "tjChannel": tracking_channel, "osType": platform, "random": random}, center_url) self.session.server_url = address self.session.server_id, self.session.role_id = identifier, 0 def close(self): self.http.close()