psptool 3.0__tar.gz → 3.2__tar.gz

psptool-3.2/.github/workflows/gha-metrics.yml

@@ -0,0 +1,33 @@
+name: Post metrics comment
+
+on: [pull_request_target]
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.9"]
+
+    steps:
+      - uses: actions/checkout@v3
+        with:
+           submodules: recursive
+           ssh-key: ${{ secrets.PSPTOOL_FIXTURES_NEW_PRIVATE_KEY }}
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v3
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install .
+      - name: Run metrics and post comment
+        run: |
+          python tests/gha_metrics.py > metrics.md
+          gh pr comment $PRNUM --body-file metrics.md
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GH_REPO: ${{ github.repository }}
+          PRNUM: ${{ github.event.pull_request.number }}

psptool-3.2/.github/workflows/publish.yml

@@ -0,0 +1,51 @@
+name: Publish Python distribution to PyPI and TestPyPI
+
+on: push
+
+jobs:
+  build:
+    name: Build distribution
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.11"
+    - name: Install pypa/build
+      run: >-
+        python3 -m
+        pip install
+        build
+        --user
+    - name: Build a binary wheel and a source tarball
+      run: python3 -m build
+    - name: Store the distribution packages
+      uses: actions/upload-artifact@v4
+      with:
+        name: python-package-distributions
+        path: dist/
+    
+  publish-to-pypi:
+    name: >-
+      Publish Python distribution to PyPI
+    if: startsWith(github.ref, 'refs/tags')  # only publish on tag push
+    needs:
+    - build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/psptool/
+    permissions:
+      id-token: write  # important for trusted publishing
+    steps:
+    - name: Download all the dists
+      uses: actions/download-artifact@v4
+      with:
+        name: python-package-distributions
+        path: dist/
+    - name: Publish distribution to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1

{psptool-3.0 → psptool-3.2}/PKG-INFO

@@ -1,24 +1,13 @@
 Metadata-Version: 2.4
 Name: psptool
-Version: 3.0
+Version: 3.2
 Summary: PSPTool is a tool for dealing with AMD binary blobs
-Home-page: https://github.com/PSPReverse/PSPTool
-Author: Christian Werling
-Author-email: cwerling@posteo.de
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Science/Research
-Classifier: Topic :: Security
-Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
-Classifier: Programming Language :: Python :: 3.8
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
+Author-email: Christian Werling <cwerling@posteo.de>
 License-File: LICENSE
-Requires-Dist: setuptools
+Requires-Python: >=3.8
 Requires-Dist: cryptography>=38.0.0
 Requires-Dist: prettytable
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: license-file
+Description-Content-Type: text/markdown
 
 # PSPTool
 
@@ -880,4 +869,4 @@ b'\x01\x00\x00\x00\x1b\xb9\x87\xc3YIF\x06\xb1t\x94V\x01\xc9\xea[\x1b\xb9\x87\xc3
 > psp.blob.roms[0].directories[0].files[1].move_buffer(0x60000, 0x1000)
 > psp.blob.roms[0].set_bytes(0x60000, 0x1000, my_stuff)
 > psp.to_file('my_modified_bios.bin')
-```
+```

{psptool-3.0 → psptool-3.2}/psptool/__init__.py

@@ -15,6 +15,6 @@
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 from .psptool import PSPTool
+from importlib.metadata import version
 
-import pkg_resources
-__version__ = pkg_resources.get_distribution("psptool").version
+__version__ = version("psptool")

{psptool-3.0 → psptool-3.2}/psptool/__main__.py

@@ -16,9 +16,10 @@
 
 import sys
 import os
-import pkg_resources
+import re
 
 from .psptool import PSPTool
+from . import __version__
 from .utils import ObligingArgumentParser, PrintHelper
 from .header_file import HeaderFile
 from .pubkey_file import PubkeyFile
@@ -27,6 +28,36 @@ from .crypto import PrivateKeyDict
 from argparse import RawTextHelpFormatter, SUPPRESS
 
 
+def find_files_by_type_regex(psp, pattern, rom_index=0):
+    """Find files whose type matches the given regex pattern.
+
+    Returns a tuple of (matching_files, are_identical) where:
+    - matching_files: list of matching files
+    - are_identical: boolean indicating if all matching files have identical content
+    """
+    matching_files = []
+    regex = re.compile(pattern, re.IGNORECASE)
+
+    # Search through all directories in the specified ROM
+    for directory in psp.blob.roms[rom_index].directories:
+        for file in directory.files:
+            if file is not None:
+                file_type = file.get_readable_type()
+                if regex.search(file_type):
+                    matching_files.append(file)
+
+    # Check if all matching files are identical
+    are_identical = True
+    if len(matching_files) > 1:
+        first_bytes = matching_files[0].get_bytes()
+        for file in matching_files[1:]:
+            if file.get_bytes() != first_bytes:
+                are_identical = False
+                break
+
+    return matching_files, are_identical
+
+
 def main():
     # CLI stuff to create a PSPTool object and interact with it
     parser = ObligingArgumentParser(description='Display, extract, and manipulate AMD PSP firmware inside BIOS ROMs.\n',
@@ -50,6 +81,7 @@ def main():
     parser.add_argument('-m', '--metrics', help=SUPPRESS, action='store_true')
     parser.add_argument('-p', '--privkeystub', help=SUPPRESS)
     parser.add_argument('-a', '--privkeypass', help=SUPPRESS)
+    parser.add_argument('-T', '--type-regex', help=SUPPRESS)
 
     action = parser.add_mutually_exclusive_group(required=False)
 
@@ -67,11 +99,15 @@ def main():
 
     action.add_argument('-X', '--extract-file', help='\n'.join([
         'Extract one or more PSP firmware files.',
-        '[-d idx [-e idx]] [-n] [-u] [-c] [-k] [-o outfile]',
+        '[-d idx [-e idx]] [-n] [-u] [-c] [-k] [-o outfile] [-T regex]',
         '',
-        '-r idx:  specifies rom_index (default: 0)',
+        '-r idx:  specifies rom_index (default: ROM 0 only)',
         '-d idx:  specifies directory_index (default: all directories)',
         '-e idx:  specifies file_index (default: all files)',
+        '-T regex: extract file(s) whose type matches the regex pattern',
+        '          (e.g., "SMUSCS" matches "FW_PSP_SMUSCS~0x5f")',
+        '          If multiple identical files match, extracts one with warning',
+        '          If multiple different files match, exits with error',
         '-n:      skip duplicate files and extract unique files only',
         '-u:      uncompress compressed files',
         '-c:      try to decrypt files',
@@ -97,7 +133,7 @@ def main():
     ph = PrintHelper(args.verbose)
 
     if args.version:
-        print(pkg_resources.get_distribution("psptool").version)
+        print(__version__)
         sys.exit(0)
     elif not args.file:
         parser.print_help(sys.stderr)
@@ -107,9 +143,29 @@ def main():
     output = None
 
     if args.extract_file:
-        if args.directory_index is not None and args.file_index is not None:
+        file = None
+
+        # Option 1) A single file should be extracted and we get it from a regex-based type search
+        if args.type_regex:
+            matching_files, are_identical = find_files_by_type_regex(psp, args.type_regex, args.rom_index)
+
+            if not matching_files:
+                ph.print_error_and_exit(f'No files found matching type regex: {args.type_regex}')
+            elif len(matching_files) > 1:
+                if are_identical:
+                    ph.print_warning(f'Found {len(matching_files)} files matching "{args.type_regex}" but they are identical. Extracting one of them.')
+                    file = matching_files[0]
+                else:
+                    ph.print_error_and_exit(f'Found {len(matching_files)} files matching "{args.type_regex}" but they have different contents. Not extracting any.')
+            else:
+                file = matching_files[0]
+
+        elif args.directory_index is not None and args.file_index is not None:
+            # Option 2) A single file should be extracted and we get it from (rom_index, directory_index, file_index)
             file = psp.blob.roms[args.rom_index].directories[args.directory_index].files[args.file_index]
 
+        if file:
+            # For Options 1 and 2, do additional extraction magic if requested
             if args.decompress:
                 if not file.compressed:
                     ph.print_error_and_exit(f'File is not compressed {file.get_readable_type()}')
@@ -123,36 +179,17 @@ def main():
             else:
                 output = file.get_bytes()
 
-        else:
-            if args.file_index is None:  # if neither directory_index nor file_index are specified
-                if args.directory_index is not None:
-                    directories = [psp.blob.roms[args.rom_index].directories[args.directory_index]]
-                else:
-                    directories = psp.blob.roms[args.rom_index].directories
-
-                if args.no_duplicates is False:
-                    outdir = args.outfile or f'./{psp.filename}_extracted'
-                    for dir_index, directory in enumerate(directories):
-                        for file_index, file in enumerate(directory.files):
-                            if args.decompress and type(file) is HeaderFile:
-                                out_bytes = file.get_signed_bytes()
-                            elif args.decrypt and type(file) is HeaderFile:
-                                out_bytes = file.get_decrypted()
-                            elif args.pem_key and type(file) is PubkeyFile:
-                                out_bytes = file.get_pem_encoded()
-                            else:
-                                out_bytes = file.get_bytes()
-
-                            outpath = outdir + '/d%.2d_e%.2d_%s' % (dir_index, file_index, file.get_readable_type())
-                            if type(file) is HeaderFile:
-                                outpath += f'_{file.get_readable_version()}'
-
-                            os.makedirs(os.path.dirname(outpath), exist_ok=True)
-                            with open(outpath, 'wb') as f:
-                                f.write(out_bytes)
-                    ph.print_info(f"Extracted all files to {outdir}")
-                else:  # no_duplicates is True
-                    for file in psp.blob.roms[args.rom_index].unique_files:
+        # Option 3) Multiple files should be extracted
+        if args.file_index is None:
+            if args.directory_index is not None: # Option 3a) All files from a given directory_index
+                directories = [psp.blob.roms[args.rom_index].directories[args.directory_index]]
+            else: # Option 3b) All files from all directories from the given ROM (default: 0)
+                directories = psp.blob.roms[args.rom_index].directories
+
+            if args.no_duplicates is False:
+                outdir = args.outfile or f'./{psp.filename}_extracted'
+                for dir_index, directory in enumerate(directories):
+                    for file_index, file in enumerate(directory.files):
                         if args.decompress and type(file) is HeaderFile:
                             out_bytes = file.get_signed_bytes()
                         elif args.decrypt and type(file) is HeaderFile:
@@ -162,17 +199,41 @@ def main():
                         else:
                             out_bytes = file.get_bytes()
 
-                        outdir = args.outfile or f'./{psp.filename}_unique_extracted'
-                        outpath = outdir + '/%s' % (file.get_readable_type())
+                        outpath = outdir + '/d%.2d_e%.2d_%s' % (dir_index, file_index, file.get_readable_type())
 
-                        if issubclass(type(file), HeaderFile):
+                        # We may have same file types but different subprograms, instances
+                        # Account for it in the filenames
+                        if file.entry.subprogram != 0 or file.entry.instance != 0:
+                            outpath += f'_SUB_{hex(file.entry.subprogram)}_INS_{hex(file.entry.instance)}'
+                        if type(file) is HeaderFile:
                             outpath += f'_{file.get_readable_version()}'
 
                         os.makedirs(os.path.dirname(outpath), exist_ok=True)
                         with open(outpath, 'wb') as f:
                             f.write(out_bytes)
-            else:
-                parser.print_help(sys.stderr)
+            else:  # no_duplicates is True
+                for file in psp.blob.unique_files():
+                    if args.decompress and type(file) is HeaderFile:
+                        out_bytes = file.get_signed_bytes()
+                    elif args.decrypt and type(file) is HeaderFile:
+                        out_bytes = file.get_decrypted()
+                    elif args.pem_key and type(file) is PubkeyFile:
+                        out_bytes = file.get_pem_encoded()
+                    else:
+                        out_bytes = file.get_bytes()
+
+                    outdir = args.outfile or f'./{psp.filename}_unique_extracted'
+                    outpath = outdir + '/%s' % (file.get_readable_type())
+
+                    if issubclass(type(file), HeaderFile):
+                        outpath += f'_{file.get_readable_version()}'
+
+                    os.makedirs(os.path.dirname(outpath), exist_ok=True)
+                    with open(outpath, 'wb') as f:
+                        f.write(out_bytes)
+            ph.print_info(f"Extracted all files to {outdir}")
+        else:
+            parser.print_help(sys.stderr)
 
     elif args.replace_file:
         if args.directory_index is not None and args.file_index is not None and args.outfile is not None:

{psptool-3.0 → psptool-3.2}/psptool/blob.py

@@ -67,7 +67,11 @@ class Blob(NestedBuffer):
                     continue
                 try:
                     rom_offset = fet_location - fet_offset  # e.g. 0x20800 - 0x20000 = 0x0800
-                    potential_rom = Rom(self, min(rom_size, self._MAX_PAGE_SIZE), rom_offset, fet_offset, psptool)
+                    # W/A for images with single ROMs that have entries crossing 16MB boundary
+                    if rom_page == 0:
+                        potential_rom = Rom(self, rom_size, rom_offset, fet_offset, psptool)
+                    else:
+                        potential_rom = Rom(self, min(rom_size, self._MAX_PAGE_SIZE), rom_offset, fet_offset, psptool)
                     self.roms.append(potential_rom)
                     fet_parsed = True
                     break  # found correct fet_offset!

{psptool-3.0 → psptool-3.2}/psptool/directory.py

@@ -31,10 +31,6 @@ class Directory(NestedBuffer):
     ENTRY_SIZE = DirectoryEntry.ENTRY_SIZE
     FILE_CLASS = File
 
-    # all directories by offset in rom
-    # todo: what if we have multi-ROM? then two ROMs share this singleton!
-    directories_by_offset = {}
-
     class ParseError(Exception):
         pass
 
@@ -45,14 +41,15 @@ class Directory(NestedBuffer):
     @classmethod
     def create_directories_if_not_exist(cls, offset, fet, zen_generation=None) -> List['Directory']:
         # Recursively return or create and return found directories
-        if offset in cls.directories_by_offset:
-            return [cls.directories_by_offset[offset]]
+
+        if offset in fet.psptool.directories_by_offset:
+            return [fet.psptool.directories_by_offset[offset]]
         else:
             # 1. Create the immediate directory in front of us
             created_directories = []
             try:
                 directory = cls.from_offset(fet, offset, zen_generation)
-                cls.directories_by_offset[offset] = directory
+                fet.psptool.directories_by_offset[offset] = directory
                 created_directories.append(directory)
             except Directory.ParseError as e:
                 # Handle empty entries gracefully (like master branch)
@@ -70,8 +67,8 @@ class Directory(NestedBuffer):
 
             # 3. Recursively add tertiary directories (double references introduced in Zen 4), if applicable
             for tertiary_directory_offset in directory.tertiary_directory_offsets:
-                directory_body = fet.rom.get_bytes(tertiary_directory_offset + 16, 8)
-                actual_tertiary_offset = int.from_bytes(directory_body[:4], 'little')
+                directory_body = fet.rom.get_bytes(tertiary_directory_offset, 32)
+                actual_tertiary_offset = int.from_bytes(directory_body[16:20], 'little')
                 # Resolve one more indirection
                 tertiary_directories = cls.create_directories_if_not_exist(actual_tertiary_offset, fet, zen_generation)
                 created_directories += tertiary_directories
@@ -83,7 +80,7 @@ class Directory(NestedBuffer):
         rom_offset &= fet.rom.addr_mask
         magic = fet.rom.get_bytes(rom_offset, 4)
 
-        if magic == b'\xff\xff\xff\xff':
+        if magic == b'\xff\xff\xff\xff' or magic == b'\x00\x00\x00\x00':
             fet.psptool.ph.print_warning(f"Empty FET entry at ROM address 0x{rom_offset:x}")
             raise Directory.ParseError("Empty entry")
         if magic in cls.DIRECTORY_MAGICS:
@@ -106,7 +103,7 @@ class Directory(NestedBuffer):
         self._count = int.from_bytes(self.rom[self.buffer_offset + 8: self.buffer_offset + 12], 'little')
         self.magic = self.rom.get_bytes(self.buffer_offset, 4)
         assert self.magic in self.DIRECTORY_MAGICS
-        self.reserved = self.rom.get_bytes(self.buffer_offset + 12, 4)
+        self.additional_info = self.rom.get_bytes(self.buffer_offset + 12, 4)
         self.header = NestedBuffer(self, self.HEADER_SIZE)
         self.body = NestedBuffer(self, self.ENTRY_SIZE * self.count, buffer_offset=self.HEADER_SIZE)
         self.buffer_size = len(self.header) + len(self.body)
@@ -157,13 +154,18 @@ class Directory(NestedBuffer):
         self.header[8:12] = struct.pack('<I', self.count)
         self.update_checksum()
 
+    # 00b: x86 Physical address
+    # 01b: Offset from start of the BIOS (flash offset)
+    # 10b: Offset from start of directory header
+    # 11b: Offset from start of partition
     @property
     def address_mode(self):
-        rsvd = struct.unpack('=L', self.reserved)[0]
-        return (rsvd & 0x60000000) >> 29 if rsvd != 0 else None
-    # todo: do we need to still consider the address_mode somewhere?
-    #   at the moment we seem to be running fine by checking entry.rsv0 & (1 << 30) to figure out if we need
-    #   directory-relative or absolute addressing
+        info = struct.unpack('<L', self.additional_info)[0]
+        version = (info >> 31) & 1
+        if version == 1:
+            return (info >> 24) & 3
+        else:
+            return (info >> 29) & 3
 
     def verify_checksum(self):
         data = self[0x8:]

psptool-3.2/psptool/entry.py

@@ -0,0 +1,180 @@
+# PSPTool - Display, extract and manipulate PSP firmware inside UEFI images
+# Copyright (C) 2021 Christian Werling, Robert Buhren, Hans Niklas Jacob
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+import struct
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from directory import Directory
+
+from .utils import NestedBuffer
+
+
+class DirectoryEntry(NestedBuffer):
+    ENTRY_SIZE = 4 * 4
+
+    def __init__(self, parent_directory: 'Directory', entry_offset):
+        super().__init__(parent_directory.body, self.ENTRY_SIZE, entry_offset)
+        self.parent_directory = parent_directory
+        self.entry_offset = entry_offset
+
+    def __repr__(self):
+        return f'{self.__class__.__name__}({self.type=:#x}, {self.flags=:#x}, {self.size=:#x}, ' \
+               f'{self.offset=:#x}, {self.entry_offset=:#x}, {self.rsv0=:#x})'
+
+    def file_offset(self):
+        # Special case soft fuse chain, no offset or size
+        if self.type == 0xb:
+            dir_start = self.parent_directory.buffer_offset + self.parent_directory.HEADER_SIZE
+            return dir_start + self.entry_offset
+
+        addr_mode = self.parent_directory.address_mode
+        # If directory address mode is 2 or 3 (relative to dir or slot), the
+        # entry address mode must be taken into account, otherwise ignored.
+        if addr_mode == 2 or addr_mode == 3:
+            addr_mode = self.address_mode
+
+        if addr_mode == 0:
+            # x86 physical address, should be in range 0xff000000 - 0xffffffff
+            # But some images use flash offset in x86 physical address mode.
+            # If ROM is bigger than 16MB and the entry address is in the
+            # 0xff000000 - 0xffffffff range, we have to override the mask for
+            # physical address.
+            rom_size = self.parent_directory.rom.addr_mask + 1
+            if self.offset > 0xFF000000 and rom_size > 16 * 1024 * 1024:
+                return self.offset & 0x00FFFFFF
+            else:
+                return self.offset & self.parent_directory.rom.addr_mask
+        elif addr_mode == 1:
+            # Flash offset from start of BIOS, most common on modern systems
+            return self.offset
+        elif addr_mode == 2:
+            # Flash offset from start of directory header
+            return self.parent_directory.buffer_offset + self.offset
+        elif addr_mode == 3:
+            # Flash offset from start of the slot
+            # TODO: How to calculate the offset from slot? Is this correct?
+            return self.parent_directory.buffer_offset + self.offset
+
+    @property
+    def type(self):
+        return struct.unpack('<B', self[0:1])[0]
+
+    @type.setter
+    def type(self, value):
+        self.set_bytes(0, 1, struct.pack('<B', value))
+
+    @property
+    def subprogram(self):
+        return struct.unpack('<B', self[1:2])[0]
+
+    @subprogram.setter
+    def subprogram(self, value):
+        self.set_bytes(1, 1, struct.pack('<B', value))
+
+    @property
+    def flags(self):
+        return struct.unpack('<H', self[2:4])[0]
+
+    @flags.setter
+    def flags(self, value):
+        self.set_bytes(2, 2, struct.pack('<H', value))
+
+    @property
+    def instance(self):
+        return (self.flags >> 3) & 0xF
+
+    @instance.setter
+    def instance(self, value):
+       self.flags = self.flags | ((value & 0xF) << 3)
+
+    @property
+    def size(self):
+        return struct.unpack('<I', self[4:8])[0]
+
+    @size.setter
+    def size(self, value):
+        self.set_bytes(4, 4, struct.pack('<I', value))
+
+    @property
+    def offset(self):
+        return struct.unpack('<I', self[8:12])[0]
+
+    @offset.setter
+    def offset(self, value):
+        self.set_bytes(8, 4, struct.pack('<I', value))
+
+    @property
+    def rsv0(self):
+        return struct.unpack('<I', self[12:16])[0]
+
+    @rsv0.setter
+    def rsv0(self, value):
+        self.set_bytes(12, 4, struct.pack('<I', value))
+
+    # 00b: x86 Physical address
+    # 01b: Offset from start of the BIOS (flash offset)
+    # 10b: Offset from start of directory header
+    # 11b: Offset from start of partition
+    @property
+    def address_mode(self):
+        return (self.rsv0 >> 30) & 3
+
+class BiosDirectoryEntry(DirectoryEntry):
+    ENTRY_SIZE = 4 * 6
+
+    def __repr__(self):
+        return super().__repr__()[:-1] + f', {self.destination=:#x})'
+
+    @property
+    def destination(self):
+        return struct.unpack('<Q', self[16:24])[0]
+
+    @destination.setter
+    def destination(self, value):
+        self.set_bytes(16, 8, struct.pack('<Q', value))
+
+    @property
+    def region_type(self):
+        return struct.unpack('<B', self[1:2])[0]
+
+    @region_type.setter
+    def region_type(self, value):
+        self.set_bytes(1, 1, struct.pack('<B', value))
+
+    @property
+    def flags(self):
+        return struct.unpack('<H', self[2:4])[0]
+
+    @flags.setter
+    def flags(self, value):
+        self.set_bytes(2, 2, struct.pack('<H', value))
+
+    @property
+    def subprogram(self):
+        return (self.flags >> 8) & 0x7
+
+    @subprogram.setter
+    def subprogram(self, value):
+       self.flags = self.flags | ((value & 0x7) << 8)
+
+    @property
+    def instance(self):
+        return (self.flags >> 4) & 0xF
+
+    @instance.setter
+    def instance(self, value):
+       self.flags = self.flags | ((value & 0xF) << 4)

{psptool-3.0 → psptool-3.2}/psptool/fet.py

@@ -69,10 +69,16 @@ class Fet(NestedBuffer):
             # TODO: Why is 0xFFFFFFFe a possible value here?
             if rom_addr in [0x0, 0xFFFFFFFF, 0xFFFFFFFe]:
                 continue
-            rom_addr &= self.rom.addr_mask
+            # if ROM is bigger than 16MB, we have to override the mask for
+            # physical address
+            if rom_addr > 0xFF000000 and self.rom.addr_mask + 1 > 16 * 1024 * 1024:
+                rom_addr &= 0x00FFFFFF
+            else:
+                rom_addr &= self.rom.addr_mask
+
             try:
                 dir_magic = self.rom[rom_addr:rom_addr + 4]
-            except:
+            except AssertionError as e:
                 self.psptool.ph.print_warning(f"FET entry 0x{rom_addr:x} not found or invalid, skipping ...")
                 continue
             if dir_magic == b'2PSP' or dir_magic == b'2BHD':
@@ -105,7 +111,14 @@ class Fet(NestedBuffer):
             entry_addr = int.from_bytes(entry, 'little')
             if entry_addr in [0, 0xFFFFFFFF]:
                 continue
-            entry_addr &= self.rom.addr_mask
+            # if ROM is bigger than 16MB, we have to override the mask for
+            # physical address
+            rom_size = self.rom.addr_mask + 1
+            if entry_addr > 0xFF000000 and rom_size > 16 * 1024 * 1024:
+                entry_addr &= 0x00FFFFFF
+            else:
+                entry_addr &= self.rom.addr_mask
+
             # entry_addr += self.blob_offset
             zen_generation_id = combo_dir[i*16+5:i*16+8]
             zen_generation = 'unknown'