https://www97.zippyshare.com/v/JdPLbnUB/file.html игра USA позже свафлирую фуллрусс версию!раз уж на новом методе апокалипС ЗАРАБОТАЛ!!! FULLRUSS https://www12.zippyshare.com/v/vi09pdJ5/file.html

mast1c0re: Взлом PS4/PS5 через эмулятор PS2 — Часть 1 — Побег Первоначальная публикация: 14 сентября 2022 г. В этой статье я расскажу, как мне удалось избежать эмулятора PS2, разработанного для PlayStation 4. См. также часть 2 (будет опубликована), описывающую следующую часть цепочки эксплойтов и ответ PlayStation на исследование.

Для нетерпеливых ниже в этой статье представлено демонстрационное видео для первой части этой цепочки .

Обратите внимание, что эти уязвимости были обнаружены и зарегистрированы еще в сентябре 2021 года, но я смог опубликовать их только сейчас.

вступление Прошло много времени с тех пор, как я в последний раз работал над каким-либо современным взломом PlayStation, но с выпуском PS5 и введением программы PlayStation Bug Bounty у меня возникла мотивация попытаться использовать какую-то цепочку эксплойтов, которая будет работать на PS5.

Я решил атаковать эмулятор PS2, который оказался очень привлекательной целью по ряду причин:

Выход из него даст возможность запускать пиратские игры для PS2 на PS4, PS5 и, возможно, на облачном игровом сервисе PSN.

Это особенно ценно, потому что доступ к запуску только подмножества официально доступных игр для PS2 на этих платформах оплачивается на самом высоком уровне новой службы подписки PlayStation.

Эмулятор PS2 — один из последних оставшихся привилегированных JIT-кодов на PS5.

Sony агрессивно удалила привилегированную поверхность атаки JIT из PS5, отключив JIT как в веб-браузере, так и в проигрывателе BluRay . Поскольку эмулятор PS2 на самом деле является игрой для PS4, которая работает из-за обратной совместимости, они не могли вносить изменения в программное обеспечение, поэтому его привилегию JIT пришлось сохранить.

Наличие привилегии JIT означает, что полная компрометация эмулятора, включая совместный процесс компилятора, даст возможность запускать полностью произвольный нативный код (а не только ROP) на PS4/PS5 без необходимости эксплойта ядра. Это было бы особенно удобно на PS5, потому что недавно введенный гипервизор обеспечивает нечитаемость кодовых страниц (как пользовательской, так и ядра), и у меня нет терпения снова пытаться написать слепой эксплойт ядра, как я это делал при портировании . BadIRET на PS4 без дампа ядра.

При выполнении произвольного кода в игровом процессе PS4 в этом контексте может запускаться самодельное программное обеспечение, включая JIT-оптимизированные эмуляторы, и, возможно, даже некоторые пиратские коммерческие игры для PS4.

В соответствии с моделью безопасности PlayStation его практически невозможно исправить .

Поскольку PlayStation не может нести ответственность за безопасность сторонних игр (частично тех, которые статически связаны со старыми версиями WebKit), их модель безопасности работает на основе предположения, что игры скомпрометированы, и вместо этого фокусируется на защите более высоких привилегированных уровней платформа (ядро и гипервизор на PS5).

В результате они не разработали консоль с механизмами для принудительного применения исправлений для игр. Вы можете просто запустить физическую игру, не проверяя наличие обновлений, или даже понизить версию цифровых игр , передав трафик PSN (который является просто HTTP из соображений экономии).

Моя интерпретация заключается в том, что существование игр с особыми привилегиями, таких как JIT эмулятора PS2, в корне нарушает их собственную модель безопасности, поскольку оставляет привилегированный код без доступных механизмов для исправления потенциальных будущих уязвимостей.

Хотя термин «неисправляемый» не совсем точен с технической точки зрения, я чувствую себя комфортно, используя этот термин, потому что официальный ответ PlayStation спустя год после сообщения заключался в том, что они решили не пытаться исправлять эту цепочку. Подумайте об этом с их стороны: если они рассмотрят возможность включения старых версий эмуляторов PS2 в более поздние обновления прошивки, это разрушит ожидания потребителей, что они могут воспроизводить диски в автономном режиме. Бинарное исправление каждой версии эмулятора PS2 вручную и объединение их с исправлениями операционной системы вместо этого было бы для них практически невыполнимым.

Анатомия эмулятора PS2 Эмулятор разделен на 2 отдельных процесса: основной процесс приложения ( eboot.bin) и его дочерний процесс компилятораps2-emu-compiler.self ( ).

Ядро назначает каждому из этих процессов различные привилегии, реализованные путем проверки результата функций sceSblACMgrIsJitApplicationProcessи sceSblACMgrIsJitCompilerProcess(имена, взятые из тех времен, когда ядра PS4 все еще имели символы). Компилятор может писать код, а приложение может выполнять код.

Раньше проверка была реализована неправильно , и процесс браузерного приложения на прошивке PS4 1.76 мог создавать как записываемые сопоставления, так и исполняемые сопоставления, но в настоящее время нам нужно было бы контролировать оба процесса, чтобы иметь возможность производить полностью произвольный код, и чтобы будет целью этой цепочки.

Точка входа для выполнения кода PS2 Наша цепочка эксплойтов начнется с использования игры для PS2 для выполнения кода в эмуляторе либо с помощью эксплойта сохранения игры, либо с помощью эксплойта, запускаемого исключительно контроллером.

Эксплуатируемые уязвимости сохранения PS2 найти несложно; например, см. декомпиляцию GTA , показывающую копию с карты памяти в буфер фиксированного размера с размером, предоставленным сохранением. С помощью одного из этих эксплойтов файл сохранения PS4, содержащий созданную карту памяти PS2, может быть зашифрован и подписан для любого PSN-ID любым пользователем взломанной PS4 на любой прошивке (или только ПК, если у него есть декапированные ключи SAMU), и затем импортируется на целевую PS4/PS5 с помощью функции импорта сохранения USB в настройках.

Эксплойт, запускаемый контроллером, был бы менее практичным, за исключением того, что его можно было бы использовать, не требуя функции импорта сохранения USB, которая зависит от входа в PSN (поскольку сохранения шифруются для каждой учетной записи) и истекает по тайм-ауту. PS5 после слишком долгого отсутствия в сети.

Я немного поискал игры для PS2, доступные на PS4, которые можно было бы использовать таким образом, и обнаружил, что Dark Cloud будет (существует известная ошибка, из- за которой перемещение курсора и нажатие X в одном и том же кадре в меню предметов позволяет вам забрать элемент из недоступной памяти, что приводит к эксплуататорскому поведению), но, к сожалению, он получил только цифровую версию PS4, а не версию на физическом диске (поэтому это не помогает устранить требование PSN).

Для своей цепочки я остановился на Okage Shadow King , который имеет типичный переполнение буфера стека, если вы расширяете имя игрока/города.

Ошибка эмулятора Получив выполнение кода PS2 из любой из 3 идентифицированных игр для PS2, я начал обратное проектирование самого эмулятора. Самое первое, на что я обратил внимание, это обратные вызовы чтения/записи памяти; Вы можете видеть на ps2tek , что некоторые адреса управляют различными аппаратными функциями PS2, поэтому для доступа к ним требуется специальный код, чтобы эмулятор обрабатывал эти запросы.

Например, вы можете увидеть, как порт ядра Linux PS2 выполняет команды CDVD S, используя эти регистры ввода-вывода. Чтобы передать аргументы команде S, они записываются байт за байтом в регистр SCMD_SEND/ ( ), и есть аналогичный регистр, используемый для предоставления аргументов командам CDVD N ( ).SCMD_STATUS0x1F4020050x1f402017

Давайте посмотрим, как эмулятор обрабатывает байтовые записи в эти регистры. Ниже приведены фрагменты декомпиляции функции 0x479584в электронной загрузке обновления 1.01 Okage Shadow King:

case 0x1f402005: // N_STATUS currentbufferoffset = (ulong)nstatusindex; nstatusindex = nstatusindex + 1; (&nstatusbuffer)[currentbufferoffset] = b; bVar3 = DAT_014977d5; break;

...

case 0x1f402017: // S_STATUS currentbufferoffset = (ulong)sstatusindex; sstatusindex = sstatusindex + 1; (&sstatusbuffer)[currentbufferoffset] = b; bVar3 = DAT_014977d5; break;

Это довольно очевидная ошибка: ни одна из этих буферизованных операций не проверяет границы.

Другими словами, простая последовательная запись в любой из этих регистров более 16 раз приведет к переполнению буферов состояния произвольными байтами; мы назовем этот Primitive 1 , и, отправив недопустимые команды для сброса индекса, мы сможем использовать его повторно:

void resetSStatusIndex(void) { // Submit invalid command! *S_CMD = 0; // Wait for completion (busy flag to be cleared) while((*S_STATUS) & 0x80);

// Flush S command result while(!((*S_STATUS) & 0x40)) (void)S_IN; }

void sStatusBufferOverflow(void *overflow, unsigned int overflowSize) { resetSStatusIndex();

// Fill the buffer for(int i = 0; i < 0x10; i++) { *S_STATUS = 0; }

// Begin writing out-of-bounds for(int i = 0; i < overflowSize; i++) { *S_STATUS = ((unsigned char *)overflow)[i]; } }

Обратите внимание, что другие регистры, такие как 0x1f402016(команда CDVD S) и 0x1f402004(команда CDVD N), также уязвимы к переполнению буфера, поэтому в общей сложности существует как минимум 4 варианта подобных уязвимостей, но, поскольку эмулятор почти неисправим, и щедрость PlayStation программа перестала принимать отчеты о выходе из эмулятора PS2 после первого, нет причин искать или анализировать другие ошибки.

Примитив 2 — последовательная перезапись для перезаписи произвольного индекса Чтобы начать эксплуатировать эту ошибку, давайте выложим адреса вышеупомянутых переменных, чтобы мы могли видеть, какие повреждения мы можем вызвать из-за переполнения:

0x897810 n status buffer (16-bytes) 0x897820 s status buffer (16-bytes) (0x60 bytes of other variables) 0x897890 n status index (4-bytes) (0xc bytes of other variables) 0x8978A0 s status index (4-bytes)

Переполнив буфер состояния S, мы очень быстро начнем перезаписывать индекс состояния N.

Оглядываясь назад на обработку записи байта в регистр состояния N, вы заметите, что как только мы управляем индексом состояния N, этот путь кода позволит нам записать произвольный входной байт в буфер состояния N с произвольной скоростью 4-. byte unsigned index (а затем увеличить индекс на 1):

case 0x1f402005: // N_STATUS currentbufferoffset = (ulong)nstatusindex; nstatusindex = nstatusindex + 1; (&nstatusbuffer)[currentbufferoffset] = b; // <-- Controlled byte write to controlled 4-byte unsigned index bVar3 = DAT_014977d5; break;

Мы назовем это Primitive 2 .

void resetNStatusIndex(void) { // Submit invalid command! *N_CMD = 0;

// Wait for completion (busy flag to be cleared) while((*N_STATUS) & 0x80); }

void setOOBindex(unsigned int index) { resetNStatusIndex();

unsigned char overflow[0x60 + sizeof(index)] = {}; // Overwrite N status index overflow[0x60 + 0] = index >> 0; overflow[0x60 + 1] = index >> 8; overflow[0x60 + 2] = index >> 16; overflow[0x60 + 3] = index >> 24;

sStatusBufferOverflow(overflow, sizeof(overflow)); }

void writeToOOBIndex(unsigned char v) { // Perform OOB write to N status index and advance index *N_STATUS = v; }

void writeOOB1(unsigned int index, unsigned char v) { setOOBindex(index); writeToOOBIndex(v); }

// ... writeOOB2, writeOOB4, writeOOB8, writeOOBN ...

Поскольку запись выполняется относительно статически выделенного буфера в области данных чтения-записи eboot, ASLR не влияет на нашу способность повреждать любые другие достижимые цели в сопоставленных разделах eboot, но только в демонстрационных целях: если мы временно отключим ASLR , мы можем использовать его для создания небольшого Proof-Of-Concept, который записывает на собственный адрес PS4 0x41414141из контекста выполнения кода PS2:

// Write 0x41 to native PS4 address 0x41414141 (if ASLR is disabled, N status buffer will be at 0x897810) writeOOB1(0x41414141 - N_STATUS_BUFFER, 0x41);

Как и в случае с первым примитивом, мы можем делать это неоднократно, что приводит к чрезвычайно мощному примитиву: возможность повреждать любые байты в области данных для чтения-записи eboot, которые идут после буфера состояния (поскольку индекс равен unsigned), до контролируемых значений, без каких-либо значительных побочных эффектов коррупции.

Давайте просмотрим память после этого буфера состояния N, чтобы увидеть, что мы можем испортить с помощью этого нового примитива.

Неиспользуемый примитив — произвольное чтение/запись путем переназначения ОЗУ IOP Если мы вернемся к обработчикам чтения/записи памяти, мы увидим, что код, обрабатывающий адреса виртуальной памяти, поддерживаемые областями оперативной памяти, реализован с использованием указателей. Например, когда PS2 выполняет 32-битную запись в ОЗУ IOP, эмулятор в конечном итоге выполнит запись по своему собственному iopramуказателю:

*(unsigned int *)(iopram + (ulong)address) = value;

Поскольку этот iopramуказатель ( 0xAF6E38) расположен после буфера состояния N, он доступен с помощью примитива повреждения 2.

Перезаписывая его, мы эффективно переназначим внутренний указатель эмулятора на ОЗУ IOP (из его обычного значения фиксированного адреса 0x9000000000), так что любые операции чтения/записи, которые мы делаем из PS2 в область ОЗУ IOP, будут перенаправлены на наш новый адрес.

Приведенный ниже PoC демонстрирует использование этого нового примитива для записи на собственный адрес, который мы не могли получить раньше с помощью 32-битной индексации примитива 2:

// Remap IOP from 0x0000009000000000 -> 0x0000004100000000 writeOOB1(IOP_RAM_POINTER - N_STATUS_BUFFER + 4, 0x41);

// Write 0x61 to 0x4100000000 volatile unsigned char *iop_ram = (void *)0x1C000000; *iop_ram = 0x61;

Точно так же мы добились произвольного собственного чтения/записи из кода PS2!

На практике этот примитив не очень надежен, потому что эмулятор запускает несколько потоков, которые могут начать вести себя неожиданно, если мы перенаправим этот указатель, поэтому я не стал использовать его в финальном эксплойте. Давайте продолжим поиск других объектов коррупции.

Примитив 3 — перенаправленный вызов обработчика чтения Вернемся снова к обработчикам чтения/записи памяти. Мы увидим, что есть также несколько таблиц переходов/массивов указателей на функции, которые вызываются, когда мы обращаемся к некоторым из отображаемых в память регистров ввода-вывода.

Например, если мы отправим чтение в 0x10000000, приведенный ниже код будет достигнут с помощью rax == 0, и он вызовет первый указатель функции в ioRegisterReadHandlersмассиве:

0x6E4098: LEA RAX, [ioRegisterReadHandlers] ... 0x6E40B2: CALL qword ptr [RCX + RAX*0x1]

Используя примитив 2, мы можем преобразовать весь этот указатель функции в произвольный 64-битный адрес.

Поскольку эта программа не была скомпилирована с включенным CFI , это позволит нам инициировать вызов нашего поврежденного указателя функции путем чтения из 0x10000000, и в eaxконечном итоге регистр будет возвращен в качестве результата обратно в нашу инструкцию чтения PS2; мы назовем этот Primitive 3 :

// Redirecting the emulator's IO read function pointer lets us call an arbitrary address and get back whatever eax holds after it returns unsigned int callGadgetAndGetResult(unsigned int gadget) { unsigned int ioReadFunctionPointerIndex = IO_REGISTER_READ_HANDLERS - N_STATUS_BUFFER; volatile unsigned int *io = (void *)0x10000000;

// Corrupt the function pointer writeOOB4(ioReadFunctionPointerIndex, gadget);

// Call the corrupted function pointer, return the result return *io; }

Теперь мы добились произвольного перенаправления потока управления (с возможностью чтения возвращаемого значения)!

Примитив 4 — утечка перезаписи указателя частичной функции На данный момент игра почти окончена; хотя мы можем перенаправить поток управления, мы еще не знаем адрес чего-либо, к которому нужно перейти.

Хотя я считал, что возможно обойти ASLR без каких-либо программных уязвимостей, реализуя атаку по побочному каналу в стиле призрака с использованием высокоточных таймеров , к которым PS2 предоставляет доступ, оказалось, что проще просто продолжать использовать примитивы. Я уже установил.

Я использовал метод частичной перезаписи указателя. Это использует тот факт, что базовые адреса модулей выровнены по страницам, поэтому не являются полностью случайными. В частности, размер страницы PS4 равен 0x4000 = 2^14, поэтому младшие 14 бит (1,75 байта) любого кодового адреса всегда будут одинаковыми.

Возьмем первый указатель обработчика чтения регистра ввода-вывода; он указывает на очень маленькую функцию с 0x31разницей всего в байтах между ее первой и последней инструкциями ( 0x615381 - 0x615350):

0000000000615350 add edi, 0xf0000000 ... 0000000000615381 ret

Мы точно знаем, что младший байт адреса этой функции всегда будет 0x50. Это делает повреждение только этого одного байта полностью детерминированным, т. е. изменяя его на, 0x51мы всегда будем указывать на смещение 1 байт в функции и т. д., несмотря на ASLR. Давайте добавим параметр к предварительно установленной callGadgetAndGetResultфункции, чтобы разрешить частичную перезапись указателя:

// Redirecting the emulator's IO read function pointer lets us call an arbitrary address and get back whatever eax holds after it returns unsigned int callGadgetAndGetResult(unsigned int gadget, unsigned int gadgetSize) { unsigned int ioReadFunctionPointerIndex = IO_REGISTER_READ_HANDLERS - N_STATUS_BUFFER; volatile unsigned int *io = (void *)0x10000000;

// Corrupt the function pointer if(gadgetSize == 4) writeOOB4(ioReadFunctionPointerIndex, gadget);

// Overwrite just the least significant byte, for before we've defeated ASLR else if(gadgetSize == 1) writeOOB1(ioReadFunctionPointerIndex, gadget);

// Call the corrupted function pointer return *io; }

Итак, куда мы перенаправляем указатель на функцию? Зная, что все, что находится внутри eax, будет возвращено коду PS2, инициировавшему чтение памяти, нам нужен какой-то код, который оставит указатель внутри eax... Если вы помните, как вызывался указатель на функцию, raxрегистр использовался для хранения функции. адрес указателя, поэтому нам не нужно, чтобы он что-то делал, просто сразу возвращайтесь!

unsigned int getEbootDiff(void) { // Corrupt the least significant byte from 0x50 -> 0x81 (0x60 -> 0x91 in Okage), to point to a ret instruction // this will make the call return without updating eax (it will still hold the address of the function pointer itself) unsigned int ioFunctionPointerAddress = callGadgetAndGetResult(PARTIAL_POINTER_OVERWRITE_RET, 1);

// This is the difference from the address of the function pointer that we see during static analysis in Ghidra unsigned int ebootDiff = ioFunctionPointerAddress - IO_REGISTER_READ_HANDLERS;

return ebootDiff; }

С помощью просочившегося адреса мы можем получить адрес чего-либо еще в любом из отображаемых разделов двоичного файла eboot (поскольку все они сливаются). Еще одно полезное замечание для нас заключается в том, что, поскольку это первое, что отображается в процессе, их адреса гарантированно умещаются в пределах 32-бит; ниже образец:

eboot executable pages - 0x400000 eboot read-only pages - 0x750000 eboot read-write pages - 0x768000 eboot read-write pages - 0x76c000

Утечка указателя стека Теперь, когда мы победили ASLR электронной загрузки, мы больше не ограничены выполнением только гаджетов в пределах досягаемости, используя трюк с частичной перезаписью указателя.

Давайте попробуем найти гаджет, который может слить адрес стека (который нам понадобится позже, чтобы изящно вернуть его после завершения нашей цепочки ROP).

Я использовал инструмент rp++ для создания списков гаджетов ROP с первых дней PS4 (привет 0vercl0k ). В этом случае я искал espи определил это:

0x6BE323: add eax, esp ; ret

Мы уже знаем, какое начальное eaxзначение будет в момент вызова гаджета (из описанной выше утечки частичной перезаписи указателя), поэтому мы можем просто вычесть его, чтобы получить esp, а затем rspпредсказуемо esp | 0x700000000(еще одна слабость реализации PS4 ASLR ):

// "Runtime_EE start" stack page base address unsigned long getStackBase(unsigned int ebootDiff) { #define STACK_DIFF (0x7EECAFAE8 - 0x7EEC90000) unsigned int add_eax_esp_ret = 0x6BE323 + ebootDiff;

unsigned long stackLeak = (callGadgetAndGetResult(add_eax_esp_ret, 4) - (IO_REGISTER_READ_HANDLERS + ebootDiff)) | 0x700000000;

return stackLeak - STACK_DIFF; }

Примитив 5 — перенаправленный вызов обработчика записи До этого момента мы успешно использовали примитив 3, наш примитив перенаправления потока управления, для выполнения отдельных гаджетов (таких как add eax, esp). Нашим следующим шагом будет выполнение цепочки ROP из нескольких гаджетов, что обычно делается путем поворота указателя стека (перенаправление rspтуда, где мы контролируем содержимое).

Есть много различных потенциальных маршрутов на выбор. Я решил поэкспериментировать с перенаправлением обработчиков записи. В то время как обработчики чтения вернули нам результат вызванного гаджета, обработчик записи может быть вызван с произвольным аргументом в esiрегистре (значение, которое записывает инструкция PS2), что может быть полезно для контроля. Назовем этот Примитив 5 :

// Redirecting the emulator's interrupt register write handler lets us call an arbitrary address with an arbitrary argument in edi register void callGadgetWithArgument(unsigned int gadget, unsigned int argument) { unsigned int interruptRegisterWriteFunctionPointerIndex = INTERRUPT_WRITE_HANDLERS - N_STATUS_BUFFER; volatile unsigned int *interruptRegisters = (void *)0x1F801000;

// Corrupt jump target writeOOB4(interruptRegisterWriteFunctionPointerIndex, gadget);

// Jump to the corrupted target *interruptRegisters = argument; }

Поворот стека Я не мог найти каких-либо простых гаджетов для прямого поворота стека с помощью примитива 5 (например mov esp, esi; ret), но смог придумать немного более сложный набор гаджетов:

//0x7E677C: push rsi ; add bh, cl ; call qword [rsi+0x3B] ; (1 found) unsigned int push_rsi_call_deref_rsi_plus_3b = 0x7E677C + ebootDiff;

//0x49A2E6: pop rcx ; fld st0, st5 ; clc ; pop rsp ; ret ; (2 found) unsigned int pop_rcx_pop_rsp_ret = 0x49A2E6 + ebootDiff;

unsigned int pop_rsp_ret = 0x49A2EA + ebootDiff;

// Let's write initial chain to some free space unsigned int initialROP_address = FREE_SPACE + ebootDiff;

setOOBindex(FREE_SPACE - N_STATUS_BUFFER);

writeOOB8_presetIndex(pop_rsp_ret); writeOOB8_presetIndex(toNative(ropChain));

setOOBindex(FREE_SPACE - N_STATUS_BUFFER + 0x3b);

writeOOB8_presetIndex(pop_rcx_pop_rsp_ret);

callGadgetWithArgument(push_rsi_call_deref_rsi_plus_3b, initialROP_address);

Выполнение начнется с push_rsi_call_deref_rsi_plus_3bгаджета, который отправит rsi(адрес нашей начальной ROP-цепочки) и фиктивный адрес возврата, а затем перейдет к pop_rcx_pop_rsp_retгаджету. Этот второй гаджет вставит фиктивный адрес возврата, rcxа затем повернет стек к нашей начальной цепочке ROP!

Поскольку исходная цепочка ROP должна иметь указатель на вторую половину гаджета поворота стека по адресу offset 0x3b, мы просто используем его, чтобы снова повернуть стек в область, которую мы полностью контролируем без каких-либо ограничений (основная цепочка ROP). Достигнута произвольная ROP!

Краткое изложение пути к ROP Консолидированный план для достижения ROP заключается в настройке всех вышеупомянутых примитивов, кратко изложенных ниже:

Примитив 1 (начальная ошибка):

Запись в регистр состояния S CDVD неоднократно приводит к переполнению буфера состояния S, Примитив 2 (запись произвольного индекса):

Используйте примитив 1, чтобы повредить индекс состояния N, Запись в регистр состояния CDVD N теперь вызывает запись произвольного байта в произвольный индекс, Примитив 3 (произвольный вызов с результатом):

Используйте примитив 2, чтобы перезаписать указатель функции обработчика чтения ввода-вывода, Чтение из этого отображаемого в память регистра ввода-вывода теперь вызывает произвольный адрес и дает нам результат: Примитив 4 (победить eboot ASLR):

Используйте примитив 3, но только частичный указатель-перезапись адреса, перенаправляя его на retинструкцию функции, Этот примитив теперь вернет нам адрес в eboot, Примитив 5 (произвольный вызов с произвольным аргументом):

Используйте примитив 2, чтобы перезаписать указатель функции обработчика записи ввода-вывода, Запись в этот отображенный в память регистр ввода-вывода теперь вызывает произвольный адрес с контролируемым esiрегистром, Затем использовать их так:

Используйте примитив 4 для утечки указателя eboot, который мы будем использовать в последующих шагах для поиска гаджетов в исполняемой секции eboot, Используйте примитив 3, чтобы вызвать гаджет раскрытия указателя стека и получить результат, Создайте начальную цепочку ROP (просто разворот стека к основной цепочке ROP); используйте примитив 2, чтобы записать его в некоторое свободное пространство в разделе данных eboot, чтобы его адрес соответствовал 32-битам, Создайте основную цепочку ROP, которая завершается восстановлением исходных регистров, сохраненных вызываемым пользователем, включая значение указателя стека, которое мы просочили на шаге 2. Используйте примитив 5 для вызова пары гаджетов сводки стека (с rsiуказанием на начальную цепочку ROP), Это приведет к выполнению нашей основной цепочки ROP, а затем изящному возвращению к выполнению PS2. Обратите внимание, что первые 3 шага являются частью процесса установки, который необходимо выполнить только один раз; для выполнения последующих цепочек ROP нам просто нужно записать их поверх последней цепочки, а затем выполнить их, записав в предварительно поврежденный обработчик ввода-вывода с отображением памяти (шаги 4–5).

Загрузка пользовательских игр для PS2 Теперь, когда мы успешно избежали эмулятора PS2, естественно, первое, что нужно попробовать сделать с ним, — это загрузить другую игру.

Есть несколько вариантов получения внешнего файла игры:

Объединение его в файл сохранения изначально кажется очевидным выбором, но поскольку игры для сохранения PS4 имеют ограничение на размер файла (я думаю, он был 1 ГБ, но затем немного увеличился для выпуска Cyberpunk), этот подход не будет работать для многих игр для PS2.

Вероятно, вы также можете копировать игры с USB-накопителя, вручную перенося их через реализацию USB и FAT (поскольку mountсистемные вызовы ограничены), как я сделал с моим родным эмулятором GameBoy Proof-of-Concept для PS4 1.76 WebKit и эксплойтом JIT.

Я решил просто загружать нужную игру на консоль по локальной сети при каждом запуске. Мое элементарное доказательство концепции без сжатия и через Wi-Fi занимает почти 20 минут для 1,3-гигабайтной игры, такой как Klonoa 2, но это, безусловно, можно улучшить.

Как только файл ISO становится доступным в файловой системе, остается только найти код эмулятора, ответственный за открытие файла диска ( /app0/images/disc01.iso), установив точку останова на sceKernelOpen, используя эксплойт для его вызова (с пройденным путем, например ./../bla/boot.iso, для обхода некоторых внутренняя проверка), устранение любых оставшихся повреждений и, наконец, вызов кода PS2 LoadExecPS2для загрузки ELF на недавно смонтированном виртуальном диске для запуска новой игры.

Обратите внимание, что эмулятор был настроен специально для игры, с которой он был связан (в данном случае Okage Shadow King), и хотя некоторые настройки могут быть изменены во время выполнения с помощью эксплойта, ожидайте, что совместимость с другими играми в целом будет неравномерной, хотя по крайней мере, Klonoa 2, кажется, работает нормально (в остальном игра за 40 долларов ).

Часть 1 Заключение Пиратство PS2 — забавный подтекст, особенно возможность раскрыть его, несмотря на отсутствие патча, но моей главной целью было запустить родные доморощенные приложения.

Что касается этой цели, побег от эмулятора — это только первая половина цепочки; мы пока не можем писать произвольный нативный код, так как процесс нашего приложения имеет разрешение отображать только общую память JIT как исполняемую, а не записываемую.

Технически мы могли бы написать «улучшенные для PS4» домашние приложения для PS2, которые могли бы использовать любые нативные функции PS4 и, таким образом, могли бы вести себя по существу так же, как обычные домашние приложения для PS4 (доступ к сенсорной панели контроллера PS4 и т. д.), но я действительно хотел получить полностью произвольный код. исполнение для более практичной домашней среды. Это делает следующий шаг атаки на процесс компилятора: mast1c0re — Взлом PS4/PS5 через эмулятор PS2 — Часть 2 — Выполнение произвольного кода .

Спасибо flatz, balika011, theflow0, курица(и), PlayStation