284 lines
14 KiB
Python
284 lines
14 KiB
Python
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):
|
||
def __init__(self, message, *, code=None):
|
||
super().__init__(message)
|
||
self.code = code
|
||
|
||
|
||
class SessionExpiredError(ApiError):
|
||
"""The game explicitly rejected its saved session (resCode 408)."""
|
||
|
||
|
||
class TemporaryApiError(ApiError):
|
||
"""Transport/server failure with an unknown outcome; never replay writes."""
|
||
|
||
|
||
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:
|
||
error_type = TemporaryApiError if result.status_code in (408, 429) or result.status_code >= 500 else ApiError
|
||
raise error_type(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:
|
||
error_type = TemporaryApiError if result.status_code in (408, 429) or result.status_code >= 500 else ApiError
|
||
raise error_type(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 SessionExpiredError("会话已失效,请手动恢复会话或重新登录", code=408)
|
||
raise ApiError(f"游戏接口返回 {code},已停止本轮操作", code=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 TemporaryApiError("网络请求未确认完成;已停止执行,请刷新状态后再启动") 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()
|