Download tools/patch_masterdata.py from TQHYG/Prism-Step-SRV: direct link, hf CLI and curl.
- Browser
- Download file 15.4 kB
-
https://huggingface.co/datasets/TQHYG/Prism-Step-SRV/resolve/main/tools/patch_masterdata.py
- Command line
-
hf download hf://datasets/TQHYG/Prism-Step-SRV/tools/patch_masterdata.py
-
curl -L -o patch_masterdata.py https://huggingface.co/datasets/TQHYG/Prism-Step-SRV/resolve/main/tools/patch_masterdata.py
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()) | |