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.hindex 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.cindex 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.cindex 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,