#include "xbox_ref_bridge.h" #include #ifdef WIN32 #define WIN32_LEAN_AND_MEAN #define _WIN32_WINNT 0x0500 #include #include #include #include #include #include #ifndef SCSI_IOCTL_DATA_UNSPECIFIED #define SCSI_IOCTL_DATA_UNSPECIFIED 2 #endif #include "xbox_ref/utils.h" #include "xbox_ref/sha1.h" #include "xbox_ref/unlock.h" #include "xbox_ref/xbox_ref_log.h" #define printf xbox_ref_printf #define XGD1_RAW_ID_PROBE_SCHEMA_VERSION 2 #define XGD1_RAW_ID_CACHE_BASE 0x80000000U #define XGD1_RAW_SECTOR_BYTES 2064U #define XGD1_LOGICAL_SECTOR_BYTES 2048U #define XGD1_CACHE_FILL_SECTORS 16U #define XGD1_RAW_ID_MAX_SAMPLES 16U typedef struct xgd1_sptd_with_sense_s { SCSI_PASS_THROUGH_DIRECT sptd; ULONG filler; UCHAR sense[32]; } xgd1_sptd_with_sense; typedef struct xgd1_cmd_result_s { int ok; DWORD win32_error; UCHAR scsi_status; UCHAR sense_key; UCHAR asc; UCHAR ascq; } xgd1_cmd_result; typedef struct xgd1_raw_id_sample_s { uint32_t lba; const char *label; uint32_t cache_fill_lba; uint32_t cache_index; uint32_t cache_address; xgd1_cmd_result cache_flush; xgd1_cmd_result cache_fill; xgd1_cmd_result memdump_header; xgd1_cmd_result memdump_edc; int raw_header_valid; UCHAR sector_information; uint32_t layer_number; uint32_t physical_sector_number; uint32_t normalized_physical_sector_number; uint32_t output_lba; uint32_t expected_layer_number; uint32_t expected_physical_sector_number; uint32_t expected_normalized_physical_sector_number; int layer_matches_expected; int psn_matches_expected; int geometry_matches_expected; char logical_sha1[41]; unsigned char logical[XGD1_LOGICAL_SECTOR_BYTES]; unsigned char raw_header[12]; unsigned char raw_edc[4]; } xgd1_raw_id_sample; typedef struct xgd1_raw_id_state_s { const char *name; int locked_view; uint32_t capacity; int capacity_valid; int state_verified; uint32_t sample_count; uint32_t geometry_validation_failures; int geometry_verified; xgd1_raw_id_sample samples[XGD1_RAW_ID_MAX_SAMPLES]; } xgd1_raw_id_state; typedef struct xgd1_probe_point_s { uint32_t lba; const char *label; } xgd1_probe_point; static const xgd1_probe_point xgd1_locked_points[] = { {0U, "locked_logical_start"}, {31U, "locked_early_lba_31"}, {32U, "locked_early_lba_32"}, {XGD1_VIDEO_L0_SECTORS - 1U, "video_l0_last"}, {XGD1_VIDEO_L0_SECTORS, "video_l1_first"}, {XGD1_VIDEO_TOTAL_SECTORS - 1U, "locked_video_last"} }; static const xgd1_probe_point xgd1_unlocked_points[] = { {0U, "unlocked_source_start"}, {XGD1_XISO_LEADIN_SECTORS - 1U, "unlocked_leadin_last"}, {XGD1_GAME_SOURCE_START_LBA, "xdfs_source_start"}, {XGD1_GAME_SOURCE_START_LBA + 1U, "xdfs_source_next"}, {(XGD1_REDUMP_LAYER_BREAK_LBA - XGD1_GAME_OUTPUT_START_LBA) - 1U, "mapped_layer_break_source_minus_one"}, {XGD1_REDUMP_LAYER_BREAK_LBA - XGD1_GAME_OUTPUT_START_LBA, "mapped_layer_break_source"}, {REDUMP_SECTORS - 1U, "unlocked_source_last"} }; static char xgd1_drive_letter_from_device(const char *device) { if (!device || !device[0]) return 0; if (device[0] && device[1] == ':') return device[0]; if (device[0] == '\\' && device[1] == '\\' && device[2] == '.' && device[3] == '\\' && device[4] && device[5] == ':') return device[4]; return device[0]; } static int xgd1_capacity_is_locked(uint32_t sectors) { return sectors == XGD1_VIDEO_TOTAL_SECTORS; } static int xgd1_capacity_is_game(uint32_t sectors) { return sectors == REDUMP_SECTORS; } static uint32_t xgd1_refresh_ready_capacity(HANDLE hDevice) { RefreshVolume(hDevice); Sleep(2000); EnsureDriveReady(hDevice, 30000); return GetTotalSectors(hDevice); } static void xgd1_parse_sense(const UCHAR *sense, UCHAR *sense_key, UCHAR *asc, UCHAR *ascq) { UCHAR response; if (sense_key) *sense_key = 0; if (asc) *asc = 0; if (ascq) *ascq = 0; if (!sense) return; response = (UCHAR)(sense[0] & 0x7f); if (response == 0x70 || response == 0x71) { if (sense_key) *sense_key = (UCHAR)(sense[2] & 0x0f); if (asc) *asc = sense[12]; if (ascq) *ascq = sense[13]; } else if (response == 0x72 || response == 0x73) { if (sense_key) *sense_key = (UCHAR)(sense[1] & 0x0f); if (asc) *asc = sense[2]; if (ascq) *ascq = sense[3]; } } static void xgd1_sha1(const unsigned char *data, uint32_t data_size, char out_sha1[41]) { SHA1_CTX ctx; unsigned char digest[20]; uint32_t i; if (!out_sha1) return; out_sha1[0] = '\0'; if (!data || data_size == 0) return; SHA1_Init(&ctx); SHA1_Update(&ctx, data, data_size); SHA1_Final(digest, &ctx); for (i = 0; i < 20U; ++i) sprintf(out_sha1 + (i * 2U), "%02x", digest[i]); out_sha1[40] = '\0'; } static void xgd1_cmd_result_init(xgd1_cmd_result *result) { if (result) memset(result, 0, sizeof(*result)); } static void xgd1_execute_data_in(HANDLE hDevice, const UCHAR *cdb, UCHAR cdb_length, unsigned char *buffer, DWORD buffer_length, DWORD timeout_seconds, xgd1_cmd_result *result) { xgd1_sptd_with_sense packet; DWORD bytes_returned; BOOL ioctl_ok; xgd1_cmd_result_init(result); if (!result || !cdb || !buffer || buffer_length == 0U) return; memset(buffer, 0, buffer_length); memset(&packet, 0, sizeof(packet)); packet.sptd.Length = sizeof(SCSI_PASS_THROUGH_DIRECT); packet.sptd.CdbLength = cdb_length; packet.sptd.SenseInfoLength = sizeof(packet.sense); packet.sptd.DataIn = SCSI_IOCTL_DATA_IN; packet.sptd.DataTransferLength = buffer_length; packet.sptd.TimeOutValue = timeout_seconds; packet.sptd.DataBuffer = buffer; packet.sptd.SenseInfoOffset = offsetof(xgd1_sptd_with_sense, sense); memcpy(packet.sptd.Cdb, cdb, cdb_length); bytes_returned = 0; ioctl_ok = DeviceIoControl(hDevice, IOCTL_SCSI_PASS_THROUGH_DIRECT, &packet, sizeof(packet), &packet, sizeof(packet), &bytes_returned, NULL); result->win32_error = ioctl_ok ? ERROR_SUCCESS : GetLastError(); result->scsi_status = packet.sptd.ScsiStatus; xgd1_parse_sense(packet.sense, &result->sense_key, &result->asc, &result->ascq); result->ok = (ioctl_ok && packet.sptd.ScsiStatus == 0) ? 1 : 0; } static void xgd1_execute_no_data(HANDLE hDevice, const UCHAR *cdb, UCHAR cdb_length, DWORD timeout_seconds, xgd1_cmd_result *result) { xgd1_sptd_with_sense packet; DWORD bytes_returned; BOOL ioctl_ok; xgd1_cmd_result_init(result); if (!result || !cdb) return; memset(&packet, 0, sizeof(packet)); packet.sptd.Length = sizeof(SCSI_PASS_THROUGH_DIRECT); packet.sptd.CdbLength = cdb_length; packet.sptd.SenseInfoLength = sizeof(packet.sense); packet.sptd.DataIn = SCSI_IOCTL_DATA_UNSPECIFIED; packet.sptd.DataTransferLength = 0; packet.sptd.TimeOutValue = timeout_seconds; packet.sptd.DataBuffer = NULL; packet.sptd.SenseInfoOffset = offsetof(xgd1_sptd_with_sense, sense); memcpy(packet.sptd.Cdb, cdb, cdb_length); bytes_returned = 0; ioctl_ok = DeviceIoControl(hDevice, IOCTL_SCSI_PASS_THROUGH_DIRECT, &packet, sizeof(packet), &packet, sizeof(packet), &bytes_returned, NULL); result->win32_error = ioctl_ok ? ERROR_SUCCESS : GetLastError(); result->scsi_status = packet.sptd.ScsiStatus; xgd1_parse_sense(packet.sense, &result->sense_key, &result->asc, &result->ascq); result->ok = (ioctl_ok && packet.sptd.ScsiStatus == 0) ? 1 : 0; } static void xgd1_set_lba(UCHAR *cdb, uint32_t lba) { cdb[2] = (UCHAR)((lba >> 24) & 0xff); cdb[3] = (UCHAR)((lba >> 16) & 0xff); cdb[4] = (UCHAR)((lba >> 8) & 0xff); cdb[5] = (UCHAR)(lba & 0xff); } static void xgd1_build_memdump_cdb(UCHAR cdb[12], uint32_t address, uint32_t length) { memset(cdb, 0, 12); cdb[0] = 0xE7; cdb[1] = 0x48; cdb[2] = 0x49; cdb[3] = 0x54; cdb[4] = 0x01; cdb[6] = (UCHAR)((address >> 24) & 0xff); cdb[7] = (UCHAR)((address >> 16) & 0xff); cdb[8] = (UCHAR)((address >> 8) & 0xff); cdb[9] = (UCHAR)(address & 0xff); cdb[10] = (UCHAR)((length >> 8) & 0xff); cdb[11] = (UCHAR)(length & 0xff); } static void xgd1_set_expected_geometry(int locked_view, xgd1_raw_id_sample *sample) { uint32_t output_lba; uint32_t layer_zero_last_psn; uint32_t normalized_psn; uint32_t expected_normalized_psn; uint32_t expected_layer; uint32_t expected_raw_psn; if (!sample) return; if (locked_view) { if (sample->lba < XGD1_VIDEO_L0_SECTORS) output_lba = sample->lba; else output_lba = XGD1_VIDEO_L1_OUTPUT_START_LBA + (sample->lba - XGD1_VIDEO_L0_SECTORS); } else { output_lba = XGD1_GAME_OUTPUT_START_LBA + sample->lba; } layer_zero_last_psn = 0x30000U + XGD1_REDUMP_LAYER_BREAK_LBA - 1U; if (output_lba < XGD1_REDUMP_LAYER_BREAK_LBA) { expected_layer = 0U; expected_normalized_psn = 0x30000U + output_lba; expected_raw_psn = expected_normalized_psn; } else { expected_layer = 1U; expected_normalized_psn = layer_zero_last_psn - (output_lba - XGD1_REDUMP_LAYER_BREAK_LBA); expected_raw_psn = (~expected_normalized_psn) & 0x00ffffffU; } normalized_psn = (sample->layer_number != 0U) ? ((~sample->physical_sector_number) & 0x00ffffffU) : sample->physical_sector_number; sample->output_lba = output_lba; sample->normalized_physical_sector_number = normalized_psn; sample->expected_layer_number = expected_layer; sample->expected_physical_sector_number = expected_raw_psn; sample->expected_normalized_physical_sector_number = expected_normalized_psn; sample->layer_matches_expected = (sample->layer_number == expected_layer) ? 1 : 0; sample->psn_matches_expected = (sample->physical_sector_number == expected_raw_psn) ? 1 : 0; sample->geometry_matches_expected = (sample->layer_matches_expected && sample->psn_matches_expected) ? 1 : 0; } static void xgd1_capture_sample(HANDLE hDevice, uint32_t capacity, int locked_view, const xgd1_probe_point *point, xgd1_raw_id_sample *sample) { unsigned char *read_buffer; UCHAR flush_cdb[12]; UCHAR read_cdb[12]; UCHAR e7_cdb[12]; uint32_t fill_lba; uint32_t index; uint32_t address; if (!sample || !point) return; memset(sample, 0, sizeof(*sample)); sample->lba = point->lba; sample->label = point->label; if (capacity < XGD1_CACHE_FILL_SECTORS || point->lba >= capacity) { sample->cache_flush.win32_error = ERROR_INVALID_PARAMETER; return; } fill_lba = point->lba & ~(XGD1_CACHE_FILL_SECTORS - 1U); if (fill_lba > capacity - XGD1_CACHE_FILL_SECTORS) fill_lba = capacity - XGD1_CACHE_FILL_SECTORS; index = point->lba - fill_lba; address = XGD1_RAW_ID_CACHE_BASE + index * XGD1_RAW_SECTOR_BYTES; sample->cache_fill_lba = fill_lba; sample->cache_index = index; sample->cache_address = address; memset(flush_cdb, 0, sizeof(flush_cdb)); flush_cdb[0] = 0xA8; flush_cdb[1] = 0x08; xgd1_set_lba(flush_cdb, fill_lba); xgd1_execute_no_data(hDevice, flush_cdb, 12, 15, &sample->cache_flush); if (!sample->cache_flush.ok) return; read_buffer = (unsigned char *)VirtualAlloc( NULL, XGD1_CACHE_FILL_SECTORS * XGD1_LOGICAL_SECTOR_BYTES, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); if (!read_buffer) { sample->cache_fill.win32_error = ERROR_NOT_ENOUGH_MEMORY; return; } memset(read_cdb, 0, sizeof(read_cdb)); read_cdb[0] = 0xA8; xgd1_set_lba(read_cdb, fill_lba); read_cdb[9] = (UCHAR)XGD1_CACHE_FILL_SECTORS; read_cdb[10] = 0x80; xgd1_execute_data_in(hDevice, read_cdb, 12, read_buffer, XGD1_CACHE_FILL_SECTORS * XGD1_LOGICAL_SECTOR_BYTES, 15, &sample->cache_fill); if (sample->cache_fill.ok) { memcpy(sample->logical, read_buffer + index * XGD1_LOGICAL_SECTOR_BYTES, XGD1_LOGICAL_SECTOR_BYTES); xgd1_sha1(sample->logical, XGD1_LOGICAL_SECTOR_BYTES, sample->logical_sha1); xgd1_build_memdump_cdb(e7_cdb, address, 12U); xgd1_execute_data_in(hDevice, e7_cdb, 12, sample->raw_header, 12U, 15, &sample->memdump_header); xgd1_build_memdump_cdb(e7_cdb, address + 2060U, 4U); xgd1_execute_data_in(hDevice, e7_cdb, 12, sample->raw_edc, 4U, 15, &sample->memdump_edc); if (sample->memdump_header.ok && sample->memdump_edc.ok) { sample->raw_header_valid = 1; sample->sector_information = sample->raw_header[0]; sample->layer_number = (uint32_t)(sample->sector_information & 1U); sample->physical_sector_number = ((uint32_t)sample->raw_header[1] << 16) | ((uint32_t)sample->raw_header[2] << 8) | (uint32_t)sample->raw_header[3]; xgd1_set_expected_geometry(locked_view, sample); } } VirtualFree(read_buffer, 0, MEM_RELEASE); } static void xgd1_capture_state(HANDLE hDevice, xgd1_raw_id_state *state, const xgd1_probe_point *points, uint32_t point_count) { uint32_t i; if (!state || !points || !state->state_verified) return; if (point_count > XGD1_RAW_ID_MAX_SAMPLES) point_count = XGD1_RAW_ID_MAX_SAMPLES; state->sample_count = point_count; state->geometry_validation_failures = 0U; for (i = 0; i < point_count; ++i) { printf("[XGD1-RAW-ID] %s: cache-flush, aligned READ(12), and HIT 0xE7 header/EDC capture for LBA %u (%s).\n", state->name ? state->name : "state", points[i].lba, points[i].label ? points[i].label : "unlabeled"); xgd1_capture_sample(hDevice, state->capacity, state->locked_view, &points[i], &state->samples[i]); if (!state->samples[i].cache_flush.ok || !state->samples[i].cache_fill.ok || !state->samples[i].raw_header_valid || !state->samples[i].geometry_matches_expected) state->geometry_validation_failures++; } state->geometry_verified = (state->state_verified && state->sample_count > 0U && state->geometry_validation_failures == 0U) ? 1 : 0; } static void xgd1_json_string(FILE *f, const char *s) { const unsigned char *p; fputc('"', f); if (s) { for (p = (const unsigned char *)s; *p; ++p) { switch (*p) { case '\\': fputs("\\\\", f); break; case '"': fputs("\\\"", f); break; case '\b': fputs("\\b", f); break; case '\f': fputs("\\f", f); break; case '\n': fputs("\\n", f); break; case '\r': fputs("\\r", f); break; case '\t': fputs("\\t", f); break; default: if (*p < 0x20) fprintf(f, "\\u%04x", (unsigned int)*p); else fputc(*p, f); break; } } } fputc('"', f); } static void xgd1_json_hex(FILE *f, const unsigned char *data, uint32_t size) { uint32_t i; fputc('"', f); for (i = 0; i < size; ++i) fprintf(f, "%02x", data[i]); fputc('"', f); } static void xgd1_write_cmd_result(FILE *f, const xgd1_cmd_result *r) { fprintf(f, "{\"ok\":%s,\"win32_error\":%lu,\"scsi_status\":%u," "\"sense_key\":%u,\"asc\":%u,\"ascq\":%u}", (r && r->ok) ? "true" : "false", (unsigned long)(r ? r->win32_error : 0), (unsigned int)(r ? r->scsi_status : 0), (unsigned int)(r ? r->sense_key : 0), (unsigned int)(r ? r->asc : 0), (unsigned int)(r ? r->ascq : 0)); } static void xgd1_write_sample(FILE *f, const xgd1_raw_id_sample *s, int comma) { fprintf(f, " {\n"); fprintf(f, " \"lba\": %u,\n", s->lba); fprintf(f, " \"label\": "); xgd1_json_string(f, s->label ? s->label : ""); fprintf(f, ",\n"); fprintf(f, " \"cache_fill_lba\": %u,\n", s->cache_fill_lba); fprintf(f, " \"cache_index\": %u,\n", s->cache_index); fprintf(f, " \"cache_address\": \"0x%08x\",\n", s->cache_address); fprintf(f, " \"cache_flush\": "); xgd1_write_cmd_result(f, &s->cache_flush); fprintf(f, ",\n"); fprintf(f, " \"cache_fill\": "); xgd1_write_cmd_result(f, &s->cache_fill); fprintf(f, ",\n"); fprintf(f, " \"memdump_header\": "); xgd1_write_cmd_result(f, &s->memdump_header); fprintf(f, ",\n"); fprintf(f, " \"memdump_edc\": "); xgd1_write_cmd_result(f, &s->memdump_edc); fprintf(f, ",\n"); fprintf(f, " \"raw_header_valid\": %s,\n", s->raw_header_valid ? "true" : "false"); if (s->raw_header_valid) { fprintf(f, " \"sector_information\": %u,\n", (unsigned int)s->sector_information); fprintf(f, " \"layer_number\": %u,\n", s->layer_number); fprintf(f, " \"physical_sector_number\": %u,\n", s->physical_sector_number); fprintf(f, " \"normalized_physical_sector_number\": %u,\n", s->normalized_physical_sector_number); fprintf(f, " \"output_lba\": %u,\n", s->output_lba); fprintf(f, " \"expected_layer_number\": %u,\n", s->expected_layer_number); fprintf(f, " \"expected_physical_sector_number\": %u,\n", s->expected_physical_sector_number); fprintf(f, " \"expected_normalized_physical_sector_number\": %u,\n", s->expected_normalized_physical_sector_number); fprintf(f, " \"layer_matches_expected\": %s,\n", s->layer_matches_expected ? "true" : "false"); fprintf(f, " \"psn_matches_expected\": %s,\n", s->psn_matches_expected ? "true" : "false"); fprintf(f, " \"geometry_matches_expected\": %s,\n", s->geometry_matches_expected ? "true" : "false"); fprintf(f, " \"logical_sha1\": \"%s\",\n", s->logical_sha1); fprintf(f, " \"raw_header_hex\": "); xgd1_json_hex(f, s->raw_header, 12U); fprintf(f, ",\n"); fprintf(f, " \"raw_edc_hex\": "); xgd1_json_hex(f, s->raw_edc, 4U); fprintf(f, ",\n"); fprintf(f, " \"logical_data_hex\": "); xgd1_json_hex(f, s->logical, XGD1_LOGICAL_SECTOR_BYTES); fprintf(f, "\n"); } else { fprintf(f, " \"sector_information\": null,\n"); fprintf(f, " \"layer_number\": null,\n"); fprintf(f, " \"physical_sector_number\": null,\n"); fprintf(f, " \"normalized_physical_sector_number\": null,\n"); fprintf(f, " \"output_lba\": null,\n"); fprintf(f, " \"expected_layer_number\": null,\n"); fprintf(f, " \"expected_physical_sector_number\": null,\n"); fprintf(f, " \"expected_normalized_physical_sector_number\": null,\n"); fprintf(f, " \"layer_matches_expected\": false,\n"); fprintf(f, " \"psn_matches_expected\": false,\n"); fprintf(f, " \"geometry_matches_expected\": false,\n"); fprintf(f, " \"logical_sha1\": null,\n"); fprintf(f, " \"raw_header_hex\": \"\",\n"); fprintf(f, " \"raw_edc_hex\": \"\",\n"); fprintf(f, " \"logical_data_hex\": \"\"\n"); } fprintf(f, " }%s\n", comma ? "," : ""); } static void xgd1_write_state(FILE *f, const xgd1_raw_id_state *state, int comma) { uint32_t i; fprintf(f, " {\n"); fprintf(f, " \"name\": "); xgd1_json_string(f, state->name ? state->name : ""); fprintf(f, ",\n"); fprintf(f, " \"capacity_valid\": %s,\n", state->capacity_valid ? "true" : "false"); fprintf(f, " \"capacity_sectors\": %u,\n", state->capacity); fprintf(f, " \"state_verified\": %s,\n", state->state_verified ? "true" : "false"); fprintf(f, " \"geometry_validation_failures\": %u,\n", state->geometry_validation_failures); fprintf(f, " \"geometry_verified\": %s,\n", state->geometry_verified ? "true" : "false"); fprintf(f, " \"samples\": [\n"); for (i = 0; i < state->sample_count; ++i) xgd1_write_sample(f, &state->samples[i], (i + 1U < state->sample_count)); fprintf(f, " ]\n"); fprintf(f, " }%s\n", comma ? "," : ""); } static int xgd1_write_report(const char *report_path, const char *device, uint32_t entry_capacity, int entry_game_view, int volume_lock_ever, const xgd1_raw_id_state *locked_state, const xgd1_raw_id_state *unlocked_state, int restore_attempted, uint32_t restored_capacity, int restore_verified) { const char *final_path; char tmp_path[MAX_PATH * 4]; FILE *f; int fd; BOOL moved; uint32_t validation_failures; int geometry_resolved; final_path = (report_path && report_path[0]) ? report_path : "xgd1_raw_id_probe.json"; validation_failures = (locked_state ? locked_state->geometry_validation_failures : 0U) + (unlocked_state ? unlocked_state->geometry_validation_failures : 0U); geometry_resolved = (locked_state && locked_state->geometry_verified && unlocked_state && unlocked_state->geometry_verified) ? 1 : 0; if (strlen(final_path) + 32U >= sizeof(tmp_path)) { printf("[XGD1-RAW-ID] Fatal: report path is too long.\n"); return 0; } sprintf(tmp_path, "%s.tmp.%lu.%lu", final_path, (unsigned long)GetCurrentProcessId(), (unsigned long)GetTickCount()); f = fopen(tmp_path, "wb"); if (!f) { printf("[XGD1-RAW-ID] Fatal: could not create temporary report %s.\n", tmp_path); return 0; } fprintf(f, "{\n"); fprintf(f, " \"schema_version\": %u,\n", XGD1_RAW_ID_PROBE_SCHEMA_VERSION); fprintf(f, " \"producer\": \"friidump-0.5.3.13\",\n"); fprintf(f, " \"probe\": \"original_xbox_xgd1_cache_aligned_raw_id_geometry\",\n"); fprintf(f, " \"device\": "); xgd1_json_string(f, device ? device : ""); fprintf(f, ",\n"); fprintf(f, " \"cache\": {\n"); fprintf(f, " \"memdump_command\": \"E7 48 49 54 01\",\n"); fprintf(f, " \"base_address\": \"0x%08x\",\n", XGD1_RAW_ID_CACHE_BASE); fprintf(f, " \"raw_sector_stride\": %u,\n", XGD1_RAW_SECTOR_BYTES); fprintf(f, " \"cache_flush_command\": \"READ(12), byte1=0x08, zero transfer length\",\n"); fprintf(f, " \"cache_fill_command\": \"READ(12) streaming, 16 sectors, block-aligned LBA\",\n"); fprintf(f, " \"memdump_regions\": \"12-byte ID/IED/CPR_MAI header plus 4-byte EDC only\",\n"); fprintf(f, " \"raw_user_data_compared_to_logical\": false,\n"); fprintf(f, " \"raw_user_data_note\": \"The proven Method 8 path replaces the drive-cache user field with READ(12) data before unscrambling; equality is not expected and is not a geometry test.\"\n"); fprintf(f, " },\n"); fprintf(f, " \"geometry_model\": {\n"); fprintf(f, " \"dvd_start_psn\": 196608,\n"); fprintf(f, " \"game_output_start_lba\": %u,\n", XGD1_GAME_OUTPUT_START_LBA); fprintf(f, " \"layer_break_lba\": %u,\n", XGD1_REDUMP_LAYER_BREAK_LBA); fprintf(f, " \"layer_zero_last_normalized_psn\": %u,\n", 0x30000U + XGD1_REDUMP_LAYER_BREAK_LBA - 1U); fprintf(f, " \"layer_one_raw_psn_is_24bit_complement\": true\n"); fprintf(f, " },\n"); fprintf(f, " \"safety\": {\n"); fprintf(f, " \"read_only_sector_commands\": true,\n"); fprintf(f, " \"authentication_handshake_used\": true,\n"); fprintf(f, " \"tray_cycle_used\": true,\n"); fprintf(f, " \"firmware_write_used\": false,\n"); fprintf(f, " \"flash_command_used\": false\n"); fprintf(f, " },\n"); fprintf(f, " \"entry\": {\n"); fprintf(f, " \"capacity_sectors\": %u,\n", entry_capacity); fprintf(f, " \"game_view\": %s,\n", entry_game_view ? "true" : "false"); fprintf(f, " \"classification\": \"%s\"\n", entry_game_view ? "unlocked_game" : "locked_video_or_unknown"); fprintf(f, " },\n"); fprintf(f, " \"volume_lock_acquired_at_least_once\": %s,\n", volume_lock_ever ? "true" : "false"); fprintf(f, " \"required_states_verified\": %s,\n", (locked_state && locked_state->state_verified && unlocked_state && unlocked_state->state_verified) ? "true" : "false"); fprintf(f, " \"geometry_validation_failures\": %u,\n", validation_failures); fprintf(f, " \"physical_geometry_resolved\": %s,\n", geometry_resolved ? "true" : "false"); fprintf(f, " \"states\": [\n"); xgd1_write_state(f, locked_state, 1); xgd1_write_state(f, unlocked_state, 0); fprintf(f, " ],\n"); fprintf(f, " \"restoration\": {\n"); fprintf(f, " \"attempted\": %s,\n", restore_attempted ? "true" : "false"); fprintf(f, " \"capacity_sectors\": %u,\n", restored_capacity); fprintf(f, " \"verified\": %s\n", restore_verified ? "true" : "false"); fprintf(f, " },\n"); fprintf(f, " \"interpretation_boundary\": {\n"); fprintf(f, " \"physical_geometry_resolved\": %s,\n", geometry_resolved ? "true" : "false"); fprintf(f, " \"pregame_filler_content_resolved\": false,\n"); fprintf(f, " \"postgame_filler_content_resolved\": false,\n"); fprintf(f, " \"note\": \"A complete cache-aligned raw-ID match can validate the logical-to-physical placement used by the current reconstruction. It does not make inaccessible filler sectors readable and does not establish exact filler bytes.\"\n"); fprintf(f, " }\n"); fprintf(f, "}\n"); if (fflush(f) != 0) { fclose(f); DeleteFileA(tmp_path); return 0; } fd = _fileno(f); if (fd < 0 || _commit(fd) != 0) { fclose(f); DeleteFileA(tmp_path); return 0; } if (fclose(f) != 0) { DeleteFileA(tmp_path); return 0; } moved = MoveFileExA(tmp_path, final_path, MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH); if (!moved) { printf("[XGD1-RAW-ID] Fatal: could not atomically publish report %s (error %lu).\n", final_path, (unsigned long)GetLastError()); DeleteFileA(tmp_path); return 0; } printf("[XGD1-RAW-ID] Atomic report written: %s\n", final_path); return 1; } static int xgd1_raw_id_probe_core(HANDLE hDevice, const char *device, const char *report_path, BOOL owns_handle) { xgd1_raw_id_state locked_state; xgd1_raw_id_state unlocked_state; uint32_t entry_capacity; uint32_t restored_capacity; int entry_game_view; int volume_lock_acquired; int volume_lock_ever; int restore_attempted; int restore_verified; int states_verified; DWORD bytes_returned; int report_ok; memset(&locked_state, 0, sizeof(locked_state)); memset(&unlocked_state, 0, sizeof(unlocked_state)); locked_state.name = "locked_video"; locked_state.locked_view = 1; unlocked_state.name = "unlocked_game"; unlocked_state.locked_view = 0; entry_capacity = 0; restored_capacity = 0; entry_game_view = 0; volume_lock_acquired = 0; volume_lock_ever = 0; restore_attempted = 0; restore_verified = 0; states_verified = 0; bytes_returned = 0; xbox_ref_log_open_for_target(report_path, xgd1_drive_letter_from_device(device)); printf("[XGD1-RAW-ID] Starting cache-aligned raw-sector ID geometry probe.\n"); printf("[XGD1-RAW-ID] Requires modified GDR-8050L firmware with HIT 0xE7 memdump support.\n"); printf("[XGD1-RAW-ID] No ISO or firmware-write command will be issued.\n"); if (hDevice == INVALID_HANDLE_VALUE || hDevice == NULL) { printf("[XGD1-RAW-ID] Fatal: invalid drive handle.\n"); if (owns_handle) xbox_ref_log_close(); return 1; } if (!EnsureDriveReady(hDevice, 30000)) { printf("[XGD1-RAW-ID] Fatal: media did not become ready.\n"); if (owns_handle) xbox_ref_log_close(); return 1; } entry_capacity = GetTotalSectors(hDevice); entry_game_view = xgd1_capacity_is_game(entry_capacity) ? 1 : 0; printf("[XGD1-RAW-ID] Entry READ CAPACITY: %u sectors (%s).\n", entry_capacity, entry_game_view ? "game view" : "locked/video or unknown view"); DeviceIoControl(hDevice, FSCTL_UNLOCK_VOLUME, NULL, 0, NULL, 0, &bytes_returned, NULL); printf("[XGD1-RAW-ID] Cycling tray to establish locked/video view.\n"); AutomateTrayCycle(hDevice); locked_state.capacity = xgd1_refresh_ready_capacity(hDevice); locked_state.capacity_valid = locked_state.capacity != 0U; locked_state.state_verified = (locked_state.capacity_valid && xgd1_capacity_is_locked(locked_state.capacity)) ? 1 : 0; printf("[XGD1-RAW-ID] Locked/video READ CAPACITY: %u sectors; verified=%s.\n", locked_state.capacity, locked_state.state_verified ? "yes" : "no"); if (DeviceIoControl(hDevice, FSCTL_LOCK_VOLUME, NULL, 0, NULL, 0, &bytes_returned, NULL)) { volume_lock_acquired = 1; volume_lock_ever = 1; printf("[XGD1-RAW-ID] Windows volume lock acquired.\n"); } else { printf("[XGD1-RAW-ID][WARN] Windows volume lock was not acquired.\n"); } SetDriveSpeedMax(hDevice); xgd1_capture_state(hDevice, &locked_state, xgd1_locked_points, (uint32_t)(sizeof(xgd1_locked_points) / sizeof(xgd1_locked_points[0]))); printf("[XGD1-RAW-ID] Applying the full Xbox handshake to establish game view.\n"); UnlockDrive(hDevice); unlocked_state.capacity = xgd1_refresh_ready_capacity(hDevice); unlocked_state.capacity_valid = unlocked_state.capacity != 0U; unlocked_state.state_verified = (unlocked_state.capacity_valid && xgd1_capacity_is_game(unlocked_state.capacity)) ? 1 : 0; printf("[XGD1-RAW-ID] Unlocked/game READ CAPACITY: %u sectors; verified=%s.\n", unlocked_state.capacity, unlocked_state.state_verified ? "yes" : "no"); xgd1_capture_state(hDevice, &unlocked_state, xgd1_unlocked_points, (uint32_t)(sizeof(xgd1_unlocked_points) / sizeof(xgd1_unlocked_points[0]))); if (volume_lock_acquired) { DeviceIoControl(hDevice, FSCTL_UNLOCK_VOLUME, NULL, 0, NULL, 0, &bytes_returned, NULL); volume_lock_acquired = 0; } if (!entry_game_view && entry_capacity != 0U) { restore_attempted = 1; printf("[XGD1-RAW-ID] Restoring entry locked/video state with a final tray cycle.\n"); AutomateTrayCycle(hDevice); restored_capacity = xgd1_refresh_ready_capacity(hDevice); restore_verified = (restored_capacity != 0U && xgd1_capacity_is_locked(restored_capacity)) ? 1 : 0; } else { restored_capacity = GetTotalSectors(hDevice); restore_verified = (entry_game_view && xgd1_capacity_is_game(restored_capacity)) ? 1 : 0; } states_verified = (locked_state.state_verified && unlocked_state.state_verified) ? 1 : 0; report_ok = xgd1_write_report(report_path, device, entry_capacity, entry_game_view, volume_lock_ever, &locked_state, &unlocked_state, restore_attempted, restored_capacity, restore_verified); if (owns_handle) { printf("[XGD1-RAW-ID] Issuing STOP UNIT / spin-down after probe... "); printf("%s\n", StopDriveUnit(hDevice) ? "OK" : "FAILED"); CloseDrive(hDevice); xbox_ref_log_close(); } if (!report_ok) return 1; if (!states_verified) { printf("[XGD1-RAW-ID] Probe report is partial because one or more states were not verified.\n"); return 1; } if (!locked_state.geometry_verified || !unlocked_state.geometry_verified) { printf("[XGD1-RAW-ID] Geometry validation failed: locked failures=%u, unlocked failures=%u.\n", locked_state.geometry_validation_failures, unlocked_state.geometry_validation_failures); return 1; } printf("[XGD1-RAW-ID] Probe complete. All selected raw IDs match the current XGD1 output geometry.\n"); return 0; } int xbox_ref_xgd1_raw_id_probe_with_handle(void *native_handle, const char *device, const char *report_path) { return xgd1_raw_id_probe_core((HANDLE)native_handle, device, report_path, FALSE); } int xbox_ref_xgd1_raw_id_probe(const char *device, const char *report_path) { char drive_letter; HANDLE hDevice; drive_letter = xgd1_drive_letter_from_device(device); if (!drive_letter) { printf("[XGD1-RAW-ID] Fatal: could not parse drive letter from device.\n"); return 1; } hDevice = OpenDrive(drive_letter); if (hDevice == INVALID_HANDLE_VALUE) { printf("[XGD1-RAW-ID] Fatal: cannot open drive %c:. Run as Administrator.\n", drive_letter); return 1; } return xgd1_raw_id_probe_core(hDevice, device, report_path, TRUE); } #else int xbox_ref_xgd1_raw_id_probe_with_handle(void *native_handle, const char *device, const char *report_path) { (void)native_handle; (void)device; (void)report_path; return 1; } int xbox_ref_xgd1_raw_id_probe(const char *device, const char *report_path) { (void)device; (void)report_path; return 1; } #endif