Отладка процесса, запущенного другим процессом

В общем, нужно начать отлаживание программы в тот момент, когда управление передаётся на её точку входа. Целевая программа запускается загрузчиком, который динамически генерирует передаваемую командную строку, т.е. самостоятельный запуск целевого процесса без реверса загрузчика невозможен.
Как вариант - запускать загрузчик с DEBUG_ACTIVE_PROCESS и реагировать на CREATE_PROCESS_DEBUG_EVENT. Есть ли другие способы?

 

int3 на EP?

 

n0name
Пропатчить файл нельзя. Пропатчить память можно, но это нужно сделать до того как управление попадёт на EP. Собственно, вопрос в том, как отловить этот момент.

 

кинуть любую длл-ку из импорта второго екзешника рядом с ним и на DLL_PROCESS_ATTACH что-то сделать. Только я забыл будет ли сначала браться длл-ка из текущей директории))) Только чем не подходит твой вариант?

 

Да на крайняк можно и оригинал пропатчить.

 

onSide
Интересный вариант Но мой проще, ведь в этом придётся создавать модифицированную DLL + следить за тем, кто её загружает.

Всем подходит, но может быть есть штатные способы проще?

 

KeSqueer
Хардварные брейки использовать. Или контекст изменить, например взвести TF, затем откатать фолт. Или в системный лодер брейков поставить. Не понятно в чём проблема, опишите подробно.

 

А почему нельзя элементарно поставить хук на CreateProcess в лоадере, создать его саспендед и вставить АРС?

Где все это делать если не трогать первый процесс? А изначально задача стояла именно так) Как узнать что он вообще создался и сделать что-то до ЕР? Что-то не врубаюсь)

 

onSide
Почему нельзя трогать процесс ?

 

Clerk
Имеется приложение А, которое запускает приложение Б, и только А может запустить Б. Нужно получать значения аргументов некоторой процедуры в приложении Б, в то время пока оно работает. Чтобы осуществить задуманное, можно запустить А в режиме отладки и с WaitForDebugEvent ловить CREATE_PROCESS_DEBUG_EVENT, во время которого можно поставить брейк на начало нужной процедуры (int3), а далее обрабатывать EXCEPTION_DEBUG_EVENT + EXCEPTION_BREAKPOINT. По приходу оного, сверять адрес исключения, и получать значения регистров (GetThreadContext) => значения аргументов (ReadProcessMemory).
Можно просто приаттачиться к работающему приложению Б (DebugActiveProcess), но тогда теряется часть передаваемых целевой процедуре параметров, которые были переданы до присоединения отлаживающего приложения.
Есть ли другие варианты, как например нотификация моего приложения, что создан некий процесс.
Хотел задать вопрос позже, но раз уж зашло дело... Понимаю, что идея с софтварными брейками не лучшая также, т.к. создаёт много геморроя при патче. Хардварными, к сожалению, не умею пользоваться, но они были бы кстати. Про системный лодер брейков не слышал.

 

KeSqueer
Удалённая обработка исключений в юзермоде возможна только посредством отладочного порта, поэтому решение его использовать верное. Мониторить CREATE_THREAD_DEBUG_EVENT, устанавливать хардварный брейк на исполнение процедуры, ловить EXCEPTION_DEBUG_EVENT(STATUS_SINGLE_STEP).

 

Clerk

Отладка идёт локально.
Как устанавливать хардварные брейки вроде нашел. Единственной небольшой проблемой может быть то, что нужную процедуру могут использовать несколько потоков, т.е. придётся для всех потоков целевого процесса выполнять установку брейков.
Хорошо, с этим более-менее всё ясно. Ещё пара вопросов.
1) Один из параметров исследуемой процедуры является указателем на ASCIIZ-строку, длина которой заранее неизвестна. Чтобы получить строку можно вызвать ReadProcessMemory с довольно большим значением количества считывемых байтов, но есть риск выйти за границы. Как правильно организовать чтение? Нужно получать карту памяти процесса и проверять какому диапазону принадлежит адрес?
2) Поясните, пожалуйста насчёт поля DEBUG_EVENT.u.Exception.dwFirstChance и ContinueDebugEvent(DBG_CONTINUE / DBG_EXCEPTION_NOT_HANDLED). Не пойму как правильно обрабатывать исключения по значению dwFirstChance и что после обработки/необработки передавать в ContinueDebugEvent - DBG_CONTINUE или DBG_EXCEPTION_NOT_HANDLED. Просто, при отладке приложения, кроме брейка, который установил я, срабатывают другие, где-то в недрах ntdll.dll, которые мне ловить не нужно. Как на них реагировать, т.е. что передавать в ContinueDebugEvent если поймалось исключение, которое вызвали не мои действия? На данный момент просто передаю DBG_CONTINUE.

 

KeSqueer
Когда приходит сообщение CREATE_THREAD_DEBUG_EVENT получаете контекст потока, загружаете в Dr[0%3] адрес процедуры, в Dr7 флажки(для Dr0: HB_0_ON_LOCAL | HB_LOCALS_ENABLE | HB_0_TYPE_EXEC):

Код (Text):

1. ; DR7
2. HB_3_SIZE_BYTE      equ 00000000000000000000000000000000B
3. HB_3_SIZE_WORD      equ 01000000000000000000000000000000B
4. HB_3_SIZE_LONG      equ 11000000000000000000000000000000B
5.  
6. HB_3_TYPE_EXEC      equ 00000000000000000000000000000000B
7. HB_3_TYPE_WRITE equ 00010000000000000000000000000000B
8. HB_3_TYPE_IO        equ 00100000000000000000000000000000B
9. HB_3_TYPE_RW        equ 00110000000000000000000000000000B
10.  
11. HB_2_SIZE_BYTE      equ 00000000000000000000000000000000B
12. HB_2_SIZE_WORD      equ 00000100000000000000000000000000B
13. HB_2_SIZE_LONG      equ 00001100000000000000000000000000B
14.  
15. HB_2_TYPE_EXEC      equ 00000000000000000000000000000000B
16. HB_2_TYPE_WRITE equ 00000001000000000000000000000000B
17. HB_2_TYPE_IO        equ 00000010000000000000000000000000B
18. HB_2_TYPE_RW        equ 00000011000000000000000000000000B
19.  
20. HB_1_SIZE_BYTE      equ 00000000000000000000000000000000B
21. HB_1_SIZE_WORD      equ 00000000010000000000000000000000B
22. HB_1_SIZE_LONG      equ 00000000110000000000000000000000B
23.  
24. HB_1_TYPE_EXEC      equ 00000000000000000000000000000000B
25. HB_1_TYPE_WRITE equ 00000000000100000000000000000000B
26. HB_1_TYPE_IO        equ 00000000001000000000000000000000B
27. HB_1_TYPE_RW        equ 00000000001100000000000000000000B
28.  
29. HB_0_SIZE_BYTE      equ 00000000000000000000000000000000B
30. HB_0_SIZE_WORD      equ 00000000000001000000000000000000B
31. HB_0_SIZE_LONG      equ 00000000000011000000000000000000B
32.  
33. HB_0_TYPE_EXEC      equ 00000000000000000000000000000000B
34. HB_0_TYPE_WRITE equ 00000000000000010000000000000000B
35. HB_0_TYPE_IO        equ 00000000000000100000000000000000B
36. HB_0_TYPE_RW        equ 00000000000000110000000000000000B
37.  
38. HB_PROTECT_ENABLE   equ 00000000000000000010000000000000B
39. HB_GLOBALS_ENABLE   equ 00000000000000000000001000000000B
40. HB_LOCALS_ENABLE    equ 00000000000000000000000100000000B
41.  
42. HB_3_ON_GLOBAL      equ 00000000000000000000000010000000B
43. HB_3_ON_LOCAL       equ 00000000000000000000000001000000B
44. HB_2_ON_GLOBAL      equ 00000000000000000000000000100000B
45. HB_2_ON_LOCAL       equ 00000000000000000000000000010000B
46. HB_1_ON_GLOBAL      equ 00000000000000000000000000001000B
47. HB_1_ON_LOCAL       equ 00000000000000000000000000000100B
48. HB_0_ON_GLOBAL      equ 00000000000000000000000000000010B
49. HB_0_ON_LOCAL       equ 00000000000000000000000000000001B
50.  
51. ; DR6
52. HB_EVENT_BREAK_0    equ 00000000000000000000000000000001B
53. HB_EVENT_BREAK_1    equ 00000000000000000000000000000010B
54. HB_EVENT_BREAK_2    equ 00000000000000000000000000000100B
55. HB_EVENT_BREAK_3    equ 00000000000000000000000000001000B
56. HB_EVENT_PROTECT    equ 00000000000000000010000000000000B
57. HB_EVENT_TRAP       equ 00000000000000000100000000000000B
58. HB_EVENT_TSS        equ 00000000000000001000000000000000B

Когда произойдёт останов на порт доставляется #STATUS_SINGLE_STEP.
1. Получить размер региона памяти на основе ссылки, тоесть NtQueryVirtualMemory/NtReadVirtualMemory. Обычно передаётся размер строки, также у строк имеется лимит. Строка может быть в модуле, тогда проверяется вхождение в него. Может быть в хипе, тогда можно сделать слепок, но с этим могут быть проблемы, так как используются удалённые потоки(хотя он и скрыт от отладчика - PS_CROSS_THREAD_FLAGS_HIDEFROMDBG).
2.

 

Clerk
Благодарю

 

Странное что-то творится. После первого события CREATE_PROCESS_DEBUG_EVENT приходит EXCEPTION_BREAKPOINT с адресом 0x7C90120E. Гугль говорит что это фэйл Майкрософта, и вместо возвращения корректного значения из функции с соответствующей установкой LastError вызывает DbgBreakPoint. По ответу Клерка на мой вопрос №2 (#12 -> #13), при dwFirstChance != 0 отправляю исключение путешествовать по фреймам, а вместо этого получаю MessageBox следующего содержания:

Код (Text):

1. ---------------------------
2. warpatch.exe - Ошибка приложения
3. ---------------------------
4. Ошибка при инициализации приложения (0x80000003). Для выхода из приложения нажмите кнопку "ОК".
5. ---------------------------
6. ОК  
7. ---------------------------

После него еще один такой же MessageBox, потом приходит следующее EXCEPTION_BREAKPOINT с адресом 0x7C96478E (тоже легко гуглится, сошлём это на ошибку программиста) и dwFirstChance != 0. Отвечая на него опять же ContinueDebugEvent(DBG_EXCEPTION_NOT_HANDLED) я его получаю второй раз, но с уже dwFirstChance = 0. После этого начинается самое интересное - нескончаемо приходят EXCEPTION_ACCESS_VIOLATION по адресу 0x80000003 (странно, но этот адрес = EXCEPTION_BREAKPOINT).

 

Код:

Код (Text):

1. #define _WIN32_WINNT 0x500
2. #include <windows.h>
3. #include <psapi.h>
4. #pragma comment(lib, "psapi.lib")
5.  
6. #include <stdlib.h>
7. #include <stdio.h>
8. #include <string.h>
9. #include <assert.h>
10.  
11. void DebugLoop(void)
12. {
13.     TCHAR           szModuleName[MAX_PATH];
14.     DWORD           dwModuleNameLen;
15.     DEBUG_EVENT     DbgEvent;
16.     HANDLE          hProcess;
17.     BOOL            bRet;
18.  
19.     for (;;)
20.     {
21.         DWORD   dwContinueStatus = DBG_CONTINUE;
22.  
23.         bRet = WaitForDebugEvent(&DbgEvent, INFINITE);
24.         assert(bRet);
25.         switch (DbgEvent.dwDebugEventCode)
26.         {
27.         case EXCEPTION_DEBUG_EVENT:
28.             {
29.                 EXCEPTION_RECORD *pER = &DbgEvent.u.Exception.ExceptionRecord;
30.                 wprintf(L"Caught an exception:\t[0x%08X] at address [0x%08p] PID=%d TID=%d\n",
31.                     pER->ExceptionCode, pER->ExceptionAddress, DbgEvent.dwProcessId, DbgEvent.dwThreadId);
32.             }
33.             if (DbgEvent.u.Exception.dwFirstChance)
34.                 dwContinueStatus = DBG_EXCEPTION_NOT_HANDLED;
35.             break;
36.         case CREATE_THREAD_DEBUG_EVENT:
37.             wprintf(L"Thread Created:\t\tPID=%d TID=%d\n", DbgEvent.dwProcessId, DbgEvent.dwThreadId);
38.             break;
39.         case CREATE_PROCESS_DEBUG_EVENT:
40.             CloseHandle(DbgEvent.u.CreateProcessInfo.hFile);
41.             dwModuleNameLen = GetProcessImageFileName(DbgEvent.u.CreateProcessInfo.hProcess, szModuleName, _countof(szModuleName));
42.             wprintf(L"Process Created:\t%ls PID=%d TID=%d\n", wcsrchr(szModuleName, '\\')+1, DbgEvent.dwProcessId, DbgEvent.dwThreadId);
43.             break;
44.         case EXIT_THREAD_DEBUG_EVENT:
45.             wprintf(L"Thread Terminated:\tPID=%d TID=%d\n", DbgEvent.dwProcessId, DbgEvent.dwThreadId);
46.             break;
47.         case EXIT_PROCESS_DEBUG_EVENT:
48.             hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, DbgEvent.dwProcessId);
49.             dwModuleNameLen = GetProcessImageFileName(hProcess, szModuleName, _countof(szModuleName));
50.             CloseHandle(hProcess);
51.             wprintf(L"Process Terminated:\t%ls PID=%d TID=%d\n", wcsrchr(szModuleName, '\\')+1, DbgEvent.dwProcessId, DbgEvent.dwThreadId);
52.             break;
53.         case LOAD_DLL_DEBUG_EVENT:
54.             CloseHandle(DbgEvent.u.LoadDll.hFile);
55.             break;
56.         }
57.         bRet = ContinueDebugEvent(DbgEvent.dwProcessId, DbgEvent.dwThreadId, dwContinueStatus);
58.         assert(bRet);
59.     }
60. }
61.  
62. BOOL EnableDebugPrivilege(void)
63. {
64.     HANDLE  hToken;
65.     BOOL    bRet = FALSE;
66.     if (OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES, &hToken))
67.     {
68.         LUID    Luid;
69.         if (LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &Luid))
70.         {
71.             TOKEN_PRIVILEGES    tp;
72.             tp.PrivilegeCount = 1;
73.             tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
74.             tp.Privileges[0].Luid = Luid;
75.             if (AdjustTokenPrivileges(hToken, FALSE, &tp, sizeof(tp), NULL, 0) && GetLastError() != ERROR_NOT_ALL_ASSIGNED)
76.                 bRet = TRUE;
77.         }
78.         CloseHandle(hToken);
79.     }
80.     return bRet;
81. }
82.  
83. int wmain(void)
84. {
85.     STARTUPINFO         StartupInfo;
86.     PROCESS_INFORMATION ProcessInfo;
87.     BOOL                bRet;
88.     LPCWSTR             pszCurDir = L"D:\\Games\\WARHAM~1";
89.     LPCWSTR             pszAppName = L"D:\\Games\\WARHAM~1\\warpatch.exe";
90.     LPWSTR              pszCommandLine = _wcsdup(pszAppName);
91.  
92.     bRet = EnableDebugPrivilege();
93.     assert(bRet);
94.     ZeroMemory(&StartupInfo, sizeof(StartupInfo));
95.     StartupInfo.cb = sizeof(StartupInfo);
96.     StartupInfo.dwFlags = CREATE_UNICODE_ENVIRONMENT;
97.     bRet = CreateProcess(pszAppName, pszCommandLine, NULL, NULL, FALSE, DEBUG_PROCESS, NULL, pszCurDir, &StartupInfo, &ProcessInfo);
98.     assert(bRet);
99.     CloseHandle(ProcessInfo.hThread);
100.     CloseHandle(ProcessInfo.hProcess);
101.     DebugSetProcessKillOnExit(FALSE);
102.     DebugLoop();
103.  
104.     free(pszCommandLine);
105.     return 0;
106. }

Результат работы с ответом DBG_EXCEPTION_NOT_HANDLED при dwFirstChance != 0:

Код (Text):

1. Process Created:        warpatch.exe PID=2996 TID=1664
2. Caught an exception:    [0x80000003] at address [0x7C90120E] PID=2996 TID=1664
3. Caught an exception:    [0x80000003] at address [0x7C96478E] PID=2996 TID=1664
4. Caught an exception:    [0x80000003] at address [0x7C96478E] PID=2996 TID=1664
5. Caught an exception:    [0xC0000005] at address [0x80000003] PID=2996 TID=1664
6. Caught an exception:    [0xC0000005] at address [0x80000003] PID=2996 TID=1664
7. Caught an exception:    [0xC0000005] at address [0x80000003] PID=2996 TID=1664
8. Caught an exception:    [0xC0000005] at address [0x80000003] PID=2996 TID=1664
9. Caught an exception:    [0xC0000005] at address [0x80000003] PID=2996 TID=1664
10. ...

Результат работы с ответом DBG_CONTINUE при любом dwFirstChance (рабочий вариант):

Код (Text):

1. Process Created:        warpatch.exe PID=1296 TID=2824
2. Caught an exception:    [0x80000003] at address [0x7C90120E] PID=1296 TID=2824
3. Thread Created:         PID=1296 TID=2176
4. Thread Created:         PID=1296 TID=3060
5. Thread Created:         PID=1296 TID=3188
6. Thread Created:         PID=1296 TID=1192
7. Thread Created:         PID=1296 TID=2912
8. Thread Created:         PID=1296 TID=1752
9. Thread Created:         PID=1296 TID=252
10. Thread Created:         PID=1296 TID=3676
11. Thread Terminated:      PID=1296 TID=1752
12. Thread Created:         PID=1296 TID=460
13. Thread Terminated:      PID=1296 TID=3188
14. Thread Terminated:      PID=1296 TID=460
15. Thread Terminated:      PID=1296 TID=1192
16. Thread Terminated:      PID=1296 TID=2912
17. Thread Terminated:      PID=1296 TID=252
18. Process Created:        warpatch.bin PID=3572 TID=2296
19. Thread Terminated:      PID=1296 TID=3060
20. Thread Terminated:      PID=1296 TID=2176
21. Thread Terminated:      PID=1296 TID=3676
22. Caught an exception:    [0x80000003] at address [0x7C90120E] PID=3572 TID=2296
23. Process Terminated:     warpatch.exe PID=1296 TID=2824
24. Thread Created:         PID=3572 TID=3692
25. Thread Created:         PID=3572 TID=3196
26. Thread Created:         PID=3572 TID=3308
27. Thread Created:         PID=3572 TID=704
28. Thread Created:         PID=3572 TID=204
29. Thread Created:         PID=3572 TID=2576
30. Thread Created:         PID=3572 TID=1748
31. Thread Created:         PID=3572 TID=1340
32. Thread Created:         PID=3572 TID=3216
33. Thread Created:         PID=3572 TID=3252
34. Thread Created:         PID=3572 TID=3640
35. Thread Terminated:      PID=3572 TID=2576
36. Thread Created:         PID=3572 TID=1440
37. Thread Created:         PID=3572 TID=4092
38. Thread Created:         PID=3572 TID=848
39. Thread Created:         PID=3572 TID=3900
40. Thread Created:         PID=3572 TID=1068
41. Thread Created:         PID=3572 TID=1356
42. Thread Created:         PID=3572 TID=216
43. Thread Terminated:      PID=3572 TID=3640
44. Thread Created:         PID=3572 TID=3088
45. Thread Created:         PID=3572 TID=1116
46. Thread Created:         PID=3572 TID=3596
47. Thread Terminated:      PID=3572 TID=3596
48. Thread Terminated:      PID=3572 TID=3308
49. Thread Terminated:      PID=3572 TID=1748
50. Thread Terminated:      PID=3572 TID=704
51. Thread Terminated:      PID=3572 TID=204
52. Thread Terminated:      PID=3572 TID=3692
53. Thread Terminated:      PID=3572 TID=3196
54. Thread Terminated:      PID=3572 TID=1340
55. Thread Terminated:      PID=3572 TID=3216
56. Thread Terminated:      PID=3572 TID=4092
57. Thread Terminated:      PID=3572 TID=3252
58. Thread Terminated:      PID=3572 TID=1440
59. Thread Terminated:      PID=3572 TID=3900
60. Thread Terminated:      PID=3572 TID=3088
61. Thread Terminated:      PID=3572 TID=1116
62. Thread Terminated:      PID=3572 TID=216
63. Thread Terminated:      PID=3572 TID=1068
64. Thread Terminated:      PID=3572 TID=848
65. Thread Terminated:      PID=3572 TID=1356
66. Process Terminated:     warpatch.bin PID=3572 TID=2296

 

Наверное стоит отметить, что первый брейк возникает только при наличии отладчика, т.к. походу приложение его не ловит, из за чего и возникает MessageBox. Другое дело - не понятно почему он (MessageBox) возникает после dwFirstChance !=0, а не после dwFirstChance = 0. Кроме того, второй брейк (тот что по другому адресу) не возникает, если в ответ на первый послать DBG_CONTINUE.
Далее встречаются другие исключения (например invalid instruction при попытке выполнить некоторые SSSE-инструкции), которые корректно обрабатываются самим приложением в своих SEH фреймах после ContinueDebugEvent(DBG_EXCEPTION_NOT_HANDLED) в ответ на dwFirstChance != 0.

 

KeSqueer
Первый брейк, генерируемый в ntdll.DbgBreakPoint, предназначен именно отладчику, и соотв-но в ответ на него нужно слать DBG_CONTINUE

 

leo
Вот те на
А это где-то сказано? Видимо упустил.

 

Это как-бы "хорошо известно"
О том, что это спец-брик для отладчика у Руссиновича сказано (в описании создания процесса). Да и на "бытовом уровне" работы с OllyDbg этот system breakpoint "невооруженным глазом видно" Ну а то, что на него нужно выдавать DBG_CONTINUE - это уже просто следствие того, что этот брик предназначен отладчику - типа отладчик его получил и сказал "спасибо", и соотв-но далее искать какой-то SEH-обработчик этого исключения в самой проге не нужно