sceutils 0.1.0__tar.gz

sceutils-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 molecule
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sceutils-0.1.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: sceutils
+Version: 0.1.0
+Summary: Utilities for PlayStation Vita SCE files
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pycryptodomex>=3.23.0
+Dynamic: license-file
+
+sceutils
+========
+
+Utilities for working with PlayStation Vita SCE / SELF / PUP files.
+
+Requirements
+------------
+
+* Python 3.11+
+* pycryptodomex
+
+Installation
+------------
+
+```sh
+pip install .
+```
+
+Usage
+-----
+
+### As a command line tool
+
+```sh
+sceutils --help
+sceutils selfinfo file.self
+sceutils self2elf -i eboot.bin -o eboot.elf -K keys_external.py
+sceutils pup_fiction PSP2UPDATE.pup output keys_external.py
+```
+
+The ARZL helper is also available directly:
+
+```sh
+unarzl kernel_boot_loader.self.seg03 nsbl.bin
+```
+
+### As a library
+
+```python
+from sceutils import self2elf, read_self_info, scedecrypt, unarzl, keys
+
+keys.use_keys("keys_external.py")
+
+with open("eboot.bin", "rb") as inf, open("eboot.elf", "wb") as outf:
+    self2elf(inf, outf)
+
+with open("eboot.bin", "rb") as inf:
+    info = read_self_info(inf)
+
+with open("kernel_boot_loader.self.seg03", "rb") as f:
+    nsbl = unarzl(f.read())
+```
+
+Modules
+-------
+
+pup_fiction
+-----------
+### usage:
+* `sceutils pup_fiction PUP_filename output_folder keys_file`
+
+### examples:
+* `sceutils pup_fiction PSP2UPDATE.pup 368 keys_external.py`
+
+---
+
+self2elf
+--------
+### usage:
+* `sceutils self2elf -i [input self] -o [output elf] -k [RIF file] [-K keys_external.py]`
+* `sceutils self2elf -i [input self] -o [output elf] -z [zRIF]`
+
+### examples:
+* `sceutils self2elf -i eboot.bin -o eboot.elf -z [zRIF here] [-K keys_external.py]`
+* `sceutils self2elf -i eboot.bin -o eboot.elf -k [RIF] [-K keys_external.py]`
+
+---
+
+selfinfo
+--------
+### usage:
+* `sceutils selfinfo [input self] [-K keys_external.py]`
+
+Prints the SCE header, SELF header, app info, control info, ELF headers,
+segment metadata and (when possible) module imports/exports.
+
+---
+
+axfs
+----
+### usage:
+* `sceutils axfs [list|tar] image_name [output_name]`
+
+### examples:
+* `sceutils axfs list fsimage.img`
+* `sceutils axfs tar fsimage.img [fsimage.tar]`

sceutils-0.1.0/README.md

@@ -0,0 +1,96 @@
+sceutils
+========
+
+Utilities for working with PlayStation Vita SCE / SELF / PUP files.
+
+Requirements
+------------
+
+* Python 3.11+
+* pycryptodomex
+
+Installation
+------------
+
+```sh
+pip install .
+```
+
+Usage
+-----
+
+### As a command line tool
+
+```sh
+sceutils --help
+sceutils selfinfo file.self
+sceutils self2elf -i eboot.bin -o eboot.elf -K keys_external.py
+sceutils pup_fiction PSP2UPDATE.pup output keys_external.py
+```
+
+The ARZL helper is also available directly:
+
+```sh
+unarzl kernel_boot_loader.self.seg03 nsbl.bin
+```
+
+### As a library
+
+```python
+from sceutils import self2elf, read_self_info, scedecrypt, unarzl, keys
+
+keys.use_keys("keys_external.py")
+
+with open("eboot.bin", "rb") as inf, open("eboot.elf", "wb") as outf:
+    self2elf(inf, outf)
+
+with open("eboot.bin", "rb") as inf:
+    info = read_self_info(inf)
+
+with open("kernel_boot_loader.self.seg03", "rb") as f:
+    nsbl = unarzl(f.read())
+```
+
+Modules
+-------
+
+pup_fiction
+-----------
+### usage:
+* `sceutils pup_fiction PUP_filename output_folder keys_file`
+
+### examples:
+* `sceutils pup_fiction PSP2UPDATE.pup 368 keys_external.py`
+
+---
+
+self2elf
+--------
+### usage:
+* `sceutils self2elf -i [input self] -o [output elf] -k [RIF file] [-K keys_external.py]`
+* `sceutils self2elf -i [input self] -o [output elf] -z [zRIF]`
+
+### examples:
+* `sceutils self2elf -i eboot.bin -o eboot.elf -z [zRIF here] [-K keys_external.py]`
+* `sceutils self2elf -i eboot.bin -o eboot.elf -k [RIF] [-K keys_external.py]`
+
+---
+
+selfinfo
+--------
+### usage:
+* `sceutils selfinfo [input self] [-K keys_external.py]`
+
+Prints the SCE header, SELF header, app info, control info, ELF headers,
+segment metadata and (when possible) module imports/exports.
+
+---
+
+axfs
+----
+### usage:
+* `sceutils axfs [list|tar] image_name [output_name]`
+
+### examples:
+* `sceutils axfs list fsimage.img`
+* `sceutils axfs tar fsimage.img [fsimage.tar]`

sceutils-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "sceutils"
+version = "0.1.0"
+description = "Utilities for PlayStation Vita SCE files"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "pycryptodomex>=3.23.0",
+]
+
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project.scripts]
+sceutils = "sceutils.__main__:main"
+unarzl = "unarzl.__main__:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["sceutils*", "unarzl*"]

sceutils-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sceutils-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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()