psptool 2.8__tar.gz → 3.0__tar.gz

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: psptool
-Version: 2.8
+Version: 3.0
 Summary: PSPTool is a tool for dealing with AMD binary blobs
 Home-page: https://github.com/PSPReverse/PSPTool
 Author: Christian Werling
@@ -16,6 +16,9 @@ License-File: LICENSE
 Requires-Dist: setuptools
 Requires-Dist: cryptography>=38.0.0
 Requires-Dist: prettytable
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
 
 # PSPTool
 
@@ -798,40 +801,41 @@ usage: psptool [-V | -E | -X | -R] [file]
 Display, extract, and manipulate AMD PSP firmware inside BIOS ROMs.
 
 positional arguments:
-  file                 Binary file to be parsed for PSP firmware
+  file                Binary file to be parsed for PSP firmware
 
 optional arguments:
   -V, --version
-  -E, --entries        Default: Parse and display PSP firmware entries.
-                       [-n] [-j] [-t]
-                       
-                       -n:      list unique entries only ordered by their offset
-                       -j:      output in JSON format instead of tables
-                       -t:      print tree of all signed entities and their certifying keys
-                       
-  -X, --extract-entry  Extract one or more PSP firmware entries.
-                       [[-r idx] -d idx [-e idx]] [-n] [-u] [-c] [-k] [-o outfile]
-                       
-                       -r idx:  specifies rom_index (default: 0)
-                       -d idx:  specifies directory_index (default: all directories)
-                       -e idx:  specifies entry_index (default: all entries)
-                       -n:      skip duplicate entries and extract unique entries only
-                       -u:      uncompress compressed entries
-                       -c:      try to decrypt entries
-                       -k:      convert pubkeys into PEM format
-                       -o file: specifies outfile/outdir (default: stdout/{file}_extracted)
-                       
-  -R, --replace-entry  Copy a new entry (including header and signature) into the
-                       ROM file and update metadata accordingly.
-                       [-r idx] -d idx -e idx -s subfile -o outfile [-p file-stub] [-a pass]
-                       
-                       -r idx:  specifies rom_index (default: 0)
-                       -d idx:  specifies directory_index
-                       -e idx:  specifies entry_index
-                       -s file: specifies subfile (i.e. the new entry contents)
-                       -o file: specifies outfile
-                       -p file: specifies file-stub (e.g. 'keys/id') for the re-signing keys
-                       -a pass: specifies password for the re-signing keys
+  -E, --entries       Default: Parse and display PSP firmware entries.
+                      [-n] [-j] [-t]
+
+                      -n:      list unique entries only ordered by their offset
+                      -j:      output in JSON format instead of tables
+                      -t:      print tree of all signed entities and their certifying keys
+                      -m:      print parsing metrics for testing
+
+  -X, --extract-file  Extract one or more PSP firmware files.
+                      [-d idx [-e idx]] [-n] [-u] [-c] [-k] [-o outfile]
+
+                      -r idx:  specifies rom_index (default: 0)
+                      -d idx:  specifies directory_index (default: all directories)
+                      -e idx:  specifies file_index (default: all files)
+                      -n:      skip duplicate files and extract unique files only
+                      -u:      uncompress compressed files
+                      -c:      try to decrypt files
+                      -k:      convert pubkeys into PEM format
+                      -o file: specifies outfile/outdir (default: stdout/{file}_extracted)
+
+  -R, --replace-file  Copy a new file (including header and signature) into the
+                      ROM file and update file and other metadata accordingly.
+                      -d idx -e idx -s subfile -o outfile [-p file-stub] [-a pass]
+
+                      -r idx:  specifies rom_index (default: 0)
+                      -d idx:  specifies directory_index
+                      -e idx:  specifies file_index
+                      -s file: specifies subfile (i.e. the new file contents)
+                      -o file: specifies outfile
+                      -p file: specifies file-stub (e.g. 'keys/id') for the re-signing keys
+                      -a pass: specifies password for the re-signing keys
 ```
 
 ## Python Usage
@@ -867,13 +871,13 @@ PSPTool can be **used as a Python module**, e.g. in an interactive IPython sessi
 |   |    14 |  0xeba00 |  0xbd60 | 0x36 |                             |  AR6B | 17.9.18.12 | OEM_PSP_FW_PUBLIC_KEY |
 |   |    15 | 0x149000 |   0x400 | 0x40 |    !PL2_SECONDARY_DIRECTORY |       |            |                       |
 +---+-------+----------+---------+------+-----------------------------+-------+------------+-----------------------+
-> psp.blob.roms[0].directories[0].entries[0]
-PubkeyEntry(type=0x0, address=0x77400, size=0x240, len(references)=1)
-> psp.blob.directories[0].entries[0].get_bytes()
+> psp.blob.roms[0].directories[0].files[0]
+PubkeyFile(type=0x0, address=0x77400, size=0x240, len(references)=1)
+> psp.blob.directories[0].files[0].get_bytes()
 b'\x01\x00\x00\x00\x1b\xb9\x87\xc3YIF\x06\xb1t\x94V\x01\xc9\xea[\x1b\xb9\x87\xc3YIF\x06\xb1t\x94V\x01\xc9\xea[\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x08\x00\x00\x01\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
 [...]
 > my_stuff = [...]
-> psp.blob.roms[0].directories[0].entries[1].move_buffer(0x60000, 0x1000)
+> 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-2.8 → psptool-3.0}/README.md

@@ -779,40 +779,41 @@ usage: psptool [-V | -E | -X | -R] [file]
 Display, extract, and manipulate AMD PSP firmware inside BIOS ROMs.
 
 positional arguments:
-  file                 Binary file to be parsed for PSP firmware
+  file                Binary file to be parsed for PSP firmware
 
 optional arguments:
   -V, --version
-  -E, --entries        Default: Parse and display PSP firmware entries.
-                       [-n] [-j] [-t]
-                       
-                       -n:      list unique entries only ordered by their offset
-                       -j:      output in JSON format instead of tables
-                       -t:      print tree of all signed entities and their certifying keys
-                       
-  -X, --extract-entry  Extract one or more PSP firmware entries.
-                       [[-r idx] -d idx [-e idx]] [-n] [-u] [-c] [-k] [-o outfile]
-                       
-                       -r idx:  specifies rom_index (default: 0)
-                       -d idx:  specifies directory_index (default: all directories)
-                       -e idx:  specifies entry_index (default: all entries)
-                       -n:      skip duplicate entries and extract unique entries only
-                       -u:      uncompress compressed entries
-                       -c:      try to decrypt entries
-                       -k:      convert pubkeys into PEM format
-                       -o file: specifies outfile/outdir (default: stdout/{file}_extracted)
-                       
-  -R, --replace-entry  Copy a new entry (including header and signature) into the
-                       ROM file and update metadata accordingly.
-                       [-r idx] -d idx -e idx -s subfile -o outfile [-p file-stub] [-a pass]
-                       
-                       -r idx:  specifies rom_index (default: 0)
-                       -d idx:  specifies directory_index
-                       -e idx:  specifies entry_index
-                       -s file: specifies subfile (i.e. the new entry contents)
-                       -o file: specifies outfile
-                       -p file: specifies file-stub (e.g. 'keys/id') for the re-signing keys
-                       -a pass: specifies password for the re-signing keys
+  -E, --entries       Default: Parse and display PSP firmware entries.
+                      [-n] [-j] [-t]
+
+                      -n:      list unique entries only ordered by their offset
+                      -j:      output in JSON format instead of tables
+                      -t:      print tree of all signed entities and their certifying keys
+                      -m:      print parsing metrics for testing
+
+  -X, --extract-file  Extract one or more PSP firmware files.
+                      [-d idx [-e idx]] [-n] [-u] [-c] [-k] [-o outfile]
+
+                      -r idx:  specifies rom_index (default: 0)
+                      -d idx:  specifies directory_index (default: all directories)
+                      -e idx:  specifies file_index (default: all files)
+                      -n:      skip duplicate files and extract unique files only
+                      -u:      uncompress compressed files
+                      -c:      try to decrypt files
+                      -k:      convert pubkeys into PEM format
+                      -o file: specifies outfile/outdir (default: stdout/{file}_extracted)
+
+  -R, --replace-file  Copy a new file (including header and signature) into the
+                      ROM file and update file and other metadata accordingly.
+                      -d idx -e idx -s subfile -o outfile [-p file-stub] [-a pass]
+
+                      -r idx:  specifies rom_index (default: 0)
+                      -d idx:  specifies directory_index
+                      -e idx:  specifies file_index
+                      -s file: specifies subfile (i.e. the new file contents)
+                      -o file: specifies outfile
+                      -p file: specifies file-stub (e.g. 'keys/id') for the re-signing keys
+                      -a pass: specifies password for the re-signing keys
 ```
 
 ## Python Usage
@@ -848,13 +849,13 @@ PSPTool can be **used as a Python module**, e.g. in an interactive IPython sessi
 |   |    14 |  0xeba00 |  0xbd60 | 0x36 |                             |  AR6B | 17.9.18.12 | OEM_PSP_FW_PUBLIC_KEY |
 |   |    15 | 0x149000 |   0x400 | 0x40 |    !PL2_SECONDARY_DIRECTORY |       |            |                       |
 +---+-------+----------+---------+------+-----------------------------+-------+------------+-----------------------+
-> psp.blob.roms[0].directories[0].entries[0]
-PubkeyEntry(type=0x0, address=0x77400, size=0x240, len(references)=1)
-> psp.blob.directories[0].entries[0].get_bytes()
+> psp.blob.roms[0].directories[0].files[0]
+PubkeyFile(type=0x0, address=0x77400, size=0x240, len(references)=1)
+> psp.blob.directories[0].files[0].get_bytes()
 b'\x01\x00\x00\x00\x1b\xb9\x87\xc3YIF\x06\xb1t\x94V\x01\xc9\xea[\x1b\xb9\x87\xc3YIF\x06\xb1t\x94V\x01\xc9\xea[\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x08\x00\x00\x01\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
 [...]
 > my_stuff = [...]
-> psp.blob.roms[0].directories[0].entries[1].move_buffer(0x60000, 0x1000)
+> 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-2.8 → psptool-3.0}/psptool/__main__.py

@@ -20,7 +20,8 @@ import pkg_resources
 
 from .psptool import PSPTool
 from .utils import ObligingArgumentParser, PrintHelper
-from .entry import PubkeyEntry, HeaderEntry
+from .header_file import HeaderFile
+from .pubkey_file import PubkeyFile
 from .crypto import PrivateKeyDict
 
 from argparse import RawTextHelpFormatter, SUPPRESS
@@ -37,7 +38,7 @@ def main():
 
     parser.add_argument('-r', '--rom-index', help=SUPPRESS, type=int, default=0)
     parser.add_argument('-d', '--directory-index', help=SUPPRESS, type=int)
-    parser.add_argument('-e', '--entry-index', help=SUPPRESS, type=int)
+    parser.add_argument('-e', '--file-index', help=SUPPRESS, type=int)
     parser.add_argument('-s', '--subfile', help=SUPPRESS)
     parser.add_argument('-o', '--outfile', help=SUPPRESS)
     parser.add_argument('-u', '--decompress', help=SUPPRESS, action='store_true')
@@ -61,32 +62,32 @@ def main():
         '-n:      list unique entries only ordered by their offset',
         '-j:      output in JSON format instead of tables',
         '-t:      print tree of all signed entities and their certifying keys',
-        '-m:      print entry parsing metrics for testing',
+        '-m:      print parsing metrics for testing',
         '', '']), action='store_true')
 
-    action.add_argument('-X', '--extract-entry', help='\n'.join([
-        'Extract one or more PSP firmware entries.',
+    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]',
         '',
         '-r idx:  specifies rom_index (default: 0)',
         '-d idx:  specifies directory_index (default: all directories)',
-        '-e idx:  specifies entry_index (default: all entries)',
-        '-n:      skip duplicate entries and extract unique entries only',
-        '-u:      uncompress compressed entries',
-        '-c:      try to decrypt entries',
+        '-e idx:  specifies file_index (default: all files)',
+        '-n:      skip duplicate files and extract unique files only',
+        '-u:      uncompress compressed files',
+        '-c:      try to decrypt files',
         '-k:      convert pubkeys into PEM format',
         '-o file: specifies outfile/outdir (default: stdout/{file}_extracted)',
         '', '']), action='store_true')
 
-    action.add_argument('-R', '--replace-entry', help='\n'.join([
-        'Copy a new entry (including header and signature) into the',
-        'ROM file and update metadata accordingly.',
+    action.add_argument('-R', '--replace-file', help='\n'.join([
+        'Copy a new file (including header and signature) into the',
+        'ROM file and update file and other metadata accordingly.',
         '-d idx -e idx -s subfile -o outfile [-p file-stub] [-a pass]',
         '',
         '-r idx:  specifies rom_index (default: 0)',
         '-d idx:  specifies directory_index',
-        '-e idx:  specifies entry_index',
-        '-s file: specifies subfile (i.e. the new entry contents)',
+        '-e idx:  specifies file_index',
+        '-s file: specifies subfile (i.e. the new file contents)',
         '-o file: specifies outfile',
         '-p file: specifies file-stub (e.g. \'keys/id\') for the re-signing keys',
         '-a pass: specifies password for the re-signing keys'
@@ -105,25 +106,25 @@ def main():
     psp = PSPTool.from_file(args.file, verbose=args.verbose)
     output = None
 
-    if args.extract_entry:
-        if args.directory_index is not None and args.entry_index is not None:
-            entry = psp.blob.roms[args.rom_index].directories[args.directory_index].entries[args.entry_index]
+    if args.extract_file:
+        if args.directory_index is not None and args.file_index is not None:
+            file = psp.blob.roms[args.rom_index].directories[args.directory_index].files[args.file_index]
 
             if args.decompress:
-                if not entry.compressed:
-                    ph.print_error_and_exit(f'Entry is not compressed {entry.get_readable_type()}')
-                output = entry.get_signed_bytes()
+                if not file.compressed:
+                    ph.print_error_and_exit(f'File is not compressed {file.get_readable_type()}')
+                output = file.get_signed_bytes()
             elif args.decrypt:
-                if not entry.encrypted:
-                    ph.print_error_and_exit(f'Entry is not encrypted {entry.get_readable_type()}')
-                output = entry.to_decrypted_entry_bytes()
+                if not file.encrypted:
+                    ph.print_error_and_exit(f'File is not encrypted {file.get_readable_type()}')
+                output = file.to_decrypted_file_bytes()
             elif args.pem_key:
-                output = entry.get_pem_encoded()
+                output = file.get_pem_encoded()
             else:
-                output = entry.get_bytes()
+                output = file.get_bytes()
 
         else:
-            if args.entry_index is None:  # if neither directory_index nor entry_index are specified
+            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:
@@ -132,40 +133,40 @@ def main():
                 if args.no_duplicates is False:
                     outdir = args.outfile or f'./{psp.filename}_extracted'
                     for dir_index, directory in enumerate(directories):
-                        for entry_index, entry in enumerate(directory.entries):
-                            if args.decompress and type(entry) is HeaderEntry:
-                                out_bytes = entry.get_signed_bytes()
-                            elif args.decrypt and type(entry) is HeaderEntry:
-                                out_bytes = entry.get_decrypted()
-                            elif args.pem_key and type(entry) is PubkeyEntry:
-                                out_bytes = entry.get_pem_encoded()
+                        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 = entry.get_bytes()
+                                out_bytes = file.get_bytes()
 
-                            outpath = outdir + '/d%.2d_e%.2d_%s' % (dir_index, entry_index, entry.get_readable_type())
-                            if type(entry) is HeaderEntry:
-                                outpath += f'_{entry.get_readable_version()}'
+                            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 entries to {outdir}")
+                    ph.print_info(f"Extracted all files to {outdir}")
                 else:  # no_duplicates is True
-                    for entry in psp.blob.roms[args.rom_index].unique_entries:
-                        if args.decompress and type(entry) is HeaderEntry:
-                            out_bytes = entry.get_signed_bytes()
-                        elif args.decrypt and type(entry) is HeaderEntry:
-                            out_bytes = entry.get_decrypted()
-                        elif args.pem_key and type(entry) is PubkeyEntry:
-                            out_bytes = entry.get_pem_encoded()
+                    for file in psp.blob.roms[args.rom_index].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 = entry.get_bytes()
+                            out_bytes = file.get_bytes()
 
                         outdir = args.outfile or f'./{psp.filename}_unique_extracted'
-                        outpath = outdir + '/%s' % (entry.get_readable_type())
+                        outpath = outdir + '/%s' % (file.get_readable_type())
 
-                        if type(entry) is HeaderEntry:
-                            outpath += f'_{entry.get_readable_version()}'
+                        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:
@@ -173,26 +174,26 @@ def main():
             else:
                 parser.print_help(sys.stderr)
 
-    elif args.replace_entry:
-        if args.directory_index is not None and args.entry_index is not None and args.outfile is not None:
-            entry = psp.blob.roms[args.rom_index].directories[args.directory_index].entries[args.entry_index]
+    elif args.replace_file:
+        if args.directory_index is not None and args.file_index is not None and args.outfile is not None:
+            file = psp.blob.roms[args.rom_index].directories[args.directory_index].files[args.file_index]
 
-            # Substituting an entry is actually optional to allow plain re-signs
+            # Substituting an file is actually optional to allow plain re-signs
             if args.subfile is not None:
                 with open(args.subfile, 'rb') as f:
                     sub_binary = f.read()
-                # Keep the existing entry's address, but adapt its size
-                entry.move_buffer(entry.get_address(), len(sub_binary))
-                entry.set_bytes(0, len(sub_binary), sub_binary)
+                # Keep the existing file's address, but adapt its size
+                file.move_buffer(file.get_address(), len(sub_binary))
+                file.set_bytes(0, len(sub_binary), sub_binary)
 
             privkeys = None
             if args.privkeystub:
                 privkeys = PrivateKeyDict.read_from_files(args.privkeystub, args.privkeypass)
 
-            if hasattr(entry, 'signed_entity') and entry.signed_entity:
-                entry.signed_entity.resign_and_replace(privkeys=privkeys, recursive=True)
+            if hasattr(file, 'signed_entity') and file.signed_entity:
+                file.signed_entity.resign_and_replace(privkeys=privkeys, recursive=True)
             else:
-                ph.print_warning("Did not resign anything since target entry is not signed")
+                ph.print_warning("Did not resign anything since target file is not signed")
 
             psp.to_file(args.outfile)
 
@@ -208,7 +209,7 @@ def main():
         elif args.metrics:
             psp.print_metrics()
         elif args.no_duplicates:
-            psp.ls_entries(verbose=args.verbose)
+            psp.ls_files(verbose=args.verbose)
         else:
             psp.ls(verbose=args.verbose)
 

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

@@ -22,13 +22,14 @@ from typing import List
 from .fet import EmptyFet
 from .rom import Rom
 from .utils import NestedBuffer, RangeDict
-from .entry import Entry, PubkeyEntry
+from .file import File
+from .pubkey_file import PubkeyFile, InlinePubkeyFile
 
 
 class Blob(NestedBuffer):
     _FIRMWARE_ENTRY_MAGIC = b'\xAA\x55\xAA\x55'
-    _FIRMWARE_ENTRY_TABLE_BASE_ADDRESS = 0x20000
-
+    # All structures per Rom must be in 16MB windows
+    _MAX_PAGE_SIZE = 16 * 1024 * 1024
     class NoFirmwareEntryTableError(Exception):
         pass
 
@@ -38,7 +39,7 @@ class Blob(NestedBuffer):
         self.psptool = psptool
         self.roms: List[Rom] = []
 
-        potential_fet_offsets = [
+        possible_fet_offsets = [
             # as seen by a PSPTrace Zen 1 boot
             0x020000,
             0xfa0000,
@@ -48,24 +49,25 @@ class Blob(NestedBuffer):
             0x820000,
         ]
 
-        rom_size = 0x1000000
-        if self.buffer_size < rom_size:
-            self.psptool.ph.print_warning("Input  file < 16M, will assume 8M ROM ...")
-            rom_size = 0x800000
+        possible_rom_sizes = [32, 16, 8]
+        _rom_size = max(value for value in possible_rom_sizes if value * 1024 * 1024 <= self.buffer_size)
+        rom_size = _rom_size * 1024 * 1024
+        self.psptool.ph.print_warning(f"Input  file is {self.buffer_size:#x}, will assume ROM size of {_rom_size}M")
 
         # For each FET, we try to create a 16MB ROM starting at `FET - offset`
         for fet_location in self._find_fets():
             fet_parsed = False
-            for fet_offset in potential_fet_offsets:
+            for fet_offset in possible_fet_offsets:
                 if fet_location < fet_offset:
                     # would lead to Blob underflow
                     continue
-                if fet_location - fet_offset + rom_size > self.buffer_size:
+                rom_page = int(fet_location / self._MAX_PAGE_SIZE)
+                if fet_location - fet_offset + rom_size - rom_page * self._MAX_PAGE_SIZE > self.buffer_size:
                     # would lead to Blob overflow
                     continue
                 try:
                     rom_offset = fet_location - fet_offset  # e.g. 0x20800 - 0x20000 = 0x0800
-                    potential_rom = Rom(self, rom_size, rom_offset, fet_offset, psptool)
+                    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!
@@ -84,16 +86,16 @@ class Blob(NestedBuffer):
         return f'Blob({self.roms=})'
 
     def _construct_range_dict(self):
-        all_entries = self.unique_entries()
+        all_files = self.unique_files()
 
         # create RangeDict in order to find entries, directories and fets for a given address
         directories = [directory for rom in self.roms for directory in rom.directories]
         self.range_dict = RangeDict({
             **{
-                range(entry.get_address(),
-                      entry.get_address() + entry.buffer_size):  # key is start and end address of the entry
-                entry
-                for entry in all_entries if entry.buffer_size != 0xffffffff  # value is its type
+                range(file.get_address(),
+                      file.get_address() + file.buffer_size):  # key is start and end address of the file
+                file
+                for file in all_files if file.buffer_size != 0xffffffff  # value is its type
             }, **{
                 range(directory.get_address(), directory.get_address() + len(directory)):
                     directory
@@ -105,73 +107,65 @@ class Blob(NestedBuffer):
             }
         })
 
-    def unique_entries(self) -> set:
+    def unique_files(self) -> set:
         directories = [directory for rom in self.roms for directory in rom.directories]
-        directory_entries = [directory.entries for directory in directories]
+        directory_files = [directory.files for directory in directories]
         # flatten list of lists
-        all_entries = [entry for sublist in directory_entries for entry in sublist]
+        all_files = [file for sublist in directory_files for file in sublist]
         # filter duplicates through set
-        unique_entries = set(all_entries)
-        return unique_entries
+        unique_files = set(all_files)
+        return unique_files
 
     def _find_fets(self):
         # AA55AA55 is to unspecific, so we require a word of padding before (to be tested)
         for m in re.finditer(b'\xff\xff\xff\xff' + self._FIRMWARE_ENTRY_MAGIC, self.get_buffer()):
             fet_offset = m.start() + 4
             yield fet_offset
+        for m in re.finditer(b'\x00\x00\x00\x00' + self._FIRMWARE_ENTRY_MAGIC, self.get_buffer()):
+            fet_offset = m.start() + 4
+            yield fet_offset
 
     def _find_inline_pubkeys(self, fp):
 
-        """ Try to find a pubkey anywhere in the blob.
+        """ Try to find a pubkey in any of the found files.
         The pubkey is identified by its fingerprint. If found, the pubkey is
         added to the list of pubkeys of the blob """
         found_pubkeys = []
 
-        m = re.finditer(re.escape(binascii.a2b_hex(fp)), self.get_bytes())
-        for index in m:
-            start = index.start() - 4
-            if int.from_bytes(self[start:start + 4], 'little') == 1:
-                # Maybe a pubkey. Determine its size:
-                pub_exp_size = int.from_bytes(self[start + 0x38: start + 0x3c],
-                                              'little')
-                if pub_exp_size == 2048:
-                    size = 0x240
-                elif pub_exp_size == 4096:
-                    size = 0x440
-                else:
-                    continue
-
-                key_id = self[start + 0x04: start + 0x14]
-                cert_id = self[start + 0x14: start + 0x24]
-
-                if key_id != cert_id and cert_id != b'\0' * 0x10:
+        for file in self.unique_files():
+            if type(file) == PubkeyFile:
+                continue  # Pubkeys don't have inline keys but will only produce false positives
+            m = re.finditer(re.escape(binascii.a2b_hex(fp)), file.get_bytes())
+            for index in m:
+                start_offset = index.start() - 4
+                if int.from_bytes(self[start_offset:start_offset + 4], 'little') in PubkeyFile.KNOWN_VERSIONS:
+                    # Maybe a pubkey. Determine its size:
+                    pub_exp_size = int.from_bytes(self[start_offset + 0x38: start_offset + 0x3c],
+                                                  'little')
                     if pub_exp_size == 2048:
-                        size += 0x100
+                        size = 0x240
+                    elif pub_exp_size == 4096:
+                        size = 0x440
                     else:
-                        size += 0x200
-
-                try:
-                    entry = PubkeyEntry(self, self, 0xdead, 0, size, start, self, self.psptool)
-                    # todo: use from_fields factory instead of PubkeyEntry init
-                    # entry = Entry.from_fields(self, self.parent_buffer,
-                    #                           0xdead,
-                    #                           size,
-                    #                           start,
-                    #                           self,
-                    #                           self.psptool)
-                    assert isinstance(entry, PubkeyEntry)
-                    entry.is_inline = True
-                    entry.parent_entry = self.range_dict[entry.get_address()]
-                    if type(entry.parent_entry) == PubkeyEntry:
-                        break
-                    entry.parent_entry.inline_keys.add(entry)
-                    found_pubkeys.append(entry)
-                except Entry.ParseError as e:
-                    self.psptool.ph.print_warning(f"_find_pubkey: Entry parse error at 0x{start:x}")
-                    self.psptool.ph.print_warning(f'{e}')
-                except Exception as e:
-                    self.psptool.ph.print_warning(f"_find_pubkey: Error couldn't convert key at: 0x{start:x}")
-                    self.psptool.ph.print_warning(f'{e}')
+                        continue
+
+                    key_id = self[start_offset + 0x04: start_offset + 0x14]
+                    cert_id = self[start_offset + 0x14: start_offset + 0x24]
+
+                    if key_id != cert_id and cert_id != b'\0' * 0x10:
+                        if pub_exp_size == 2048:
+                            size += 0x100
+                        else:
+                            size += 0x200
+
+                    try:
+                        file = InlinePubkeyFile(file, start_offset, size, self, self.psptool)
+                        assert isinstance(file, PubkeyFile)
+                        file.inline_keys.add(file)
+                        found_pubkeys.append(file)
+                    except File.ParseError as e:
+                        self.psptool.ph.print_warning(f"_find_pubkey: File parse error at 0x{start_offset:x}")
+                        self.psptool.ph.print_warning(f'{e}')
 
         return found_pubkeys
 
@@ -181,7 +175,7 @@ class Blob(NestedBuffer):
             found_pkes += self._find_inline_pubkeys(key_id)
         return found_pkes
 
-    def get_entries_by_type(self, type_) -> List[Entry]:
+    def get_entries_by_type(self, type_) -> List[File]:
         entries = []
 
         for rom in self.roms: