#!/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(" {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())