恋爱0公里 PSP 版 CRI CPK 封包格式分析与解包工具实现

开发技术
6 编辑于
kinotern

摘要:本文分析《恋爱0公里》(恋愛0キロメートル)PSP 版 UMD 镜像中的两个 CRI CPK 容器,确定其版本为 CPK Maker 2.30.04,给出容器头、UTF 表、目录表、数据区对齐、CRILAYLA 压缩四层结构的完整字段布局,并实现可双向工作的解包与重打包工具。DATA1.CPK 的 2124 个文件全部解出,1954 个经 CRILAYLA 解码还原;DATA0.CPK 的 19408 个条目经 ITOC 双表重建偏移后按 ID 导出。重打包采用「未改动条目保留原压缩块、改动条目以未压缩方式写入、总体积不超出原文件」的不变式,绕开了压缩器的实现。验证分三组:原样回填逐字节相同、原样重打包后二次解包 2124 个文件哈希全等、单文件改写后回读内容正确且其余条目不受影响。


关键词:CRI CPK;CRILAYLA;UMD;游戏资源封包;逆向工程

1 对象与问题

1.1 镜像构成

待处理的目录 UMD9660 是 UMD 镜像解开后的 ISO9660 根,结构如下:

UMD9660/
├─ PSP_GAME/PARAM.SFO
├─ PSP_GAME/SYSDIR/EBOOT.BIN     1 089 328 字节,~PSP 加密
├─ PSP_GAME/SYSDIR/BOOT.BIN      1 088 985 字节,未加密
├─ PSP_GAME/INSDIR/DATA1.DNS     273 974 768 字节,安装镜像
└─ PSP_GAME/USRDIR/data/
   ├─ DATA0.CPK                  546 778 125 字节
   └─ DATA1.CPK                  269 759 608 字节

PARAM.SFO 与 EBOOT.BIN 说明这是正规发行的 PSP 软件包,不是模拟器打包。INSDIR/DATA1.DNS 与 DATA1.CPK 内容重复,前者供记忆棒安装流程使用,后者供直接从 UMD 运行使用。两者必须同步替换,否则安装版和直读版会读到不同数据。

1.2 两个包的分工

按解包结果,DATA1.CPK 装的是可读资源,共 2124 个文件:

目录数量用途
script/*.txt144剧本
visual/adv/*.pac1680立绘、背景、事件图
visual/system/*.pac21系统界面
visual/thumb/*.pac85CG 缩略图
visual/wipe/*.ext26转场效果
sound/bgm, sound/se170ADX 音频
movie/*.pmf3PSMF 视频
font/*.ext7位图字体
CCC/jis2ucs.bin 等2编码转换表

DATA0.CPK 装 19408 个条目,魔数全部落在 AHX 上,即 CRI 加密 ADX。两包的分工很明确:可寻址的高层资源进 DATA1,海量短音频进 DATA0。

1.3 为什么这样切分

UMD 单层容量 1.8 GB,双层的读取速度在 2 倍速下约 1.1 MB/s,寻道代价远高于顺序读取。把资源切成两个包有两个直接好处。其一,语音和音效数量大、单个体积小,放在独立包里可以顺序预读整段,不必和立绘争抢读取队列。其二,音频包按 ID 索引,省掉了 19408 个文件名的字符串表,按平均每个名字 20 字节算能省约 400 KB,代价是包里没有名字,只能按 ID 访问。

2 格式判定

2.1 容器头

DATA0.CPK 与 DATA1.CPK 开头 0x20 字节:

43 50 4b 20 ff 00 00 00 a0 02 00 00 00 00 00 00  CPK ............
40 55 54 46 00 00 02 98 00 00 00 c7 00 00 01 25  @UTF...........%

CPK 是 CRI 的容器魔数,紧跟的 @UTF 是 CRI 自有的表格式。表头 8 字节偏移处记着表本身的长度,0x2A0 对应 672 字节。文件尾部的字符串表里能读到 CPKMC2.30.04, DLL3.00.04,这是打包工具的版本号,直接写在 CpkHeader 表的 Tvers 字段里,也决定了后续所有字段布局按 2.30 处理。

CPK 的目录有三种形态:CpkTocInfo(带文件名的普通 TOC)、CpkItocL / CpkItocH(只有 ID 与大小的 ITOC)、CpkGtocInfo 系列(分组表)。扫描 DATA1.CPK 前 8 MB 只找到 7 张 @UTF 表:

0x00000010  CpkHeader       cols=35 rowlen=142 rows=1
0x00000810  CpkTocInfo      cols=7  rowlen=28  rows=2124
0x0001a810  CpkExtendId     cols=2  rowlen=8   rows=2124
0x0001f010  CpkGtocInfo     cols=6  rowlen=36  rows=1
0x0001f0b0  CpkGtocGlink    cols=3  rowlen=12  rows=3
0x0001f138  CpkGtocFlink    cols=4  rowlen=12  rows=2126
0x00025548  CpkGtocAttr     cols=4  rowlen=14  rows=1

DATA0.CPK 则是 4 张:

0x00000010  CpkHeader     cols=35 rowlen=94  rows=1
0x00000810  CpkItocInfo   cols=4  rowlen=24  rows=1
0x00000890  CpkItocL      cols=3  rowlen=6   rows=19034
0x0001c708  CpkItocH      cols=3  rowlen=10  rows=374

CpkItocInfo 只有一行,记 FilesL=19034、FilesH=374,两者之和等于 19408。这是 ITOC 的关键:文件数超过单表容量时拆成两表,小文件用 u16 记大小,大文件用 u32 记大小。

2.2 UTF 表的偏移基准

表内所有偏移字段都以「表起点 + 8」为基准,这一点用三张表交叉验证过。

CpkHeader(起点 0x10)的 rows_off 字段是 199,199 + 0x10 + 8 = 0xD7,正是行数据的真实起点。CpkItocL(起点 0x890)的字段是 39,39 + 0x890 + 8 = 0x8BF,与手算的「列定义结束位置」吻合。CpkTocInfo(起点 0x810)的 rows_off 是 63,63 + 0x810 + 8 = 0x857,而 0x857 加上 2124 × 28 恰好等于字符串表起点 0xF0A7。

最初按「相对表起点」解释,行起点整体偏 8 字节,读出的大小值和偏移全部错位,ContentOffset 被解成 269 576 192 这种明显越界的数。改正基准后所有字段立刻自洽。

2.3 列定义与常量列

列定义紧跟表头,每列 5 字节:1 字节类型标志,4 字节名字偏移。类型标志拆两半用:低 4 位表示宽度,高 4 位表示存储方式。

低 4 位宽度典型列
0x22 字节Align、ID
0x44 字节FileSize、FileOffset(TOC 内)
0x68 字节ContentOffset、FileOffset(头部内)
0xA4 字节(字符串偏移)DirName、Tvers

高 4 位为 0x1 或 0x3 时该列是常量列,值直接内联在那 4 字节描述符里,行数据不占空间。这条规则用行宽反推确认:

CpkHeader(DATA1)共 35 列,其中 0x56 型 13 个、0x54 型 6 个、0x52 型 5 个、0x5A 型 1 个,其余 0x16 型 2 个、0x14 型 7 个、0x1A 型 1 个属于常量列不占位。于是

13×8 + 6×4 + 5×2 + 1×4 = 104 + 24 + 10 + 4 = 142

与实际 rowlen 142 完全相等。同一算式套到 DATA0 的头部表给出 94,也相等。

CpkTocInfo 的 UserString 列类型是 0x3A,按此规则判为常量,因此每行实际只写 DirName(4) + FileName(4) + FileSize(4) + ExtractSize(4) + FileOffset(8) + ID(4) = 28 字节,与 rowlen 28 一致。忽略这条规则时,多读 4 字节会把下一行的 DirName 读成 UserString,表面上还能解出人名,实际已经整体错位。

2.4 两种目录布局

TOC 型(DATA1) 每行给出名字、压缩前后大小、64 位偏移,按偏移直接定位。FileOffset 的相对基准是「数据区起点减去对齐值」,实测数据区起点 ContentOffset = 0x26800,首个条目的 FileOffset = 0x26000,差 0x800,因此绝对位置等于 0x800 + FileOffset。这个 0x800 的差不能想当然用 ContentOffset + FileOffset 代替,二者相差 0x26000,偏移全部失效。

ITOC 型(DATA0) 表里没有偏移,只有 ID 与大小,位置要靠顺序累加:

off = ContentOffset
for id in 升序 ID:
    条目位置 = off
    off += size(id)
    off 向上对齐到 0x800

两个表按 ID 合并后共 19408 条,ID 连续区间 10000 至 30315 之间存在空洞,大小之和 526 721 010 字节,加上逐条 0x800 对齐的填充正好填满 546 MB 的包体。

2.5 数据区对齐

每条目起点向 0x800 取整。PSP 的 UMD 以 2048 字节扇区读取,取整到扇区边界能让每个文件落在扇区起点的整数倍上,读一个文件只需一次定位。Align 字段写在头部表里,值就是 2048。

3 CRILAYLA 压缩

3.1 头部字段

DATA1 的 1954 个压缩条目都以 CRILAYLA 开头,其后两个 32 位小端整数:

0x00  'CRILAYLA'
0x08  u32le  uncompressed_size - 0x100
0x0C  u32le  compressed_payload_size
0x10  压缩数据
末尾 0x100 字节  原始文件的前 0x100 字节

拿 jis2ucs.bin 核对:文件 18 520 字节,字段值为 130 816 与 18 248。130 816 + 256 = 131 072,正是解压后大小;16 + 18 248 + 256 = 18 520,正是文件总长。两个等式同时成立,布局确定。

前 0x100 字节单独存放是因为反向 LZ 无法用回引构造流的开头,只好原文照抄一段。

3.2 反向位流与长度级联

解压从压缩数据末尾往前读,逐位 MSB 优先。一个字面量占 1 位标志加 8 位数据,回引占 1 位标志加 13 位距离,距离字段不带偏移量,直接用「当前位置加距离」定位。长度不是定宽字段,而是级联编码:

读 2 位 -> more
长度 = 3 + more
若 more == 3,再读 3 位,长度 = more
  若 more == 7,再读 5 位,长度 = more
    若 more == 31,循环读 8 位,长度 = more,直到 more != 255

级联段用「从高地址向低地址」的复制方式写回,这样重叠区间也能正确展开成重复串,全零块就靠这条路径压缩到几个字节。

3.3 判定过程的弯路

起初按另外几种假说试过:把 0x0C 字段按大端读,compressed_size 直接变成 1.2 GB;把数据当作正向位流;把回引编码猜成「13 位距离 + 4 位长度」,或者「先读长度再读距离」;把填充方向猜成从 0x100 向后。每套假说配的验证脚本都跑过一轮,结果是解码在头几十个字节内就出现越界回引或位流耗尽。

收敛靠的是一个结构上的观察:jis2ucs.bin 解压后应是 65 536 个 u16 的映射表,未定义码位取 0,整表零字节占比应在 80% 以上。把「零占比」当评分函数后,错误假说立刻暴露,因为它们的输出满是随机值。随后查到的 Kuriimu2 实现与前述字段布局逐条对上,两处编码细节(级联阈值 3、7、31、255,以及距离不带 +3)与我的猜测都不同。

4 工具实现

4.1 解包

流程分四步:定位 CpkHeader 与 CpkTocInfo,按上述规则解析列定义与行数据,按「对齐值 + FileOffset」定位条目,压缩条目过一遍 CRILAYLA 解码后落盘。文件名先按 UTF-8 解,失败退到 cp932,再退到 latin-1。日文音效名如 ときめき.adx 走的正是 cp932 分支。

4.2 重打包的不变式

重打包最大的障碍是压缩器:CPK 要求 FileSize 小于 ExtractSize 的条目必须能被 CRI 的解压器还原,自己写一遍 CRILAYLA 压缩器要花双倍工,压缩率还未必追得上原厂。

绕法是不压缩。CRI 的文件系统在读取时先比较 FileSize 与 ExtractSize,相等就直接取数据,不等才解压。于是改动过的文件按未压缩写入,两个字段同时设成实际长度,游戏照常读取。未改动的条目则原样复制压缩块,体积与行为都不变。

第二条不变式是总体积不增大。头部表里的 ContentOffset、ContentSize、EtocOffset、TocSize 等字段全部照抄原文件,工具不重算这些常量列,因此新包的字节数必须等于旧包。做法是在数据区末尾补零把长度补回原值。DATA1 原本留有余量,实测修改单文件后总量仍在限内。

4.3 索引与差异检测

解包时在输出目录写一份 _index.json,逐条记录相对路径、原始压缩前后大小、原始偏移、解压后内容的 SHA1。打包时按这份索引逐条比对磁盘文件的 SHA1,全等就复制原压缩块,不等就按未压缩写入。这样避免了按文件名模糊匹配,也避开了编码差异带来的误判。

4.4 命令集

python cpk.py info        DATA1.CPK
python cpk.py unpack      DATA1.CPK  <输出目录>
python cpk.py pack        DATA1.CPK  <解包目录>  <新CPK>
python cpk.py itoc-unpack DATA0.CPK  <输出目录>
python cpk.py itoc-patch  DATA0.CPK  <解包目录>  <新CPK>

itoc-patch 只支持等长替换。ITOC 的大小字段是 u16 与 u32 两套表,条目变大就要挪表重排,收益不抵风险。增大的文件以零填充补齐,游戏按 ExtractSize 读取时不会越过有效数据。

5 验证

实验环境:Windows 11,Python 3.12.14,工具只用标准库 struct、json、hashlib。输入为 UMD9660/PSP_GAME/USRDIR/data 下的原始 CPK,解包结果写到 _unpacked/DATA1、_unpacked/DATA0,重打包结果写到 _out,原文件全程只读。

三组实验,判据都是字节级或哈希级,不靠肉眼。

实验操作结果
一DATA1 解包后原样 pack,再解包2124 个文件 SHA1 全等,0 个不符
二改写 script/011c.txt(4009 → 4025 字节)后 pack 再解包回读 4025 字节,尾部 <99 TEST TEST> 存在;其余 2123 个条目不变
三DATA0 解包 19408 个条目后原样 itoc-patch输出与原文件 SHA256 完全相同

实验一还有一句要交代:首轮 pack 的输出比原文件小 26 700 字节,逐字节比对显示差异集中在目录表行数据区,是 FileOffset 重算值与原始值的细微差别(原包的条目间隙并非纯对齐产生)。补上「总量补回原值」这一步后,二次解包的哈希比对全部通过,说明重算出的偏移虽然与原始值不同,但内部自洽,解包器按新偏移能正确还原每个条目。

实验二同时验证了未压缩写入的可行性:被改文件在第二次解包时按 4025 字节原样读出,另外 1953 个压缩条目仍走 CRILAYLA 路径。

6 限制与未解部分

AHX 无法直接播放。 DATA0 的 19408 个条目全部以 AHX 开头,尾部带 AHXE(c)CRI 签名,这是 CRI 的加密 ADX。解密需要密钥,密钥写在 EBOOT.BIN 里,而该文件是 ~PSP 封装,要先做 KIRK 解密才能读到明文代码。改文字与换图用不到这部分。

字体与编码限制汉化空间。 剧本是 Shift-JIS 明文,保存时必须维持该编码。界面文字用 font_16_*.ext 位图字体,字形集为 JIS 第一、第二水准汉字,简体字大多不在其中,直接写简体会出现缺字。要么改字体纹理,要么在文本层做字形映射。

头部表的常量列未重写。 FileSize、TotalFiles 等字段以常量列形式内联在列描述符里,当前实现照抄原值。因为总体积不变,这些字段仍然成立。若将来必须让包体增大,需要改写这部分描述符,并重算 ContentSize、EtocOffset 等字段,工作量和风险都会上一个台阶。

.pac 容器未解析。 1680 个图像包以固定 8 字节头开始(形如 00 01 01 00 00 00 00 00),后面跟尺寸与偏移。换图需要单独逆向这个容器,与 CPK 层无关。

校验字段的状态未确认。 TocCrc、ItocCrc、GtocCrc 三个字段按常量列解析出的值是 85、132、160,量级不像 CRC32。可能 CPK Maker 2.30 默认不填这三个字段,也可能是我对常量列取值的解释在数值类型上仍有偏差。当前实现不改这些字段,重打包后的包能否被实机接受,还需要在 PPSSPP 或真机上跑一遍确认。

7 结论

这套镜像的封包结构可以完整还原:两层 CRI CPK,一层 TOC 一层 ITOC,内部条目用 CRILAYLA 压缩,数据区按 2048 字节对齐。难点集中在三处:UTF 表的偏移基准是表起点加 8 而不是表起点;常量列不占行宽,靠行宽反推才能定位;CRILAYLA 的长度级联编码不能用定宽字段假设。

工具侧的关键决定是放弃实现压缩器,改用「未改动条目原样复制、改动条目未压缩写入」的策略。这个策略把工作量从「逆向压缩与解压两条链路」压到「只做解压」,代价是修改后的条目体积变大,需要靠原包的尾部余量吸收。三组字节级验证确认了策略有效。

参考文献

  1. FanTranslatorsInternational. Kuriimu2, plugins/Criware/plugin_criware/CRILAYLA/CRILAYLA.cs. GitHub, 2021.
  2. vgmstream contributors. vgmstream, src/meta/cpk.c(CPK 的 ITOC 双表与 ID 排序逻辑).
  3. CRI Middleware. CPK Maker 2.30.04 / DLL3.00.04,版本号取自包内 CpkHeader.Tvers 字段.
  4. hcs64 论坛. CPK 与 CRILAYLA 相关讨论帖.

附源码

python
# -*- coding: utf-8 -*-
"""CRI CPK (CPKMC 2.x) toolkit for Renai 0 Kilometer PSP.

Commands:
  info   <cpk>
  unpack <cpk> <outdir>
  pack   <orig_cpk> <indir> <out_cpk>

The TOC listing is written to <outdir>/_index.json during unpack; pack uses it,
so edited files are detected by content hash.  Unchanged compressed entries are
copied verbatim (still CRILAYLA); edited ones are stored uncompressed, which the
CRI file system accepts because FileSize == ExtractSize then.
"""
import struct, sys, os, json, hashlib

CONST_HI = (0x10, 0x30)
WIDTH = {0x0: 4, 0xA: 4, 0xB: 4, 0x1: 4, 0x2: 2, 0x3: 2, 0x4: 4, 0x5: 4, 0x6: 8, 0x7: 8}


def dec(raw):
    for enc in ('utf-8', 'cp932', 'latin-1'):
        try:
            return raw.decode(enc)
        except UnicodeDecodeError:
            continue
    return raw.decode('latin-1')


class Utf:
    def __init__(self, buf, base):
        assert buf[base:base+4] == b'@UTF'
        self.buf = buf
        self.base = base
        self.size = struct.unpack_from('>I', buf, base+4)[0]
        self.rows_off, self.strs_off, self.data_off = struct.unpack_from('>III', buf, base+8)
        self.ncols, self.rowlen = struct.unpack_from('>HH', buf, base+0x18)
        self.nrows = struct.unpack_from('>I', buf, base+0x1c)[0]
        self.rows_start = base + 8 + self.rows_off
        self.strs_start = base + 8 + self.strs_off
        self.cols = []
        for i in range(self.ncols):
            p = base + 0x20 + i*5
            flags = buf[p]
            desc = struct.unpack_from('>I', buf, p+1)[0]
            self.cols.append((flags, desc, self.s(desc & 0xFFFFF),
                              (flags & 0xF0) in CONST_HI, WIDTH.get(flags & 0x0F, 4)))
        q = self.strs_start
        while q < self.strs_start + 0x100 and buf[q] == 0:
            q += 1
        nm = dec(buf[q:buf.find(b'\x00', q)])
        if nm == '<NULL>':
            q = buf.find(b'\x00', q) + 1
            nm = dec(buf[q:buf.find(b'\x00', q)])
        self.name = nm

    def s(self, off):
        q = self.strs_start + off
        return dec(self.buf[q:self.buf.find(b'\x00', q)])

    def rows(self):
        out = []
        for r in range(self.nrows):
            p = self.rows_start + r*self.rowlen
            row, pos = {}, {}
            for flags, desc, name, const, width in self.cols:
                t = flags & 0x0F
                if const:
                    row[name] = self.s(desc & 0xFFFFF) if t in (0x0, 0xA, 0xB) else desc
                    pos[name] = None
                    continue
                if t in (0x0, 0xA, 0xB):
                    o = struct.unpack_from('>I', self.buf, p)[0]
                    row[name] = self.s(o & 0xFFFFF)
                    pos[name] = (p, 'str'); p += 4
                elif width == 2:
                    row[name] = struct.unpack_from('>H', self.buf, p)[0]
                    pos[name] = (p, 'u16'); p += 2
                elif width == 4:
                    row[name] = struct.unpack_from('>I', self.buf, p)[0]
                    pos[name] = (p, 'u32'); p += 4
                else:
                    row[name] = struct.unpack_from('>Q', self.buf, p)[0]
                    pos[name] = (p, 'u64'); p += 8
            out.append((row, pos))
        return out


def tables(buf, limit=0x800000):
    res, i = [], buf.find(b'@UTF')
    while 0 <= i < limit:
        try:
            res.append(Utf(buf, i))
        except Exception:
            pass
        i = buf.find(b'@UTF', i+4)
    return res


def load(cpk):
    return load_buf(open(cpk, 'rb').read())


def load_buf(buf):
    tbs = tables(buf)
    hdr = next((t for t in tbs if t.name == 'CpkHeader'), None)
    toc = next((t for t in tbs if t.name == 'CpkTocInfo'), None)
    return buf, tbs, hdr, toc


def header_row(hdr):
    return hdr.rows()[0][0] if hdr else {}


def content_offset(hdr):
    h = header_row(hdr)
    co = h.get('ContentOffset')
    if not isinstance(co, int) or not (0x20 <= co < 0x1000000):
        co = 0x26800
    return co


# --------------------------------------------------------------- crilayla
def crilayla_decompress(data):
    assert data[:8] == b'CRILAYLA'
    usize = struct.unpack_from('<I', data, 8)[0]
    csize = struct.unpack_from('<I', data, 12)[0]
    dest = bytearray(0x100 + usize)
    dest[0:0x100] = data[len(data)-0x100:]
    payload = data[0x10:0x10+csize]
    p = len(payload) - 1
    nb = cur = 0
    def bit():
        nonlocal p, nb, cur
        if nb == 0:
            cur = payload[p]; p -= 1; nb = 8
        nb -= 1
        return (cur >> nb) & 1
    def bits(k):
        v = 0
        for _ in range(k):
            v = (v << 1) | bit()
        return v
    dp = len(dest)
    def casc(src, count):
        nonlocal dp
        d = dp + count; s = src + count
        while count > 0:
            count -= 1; d -= 1; s -= 1
            dest[d] = dest[s]
    while dp > 0x100:
        if bits(1):
            initial = bits(13)
            off = dp + initial
            dp -= 3
            def rd(k):
                nonlocal dp, off
                v = bits(k); dp -= v; off -= v
                return v
            if initial >= 3:
                more = rd(2); n = 3 + more
                dest[dp:dp+n] = dest[off:off+n]
            else:
                dest[dp:dp+3] = dest[off:off+3]
                more = rd(2)
                dest[dp:dp+more] = dest[off:off+more]
            if more == 3:
                more = rd(3); casc(off, more)
                if more == 7:
                    more = rd(5); casc(off, more)
                    if more == 31:
                        while True:
                            more = rd(8); casc(off, more)
                            if more != 255:
                                break
        else:
            dp -= 1
            dest[dp] = bits(8)
    return bytes(dest)


# --------------------------------------------------------------- commands
def rel_of(row):
    d = row.get('DirName') or ''
    f = row.get('FileName') or ''
    if d in ('<NULL>', ''):
        d = ''
    r = (d + '/' + f).replace('\\', '/')
    return ''.join('_' if c in '<>:"|?*' else c for c in r)


def cmd_info(cpk):
    buf, tbs, hdr, toc = load(cpk)
    print('file:', cpk, os.path.getsize(cpk))
    for t in tbs:
        print('  0x%08x  %-18s size=%-8d cols=%d rowlen=%d rows=%d' %
              (t.base, t.name, t.size, t.ncols, t.rowlen, t.nrows))
    h = header_row(hdr)
    print('  ContentOffset = %d (0x%x)' % (content_offset(hdr), content_offset(hdr)))
    for k in ('Tvers', 'CpkMode', 'TotalFiles', 'Files'):
        if k in h:
            print('  %-12s = %r' % (k, h[k]))


def cmd_unpack(cpk, outdir):
    buf, tbs, hdr, toc = load(cpk)
    co = content_offset(hdr)
    rows = toc.rows()
    first = rows[0][0]['FileOffset']
    al = co - first
    if not (1 <= al <= 0x10000):
        al = 0x800
    os.makedirs(outdir, exist_ok=True)
    index = []
    ncomp = 0
    for row, pos in rows:
        rel = rel_of(row)
        path = os.path.join(outdir, *rel.split('/'))
        os.makedirs(os.path.dirname(path), exist_ok=True)
        size = row.get('FileSize', 0)
        ext = row.get('ExtractSize', size)
        off = al + row.get('FileOffset', 0)
        raw = buf[off:off+size]
        data = raw
        if size != ext and raw[:8] == b'CRILAYLA':
            try:
                data = crilayla_decompress(raw)
                ncomp += 1
            except Exception as e:
                print('  !! decompress', rel, e)
        open(path, 'wb').write(data)
        index.append({'path': rel, 'file_size': size, 'extract_size': ext,
                      'offset': row.get('FileOffset', 0),
                      'sha1': hashlib.sha1(data).hexdigest(),
                      'sha1_raw': hashlib.sha1(raw).hexdigest()})
    with open(os.path.join(outdir, '_index.json'), 'w', encoding='utf-8') as f:
        json.dump({'cpk': os.path.basename(cpk), 'content_offset': co,
                   'align': al, 'files': index}, f, ensure_ascii=False, indent=1)
    print('unpacked %d files (%d CRILAYLA) -> %s' % (len(rows), ncomp, outdir))


def cmd_pack(cpk, indir, outcpk):
    buf, tbs, hdr, toc = load(cpk)
    co = content_offset(hdr)
    rows = toc.rows()
    idx_path = os.path.join(indir, '_index.json')
    index = {}
    if os.path.exists(idx_path):
        with open(idx_path, encoding='utf-8') as f:
            for e in json.load(f)['files']:
                index[e['path']] = e
    first = rows[0][0]['FileOffset']
    al = co - first if 1 <= co - first <= 0x10000 else 0x800
    head = bytearray(buf[:co])
    blob = bytearray()
    updates = []
    same = edited = 0
    for row, pos in rows:
        rel = rel_of(row)
        path = os.path.join(indir, *rel.split('/'))
        size = row.get('FileSize', 0)
        ext = row.get('ExtractSize', size)
        off = al + row.get('FileOffset', 0)
        raw = bytes(buf[off:off+size])
        entry = index.get(rel)
        if os.path.exists(path):
            cur = open(path, 'rb').read()
            changed = not (entry and hashlib.sha1(cur).hexdigest() == entry['sha1'])
            if changed:
                data, store_size, store_ext = cur, len(cur), len(cur)
                edited += 1
            else:
                data, store_size, store_ext = raw, size, ext
                same += 1
        else:
            data, store_size, store_ext = raw, size, ext
            same += 1
        cur = co + len(blob)
        pad = (-cur) % al
        blob += b'\x00' * pad
        rel_off = co + len(blob) - al
        updates.append((pos, rel_off, store_size, store_ext))
        blob += data
    newbuf = head + blob
    for pos, rel_off, store_size, store_ext in updates:
        if pos.get('FileOffset') and pos['FileOffset'][1] == 'u64':
            struct.pack_into('>Q', newbuf, pos['FileOffset'][0], rel_off)
        if pos.get('FileSize'):
            struct.pack_into('>I', newbuf, pos['FileSize'][0], store_size)
        if pos.get('ExtractSize'):
            struct.pack_into('>I', newbuf, pos['ExtractSize'][0], store_ext)
    if len(newbuf) > len(buf):
        print('!! new archive is larger than the original (%d > %d); '
              'header sizes were not rewritten, keep it under the original size'
              % (len(newbuf), len(buf)))
    else:
        newbuf += b'\x00' * (len(buf) - len(newbuf))
    open(outcpk, 'wb').write(bytes(newbuf))
    print('repacked: %d copied, %d edited -> %s (%d -> %d bytes)' %
          (same, edited, outcpk, len(buf), len(newbuf)))




# ---------------------------------------------------------------- ITOC (DATA0)
def itoc_sizes(tbs):
    sizes = {}
    L = next((t for t in tbs if t.name == 'CpkItocL'), None)
    H = next((t for t in tbs if t.name == 'CpkItocH'), None)
    if L:
        for r, _ in L.rows():
            sizes[r['ID']] = (r['FileSize'], r['ExtractSize'])
    if H:
        for r, _ in H.rows():
            sizes[r['ID']] = (r['FileSize'], r['ExtractSize'])
    return sizes


def itoc_layout(buf, tbs, hdr):
    co = content_offset(hdr)
    sizes = itoc_sizes(tbs)
    ids = sorted(sizes)
    al = 0x800
    out = {}
    off = co
    for i in ids:
        out[i] = off
        off += sizes[i][0]
        off = (off + al - 1) & ~(al - 1)
    return out, sizes, co, al


def cmd_itoc_unpack(cpk, outdir):
    buf, tbs, hdr, toc = load(cpk)
    layout, sizes, co, al = itoc_layout(buf, tbs, hdr)
    os.makedirs(outdir, exist_ok=True)
    idx = []
    for i in sorted(layout):
        off = layout[i]
        sz = sizes[i][0]
        data = buf[off:off+sz]
        open(os.path.join(outdir, 'id_%05d.bin' % i), 'wb').write(data)
        idx.append({'id': i, 'offset': off, 'size': sz, 'extract': sizes[i][1],
                    'sha1': hashlib.sha1(data).hexdigest()})
    with open(os.path.join(outdir, '_itoc.json'), 'w', encoding='utf-8') as f:
        json.dump({'content_offset': co, 'align': al, 'files': idx}, f, indent=1)
    print('itoc unpack: %d files -> %s' % (len(layout), outdir))


def cmd_itoc_patch(cpk, indir, outcpk):
    buf = bytearray(open(cpk, 'rb').read())
    layout, sizes, co, al = itoc_layout(bytes(buf), tables(bytes(buf)), load(cpk)[2])
    meta = os.path.join(indir, '_itoc.json')
    files = json.load(open(meta, encoding='utf-8'))['files'] if os.path.exists(meta) else []
    ok = bad = 0
    for e in files:
        p = os.path.join(indir, 'id_%05d.bin' % e['id'])
        if not os.path.exists(p):
            continue
        d = open(p, 'rb').read()
        if hashlib.sha1(d).hexdigest() == e['sha1']:
            continue
        if len(d) > e['size']:
            print('  !! too big id %d (%d > %d)' % (e['id'], len(d), e['size']))
            bad += 1
            continue
        buf[e['offset']:e['offset']+e['size']] = d + b'\x00' * (e['size'] - len(d))
        ok += 1
    if bad:
        print('!! %d files too big, aborted' % bad)
        return
    open(outcpk, 'wb').write(bytes(buf))
    print('itoc patched %d files -> %s' % (ok, outcpk))


if __name__ == '__main__':
    cmd = sys.argv[1]
    if cmd == 'info':
        cmd_info(sys.argv[2])
    elif cmd == 'unpack':
        cmd_unpack(sys.argv[2], sys.argv[3])
    elif cmd == 'pack':
        cmd_pack(sys.argv[2], sys.argv[3], sys.argv[4])
    elif cmd == 'itoc-unpack':
        cmd_itoc_unpack(sys.argv[2], sys.argv[3])
    elif cmd == 'itoc-patch':
        cmd_itoc_patch(sys.argv[2], sys.argv[3], sys.argv[4])
    else:
        print(__doc__)

本文版权遵循 CC BY-NC 协议 和 本站版权政策

(。>︿<。) 已经一滴回复都不剩了哦~