Virtual-World-RE/NeoGF
4
0
Fork 0
mirror of https://github.com/Virtual-World-RE/NeoGF.git synced 2024-11-15 13:55:35 +01:00
Code Issues Releases Wiki Activity

Update gcmtool.py

Browse Source
This commit is contained in:
tmpz23 2022-01-14 15:37:41 +01:00 committed by GitHub
parent b2a5ed9a43
commit c225501bf3
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 152 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

272
gcmtool.py
View File

@ -3,73 +3,65 @@ from pathlib import Path
import logging import logging
__version__ = "0.0.7" __version__ = "0.0.8"
__author__ = "rigodron, algoflash, GGLinnk" __author__ = "rigodron, algoflash, GGLinnk"
__license__ = "MIT" __license__ = "MIT"
__status__ = "developpement" __status__ = "developpement"
DVD_MAGIC = b"\xC2\x33\x9F\x3D"
FST_TYPE_FILE = 0
FST_TYPE_DIR = 1
BOOTBIN_LEN = 0x440
BOOTBIN_DOLOFFSET_OFFSET = 0x420
BOOTBIN_FSTOFFSET_OFFSET = 0x424
BOOTBIN_FSTLEN_OFFSET = 0x428
BI2BIN_LEN = 0x2000
DOL_HEADER_LEN = 0x100
APPLOADER_HEADER_LEN = 0x20
ISO_APPLOADER_OFFSET = 0x2440
ISO_APPLOADERSIZE_OFFSET = 0x2454
def align_offset(offset:int, align:int): def align_offset(offset:int, align:int):
if offset % align != 0: if offset % align != 0:
offset += align - (offset % align) offset += align - (offset % align)
return offset return offset
class Fst:
TYPE_FILE = 0
TYPE_DIR = 1
class Node: class Node:
__id = None __id = None
__type = None
__name = None __name = None
__offset_name = None __name_offset = None
def __init__(self, name:str, type): def __init__(self, name:str):
self.__name = name self.__name = name
self.__type = type
def id(self): return self.__id def id(self): return self.__id
def name(self): return self.__name def name(self): return self.__name
def offset_name(self): return self.__offset_name def name_offset(self): return self.__name_offset
def type(self): return self.__type def set_id(self, id:int): self.__id = id
def set_id(self, id:int): self.id = id def set_name_offset(self, name_offset:int): self.__name_offset = name_offset
def set_offset_name(self, offset_name:int): self.__offset_name = offset_name
class File(Node): class File(Node):
__type = Fst.TYPE_FILE
__size = None __size = None
__offset = None __offset = None
def __init__(self, name:str, size:int): def __init__(self, name:str, size:int):
super().__init__(name, FST_TYPE_FILE) super().__init__(name)
self.__size = size self.__size = size
def __str__(self): def __str__(self):
return f"{self.id};{self.name()};{self.size()};{self.offset()};{self.offset_name()}" return f"{self.id()};{self.name()};{self.size()};{self.offset()};{self.name_offset()}"
def type(self): return self.__type
def size(self): return self.__size def size(self): return self.__size
def offset(self): return self.__offset def offset(self): return self.__offset
def set_offset(self, offset:int): self.__offset = offset def set_offset(self, offset:int): self.__offset = offset
def format(self): def format(self):
return self.type().to_bytes(1, "big") + self.offset_name().to_bytes(3, "big") + self.offset().to_bytes(4, "big") + self.size().to_bytes(4, "big") return self.type().to_bytes(1, "big") + self.name_offset().to_bytes(3, "big") + self.offset().to_bytes(4, "big") + self.size().to_bytes(4, "big")
class Folder(Node): class Folder(Node):
__type = Fst.TYPE_DIR
__parent = None __parent = None
__next_dir = None __next_dir = None
__childs = None __childs = None
def __init__(self, name:str, parent:Node): def __init__(self, name:str, parent:Node):
super().__init__(name, FST_TYPE_DIR) super().__init__(name)
self.__parent = parent self.__parent = parent
self.__childs = [] self.__childs = []
def __str__(self): def __str__(self):
return f"{self.id};{self.name()};{self.next_dir()};{self.offset_name()}" return f"{self.id()};{self.name()};{self.next_dir()};{self.name_offset()}"
def type(self): return self.__type
def parent(self): return self.__parent def parent(self): return self.__parent
def next_dir(self): return self.__next_dir def next_dir(self): return self.__next_dir
def childs(self): return self.__childs def childs(self): return self.__childs
@ -82,13 +74,13 @@ class Folder(Node):
self.__childs.append(node) self.__childs.append(node)
return node return node
def format(self): def format(self):
return self.type().to_bytes(1, "big") + self.offset_name().to_bytes(3, "big") + self.parent().id.to_bytes(4, "big") + self.next_dir().to_bytes(4, "big") return self.type().to_bytes(1, "big") + self.name_offset().to_bytes(3, "big") + self.parent().id().to_bytes(4, "big") + self.next_dir().to_bytes(4, "big")
class FstTree: class FstTree(Fst):
__root_path_length = None __root_path_length = None
__root_node = None __root_node = None
__current_index = 0 __current_id = 0
__current_file_offset = None __current_file_offset = None
__align = None __align = None
__fst_block = None __fst_block = None
@ -106,7 +98,7 @@ class FstTree:
return self.__to_str(self.__root_node) return self.__to_str(self.__root_node)
def __to_str(self, node:Node, depth=0): def __to_str(self, node:Node, depth=0):
result = (depth * " ") + str(node) +"\n" result = (depth * " ") + str(node) +"\n"
if node.type() == FST_TYPE_DIR: if node.type() == FstTree.TYPE_DIR:
for child in node.childs(): for child in node.childs():
result += self.__to_str(child, depth+1) result += self.__to_str(child, depth+1)
return result return result
@ -119,9 +111,38 @@ class FstTree:
node = self.__root_node node = self.__root_node
else: else:
self.__nameblock_length += len(node.name()) + 1 self.__nameblock_length += len(node.name()) + 1
if node.type() == FST_TYPE_DIR: if node.type() == FstTree.TYPE_DIR:
for child in node.childs(): for child in node.childs():
self.__generate_nameblock_length(child) self.__generate_nameblock_length(child)
def __prepare(self, node:Node = None):
name_offset = 0
if node == None:
node = self.__root_node
else:
name_offset = len(self.__name_block)
self.__name_block += node.name().encode("utf-8")+b"\x00"
node.set_name_offset(name_offset)
node.set_id(self.__current_id)
self.__current_id += 1
if node.type() == FstTree.TYPE_DIR:
node.set_next_dir(self.__current_id + self.__count_childs(node))
if node == self.__root_node:
self.__fst_block = b"\x01\x00\x00\x00\x00\x00\x00\x00" + node.next_dir().to_bytes(4, "big")
else:
self.__fst_block += node.format()
for child in node.childs():
self.__prepare(child)
else:
node.set_offset(self.__current_file_offset)
self.__fst_block += node.format()
self.__current_file_offset = align_offset(self.__current_file_offset + node.size(), self.__align)
def __count_childs(self, node:Folder):
count = 0
for child in node.childs():
if child.type() == FstTree.TYPE_DIR:
count += self.__count_childs(child)
return count + len(node.childs())
def add_node_by_path(self, node_path:Path): def add_node_by_path(self, node_path:Path):
parent = self.__root_node parent = self.__root_node
node = None node = None
@ -133,84 +154,93 @@ class FstTree:
else: else:
node = Folder(node_path.name, parent) node = Folder(node_path.name, parent)
parent.add_child(node) parent.add_child(node)
def __prepare(self, node:Node = None):
offset_name = 0
if node == None:
node = self.__root_node
else:
offset_name = len(self.__name_block)
self.__name_block += node.name().encode("utf-8")+b"\x00"
node.set_offset_name(offset_name)
node.set_id(self.__current_index)
self.__current_index += 1
if node.type() == FST_TYPE_DIR:
node.set_next_dir(self.__current_index + self.__count_childs(node))
if node == self.__root_node:
self.__fst_block = b"\x01\x00\x00\x00\x00\x00\x00\x00" + node.next_dir().to_bytes(4, "big")
else:
self.__fst_block += node.format()
for child in node.childs():
self.__prepare(child)
else:
node.set_offset(self.__current_file_offset)
self.__fst_block += node.format()
self.__current_file_offset = align_offset(self.__current_file_offset + node.size(), self.__align)
def get_fst(self): def get_fst(self):
self.__current_file_offset += self.__get_fst_length() self.__current_file_offset += self.__get_fst_length()
self.__prepare() self.__prepare()
return self.__fst_block + self.__name_block return self.__fst_block + self.__name_block
def __count_childs(self, node:Folder):
count = 0
for child in node.childs(): class BootBin:
if child.type() == FST_TYPE_DIR: LEN = 0x440
count += self.__count_childs(child) DOLOFFSET_OFFSET = 0x420
return count + len(node.childs()) FSTOFFSET_OFFSET = 0x424
FSTLEN_OFFSET = 0x428
MAXFSTLEN_OFFSET = 0x42c
__data = None
def __init__(self, data:bytes):
self.__data = bytearray(data)
def data(self): return self.__data
def dvd_magic(self):
return self.__data[0x1c:0x20]
def fstbin_offset(self):
return int.from_bytes(self.__data[BootBin.FSTOFFSET_OFFSET:BootBin.FSTOFFSET_OFFSET+4],"big", signed=False)
def fstbin_len(self):
return int.from_bytes(self.__data[BootBin.FSTLEN_OFFSET:BootBin.FSTLEN_OFFSET+4],"big", signed=False)
def dol_offset(self):
return int.from_bytes(self.__data[BootBin.DOLOFFSET_OFFSET:BootBin.DOLOFFSET_OFFSET+4],"big", signed=False)
def game_code(self):
return self.__data[:4].decode('utf-8')
def disc_number(self):
return int.from_bytes(self.__data[6:7], 'big', signed=False)
def set_dol_offset(self, offset:int):
self.__data[BootBin.DOLOFFSET_OFFSET:BootBin.DOLOFFSET_OFFSET+4] = offset.to_bytes(4, "big")
def set_fst_offset(self, offset:int):
self.__data[BootBin.FSTOFFSET_OFFSET:BootBin.FSTOFFSET_OFFSET+4] = offset.to_bytes(4, "big")
def set_fst_len(self, size:int):
self.__data[BootBin.FSTLEN_OFFSET:BootBin.FSTLEN_OFFSET+4] = size.to_bytes(4, "big")
def set_max_fst_len(self, size:int):
self.__data[BootBin.MAXFSTLEN_OFFSET:BootBin.MAXFSTLEN_OFFSET+4] = size.to_bytes(4, "big")
class Dol: class Dol:
DOLHEADER_SECTIONLENTABLE_OFFSET = 0x90 HEADER_LEN = 0x100
HEADER_SECTIONLENTABLE_OFFSET = 0x90
# Get total length using the sum of the 18 sections length and dol header length # Get total length using the sum of the 18 sections length and dol header length
def get_dol_len(self, dolheader_data:bytes): def get_dol_len(self, dolheader_data:bytes):
dol_len = DOL_HEADER_LEN dol_len = Dol.HEADER_LEN
for i in range(18): for i in range(18):
dol_len += int.from_bytes(dolheader_data[Dol.DOLHEADER_SECTIONLENTABLE_OFFSET+i*4:Dol.DOLHEADER_SECTIONLENTABLE_OFFSET+(i+1)*4], "big", signed=False) dol_len += int.from_bytes(dolheader_data[Dol.HEADER_SECTIONLENTABLE_OFFSET+i*4:Dol.HEADER_SECTIONLENTABLE_OFFSET+(i+1)*4], "big", signed=False)
return dol_len return dol_len
# https://sudonull.com/post/68549-Gamecube-file-system-device # https://sudonull.com/post/68549-Gamecube-file-system-device
class GCM: class Gcm:
BI2BIN_LEN = 0x2000
APPLOADER_HEADER_LEN = 0x20
APPLOADER_OFFSET = 0x2440
APPLOADERSIZE_OFFSET = 0x2454
DVD_MAGIC = b"\xC2\x33\x9F\x3D"
def unpack(self, iso_path:Path, folder_path:Path): def unpack(self, iso_path:Path, folder_path:Path):
with iso_path.open("rb") as iso_file: with iso_path.open("rb") as iso_file:
bootbin_data = iso_file.read(BOOTBIN_LEN) bootbin = BootBin(iso_file.read(BootBin.LEN))
if bootbin_data[0x1c:0x20] != DVD_MAGIC: if bootbin.dvd_magic() != Gcm.DVD_MAGIC:
raise Exception("Invalid DVD format - this tool is for ISO/GCM files") raise Exception("Invalid DVD format - this tool is for ISO/GCM files")
bi2bin_data = iso_file.read(BI2BIN_LEN) bi2bin_data = iso_file.read(Gcm.BI2BIN_LEN)
iso_file.seek(ISO_APPLOADERSIZE_OFFSET) iso_file.seek(Gcm.APPLOADERSIZE_OFFSET)
size = int.from_bytes(iso_file.read(4), "big", signed=False) size = int.from_bytes(iso_file.read(4), "big", signed=False)
trailerSize = int.from_bytes(iso_file.read(4), "big", signed=False) trailerSize = int.from_bytes(iso_file.read(4), "big", signed=False)
apploader_size = APPLOADER_HEADER_LEN + size + trailerSize apploader_size = Gcm.APPLOADER_HEADER_LEN + size + trailerSize
iso_file.seek(ISO_APPLOADER_OFFSET) iso_file.seek(Gcm.APPLOADER_OFFSET)
apploaderimg_data = iso_file.read(apploader_size) apploaderimg_data = iso_file.read(apploader_size)
fstbin_offset = int.from_bytes(bootbin_data[BOOTBIN_FSTOFFSET_OFFSET:BOOTBIN_FSTOFFSET_OFFSET+4],"big", signed=False) fstbin_offset = bootbin.fstbin_offset()
fstbin_len = int.from_bytes(bootbin_data[BOOTBIN_FSTLEN_OFFSET:BOOTBIN_FSTLEN_OFFSET+4],"big", signed=False) fstbin_len = bootbin.fstbin_len()
iso_file.seek( fstbin_offset ) iso_file.seek( fstbin_offset )
fstbin_data = iso_file.read( fstbin_len ) fstbin_data = iso_file.read( fstbin_len )
dol_offset = int.from_bytes(bootbin_data[BOOTBIN_DOLOFFSET_OFFSET:BOOTBIN_DOLOFFSET_OFFSET+4],"big", signed=False) dol_offset = bootbin.dol_offset()
iso_file.seek( dol_offset ) iso_file.seek( dol_offset )
dol = Dol() dol = Dol()
dolheader_data = iso_file.read(DOL_HEADER_LEN) dolheader_data = iso_file.read(Dol.HEADER_LEN)
dol_len = dol.get_dol_len( dolheader_data ) dol_len = dol.get_dol_len( dolheader_data )
bootdol_data = dolheader_data + iso_file.read( dol_len - DOL_HEADER_LEN ) bootdol_data = dolheader_data + iso_file.read( dol_len - Dol.HEADER_LEN )
if folder_path != Path("."): if folder_path != Path("."):
base_path = folder_path base_path = folder_path
else: else:
base_path = Path(f"{bootbin_data[:4].decode('utf-8')}-{int.from_bytes(bootbin_data[6:7], 'little', signed=False):02}") base_path = Path(f"{bootbin.game_code()}-{bootbin.disc_number():02}")
logging.info(f"unpacking {iso_path} in {base_path}") logging.info(f"unpacking {iso_path} in {base_path}")
sys_path = base_path / "sys" sys_path = base_path / "sys"
@ -221,11 +251,11 @@ class GCM:
(sys_path / "fst.bin").open("wb") as fstbin_file, \ (sys_path / "fst.bin").open("wb") as fstbin_file, \
(sys_path / "apploader.img").open("wb") as apploaderimg_file,\ (sys_path / "apploader.img").open("wb") as apploaderimg_file,\
(sys_path / "boot.dol").open("wb") as bootdol_file: (sys_path / "boot.dol").open("wb") as bootdol_file:
logging.debug(f"{iso_path}(0x0:0x{BOOTBIN_LEN:x}) -> {sys_path / 'boot.bin'}") logging.debug(f"{iso_path}(0x0:0x{BootBin.LEN:x}) -> {sys_path / 'boot.bin'}")
bootbin_file.write(bootbin_data) bootbin_file.write(bootbin.data())
logging.debug(f"{iso_path}(0x440:0x{ISO_APPLOADER_OFFSET:x}) -> {sys_path / 'bi2.bin'}") logging.debug(f"{iso_path}(0x440:0x{Gcm.APPLOADER_OFFSET:x}) -> {sys_path / 'bi2.bin'}")
bi2bin_file.write(bi2bin_data) bi2bin_file.write(bi2bin_data)
logging.debug(f"{iso_path}(0x{ISO_APPLOADER_OFFSET:x}:0x{ISO_APPLOADER_OFFSET + apploader_size:x} -> {sys_path / 'apploader.img'}") logging.debug(f"{iso_path}(0x{Gcm.APPLOADER_OFFSET:x}:0x{Gcm.APPLOADER_OFFSET + apploader_size:x} -> {sys_path / 'apploader.img'}")
apploaderimg_file.write(apploaderimg_data) apploaderimg_file.write(apploaderimg_data)
logging.debug(f"{iso_path}(0x{fstbin_offset:x}:0x{fstbin_offset + fstbin_len:x}) -> {sys_path / 'fst.bin'}") logging.debug(f"{iso_path}(0x{fstbin_offset:x}:0x{fstbin_offset + fstbin_len:x}) -> {sys_path / 'fst.bin'}")
fstbin_file.write(fstbin_data) fstbin_file.write(fstbin_data)
@ -235,32 +265,32 @@ class GCM:
root_path.mkdir(exist_ok=True) root_path.mkdir(exist_ok=True)
# And now we parse FST data to unpack all files in the GCM iso file # And now we parse FST data to unpack all files in the GCM iso file
dir_index_path = {0: root_path} dir_id_path = {0: root_path}
currentdir_path = root_path currentdir_path = root_path
# root: index=0 so nextdir is the end # root: id=0 so nextdir is the end
nextdir = int.from_bytes(fstbin_data[8:12], "big", signed=False) nextdir = int.from_bytes(fstbin_data[8:12], "big", signed=False)
# offset of filenames block # offset of filenames block
base_names = nextdir * 12 base_names = nextdir * 12
# go to parent when index reach next dir # go to parent when id reach next dir
nextdir_arr = [ nextdir ] nextdir_arr = [ nextdir ]
for index in range(1, base_names // 12): for id in range(1, base_names // 12):
i = index * 12 i = id * 12
file_type = int.from_bytes(fstbin_data[i:i+1], "big", signed=False) file_type = int.from_bytes(fstbin_data[i:i+1], "big", signed=False)
name = fstbin_data[base_names + int.from_bytes(fstbin_data[i+1:i+4], "big", signed=False):].split(b"\x00")[0].decode("utf-8") name = fstbin_data[base_names + int.from_bytes(fstbin_data[i+1:i+4], "big", signed=False):].split(b"\x00")[0].decode("utf-8")
while index == nextdir_arr[-1]: while id == nextdir_arr[-1]:
currentdir_path = currentdir_path.parent currentdir_path = currentdir_path.parent
nextdir_arr.pop() nextdir_arr.pop()
if file_type == FST_TYPE_DIR: if file_type == FstTree.TYPE_DIR:
nextdir = int.from_bytes(fstbin_data[i+8:i+12], "big", signed=False) nextdir = int.from_bytes(fstbin_data[i+8:i+12], "big", signed=False)
parentdir = int.from_bytes(fstbin_data[i+4:i+8], "big", signed=False) parentdir = int.from_bytes(fstbin_data[i+4:i+8], "big", signed=False)
nextdir_arr.append( nextdir ) nextdir_arr.append( nextdir )
currentdir_path = dir_index_path[parentdir] / name currentdir_path = dir_id_path[parentdir] / name
dir_index_path[index] = currentdir_path dir_id_path[id] = currentdir_path
currentdir_path.mkdir(exist_ok=True) currentdir_path.mkdir(exist_ok=True)
else: else:
fileoffset = int.from_bytes(fstbin_data[i+4:i+8], "big", signed=False) fileoffset = int.from_bytes(fstbin_data[i+4:i+8], "big", signed=False)
@ -281,56 +311,56 @@ class GCM:
(folder_path / "sys" / "apploader.img").open("rb") as apploaderimg_file,\ (folder_path / "sys" / "apploader.img").open("rb") as apploaderimg_file,\
(folder_path / "sys" / "boot.dol").open("rb") as bootdol_file : (folder_path / "sys" / "boot.dol").open("rb") as bootdol_file :
logging.debug(f"{folder_path / 'sys' / 'boot.bin'} -> {iso_path}(0x0:0x{BOOTBIN_LEN:x})") logging.debug(f"{folder_path / 'sys' / 'boot.bin'} -> {iso_path}(0x0:0x{BootBin.LEN:x})")
logging.debug(f"{folder_path / 'sys' / 'bi2.bin'} -> {iso_path}(0x{BOOTBIN_LEN:x}:0x{ISO_APPLOADER_OFFSET:x})") logging.debug(f"{folder_path / 'sys' / 'bi2.bin'} -> {iso_path}(0x{BootBin.LEN:x}:0x{Gcm.APPLOADER_OFFSET:x})")
logging.debug(f"{folder_path / 'sys' / 'apploader.img'} -> {iso_path}(0x{ISO_APPLOADER_OFFSET:x}:0x{ISO_APPLOADER_OFFSET + (folder_path / 'sys' / 'apploader.img').stat().st_size:x}") logging.debug(f"{folder_path / 'sys' / 'apploader.img'} -> {iso_path}(0x{Gcm.APPLOADER_OFFSET:x}:0x{Gcm.APPLOADER_OFFSET + (folder_path / 'sys' / 'apploader.img').stat().st_size:x}")
bootbin_data = bootbin_file.read() bootbin = BootBin(bootbin_file.read())
iso_file.write( bootbin_data ) iso_file.write(bootbin.data())
iso_file.write(bi2bin_file.read()) iso_file.write(bi2bin_file.read())
iso_file.write(apploaderimg_file.read()) iso_file.write(apploaderimg_file.read())
fstbin_offset = int.from_bytes(bootbin_data[BOOTBIN_FSTOFFSET_OFFSET:BOOTBIN_FSTOFFSET_OFFSET+4],"big", signed=False) fstbin_offset = bootbin.fstbin_offset()
fstbin_len = int.from_bytes(bootbin_data[BOOTBIN_FSTLEN_OFFSET:BOOTBIN_FSTLEN_OFFSET+4],"big", signed=False) fstbin_len = bootbin.fstbin_len()
if (folder_path / "sys" / "fst.bin").stat().st_size != fstbin_len: if (folder_path / "sys" / "fst.bin").stat().st_size != fstbin_len:
raise Exception("Invalid fst.bin size in boot.bin offset 0x{BOOTBIN_FSTLEN_OFFSET:x}:0x{BOOTBIN_FSTLEN_OFFSET+4:x}!") raise Exception("Invalid fst.bin size in boot.bin offset 0x{BootBin.FSTLEN_OFFSET:x}:0x{BootBin.FSTLEN_OFFSET+4:x}!")
logging.debug(f"{folder_path / 'sys' / 'fst.bin'} -> {iso_path}(0x{fstbin_offset:x}:0x{fstbin_offset + fstbin_len:x})") logging.debug(f"{folder_path / 'sys' / 'fst.bin'} -> {iso_path}(0x{fstbin_offset:x}:0x{fstbin_offset + fstbin_len:x})")
iso_file.seek( fstbin_offset ) iso_file.seek( fstbin_offset )
fstbin_data = fstbin_file.read() fstbin_data = fstbin_file.read()
iso_file.write( fstbin_data ) iso_file.write( fstbin_data )
dol_offset = int.from_bytes(bootbin_data[BOOTBIN_DOLOFFSET_OFFSET:BOOTBIN_DOLOFFSET_OFFSET+4],"big", signed=False) dol_offset = bootbin.dol_offset()
logging.debug(f"{folder_path / 'sys' / 'boot.dol'} -> {iso_path}(0x{dol_offset:x}:0x{dol_offset + (folder_path / 'sys' / 'boot.dol').stat().st_size:x})") logging.debug(f"{folder_path / 'sys' / 'boot.dol'} -> {iso_path}(0x{dol_offset:x}:0x{dol_offset + (folder_path / 'sys' / 'boot.dol').stat().st_size:x})")
iso_file.seek( dol_offset ) iso_file.seek( dol_offset )
iso_file.write( bootdol_file.read() ) iso_file.write( bootdol_file.read() )
# Now parse fst.bin for writing files in the iso # Now parse fst.bin for writing files in the iso
dir_index_path = {0: folder_path / "root"} dir_id_path = {0: folder_path / "root"}
currentdir_path = folder_path / "root" currentdir_path = folder_path / "root"
# root: index=0 so nextdir is the end # root: id=0 so nextdir is the end
nextdir = int.from_bytes(fstbin_data[8:12], "big", signed=False) nextdir = int.from_bytes(fstbin_data[8:12], "big", signed=False)
# offset of filenames block # offset of filenames block
base_names = nextdir * 12 base_names = nextdir * 12
# go to parent when index reach next dir # go to parent when id reach next dir
nextdir_arr = [ nextdir ] nextdir_arr = [ nextdir ]
for index in range(1, base_names // 12): for id in range(1, base_names // 12):
i = index * 12 i = id * 12
file_type = int.from_bytes(fstbin_data[i:i+1], "big", signed=False) file_type = int.from_bytes(fstbin_data[i:i+1], "big", signed=False)
name = fstbin_data[base_names + int.from_bytes(fstbin_data[i+1:i+4], "big", signed=False):].split(b"\x00")[0].decode("utf-8") name = fstbin_data[base_names + int.from_bytes(fstbin_data[i+1:i+4], "big", signed=False):].split(b"\x00")[0].decode("utf-8")
while index == nextdir_arr[-1]: while id == nextdir_arr[-1]:
currentdir_path = currentdir_path.parent currentdir_path = currentdir_path.parent
nextdir_arr.pop() nextdir_arr.pop()
if file_type == FST_TYPE_DIR: if file_type == FstTree.TYPE_DIR:
nextdir = int.from_bytes(fstbin_data[i+8:i+12], "big", signed=False) nextdir = int.from_bytes(fstbin_data[i+8:i+12], "big", signed=False)
parentdir = int.from_bytes(fstbin_data[i+4:i+8], "big", signed=False) parentdir = int.from_bytes(fstbin_data[i+4:i+8], "big", signed=False)
nextdir_arr.append( nextdir ) nextdir_arr.append( nextdir )
currentdir_path = dir_index_path[parentdir] / name currentdir_path = dir_id_path[parentdir] / name
dir_index_path[index] = currentdir_path dir_id_path[id] = currentdir_path
currentdir_path.mkdir(exist_ok=True) currentdir_path.mkdir(exist_ok=True)
else: else:
fileoffset = int.from_bytes(fstbin_data[i+4:i+8], "big", signed=False) fileoffset = int.from_bytes(fstbin_data[i+4:i+8], "big", signed=False)
@ -346,15 +376,14 @@ class GCM:
root_path = folder_path / "root" root_path = folder_path / "root"
sys_path = folder_path / "sys" sys_path = folder_path / "sys"
with (sys_path / "boot.bin").open("rb+") as bootbin_file: with (sys_path / "boot.bin").open("rb+") as bootbin_file:
dol_offset = align_offset(ISO_APPLOADER_OFFSET + (sys_path / "apploader.img").stat().st_size, align) dol_offset = align_offset(Gcm.APPLOADER_OFFSET + (sys_path / "apploader.img").stat().st_size, align)
logging.info(f"Patching sys/boot.bin offset 0x{BOOTBIN_DOLOFFSET_OFFSET:x} with new dol offset (0x{dol_offset:x})") logging.info(f"Patching sys/boot.bin offset 0x{BootBin.DOLOFFSET_OFFSET:x} with new dol offset (0x{dol_offset:x})")
bootbin_file.seek(BOOTBIN_DOLOFFSET_OFFSET) bootbin = BootBin(bootbin_file.read())
bootbin_file.write(dol_offset.to_bytes(4, "big")) bootbin.set_dol_offset(dol_offset)
fst_offset = align_offset(dol_offset + (sys_path / "boot.dol").stat().st_size, align) fst_offset = align_offset(dol_offset + (sys_path / "boot.dol").stat().st_size, align)
logging.info(f"Patching sys/boot.bin offset 0x{BOOTBIN_FSTOFFSET_OFFSET:x} with new fst offset (0x{fst_offset:x})") logging.info(f"Patching sys/boot.bin offset 0x{BootBin.FSTOFFSET_OFFSET:x} with new fst offset (0x{fst_offset:x})")
bootbin_file.seek(BOOTBIN_FSTOFFSET_OFFSET) bootbin.set_fst_offset(fst_offset)
bootbin_file.write(fst_offset.to_bytes(4, "big"))
fst_tree = FstTree(root_path, fst_offset, align=align) fst_tree = FstTree(root_path, fst_offset, align=align)
@ -370,9 +399,12 @@ class GCM:
fstbin_file.write( fst_tree.get_fst() ) fstbin_file.write( fst_tree.get_fst() )
fst_size = fst_path.stat().st_size fst_size = fst_path.stat().st_size
logging.info(f"Patching sys/boot.bin offset 0x{BOOTBIN_FSTLEN_OFFSET:x} with new fst size (0x{fst_size:x})") logging.info(f"Patching sys/boot.bin offset 0x{BootBin.FSTLEN_OFFSET:x} with new fst size (0x{fst_size:x})")
bootbin_file.seek(BOOTBIN_FSTLEN_OFFSET) bootbin.set_fst_len(fst_size)
bootbin_file.write(fst_size.to_bytes(4, "big")) logging.info(f"Patching sys/boot.bin offset 0x{BootBin.MAXFSTLEN_OFFSET:x} with new max fst size (0x{fst_size:x})")
bootbin.set_max_fst_len(fst_size)
bootbin_file.write(bootbin.data())
def get_argparser(): def get_argparser():
@ -398,7 +430,7 @@ if __name__ == '__main__':
p_input = Path(args.input_path) p_input = Path(args.input_path)
p_output = Path(args.output_path) p_output = Path(args.output_path)
gcm = GCM() gcm = Gcm()
if args.verbose: if args.verbose:
logging.getLogger().setLevel(logging.DEBUG) logging.getLogger().setLevel(logging.DEBUG)