sceutils 0.1.0__py3-none-any.whl

sceutils/emmc_extract.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import itertools
+import os
+import struct
+import subprocess
+import sys
+import zipfile
+from enum import Enum
+from glob import glob
+from typing import IO
+
+from sceutils import keys, pup_fiction
+
+DO_EXTRACT = True
+EMMC_BLOCK_SIZE = 512
+
+
+class EmmcPartitionCode(Enum):
+    EMPTY = 0
+    IDSTORAGE = 1
+    SLB2 = 2
+    OS0 = 3
+    VS0 = 4
+    VD0 = 5
+    TM0 = 6
+    UR0 = 7
+    UX0 = 8
+    GRO0 = 9
+    GRW0 = 0xA
+    UD0 = 0xB
+    SA0 = 0xC
+    UNKOWN_MC = 0xD
+    PD0 = 0xE
+
+
+class EmmcPartitionType(Enum):
+    UNKNOWN_0 = 0
+    FAT16 = 0x6
+    EXFAT = 0x7
+    UNKNOWN = 0xB
+    RAW = 0xDA
+
+
+def sizeof_fmt(num, suffix='B'):
+    for unit in ['','Ki','Mi','Gi','Ti','Pi','Ei','Zi']:
+        if abs(num) < 1024.0:
+            return "%3.1f%s%s" % (num, unit, suffix)
+        num /= 1024.0
+    return "%.1f%s%s" % (num, 'Yi', suffix)
+
+
+class EmmcPartition:
+    Size = 0x11
+
+    def __init__(self, data):
+        (
+            offset,
+            size,
+            code,
+            type,
+            self.active,
+            self.flags,
+        ) = struct.unpack('<IIBB?I2x', data)
+
+        self.offset = offset*EMMC_BLOCK_SIZE
+        self.size = size*EMMC_BLOCK_SIZE
+        self.code = EmmcPartitionCode(code)
+        self.type = EmmcPartitionType(type)
+
+    def __str__(self):
+        ret =  'EmmcPartition:\n'
+        ret += f'Offset (bytes):   0x{self.offset:X}\n'
+        ret += f'Size (bytes):     0x{self.size:X} ({sizeof_fmt(self.size)})\n'
+        ret += f'Code:             {self.code}\n'
+        ret += f'Type:             {self.type}\n'
+        ret += f'Active:           {self.active}\n'
+        ret += f'Flags:            0x{self.flags:08X}\n'
+        return ret
+
+
+class EmmcMasterBlock:
+    Size = 0x200
+
+    def __init__(self, data):
+        (
+            self.magic,
+            self.version,
+            size,
+            signature
+        ) = struct.unpack('<32sII40x272x94x16x16x16x16xH', data)
+
+        if signature != 0xAA55:
+            raise TypeError('Invalid boot signature')
+
+        if self.version != 3:
+            raise TypeError('Unknown version')
+
+        self.size = size*EMMC_BLOCK_SIZE
+
+        partitions = data[0x50:0x160]
+        partitions = [
+            EmmcPartition(partitions[x:x+EmmcPartition.Size])
+            for x in range(0, len(partitions), EmmcPartition.Size)
+        ]
+        self.partitions = [p for p in itertools.takewhile(lambda x: x.offset != 0, partitions)]
+
+    def __str__(self):
+        ret =  'EmmcMasterBlock:\n'
+        ret += f'Magic:          {self.magic}\n'
+        ret += f'Version:        {self.version}\n'.format()
+        ret += f'Size (bytes):   0x{self.size:X} ({sizeof_fmt(self.size)})\n'
+        ret += 'Partitions:\n'
+
+        for p in self.partitions:
+            ret += f'{p}\n'
+
+        return ret
+
+
+def extract_partition(emmc: IO, p: EmmcPartition, partition_image_name: str):
+    if not os.path.exists(partition_image_name):
+        with open(partition_image_name, "wb") as f:
+            emmc.seek(p.offset)
+            length = 0
+
+            while length != p.size:
+                data = emmc.read(min(p.size - length, int(100e6)))
+                if len(data) == 0 or data is None:
+                    break
+
+                f.write(data)
+                length += len(data)
+                print(f'{100*length/p.size:.2f}%... ')
+
+        if length != p.size:
+            print(f'output {p.code.name} is truncated ({100*length/p.size:.2f}% dumped)')
+
+
+def extract_fs(basedir: str, partition_name: str, p: EmmcPartition, partition_image_name: str):
+    print(f"Extracting {partition_name}")
+    partition_out = os.path.join(basedir, "fs", partition_name)
+    if not os.path.exists(partition_out):
+        subprocess.call(["7z", "x", partition_image_name, f"-o{partition_out}"])
+
+    partition_dec_out = os.path.join(basedir, "fs_dec", partition_name)
+    if not os.path.exists(partition_dec_out):
+        print("Decryping selfs")
+        pup_fiction.decrypt_selfs(partition_out, partition_dec_out)
+
+    if p.code == EmmcPartitionCode.OS0:
+        if not os.path.exists(partition_dec_out):
+            print("decrypting os0")
+            pup_fiction.decrypt_os0(basedir)
+
+        try:
+            bootimage_out = partition_dec_out+"/kd/bootimage"
+            if not os.path.exists(bootimage_out):
+                print("decrypting bootimage")
+                os.makedirs(bootimage_out, exist_ok=True)
+                pup_fiction.extract_bootimage(partition_dec_out+"/kd/bootimage.elf", bootimage_out)
+        except Exception as e:
+            print("error extracting bootimage")
+            print(e)
+
+
+def extract_slb2(basedir: str, partition_name: str, partition_image_name: str):
+    slb2_out = os.path.join(basedir, partition_name)
+    if not os.path.exists(slb2_out):
+        print("extracting slb2")
+        os.makedirs(slb2_out, exist_ok=True)
+        pup_fiction.slb2_extract(partition_image_name, slb2_out)
+
+    slb2_dec_out = os.path.join(basedir, partition_name+"_dec")
+    if not os.path.exists(slb2_dec_out):
+        print("decrypting slb2")
+        os.makedirs(slb2_dec_out, exist_ok=True)
+        try:
+            pup_fiction.slb2_decrypt(slb2_out, slb2_dec_out)
+        except KeyError as e:
+            with open(slb2_dec_out+"/error.txt", "w", encoding="utf8") as f:
+                f.write(str(e))
+            print(e)
+
+
+def extract_emmc(emmc: IO, basedir: str):
+    master = EmmcMasterBlock(emmc.read(EmmcMasterBlock.Size))
+    print(master)
+
+    for p in master.partitions:
+        partition_name = p.code.name.lower()
+        have_inactive = len([x for x in master.partitions if x.code == p.code]) > 1
+        if have_inactive:
+            partition_name = f"{partition_name}_{'active' if p.active else 'inactive'}"
+        name = f'{partition_name}.bin'
+
+        partition_image_name = f"{basedir}/{name}"
+        print(f'extracting {partition_image_name}... ')
+        extract_partition(emmc, p, partition_image_name)
+
+        if p.code in (EmmcPartitionCode.OS0, EmmcPartitionCode.VS0) and DO_EXTRACT:
+            extract_fs(basedir, partition_name, p, partition_image_name)
+
+        if p.code == EmmcPartitionCode.SLB2 and DO_EXTRACT:
+            extract_slb2(basedir, partition_name, partition_image_name)
+
+
+def main(argv = sys.argv):
+    if len(argv) < 4:
+        print(f"usage: {argv[0]} (filename) (output_folder) [keyset]")
+        sys.exit(1)
+    fname = argv[1]
+    output = argv[2]
+    keyset = argv[3] if len(argv) > 3 else "keys_external.py"
+    keys.use_keys(keyset)
+    
+    if fname.endswith(".zip"):
+        z = zipfile.PyZipFile(fname)
+        emmc = z.open(z.namelist()[0], "r")
+    else:
+        emmc = open(fname, "rb")
+
+    os.makedirs(output, exist_ok=True)
+    try:
+        extract_emmc(emmc, output)
+    finally:
+        emmc.close()
+
+if __name__ == "__main__":
+    main()

sceutils/extract_idstorage.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+
+import os
+import sys
+
+from .util import u16
+
+
+def main(argv = sys.argv):
+    if len(argv) != 3:
+        print(f"Usage: {argv[0]} idstorage-partition.bin output-directory/")
+        sys.exit(1)
+
+    with open(argv[1], "rb") as fin:
+        data = fin.read()
+
+    index_table = data[0:512]
+    for index in range(256):
+        leaf = u16(index_table, index * 2)
+        if leaf not in [0xFFFF, 0xFFF5]:
+            with open(os.path.join(argv[2], f"leaf_{leaf:04X}.bin"), "wb") as fout:
+                fout.write(data[512 * index:512 * (index + 1)])
+            print(f"Leaf 0x{leaf:04X}")
+
+
+if __name__ == "__main__":
+    main()

sceutils/find_imported_by.py

@@ -0,0 +1,35 @@
+# --folder = path to /fs_dec/
+# --nid = the function nid you are search for
+
+import argparse
+import os
+import sys
+
+from sceutils import module_info
+
+
+def main(argv = sys.argv):
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-f", "--folder", type=str, required=True)
+    parser.add_argument("-n", "--nid", type=str, required=True)
+    args = parser.parse_args(argv[1:])
+    nid = int(args.nid, 0)
+    
+    for (root, folders, files) in os.walk(args.folder):
+        for file in files:
+            if not file.split(".")[-1] == "elf":
+                continue
+            path = os.path.join(root, file)
+            relpath = os.path.relpath(path, args.folder)
+            with open(path, "rb") as f:
+                info = module_info.read_module_info(f)
+                if info is None:
+                    continue
+                module, imports, exports = info
+            for imp in imports:
+                if nid in imp.functions:
+                    print(relpath)
+                    break
+
+if __name__ == "__main__":
+    main()

sceutils/keys.py

@@ -0,0 +1,57 @@
+import binascii
+import importlib
+import os
+import sys
+from collections import defaultdict
+from typing import Literal, NamedTuple
+
+from .scetypes import SelfType
+
+ENC_KEY: bytes
+ENC_IV: bytes
+
+XXX_KEY: bytes
+XXX_IV: bytes
+
+SCEWM_KEY: bytes
+SCEWM_IV: bytes
+
+SCEAS_KEY: bytes
+SCEAS_IV: bytes
+
+SCE_KEYS: "KeyStore"
+
+class KeyEntry(NamedTuple):
+    minver: int
+    maxver: int
+    keyrev: int
+    key: bytes
+    iv: bytes
+
+class KeyStore:
+    def __init__(self):
+        self._store = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
+
+    def register(self, keytype, scetype, keyrev, key, iv, minver=0, maxver=0xffffffffffffffff, selftype=SelfType.NONE):
+        self._store[keytype][scetype][selftype].append(KeyEntry(minver, maxver, keyrev, binascii.a2b_hex(key), binascii.a2b_hex(iv)))
+
+    def get(self, keytype, scetype, sysver=-1, keyrev=-1, selftype=SelfType.NONE):
+        if keytype not in self._store:
+            raise KeyError("Cannot find any keys for this key type")
+        if scetype not in self._store[keytype]:
+            raise KeyError("Cannot find any keys for this SCE type")
+        if selftype not in self._store[keytype][scetype]:
+            raise KeyError("Cannot find any keys for this SELF type")
+        for item in self._store[keytype][scetype][selftype]:
+            if (sysver < 0 or (sysver >= item.minver and sysver <= item.maxver)) and (keyrev < 0 or keyrev == item.keyrev):
+                return (item.key, item.iv)
+        print(f"{keytype=} {scetype=} {sysver=:x} {keyrev=} {selftype}")
+        raise KeyError("Cannot find key/iv for this SCE file")
+
+def use_keys(name: Literal["keys_external.py", "keys_internal.py", "keys_proto.py"] | str):
+    mod_name = os.path.basename(name).split(".")[0]
+    dir_ = os.path.dirname(name)
+    if dir_ not in sys.path:
+        sys.path.append(dir_)
+    mod = importlib.import_module("sceutils."+mod_name)
+    globals().update(vars(mod))

sceutils/keys_external.py

@@ -0,0 +1,333 @@
+import binascii
+
+from .keys import KeyStore
+from .scetypes import KeyType, SceType, SelfType
+
+ENC_KEY = binascii.a2b_hex('AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA')
+ENC_IV =  binascii.a2b_hex('AF5F2CB04AC1751ABF51CEF1C8096210')
+
+SCEWM_KEY = binascii.a2b_hex("BFD5EA9F91AE9AF23565E534C4823B72")
+SCEWM_IV =  binascii.a2b_hex("CE16937E97A3349F143C8FB6AA219528")
+
+SCEAS_KEY = binascii.a2b_hex("AC5AB4907867FE8017072C98280DC311")
+SCEAS_IV =  binascii.a2b_hex("ACDFA94246D31970B7925FF7A26B0036")
+
+SCE_KEYS = KeyStore()
+SCE_KEYS.register(
+    KeyType.METADATA,
+    SceType.SPKG, 
+    0, 
+    '2E6F4751D15B06C51F572A9306E52DD7007EA56A31D459EC6D3681AB08625501', 
+    'B3D541A568751DF8F4833BAB4EFE0537', 
+    0x00000000000, 
+    0xFFF00000000, 
+    SelfType.NONE
+)
+
+SCE_KEYS.register(
+    KeyType.METADATA,
+    (SceType.SPKG, 2),
+    0,
+    '77E388FB9AC78A00BA7A746610A0DF76350919F541974E1439AD76AA96327CE2',
+    '41F2D4F7E5B106757ABCF48192B93944',
+    0x00000000000, 
+    0xFFF00000000, 
+    SelfType.NONE
+)
+
+SCE_KEYS.register(
+    KeyType.METADATA,
+    SceType.SRVK, 
+    0, 
+    '4648164DB9E67009456C7CA6F2378835FD678539B36B3DE6F1C604B7D4258141', 
+    '6EC8AD67993DAE75675F0AFFDE5C41F3', 
+    0x10300000000, 
+    0x16920000000, 
+    SelfType.NONE
+)
+
+SCE_KEYS.register(
+    KeyType.METADATA,
+    SceType.SRVK, 
+    0, 
+    'DAE4B0F901E338DEFF3CCDBDEA1E2FDEA9926BB98CB182443CC0C0F7FAE428EE', 
+    '18D925FA885C7E28A9CFF458C24D8BED', 
+    0x18000000000, 
+    0xFFF00000000, 
+    SelfType.NONE
+)
+
+SCE_KEYS.register(
+    KeyType.METADATA,
+    SceType.SELF, 
+    1, 
+    '9D4E4CE92EA1C4576EB9601EC43EC03AAE8EC324ECF6DE01E918E61D2223EE55', 
+    'CFEA3CCBA454D3279AD7CB0510431434', 
+    0x10300000000, 
+    0x16920000000, 
+    SelfType.SECURE
+)
+
+SCE_KEYS.register(
+    KeyType.METADATA,
+    SceType.SELF, 
+    1, 
+    'B1B6FEB39A8BD7A2AC584D435E150C624F560D3EFB03E745C575E0844569E2D0', 
+    '89B4E6BAB03B03D49BF0FC927FEA8659', 
+    0x18000000000, 
+    0x36100000000, 
+    SelfType.SECURE
+)
+
+SCE_KEYS.register(
+    KeyType.METADATA,
+    SceType.SELF, 
+    1, 
+    '59AC7F05E115D758201A3F3461BCA0D42BD186F00CFC24263973F622AD9ED30C', 
+    'A053B00BA4BF880799B4265C6BC064B5', 
+    0x36300000000, 
+    0xFFF00000000, 
+    SelfType.SECURE
+)
+
+SCE_KEYS.register(
+    KeyType.METADATA,
+    SceType.SELF, 
+    1, 
+    '7A7FB1560DCD121CEA5E11B90124B13282752F2D5B95D75036AB3A29BB3BD2AB', 
+    '6C71642A042A041F1EE3094070B009BE', 
+    0x10300000000, 
+    0x16920000000, 
+    SelfType.BOOT
+)
+
+SCE_KEYS.register(
+    KeyType.METADATA,
+    SceType.SELF, 
+    1, 
+    'B1B936B512F9A16E51B948622B26F15C53680C77AC332EC25846B839520393EC', 
+    '90D527BAF7296B5B6A576CFA6B54D266', 
+    0x18000000000, 
+    0x36100000000, 
+    SelfType.BOOT
+)
+
+SCE_KEYS.register(
+    KeyType.METADATA,
+    SceType.SELF, 
+    1, 
+    '426FD1D33FEBBFAC560B7957B94F445AE5F1DED2AA70F74DB944645DC439122F', 
+    '995F1364BB9735FA448B18D886150C85', 
+    0x36300000000, 
+    0xFFF00000000, 
+    SelfType.BOOT
+)
+
+SCE_KEYS.register(
+    KeyType.METADATA,
+    SceType.SELF, 
+    1, 
+    'B4AAF62D48FBD898C240308A9773AFE57B8A18D783F0B37932BB21B51386A9A0', 
+    '8CD162C5C613376F3E4BEA0B8FD5A3D0', 
+    0x10300000000, 
+    0x16920000000, 
+    SelfType.KERNEL
+)
+
+SCE_KEYS.register(
+    KeyType.METADATA,
+    SceType.SELF, 
+    1, 
+    '849AF7E8DE5B9C28C38CA74963FCF155E0F200FB08185E46CDA87790AAA10D72', 
+    '88710E219454A3CBF6D382D4BBD22BFC', 
+    0x18000000000, 
+    0x36100000000, 
+    SelfType.KERNEL
+)
+
+SCE_KEYS.register(
+    KeyType.METADATA,
+    SceType.SELF, 
+    1, 
+    '18E26DF712C362769D4F5E70460D28D88B7B991733DE692C2B9463B41FF4B925', 
+    '5B13077EEA801FC77D492050801FA507', 
+    0x36300000000, 
+    0xFFF00000000, 
+    SelfType.KERNEL
+)
+
+SCE_KEYS.register(
+    KeyType.METADATA,
+    SceType.SELF, 
+    0, 
+    '4769935C3B1CB248C3A88A406B1535D5DC2C0279D5901DE534DC4A11B8F60804', 
+    '0CE906F746D40105660456D827CEBD25', 
+    0x10300000000, 
+    0x16920000000, 
+    SelfType.USER
+)
+
+SCE_KEYS.register(
+    KeyType.METADATA,
+    SceType.SELF, 
+    0, 
+    '4769935C3B1CB248C3A88A406B1535D5DC2C0279D5901DE534DC4A11B8F60804', 
+    '0CE906F746D40105660456D827CEBD25', 
+    0x18000000000, 
+    0xFFF00000000, 
+    SelfType.USER
+)
+
+SCE_KEYS.register(
+    KeyType.METADATA,
+    SceType.SELF, 
+    1, 
+    '613AD6EAC63D4E14F51A8C6AF18C66621968323B6F205B5E515C16D77BB06671', 
+    'ADBDAA5041B2094CF2B359301DE64171', 
+    0x10300000000, 
+    0xFFF00000000, 
+    SelfType.USER
+)
+
+SCE_KEYS.register(
+    KeyType.METADATA,
+    SceType.SELF, 
+    2, 
+    '0F2041269B26D6B7EF143E35E83E914629A92F50F3A4CEE14CDFF63AEC641117', 
+    '07EF64437F0CB6995E6D785E42796C83', 
+    0x18000000000, 
+    0xFFF00000000, 
+    SelfType.USER
+)
+
+SCE_KEYS.register(
+    KeyType.METADATA,
+    SceType.SELF, 
+    3, 
+    '3AFADA34660C6515B539EBBBC79C9C0ADA4337C32652CA03C6DD21A1D612D8F4', 
+    '7F98A137869B91B1EB9604F81FD74C50', 
+    0x18000000000, 
+    0xFFF00000000, 
+    SelfType.USER
+)
+
+SCE_KEYS.register(
+    KeyType.METADATA,
+    SceType.SELF, 
+    4, 
+    '8FF491B36713E8AA38DE30B303689657F07AE70A8A8B1D7867441C52DB39C806', 
+    'D9CC7E26CE99053E48F9BEF1CB93C184', 
+    0x36300000000, 
+    0xFFF00000000, 
+    SelfType.USER
+)
+
+SCE_KEYS.register(
+    KeyType.METADATA,
+    SceType.SELF, 
+    5, 
+    '4D71B2FB3D4359FB34445305C88A5E82FA12D34A8308F312AA34B58F6112253A', 
+    '04A27133FF0205C96B7F45A60D7D417B',
+    0x36300000000, 
+    0xFFF00000000, 
+    SelfType.USER
+)
+
+SCE_KEYS.register(
+    KeyType.NPDRM,
+    SceType.SELF,
+    0,
+    'C10368BF3D2943BC6E5BD05E46A9A7B6',
+    '00000000000000000000000000000000',
+    0x00000000000, 
+    0xFFFFFFFFFFFFFFFFFFFFFF, 
+    SelfType.APP
+)
+
+SCE_KEYS.register(
+    KeyType.NPDRM,
+    SceType.SELF,
+    1,
+    '16419DD3BFBE8BDC596929B72CE237CD',
+    '00000000000000000000000000000000',
+    0x00000000000, 
+    0xFFFFFFFFFFFFFFFFFFFFFF, 
+    SelfType.APP
+)
+
+SCE_KEYS.register(
+    KeyType.METADATA,
+    SceType.SELF,
+    0,
+    'AAA508FA5E85EAEE597ED2B27804D22287CFADF1DF32EDC7A7C58E8C9AA8BB36',
+    'CD1BD3A59200CC67A3B804808DC2AE73',
+    0x00000000000, 
+    0x16920000000, 
+    SelfType.APP
+)
+
+SCE_KEYS.register(
+    KeyType.METADATA,
+    SceType.SELF,
+    0,
+    '5661E5FB20CFD1D1DFF50C1E59A6EA977D0AA5C5770F53B9CDD4E9451FFF55CB',
+    '23D02FF79BF430E2D123869BF0CACAA0',
+    0x18000000000, 
+    0xFFFFFFFFFFFFFFFFFFFFFF, 
+    SelfType.APP
+)
+
+SCE_KEYS.register(
+    KeyType.METADATA,
+    SceType.SELF,
+    1,
+    '4181B2DF5F5D94D3C80B7D86EACF1928533A49BA58EDE2B43CDEE7E572568BD4',
+    'B1678C0543B6C1997B63A6F4F3C8FD33',
+    0x00000000000, 
+    0xFFFFFFFFFFFFFFFFFFFFFF, 
+    SelfType.APP
+)
+
+SCE_KEYS.register(
+    KeyType.METADATA,
+    SceType.SELF,
+    2,
+    '5282582F17F068F89A260AAFB71C58928F45A8D08C681376B07FF9EAB1114226',
+    '29672DF43E426F41AF46D42E8437D449',
+    0x18000000000, 
+    0xFFFFFFFFFFFFFFFFFFFFFF, 
+    SelfType.APP
+)
+
+SCE_KEYS.register(
+    KeyType.METADATA,
+    SceType.SELF,
+    3,
+    '270CBA370061B87077672ADB5142D18844AAED352A9CCEE63602B0D740594334',
+    '1CF2454FBF47D76221B91AFC3B608C28',
+    0x18000000000, 
+    0xFFFFFFFFFFFFFFFFFFFFFF, 
+    SelfType.APP
+)
+
+SCE_KEYS.register(
+    KeyType.METADATA,
+    SceType.SELF,
+    4,
+    'A782BC5A9EDDFC49A513FF3E592C4677A8C8920F23C9F11F2558FB9D99A43868',
+    '559B5E658559EB65EBF892C274E098A9',
+    0x35700000000, 
+    0xFFFFFFFFFFFFFFFFFFFFFF, 
+    SelfType.APP
+)
+
+SCE_KEYS.register(
+    KeyType.METADATA,
+    SceType.SELF,
+    5,
+    '12D64D0172495226010A687DE245A73DE028B3561E25E69BABC325636F3CAE0A',
+    'F149EED1757E5A915B24309795BFC380',
+    0x35700000000, 
+    0xFFFFFFFFFFFFFFFFFFFFFF, 
+    SelfType.APP
+)