[C++] Example_Loader

[Zer0Flag]

Hey,

Ich habe hier einen kleinen Loader für ein reverseMe von Lena151 gemacht. Bei diesem Target wäre ein Patch wohl einfacher gewesen aber ich dachte mir Übung schadet nie :). Hoffe iwer anderst kann mit dem Source auch noch etwas anfangen. Im Anhang befindet sich der Loader sowie das reverseME.




#include <Windows.h>

#define WIN32_LEAN_AND_MEAN
#define VC_EXTRALEAN

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {

/*
CPU Disasm
Address Hex dump Command Comments
0040107B EB 1D JMP SHORT reverseMe.0040109A
0040107D . 6A 00 PUSH 0 ; Type = MB_OK|MB_DEFBUTTON1|MB_APPLMODAL
0040107F . 68 00204000 PUSH OFFSET reverseMe.00402000 ; Caption = " Key File ReverseMe"
00401084 . 68 17204000 PUSH OFFSET reverseMe.00402017 ; Text = "Evaluation period out of date. Purchase new license"
00401089 . 6A 00 PUSH 0 ; hOwner = NULL
0040108B . E8 D7020000 CALL <JMP.&USER32.MessageBoxA> ; Jump to USER32.MessageBoxA
00401090 . E8 24020000 CALL <JMP.&KERNEL32.ExitProcess> ; KERNEL32.ExitProcess
00401095 . E9 83010000 JMP reverseMe.0040121D
0040109A > 6A 00 PUSH 0 ; pOverlapped = NULL
0040109C . 68 73214000 PUSH OFFSET reverseMe.00402173 ; pBytesRead = reverseMe.402173 -> 0
004010A1 . 6A 46 PUSH 46 ; Size = 70.
004010A3 . 68 1A214000 PUSH OFFSET reverseMe.0040211A ; Buffer = reverseMe.40211A -> 00
004010A8 . 50 PUSH EAX ; hFile
004010A9 . E8 2F020000 CALL <JMP.&KERNEL32.ReadFile> ; KERNEL32.ReadFile
004010AE . 85C0 TEST EAX,EAX
004010B0 EB 02 JMP SHORT reverseMe.004010B4
004010B2 . EB 43 JMP SHORT reverseMe.004010F7
004010B4 > 33DB XOR EBX,EBX
004010B6 . 33F6 XOR ESI,ESI
004010B8 . 833D 73214000 1 CMP DWORD PTR DS:[reverseMe.402173],10
004010BF 90 NOP
004010C0 90 NOP
004010C1 > 8A83 1A214000 MOV AL,BYTE PTR DS:[EBX+reverseMe.40211A
004010C7 . 3C 00 CMP AL,0
004010C9 EB 08 JMP SHORT reverseMe.004010D3
004010CB . 3C 47 CMP AL,47
004010CD . 75 01 JNE SHORT reverseMe.004010D0
004010CF . 46 INC ESI
004010D0 > 43 INC EBX
004010D1 . EB EE JMP SHORT reverseMe.004010C1
004010D3 > 83FE 08 CMP ESI,8
004010D6 90 NOP
004010D7 90 NOP
*/
CONTEXT* tCONTEXT = 0;
STARTUPINFO* tSTARTUPINFO = 0;
PROCESS_INFORMATION* tPROCESS_INFORMATION = 0;

DWORD Patch1 = 0x40107B;
DWORD Patch2 = 0x4010B0;
DWORD Patch3 = 0x4010BF;
DWORD Patch4 = 0x4010C9;
DWORD Patch5 = 0x4010D6;

UCHAR PatchVal1[] = "\xEB\x1D";
UCHAR PatchVal2[] = "\xEB\x02";
UCHAR PatchVal3[] = "\x90\x90";
UCHAR PatchVal4[] = "\xEB\x08";
UCHAR PatchVal5[] = "\x90\x90";

char* cCommandLine = GetCommandLine();

tCONTEXT = (CONTEXT*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CONTEXT));
tSTARTUPINFO = (STARTUPINFO*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(STARTUPINFO));
tPROCESS_INFORMATION = (PROCESS_INFORMATION*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PROCESS_INFORMATION));

tCONTEXT->ContextFlags = CONTEXT_FULL;
tSTARTUPINFO->cb = sizeof(STARTUPINFO);


if(CreateProcessA("reverseMe.exe", cCommandLine, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, tSTARTUPINFO, tPROCESS_INFORMATION)){

WriteProcessMemory(tPROCESS_INFORMATION->hProcess, (LPVOID)Patch1, &PatchVal1, sizeof(PatchVal1)-1, NULL);
WriteProcessMemory(tPROCESS_INFORMATION->hProcess, (LPVOID)Patch2, &PatchVal2, sizeof(PatchVal2)-1, NULL);
WriteProcessMemory(tPROCESS_INFORMATION->hProcess, (LPVOID)Patch3, &PatchVal3, sizeof(PatchVal3)-1, NULL);
WriteProcessMemory(tPROCESS_INFORMATION->hProcess, (LPVOID)Patch4, &PatchVal4, sizeof(PatchVal4)-1, NULL);
WriteProcessMemory(tPROCESS_INFORMATION->hProcess, (LPVOID)Patch5, &PatchVal5, sizeof(PatchVal5)-1, NULL);


ResumeThread(tPROCESS_INFORMATION->hThread);
}

return 0;
}



Download:
http://www.multiupload.com/YKCNJU4Y38

~Zer0Flag

[l0dsb]

Erst einmal Danke für das Posten (auch wenn ich den Post vorher schon auf drei anderen (RCE-)Boards sah :)). Ich hoffe, die konstruktive Kritik hilft dir weiter:

Wieso allokierst du CONTEXT-, STARTUP- und PROCESS_INFORMATION-Strukturen auf dem Heap? Wie Op schon sagte, wäre da new (und ein passendes delete, bei dir vermisse ich HeapFree) angebracht.

Selbst dann ist es doch viel einfacher, das ganze auf dem Stack zu allokieren - die Strukturen sind nicht wirklich groß und die Stackvariante ist wesentlich einfacher zu schreiben und letzten Endes vermutlich noch performanter (kein Memory-Leak ;)).

Du solltest dir noch im Klaren darüber sein, dass GetCommandLine auch den Pfad der eigenen Anwendung beinhaltet, diesen müsstest du also zuerst "rausschneiden" - oder einfach den passenden Parameter von WinMain verwenden.

VC_EXTRALEAN und WIN32_LEAN_AND_MEAN sind bei so einem Projekt unnötig, selbst bei größeren konnte ich nie einen wirklichen Unterschied in der Build-Geschwindigkeit feststellen. Die würde ich weglassen, zusätzliche Schreibarbeit. :)

Zuletzt wären noch Fehlerabfragen bei WriteProcessMemory sinnvoll und natürlich die Überprüfung per ReadProcessMemory, ob die zu patchende Location auch den richtigen Wert beinhaltet (bzw. für ganz paranoide noch eine Checksum über die ganze Binary).

Die Patches selbst (Adressen, alte und neue Werte) kann man prima in ein Array verlagern, somit spart man sich das Kopieren des WriteProcessMemory-Aufrufs und muss lediglich einen neuen Datensatz einfügen.