TQHYG's picture
Prism Step offline workspace snapshot (part 4)
13ca229 verified
Raw History Blame Contribute Delete
14.1 kB
// Command patchmasterdata produces a patched copy of Android2/masterdata_encrypted
// in which the end-of-service window is moved into the past.
//
// Why
// ---
// The game decides whether to show the "サービスを終了いたしました" notice by
// comparing masterdata.moduleActivation start_date/end_date against the *device
// clock*, inside IL2CPP native code. A Java (LSPlant) hook cannot reach that, and
// permanently changing the device clock is intrusive. Rewriting the data we already
// serve is the only device-independent lever.
//
// id=4 サービス終了 start 2026-07-31 12:00:00 end 2030-09-11 12:00:00
// id=5 返金受付 start 2026-07-31 12:00:00 end 2026-09-30 12:00:00
//
// Both dates are 19 ASCII bytes, so the replacement is length-preserving and the
// serialized layout (offsets, sizes) stays valid.
//
// Layout
// ------
// masterdata_encrypted (UnityFS, served to the client)
// └─ SerializedFile
// └─ asset ".../appdata/masterdata_encrypted.bytes" (Rijndael-256 CBC)
// └─ UnityFS (inner, LZ4)
// └─ SerializedFile holding masterdata as Unity-serialized binary
// int32 id | int32 len "name" | int32 len "desc"
// | int32 len "start_date" | int32 len "end_date"
//
// The encrypted asset runs exactly to the end of the outer SerializedFile, so its
// length is free: only the little-endian int32 length prefix in front of it has to
// be rewritten.
//
// Usage:
// go run ./cmd/patchmasterdata -workspace "D:\tqhyg\Project\Prism Step"
package main
import (
"encoding/binary"
"encoding/hex"
"flag"
"fmt"
"os"
"path/filepath"
"prismstep/server/internal/rijndael"
"prismstep/server/internal/unityfs"
)
const (
manifestKeyHex = "4a6d636454635737726d41764c686767665265714c787a377170324750777558"
manifestIVHex = "597379693364674d46394b557556524a396a6a344c6766755764564737374543"
oldStart = "2026-07-31 12:00:00"
newStart = "2016-07-31 12:00:00"
newEnd = "2016-09-11 12:00:00"
)
func main() {
ws := flag.String("workspace", ".", "workspace root")
flag.Parse()
src := filepath.Join(*ws, "Game Data", "step3_wget下載後遊戲原始資料", "DL",
"rs.rst-game.com", "Android2", "masterdata_encrypted")
dstDir := filepath.Join(*ws, "src-server-go", "patched", "Android2")
dst := filepath.Join(dstDir, "masterdata_encrypted")
key, _ := hex.DecodeString(manifestKeyHex)
iv, _ := hex.DecodeString(manifestIVHex)
raw, err := os.ReadFile(src)
check(err, "read source")
outer, err := unityfs.Parse(raw)
check(err, "parse outer bundle")
outerData, err := outer.Data()
check(err, "decompress outer bundle")
fmt.Printf("outer bundle : v%d blocks=%d data=%d\n",
outer.Version, len(outer.Blocks), len(outerData))
assetOff, assetCT, innerTotal, err := findEncryptedAsset(outerData, key, iv)
check(err, "locate encrypted asset")
fmt.Printf("encrypted asset : offset=%d len=%d inner_total=%d\n", assetOff, len(assetCT), innerTotal)
innerRaw := rijndael.RawDecrypt(assetCT, key, iv)[:innerTotal]
inner, err := unityfs.Parse(innerRaw)
check(err, "parse inner bundle")
innerData, err := inner.Data()
check(err, "decompress inner bundle")
fmt.Printf("inner bundle : len=%d data=%d\n", len(innerRaw), len(innerData))
// ---- length-preserving patch ----
startStr := indexOf(innerData, append(append([]byte{0x13, 0, 0, 0}, []byte(oldStart)...), 0))
if startStr < 0 {
fatal("id=4 start_date record not found")
}
startStr += 4
endLenOff := startStr + len(oldStart) + 1
endStr := endLenOff + 4
if binary.LittleEndian.Uint32(innerData[endLenOff:endStr]) != 19 {
fatal(fmt.Sprintf("unexpected end_date length prefix %x", innerData[endLenOff:endStr]))
}
fmt.Printf("patch start_date : %q -> %q @%d\n", string(innerData[startStr:startStr+19]), newStart, startStr)
fmt.Printf("patch end_date : %q -> %q @%d\n", string(innerData[endStr:endStr+19]), newEnd, endStr)
patched := make([]byte, len(innerData))
copy(patched, innerData)
copy(patched[startStr:], newStart)
copy(patched[endStr:], newEnd)
// ---- rebuild inner bundle (single stored block) ----
in := inner.Nodes[0]
newInner := unityfs.Build(inner.Version, inner.UnityVersion, inner.UnityRevision,
in.Path, in.Flags, patched, inner.Flags)
fmt.Printf("inner rebuilt : %d -> %d bytes\n", len(innerRaw), len(newInner))
newCT := rijndael.CBCEncryptZeroPad(newInner, key, iv)
// ---- splice into the outer SerializedFile ----
if assetOff+len(assetCT) != len(outerData) {
fatal(fmt.Sprintf("asset is not at the end of outer data (%d+%d != %d)",
assetOff, len(assetCT), len(outerData)))
}
prefixOff := assetOff - 4
if int(binary.LittleEndian.Uint32(outerData[prefixOff:assetOff])) != len(assetCT) {
fatal("asset length prefix mismatch, refusing to patch")
}
newOuterData := make([]byte, 0, prefixOff+4+len(newCT))
newOuterData = append(newOuterData, outerData[:prefixOff]...)
newOuterData = binary.LittleEndian.AppendUint32(newOuterData, uint32(len(newCT)))
newOuterData = append(newOuterData, newCT...)
// The SerializedFile object table stores byteStart/byteSize for every object.
// We changed the last object's length, so its byteSize must be bumped by the
// same delta or Unity rejects the file (it bounds the TextAsset read by it).
delta := int64(len(newOuterData)) - int64(len(outerData))
// SerializedFile header carries its own fileSize; bump it first.
if fileSizeOff := findFileSizeField(outerData, int64(len(outerData))); fileSizeOff >= 0 {
binary.BigEndian.PutUint64(newOuterData[fileSizeOff:], uint64(len(newOuterData)))
fmt.Printf("serializedfile : fileSize @%d %d -> %d\n", fileSizeOff, len(outerData), len(newOuterData))
} else {
fmt.Println("serializedfile : fileSize field not found (header may be non-standard)")
}
// locate the SerializedFile object table; meta starts right after the 48-byte header
metaStart := 48
dataOffset := len(outerData)
if v := int(binary.BigEndian.Uint64(outerData[32:])); v > metaStart && v <= len(outerData) {
dataOffset = v
}
metaEnd := metaStart + int(binary.BigEndian.Uint64(outerData[16:]))
if metaEnd > len(outerData) {
metaEnd = dataOffset
}
sizeOff, _, objCount, found := findObjectTable(outerData, metaStart, metaEnd, dataOffset)
if !found {
dbgDumpHeader(outerData, prefixOff)
fatal("could not locate SerializedFile object table")
}
oldSize := int64(binary.BigEndian.Uint32(outerData[sizeOff:]))
binary.BigEndian.PutUint32(newOuterData[sizeOff:], uint32(oldSize+delta))
fmt.Printf("object table : %d objects, meta=[%d,%d) dataOffset=%d\n", objCount, metaStart, dataOffset, dataOffset)
fmt.Printf("object byteSize : @%d %d -> %d (%+d)\n", sizeOff, oldSize, oldSize+delta, delta)
on := outer.Nodes[0]
newOuter := unityfs.Build(outer.Version, outer.UnityVersion, outer.UnityRevision,
on.Path, on.Flags, newOuterData, outer.Flags)
fmt.Printf("outer rebuilt : %d -> %d bytes\n", len(raw), len(newOuter))
// ---- verify by round-trip ----
vo, err := unityfs.Parse(newOuter)
check(err, "verify: parse outer")
vod, err := vo.Data()
check(err, "verify: decompress outer")
vOff, vCT, vTotal, err := findEncryptedAsset(vod, key, iv)
check(err, "verify: locate asset")
if vOff != prefixOff+4 {
fatal(fmt.Sprintf("asset moved: %d != %d", vOff, prefixOff+4))
}
vInner := rijndael.RawDecrypt(vCT, key, iv)[:vTotal]
vi, err := unityfs.Parse(vInner)
check(err, "verify: parse inner")
vid, err := vi.Data()
check(err, "verify: decompress inner")
if countOf(vid, []byte(oldStart)) != countOf(innerData, []byte(oldStart))-1 {
fatal("expected exactly one start_date occurrence to change")
}
if countOf(vid, []byte(newStart)) != 1 || countOf(vid, []byte(newEnd)) != 1 {
fatal("patched dates missing")
}
if len(vid) != len(innerData) {
fatal("inner data length changed")
}
check(os.MkdirAll(dstDir, 0o755), "mkdir patched")
check(os.WriteFile(dst, newOuter, 0o644), "write patched bundle")
overrides := fmt.Sprintf("{\n \"masterdata_encrypted\": %d\n}\n", len(newOuter))
check(os.WriteFile(filepath.Join(*ws, "src-server-go", "patched", "overrides.json"), []byte(overrides), 0o644), "write overrides")
fmt.Println()
fmt.Printf("OK -> %s\n", dst)
fmt.Printf(" size %d (source %d)\n", len(newOuter), len(raw))
fmt.Println(" overrides.json written (manifest size override)")
}
// findEncryptedAsset scans for a 32-byte block that decrypts to a UnityFS header.
func findEncryptedAsset(data, key, iv []byte) (off int, ct []byte, total int64, err error) {
block := rijndael.NewRijndael256(key)
for o := 0; o+rijndael.BlockSize <= len(data); o++ {
dec := block.DecryptBlock(data[o : o+rijndael.BlockSize])
head := make([]byte, 8)
for i := range head {
head[i] = dec[i] ^ iv[i]
}
if string(head) != "UnityFS\x00" {
continue
}
need := 256
ctLen := ((need + 31) / 32) * 32
if o+ctLen > len(data) {
return 0, nil, 0, fmt.Errorf("truncated asset header")
}
head2 := rijndael.RawDecrypt(data[o:o+ctLen], key, iv)
t, e := innerTotalSize(head2)
if e != nil {
return 0, nil, 0, e
}
full := int(((t + 31) / 32) * 32)
if o+full > len(data) {
return 0, nil, 0, fmt.Errorf("asset overruns data")
}
return o, data[o : o+full], t, nil
}
return 0, nil, 0, fmt.Errorf("encrypted inner bundle not found")
}
// innerTotalSize reads total_size from a decrypted UnityFS header.
func innerTotalSize(b []byte) (int64, error) {
p := 0
readCStr := func() (string, error) {
for i := p; i < len(b); i++ {
if b[i] == 0 {
s := string(b[p:i])
p = i + 1
return s, nil
}
}
return "", fmt.Errorf("bad cstring")
}
if _, err := readCStr(); err != nil { // "UnityFS"
return 0, err
}
p += 4 // version
if _, err := readCStr(); err != nil {
return 0, err
}
if _, err := readCStr(); err != nil {
return 0, err
}
if p+8 > len(b) {
return 0, fmt.Errorf("short header")
}
return int64(binary.BigEndian.Uint64(b[p:])), nil
}
func indexOf(h, n []byte) int {
for i := 0; i+len(n) <= len(h); i++ {
match := true
for j := range n {
if h[i+j] != n[j] {
match = false
break
}
}
if match {
return i
}
}
return -1
}
// findObjectTable locates the SerializedFile object table (m_Objects).
//
// IMPORTANT: the SerializedFile *header* is big-endian, but the metadata that
// follows it (type trees, m_Objects) is little-endian in this file - verified by
// decoding typeCount=2, classID=142 (AssetBundle) and nodeCount=58 in LE.
//
// We validate the whole table rather than hunting a single number: objectCount
// followed by `count` entries, each (pathID, byteStart, byteSize), in one of the
// historical widths. A candidate is accepted only if every entry is sane, entries
// are ascending and non-overlapping, and the last one reaches the end of data.
func findObjectTable(data []byte, metaStart, metaEnd, dataOffset int) (sizeOff, sizeW int, count int, ok bool) {
type layout struct{ entryW, startOff, startW, sizeOff int }
layouts := []layout{
{20, 8, 8, 16}, // v22+ : pathID i64, byteStart i64, byteSize u32
{16, 8, 4, 12}, // v17+ : pathID i64, byteStart u32, byteSize u32
{12, 4, 4, 8}, // older: pathID i32, byteStart u32, byteSize u32
}
dataLen := len(data)
if metaEnd > dataLen {
metaEnd = dataLen
}
best := -1
for _, bo := range []binary.ByteOrder{binary.LittleEndian, binary.BigEndian} {
for _, l := range layouts {
for o := metaStart; o+4+l.entryW <= metaEnd; o++ {
n := int(bo.Uint32(data[o:]))
if n < 1 || n > 64 {
continue
}
if o+4+n*l.entryW > metaEnd {
continue
}
good := true
var prevEnd int64
lastSizeOff := -1
for k := 0; k < n; k++ {
base := o + 4 + k*l.entryW
var start int64
if l.startW == 8 {
start = int64(bo.Uint64(data[base+l.startOff:]))
} else {
start = int64(bo.Uint32(data[base+l.startOff:]))
}
size := int64(bo.Uint32(data[base+l.sizeOff:]))
if start < int64(dataOffset) || size <= 0 || start+size > int64(dataLen) {
good = false
break
}
if k > 0 && start < prevEnd {
good = false
break
}
prevEnd = start + size
lastSizeOff = base + l.sizeOff
}
if !good || int64(dataLen)-prevEnd > 16 {
continue
}
score := o
if score > best {
best = score
sizeOff = lastSizeOff
sizeW = 4
count = n
ok = true
}
}
}
}
return
}
// findFileSizeField returns the offset of the SerializedFile header `fileSize`
// field: the u64 equal to the current data length near the header start.
func findFileSizeField(data []byte, dataLen int64) int {
limit := 128
if limit > len(data)-8 {
limit = len(data) - 8
}
for o := 0; o < limit; o++ {
if int64(binary.BigEndian.Uint64(data[o:])) == dataLen {
return o
}
}
return -1
}
// dbgDumpHeader prints the header words when the object table cannot be located.
func dbgDumpHeader(data []byte, assetStart int) {
fmt.Println("--- debug: header ---")
fmt.Printf("data len=%d assetStart=%d\n", len(data), assetStart)
n := 112
if n > len(data) {
n = len(data)
}
for i := 0; i < n; i += 16 {
end := i + 16
if end > n {
end = n
}
fmt.Printf("%04x % x\n", i, data[i:end])
}
}
func countOf(h, n []byte) int { c := 0
for i := 0; i+len(n) <= len(h); i++ {
match := true
for j := range n {
if h[i+j] != n[j] {
match = false
break
}
}
if match {
c++
i += len(n) - 1
}
}
return c
}
func fatal(msg string) {
fmt.Fprintf(os.Stderr, "[fatal] %s\n", msg)
os.Exit(1)
}
func check(err error, what string) {
if err != nil {
fatal(what + ": " + err.Error())
}
}