Skip to content

Linux payload implementing HV exploits to run a custom bootloader

C

Dump gpu ucode on PS5 Pro. Only 13.20 for now (#84)

Borchev12c0a82db23c
diff --git a/include/offsets.h b/include/offsets.h
index 780b10c..bba7b0e 100644
--- a/include/offsets.h
+++ b/include/offsets.h
@@ -50,8 +50,10 @@ typedef struct _offset_list {
/* Wifi FW */
uint64_t PS5_WIFI_FW_OFFSET;
uint64_t PS5_WIFI_FW_SIZE;
-
+ /* PS5 Pro GPU FW */
+ uint64_t PS5_PRO_GPU_FW_OFFSET;
uint64_t HV_MP_STARTUP_CALL;
+
uint64_t MP_STARTUP_INIT_VECTOR;
uint64_t DATA_CAVE;
uint64_t GAD_PIVOT_ADD_RSP28_RET;
@@ -74,8 +76,8 @@ typedef struct _offset_list {
uint64_t HV_EFI_MAP_ROOT;
} offset_list;
-_Static_assert(sizeof(offset_list) == 0x1E0,
- "offset_list must match the 13.60 60-qword table");
+_Static_assert(sizeof(offset_list) == 0x1E8,
+ "offset_list must match the 13.60 61-qword table");
extern offset_list off_0300;
extern offset_list off_0310;
diff --git a/source/firmware.c b/source/firmware.c
index 2653eaa..c8bce78 100644
--- a/source/firmware.c
+++ b/source/firmware.c
@@ -2,10 +2,120 @@
#include "utils.h"
#include <errno.h>
#include <fcntl.h>
+#include <stdint.h>
#include <stdio.h>
+#include <string.h>
#include <sys/stat.h>
+#include <unistd.h>
#define PS5_WIFI_FW_BOOT_PATH "lib/nxp/pcieuartiw620_combo_v1.bin"
+#define PS5_PRO_GPU_FW_BOOT_PATH_BASE "lib/firmware/amdgpu/viola"
+
+// An amdgpu firmware file is a 0x100-byte driver header followed by the ucode
+// array: a 0x100-byte $PS1 header, the payload and a 0x100-byte signature
+// slot. The PS5 keeps only the payload, so the rest is rebuilt with the $PS1
+// header reduced to its magic and payload size and the signature left blank.
+#define AMDGPU_FW_HEADER_SIZE 0x100
+#define PS1_HEADER_SIZE 0x100
+#define PS1_SIGNATURE_SIZE 0x100
+
+// Offset of the payload in a dumped file.
+#define GPU_FIRMWARE_PAYLOAD_OFFSET (AMDGPU_FW_HEADER_SIZE + PS1_HEADER_SIZE)
+
+#define AMDGPU_FW_MAX_PAYLOAD_DWORDS \
+ ((UINT32_MAX - AMDGPU_FW_HEADER_SIZE - PS1_HEADER_SIZE - \
+ PS1_SIGNATURE_SIZE) / \
+ sizeof(uint32_t))
+
+// sizeof(struct rlc_firmware_header_v2_0) in amdgpu_ucode.h. Every field past
+// the common header stays zero.
+#define AMDGPU_RLC_HEADER_V2_0_SIZE 0x68
+
+#define ARRAY_COUNT(a) (sizeof(a) / sizeof((a)[0]))
+
+// A kernel GPU firmware table entry. The table at PS5_PRO_GPU_FW_OFFSET is an
+// array of pointers to these.
+struct gpu_firmware_blob_header {
+ uint64_t size; // payload length in dwords
+ uint64_t tagString; // kernel VA
+ uint64_t unknown1; // ucode feature version: rlc 0x1, sdma 0x32, cp 0x1c
+ uint64_t imagePtr; // kernel VA
+ uint32_t jtOffset; // jump table start, dwords into the payload
+ uint32_t jtSize; // jump table length in dwords
+ uint32_t unknown2; // 0
+ uint32_t checksum; // rlc: xor of payload dwords, sdma: sum, cp: unknown
+};
+
+// Layouts from the Linux amdgpu driver's amdgpu_ucode.h.
+struct amdgpu_common_firmware_header {
+ uint32_t size_bytes;
+ uint32_t header_size_bytes;
+ uint16_t header_version_major;
+ uint16_t header_version_minor;
+ uint16_t ip_version_major;
+ uint16_t ip_version_minor;
+ uint32_t ucode_version;
+ uint32_t ucode_size_bytes;
+ uint32_t ucode_array_offset_bytes;
+ uint32_t crc32;
+};
+
+struct amdgpu_gfx_firmware_header_v1_0 {
+ struct amdgpu_common_firmware_header header;
+ uint32_t ucode_feature_version;
+ uint32_t jt_offset;
+ uint32_t jt_size;
+};
+
+struct amdgpu_sdma_firmware_header_v1_0 {
+ struct amdgpu_common_firmware_header header;
+ uint32_t ucode_feature_version;
+ uint32_t ucode_change_version;
+ uint32_t jt_offset;
+ uint32_t jt_size;
+};
+
+union amdgpu_firmware_header {
+ struct amdgpu_common_firmware_header common;
+ struct amdgpu_gfx_firmware_header_v1_0 gfx;
+ struct amdgpu_sdma_firmware_header_v1_0 sdma;
+ uint8_t raw[AMDGPU_FW_HEADER_SIZE];
+};
+
+enum gpu_firmware_kind { GPU_FW_RLC, GPU_FW_GFX, GPU_FW_SDMA };
+
+struct gpu_firmware_blob_info {
+ const char *name;
+ enum gpu_firmware_kind kind;
+ uint32_t ucode_version;
+ uint32_t feature_version;
+};
+
+// Byte changes made to dumped files, at offsets into the file. A patch is
+// only applied when the payload still holds its original bytes.
+struct gpu_firmware_patch {
+ const char *name;
+ uint32_t file_offset;
+ uint8_t from[4];
+ uint8_t to[4];
+};
+
+// In kernel table order. The kernel does not keep ucode versions, so the
+// versions are those of the cyan_skillfish2 firmware in linux-firmware
+// (AMD 21.50)
+static const struct gpu_firmware_blob_info gpu_firmware_blobs[] = {
+ {"rlc", GPU_FW_RLC, 0xd, 0}, {"sdma", GPU_FW_SDMA, 0x34, 0x32},
+ {"sdma1", GPU_FW_SDMA, 0x34, 0x32}, {"ce", GPU_FW_GFX, 0x25, 0x20},
+ {"pfp", GPU_FW_GFX, 0x94, 0x20}, {"me", GPU_FW_GFX, 0x63, 0x20},
+ {"mec", GPU_FW_GFX, 0x90, 0x20}, {"mec2", GPU_FW_GFX, 0x90, 0x20}};
+
+static const struct gpu_firmware_patch gpu_firmware_patches[] = {
+ // Viola checks bit 23 of indirect buffer packets. It does something weird
+ // (likely proprietary) when it finds it set, causing a hang. Cyan Skillfish
+ // ignores it. This patch just forces Viola to ignore it too, avoiding the
+ // hang.
+ {"pfp", 0x18b8, {0x63, 0x00, 0xc0, 0x96}, {0x11, 0x06, 0x00, 0x80}},
+};
static size_t ps5_wifi_firmware_size(void) {
return (size_t)env_offset.PS5_WIFI_FW_SIZE;
@@ -15,6 +125,12 @@ static uint64_t ps5_wifi_firmware_va(void) {
return get_offset_va(env_offset.PS5_WIFI_FW_OFFSET);
}
+// The table is an array of pointers to gpu_firmware_blob_header.
+static uint64_t ps5_pro_gpu_firmware_table_slot_va(size_t index) {
+ return get_offset_va(env_offset.PS5_PRO_GPU_FW_OFFSET) +
+ index * sizeof(uint64_t);
+}
+
static int write_all(int fd, const void *buf, size_t len) {
size_t written = 0;
@@ -45,9 +161,8 @@ static int mkdir_if_needed(const char *path) {
return S_ISDIR(st.st_mode) ? 0 : -1;
}
-static int build_firmware_path(const char *boot_file_path, char *boot_dir,
- size_t boot_dir_size, char *fw_path,
- size_t fw_path_size) {
+static int build_boot_dir(const char *boot_file_path, char *boot_dir,
+ size_t boot_dir_size) {
const char *slash = strrchr(boot_file_path, '/');
int ret;
@@ -59,29 +174,261 @@ static int build_firmware_path(const char *boot_file_path, char *boot_dir,
if (ret < 0 || (size_t)ret >= boot_dir_size)
return -1;
+ return 0;
+}
+
+static int build_firmware_path(const char *boot_file_path, char *boot_dir,
+ size_t boot_dir_size, char *fw_path,
+ size_t fw_path_size,
+ const char *file_leaf_name) {
+ int ret;
+
+ if (build_boot_dir(boot_file_path, boot_dir, boot_dir_size) < 0)
+ return -1;
+
ret =
- snprintf(fw_path, fw_path_size, "%s/%s", boot_dir, PS5_WIFI_FW_BOOT_PATH);
+ snprintf(fw_path, fw_path_size, "%s/%s", boot_dir, file_leaf_name);
if (ret < 0 || (size_t)ret >= fw_path_size)
return -1;
return 0;
}
-static int create_firmware_dirs(const char *boot_dir) {
+// Creates every directory component of file_leaf_name under boot_dir.
+static int create_firmware_dirs(const char *boot_dir,
+ const char *file_leaf_name) {
char path[512];
+ const char *slash = file_leaf_name;
int ret;
- ret = snprintf(path, sizeof(path), "%s/lib", boot_dir);
- if (ret < 0 || (size_t)ret >= sizeof(path))
+ while ((slash = strchr(slash, '/')) != NULL) {
+ ret = snprintf(path, sizeof(path), "%s/%.*s", boot_dir,
+ (int)(slash - file_leaf_name), file_leaf_name);
+ if (ret < 0 || (size_t)ret >= sizeof(path))
+ return -1;
+ if (mkdir_if_needed(path) < 0)
+ return -1;
+ slash++;
+ }
+
+ return 0;
+}
+
+static uint32_t crc32_update(uint32_t crc, const uint8_t *buf, size_t len) {
+ crc = ~crc;
+ while (len--) {
+ crc ^= *buf++;
+ for (int i = 0; i < 8; i++)
+ crc = (crc >> 1) ^ (0xedb88320u & -(crc & 1));
+ }
+ return ~crc;
+}
+
+static void build_ps1_header(uint8_t *out, uint32_t payload_size) {
+ memset(out, 0, PS1_HEADER_SIZE);
+ memcpy(out + 0x10, "$PS1", 4);
+ memcpy(out + 0x14, &payload_size, sizeof(payload_size));
+}
+
+static void build_amdgpu_header(union amdgpu_firmware_header *out,
+ const struct gpu_firmware_blob_info *info,
+ const struct gpu_firmware_blob_header *blob,
+ uint32_t crc) {
+ uint32_t ucode_size = (uint32_t)blob->size * sizeof(uint32_t) +
+ PS1_HEADER_SIZE + PS1_SIGNATURE_SIZE;
+
+ memset(out, 0, sizeof(*out));
+ out->common.size_bytes = AMDGPU_FW_HEADER_SIZE + ucode_size;
+ out->common.ucode_version = info->ucode_version;
+ out->common.ucode_size_bytes = ucode_size;
+ out->common.ucode_array_offset_bytes = AMDGPU_FW_HEADER_SIZE;
+ out->common.crc32 = crc;
+
+ switch (info->kind) {
+ case GPU_FW_RLC:
+ out->common.header_size_bytes = AMDGPU_RLC_HEADER_V2_0_SIZE;
+ out->common.header_version_major = 2;
+ out->common.ip_version_major = 10;
+ out->common.ip_version_minor = 1;
+ break;
+ case GPU_FW_GFX:
+ out->common.header_size_bytes = sizeof(out->gfx);
+ out->common.header_version_major = 1;
+ out->common.ip_version_major = 10;
+ out->common.ip_version_minor = 1;
+ out->gfx.ucode_feature_version = info->feature_version;
+ out->gfx.jt_offset = blob->jtOffset;
+ out->gfx.jt_size = blob->jtSize;
+ break;
+ case GPU_FW_SDMA:
+ out->common.header_size_bytes = sizeof(out->sdma);
+ out->common.header_version_major = 1;
+ out->common.ip_version_major = 5;
+ out->common.ip_version_minor = 0;
+ out->sdma.ucode_feature_version = info->feature_version;
+ out->sdma.jt_offset = blob->jtOffset;
+ out->sdma.jt_size = blob->jtSize;
+ break;
+ }
+}
+
+// Sets apply[i] for each patch that targets this blob and whose original bytes
+// are still in its payload.
+static void select_gpu_firmware_patches(
+ const char *name, const struct gpu_firmware_blob_header *hdr,
+ uint64_t payload_size, int *apply) {
+ for (size_t i = 0; i < ARRAY_COUNT(gpu_firmware_patches); i++) {
+ const struct gpu_firmware_patch *p = &gpu_firmware_patches[i];
+ uint64_t off = (uint64_t)p->file_offset - GPU_FIRMWARE_PAYLOAD_OFFSET;
+ uint8_t cur[sizeof(p->from)];
+
+ apply[i] = 0;
+ if (strcmp(p->name, name) != 0)
+ continue;
+
+ if (p->file_offset < GPU_FIRMWARE_PAYLOAD_OFFSET ||
+ off + sizeof(cur) > payload_size) {
+ notify("PS5 Pro GPU firmware %s is too short for the patch at %#x, "
+ "not patched\n",
+ name, p->file_offset);
+ continue;
+ }
+
+ kread(hdr->imagePtr + off, cur, sizeof(cur));
+ if (memcmp(cur, p->from, sizeof(cur)) != 0) {
+ notify("PS5 Pro GPU firmware %s has unexpected bytes at %#x, not "
+ "patched\n",
+ name, p->file_offset);
+ continue;
+ }
+
+ apply[i] = 1;
+ }
+}
+
+// Applies the selected patches to a chunk of payload starting at chunk_off.
+static void patch_gpu_firmware_chunk(const int *apply, uint8_t *buf,
+ uint64_t chunk_off, size_t chunk_len) {
+ for (size_t i = 0; i < ARRAY_COUNT(gpu_firmware_patches); i++) {
+ const struct gpu_firmware_patch *p = &gpu_firmware_patches[i];
+ uint64_t off = (uint64_t)p->file_offset - GPU_FIRMWARE_PAYLOAD_OFFSET;
+
+ if (!apply[i])
+ continue;
+
+ for (size_t j = 0; j < sizeof(p->to); j++) {
+ if (off + j >= chunk_off && off + j < chunk_off + chunk_len)
+ buf[off + j - chunk_off] = p->to[j];
+ }
+ }
+}
+
+static int dump_ps5_pro_gpu_firmware_blob(const char *boot_dir, size_t index) {
+ const struct gpu_firmware_blob_info *info = &gpu_firmware_blobs[index];
+ int apply_patch[ARRAY_COUNT(gpu_firmware_patches)];
+ struct gpu_firmware_blob_header hdr;
+ union amdgpu_firmware_header fw_hdr;
+ uint8_t ps1_hdr[PS1_HEADER_SIZE];
+ char fw_path[512];
+ uint8_t buf[0x4000];
+ uint64_t hdr_va;
+ uint64_t payload_size;
+ uint32_t crc;
+ int ret;
+ int fd;
+
+ ret = snprintf(fw_path, sizeof(fw_path), "%s/%s_%s.bin", boot_dir,
+ PS5_PRO_GPU_FW_BOOT_PATH_BASE, info->name);
+ if (ret < 0 || (size_t)ret >= sizeof(fw_path)) {
+ notify("PS5 Pro GPU firmware dump path is too long\n");
return -1;
- if (mkdir_if_needed(path) < 0)
+ }
+
+ kread(ps5_pro_gpu_firmware_table_slot_va(index), &hdr_va, sizeof(hdr_va));
+ if (hdr_va == 0) {
+ notify("PS5 Pro GPU firmware header pointer for %s is null\n", info->name);
return -1;
+ }
- ret = snprintf(path, sizeof(path), "%s/lib/nxp", boot_dir);
- if (ret < 0 || (size_t)ret >= sizeof(path))
+ kread(hdr_va, &hdr, sizeof(hdr));
+ if (hdr.size == 0 || hdr.imagePtr == 0) {
+ notify("PS5 Pro GPU firmware header for %s is empty\n", info->name);
return -1;
- if (mkdir_if_needed(path) < 0)
+ }
+
+ if (hdr.size > AMDGPU_FW_MAX_PAYLOAD_DWORDS ||
+ (uint64_t)hdr.jtOffset + hdr.jtSize > hdr.size) {
+ notify("PS5 Pro GPU firmware header for %s is malformed\n", info->name);
return -1;
+ }
+
+ payload_size = hdr.size * sizeof(uint32_t);
+ select_gpu_firmware_patches(info->name, &hdr, payload_size, apply_patch);
+
+ fd = open(fw_path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
+ if (fd < 0) {
+ notify("Could not create PS5 Pro GPU firmware file %s\n", fw_path);
+ return -1;
+ }
+
+ // The driver header holds the crc of everything after it, so a blank one
+ // goes first and is filled in once the rest is written.
+ memset(&fw_hdr, 0, sizeof(fw_hdr));
+ build_ps1_header(ps1_hdr, (uint32_t)payload_size);
+ crc = crc32_update(0, ps1_hdr, sizeof(ps1_hdr));
+ if (write_all(fd, &fw_hdr, sizeof(fw_hdr)) < 0 ||
+ write_all(fd, ps1_hdr, sizeof(ps1_hdr)) < 0)
+ goto write_failed;
+
+ for (uint64_t copied = 0; copied < payload_size; copied += sizeof(buf)) {
+ size_t chunk = payload_size - copied;
+ if (chunk > sizeof(buf))
+ chunk = sizeof(buf);
+
+ kread(hdr.imagePtr + copied, buf, chunk);
+ patch_gpu_firmware_chunk(apply_patch, buf, copied, chunk);
+ crc = crc32_update(crc, buf, chunk);
+ if (write_all(fd, buf, chunk) < 0)
+ goto write_failed;
+ }
+
+ memset(buf, 0, PS1_SIGNATURE_SIZE);
+ crc = crc32_update(crc, buf, PS1_SIGNATURE_SIZE);
+ build_amdgpu_header(&fw_hdr, info, &hdr, crc);
+ if (write_all(fd, buf, PS1_SIGNATURE_SIZE) < 0 ||
+ lseek(fd, 0, SEEK_SET) < 0 ||
+ write_all(fd, &fw_hdr, sizeof(fw_hdr)) < 0)
+ goto write_failed;
+
+ close(fd);
+ notify("Dumped PS5 Pro GPU firmware %s to %s (%llu bytes)\n", info->name,
+ fw_path, (unsigned long long)fw_hdr.common.size_bytes);
+ return 0;
+
+write_failed:
+ close(fd);
+ notify("Could not write PS5 Pro GPU firmware file %s\n", fw_path);
+ return -1;
+}
+
+static int dump_ps5_pro_gpu_firmware(const char *boot_file_path) {
+ char boot_dir[512];
+
+ if (build_boot_dir(boot_file_path, boot_dir, sizeof(boot_dir)) < 0) {
+ notify("PS5 Pro GPU firmware dump path is too long\n");
+ return -1;
+ }
+
+ if (create_firmware_dirs(boot_dir, PS5_PRO_GPU_FW_BOOT_PATH_BASE) < 0) {
+ notify("Could not create PS5 Pro GPU firmware directory under %s\n",
+ boot_dir);
+ return -1;
+ }
+
+ for (size_t i = 0; i < ARRAY_COUNT(gpu_firmware_blobs); i++) {
+ if (dump_ps5_pro_gpu_firmware_blob(boot_dir, i) < 0)
+ return -1;
+ }
return 0;
}
@@ -100,12 +447,12 @@ static int dump_ps5_wifi_firmware(const char *boot_file_path) {
}
if (build_firmware_path(boot_file_path, boot_dir, sizeof(boot_dir), fw_path,
- sizeof(fw_path)) < 0) {
+ sizeof(fw_path), PS5_WIFI_FW_BOOT_PATH) < 0) {
notify("PS5 WiFi firmware dump path is too long\n");
return -1;
}
- if (create_firmware_dirs(boot_dir) < 0) {
+ if (create_firmware_dirs(boot_dir, PS5_WIFI_FW_BOOT_PATH) < 0) {
notify("Could not create PS5 WiFi firmware directory under %s\n", boot_dir);
return -1;
}
@@ -138,5 +485,12 @@ static int dump_ps5_wifi_firmware(const char *boot_file_path) {
}
int dump_device_firmwares(const char *boot_file_path) {
- return dump_ps5_wifi_firmware(boot_file_path);
+ int ret = dump_ps5_wifi_firmware(boot_file_path);
+
+ // Only PS5 Pro firmwares have a GPU firmware table offset.
+ if (env_offset.PS5_PRO_GPU_FW_OFFSET != 0 &&
+ dump_ps5_pro_gpu_firmware(boot_file_path) < 0)
+ ret = -1;
+
+ return ret;
}
diff --git a/source/offsets.c b/source/offsets.c
index 998036b..45d5a4a 100644
--- a/source/offsets.c
+++ b/source/offsets.c
@@ -1351,6 +1351,7 @@ offset_list off_1320 = {
.FUN_MP3_INVOKE = 0xA0A9D0,
.PS5_WIFI_FW_OFFSET = 0x1505170,
.PS5_WIFI_FW_SIZE = 0x7A248,
+ .PS5_PRO_GPU_FW_OFFSET = 0x25141D0,
.HV_MP_STARTUP_CALL = 0xC0A310,
.MP_STARTUP_INIT_VECTOR = 0x26A798,
.DATA_CAVE = 0x2D29000,