sceutils 0.1.0__py3-none-any.whl

sceutils/__init__.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from unarzl import (
+    ArlzBufferOverflowError,
+    ArlzError,
+    ArlzInvalidDataError,
+    arzl_arm_filter,
+    arzl_decode,
+    arzl_decompress,
+    unarzl,
+)
+
+from . import keys, module_info, scetypes, sceutils
+from .axfs import AXFS
+from .module_info import read_module_info
+from .pup_fiction import (
+    extract_bootimage,
+    extract_pup,
+    pup_decrypt_packages,
+    pup_extract_files,
+    slb2_decrypt,
+    slb2_extract,
+)
+from .scedecrypt import scedecrypt
+from .sceutils import get_key_type, get_segments, zrif_decode
+from .self2elf import self2elf
+from .selfinfo import read_self_info
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "AXFS",
+    "ArlzError",
+    "ArlzInvalidDataError",
+    "ArlzBufferOverflowError",
+    "arzl_decode",
+    "arzl_decompress",
+    "arzl_arm_filter",
+    "extract_bootimage",
+    "extract_pup",
+    "get_key_type",
+    "get_segments",
+    "keys",
+    "module_info",
+    "pup_decrypt_packages",
+    "pup_extract_files",
+    "read_module_info",
+    "read_self_info",
+    "scetypes",
+    "sceutils",
+    "scedecrypt",
+    "self2elf",
+    "slb2_decrypt",
+    "slb2_extract",
+    "unarzl",
+    "zrif_decode",
+]

sceutils/__main__.py

@@ -0,0 +1,57 @@
+import importlib
+import sys
+
+MODULES = [
+    "axfs",
+    "emmc_extract",
+    "extract_idstorage",
+    "find_imported_by",
+    "module_info",
+    "pup_fiction",
+    "pup_info",
+    "scedecrypt",
+    "self2elf",
+    "selfinfo",
+    "ud0_extract_pup",
+    "unpack_bootimage_new",
+    "unarzl",
+]
+
+
+def print_modules() -> None:
+    print("usage: sceutils <module> [options]")
+    print()
+    print("modules:")
+    for module in MODULES:
+        print(f"  {module}")
+    print()
+    print("Use 'sceutils <module> --help' for module specific options.")
+
+
+def main(argv: list[str] | None = None) -> int:
+    argv = list(sys.argv if argv is None else argv)
+
+    if len(argv) < 2 or argv[1] in ("-h", "--help"):
+        print_modules()
+        return 0 if len(argv) >= 2 else 1
+
+    module_name = argv[1]
+
+    if module_name == "unarzl":
+        from unarzl.__main__ import main as unarzl_main
+        return unarzl_main(argv[2:])
+
+    if module_name not in MODULES:
+        print(f"Unknown module: {module_name}")
+        print()
+        print_modules()
+        return 1
+
+    sys.argv = argv[1:]
+    module = importlib.import_module(f"sceutils.{module_name}")
+    result = module.main(sys.argv)
+    return result if isinstance(result, int) else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

sceutils/axfs.py

@@ -0,0 +1,308 @@
+#!/usr/bin/env python3
+
+import argparse
+import os
+import pathlib
+import stat
+import struct
+import tarfile
+import zlib
+import sys
+from dataclasses import dataclass
+from io import BytesIO
+from typing import Literal, Optional, IO
+
+PAGE_SHIFT = 12
+
+
+class ENodeTypes:
+    XIP = 0
+    Compressed = 1
+    Byte_aligned = 2
+
+
+def MAJOR(dev):
+    return dev >> 8
+
+
+def MINOR(dev):
+    return dev & 0xff
+
+
+@dataclass
+class axfs_super_onmedia:
+    magic: bytes        # 0x48A0E4CD
+    signature: bytes    # Advanced XIP FS\x00
+    digest: bytes       # sha1 digest for checking data integrity (sometimes 0x0)
+    cblock_size: int    # maximum size of the block being compressed
+    files: int          # number of inodes/files in fs
+    size: int           # total image size in bytes
+    blocks: bytes       # number of nodes in fs
+    mmap_size: bytes    # size of the memory mapped part of image
+    strings: int        # offset to strings region descriptor
+    xip: int            # offset to xip region descriptor
+    byte_aligned: int   # offset to the byte aligned region desc
+    compressed: int     # offset to the compressed region desc
+    node_type: int      # offset to node type region desc
+    node_index: int     # offset to node index region desc
+    cnode_offset: int   # offset to cnode offset region desc
+    cnode_index: int    # offset to cnode index region desc
+    banode_offset: int  # offset to banode offset region desc
+    cblock_offset: int  # offset to cblock offset region desc
+    inode_file_size: int    # offset to inode file size desc
+    inode_name_offset: int  # offset to inode name region desc
+    inode_num_entries: int  # offset to inode num_entries region desc
+    inode_mode_index: int   # offset to inode mode_index  region desc
+    inode_array_index: int  # offset to inode array_index region desc
+    modes: int  # offset to mode mode region desc
+    uids: int   # offset to uid index mode region desc
+    gids: int   # offset to gid index mode region desc
+    version_major: int
+    version_minor: int
+    version_sub: int
+    compression_type: int  # Identifies type of compression used on FS
+    timestamp: int  # UNIX time_t of filesystem build time
+
+
+class axfs_region_desc_onmedia:
+    fsoffset: int
+    size: int
+    compressed_size: int
+    max_index: int
+    table_byte_depth: int
+    incore: int
+
+
+class axfs_region(axfs_region_desc_onmedia):
+    data: bytes
+
+    def __init__(self, f: IO[bytes]) -> None:
+        (
+            self.fsoffset, self.size,
+            self.compressed_size, self.max_index,
+            self.table_byte_depth, self.incore
+        ) = struct.unpack(">QQQQBB", f.read(34))
+        f.seek(self.fsoffset, os.SEEK_SET)
+        self.data = f.read(self.size)
+
+    def axfs_bytetable_stitch(self, index: int) -> int:
+        assert index < self.max_index
+        output = 0
+        split = self.size // self.table_byte_depth
+        for i in range(self.table_byte_depth):
+            output += self.data[index + i * split] << (8 * i)
+        return output
+
+
+def offsetBytes(data: bytes, start: int, length: int):
+    return data[start:start + length]
+
+
+def loadRegion(f: IO, offset: int) -> axfs_region:
+    f.seek(offset, os.SEEK_SET)
+    return axfs_region(f)
+
+
+class AXFS:
+    def __init__(self, f: IO[bytes]):
+        self.superblock = axfs_super_onmedia(*struct.unpack('>I16s40sI22Q4BQ', f.read(252)))
+        assert self.superblock.signature == b'Advanced XIP FS\x00'
+        assert self.superblock.magic == 0x48A0E4CD
+        self.xip = loadRegion(f, self.superblock.xip)
+        self.strings = loadRegion(f, self.superblock.strings)
+        self.compressed = loadRegion(f, self.superblock.compressed)
+        self.byte_aligned = loadRegion(f, self.superblock.byte_aligned)
+        self.node_type = loadRegion(f, self.superblock.node_type)
+        self.node_index = loadRegion(f, self.superblock.node_index)
+        self.cnode_offset = loadRegion(f, self.superblock.cnode_offset)
+        self.cnode_index = loadRegion(f, self.superblock.cnode_index)
+        self.banode_offset = loadRegion(f, self.superblock.banode_offset)
+        self.cblock_offset = loadRegion(f, self.superblock.cblock_offset)
+        self.inode_file_size = loadRegion(f, self.superblock.inode_file_size)
+        self.inode_name_offset = loadRegion(f, self.superblock.inode_name_offset)
+        self.inode_num_entries = loadRegion(f, self.superblock.inode_num_entries)
+        self.inode_mode_index = loadRegion(f, self.superblock.inode_mode_index)
+        self.inode_array_index = loadRegion(f, self.superblock.inode_array_index)
+        self.modes = loadRegion(f, self.superblock.modes)
+        self.uids = loadRegion(f, self.superblock.uids)
+        self.gids = loadRegion(f, self.superblock.gids)
+        f.seek(0)
+
+    def list(self, node_id: int, folder="/"):
+        num_files = self.getNumEntries(node_id)
+        first = self.getArrayIndex(node_id)
+        for i in range(first, first + num_files):
+            name = self.getName(i)
+            mode = self.getMode(i)
+            size = " " * 9
+
+            if stat.S_ISREG(mode):
+                size = str(self.getFileSize(i)).rjust(9)
+            if stat.S_ISLNK(mode):
+                link_name = self.readFileData(i).decode("utf8")
+                name += ' -> ' + link_name
+            if stat.S_ISCHR(mode) or stat.S_ISBLK(mode):
+                st_rdev = self.getFileSize(i)
+                size = f"{str(MAJOR(st_rdev)).rjust(3)} {str(MINOR(st_rdev)).rjust(3)}".rjust(9)
+
+            print(f"{stat.filemode(mode)} {size} {folder + name}")
+
+            if stat.S_ISDIR(mode):
+                self.list(i, folder + name + "/")
+
+    def toTar(self, node_id: int, tar: tarfile.TarFile, folder=""):
+        num_files = self.getNumEntries(node_id)
+        first = self.getArrayIndex(node_id)
+        for i in range(first, first + num_files):
+            name = self.getName(i)
+            mode = self.getMode(i)
+
+            file = tarfile.TarInfo()
+            file.path = folder + name
+            file.uid = self.getUid(i)
+            file.gid = self.getGid(i)
+            file.mode = mode
+            file.mtime = self.superblock.timestamp
+            data = None
+
+            if stat.S_ISDIR(mode):
+                file.type = tarfile.DIRTYPE
+                self.toTar(i, tar, file.path + "/")
+
+            elif stat.S_ISLNK(mode):
+                link_name = self.readFileData(i).decode("utf8")
+                file.type = tarfile.SYMTYPE
+                file.linkname = link_name
+            elif stat.S_ISREG(mode):
+                file.type = tarfile.REGTYPE
+                file.size = self.getFileSize(i)
+                data = self.readFileData(i)
+
+            elif stat.S_ISCHR(mode):
+                file.type = tarfile.CHRTYPE
+            elif stat.S_ISBLK(mode):
+                file.type = tarfile.BLKTYPE
+
+            elif stat.S_ISSOCK(mode) or stat.S_ISFIFO(mode):
+                pass
+            else:
+                raise Exception("unkown filetype")
+
+            if stat.S_ISCHR(mode) or stat.S_ISBLK(mode):
+                st_rdev = self.getFileSize(i)  # very weird to put that in filesize...
+                file.devmajor, file.devminor = MAJOR(st_rdev), MINOR(st_rdev)
+
+            tar.addfile(file, BytesIO(data))
+
+    def getName(self, node_id: int) -> int:
+        offset = self.inode_name_offset.axfs_bytetable_stitch(node_id)
+        ret = self.strings.data[offset:]
+        if len(ret):
+            ret = ret[:ret.index(b"\00")]
+        return ret.decode("utf8")
+
+    def getFileSize(self, node_id: int) -> int:
+        return self.inode_file_size.axfs_bytetable_stitch(node_id)
+
+    def getMode(self, node_id: int) -> int:
+        mode_index = self.inode_mode_index.axfs_bytetable_stitch(node_id)
+        return self.modes.axfs_bytetable_stitch(mode_index)
+
+    def getUid(self, node_id: int) -> int:
+        mode_index = self.inode_mode_index.axfs_bytetable_stitch(node_id)
+        return self.uids.axfs_bytetable_stitch(mode_index)
+
+    def getGid(self, node_id: int) -> int:
+        mode_index = self.inode_mode_index.axfs_bytetable_stitch(node_id)
+        return self.gids.axfs_bytetable_stitch(mode_index)
+
+    def getNumEntries(self, node_id: int) -> int:
+        return self.inode_num_entries.axfs_bytetable_stitch(node_id)
+
+    def getArrayIndex(self, node_id: int) -> int:
+        return self.inode_array_index.axfs_bytetable_stitch(node_id)
+
+    def getNodeIndex(self, node_id: int) -> int:
+        return self.node_index.axfs_bytetable_stitch(node_id)
+
+    def getNodeType(self, node_id: int) -> int:
+        return self.node_type.axfs_bytetable_stitch(node_id)
+
+    def getByteAlignedOffset(self, node_id: int) -> int:
+        return self.banode_offset.axfs_bytetable_stitch(node_id)
+
+    def readFileData(self, node_id: int) -> bytes:
+        file_size = self.getFileSize(node_id)
+        array_index = self.getArrayIndex(node_id)
+
+        length = file_size
+        offset = 0
+        out = bytearray()
+
+        while length > 0:
+            node_index = self.getNodeIndex(array_index)
+            node_type = self.getNodeType(array_index)
+
+            if node_type == ENodeTypes.Byte_aligned:
+                src_offset = self.getByteAlignedOffset(node_index)
+                block_size = min(0x1 << PAGE_SHIFT, file_size)
+                out[offset:] = offsetBytes(self.byte_aligned.data, src_offset, block_size)
+                length -= block_size
+                offset += block_size
+
+            elif node_type == ENodeTypes.XIP:
+                out[offset:] = offsetBytes(self.xip.data, node_index << PAGE_SHIFT, 1 << PAGE_SHIFT)
+                offset += 1 << PAGE_SHIFT
+                length -= 1 << PAGE_SHIFT
+
+            elif node_type == ENodeTypes.Compressed:
+                cnode_offset = self.cnode_offset.axfs_bytetable_stitch(node_index)
+                cnode_index = self.cnode_index.axfs_bytetable_stitch(node_index)
+                src_offset = self.cblock_offset.axfs_bytetable_stitch(cnode_index)
+
+                block_length = self.cblock_offset.axfs_bytetable_stitch(cnode_index + 1) - src_offset
+                data = zlib.decompress(offsetBytes(self.compressed.data, src_offset, block_length))
+                block_length = min(self.superblock.cblock_size - cnode_offset, length)
+                out[offset:] = offsetBytes(data, cnode_offset, block_length)
+                length -= block_length
+                offset += block_length
+            else:
+                raise Exception("invalid nodeType")
+
+            array_index += 1
+
+        return bytes(out)
+
+
+def main(argv = sys.argv):
+    class _args:
+        command: Literal["list", "tar"]
+        inputfile: pathlib.Path
+        output: Optional[pathlib.Path]
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("command", type=str, choices=["list", "tar"])
+    parser.add_argument("inputfile", help="input axfs image", type=pathlib.Path)
+    parser.add_argument("output", help="output file name for tar", type=pathlib.Path, required=False)  # optional
+    args: _args = parser.parse_args(argv[1:])
+
+    inputfile = args.inputfile.as_posix()
+    output = args.output.as_posix() if args.output else None
+
+    with open(inputfile, "rb") as f:
+        fs = AXFS(f)
+
+    if args.command == "list":
+        fs.list(0)
+        return
+    elif args.command == "tar":
+        if not output:
+            output = inputfile + ".tar"
+        tar = tarfile.open(output, mode="w")
+        fs.toTar(0, tar)
+        tar.close()
+        return
+
+
+if __name__ == "__main__":
+    main()

sceutils/decrypt_cpupdate.py

@@ -0,0 +1,136 @@
+import os
+import struct
+import tarfile
+from io import BytesIO
+from typing import IO
+
+from Cryptodome.Cipher import AES
+from Cryptodome.PublicKey import RSA
+
+from sceutils import axfs
+
+CPUP_MAGIC = 0x43705570
+TRF_MAGIC = 0x23642745
+
+CpUp_Public = (0xA7CCAE0F501188527BF3DACCA3E231C8D8701E7B91927390701DE5E7A96327DAD87167A8F01368ADDFE490E325A290533697058FBA775766698010AFD8FD7A3FFD265E0A52FE04928BCE8B4302F4C70FFAC3C9397FD24B106271E57BDA20D2D702298F6F990ECF9B0FE04FF6CCEE170B555304232012D78E6019DAB29763829E6AF5ADA802204FA551631179CBFE6164732662E8576741949BB136456C11DE355F487211D230267DC05E699A2652AD5C6D74B0568326F4F2F5B86AD956E94404D3A65928F4EA2189567CE9989911B04808517F4C76A8B25DF1D6ABBE8595C469BFD7E870C4F00A89610C2C9B79F625A42CA2B4C6B8D37E62CE9EC61A856FD32F, 0x10001)
+FsImage_Public = (0xA9697F9D9343CADE68E04F9E356E6AB6BBC7DE36A4D81B98A83BC12BE3F6DF96ED7A64389456ACA933BEBFBA4FFEF05CF45F2F886F434FBBC3A01348533070C0B7D5E9C21EFE53E95A6019DB51C12C6BAFEB94E992287963448E59606384B99F3FF3E5EB6AA08BF32A4DBA7A312520CEC2B69BB20A6D0640B117170AA2DDA1FB590AEE7ADFC4E80DFCF27FA55DDEC92C07922FDD05AB1618DCB727AA6FF70027A9410BC845E50EAFD46C0FD92FF500672DE56489C669B0AA481FFD75E99E21A8DC2F9F9E87957B46BBF63FB7DDBE8B8CA861BA349A62458E855EE78C3DD6791F92E76422144E51295B1337E15C126DF6FA0C29321BC1D7C00E3C19EEF3A3E7A5, 0x10001)
+
+
+def decrypt_unpack_cpup(filename: str, dst: str) -> tarfile.TarFile:
+    " decrypts a cpup into a tar "
+    os.mkdir(dst)
+    dst_name = os.path.join(dst, os.path.basename(filename) + ".tar.gz")
+
+    with open(filename, "rb") as fin:
+        data = decrypt(fin)
+        with open(dst_name, "wb") as fout:
+            fout.write(data)
+    try:
+        tar = tarfile.open(fileobj=BytesIO(data), mode="r:gz")
+    except tarfile.ReadError:
+        raise ValueError("CpUp Extraction failed likely wrong keys")
+    return tar
+
+
+def extract_cpup(tar: tarfile.TarFile, dst: str):
+    " extracts the cpup from the tar "
+    os.mkdir(dst)
+
+    # decrypt fsimage0
+    fsimage0 = tar.extractfile("./fsimage0.trf")
+    if fsimage0 is None:
+        raise ValueError("fsimage0.trf not found")
+    fsimage0.seek(0x120)
+    with open(os.path.join(dst, "fsimage0.img"), "wb") as f:
+        f.write(fsimage0.read())
+
+    # read axfs for fsimage0
+    fsimage0.seek(0x120)
+    axfs_fsimage0 = axfs.AXFS(fsimage0)
+    with tarfile.open(os.path.join(dst, "fsimage0.tar"), mode="w") as tar_fsimage0:
+        axfs_fsimage0.toTar(0, tar_fsimage0)
+
+    # decrypt fsimage1
+    fsimage1 = tar.extractfile("./fsimage1.trf")
+    if fsimage1 is None:
+        raise ValueError("fsimage1.trf not found")
+    decrypted = decrypt(fsimage1)
+    with open(os.path.join(dst, "fsimage1.img"), "wb") as f:
+        f.write(decrypted)
+
+    # read axfs for fsimage1
+    axfs_fsimage1 = axfs.AXFS(BytesIO(decrypted))
+    with tarfile.open(os.path.join(dst, "fsimage1.tar"), mode="w") as tar_fsimage1:
+        axfs_fsimage1.toTar(0, tar_fsimage1)
+
+    # decrypt vmlinux image
+    vmlinux = tar.extractfile("./vmlinux.trf")
+    if vmlinux is None:
+        raise ValueError("vmlinux.trf not found")
+    with open(os.path.join(dst, "vmlinux.img"), "wb") as f:
+        f.write(decrypt(vmlinux))
+
+
+def decrypt(f: IO[bytes], silent=False):
+    " decrypts cpupdate "
+    is_encrypted = True
+
+    magic, = struct.unpack("<I", f.read(4))
+    if magic == CPUP_MAGIC:
+        (
+            cp_version,
+            fmt_version,
+            size,
+            data_offset,
+            data_size
+        ) = struct.unpack("<I8xIIII", f.read(28))
+        rsa = RSA.construct(CpUp_Public)
+
+        magic_str = int.to_bytes(magic, 4, "big").decode("ascii")
+        cp_ver_str = '.'.join([str(num) for num in int.to_bytes(cp_version, 4, "big")])
+        fmt_ver_str = '.'.join([str(num) for num in int.to_bytes(fmt_version, 4, "big")])
+        if not silent:
+            print("CpUp Decrypt")
+            print(f"magic       : {magic_str}\t\t(0x{magic:08X})")
+            print(f"cp version  : {cp_ver_str}\t\t(0x{cp_version:08X})")
+            print(f"fmt version : {fmt_ver_str}\t\t(0x{fmt_version:08X})")
+    elif magic == TRF_MAGIC:
+        (
+            version,
+            data_size,
+            data_offset,
+            size,
+        ) = struct.unpack("<IIII", f.read(16))
+        rsa = RSA.construct(FsImage_Public)
+        if version == 0x1010100:
+            is_encrypted = False
+
+        ver_str = '.'.join([str(num) for num in int.to_bytes(version, 4, "big")])
+        if not silent:
+            print("Trf Decrypt")
+            print(f"magic       : {magic:08X}")
+            print(f"version     : {ver_str}\t\t(0x{version:08X})")
+    else:
+        raise RuntimeError("Invalid CpUp or trf")
+
+    if not silent:
+        print(f"size        : {size}\t\t(0x{size:08X})")
+        print(f"data offset : {data_offset}\t\t(0x{data_offset:08X})")
+        print(f"data size   : {data_size}\t\t(0x{data_size:08X})")
+
+    # get key and iv from sig
+    f.seek(-0x100, 2)
+    key_data = f.read()
+    sig = rsa._encrypt(int.from_bytes(key_data, "big"))
+    sig = int.to_bytes(sig, 0x100, "big")[-0x34:]
+    (iv, key, sha1_hash) = struct.unpack("16s16s20s", sig)
+
+    # read file data and decrypt
+    f.seek(data_offset, os.SEEK_SET)
+    data = f.read((size - data_offset) - 0x100)
+    if is_encrypted:
+        aes_key = AES.new(key, AES.MODE_CBC, iv)
+        data = aes_key.decrypt(data)
+
+    print("-" * 80)
+    return data[:data_size]