PUP File Documentation

Summary

A PlayStation Update Package is Sony’s signed, encrypted container for console system-software (firmware) updates, saved as PS3UPDAT.PUP, PS4UPDATE.PUP or PS5UPDATE.PUP. Its MIME type is application/octet-stream. You do not open a .pup on a PC: copy it to a FAT32 USB stick in the exact folder Sony specifies, then install it from the console’s System Update menu. The file is signed, so only the matching console will accept it.

Technical details

Feature	Value
Full name	PlayStation Update Package
File extension	`.pup`
MIME type	`application/octet-stream`
Format type	Signed, encrypted firmware-update container
Developer	Sony Interactive Entertainment
Introduced	PSP / PS3 era (PS3 launched 2006); used through PS4, PS5 and PS Vita
Standard filenames	`PS3UPDAT.PUP`, `PS4UPDATE.PUP`, `PS5UPDATE.PUP`
Open standard	No — proprietary, signed and encrypted
Byte order (PS3)	Big-endian
PS3 header size	0x30 bytes (magic, format flag, package/image version, segment count, table offsets)
Magic number (PS3)	`53 43 45 55 46` (“SCEUF”) at offset 0
Integrity (PS3)	Per-segment HMAC-SHA1 digest table (0x20-byte entries, 0x14-byte digest)
Signature	Sony digital signature verified by the console before install
Cross-generation	No single shared signature; PS4/PS5/Vita use different internal layouts and stronger encryption
USB install path (PS4)	`/PS4/UPDATE/PS4UPDATE.PUP` on a FAT32/exFAT drive
Editable	No — signed and encrypted; cannot be modified or repacked
Related extensions	`.pkg`, `.bin`, `.iso`
Reference	`psdevwiki.com/ps3/Playstation_Update_Package_(PUP)`

File signature (magic bytes)

53 43 45 55 46

Offset 0, 5 bytes, ASCII SCEUF (“SCE Update File”). This begins a PS3 .pup, followed by a 0x30-byte big-endian header giving a format flag, package and image versions, the segment count and the offsets of the segment and digest tables. This signature is specific to the PS3 layout: PS4, PS5 and PS Vita packages reuse the .pup extension but have different internal structures and stronger encryption, so there is no single magic number shared across all PlayStation generations.

What is a PUP file?

PUP stands for PlayStation Update Package, Sony Interactive Entertainment’s container for console system-software (firmware) updates. The format runs across the PSP, PlayStation 3 (launched 2006), PlayStation Vita, PlayStation 4 and PlayStation 5. A single .pup bundles everything a console needs to upgrade itself: the operating system (Sony calls it GameOS on PS3), the system modules, firmware for subcomponents such as the system controller (Syscon), the Wi-Fi/Bluetooth radio and the Blu-ray drive, plus user-interface assets. The standard filenames are PS3UPDAT.PUP, PS4UPDATE.PUP and PS5UPDATE.PUP.

The defining property of the format is security, not compression. Although some file databases file it under “compressed files”, a .pup is not an archive you extract and browse. It is digitally signed by Sony and, on PS4 and PS5, encrypted. The console verifies the signature before it writes anything to flash, which is why the package cannot be edited, forged or installed on the wrong hardware: a PS4 update will not install on a PS3, and a tampered file is rejected. Everything below describes the PS3 layout, which is the best-documented generation; later consoles keep the same extension but changed the internals.

The PS3 header: SCEUF, segment count and table offsets

A PS3 .pup opens with a fixed 0x30-byte (48-byte) header. The first five bytes are the ASCII magic SCEUF (53 43 45 55 46), short for “SCE Update File”. All multi-byte integers in the PS3 package are big-endian. The header does not hold firmware itself; it is a directory that tells the loader how many pieces follow and where each table lives.

offset  size  field
0x00    0x08  magic          "SCEUF\0\0\0"  (53 43 45 55 46 ...)
0x08    0x08  package_format flag / format version
0x10    0x08  package_version
0x18    0x08  image_version
0x20    0x08  segment_count  number of segment entries
0x28    0x08  header_length  / offset to the file (segment) table
0x30    ...   segment table, then digest table, then segment data

The segment_count field is the key number: it says how many independent firmware pieces are packed inside. Each piece is described twice, once in the segment table (where it is and how big it is) and once in the digest table (its integrity hash). Because the header carries the offsets, a loader never scans the file blindly; it jumps straight to each table.

The segment table and the digest table

After the header comes the segment table: one 0x20-byte (32-byte) entry per segment. An entry records the segment’s id, its absolute offset in the file, its size, and the signing/encryption algorithm applied to it, with the rest as padding.

segment entry (0x20 bytes)
  0x00  id             which subcomponent this segment is
  0x08  offset         where the segment data starts in the .pup
  0x10  size           byte length of the segment
  0x18  sign_algorithm / flags + padding

The digest table follows, again as 0x20-byte entries, one per segment. Each digest entry holds a segment index, a 0x14-byte (20-byte) hash and padding. The hash is an HMAC-SHA1 computed over the corresponding segment, so before installing anything the console can recompute each segment’s HMAC and compare it to the stored digest. A single flipped bit, whether from a bad download or deliberate tampering, changes the hash and the update is refused. This per-segment hashing is why an interrupted transfer, or a manually edited package, reliably fails verification rather than silently installing corrupt firmware.

Signed and encrypted segments: why you cannot open it on a PC

The bulk of the file after the tables is the segment data: the GameOS image, the individual system modules and the component firmware blobs. On PS3 these are individually signed; on PS4 and PS5 they are also encrypted with keys the console holds and the public does not. This is the practical reason a .pup resists inspection. Tools such as “PS3 PUP Extractor” can walk the header and pull out the raw segments, but what they recover is still encrypted or signed data that cannot be run, edited or repacked into a working update. There is nothing user-runnable inside, and no path from a .pup back to a flashable image outside the console’s own verified update routine.

The chain-of-trust also explains the platform lock. Each console generation ships with different verification keys and a different internal layout, so a PS4 package fails on a PS3 not because of the extension but because the signature and structure do not match what that console expects. There is no single .pup format; there is a family of format-specific packages that happen to share one extension.

Installing a PUP: the exact USB folder path

Because the file is meant for the console, the real “opener” is the console itself. For a normal update you let the machine download over the internet. For an offline install or a full “Reinstall System Software”, you download the official package from PlayStation’s support site and copy it to a USB drive formatted FAT32 (or exFAT on newer consoles), in the precise path Sony documents. On PS4 that path is:

USB root
└─ PS4
   └─ UPDATE
      └─ PS4UPDATE.PUP

The folder names must be uppercase, the filename must match exactly, and the drive must be FAT32/exFAT. Almost every “the console can’t find the update” report traces to one of three mistakes: the file sits in the wrong folder, it was renamed (for example the browser saved it as PS4UPDATE(1).PUP), or the drive uses NTFS. From the console you then choose System Update (or, for a clean reinstall, boot into Safe Mode and pick the reinstall option). The console reads the header, verifies every segment’s HMAC and signature, and only then writes the firmware.

The other PUP: Puppy Linux DotPup

Not every .pup is a PlayStation file. Older versions of the Puppy Linux distribution used a “DotPup” installer with the same extension: a self-installing package, usually a gzipped shell script, that only means anything on Puppy Linux and has since been largely replaced by the .pet package. If a .pup is a small script-like file from a Linux download rather than a multi-hundred-megabyte firmware image from Sony, it is almost certainly a DotPup and has nothing to do with a games console.

Frequently asked questions

How do I open or install a PUP file?

If it is PlayStation firmware, you do not open it on a PC. Copy it to a FAT32/exFAT USB stick in Sony’s required folder (on PS4, /PS4/UPDATE/PS4UPDATE.PUP) and install it from the console’s System Update menu. The console verifies the signature and installs the firmware itself.

Why can’t my console find the update on the USB drive?

Usually the folder or filename is wrong, or the drive is formatted NTFS. Recreate the exact uppercase path Sony specifies with the official filename on a FAT32/exFAT drive, and make sure the browser did not append a number to the filename.

Can I extract a PUP to see what is inside?

Only partially. Tools like PS3 PUP Extractor can read the header and pull out the internal segments, but the segments are signed and (on PS4/PS5) encrypted, so you cannot edit them or rebuild a valid update. There is nothing user-runnable in a .pup.

References

Feedback

Was this page helpful?

Glad to hear it! Please tell us how we can improve.

Sorry to hear that. Please tell us how we can improve.

Table of contents