169 lines
8.2 KiB
Python
169 lines
8.2 KiB
Python
"""Recover original offline libraries and tables from the pinned local APK."""
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import hashlib
|
|
import json
|
|
import struct
|
|
from pathlib import Path
|
|
import sys
|
|
import uuid
|
|
import zipfile
|
|
import zlib
|
|
|
|
ROOT = Path(__file__).resolve().parents[2]
|
|
sys.path.insert(0, str(ROOT))
|
|
from ranch_assistant.amf import Reader
|
|
from tools.battle_runtime.swf_library import digest, library_only
|
|
|
|
APK_SHA256 = "01678ee3a8465d818d32cbbd94baa0d8253b04b4c57b70ebc5544ed341f1015d"
|
|
MAIN_SHA256 = "c6838331a198a22ffa486cbf61cc74c97619e011bc3364c8bb8dc99e269036cf"
|
|
TABLES = ("setting", "game_setting", "monster_info", "monster_skill", "monster_setting",
|
|
"monster_level", "monster_fix", "team_info", "stage_info", "task_info",
|
|
"item_info", "potential_info", "entangle_info", "skin_info", "upstar_info")
|
|
|
|
|
|
def write_atomic(path: Path, data: bytes):
|
|
# Prepared resources are immutable for the pinned APK. Reusing identical
|
|
# bytes also avoids Windows rename failures while another AIR job reads a
|
|
# shared resource (each job still has its own application/storage/cwd).
|
|
if path.is_file() and path.read_bytes() == data:
|
|
return
|
|
temporary = path.with_name(path.name + "." + uuid.uuid4().hex + ".tmp")
|
|
try:
|
|
temporary.write_bytes(data)
|
|
try:
|
|
temporary.replace(path)
|
|
except PermissionError:
|
|
# Another preparer may have published the exact same bytes after
|
|
# our first check. Never accept a different or partially read file.
|
|
if not path.is_file() or path.read_bytes() != data:
|
|
raise
|
|
finally:
|
|
temporary.unlink(missing_ok=True)
|
|
|
|
|
|
def write_json(path: Path, data):
|
|
write_atomic(path, json.dumps(data, ensure_ascii=False, allow_nan=False, indent=2).encode("utf-8"))
|
|
|
|
|
|
def asset_index(apk: Path, archive: zipfile.ZipFile) -> dict:
|
|
"""Bind original packed-resource keys to their verified ZIP byte ranges."""
|
|
entries = {}
|
|
archive_size = apk.stat().st_size
|
|
with apk.open("rb") as source:
|
|
for item in archive.infolist():
|
|
if not item.filename.startswith("assets/codes/") or item.is_dir():
|
|
continue
|
|
key = item.filename.removeprefix("assets/codes/")
|
|
if len(key) != 32 or any(c not in "0123456789abcdef" for c in key) or item.flag_bits & 1 or item.compress_type not in (0,8):
|
|
raise ValueError("Unsupported original asset ZIP member")
|
|
if key in entries:
|
|
raise ValueError("Duplicate original asset ZIP member")
|
|
source.seek(item.header_offset)
|
|
header = source.read(30)
|
|
if len(header) != 30 or header[:4] != b"PK\x03\x04":
|
|
raise ValueError("Original ZIP local header mismatch")
|
|
flags, method = struct.unpack_from("<HH",header,6)
|
|
if flags != item.flag_bits or method != item.compress_type:
|
|
raise ValueError("Original ZIP local metadata mismatch")
|
|
filename_size, extra_size = struct.unpack_from("<HH", header, 26)
|
|
encoded_name = source.read(filename_size)
|
|
if encoded_name.decode("utf-8" if flags & 0x800 else "cp437") != item.filename:
|
|
raise ValueError("Original ZIP local filename mismatch")
|
|
offset = item.header_offset + 30 + filename_size + extra_size
|
|
if offset < 0 or offset + item.compress_size > archive_size:
|
|
raise ValueError("Original asset ZIP member escapes archive")
|
|
entries[key] = {"offset":offset,"compressed_size":item.compress_size,
|
|
"size":item.file_size,"method":item.compress_type,"crc32":item.CRC}
|
|
return entries
|
|
|
|
|
|
def prepare(apk: Path | None = None, *, assets: bool = False) -> dict:
|
|
if apk is None:
|
|
candidates = list(ROOT.glob("*_1.9.68.apk"))
|
|
if len(candidates) != 1:
|
|
raise ValueError("Expected exactly one original *_1.9.68.apk")
|
|
apk = candidates[0]
|
|
with apk.open("rb") as stream:
|
|
sha = hashlib.file_digest(stream, "sha256").hexdigest()
|
|
if sha != APK_SHA256:
|
|
raise ValueError("Original APK SHA-256 mismatch")
|
|
root = ROOT / "local_state/battle_runtime/original"
|
|
root.mkdir(parents=True, exist_ok=True)
|
|
manifest = {"apk_sha256": sha, "main_swf_sha256": MAIN_SHA256, "libraries": {}, "tables": {}}
|
|
with zipfile.ZipFile(apk) as archive:
|
|
entries = asset_index(apk,archive)
|
|
write_json(root / "asset_index.json", {"apk_path":str(apk.resolve()),"apk_sha256":sha,"entries":entries})
|
|
manifest["asset_index_sha256"] = digest((root / "asset_index.json").read_bytes())
|
|
for member, filename in (("assets/MYRDyd.swf", "framework.library.swf"),
|
|
("assets/MYRMain.app", "main.library.swf")):
|
|
original = archive.read(member)
|
|
if member.endswith("MYRMain.app") and digest(original) != MAIN_SHA256:
|
|
raise ValueError("Original main SWF SHA-256 mismatch")
|
|
library, identity = library_only(original)
|
|
write_atomic(root / filename, library)
|
|
manifest["libraries"][filename] = identity
|
|
tables = {}
|
|
(root / "tables").mkdir(exist_ok=True)
|
|
for name in TABLES:
|
|
member = "assets/codes/" + hashlib.md5(f"data/table/{name}.json".encode()).hexdigest()
|
|
if member not in archive.namelist():
|
|
manifest["tables"][name] = {"missing": True}
|
|
continue
|
|
compressed = archive.read(member)
|
|
write_atomic(root / "tables" / (name + ".amf.zlib"), compressed)
|
|
decoded = zlib.decompress(compressed)
|
|
reader = Reader(decoded)
|
|
value = reader.read()
|
|
if reader.pos != len(decoded):
|
|
raise ValueError(f"Trailing original table bytes: {name}")
|
|
tables[name] = value
|
|
manifest["tables"][name] = {"member": member, "sha256": digest(compressed)}
|
|
write_json(root / "tables.json", tables)
|
|
write_json(root / "table_index.json", list(tables))
|
|
manifest["tables_json_sha256"] = digest((root / "tables.json").read_bytes())
|
|
# Preserve actual libraries/assets locally. No APK is rebuilt or installed.
|
|
for member in ("assets/baseui.swf", "assets/ui/mainui.swf", "assets/ui/mainui2.swf",
|
|
"assets/ui/mainui3.swf", "assets/ui/movieclip.swf"):
|
|
original = archive.read(member)
|
|
library, identity = library_only(original)
|
|
path = root / (Path(member).stem + ".library.swf")
|
|
write_atomic(path, library)
|
|
manifest["libraries"][path.name] = identity
|
|
if assets:
|
|
asset_count = asset_bytes = 0
|
|
destination = root / "codes"
|
|
destination.mkdir(exist_ok=True)
|
|
for item in archive.infolist():
|
|
if item.filename.startswith("assets/codes/") and not item.is_dir():
|
|
basename = item.filename.removeprefix("assets/codes/")
|
|
if len(basename) != 32 or any(c not in "0123456789abcdef" for c in basename):
|
|
raise ValueError("Unexpected original asset member")
|
|
path = destination / basename
|
|
if not path.exists() or path.stat().st_size != item.file_size:
|
|
write_atomic(path, archive.read(item))
|
|
asset_count += 1
|
|
asset_bytes += item.file_size
|
|
write_json(root / "assets_prepared.json", {"count":asset_count,"bytes":asset_bytes,
|
|
"source_apk_sha256":sha})
|
|
manifest["asset_count"] = asset_count
|
|
write_json(root / "identity.json", manifest)
|
|
return manifest
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(description=__doc__)
|
|
parser.add_argument("--apk", type=Path)
|
|
parser.add_argument("--assets", action="store_true")
|
|
args = parser.parse_args()
|
|
manifest = prepare(args.apk, assets=args.assets)
|
|
print(json.dumps({"main_swf_sha256": manifest["main_swf_sha256"],
|
|
"libraries": {name: {k: v for k, v in row.items() if k in (
|
|
"removed_document_classes", "abc_count", "lazy_flags_changed", "abc_bytes_preserved")}
|
|
for name, row in manifest["libraries"].items()}}))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|