psptool 3.1__tar.gz → 3.2.dev0__tar.gz

psptool-3.2.dev0/.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.dev0/.github/workflows/publish.yml

@@ -0,0 +1,74 @@
+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
+
+  publish-to-testpypi:
+    name: >-
+      Publish Python distribution to TestPyPI
+    needs:
+    - build
+    runs-on: ubuntu-latest
+    environment:
+      name: testpypi
+      url: https://test.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 TestPyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        repository-url: https://test.pypi.org/legacy/
+        verbose: true

{psptool-3.1 → psptool-3.2.dev0}/PKG-INFO

@@ -1,18 +1,13 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: psptool
-Version: 3.1
+Version: 3.2.dev0
 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
+Author-email: Christian Werling <cwerling@posteo.de>
+License-File: LICENSE
 Requires-Python: >=3.8
+Requires-Dist: cryptography>=38.0.0
+Requires-Dist: prettytable
 Description-Content-Type: text/markdown
-License-File: LICENSE
 
 # PSPTool
 
@@ -874,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.1 → psptool-3.2.dev0}/psptool/__main__.py

@@ -200,6 +200,11 @@ def main():
                             out_bytes = file.get_bytes()
 
                         outpath = outdir + '/d%.2d_e%.2d_%s' % (dir_index, file_index, file.get_readable_type())
+
+                        # 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()}'
 

{psptool-3.1 → psptool-3.2.dev0}/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.1 → psptool-3.2.dev0}/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.dev0/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.1 → psptool-3.2.dev0}/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'