摘要:本文分析《恋爱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/*.txt | 144 | 剧本 |
visual/adv/*.pac | 1680 | 立绘、背景、事件图 |
visual/system/*.pac | 21 | 系统界面 |
visual/thumb/*.pac | 85 | CG 缩略图 |
visual/wipe/*.ext | 26 | 转场效果 |
sound/bgm, sound/se | 170 | ADX 音频 |
movie/*.pmf | 3 | PSMF 视频 |
font/*.ext | 7 | 位图字体 |
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=1DATA0.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=374CpkItocInfo 只有一行,记 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 位 | 宽度 | 典型列 |
|---|---|---|
| 0x2 | 2 字节 | Align、ID |
| 0x4 | 4 字节 | FileSize、FileOffset(TOC 内) |
| 0x6 | 8 字节 | ContentOffset、FileOffset(头部内) |
| 0xA | 4 字节(字符串偏移) | 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 的长度级联编码不能用定宽字段假设。
工具侧的关键决定是放弃实现压缩器,改用「未改动条目原样复制、改动条目未压缩写入」的策略。这个策略把工作量从「逆向压缩与解压两条链路」压到「只做解压」,代价是修改后的条目体积变大,需要靠原包的尾部余量吸收。三组字节级验证确认了策略有效。
参考文献
- FanTranslatorsInternational. Kuriimu2,
plugins/Criware/plugin_criware/CRILAYLA/CRILAYLA.cs. GitHub, 2021. - vgmstream contributors. vgmstream,
src/meta/cpk.c(CPK 的 ITOC 双表与 ID 排序逻辑). - CRI Middleware. CPK Maker 2.30.04 / DLL3.00.04,版本号取自包内
CpkHeader.Tvers字段. - hcs64 论坛. CPK 与 CRILAYLA 相关讨论帖.
附源码
# -*- 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__)
