Приветствую,
Моя очень старая мечта сбылась я написал модуль-отладчик, с
помощью которого можно отлаживать SNES (Super Nintendo)
игры прямо в IDA! Если интересно узнать, как я это
сделал, "прошу под кат" (как тут принято говорить).
Введение
Я давно увлекаюсь реверс-инжинирингом. Сначала это было просто
хобби, затем стало работой (и при этом хобби никуда не делось).
Только на работе "всё серьёзно", а дома это баловство в
виде обратной разработки игр под ретро-приставки: Sega Mega
Drive / Genesis, PS1, AmigaOS.
Задача обычно стоит следующая: понять как работает игра, если есть
сжатие победить его, понять как строится уровень, как размещаются
враги на уровне и т.д.
За то время, которое прошло с момента, как я начал этим
заниматься, мною было написано несколько удобных и полезных
инструментов для тех, кто хотел реверсить игры на Сегу, Соньку, и
другие платформы.
Мне удалось разреверсить один очень крутой shoot'em-up:
Thunder Force 3 (а именно благодаря этой игре я и
познакомился с Идой). Я написал редактор уровней, разреверсил игру
до исходников на ассемблере, и всё это попутно создавая и улучшая
инструмент, который в последствии и облегчал данную работу
плагин-отладчик сеговских ромов для IDA, который я назвал просто
Gensida (т.к. в основе лежал
один очень популярный эмулятор этой платформы GENS, а точнее его
модификация).
Без эмулятора с отладкой тоже можно создать такой
плагин, но для этого придётся писать отладочный функционал с нуля,
что не всегда хочется делать.
Со временем я узнал, что у Thunder Force 3 есть и
версия для SNES Thunder Spirits, которая имеет
несколько новых уровней и некоторые изменения в интерфейсе. Так
вот, мне захотелось портировать всё это на Сегу, дополнив игру. Но,
знаний как о самой Super Nintendo, так и о том, как её реверсить, у
меня не было. Я пошёл гуглить и понял, что как-то всё плохо с
отладкой у "сеги подороже". На данный момент существует всего ДВА
(!) эмулятора SNES с отладкой, и у одного нет исходников, а второй
второй имеет настолько убогий исходный
код, что я боялся даже с ним работать.
Тем не менее, овладев некоторыми знаниями и умениями, и
переборов желание не ввязываться в такой ужасный код (эмулятора), я
смог написать и Snesida отладчик SNES ромов для
под IDA. И, я считаю, что теперь то уж настал тот момент, когда я
готов рассказать о том, как создать более-менее полноценный
отладчик для этого ревёрсерского инструмента.
Что нам потребуется
Для того, чтобы создать свой плагин-отладчик под Иду, нам
потребуется:
- IDA v7.x
- IDA SDK
- Эмулятор-отладчик (можно и без отладки, главное с исходниками,
которые захочется допилить)
- Thrift (да, я выбрал его за сериализацию и RPC прямо "из
коробки")
- Умение писать на C++
Думаю, список достаточно простой и понятный. Если чего-то из
этого у вас нет, то плагин не получится, увы.
А теперь пишем код
Прежде чем начать, советую ознакомиться со статьёй
"Модернизация IDA Pro. Отладчик для Sega Mega Drive (часть
2)", т.к. многие моменты здесь будут повторяться, но будут и
некоторые новые (т.к. SDK Иды обновляется, и то, что работало
раньше, теперь не применимо).
Собственно, написание любого плагина для IDA всегда начинается с
создания кода-шаблона. Я использую для этого Visual Studio (на
данный момент самой свежей является версия 2019).
Открываем Студию, создаём новый проект DLL, и прописываем в
следующие пути к библиотекам в свойствах Linker для проекта:
- d:\idasdk76\lib\x64_win_vc_32\ это для плагина,
который будет работать с 32-битными приложениями (открываться в
ida.exe)
- d:\idasdk76\lib\x64_win_vc_64\ это для плагина,
который будет работать с 64-битными приложениями (открываться в
ida64.exe)
- Если у вас не Windows и компилятор не Visual Studio, посмотрите
другие имеющиеся папки в d:\idasdk76\lib\
В линкуемые библиотеки добавляем ida.lib. Теперь
создаём пустой cpp-файл, чтобы VS показала свойства C/C++
компилятора и указываем:
- d:\idasdk76\include\ в спискок путей к инклудам
- Меняем
/MDd и /MD на
/MTd и /MT соответственно в свойствах
Code Generation просто, чтобы не зависеть от лишних
библиотек, которые не всегда установлены
__NT__;__IDP__;__X64__; в Preprocessor
Definitions компилятора__EA64__; дополнительно к предыдущим флагам, если
плагин будет работать с 64-битными приложениями- Убираем
SDL Checks с ним будет сложнее писать
код
С подготовкой вроде бы всё. Теперь начнём писать код.
Плагин
Собственно, как вы уже, должно быть, поняли, отладчик для Иды
это тоже плагин, а значит он должен ей как-то идентифицироваться.
Поэтому пишем следующий код:
ida_plugin.cpp
#include <ida.hpp>#include <idp.hpp>#include <dbg.hpp>#include <loader.hpp>#include "ida_plugin.h"extern debugger_t debugger;static bool plugin_inited;static bool init_plugin(void) { return (ph.id == PLFM_65C816);}static void print_version(){ static const char format[] = NAME " debugger plugin v%s;\nAuthor: DrMefistO [Lab 313] <newinferno@gmail.com>."; info(format, VERSION); msg(format, VERSION);}static plugmod_t* idaapi init(void) { if (init_plugin()) { dbg = &debugger; plugin_inited = true; print_version(); return PLUGIN_KEEP; } return PLUGIN_SKIP;}static void idaapi term(void) { if (plugin_inited) { plugin_inited = false; }}static bool idaapi run(size_t arg) { return false;}char comment[] = NAME " debugger plugin by DrMefistO.";char help[] = NAME " debugger plugin by DrMefistO.\n" "\n" "This module lets you debug SNES roms in IDA.\n";plugin_t PLUGIN = { IDP_INTERFACE_VERSION, PLUGIN_PROC | PLUGIN_DBG, init, term, run, comment, help, NAME " debugger plugin", ""};
Здесь мы описываем наш плагин, инициализируем структуру
dbg, т.к. мы отладчик, и указываем, что работаем мы
только с платформой PLFM_65C816 (в моём случае). Более
подробно в статье про отладчик для Сеги.
Следом идёт ida_plugin.h. Тут всё просто константы
для cpp-файла плагина:
#pragma once#define NAME "snesida"#define VERSION "1.0"
Код самого отладчика
Собственно, пока у нас в голове только идея отладчика, и мы ей
горим, всё что мы можем пока написать, это базовый код, который
будем постепенно дополнять. Начиная с этой части, если сравнивать с
предыдущей статьёй, появились значительные изменения в коде и
концепции в написании отладчика, поэтому читаем внимательно:
ida_debug.cpp
#include <ida.hpp>#include <dbg.hpp>#include <auto.hpp>#include <deque>#include <mutex>#include "ida_plugin.h"#include "ida_debmod.h"#include "ida_registers.h"static ::std::mutex list_mutex;static eventlist_t events;static const char* const p_reg[] ={ "CF", "ZF", "IF", "DF", "XF", "MF", "VF", "NF",};static register_info_t registers[] = { {"A", 0, RC_CPU, dt_word, NULL, 0}, {"X", 0, RC_CPU, dt_word, NULL, 0}, {"Y", 0, RC_CPU, dt_word, NULL, 0}, {"D", 0, RC_CPU, dt_word, NULL, 0}, {"DB", 0, RC_CPU, dt_byte, NULL, 0}, {"PC", REGISTER_IP | REGISTER_ADDRESS, RC_CPU, dt_dword, NULL, 0}, {"S", REGISTER_SP | REGISTER_ADDRESS, RC_CPU, dt_word, NULL, 0}, {"P", REGISTER_READONLY, RC_CPU, dt_byte, p_reg, 0xFF}, {"m", REGISTER_READONLY, RC_CPU, dt_byte, NULL, 0}, {"x", REGISTER_READONLY, RC_CPU, dt_byte, NULL, 0}, {"e", REGISTER_READONLY, RC_CPU, dt_byte, NULL, 0},};static const char* register_classes[] = { "General Registers", NULL};static drc_t idaapi init_debugger(const char* hostname, int portnum, const char* password, qstring* errbuf){ return DRC_OK;}static drc_t idaapi term_debugger(void){ return DRC_OK;}static drc_t s_get_processes(procinfo_vec_t* procs, qstring* errbuf) { process_info_t info; info.name.sprnt("bsnes"); info.pid = 1; procs->add(info); return DRC_OK;}static drc_t idaapi s_start_process(const char* path, const char* args, const char* startdir, uint32 dbg_proc_flags, const char* input_path, uint32 input_file_crc32, qstring* errbuf = NULL){ ::std::lock_guard<::std::mutex> lock(list_mutex); events.clear(); return DRC_OK;}static drc_t idaapi prepare_to_pause_process(qstring* errbuf){ return DRC_OK;}static drc_t idaapi emul_exit_process(qstring* errbuf){ return DRC_OK;}static gdecode_t idaapi get_debug_event(debug_event_t* event, int timeout_ms){ while (true) { ::std::lock_guard<::std::mutex> lock(list_mutex); // are there any pending events? if (events.retrieve(event)) { return events.empty() ? GDE_ONE_EVENT : GDE_MANY_EVENTS; } if (events.empty()) break; } return GDE_NO_EVENT;}static drc_t idaapi continue_after_event(const debug_event_t* event){ dbg_notification_t req = get_running_notification(); switch (event->eid()) { case PROCESS_SUSPENDED: break; case PROCESS_EXITED: break; } return DRC_OK;}static drc_t idaapi s_set_resume_mode(thid_t tid, resume_mode_t resmod) // Run one instruction in the thread{ switch (resmod) { case RESMOD_INTO: ///< step into call (the most typical single stepping) break; case RESMOD_OVER: ///< step over call break; } return DRC_OK;}static drc_t idaapi read_registers(thid_t tid, int clsmask, regval_t* values, qstring* errbuf){ if (clsmask & RC_CPU) { } return DRC_OK;}static drc_t idaapi write_register(thid_t tid, int regidx, const regval_t* value, qstring* errbuf){ if (regidx >= static_cast<int>(SNES_REGS::SR_PC) && regidx <= static_cast<int>(SNES_REGS::SR_EFLAG)) { } return DRC_OK;}static drc_t idaapi get_memory_info(meminfo_vec_t& areas, qstring* errbuf){ memory_info_t info; info.start_ea = 0x0000; info.end_ea = 0x01FFF; info.sclass = "STACK"; info.bitness = 0; info.perm = SEGPERM_READ | SEGPERM_WRITE; areas.push_back(info); // Don't remove this loop for (int i = 0; i < get_segm_qty(); ++i) { segment_t* segm = getnseg(i); info.start_ea = segm->start_ea; info.end_ea = segm->end_ea; qstring buf; get_segm_name(&buf, segm); info.name = buf; get_segm_class(&buf, segm); info.sclass = buf; info.sbase = get_segm_base(segm); info.perm = segm->perm; info.bitness = segm->bitness; areas.push_back(info); } // Don't remove this loop return DRC_OK;}static ssize_t idaapi read_memory(ea_t ea, void* buffer, size_t size, qstring* errbuf){ return size;}static ssize_t idaapi write_memory(ea_t ea, const void* buffer, size_t size, qstring* errbuf){ return size;}static int idaapi is_ok_bpt(bpttype_t type, ea_t ea, int len){ switch (type) { case BPT_EXEC: case BPT_READ: case BPT_WRITE: case BPT_RDWR: return BPT_OK; } return BPT_BAD_TYPE;}static drc_t idaapi update_bpts(int* nbpts, update_bpt_info_t* bpts, int nadd, int ndel, qstring* errbuf){ for (int i = 0; i < nadd; ++i) { ea_t start = bpts[i].ea; ea_t end = bpts[i].ea + bpts[i].size - 1; bpts[i].code = BPT_OK; } for (int i = 0; i < ndel; ++i) { ea_t start = bpts[nadd + i].ea; ea_t end = bpts[nadd + i].ea + bpts[nadd + i].size - 1; bpts[nadd + i].code = BPT_OK; } *nbpts = (ndel + nadd); return DRC_OK;}static ssize_t idaapi idd_notify(void*, int msgid, va_list va) { drc_t retcode = DRC_NONE; qstring* errbuf; switch (msgid) { case debugger_t::ev_init_debugger: { const char* hostname = va_arg(va, const char*); int portnum = va_arg(va, int); const char* password = va_arg(va, const char*); errbuf = va_arg(va, qstring*); QASSERT(1522, errbuf != NULL); retcode = init_debugger(hostname, portnum, password, errbuf); } break; case debugger_t::ev_term_debugger: retcode = term_debugger(); break; case debugger_t::ev_get_processes: { procinfo_vec_t* procs = va_arg(va, procinfo_vec_t*); errbuf = va_arg(va, qstring*); retcode = s_get_processes(procs, errbuf); } break; case debugger_t::ev_start_process: { const char* path = va_arg(va, const char*); const char* args = va_arg(va, const char*); const char* startdir = va_arg(va, const char*); uint32 dbg_proc_flags = va_arg(va, uint32); const char* input_path = va_arg(va, const char*); uint32 input_file_crc32 = va_arg(va, uint32); errbuf = va_arg(va, qstring*); retcode = s_start_process(path, args, startdir, dbg_proc_flags, input_path, input_file_crc32, errbuf); } break; case debugger_t::ev_get_debapp_attrs: { debapp_attrs_t* out_pattrs = va_arg(va, debapp_attrs_t*); out_pattrs->addrsize = 3; out_pattrs->is_be = false; out_pattrs->platform = "bsnes"; out_pattrs->cbsize = sizeof(debapp_attrs_t); retcode = DRC_OK; } break; case debugger_t::ev_rebase_if_required_to: { ea_t new_base = va_arg(va, ea_t); retcode = DRC_OK; } break; case debugger_t::ev_request_pause: errbuf = va_arg(va, qstring*); retcode = prepare_to_pause_process(errbuf); break; case debugger_t::ev_exit_process: errbuf = va_arg(va, qstring*); retcode = emul_exit_process(errbuf); break; case debugger_t::ev_get_debug_event: { gdecode_t* code = va_arg(va, gdecode_t*); debug_event_t* event = va_arg(va, debug_event_t*); int timeout_ms = va_arg(va, int); *code = get_debug_event(event, timeout_ms); retcode = DRC_OK; } break; case debugger_t::ev_resume: { debug_event_t* event = va_arg(va, debug_event_t*); retcode = continue_after_event(event); } break; case debugger_t::ev_thread_suspend: { thid_t tid = va_argi(va, thid_t); retcode = DRC_OK; } break; case debugger_t::ev_thread_continue: { thid_t tid = va_argi(va, thid_t); retcode = DRC_OK; } break; case debugger_t::ev_set_resume_mode: { thid_t tid = va_argi(va, thid_t); resume_mode_t resmod = va_argi(va, resume_mode_t); retcode = s_set_resume_mode(tid, resmod); } break; case debugger_t::ev_read_registers: { thid_t tid = va_argi(va, thid_t); int clsmask = va_arg(va, int); regval_t* values = va_arg(va, regval_t*); errbuf = va_arg(va, qstring*); retcode = read_registers(tid, clsmask, values, errbuf); } break; case debugger_t::ev_write_register: { thid_t tid = va_argi(va, thid_t); int regidx = va_arg(va, int); const regval_t* value = va_arg(va, const regval_t*); errbuf = va_arg(va, qstring*); retcode = write_register(tid, regidx, value, errbuf); } break; case debugger_t::ev_get_memory_info: { meminfo_vec_t* ranges = va_arg(va, meminfo_vec_t*); errbuf = va_arg(va, qstring*); retcode = get_memory_info(*ranges, errbuf); } break; case debugger_t::ev_read_memory: { size_t* nbytes = va_arg(va, size_t*); ea_t ea = va_arg(va, ea_t); void* buffer = va_arg(va, void*); size_t size = va_arg(va, size_t); errbuf = va_arg(va, qstring*); ssize_t code = read_memory(ea, buffer, size, errbuf); *nbytes = code >= 0 ? code : 0; retcode = code >= 0 ? DRC_OK : DRC_NOPROC; } break; case debugger_t::ev_write_memory: { size_t* nbytes = va_arg(va, size_t*); ea_t ea = va_arg(va, ea_t); const void* buffer = va_arg(va, void*); size_t size = va_arg(va, size_t); errbuf = va_arg(va, qstring*); ssize_t code = write_memory(ea, buffer, size, errbuf); *nbytes = code >= 0 ? code : 0; retcode = code >= 0 ? DRC_OK : DRC_NOPROC; } break; case debugger_t::ev_check_bpt: { int* bptvc = va_arg(va, int*); bpttype_t type = va_argi(va, bpttype_t); ea_t ea = va_arg(va, ea_t); int len = va_arg(va, int); *bptvc = is_ok_bpt(type, ea, len); retcode = DRC_OK; } break; case debugger_t::ev_update_bpts: { int* nbpts = va_arg(va, int*); update_bpt_info_t* bpts = va_arg(va, update_bpt_info_t*); int nadd = va_arg(va, int); int ndel = va_arg(va, int); errbuf = va_arg(va, qstring*); retcode = update_bpts(nbpts, bpts, nadd, ndel, errbuf); } break; default: retcode = DRC_NONE; } return retcode;}debugger_t debugger{ IDD_INTERFACE_VERSION, NAME, 0x8000 + 6581, // (6) "65816", DBG_FLAG_NOHOST | DBG_FLAG_CAN_CONT_BPT | DBG_FLAG_SAFE | DBG_FLAG_FAKE_ATTACH | DBG_FLAG_NOPASSWORD | DBG_FLAG_NOSTARTDIR | DBG_FLAG_NOPARAMETERS | DBG_FLAG_ANYSIZE_HWBPT | DBG_FLAG_DEBTHREAD | DBG_FLAG_PREFER_SWBPTS, DBG_HAS_GET_PROCESSES | DBG_HAS_REQUEST_PAUSE | DBG_HAS_SET_RESUME_MODE | DBG_HAS_THREAD_SUSPEND | DBG_HAS_THREAD_CONTINUE | DBG_HAS_CHECK_BPT, register_classes, RC_CPU, registers, qnumber(registers), 0x1000, NULL, 0, 0, DBG_RESMOD_STEP_INTO | DBG_RESMOD_STEP_OVER, NULL, idd_notify};
Основное изменение, коснувшееся кода плагинов отладчиков по
сравнению с тем, что мы писали в статье про отладчик для Сеги, это
то, что колбэк теперь всего один idd_notify, но он
один теперь обрабатывает все те сообщения, которые раньше
приходилось обрабатывать по отдельности. Так что, если захотите
просто портировать свой старый код плагина-отладчика, возьмите
шаблон колбэка из данной статьи, и адаптируйте его под имеющийся
код.
Вторым важным изменением стало введением "стандартизированных"
кодов возврата у функций отладчика drc_t. Тут всё
просто: если функция отработала без ошибок, возвращаем
DRC_OK, иначе DRC_FAILED.
Остальные инклуды:
ida_registers.h
#pragma once#define RC_CPU (1 << 0)#define RC_PPU (1 << 1)enum class SNES_REGS : uint8_t{ SR_A, SR_X, SR_Y, SR_D, SR_DB, SR_PC, SR_S, SR_P, SR_MFLAG, SR_XFLAG, SR_EFLAG,};
ida_debmod.h
#pragma once#include <deque>#include <ida.hpp>#include <idd.hpp>//--------------------------------------------------------------------------// Very simple class to store pending eventsenum queue_pos_t{ IN_FRONT, IN_BACK};struct eventlist_t : public std::deque<debug_event_t>{private: bool synced;public: // save a pending event void enqueue(const debug_event_t &ev, queue_pos_t pos) { if (pos != IN_BACK) push_front(ev); else push_back(ev); } // retrieve a pending event bool retrieve(debug_event_t *event) { if (empty()) return false; // get the first event and return it *event = front(); pop_front(); return true; }};
В ida_registers.h мы просто перечисляем список
регистров для удоства обращений к ним в коде, а в
ida_debmod.h описан формат eventlist_t,
который мы будем использовать для хранения событий, с которыми
будет работать IDA.
Подготовка завершена
Теперь, когда код шаблона у нас имеется, стоит понять, что мы
будем делать дальше. А дальше нам нужно соорудить модель, по
которой между IDA и эмулятором будет происходить общение. Для этого
нужно держать в голове следующее:
- Эмулятор с функцией отладки должен уметь реагировать на запросы
Иды "добавить/убрать брейкпоинт", "прочитать/записать
память", "получить/изменить регистры"
- Эмулятор также должен: уведомлять IDA о том, что:
"брейкпоинт сработал", "шаг при пошаговой отладке
выполнен", или "процесс отладки начат или
завершён"
- Ида должна уметь сообщать эмулятору о том, что есть
необходимость: "добавить/убрать брейкпоинт",
"прочитать/записать память", "получить/изменить
регистры"
- Ида должна реагировать на сообщения от эмулятора о том, что:
"брейкпоинт сработал", "шаг при пошаговой отладке
выполнен", или "процесс отладки начат или
завершён"
Исходя из перечисленного понимаем, что понадобятся два канала,
т.к. каждому может захотеться "пообщаться" в любой момент,
асинхронно:
- IDA => эмулятор
- Эмулятор => IDA
Учитывая это, можно, опять же, пойти по стопам предыдущей статьи
про сеговский отладчик, а можно захотеть использовать "модные и
современные" технологии для реализации RPC и сериализации любых
данных. Мой выбор пал в сторону Thrift, т.к. с ним
работать гораздо удобнее, и он практически не требует
дополнительной подготовки (как, например, доклеивание RPC в
protobuf, но тут, скорее, на любителя). Единственная сложность, это
компиляция сего зверя, но, я оставлю это за рамками данной
статьи.
Thrift пишем прототип
RPC
Давайте ещё раз посмотрим на те 4 пункта, которые я описал выше,
и которые мы всё ещё держим в голове, откроем блокнот, и напишем
что-то вроде этого:
service IdaClient { oneway void start_event(), oneway void add_visited(1:set<i32> visited, 2:bool is_step), oneway void pause_event(1:i32 address), oneway void stop_event(),}
Как видим, в Thrift нету ничего сложного. Здесь мы описали
сервис IdaClient, которым будет пользоваться эмулятор,
и обработчик которого будет располагаться в IDA. Все эти методы
помечены ключевым словом oneway, т.к., по сути, нам не
нужно дожидаться их выполнения, и в принципе ожидать, что их
обработают.
start_event() будет сообщать Иде о том, что ром
выбрал и его эмуляция началась.
add_visited() метод, с помощью которого мы будем
сообщать в Иду о том коде, который был выполнен эмулятором. Это
полезно при отладке как раз таки ретро-платформ, т.к. в ромах для
них код часто перемежается с данными. Если таковой функции в
выбранном вами эмуляторе нет, её можно также пропустить и в
протоколе.
pause_event() этим методом мы будем сообщать Иде о
том, что произошла пауза эмуляции по какой-либо причине: будь то
брейкпоинт, завершился шаг при StepInto или StepOver или какой-то
другой причине. В качестве нагрузки данный метод будет также
передавать адрес, где именно произошла остановка.
stop_event() думаю, тут всё понятно. Эмуляция
завершилась, например, по причине завершения процесса эмуляции.
С этим разобрались, теперь часть посложнее отладочный RPC:
service BsnesDebugger { i32 get_cpu_reg(1:BsnesRegister reg), BsnesRegisters get_cpu_regs(), void set_cpu_reg(1:BsnesRegister reg, 2:i32 value), binary read_memory(1:DbgMemorySource src, 2:i32 address, 3:i32 size), void write_memory(1:DbgMemorySource src, 2:i32 address, 3:binary data), void add_breakpoint(1:DbgBreakpoint bpt), void del_breakpoint(1:DbgBreakpoint bpt), void pause(), void resume(), void start_emulation(), void exit_emulation(), void step_into(), void step_over(),}
Здесь у нас описана серверная часть, которая будет крутиться в
эмуляторе, и к которой Ида время от времени будет приставать.
Давайте разберём её более детально:
i32 get_cpu_reg(1:BsnesRegister reg), void set_cpu_reg(1:BsnesRegister reg, 2:i32 value),
Эти методы мы будем использовать тогда, когда нам потребуется
прочитать или записать один регистр. Использованный enum
BsnesRegister выглядит так:
enum BsnesRegister { pc, a, x, y, s, d, db, p, mflag, xflag, eflag,}
Фактически, это те регистры, значения которых мы хотим видеть во
время отладки, у вас они могут быть другими.
Т.к. IDA сама никогда не запрашивает по одному регистру, а
требует все сразу, напишем метод, который будет их все сразу и
отдавать:
struct BsnesRegisters { 1:i32 pc, 2:i32 a, 3:i32 x, 4:i32 y, 5:i32 s, 6:i32 d, 7:i16 db, 8:i16 p, 9:i8 mflag, 10:i8 xflag, 11:i8 eflag,}service BsnesDebugger { ... BsnesRegisters get_cpu_regs(), ...}
Здесь я завёл одну общую структуру под регистры, указав их
размеры и указал её в качестве возвращаемого значения для метода
get_cpu_regs().
Теперь работа с памятью:
enum DbgMemorySource { CPUBus, APUBus, APURAM, DSP, VRAM, OAM, CGRAM, CartROM, CartRAM, SA1Bus, SFXBus, SGBBus, SGBROM, SGBRAM,}service BsnesDebugger { ... binary read_memory(1:DbgMemorySource src, 2:i32 address, 3:i32 size), void write_memory(1:DbgMemorySource src, 2:i32 address, 3:binary data), ...}
Здесь мы использовали встроенный в Thrift тип данных
binary, и указали различные области памяти, которые
могут быть прочитаны (взято из эмулятора).
Теперь пришла очередь брейкпоинтов:
enum BpType { BP_PC = 1, BP_READ = 2, BP_WRITE = 4,}enum DbgBptSource { CPUBus, APURAM, DSP, VRAM, OAM, CGRAM, SA1Bus, SFXBus, SGBBus,}struct DbgBreakpoint { 1:BpType type, 2:i32 bstart, 3:i32 bend, 4:bool enabled, 5:DbgBptSource src,}service BsnesDebugger { ... void add_breakpoint(1:DbgBreakpoint bpt), void del_breakpoint(1:DbgBreakpoint bpt), ...}
Т.к. список областей памяти, которые можно читать, и на которые
можно ставить брейкпоинты отличаются, заводим отдельный список
DbgBptSource. Также указываем тип брейкпоинта
BpType и адрес его начала/конца
bstart/bend. Ещё нам может понадобиться
включать брейкпоинт не сразу enabled.
С основными сложными частями протокола закончили, теперь можно
описать более простые:
service BsnesDebugger { ... void pause(), void resume(), void start_emulation(), void exit_emulation(), void step_into(), void step_over(), ...}
Метод pause() будет приостанавливать процесс
отладки по запросу от IDA, resume() продолжать.
start_emulation() нужен для того, чтобы IDA могла
сообщить эмулятору, что она начала процесс отладки, и ожидает от
него какие-либо события. Фактически, используется в качестве
синхронизации начала эмуляции между плагином-отладчиком и
собственно эмулятором.
exit_emulation() на случай, если мы захотим
остановить отладку из IDA, а не из эмулятора.
step_into() и step_over() пошаговая
отладка.
Итоговый debug_proto.thrift
enum BsnesRegister { pc, a, x, y, s, d, db, p, mflag, xflag, eflag,}struct BsnesRegisters { 1:i32 pc, 2:i32 a, 3:i32 x, 4:i32 y, 5:i32 s, 6:i32 d, 7:i16 db, 8:i16 p, 9:i8 mflag, 10:i8 xflag, 11:i8 eflag,}enum BpType { BP_PC = 1, BP_READ = 2, BP_WRITE = 4,}enum DbgMemorySource { CPUBus, APUBus, APURAM, DSP, VRAM, OAM, CGRAM, CartROM, CartRAM, SA1Bus, SFXBus, SGBBus, SGBROM, SGBRAM,}enum DbgBptSource { CPUBus, APURAM, DSP, VRAM, OAM, CGRAM, SA1Bus, SFXBus, SGBBus,}struct DbgBreakpoint { 1:BpType type, 2:i32 bstart, 3:i32 bend, 4:bool enabled, 5:DbgBptSource src,}service BsnesDebugger { i32 get_cpu_reg(1:BsnesRegister reg), BsnesRegisters get_cpu_regs(), void set_cpu_reg(1:BsnesRegister reg, 2:i32 value), binary read_memory(1:DbgMemorySource src, 2:i32 address, 3:i32 size), void write_memory(1:DbgMemorySource src, 2:i32 address, 3:binary data), void add_breakpoint(1:DbgBreakpoint bpt), void del_breakpoint(1:DbgBreakpoint bpt), void pause(), void resume(), void start_emulation(), void exit_emulation(), void step_into(), void step_over(),}service IdaClient { oneway void start_event(), oneway void add_visited(1:set<i32> changed, 2:bool is_step), oneway void pause_event(1:i32 address), oneway void stop_event(),}
От RPC-прототипа к
реализации
На этом процесс написания RPC-прототипа завершён. Чтобы
сгенерировать из него код для языка C++, качаем Thrift-компилятор, выполняем из
командной строки следующее:
thrift --gen cpp debug_proto.thrift
На выходе мы получим каталог gen-cpp, в котором нас
будут ждать не только файлики, которые нужно будет компилировать
вместе с проектом, но и шаблон кода каждого из сервисов
IdaClient и BsnesDebugger.
Добавляем сгенерированные файлы в студийный проект (кроме файлов
*_server.skeleton.cpp). Также необходимо слинковать
наш проект плагина (и эмулятора) со скомпилированными статичными
библиотеками thrift-а и libevent-а (мы
будем использовать "nonblocking" вариант Thrift). У этих библиотек
имеется CMake вариант сборки, который значительно упрощает
процесс.
Код IdaClient хэндлера
Теперь давайте напишем шаблон кода, реализующий
IdaClient-сервис:
Необходимые инклуды и адресные пространства
#include "gen-cpp/IdaClient.h"#include "gen-cpp/BsnesDebugger.h"#include <thrift/protocol/TBinaryProtocol.h>#include <thrift/transport/TSocket.h>#include <thrift/transport/TBufferTransports.h>#include <thrift/server/TNonblockingServer.h>#include <thrift/transport/TNonblockingServerSocket.h>#include <thrift/concurrency/ThreadFactory.h>using namespace ::apache::thrift;using namespace ::apache::thrift::protocol;using namespace ::apache::thrift::transport;using namespace ::apache::thrift::server;using namespace ::apache::thrift::concurrency;::std::shared_ptr<BsnesDebuggerClient> client;::std::shared_ptr<TNonblockingServer> srv;::std::shared_ptr<TTransport> cli_transport;
Реализация серверной части IdaClient
static void pause_execution(){ try { if (client) { client->pause(); } } catch (...) { }}static void continue_execution(){ try { if (client) { client->resume(); } } catch (...) { }}static void stop_server() { try { srv->stop(); } catch (...) { }}static void finish_execution(){ try { if (client) { client->exit_emulation(); } } catch (...) { } stop_server();}class IdaClientHandler : virtual public IdaClientIf {public: void pause_event(const int32_t address) override { ::std::lock_guard<::std::mutex> lock(list_mutex); debug_event_t ev; ev.pid = 1; ev.tid = 1; ev.ea = address | 0x800000; ev.handled = true; ev.set_eid(PROCESS_SUSPENDED); events.enqueue(ev, IN_BACK); } void start_event() override { ::std::lock_guard<::std::mutex> lock(list_mutex); debug_event_t ev; ev.pid = 1; ev.tid = 1; ev.ea = BADADDR; ev.handled = true; ev.set_modinfo(PROCESS_STARTED).name.sprnt("BSNES"); ev.set_modinfo(PROCESS_STARTED).base = 0; ev.set_modinfo(PROCESS_STARTED).size = 0; ev.set_modinfo(PROCESS_STARTED).rebase_to = BADADDR; events.enqueue(ev, IN_BACK); } void stop_event() override { ::std::lock_guard<::std::mutex> lock(list_mutex); debug_event_t ev; ev.pid = 1; ev.handled = true; ev.set_exit_code(PROCESS_EXITED, 0); events.enqueue(ev, IN_BACK); } void add_visited(const std::set<int32_t>& changed, bool is_step) override { }};
В этом коде мы реагируем на события эмуляции и сообщаем о них
Иде, добавляя эти события в список. Более подробно о них можно
прочитать в той же статье про отладчик для Сеги. Код
add_visited() пока оставляем пустым. О нём позже.
Теперь напишем код, который будет отвечать за поднятие сервиса
на стороне Иды (будем использовать порт 9091), и ожидание
подключения к эмулятору:
init_ida_server и init_emu_client
static void init_ida_server() { try { ::std::shared_ptr<IdaClientHandler> handler(new IdaClientHandler()); ::std::shared_ptr<TProcessor> processor(new IdaClientProcessor(handler)); ::std::shared_ptr<TNonblockingServerTransport> serverTransport(new TNonblockingServerSocket(9091)); ::std::shared_ptr<TFramedTransportFactory> transportFactory(new TFramedTransportFactory()); ::std::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory()); srv = ::std::shared_ptr<TNonblockingServer>(new TNonblockingServer(processor, protocolFactory, serverTransport)); ::std::shared_ptr<ThreadFactory> tf(new ThreadFactory()); ::std::shared_ptr<Thread> thread = tf->newThread(srv); thread->start(); } catch (...) { }}static void init_emu_client() { ::std::shared_ptr<TTransport> socket(new TSocket("127.0.0.1", 9090)); cli_transport = ::std::shared_ptr<TTransport>(new TFramedTransport(socket)); ::std::shared_ptr<TBinaryProtocol> protocol(new TBinaryProtocol(cli_transport)); client = ::std::shared_ptr<BsnesDebuggerClient>(new BsnesDebuggerClient(protocol)); show_wait_box("Waiting for BSNES-PLUS emulation..."); while (true) { if (user_cancelled()) { break; } try { cli_transport->open(); break; } catch (...) { } } hide_wait_box();}
Осталось дополнить имеющийся шаблон ida_debug.cpp
кодом для работы со Thrift. Вот что получилось:
Полный код ida_debug.cpp
#include "gen-cpp/IdaClient.h"#include "gen-cpp/BsnesDebugger.h"#include <thrift/protocol/TBinaryProtocol.h>#include <thrift/transport/TSocket.h>#include <thrift/transport/TBufferTransports.h>#include <thrift/server/TNonblockingServer.h>#include <thrift/transport/TNonblockingServerSocket.h>#include <thrift/concurrency/ThreadFactory.h>using namespace ::apache::thrift;using namespace ::apache::thrift::protocol;using namespace ::apache::thrift::transport;using namespace ::apache::thrift::server;using namespace ::apache::thrift::concurrency;#include <ida.hpp>#include <dbg.hpp>#include <auto.hpp>#include <deque>#include <mutex>#include "ida_plugin.h"#include "ida_debmod.h"#include "ida_registers.h"::std::shared_ptr<BsnesDebuggerClient> client;::std::shared_ptr<TNonblockingServer> srv;::std::shared_ptr<TTransport> cli_transport;static ::std::mutex list_mutex;static eventlist_t events;static const char* const p_reg[] ={ "CF", "ZF", "IF", "DF", "XF", "MF", "VF", "NF",};static register_info_t registers[] = { {"A", 0, RC_CPU, dt_word, NULL, 0}, {"X", 0, RC_CPU, dt_word, NULL, 0}, {"Y", 0, RC_CPU, dt_word, NULL, 0}, {"D", 0, RC_CPU, dt_word, NULL, 0}, {"DB", 0, RC_CPU, dt_byte, NULL, 0}, {"PC", REGISTER_IP | REGISTER_ADDRESS, RC_CPU, dt_dword, NULL, 0}, {"S", REGISTER_SP | REGISTER_ADDRESS, RC_CPU, dt_word, NULL, 0}, {"P", REGISTER_READONLY, RC_CPU, dt_byte, p_reg, 0xFF}, {"m", REGISTER_READONLY, RC_CPU, dt_byte, NULL, 0}, {"x", REGISTER_READONLY, RC_CPU, dt_byte, NULL, 0}, {"e", REGISTER_READONLY, RC_CPU, dt_byte, NULL, 0},};static const char* register_classes[] = { "General Registers", NULL};static struct apply_codemap_req : public exec_request_t {private: const std::set<int32_t>& _changed; const bool _is_step;public: apply_codemap_req(const std::set<int32_t>& changed, bool is_step) : _changed(changed), _is_step(is_step) {}; int idaapi execute(void) override { auto m = _changed.size(); if (!_is_step) { show_wait_box("Applying codemap: %d/%d...", 1, m); } auto x = 0; for (auto i = _changed.cbegin(); i != _changed.cend(); ++i) { if (!_is_step && user_cancelled()) { break; } if (!_is_step) { replace_wait_box("Applying codemap: %d/%d...", x, m); } ea_t addr = (ea_t)(*i | 0x800000); auto_make_code(addr); plan_ea(addr); show_addr(addr); x++; } if (!_is_step) { hide_wait_box(); } return 0; }};static void apply_codemap(const std::set<int32_t>& changed, bool is_step){ if (changed.empty()) return; apply_codemap_req req(changed, is_step); execute_sync(req, MFF_FAST);}static void pause_execution(){ try { if (client) { client->pause(); } } catch (...) { }}static void continue_execution(){ try { if (client) { client->resume(); } } catch (...) { }}static void stop_server() { try { srv->stop(); } catch (...) { }}static void finish_execution(){ try { if (client) { client->exit_emulation(); } } catch (...) { } stop_server();}class IdaClientHandler : virtual public IdaClientIf {public: void pause_event(const int32_t address) override { ::std::lock_guard<::std::mutex> lock(list_mutex); debug_event_t ev; ev.pid = 1; ev.tid = 1; ev.ea = address | 0x800000; ev.handled = true; ev.set_eid(PROCESS_SUSPENDED); events.enqueue(ev, IN_BACK); } void start_event() override { ::std::lock_guard<::std::mutex> lock(list_mutex); debug_event_t ev; ev.pid = 1; ev.tid = 1; ev.ea = BADADDR; ev.handled = true; ev.set_modinfo(PROCESS_STARTED).name.sprnt("BSNES"); ev.set_modinfo(PROCESS_STARTED).base = 0; ev.set_modinfo(PROCESS_STARTED).size = 0; ev.set_modinfo(PROCESS_STARTED).rebase_to = BADADDR; events.enqueue(ev, IN_BACK); } void stop_event() override { ::std::lock_guard<::std::mutex> lock(list_mutex); debug_event_t ev; ev.pid = 1; ev.handled = true; ev.set_exit_code(PROCESS_EXITED, 0); events.enqueue(ev, IN_BACK); } void add_visited(const std::set<int32_t>& changed, bool is_step) override { apply_codemap(changed, is_step); }};static void init_ida_server() { try { ::std::shared_ptr<IdaClientHandler> handler(new IdaClientHandler()); ::std::shared_ptr<TProcessor> processor(new IdaClientProcessor(handler)); ::std::shared_ptr<TNonblockingServerTransport> serverTransport(new TNonblockingServerSocket(9091)); ::std::shared_ptr<TFramedTransportFactory> transportFactory(new TFramedTransportFactory()); ::std::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory()); srv = ::std::shared_ptr<TNonblockingServer>(new TNonblockingServer(processor, protocolFactory, serverTransport)); ::std::shared_ptr<ThreadFactory> tf(new ThreadFactory()); ::std::shared_ptr<Thread> thread = tf->newThread(srv); thread->start(); } catch (...) { }}static void init_emu_client() { ::std::shared_ptr<TTransport> socket(new TSocket("127.0.0.1", 9090)); cli_transport = ::std::shared_ptr<TTransport>(new TFramedTransport(socket)); ::std::shared_ptr<TBinaryProtocol> protocol(new TBinaryProtocol(cli_transport)); client = ::std::shared_ptr<BsnesDebuggerClient>(new BsnesDebuggerClient(protocol)); show_wait_box("Waiting for BSNES-PLUS emulation..."); while (true) { if (user_cancelled()) { break; } try { cli_transport->open(); break; } catch (...) { } } hide_wait_box();}static drc_t idaapi init_debugger(const char* hostname, int portnum, const char* password, qstring* errbuf){ return DRC_OK;}static drc_t idaapi term_debugger(void){ finish_execution(); return DRC_OK;}static drc_t s_get_processes(procinfo_vec_t* procs, qstring* errbuf) { process_info_t info; info.name.sprnt("bsnes"); info.pid = 1; procs->add(info); return DRC_OK;}static drc_t idaapi s_start_process(const char* path, const char* args, const char* startdir, uint32 dbg_proc_flags, const char* input_path, uint32 input_file_crc32, qstring* errbuf = NULL){ ::std::lock_guard<::std::mutex> lock(list_mutex); events.clear(); init_ida_server(); init_emu_client(); try { if (client) { client->start_emulation(); } } catch (...) { return DRC_FAILED; } return DRC_OK;}static drc_t idaapi prepare_to_pause_process(qstring* errbuf){ pause_execution(); return DRC_OK;}static drc_t idaapi emul_exit_process(qstring* errbuf){ finish_execution(); return DRC_OK;}static gdecode_t idaapi get_debug_event(debug_event_t* event, int timeout_ms){ while (true) { ::std::lock_guard<::std::mutex> lock(list_mutex); // are there any pending events? if (events.retrieve(event)) { return events.empty() ? GDE_ONE_EVENT : GDE_MANY_EVENTS; } if (events.empty()) break; } return GDE_NO_EVENT;}static drc_t idaapi continue_after_event(const debug_event_t* event){ dbg_notification_t req = get_running_notification(); switch (event->eid()) { case STEP: case PROCESS_SUSPENDED: if (req == dbg_null || req == dbg_run_to) { continue_execution(); } break; case PROCESS_EXITED: stop_server(); break; } return DRC_OK;}static drc_t idaapi s_set_resume_mode(thid_t tid, resume_mode_t resmod) // Run one instruction in the thread{ switch (resmod) { case RESMOD_INTO: ///< step into call (the most typical single stepping) try { if (client) { client->step_into(); } } catch (...) { return DRC_FAILED; } break; case RESMOD_OVER: ///< step over call try { if (client) { client->step_over(); } } catch (...) { return DRC_FAILED; } break; } return DRC_OK;}static drc_t idaapi read_registers(thid_t tid, int clsmask, regval_t* values, qstring* errbuf){ if (clsmask & RC_CPU) { BsnesRegisters regs; try { if (client) { client->get_cpu_regs(regs); values[static_cast<int>(SNES_REGS::SR_PC)].ival = regs.pc | 0x800000; values[static_cast<int>(SNES_REGS::SR_A)].ival = regs.a; values[static_cast<int>(SNES_REGS::SR_X)].ival = regs.x; values[static_cast<int>(SNES_REGS::SR_Y)].ival = regs.y; values[static_cast<int>(SNES_REGS::SR_S)].ival = regs.s; values[static_cast<int>(SNES_REGS::SR_D)].ival = regs.d; values[static_cast<int>(SNES_REGS::SR_DB)].ival = regs.db; values[static_cast<int>(SNES_REGS::SR_P)].ival = regs.p; values[static_cast<int>(SNES_REGS::SR_MFLAG)].ival = regs.mflag; values[static_cast<int>(SNES_REGS::SR_XFLAG)].ival = regs.xflag; values[static_cast<int>(SNES_REGS::SR_EFLAG)].ival = regs.eflag; } } catch (...) { return DRC_FAILED; } } return DRC_OK;}static drc_t idaapi write_register(thid_t tid, int regidx, const regval_t* value, qstring* errbuf){ if (regidx >= static_cast<int>(SNES_REGS::SR_PC) && regidx <= static_cast<int>(SNES_REGS::SR_EFLAG)) { try { if (client) { client->set_cpu_reg(static_cast<BsnesRegister::type>(regidx), value->ival & 0xFFFFFFFF); } } catch (...) { return DRC_FAILED; } } return DRC_OK;}static drc_t idaapi get_memory_info(meminfo_vec_t& areas, qstring* errbuf){ memory_info_t info; info.start_ea = 0x0000; info.end_ea = 0x01FFF; info.sclass = "STACK"; info.bitness = 0; info.perm = SEGPERM_READ | SEGPERM_WRITE; areas.push_back(info); // Don't remove this loop for (int i = 0; i < get_segm_qty(); ++i) { segment_t* segm = getnseg(i); info.start_ea = segm->start_ea; info.end_ea = segm->end_ea; qstring buf; get_segm_name(&buf, segm); info.name = buf; get_segm_class(&buf, segm); info.sclass = buf; info.sbase = get_segm_base(segm); info.perm = segm->perm; info.bitness = segm->bitness; areas.push_back(info); } // Don't remove this loop return DRC_OK;}static ssize_t idaapi read_memory(ea_t ea, void* buffer, size_t size, qstring* errbuf){ std::string mem; try { if (client) { client->read_memory(mem, DbgMemorySource::CPUBus, (int32_t)ea, (int32_t)size); memcpy(&((unsigned char*)buffer)[0], mem.c_str(), size); } } catch (...) { return DRC_FAILED; } return size;}static ssize_t idaapi write_memory(ea_t ea, const void* buffer, size_t size, qstring* errbuf){ std::string mem((const char*)buffer); try { if (client) { client->write_memory(DbgMemorySource::CPUBus, (int32_t)ea, mem); } } catch (...) { return 0; } return size;}static int idaapi is_ok_bpt(bpttype_t type, ea_t ea, int len){ DbgMemorySource::type btype = DbgMemorySource::CPUBus; switch (btype) { case DbgMemorySource::CPUBus: case DbgMemorySource::APURAM: case DbgMemorySource::DSP: case DbgMemorySource::VRAM: case DbgMemorySource::OAM: case DbgMemorySource::CGRAM: case DbgMemorySource::SA1Bus: case DbgMemorySource::SFXBus: break; default: return BPT_BAD_TYPE; } switch (type) { case BPT_EXEC: case BPT_READ: case BPT_WRITE: case BPT_RDWR: return BPT_OK; } return BPT_BAD_TYPE;}static drc_t idaapi update_bpts(int* nbpts, update_bpt_info_t* bpts, int nadd, int ndel, qstring* errbuf){ for (int i = 0; i < nadd; ++i) { ea_t start = bpts[i].ea; ea_t end = bpts[i].ea + bpts[i].size - 1; DbgBreakpoint bp; bp.bstart = start; bp.bend = end; bp.enabled = true; switch (bpts[i].type) { case BPT_EXEC: bp.type = BpType::BP_PC; break; case BPT_READ: bp.type = BpType::BP_READ; break; case BPT_WRITE: bp.type = BpType::BP_WRITE; break; case BPT_RDWR: bp.type = BpType::BP_READ; break; } DbgMemorySource::type type = DbgMemorySource::CPUBus; switch (type) { case DbgMemorySource::CPUBus: bp.src = DbgBptSource::CPUBus; break; case DbgMemorySource::APURAM: bp.src = DbgBptSource::APURAM; break; case DbgMemorySource::DSP: bp.src = DbgBptSource::DSP; break; case DbgMemorySource::VRAM: bp.src = DbgBptSource::VRAM; break; case DbgMemorySource::OAM: bp.src = DbgBptSource::OAM; break; case DbgMemorySource::CGRAM: bp.src = DbgBptSource::CGRAM; break; case DbgMemorySource::SA1Bus: bp.src = DbgBptSource::SA1Bus; break; case DbgMemorySource::SFXBus: bp.src = DbgBptSource::SFXBus; break; default: continue; } try { if (client) { client->add_breakpoint(bp); } } catch (...) { return DRC_FAILED; } bpts[i].code = BPT_OK; } for (int i = 0; i < ndel; ++i) { ea_t start = bpts[nadd + i].ea; ea_t end = bpts[nadd + i].ea + bpts[nadd + i].size - 1; DbgBreakpoint bp; bp.bstart = start; bp.bend = end; bp.enabled = true; switch (bpts[i].type) { case BPT_EXEC: bp.type = BpType::BP_PC; break; case BPT_READ: bp.type = BpType::BP_READ; break; case BPT_WRITE: bp.type = BpType::BP_WRITE; break; case BPT_RDWR: bp.type = BpType::BP_READ; break; } DbgMemorySource::type type = DbgMemorySource::CPUBus; switch (type) { case DbgMemorySource::CPUBus: bp.src = DbgBptSource::CPUBus; break; case DbgMemorySource::APURAM: bp.src = DbgBptSource::APURAM; break; case DbgMemorySource::DSP: bp.src = DbgBptSource::DSP; break; case DbgMemorySource::VRAM: bp.src = DbgBptSource::VRAM; break; case DbgMemorySource::OAM: bp.src = DbgBptSource::OAM; break; case DbgMemorySource::CGRAM: bp.src = DbgBptSource::CGRAM; break; case DbgMemorySource::SA1Bus: bp.src = DbgBptSource::SA1Bus; break; case DbgMemorySource::SFXBus: bp.src = DbgBptSource::SFXBus; break; default: continue; } try { if (client) { client->del_breakpoint(bp); } } catch (...) { return DRC_FAILED; } bpts[nadd + i].code = BPT_OK; } *nbpts = (ndel + nadd); return DRC_OK;}static ssize_t idaapi idd_notify(void*, int msgid, va_list va) { drc_t retcode = DRC_NONE; qstring* errbuf; switch (msgid) { case debugger_t::ev_init_debugger: { const char* hostname = va_arg(va, const char*); int portnum = va_arg(va, int); const char* password = va_arg(va, const char*); errbuf = va_arg(va, qstring*); QASSERT(1522, errbuf != NULL); retcode = init_debugger(hostname, portnum, password, errbuf); } break; case debugger_t::ev_term_debugger: retcode = term_debugger(); break; case debugger_t::ev_get_processes: { procinfo_vec_t* procs = va_arg(va, procinfo_vec_t*); errbuf = va_arg(va, qstring*); retcode = s_get_processes(procs, errbuf); } break; case debugger_t::ev_start_process: { const char* path = va_arg(va, const char*); const char* args = va_arg(va, const char*); const char* startdir = va_arg(va, const char*); uint32 dbg_proc_flags = va_arg(va, uint32); const char* input_path = va_arg(va, const char*); uint32 input_file_crc32 = va_arg(va, uint32); errbuf = va_arg(va, qstring*); retcode = s_start_process(path, args, startdir, dbg_proc_flags, input_path, input_file_crc32, errbuf); } break; case debugger_t::ev_get_debapp_attrs: { debapp_attrs_t* out_pattrs = va_arg(va, debapp_attrs_t*); out_pattrs->addrsize = 3; out_pattrs->is_be = false; out_pattrs->platform = "snes"; out_pattrs->cbsize = sizeof(debapp_attrs_t); retcode = DRC_OK; } break; case debugger_t::ev_rebase_if_required_to: { ea_t new_base = va_arg(va, ea_t); retcode = DRC_OK; } break; case debugger_t::ev_request_pause: errbuf = va_arg(va, qstring*); retcode = prepare_to_pause_process(errbuf); break; case debugger_t::ev_exit_process: errbuf = va_arg(va, qstring*); retcode = emul_exit_process(errbuf); break; case debugger_t::ev_get_debug_event: { gdecode_t* code = va_arg(va, gdecode_t*); debug_event_t* event = va_arg(va, debug_event_t*); int timeout_ms = va_arg(va, int); *code = get_debug_event(event, timeout_ms); retcode = DRC_OK; } break; case debugger_t::ev_resume: { debug_event_t* event = va_arg(va, debug_event_t*); retcode = continue_after_event(event); } break; case debugger_t::ev_thread_suspend: { thid_t tid = va_argi(va, thid_t); pause_execution(); retcode = DRC_OK; } break; case debugger_t::ev_thread_continue: { thid_t tid = va_argi(va, thid_t); continue_execution(); retcode = DRC_OK; } break; case debugger_t::ev_set_resume_mode: { thid_t tid = va_argi(va, thid_t); resume_mode_t resmod = va_argi(va, resume_mode_t); retcode = s_set_resume_mode(tid, resmod); } break; case debugger_t::ev_read_registers: { thid_t tid = va_argi(va, thid_t); int clsmask = va_arg(va, int); regval_t* values = va_arg(va, regval_t*); errbuf = va_arg(va, qstring*); retcode = read_registers(tid, clsmask, values, errbuf); } break; case debugger_t::ev_write_register: { thid_t tid = va_argi(va, thid_t); int regidx = va_arg(va, int); const regval_t* value = va_arg(va, const regval_t*); errbuf = va_arg(va, qstring*); retcode = write_register(tid, regidx, value, errbuf); } break; case debugger_t::ev_get_memory_info: { meminfo_vec_t* ranges = va_arg(va, meminfo_vec_t*); errbuf = va_arg(va, qstring*); retcode = get_memory_info(*ranges, errbuf); } break; case debugger_t::ev_read_memory: { size_t* nbytes = va_arg(va, size_t*); ea_t ea = va_arg(va, ea_t); void* buffer = va_arg(va, void*); size_t size = va_arg(va, size_t); errbuf = va_arg(va, qstring*); ssize_t code = read_memory(ea, buffer, size, errbuf); *nbytes = code >= 0 ? code : 0; retcode = code >= 0 ? DRC_OK : DRC_NOPROC; } break; case debugger_t::ev_write_memory: { size_t* nbytes = va_arg(va, size_t*); ea_t ea = va_arg(va, ea_t); const void* buffer = va_arg(va, void*); size_t size = va_arg(va, size_t); errbuf = va_arg(va, qstring*); ssize_t code = write_memory(ea, buffer, size, errbuf); *nbytes = code >= 0 ? code : 0; retcode = code >= 0 ? DRC_OK : DRC_NOPROC; } break; case debugger_t::ev_check_bpt: { int* bptvc = va_arg(va, int*); bpttype_t type = va_argi(va, bpttype_t); ea_t ea = va_arg(va, ea_t); int len = va_arg(va, int); *bptvc = is_ok_bpt(type, ea, len); retcode = DRC_OK; } break; case debugger_t::ev_update_bpts: { int* nbpts = va_arg(va, int*); update_bpt_info_t* bpts = va_arg(va, update_bpt_info_t*); int nadd = va_arg(va, int); int ndel = va_arg(va, int); errbuf = va_arg(va, qstring*); retcode = update_bpts(nbpts, bpts, nadd, ndel, errbuf); } break; default: retcode = DRC_NONE; } return retcode;}debugger_t debugger{ IDD_INTERFACE_VERSION, NAME, 0x8000 + 6581, // (6) "65816", DBG_FLAG_NOHOST | DBG_FLAG_CAN_CONT_BPT | DBG_FLAG_SAFE | DBG_FLAG_FAKE_ATTACH | DBG_FLAG_NOPASSWORD | DBG_FLAG_NOSTARTDIR | DBG_FLAG_NOPARAMETERS | DBG_FLAG_ANYSIZE_HWBPT | DBG_FLAG_DEBTHREAD | DBG_FLAG_PREFER_SWBPTS, DBG_HAS_GET_PROCESSES | DBG_HAS_REQUEST_PAUSE | DBG_HAS_SET_RESUME_MODE | DBG_HAS_THREAD_SUSPEND | DBG_HAS_THREAD_CONTINUE | DBG_HAS_CHECK_BPT, register_classes, RC_CPU, registers, qnumber(registers), 0x1000, NULL, 0, 0, DBG_RESMOD_STEP_INTO | DBG_RESMOD_STEP_OVER, NULL, idd_notify};
Дабы не описывать весь этот код, здесь я опишу лишь типичный код
для работы со Thrift со стороны IDA:
try { if (client) { client->step_over(); } } catch (...) { return DRC_FAILED; } return DRC_OK;
Т.е. мы просто оборачиваем код для работы с клиентом
BsnesDebugger (серверную часть которого сейчас также
напишем) в обработчик исключения и возвращаем либо ошибку, либо
ОК.
Код BsnesDebugger хэндлера
Теперь мы дошли до модификации непосредственно эмулятора. Как ни
странно, изменений потребуется не так много. Для того, чтобы не
вдаваться в подробности реализации конкретного эмулятора, и чтобы
не бомбить о том, какая же здесь ужасная структура кода, я просто
приведу шаблон cpp-файла, который я использовал при компиляции
эмулятора.
remote_debugger.cpp
#include "gen-cpp/IdaClient.h"#include "gen-cpp/BsnesDebugger.h"#include <thrift/protocol/TBinaryProtocol.h>#include <thrift/transport/TSocket.h>#include <thrift/transport/TBufferTransports.h>#include <thrift/server/TNonblockingServer.h>#include <thrift/transport/TNonblockingServerSocket.h>#include <thrift/concurrency/ThreadFactory.h>using namespace ::apache::thrift;using namespace ::apache::thrift::protocol;using namespace ::apache::thrift::transport;using namespace ::apache::thrift::server;using namespace ::apache::thrift::concurrency;#include "../ui-base.hpp"static ::std::shared_ptr<IdaClientClient> client;static ::std::shared_ptr<TNonblockingServer> srv;static ::std::shared_ptr<TTransport> cli_transport;static ::std::mutex list_mutex;::std::set<int32_t> visited;static void send_visited(bool is_step) { const auto part = visited.size(); ::std::lock_guard<::std::mutex> lock(list_mutex); try { if (client) { client->add_visited(visited, is_step); } } catch (...) { } visited.clear();}static void stop_client() { try { if (client) { send_visited(false); client->stop_event(); } cli_transport->close(); } catch (...) { }}static void init_ida_client() { ::std::shared_ptr<TTransport> socket(new TSocket("127.0.0.1", 9091)); cli_transport = ::std::shared_ptr<TTransport>(new TFramedTransport(socket)); ::std::shared_ptr<TBinaryProtocol> protocol(new TBinaryProtocol(cli_transport)); client = ::std::shared_ptr<IdaClientClient>(new IdaClientClient(protocol)); while (true) { try { cli_transport->open(); break; } catch (...) { Sleep(10); } } atexit(stop_client);}static void toggle_pause(bool enable) { application.debug = enable; application.debugrun = enable; if (enable) { audio.clear(); }}class BsnesDebuggerHandler : virtual public BsnesDebuggerIf {public: int32_t get_cpu_reg(const BsnesRegister::type reg) override { switch (reg) { case BsnesRegister::pc: case BsnesRegister::a: case BsnesRegister::x: case BsnesRegister::y: case BsnesRegister::s: case BsnesRegister::d: case BsnesRegister::db: case BsnesRegister::p: return SNES::cpu.getRegister((SNES::CPUDebugger::Register)reg); case BsnesRegister::mflag: return (SNES::cpu.usage[SNES::cpu.regs.pc] & SNES::CPUDebugger::UsageFlagM) ? 1 : 0; case BsnesRegister::xflag: return (SNES::cpu.usage[SNES::cpu.regs.pc] & SNES::CPUDebugger::UsageFlagX) ? 1 : 0; case BsnesRegister::eflag: return (SNES::cpu.usage[SNES::cpu.regs.pc] & SNES::CPUDebugger::UsageFlagE) ? 1 : 0; } } void get_cpu_regs(BsnesRegisters& _return) override { _return.pc = SNES::cpu.getRegister(SNES::CPUDebugger::Register::RegisterPC); _return.a = SNES::cpu.getRegister(SNES::CPUDebugger::Register::RegisterA); _return.x = SNES::cpu.getRegister(SNES::CPUDebugger::Register::RegisterX); _return.y = SNES::cpu.getRegister(SNES::CPUDebugger::Register::RegisterY); _return.s = SNES::cpu.getRegister(SNES::CPUDebugger::Register::RegisterS); _return.d = SNES::cpu.getRegister(SNES::CPUDebugger::Register::RegisterD); _return.db = SNES::cpu.getRegister(SNES::CPUDebugger::Register::RegisterDB); _return.p = SNES::cpu.getRegister(SNES::CPUDebugger::Register::RegisterP); _return.mflag = (SNES::cpu.usage[SNES::cpu.regs.pc] & SNES::CPUDebugger::UsageFlagM) ? 1 : 0; _return.xflag = (SNES::cpu.usage[SNES::cpu.regs.pc] & SNES::CPUDebugger::UsageFlagX) ? 1 : 0; _return.eflag = (SNES::cpu.usage[SNES::cpu.regs.pc] & SNES::CPUDebugger::UsageFlagE) ? 1 : 0; } void set_cpu_reg(const BsnesRegister::type reg, const int32_t value) override { switch (reg) { case BsnesRegister::pc: case BsnesRegister::a: case BsnesRegister::x: case BsnesRegister::y: case BsnesRegister::s: case BsnesRegister::d: case BsnesRegister::db: case BsnesRegister::p: SNES::cpu.setRegister((SNES::CPUDebugger::Register)reg, value); } } void add_breakpoint(const DbgBreakpoint& bpt) override { SNES::Debugger::Breakpoint add; add.addr = bpt.bstart; add.addr_end = bpt.bend; add.mode = bpt.type; add.source = (SNES::Debugger::Breakpoint::Source)bpt.src; SNES::debugger.breakpoint.append(add); } void del_breakpoint(const DbgBreakpoint& bpt) override { for (auto i = 0; i < SNES::debugger.breakpoint.size(); ++i) { auto b = SNES::debugger.breakpoint[i]; if (b.source == (SNES::Debugger::Breakpoint::Source)bpt.src && b.addr == bpt.bstart && b.addr_end == bpt.bend && b.mode == bpt.type) { SNES::debugger.breakpoint.remove(i); break; } } } void read_memory(std::string& _return, const DbgMemorySource::type src, const int32_t address, const int32_t size) override { _return.clear(); SNES::debugger.bus_access = true; for (auto i = 0; i < size; ++i) { _return += SNES::debugger.read((SNES::Debugger::MemorySource)src, address + i); } SNES::debugger.bus_access = false; } void write_memory(const DbgMemorySource::type src, const int32_t address, const std::string& data) override { SNES::debugger.bus_access = true; for (auto i = 0; i < data.size(); ++i) { SNES::debugger.write((SNES::Debugger::MemorySource)src, address, data[i]); } SNES::debugger.bus_access = false; } void exit_emulation() override { try { if (client) { send_visited(false); client->stop_event(); } } catch (...) { } application.app->exit(); } void pause() override { step_into(); } void resume() override { toggle_pause(false); } void start_emulation() override { init_ida_client(); try { if (client) { client->start_event(); visited.clear(); client->pause_event(SNES::cpu.getRegister(SNES::CPUDebugger::RegisterPC)); } } catch (...) { } } void step_into() override { SNES::debugger.step_type = SNES::Debugger::StepType::StepInto; application.debugrun = true; SNES::debugger.step_cpu = true; } void step_over() override { SNES::debugger.step_type = SNES::Debugger::StepType::StepOver; SNES::debugger.step_over_new = true; SNES::debugger.call_count = 0; application.debugrun = true; SNES::debugger.step_cpu = true; }};static void stop_server() { srv->stop();}void init_dbg_server() { ::std::shared_ptr<BsnesDebuggerHandler> handler(new BsnesDebuggerHandler()); ::std::shared_ptr<TProcessor> processor(new BsnesDebuggerProcessor(handler)); ::std::shared_ptr<TNonblockingServerTransport> serverTransport(new TNonblockingServerSocket(9090)); ::std::shared_ptr<TFramedTransportFactory> transportFactory(new TFramedTransportFactory()); ::std::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory()); srv = ::std::shared_ptr<TNonblockingServer>(new TNonblockingServer(processor, protocolFactory, serverTransport)); ::std::shared_ptr<ThreadFactory> tf(new ThreadFactory()); ::std::shared_ptr<Thread> thread = tf->newThread(srv); thread->start(); atexit(stop_server); SNES::debugger.breakpoint.reset(); SNES::debugger.step_type = SNES::Debugger::StepType::StepInto; application.debugrun = true; SNES::debugger.step_cpu = true;}void send_pause_event(bool is_step) { try { if (client) { client->pause_event(SNES::cpu.getRegister(SNES::CPUDebugger::RegisterPC)); send_visited(is_step); } } catch (...) { }}
Фактически, я взял код, который уже был во встроенном отладчике,
и скопировал его в реализацию каждого из требуемых методов
интерфейса BsnesDebugger.
Часть объектов и методов я не делал статичными, т.к. к ним нам
нужно будет обращаться из других участков кода эмулятора. Эти
методы и объекты представлены в следующем списке:
::std::set<int32_t> visited; сюда мы будем
добавлять код, который выполнялся во время эмуляции, и который мы
будем отправлять в Идуvoid init_dbg_server() будем запускать RPC-сервер
не при запуске эмулятора, а при запуске эмуляции выбранного
ромаvoid send_pause_event(bool is_step) данный метод я
использую не только для уведомления Иды о том, что эмуляция
приостановлена, но и для отправки перед этим карты кода (codemap).
Подробнее про параметр bool is_step и
codemap я расскажу чуть позже
Теперь остаётся найти, где же эмулятору стоит сообщать о паузе,
где начинается эмуляция, и где заполняется карта кода. Вот эти
места:
Выполнение одной инструкции:
alwaysinline uint8_t CPUDebugger::op_readpc() { extern std::set<int32_t> visited; // я решил не использовать отдельный header visited.insert(regs.pc); // вставляем в карту кода текущее значение регистра PC usage[regs.pc] |= UsageExec; int offset = cartridge.rom_offset(regs.pc); if (offset >= 0) cart_usage[offset] |= UsageExec; // execute code without setting read flag return CPU::op_read((regs.pc.b << 16) + regs.pc.w++);}
Открытие SNES рома:
Пошаговое исполнение:
Реакция на срабатывание брейкпоинта:
Хитрости применения
codemap в Иде
Осталось рассказать о хитростях работы с функциями анализатора в
IDA, и затем со спокойной (но переживающей "сомпилируется ли")
душой нажать на Build Solution.
Оказалось, что просто так взять и в цикле выполнять функции,
которые меняют IDB (файлы проектов в IDA) во время отладки нельзя
будет вылетать через раз, и доводить своим непостоянством до
сумасшествия. Нужно делать по-умному, например, вот так:
Как правильно менять IDB во время отладки
static struct apply_codemap_req : public exec_request_t {private: const std::set<int32_t>& _changed; const bool _is_step;public: apply_codemap_req(const std::set<int32_t>& changed, bool is_step) : _changed(changed), _is_step(is_step) {}; int idaapi execute(void) override { auto m = _changed.size(); if (!_is_step) { show_wait_box("Applying codemap: %d/%d...", 1, m); } auto x = 0; for (auto i = _changed.cbegin(); i != _changed.cend(); ++i) { if (!_is_step && user_cancelled()) { break; } if (!_is_step) { replace_wait_box("Applying codemap: %d/%d...", x, m); } ea_t addr = (ea_t)(*i | 0x800000); auto_make_code(addr); plan_ea(addr); show_addr(addr); x++; } if (!_is_step) { hide_wait_box(); } return 0; }};static void apply_codemap(const std::set<int32_t>& changed, bool is_step){ if (changed.empty()) return; apply_codemap_req req(changed, is_step); execute_sync(req, MFF_FAST);}
Если вкратце, то суть в использовании метода
execute_sync() и реализации своего варианта структуры
exec_request_t и её колбэка int idaapi
execute(void). Это рекомендованный разработчиками
способ.
Выводы и компиляция
Фактически, мы закончили писать свой собственный плагин-отладчик
для IDA. Мне показалось, что как раз для реализации общения между
Идой и эмулятором и создания отладчика Thrift подошёл как нельзя
кстати. С минимальными усилиями мне удалось написать и серверную и
клиентскую часть для обеих сущностей, не городя велосипеды в виде
открытия сокетов по разному для разных платформ, и изобретения RPC
реализации с нуля.
К тому же, получившийся протокол легко масштабируется под другие
методы и структуры и легко переносим.
Всем спасибо!
02.11.2020 16:19:26 |
Автор: 
Категории: 
