• załadować program lub dołączyć się do uruchomionego procesu w celu testowania go.
• otrzymywać niskopoziomowe informacje o testowanym programie, takie jak numer identyfikacyjny ID procesu, adres punktu uruchomieniowego, adres bazowy obrazu procesu itd.
• być informowanym o zdarzeniach związanych z testowaniem, takich jak uruchomienie lub zakończenie procesu lub wątku, załadowanie lub usunięcie biblioteki DLL itp.
• modyfikować testowany proces lub wątek.

1. Utwórz proces lub dołącz swój program do uruchomionego procesu. Jest to pierwszy krok w zastosowaniu funkcji uruchomieniowych Win32 API. Ponieważ twój program będzie pełnił rolę programu uruchomieniowego, musisz mieć jakiś program do testowania. Program ten możesz pozyskać na dwa sposoby:

• Możesz samemu utworzyć proces do testowania za pomocą funkcji CreateProcess. W parametrach wywołania musisz określić znacznik DEBUG_PROCESS, który poinformuje system Windows, iż chcemy testować ten proces. System będzie wysyłał do twojego programu powiadomienia o zdarzeniach istotnych z punktu widzenia testowania (debug events) występujących w uruchamianym procesie. Proces ten zostanie natychmiast zawieszony, aż twój program będzie gotowy. Jeśli uruchamiany proces utworzy procesy potomne, to system Windows będzie również przekazywał do twojego programu powiadomienia o zdarzeniach uruchomieniowych występujących we wszystkich tych procesach. Takie działanie zwykle jest niepożądane i możesz je zablokować określając znacznik DEBUG_ONLY_THIS_PROCESS w połączeniu z DEBUG_PROCESS.
• Możesz dołączyć swój program do uruchomionego procesu za pomocą DebugActiveProcess.

2. Zaczekaj na zdarzenia uruchomieniowe. Po uzyskaniu przez twój program procesu do testowania główny wątek tego procesu zostaje zawieszony aż do momentu, gdy twój program wywoła WaitForDebugEvent. Funkcja ta działa podobnie do innych funkcji typu WaitForXXX, tj. blokuje wywołujący ją wątek, aż wystąpi się oczekiwane zdarzenie. W tym przypadku oczekuje ona na wysłanie przez system Windows wiadomości o zdarzeniach uruchomieniowych. Zobaczmy na jej definicję:

WaitForDebugEvent PROTO lpDebugEvent:DWORD, dwMilliseconds:DWORD

• lpDebugEvent jest adresem struktury DEBUG_EVENT, która zostanie wypełniona informacją o zdarzeniu uruchomieniowym, które wystąpiło w testowanym procesie.
• dwMilliseconds jest długością czasu w milisekundach, przez który funkcja ta będzie oczekiwać na wystąpienie zdarzenia uruchomieniowego. Gdy okres ten minie i nie pojawi się żadne zdarzenie uruchomieniowe, funkcja WaitForDebugEvent powróci do programu wywołującego ją. Z drugiej strony określiwszy stałą INFINITE w tym argumencie funkcja nie powróci, aż do wystąpienia zdarzenia uruchomieniowego.

Teraz zbadajmy szczegółowo strukturę DEBUG_EVENT:

DEBUG_EVENT STRUCT 
    dwDebugEventCode DD ? 
    dwProcessId      DD ? 
    dwThreadId       DD ? 
    u                DEBUGSTRUCT 
DEBUG_EVENT ENDS

• dwDebugEventCode zawiera wartość określającą rodzaj występującego zdarzenia uruchomieniowego. W skrócie, może być wiele rodzajów zdarzeń, twój program musi sprawdzić wartość tego pola, aby zorientować się, które z nich wystąpiło i odpowiednio zareagować. Możliwe są następujące wartości:
  • CREATE_PROCESS_DEBUG_EVENT - tworzony jest proces. Zdarzenie to zostanie wysłane tuż po utworzeniu testowanego procesu (jeszcze nie uruchomionego) lub gdy program właśnie dołączył się do uruchomionego procesu przy pomocy DebugActiveProcess. Jest to pierwsze zdarzenie, które otrzyma twój program.
  • EXIT_PROCESS_DEBUG_EVENT - proces kończy działanie.
  • CREATE_THREAD_DEBUG_EVENT - w testowanym procesie powstaje nowy wątek lub gdy twój program po raz pierwszy dołącza się do uruchomionego procesu. Zwróć uwagę, iż nie otrzymasz tego powiadomienia przy tworzeniu głównego wątku testowanego procesu.
  • EXIT_THREAD_DEBUG_EVENT - wątek w testowanym procesie kończy działanie. Twój program nie otrzyma tego zdarzenia dla głównego wątku. W skrócie, możesz traktować główny wątek testowanego procesu jako sam testowany proces. Stąd gdy twój program zobaczy zdarzenie CREATE_PROCESS_DEBUG_EVENT, będzie to zdarzenie CREATE_THREAD_DEBUG_EVENT dla głównego wątku.
  • LOAD_DLL_DEBUG_EVENT - testowany proces ładuje bibliotekę DLL. Otrzymasz to zdarzenie, gdy program ładujący plik wykonywalny po raz pierwszy rozwiąże odwołania do bibliotek DLL (wywołujesz CreateProcess do załadowania procesu tekstowego) lub gdy proces testowany wywołuje funkcję LoadLibrary.
  • UNLOAD_DLL_DEBUG_EVENT - proces testowany usuwa bibliotekę DLL ze swojej przestrzeni adresowej.
  • EXCEPTION_DEBUG_EVENT - pojawił się wyjątek w testowanym procesie. Ważne: zdarzenie to pojawi się jeden raz tuż przed wykonaniem pierwszej instrukcji przez testowany proces. Wyjątek jest w rzeczywistości przerwaniem wykonania (int 3h). Jeśli chcesz wznowić wykonywanie procesu testowego, wywołaj ContinueDebugEvent z ustawionym znacznikiem DBG_CONTINUE. Nie używaj tutaj przypadkiem znacznika DBG_EXCEPTION_NOT_HANDLED, w przeciwnym wypadku proces testowy odmówi uruchomienia się w systemach Windows NT/2000/XP (pod Windows 98 działa to poprawnie).
  • OUTPUT_DEBUG_STRING_EVENT - to zdarzenie jest generowane, gdy testowany proces wywołuje funkcję DebugOutputString do wysłania wiadomości tekstowej do twojego programu.
  • RIP_EVENT - wystąpił systemowy błąd uruchamiania.
• dwProcessId i dwThreadId - są numerami ID procesu i wątku, gdzie wystąpiło zdarzenie uruchomieniowe. Możesz wykorzystać te wartości jako identyfikatory interesującego cię procesu lub wątku. Pamiętaj, iż jeśli zastosujesz funkcję CreateProcess do załadowania testowanego procesu, to otrzymasz również numery identyfikacyjne procesu i wątku w jego strukturze PROCESS_INFO. Możesz wykorzystać te wartości do rozróżniania zdarzeń uruchomieniowych występujących w testowanym procesie i jego procesach potomnych (o ile nie określisz znacznika DEBUG_ONLY_THIS_PROCESS).
• u - jest unią zawierającą więcej informacji na temat zdarzenia uruchomieniowego. W zależności od opisanej powyżej wartości dwDebugEventCode może to być jedna ze struktur:

  • CREATE_PROCESS_DEBUG_EVENT - struktura CREATE_PROCESS_DEBUG_INFO nazwana CreateProcessInfo

  • EXIT_PROCESS_DEBUG_EVENT - struktura EXIT_PROCESS_DEBUG_INFO nazwana ExitProcess

  • CREATE_THREAD_DEBUG_EVENT - struktura CREATE_THREAD_DEBUG_INFO nazwana CreateThread

  • EXIT_THREAD_DEBUG_EVENT - struktura EXIT_THREAD_DEBUG_EVENT nazwana ExitThread

  • LOAD_DLL_DEBUG_EVENT - struktura LOAD_DLL_DEBUG_INFO nazwana LoadDll

  • UNLOAD_DLL_DEBUG_EVENT - struktura UNLOAD_DLL_DEBUG_INFO nazwana UnloadDll

  • EXCEPTION_DEBUG_EVENT - struktura EXCEPTION_DEBUG_INFO nazwana Exception

  • OUTPUT_DEBUG_STRING_EVENT - struktura OUTPUT_DEBUG_STRING_INFO nazwana DebugString

  • RIP_EVENT - struktura RIP_INFO nazwana RipInfo

Na tej lekcji nie będę wchodził w szczegóły tych wszystkich struktur, jedynie zajmiemy się strukturą CREATE_PROCESS_DEBUG_INFO.

Załóżmy, iż nasz program wywołuje funkcję WaitForDebugEvent, która zwraca sterowanie. Pierwszą rzeczą do zrobienia jest sprawdzenie wartości pola dwDebugEventCode, aby dowiedzieć się, który rodzaj zdarzenia uruchomieniowego wystąpił w testowanym procesie. Na przykład, jeśli pole dwDebugEventCode zawiera wartość CREATE_PROCESS_DEBUG_EVENT, możesz zinterpretować zawartość pola u jako strukturę CreateProcessInfo i mieć dostęp do niej przez adresowanie u.CreateProcessInfo.

3. Wykonaj wszystko, co chcesz zrobić w odpowiedzi na wystąpienie danego zdarzenia uruchomieniowego. Gdy funkcja WaitForDebugEvent zwraca sterowanie, oznacza to, iż zdarzenie uruchomieniowe właśnie wystąpiło w testowanym procesie lub przekroczono zadany limit czasu. Twój program musi zbadać wartość pola dwDebugEventCode , aby poprawnie zareagować na dane zdarzenie. W tym sensie jest to podobne do przetwarzania wiadomości systemu Windows: wybierasz, na które reagować, a które zignorować.
4. Pozwól programowi uruchomieniowemu kontynuować wykonywanie. Gdy wystąpi zdarzenie uruchomieniowe, system Windows zawiesi proces testowany. Gdy zakończysz obsługę zdarzenia, musisz wznowić pracę procesu testowanego. Dokonujesz tego poprzez wywołanie funkcji ContinueDebugEvent.

ContinueDebugEvent PROTO dwProcessId:DWORD,\
                         dwThreadId:DWORD,\
                         dwContinueStatus:DWORD

Funkcja ta wznawia wykonywanie wątku, który został poprzednio zawieszony w wyniku wystąpienia zdarzenia uruchomieniowego.

• dwProcessId i dwThreadId są numerami identyfikacyjnymi ID procesu i wątku, które zostaną wznowione. Zwykle pobierasz te dwie wartości z pól dwProcessId i dwThreadId struktury DEBUG_EVENT.
• dwContinueStatus określa sposób kontynuacji wykonania wątku, który zgłosił dane zdarzenie uruchomieniowe. Istnieją dwie możliwe wartości: DBG_CONTINUE i DBG_EXCEPTION_NOT_HANDLED. Dla wszystkich innych zdarzeń uruchomieniowych wartości te pełnią tę samą funkcję: wznawiają wątek. Wyjątkiem jest EXCEPTION_DEBUG_EVENT. Jeśli wątek zgłasza zdarzenie uruchomieniowe wyjątku (exception debug event), oznacza to, iż wyjątek wystąpił w wątku testowanego procesu. Jeśli określisz DBG_CONTINUE, wątek zignoruje swoją własną obsługę wyjątku i będzie kontynuował wykonanie. W tym scenariuszu twój program sam musi zbadać i rozwiązać wyjątek, zanim wznowi wątek przy pomocy DBG_CONTINUE, w przeciwnym wypadku wyjątek będzie generowany bez końca. Jeśli określisz DBG_EXCEPTION_NOT_HANDLED, to twój program informuje system Windows, iż nie obsługuje tego wyjątku. Wtedy system powinien użyć standardowej obsługi wyjątków dla testowanego procesu.

5. Kontynuuj ten cykl w nieskończonej pętli, aż testowany proces zakończy swoje działanie. Pętla ta wygląda następująco:

.WHILE TRUE
        INVOKE WaitForDebugEvent, ADDR DebugEvent, INFINITE
        .BREAK .IF DebugEvent.dwDebugEventCode==EXIT_PROCESS_DEBUG_EVENT
        ...
        <Obsłóż zdarzenia uruchomieniowe>
        ...
        INVOKE ContinueDebugEvent, DebugEvent.dwProcessId,\
                                   DebugEvent.dwThreadId,\
                                   DBG_EXCEPTION_NOT_HANDLED 
    .ENDW

Jest tutaj jeden kruczek. Gdy już rozpoczniesz testowanie jakiegoś programu, nie możesz się po prostu odłączyć od niego aż do momentu, gdy zakończy on swoje działanie.

1. Utwórz proces lub dołącz swój program do uruchomionego procesu.
2. Zaczekaj na zdarzenia uruchomieniowe.
3. Wykonaj wszystko co należy w odpowiedzi na zdarzenie uruchomieniowe.
4. Pozwól testowanemu programowi kontynuować swoje działanie.
5. Powtarzaj ten cykl w nieskończonej pętli, aż testowany proces zakończy się.

.386

.MODEL FLAT, STDCALL

OPTION CASEMAP:NONE

INCLUDE    \masm32\include\windows.inc
INCLUDE    \masm32\include\kernel32.inc
INCLUDE    \masm32\include\comdlg32.inc
INCLUDE    \masm32\include\user32.inc
INCLUDELIB \masm32\lib\kernel32.lib
INCLUDELIB \masm32\lib\comdlg32.lib
INCLUDELIB \masm32\lib\user32.lib

.DATA

AppName      DB "Przykład nr 1 testowania Win32", 0
ofn          OPENFILENAME <>
FilterString DB "Pliki wykonywalne", 0, "*.exe", 0, "Wszystkie pliki", 0, "*.*", 0, 0
ExitProc     DB "Program testowany kończy działanie", 0      
NewThread    DB "Tworzony jest nowy wątek", 0
EndThread    DB "Usuwany jest wątek", 0
ProcessInfo  DB "Uchwyt pliku: %lx ", 0dh, 0Ah,
                "Uchwyt procesu: %lx", 0Dh, 0Ah,
                "Uchwyt wątku: %lx", 0Dh, 0Ah,
                "Podstawa obrazu: %lx", 0Dh, 0Ah,
                "Adres startowy: %lx", 0

.DATA?

buffer    DB 512 DUP(?)
startinfo STARTUPINFO <>
pi        PROCESS_INFORMATION <>
DBEvent   DEBUG_EVENT <>

.CODE

start:
    mov    ofn.lStructSize, SIZEOF ofn
    mov    ofn.lpstrFilter, OFFSET FilterString
    mov    ofn.lpstrFile, OFFSET buffer
    mov    ofn.nMaxFile, 512
    mov    ofn.Flags, OFN_FILEMUSTEXIST OR OFN_PATHMUSTEXIST OR \
                      OFN_LONGNAMES OR OFN_EXPLORER OR OFN_HIDEREADONLY
    INVOKE GetOpenFileName, ADDR ofn

    .IF eax==TRUE
        INVOKE GetStartupInfo, ADDR startinfo
        INVOKE CreateProcess, ADDR buffer, NULL, NULL, NULL, FALSE,
                              DEBUG_PROCESS + DEBUG_ONLY_THIS_PROCESS,
                              NULL, NULL, ADDR startinfo, ADDR pi
        .WHILE TRUE
            INVOKE WaitForDebugEvent, ADDR DBEvent, INFINITE
            .IF DBEvent.dwDebugEventCode==EXIT_PROCESS_DEBUG_EVENT
                INVOKE MessageBox, 0, ADDR ExitProc, ADDR AppName,
                                   MB_OK + MB_ICONINFORMATION
                .BREAK
            .ELSEIF DBEvent.dwDebugEventCode==CREATE_PROCESS_DEBUG_EVENT
                INVOKE wsprintf, ADDR buffer, ADDR ProcessInfo,
                                 DBEvent.u.CreateProcessInfo.hFile,
                                 DBEvent.u.CreateProcessInfo.hProcess,
                                 DBEvent.u.CreateProcessInfo.hThread,
                                 DBEvent.u.CreateProcessInfo.lpBaseOfImage,
                                 DBEvent.u.CreateProcessInfo.lpStartAddress
                INVOKE MessageBox, 0, ADDR buffer, ADDR AppName,
                                   MB_OK + MB_ICONINFORMATION
            .ELSEIF DBEvent.dwDebugEventCode==EXCEPTION_DEBUG_EVENT
                .IF DBEvent.u.Exception.pExceptionRecord.ExceptionCode==\
                    EXCEPTION_BREAKPOINT
                    INVOKE ContinueDebugEvent, DBEvent.dwProcessId,
                                               DBEvent.dwThreadId,
                                               DBG_CONTINUE   
                    .CONTINUE
                .ENDIF
            .ELSEIF DBEvent.dwDebugEventCode==CREATE_THREAD_DEBUG_EVENT
                INVOKE MessageBox, 0, ADDR NewThread, ADDR AppName,
                                   MB_OK + MB_ICONINFORMATION           
            .ELSEIF DBEvent.dwDebugEventCode==EXIT_THREAD_DEBUG_EVENT
                INVOKE MessageBox, 0, ADDR EndThread, ADDR AppName,
                                   MB_OK + MB_ICONINFORMATION           
            .ENDIF
            INVOKE ContinueDebugEvent, DBEvent.dwProcessId,
                                       DBEvent.dwThreadId,
                                       DBG_EXCEPTION_NOT_HANDLED
       
        .ENDW
    .ENDIF
    INVOKE CloseHandle, pi.hProcess
    INVOKE CloseHandle, pi.hThread
    INVOKE ExitProcess, 0

END start

    INVOKE GetStartupInfo, ADDR startinfo
    INVOKE CreateProcess, ADDR buffer, NULL, NULL, NULL, FALSE,
                          DEBUG_PROCESS + DEBUG_ONLY_THIS_PROCESS,
                          NULL, NULL, ADDR startinfo, ADDR pi

    .WHILE TRUE
        INVOKE WaitForDebugEvent, ADDR DBEvent, INFINITE

    .IF DBEvent.dwDebugEventCode==EXIT_PROCESS_DEBUG_EVENT
        INVOKE MessageBox, 0, ADDR ExitProc, ADDR AppName,
                           MB_OK + MB_ICONINFORMATION
        .BREAK

    .ELSEIF DBEvent.dwDebugEventCode==CREATE_PROCESS_DEBUG_EVENT
        INVOKE wsprintf, ADDR buffer, ADDR ProcessInfo,
                         DBEvent.u.CreateProcessInfo.hFile,
                         DBEvent.u.CreateProcessInfo.hProcess,
                         DBEvent.u.CreateProcessInfo.hThread,
                         DBEvent.u.CreateProcessInfo.lpBaseOfImage,
                         DBEvent.u.CreateProcessInfo.lpStartAddress
        INVOKE MessageBox, 0, ADDR buffer, ADDR AppName,
                           MB_OK + MB_ICONINFORMATION

    .ELSEIF DBEvent.dwDebugEventCode==EXCEPTION_DEBUG_EVENT
        .IF DBEvent.u.Exception.pExceptionRecord.ExceptionCode==\
            EXCEPTION_BREAKPOINT
            INVOKE ContinueDebugEvent, DBEvent.dwProcessId,
                                       DBEvent.dwThreadId,
                                       DBG_CONTINUE    
            .CONTINUE
        .ENDIF

    .ELSEIF DBEvent.dwDebugEventCode==CREATE_THREAD_DEBUG_EVENT
        INVOKE MessageBox, 0, ADDR NewThread, ADDR AppName,
                           MB_OK + MB_ICONINFORMATION            
    .ELSEIF DBEvent.dwDebugEventCode==EXIT_THREAD_DEBUG_EVENT
        INVOKE MessageBox, 0, ADDR EndThread, ADDR AppName,
                           MB_OK + MB_ICONINFORMATION            
    .ENDIF

        INVOKE ContinueDebugEvent, DBEvent.dwProcessId,
                                   DBEvent.dwThreadId,
                                   DBG_EXCEPTION_NOT_HANDLED
    .ENDW

    INVOKE CloseHandle, pi.hProcess
    INVOKE CloseHandle, pi.hThread
    INVOKE ExitProcess, 0

END start