Files

284 lines
14 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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()