Prism-Step-SRV / tools /patch_masterdata.py
TQHYG's picture
Prism Step offline workspace snapshot (part 4)
13ca229 verified
Raw History Blame Contribute Delete
15.4 kB
#!/usr/bin/env python3
"""
停服公告「等长替换」补丁生成器
背景
----
停服公告由 masterdata.moduleActivation 的时间窗决定(与设备时钟比较):
{"id":4,"name":"サービス終了","start_date":"2026-07-31 12:00:00","end_date":"2030-09-11 12:00:00"}
{"id":5,"name":"返金受付", "start_date":"2026-07-31 12:00:00","end_date":"2026-09-30 12:00:00"}
把 id=4 的 start/end 都改到过去,判定就永远为 false。日期字符串等长(19 字符),
所以 JSON 长度不变 -> 内层 SerializedFile 的所有偏移不变。
数据结构层级
------------
rs.rst-game.com/Android2/masterdata_encrypted <- UnityFS 外层 bundle(客户端下载这个)
└─ SerializedFile
└─ 资源 ".../appdata/masterdata_encrypted.bytes" <- Rijndael-256 加密的字节流
└─ UnityFS 内层 bundle
└─ SerializedFile
└─ masterdata.json(含 moduleActivation)
补丁策略(不重压缩、不改大小)
------------------------------
1. 解压外层 -> 定位加密资源区间(用「解出的头 32 字节异或 IV 后是否以 UnityFS 开头」扫描)
2. 解密该区间 -> 内层 bundle -> 解压 -> 得到 JSON 字节
3. JSON 等长替换两个日期
4. 重新打包**内层** bundle:单块 STORED + 零填充,使总长度与原内层 bundle **完全相等**
5. 重新加密(长度自然相等)
6. **只把外层文件中对应 STORED 区块的那几个字节区间原地覆写** -> 外层文件大小与结构完全不变
用法:
python tools/patch_masterdata.py
输出:
src-server-go/patched/masterdata_encrypted
"""
from __future__ import annotations
import hashlib
import pathlib
import struct
import sys
WS = pathlib.Path(__file__).resolve().parent.parent
sys.path.insert(0, str(WS / "src-server"))
import rijndael256 # noqa: E402 (verified byte-for-byte against BouncyCastle)
KEY = b"JmcdTcW7rmAvLhggfReqLxz7qp2GPwuX"
IV = b"Ysyi3dgMF9KUuVRJ9jj4LgfuWdVG77EC"
SRC = WS / "Game Data/step3_wget下載後遊戲原始資料/DL/rs.rst-game.com/Android2/masterdata_encrypted"
DST = WS / "src-server-go/patched/masterdata_encrypted"
# 等长替换:都是 19 字节
OLD_START = b"2026-07-31 12:00:00" # id=4 start(同时是 id=5 start,按出现顺序取第一个)
NEW_START = b"2016-07-31 12:00:00"
NEW_END = b"2016-09-11 12:00:00" # id=4 end(原 2030-09-11 12:00:00)
# ------------------------------------------------------------------ UnityFS read
class Reader:
def __init__(self, d: bytes, p: int = 0):
self.d, self.p = d, p
def cstr(self) -> str:
e = self.d.index(b"\x00", self.p)
s = self.d[self.p:e].decode("utf-8", "replace")
self.p = e + 1
return s
def u32(self) -> int:
v = struct.unpack_from(">I", self.d, self.p)[0]
self.p += 4
return v
def i64(self) -> int:
v = struct.unpack_from(">q", self.d, self.p)[0]
self.p += 8
return v
def raw(self, n: int) -> bytes:
b = self.d[self.p:self.p + n]
self.p += n
return b
def align16(self) -> None:
self.p = (self.p + 15) & ~15
def lz4_block_decompress(src: bytes, expected: int | None = None) -> bytes:
dst = bytearray()
i, n = 0, len(src)
while i < n:
token = src[i]; i += 1
lit = token >> 4
if lit == 15:
while True:
b = src[i]; i += 1; lit += b
if b != 255:
break
dst += src[i:i + lit]; i += lit
if i >= n:
break
off = src[i] | (src[i + 1] << 8); i += 2
if off == 0:
raise ValueError("lz4 zero offset")
ml = token & 0x0F
if ml == 15:
while True:
b = src[i]; i += 1; ml += b
if b != 255:
break
ml += 4
start = len(dst) - off
for k in range(ml):
dst.append(dst[start + k])
if expected is not None and len(dst) != expected:
raise ValueError(f"lz4 size {len(dst)} != {expected}")
return bytes(dst)
def decompress(kind: int, data: bytes, expected: int | None = None) -> bytes:
if kind == 0:
return data
if kind in (2, 3):
return lz4_block_decompress(data, expected)
raise NotImplementedError(f"compression {kind}")
def parse_bundle(raw: bytes) -> dict:
r = Reader(raw)
sig = r.cstr()
if sig != "UnityFS":
raise ValueError(f"not UnityFS: {sig!r}")
version = r.u32()
unity_version = r.cstr()
unity_revision = r.cstr()
total_size = r.i64()
ci_size = r.u32()
ui_size = r.u32()
flags = r.u32()
header_end = r.p
if version >= 7:
r.align16()
header_end = r.p
bi_raw = r.raw(ci_size)
bi = decompress(flags & 0x3F, bi_raw, ui_size) if ci_size != ui_size else bi_raw
b = Reader(bi)
data_hash = b.raw(16)
block_count = b.u32()
blocks = []
for _ in range(block_count):
blocks.append({"u": b.u32(), "c": b.u32(), "f": struct.unpack_from(">H", bi, b.p)[0]})
b.p += 2
node_count = b.u32()
nodes = []
for _ in range(node_count):
off = b.i64(); size = b.i64(); nflags = b.u32(); path = b.cstr()
nodes.append({"offset": off, "size": size, "flags": nflags, "path": path})
if version >= 7 and (flags & 0x200):
r.align16()
return {
"version": version, "unity_version": unity_version, "unity_revision": unity_revision,
"total_size": total_size, "ci_size": ci_size, "ui_size": ui_size, "flags": flags,
"data_hash": data_hash, "blocks": blocks, "nodes": nodes,
"data_start": r.p, "header_end": header_end, "bi_raw": bi_raw,
}
def extract_data(info: dict, raw: bytes) -> bytes:
pos = info["data_start"]
out = bytearray()
for blk in info["blocks"]:
chunk = raw[pos:pos + blk["c"]]
pos += blk["c"]
out += decompress(blk["f"] & 0x3F, chunk, blk["u"])
return bytes(out)
# ----------------------------------------------------------------- UnityFS write
def build_bundle(version: int, unity_version: str, unity_revision: str,
node_path: str, node_flags: int, data: bytes,
base_flags: int = 0x40, target_total: int | None = None) -> bytes:
"""Emit a UnityFS bundle with ONE stored block. Optional exact total size."""
uv = unity_version.encode() + b"\x00"
ur = unity_revision.encode() + b"\x00"
def assemble(d: bytes) -> bytes:
blocks_info = bytearray()
blocks_info += hashlib.md5(d).digest()
blocks_info += struct.pack(">I", 1)
blocks_info += struct.pack(">III", len(d), len(d), 0)[:10] # u32,u32,u16
node_blob = bytearray()
node_blob += struct.pack(">I", 1)
node_blob += struct.pack(">qqI", 0, len(d), node_flags & ~0x3F)
node_blob += node_path.encode() + b"\x00"
blocks_info += node_blob
flags = base_flags & ~0x3F # no compression for blocksInfo
flags &= ~0x200 # we will not align after blocksInfo
hdr = bytearray(b"UnityFS\x00")
hdr += struct.pack(">I", version)
hdr += uv + ur
total = 0 # patched below
hdr += struct.pack(">q", total)
hdr += struct.pack(">II", len(blocks_info), len(blocks_info))
hdr += struct.pack(">I", flags)
if version >= 7:
pad = (-len(hdr)) % 16
hdr += b"\x00" * pad
body = bytes(hdr) + bytes(blocks_info) + d
total = len(body)
# total_size is an 8-byte big-endian field right after the two cstrings
off = 8 + 4 + len(uv) + len(ur)
body = body[:off] + struct.pack(">q", total) + body[off + 8:]
return body
if target_total is None:
return assemble(data)
# ui_size is independent of data length, so one correction pass is enough
probe = assemble(data + b"\x00" * 64)
delta = target_total - len(probe)
pad = max(0, 64 + delta)
out = assemble(data + b"\x00" * pad)
if len(out) != target_total:
# second pass, exact
out2 = assemble(data + b"\x00" * max(0, pad + (target_total - len(out))))
out = out2
if len(out) != target_total:
raise RuntimeError(f"cannot hit target size {target_total}, got {len(out)}")
return out
# ------------------------------------------------------------------- patch logic
def cbc_decrypt_raw(ct: bytes) -> bytes:
"""CBC decrypt WITHOUT stripping trailing zeros.
rijndael256.cbc_decrypt() strips trailing NULs (ZeroPadding semantics), which
truncates a bundle whose last bytes happen to be zero. We need the exact
ciphertext length here.
"""
cipher = rijndael256.Rijndael256(KEY)
prev = IV
out = bytearray()
for i in range(0, len(ct), 32):
blk = ct[i:i + 32]
dec = cipher.decrypt_block(blk)
out += bytes(a ^ b for a, b in zip(dec, prev))
prev = blk
return bytes(out)
def find_encrypted_asset(outer_data: bytes) -> tuple[int, bytes, int]:
"""Scan for the Rijndael-256 encrypted inner bundle; return (offset, ciphertext, inner_total)."""
n = len(outer_data)
for off in range(0, n - 32):
blk = outer_data[off:off + 32]
plain = rijndael256.Rijndael256(KEY).decrypt_block(blk)
head = bytes(a ^ b for a, b in zip(plain, IV))
if head.startswith(b"UnityFS\x00"):
# inner total size lives after the two cstrings; decrypt more to read it
need = 256
ct = outer_data[off:off + ((need + 31) // 32) * 32]
inner = cbc_decrypt_raw(ct)
r = Reader(inner)
r.cstr()
r.u32()
r.cstr()
r.cstr()
total = struct.unpack_from(">q", inner, r.p)[0]
ct_len = ((total + 31) // 32) * 32
return off, outer_data[off:off + ct_len], total
raise RuntimeError("encrypted inner bundle not found")
def main() -> int:
raw = SRC.read_bytes()
print(f"source : {SRC.name} ({len(raw)} bytes)")
outer = parse_bundle(raw)
outer_data = extract_data(outer, raw)
print(f"outer bundle : v{outer['version']} blocks={len(outer['blocks'])} "
f"data={len(outer_data)} nodes={len(outer['nodes'])}")
print(f"outer flags : 0x{outer['flags']:08x}")
asset_off, asset_ct, inner_total = find_encrypted_asset(outer_data)
print(f"encrypted asset : offset={asset_off} len={len(asset_ct)} inner_total={inner_total}")
inner_raw = cbc_decrypt_raw(asset_ct)[:inner_total]
inner = parse_bundle(inner_raw)
inner_data = extract_data(inner, inner_raw)
print(f"inner bundle : len={len(inner_raw)} data={len(inner_data)} "
f"node={inner['nodes'][0]['path']}")
# ---- equal-length binary patch ----
# The bundle stores masterdata as Unity-serialized binary, NOT JSON text:
# int32 id | int32 len "name" 0x00 0x00 | int32 len "description" 0x00 0x00
# | int32 len "start_date" 0x00 | int32 len "end_date" 0x00
# Each string is preceded by a little-endian int32 length and followed by a NUL.
# So for id=4: end_date string starts exactly 19 (start) + 1 (NUL) + 4 (len) after
# the start_date string. Both dates are 19 chars -> equal-length replacement.
i0 = inner_data.find(b"\x13\x00\x00\x00" + OLD_START + b"\x00")
if i0 < 0:
print("!! id=4 start_date record not found")
return 3
start_str = i0 + 4
end_len_off = start_str + len(OLD_START) + 1
end_str = end_len_off + 4
if inner_data[end_len_off:end_str] != b"\x13\x00\x00\x00":
print(f"!! unexpected end_date length prefix: {inner_data[end_len_off:end_str]!r}")
return 3
old_end = inner_data[end_str:end_str + len(NEW_END)]
print(f"patch start_date : {OLD_START.decode()} -> {NEW_START.decode()} @{start_str}")
print(f"patch end_date : {old_end.decode()} -> {NEW_END.decode()} @{end_str}")
patched = bytearray(inner_data)
patched[start_str:start_str + len(NEW_START)] = NEW_START
patched[end_str:end_str + len(NEW_END)] = NEW_END
patched = bytes(patched)
assert len(patched) == len(inner_data)
# ---- rebuild inner bundle (stored block, length may change) ----
node = inner["nodes"][0]
new_inner = build_bundle(inner["version"], inner["unity_version"], inner["unity_revision"],
node["path"], node["flags"], patched,
base_flags=inner["flags"])
print(f"inner rebuilt : {len(inner_raw)} -> {len(new_inner)} bytes")
new_ct = rijndael256.cbc_encrypt(new_inner, KEY, IV)
print(f"asset ciphertext : {len(asset_ct)} -> {len(new_ct)} bytes")
# ---- splice into the outer SerializedFile ----
# The encrypted asset runs exactly to the end of the outer data (verified
# below), so its length is free: we only have to rewrite the little-endian
# int32 length prefix that precedes it. Nothing after it can shift.
if asset_off + len(asset_ct) != len(outer_data):
print(f"!! asset is not at the end of outer data "
f"({asset_off}+{len(asset_ct)} != {len(outer_data)})")
return 4
prefix_off = asset_off - 4
prefix = outer_data[prefix_off:asset_off]
declared = struct.unpack("<i", prefix)[0]
print(f"asset length prefix: {declared} (expected {len(asset_ct)})")
if declared != len(asset_ct):
print("!! length prefix does not match asset length - refusing to patch")
return 4
new_outer_data = bytearray(outer_data[:prefix_off])
new_outer_data += struct.pack("<i", len(new_ct))
new_outer_data += new_ct
node_o = outer["nodes"][0]
new_outer = build_bundle(outer["version"], outer["unity_version"], outer["unity_revision"],
node_o["path"], node_o["flags"], bytes(new_outer_data),
base_flags=outer["flags"])
print(f"outer rebuilt : {len(raw)} -> {len(new_outer)} bytes")
# ---- verify by re-reading the rebuilt bundle ----
v_outer = parse_bundle(new_outer)
v_data = extract_data(v_outer, new_outer)
v_off, v_ct, v_total = find_encrypted_asset(v_data)
if v_off != prefix_off + 4:
print(f"!! asset offset moved {v_off} != {prefix_off + 4}")
return 5
v_inner = cbc_decrypt_raw(v_ct)[:v_total]
check_data = extract_data(parse_bundle(v_inner), v_inner)
if NEW_START not in check_data or NEW_END not in check_data:
print("!! patch verification failed")
return 5
if OLD_START in check_data:
print("!! old start_date still present")
return 5
DST.parent.mkdir(parents=True, exist_ok=True)
DST.write_bytes(new_outer)
(DST.parent / "overrides.json").write_text(
"{\n \"masterdata_encrypted\": " + str(len(new_outer)) + "\n}\n", encoding="utf-8")
print()
print(f"OK -> {DST}")
print(f" size {len(new_outer)} bytes (source was {len(raw)})")
print(f" sha256 {hashlib.sha256(new_outer).hexdigest()}")
print(f" overrides.json written so the served manifest declares the new size")
return 0
if __name__ == "__main__":
raise SystemExit(main())