[Pytanie] Wstrzykiwanie bibliotek w VC

Propagandhi · 23 Listopada 2008

Temat wydaje się oklepany, bo o dll injecting można poczytać na niemal każdym forum o hackowaniu gier. Niemniej jednak chciałem tę technikę objaśnić, choćby z tego względu, że sam zacząłem się uczyć C++ niedawno i wiem jakie potknięcia można zrobić przy pisaniu podobnego projektu z perspektywy nowicjusza (ale nie kompletnego! zakladam, że taki ktoś ma jakąś szcvzatkową wiedzę). Program do wstrzykiwania napisałem w C++/CLI tak aby możliwe maksymalnie wykorzystać dobrodziejstwa związane ze środowiskiem .NET.

Jak zauważycie jakieś błędy merytoryczne, to piszcie.

To, co chce zrobić, to opisać program do wstrzykiwania i dynamiczną bibliotekę, która będzie uruchomiała funkcje ESP w WarRock. Od razu sobie zastrzegam, że aplikacja działa, ale jest wykrywalna przez HackShield. Nie mam czasu na obrazki, ale może kiedyś o nie ten wątek uzupełnię.

Adres ESP by Zdzisek: http://www.mpcforum.pl/index.php?showtopic=20012 na dzień 19.11.2008

Visual C++ 2008 (9.0) Express Edition: http://www.microsoft.com/express/download/ Jak ktoś ma wersje 2005, to też może spróbować.

1. Program do wstrzykiwania biblioteki

Tworzymy nowy projekt VC++: CLR->Windows Form Application. CLR z tego względu, że będziemy korzystać również ze środowiska .NET.

W oknie projektu dodajemy przycisk i timer. Przycisk bedzie uruchamiał timer, a timer będzie czekał na pojawienie się naszej gry, albo inne aplikacji i wtedy wstrzykiwał bibliotekę.

Klikamy dwa razy na przycisk i w jego kodzie tj między nawias { i } wpisujemy kod do uruchomienia naszego timera:

                 timer1->Enabled = true;

W efekcie powinno to wyglądać mniej więcej tak:

    
private: System::Void button1_Click(System::Object^  sender, System::EventArgs^  e) 
              {
                  timer1->Enabled = true;
              }

W kodzie timera wrzuciłem coś takiego:

if (wstrzykniety == false)
                  {
                     array<Process^>^aplikacja = System::Diagnostics::Process::GetProcessesByName("WarRock");
                      if (aplikacja->Length != 0)
                  {
                         zastrzyk();
                         wstrzykniety = true;
                         //Application::Exit();

Zmienną "wstrzyknięty" zadeklarowałem przed nazwą klasy tj na początku pliku Form1.h, powiedzmy po "using namespace System::Drawing;" (dodajcie przy tym jeszcze taką linijke: using namespace System::Diagnostics;) i przypisałem jej wartość fałszu. Powyższy kod będzie po wciśnięciu przycisku sprawdzał co interwał timera czy proces (w tym przypadku Warrock) jest włączony i jeśli tak to wstrzyknie bibliotekę. Gdy to zrobi zmienna wstrzyknięty zmieni wartość na prawdę i nie będzie sprawdzał dalej. Jako komentarz dodałem Application::Exit();, bo na dobrą sprawę po wstrzyknięciu program wstrzykujący nie musi być już włączony.

Na samym początku pliku Form1.h należy dodać jeszcze taką linijkę:

#include <windows.h>

Jest to informacja o pliku nagłówkowym w którym znajdują się definicje potrzebnych nam funkcji API. Bardzo ważna.

Teraz najważniejsza i ostatnia część programu do wstrzykiwania tj funkcja wstrzykująca, która w timerze u mnie pojawia się jako zastrzyk().

Wprowadzamy ją w ciele klasy po słowie "private:"

void zastrzyk()
         {
         HANDLE uWatku; 
         //char sciezkaBib[] = {"C:\\poligon2\\prop32.dll"};
         char sciezkaBib[] = {"prop32.dll"};
         void* adrBib;
         DWORD uBibMod;
         HMODULE uKernel32 = ::GetModuleHandle("Kernel32");
         array<Process^>^gra = System::Diagnostics::Process::GetProcessesByName("WarRock");
         HANDLE uProcesu = OpenProcess(PROCESS_ALL_ACCESS, FALSE, gra[0]->Id);
         adrBib = ::VirtualAllocEx(uProcesu, NULL, sizeof(sciezkaBib),MEM_COMMIT, PAGE_READWRITE );
         ::WriteProcessMemory(uProcesu, adrBib, (void*)sciezkaBib, sizeof(sciezkaBib), NULL );
         uWatku = ::CreateRemoteThread( uProcesu, NULL, 0,(LPTHREAD_START_ROUTINE) ::GetProcAddress( uKernel32,"LoadLibraryA" ),adrBib, 0, NULL );
         ::WaitForSingleObject( uWatku, INFINITE );
         ::GetExitCodeThread( uWatku, &uBibMod );
         ::CloseHandle( uWatku );
        ::CloseHandle( uProcesu ); //poprawione
         ::VirtualFreeEx( uProcesu, adrBib, sizeof(sciezkaBib), MEM_RELEASE );
         }

Po kolei postaram się objaśnić co jest czym. Generalnie sam "zastrzyk" sprowadza się do kilku czynności:

- otwieramy proces

- alokujemy miejsce w pamięci wirtualnej naszego programu na nazwę biblioteki

- zapisujemy tę nazwę w pamięci

- tworzymy zdalny wątek do sterowania biblioteką

- czekamy aż się wykona

HANDLE uWatku; - to uchwyt do wątku

char sciezkaBib[] = {"prop32.dll"}; - to dość istotna rzecz. Jest to ścieżka do naszej biblioteki. U mnie w zasadzie nie ścieżka a sama jej nazwa, jednak tak zadeklorowana będzie działała tylko jeśli program do wstrzykiwania oraz biblioteka będą w tym samym katalogu co program w który wstrzykujemy, bo inaczej się nie odnajdzie. jeśli chcemy podać od razu pełną ścieżkę, to np w taki sposób char sciezkaBib[] = {"C:\\poligon2\\prop32.dll"};. Wtedy zastrzyk powinien działać niezależnie od położenia programu wstrzykującego i programu w który wstrzykujemy.

void* adrBib; - tu będzie przechowywany adres pamięci do którego zostanie zapisana biblioteka

DWORD uBibMod; - tu będzie przechowywana informacja o stanie wątku po jego wykonaniu

HMODULE uKernel32 = ::GetModuleHandle("Kernel32"); uchwyt do biblioteki kernel

array<Process^>^gra = System::Diagnostics::Process::GetProcessesByName("WarRock"); - szukamy procesu po nazwie

HANDLE uProcesu = OpenProcess(PROCESS_ALL_ACCESS, FALSE, gra[0]->Id); - tworzymy uchwyt do procesu

adrBib = ::VirtualAllocEx(uProcesu, NULL, sizeof(sciezkaBib),MEM_COMMIT, PAGE_READWRITE ); - alokujemy pamięć

::WriteProcessMemory(uProcesu, adrBib, (void*)sciezkaBib, sizeof(sciezkaBib), NULL ); - zapisujemy

uWatku = ::CreateRemoteThread( uProcesu, NULL, 0,(LPTHREAD_START_ROUTINE) ::GetProcAddress( uKernel32,"LoadLibraryA" ),adrBib, 0, NULL ); - tworzymy watek i uchwyt do niego

::WaitForSingleObject( uWatku, INFINITE ); - czekamy aż wątek się wykona

::GetExitCodeThread( uWatku, &uBibMod ); - odbieramy informacje o zakończeniu wątku

::CloseHandle( uWatku ); - zamykamy go

::VirtualFreeEx( uProcesu, adrBib, sizeof(sciezkaBib), MEM_RELEASE ); - uwalniamy zarezerwowaną pamięć

Kompilujemy program. Mogą pojawić się błędy informujące o problemach z konwersją między zmiennymi typu char i string-podobnymi. Wtedy po wciśnięciu ALT+F7 powinno nam się wyświetlić okno właściwości naszego projektu. W zakładce "Configuration Properties->General" zmieniamy opcje "Character Set" z "Use Unicode character set" na "Use Multi-Byte character set".

2. Biblioteka DLL

Z biblioteką napisaną w C++/CLI może być ten kłopot, że niekoniecznie program do którego wstrzykujemy będzie obsługiwać biblioteki środowiska .NET. Wiem, że dałoby się to przeskoczyć, ale na chwilę obecną jestem jeszcze zbyt zielony w temacie i wybrałem klasyczną DLL'ke. Nie przeszkadza to jednak w niczym, żeby program wstrzykujący był napisany z wykorzystaniem takiego środowiska. Możnaby go z powodzeniem napisać i w VB.NET.

Tworzymy nowy projekt. Tym razem jednak nie z grupy CLR a Win32. Wybieramy Win32 Project i w kreatorze który sie pojawi zaznaczamy opcje "DLL" i "Empty Project".

Klikamy prawym w "Solution Explorer" na ikone katalogu "Source Files" i dodajemy nowy plik *.cpp.

Poniżej zamieszczam cały kod i postaram sie objaśnić z czego się składa i jak działa:

#define WIN32_LEAN_AND_MEAN
#include <windows.h>

#ifdef _MANAGED
#pragma managed(push, off)
#endif

BOOL APIENTRY DllMain( HMODULE hModule,
                        DWORD  ul_reason_for_call,
                        LPVOID lpReserved
                      )
{
     return TRUE;
}


#ifdef _MANAGED
#pragma managed(pop)
#endif

class hck
{
private:
     void zapPam(){
         LONG AdrPam1 = 0x4F46AC;
         HANDLE uchwyt;
         DWORD pid = ::GetCurrentProcessId();
         uchwyt = ::OpenProcess(PROCESS_VM_OPERATION|PROCESS_VM_WRITE, FALSE, pid);

         if (uchwyt != 0)
         {
             BYTE wart1 = 0x76;
             ::WriteProcessMemory(uchwyt,(LPVOID*)(DWORD)AdrPam1,&wart1, sizeof(wart1), NULL);
         }
         else
         {
         MessageBoxA(NULL, "Nie udało się nadpisać pamięci", "Hck", MB_OK);
         }
     
     }
public:
     hck() {
         MessageBoxA(NULL, "Propagandhi?", "Hck", MB_OK); //taki gadżet, żeby było wiadomo, że działa;-)
         zapPam();
     }

};


hck h;

To co powoduje, że biblioteka po wstrzyknięciu zaskakuje automatycznie to tzw entry point, czyli w naszym przypadku funkcja DllMain. Będzie ona wywoływała metody o zasięgu globalnym, czyli w naszym przypadku te po słowie "public:" w klasie. Jako prywatną dodałem funkcję nadpisującą ESP - zapPam(), którą później wywołałem globalnie. Można by ją od razu wywołać jako publiczną, ale chciałem zademonstrować jak też można się tym posługiwać.

Jak działa zapPam:

LONG AdrPam1 = 0x4F46AC; - tutaj przechowujemy adres dla ESP

HANDLE uchwyt;

DWORD pid = ::GetCurrentProcessId(); ponieważ biblioteka po wstrzyknięciu współdzieli pamięć z naszą grą, albo inną aplikacją, to PID procesu możemy pobrać za pomocą ::GetCurrentProcessId() opisaną w <windows.h>. Jest to o tyle wygodne, że nie trzeba szukać okna, żeby pobrac uchwyt.

uchwyt = ::OpenProcess(PROCESS_VM_OPERATION|PROCESS_VM_WRITE, FALSE, pid); - otwieramy proces. Biblioteka z jakichś przyczyn nie pobierze uchwytu jeśli użyjemy flagi PROCESS_ALL_ACCESS, dlatego wykorzystałem dwie inne, tylko z prawem dostępu do zapisu tj PROCESS_VM_OPERATION i PROCESS_VM_WRITE. Do odczytu będą potrzebne PROCESS_VM_OPERATION i PROCESS_VM_READ. W razie czego odsyłam do msdn.

if (uchwyt != 0)

{

BYTE wart1 = 0x76; - wartość do nadpisania dla ESP (szesnastkowo)

::WriteProcessMemory(uchwyt,(LPVOID*)(DWORD)AdrPam1,&wart1, sizeof(wart1), NULL); - jeśli pobrano uchwyt, to nadpisujemy pamięć, ...

}

else

{

MessageBoxA(NULL, "Nie udało się nadpisać pamięci", "Hck", MB_OK); - ...jeśli nie to wysyła komunikat

}

Tu też jeśli pojawią się błędy przy konwersji zmiennych spróbujcie zmienić "Character Set" na "Use Multi-Byte character set", jak w przypadku "strzykawki".

To w zasadzie tyle. Na menu w D3D czy nawet z wykorzystaniem windowsowego API jestem jeszcze za cienki w uszach, ale jak znajdę czas to się tym pobawię. Możecie kombinować z wyłączaniem poszczególnych funkcji w hacku za pomocą klawiszy. Dodam tylko, że biblioteki z DllMain można też pisać w VB6. Jak ktoś jest ciekawy, to moge tez udostępnić źródło "strzykawki" w VB.NET, ale trzeba je jeszcze dopieścić. Popróbujcie zapisać też inne opcje z hacka. Może znajdą się takie, które są niewykrywalne.

@edit: dodałem do strzykawki linijkę ::CloseHandle( uProcesu );, żeby zamknąć uchwyt do procesu.

N1ghtmare · 24 Listopada 2008

Gratulacje za to, że chciało ci się to pisać

Mam 1 problem a mianowicie przy funkcji timera, kiedy wpiszę kod, design się nie pokazuje

to jest owy kod, który powoduje error: @edit : to tez powoduje error *

array<Process^>^aplikacja = System::Diagnostics::Process::GetProcessesByName("WarRock");

if (aplikacja->Length != 0) //*

A to jest Error:

To prevent possible data loss before loading the designer, the following errors must be resolved:

Instances of this error (1)

1. Hide Call Stack

at System.ComponentModel.Design.Serialization.CodeDomDesignerLoader.EnsureDocument(

DesignerSerializationManager manager)

at System.ComponentModel.Design.Serialization.CodeDomDesignerLoader.PerformLoad(IDe

ignerSerializationManager manager)

at Microsoft.VisualStudio.Design.Serialization.CodeDom.VSCodeDomDesignerLoader.Perf

rmLoad(IDesignerSerializationManager serializationManager)

at System.ComponentModel.Design.Serialization.BasicDesignerLoader.BeginLoad(IDesign

rLoaderHost host)

BlaCkPr0o · 24 Listopada 2008

działa to wogulę ?bo jak tak to się biorę do roboty

Propagandhi · 24 Listopada 2008

To prevent possible data loss before loading the designer, the following errors must be resolved:

Instances of this error (1)

1. Hide Call Stack

at System.ComponentModel.Design.Serialization.CodeDomDesignerLoader.EnsureDocument(

DesignerSerializationManager manager)

at System.ComponentModel.Design.Serialization.CodeDomDesignerLoader.PerformLoad(IDe

ignerSerializationManager manager)

at Microsoft.VisualStudio.Design.Serialization.CodeDom.VSCodeDomDesignerLoader.Perf

rmLoad(IDesignerSerializationManager serializationManager)

at System.ComponentModel.Design.Serialization.BasicDesignerLoader.BeginLoad(IDesign

rLoaderHost host)

Nie wiem, co to może być. array<Process^>^aplikacja = System::Diagnostics::Process::GetProcessesByName("WarRock"); jest poprawne. Może to kwestia systemu, albo Service Packa dla VC++ 2008. Możesz też spróbować zrestartować cały projekt i ponownie zbudować, lub też spróbować usunąć pliki z pierwszego katalogu Debug, jeśli jakieś są. rzuć jeszcze okiem pod #pragma endregion w Form1.h czy są jakieś dodatkowe funkcje oprócz tych dla przycisku i timera. Możesz spróbować je usunąć i wtedy debugować.

Załączam cały projekt. Jak u Ciebie nie pójdzie, to być może jakiś bug i bedzie potrzebna łata. LINK

@up: Działa, zrobiłem tylko jeden test, ale przez 10 minut miałem włączone ESP. Jak wychodziłem z gry, to kopnęło mnie za wykryte zmiany w pamięci. Może inaczej to będzie wyglądało z modyfikacją innych adresów.

Chodzi jeszcze za mną, żeby spróbować kiedyś zrobić code cave dla ESP, albo innej opcji. Kiedyś próbowaliśmy tego z Bogdanem z gazowni, ale PB nam pozamiatało hacki w VB.NET.

N1ghtmare · 24 Listopada 2008

Twój source działa, dzięki.

Po przeanalizowaniu mojego wywnioskowałem, że zrobiłem to samo co ty, jednak mój source się różnił od mojego. Czym ? kilkoma rzeczami, tu załączam plik jeśli byłby ktoś ciekawy. Nie wiem dlaczego tak się stało :P

c_.txt

Click

PS. dll'ka cos mi nie dziala, esp nie chce xP i komunikaty się nie wyświetlają - Jeżeli ty testowałeś hacka dzisiaj to ja już nie wiem :P

Propagandhi · 25 Listopada 2008

PS. dll'ka cos mi nie dziala, esp nie chce xP i komunikaty się nie wyświetlają - Jeżeli ty testowałeś hacka dzisiaj to ja już nie wiem :P

Rozumiem, ze biblioteka się skompilowała. Teraz tak: jeśli użyłeś w kodzie samej nazwy biblioteki bez ścieżki do katalogu (czyli tak jak podałem bez modyfikacji), to całość czyli program do wstrzykiwania i bibliotekę musisz wrzucić do katalogu z plikiem wykonywalnym procesu, czyli w naszym przypadku WarRock.exe (inaczej nie będzie wiedział, gdzie jej szukać). Nazwa pliku dll musi się zgadzać z tym co podałeś w kodzie programu. Całość skopiuj do katalogu ..\Warrock\System\, bo tam znajduje się Warrock.exe. Odpal program do wstrzykiwania, wciśnij przycisk i odpal grę. Jesli wszystko pójdzie dobrze, to powinno wyskoczyć okienko MsgBox. Nie rób czasem tak, że najpierw odpalasz grę a potem program do wstrzykiwania. Zdaje się, że po tym jak HackShield się załaduje całkiem, wstrzyknięcie nie będzie możliwe. I to w zasadzie tyle. Jak coś dalej nie będzie śmigać, to pisz. Sprawdziłem na wszelki wypadek całość przed chwilą i działała.

N1ghtmare · 25 Listopada 2008

Działa Thx za pomoc, poprostu nie wiedziałem, że muszę to do warrock/system wrzucić.

Teraz czas na inne opcje ;P Spróbuje pobawić sie w hotkeye :P

Propagandhi · 8 Grudnia 2008

Trochę poczytałem, znalazłem kilka ciekawych przykładów i metodą prób i błędów udało mi się zmontować proste okienkowe menu wstrzykiwane z biblioteką do procesu, które wygląda tak:

Pozmieniało się niemalże wszystko od pierwszej wersji biblioteki, dlatego postaram się wyjaśnić co jest czym w kolejności w jakiej te elementy są wywoływane w dll'ce a na końcu wrzucę cały kod.

Nasz entry point wygląda teraz tak:

   BOOL APIENTRY DllMain( HMODULE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved)
   {
       switch (ul_reason_for_call)
       {
         case DLL_PROCESS_ATTACH:
              MessageBox (0, "Biblioteka została podłączona.\n", "Hck", MB_ICONINFORMATION);
               Module = hModule;
               /*SECURITY_ATTRIBUTES sa;
               sa.bInheritHandle = true;
               sa.lpSecurityDescriptor = NULL;
               sa.nLength = sizeof(SECURITY_ATTRIBUTES);
               */
               CreateThread(0,0,(LPTHREAD_START_ROUTINE)&Window,0,0,0); //&sa
               DisableThreadLibraryCalls(Module);
           break;
   
         case DLL_PROCESS_DETACH:
              MessageBox (0, "Biblioteka została odłączona.\n", "Hck", MB_ICONINFORMATION);
           break;
   
         case DLL_THREAD_ATTACH:
              MessageBox (0, "Wątek został podłączony.\n", "Hck", MB_ICONINFORMATION);
           break;
   
         case DLL_THREAD_DETACH:
              MessageBox (0, "Wątek został odłączony.\n", "Hck", MB_ICONINFORMATION);
           break;
       }
       return TRUE;
   }

Wcześniej DllMain zwracała nam tylko wartość prawdy, gdyż nie ładowaliśmy w niej bezpośrednio innych procedur - automatycznie uruchamiała procedury o zasięgu globalnym, tj publiczne w klasie. W ciele przełącznika, który pobiera nam argument ul_reason_for_call mamy teraz 4 komunikaty, na które będzie reagować Dllmain. DLL_PROCESS_ATTACH wiąże się bezpośrednio z załadowaniem biblioteki i tu będziemy wywoływać jakąś procedurę, która uruchomi całą resztę. Z jakichś przyczyn w niektórych aplikacjach nie mogę bezpośrednio odwołać się do danej procedury - np okno WarRock się nie pojawia, choć gra działa w tle. Być może czeka na wykonanie biblioteki. Udało mi się jednak wstrzyknąć taką bibliotekę odwołującą się bezpośrednio do jakiejś procedury do prostego programu napisanego w VB.NET. Żeby jednak funkcje z naszej biblioteki nie kolidowały z samą grą/innym programem tworzymy dla nich osobny wątek.

CreateThread(0,0,(LPTHREAD_START_ROUTINE)&Window,0,0,0); //&sa

W tym wątku uruchomimy funkcje o nazwie Window, która będzie tworzyła nam okno menu.

Ponieważ wątki w bibliotekach lubią się niespodziewanie kończyć, musimy dołączyć linijkę kodu, który będzie wyłączał komunikaty DLL_THREAD_DETACH i DLL_THREAD_ATTACH dotyczące właśnie obsługi wątków.

DLL_PROCESS_DETACH dotyczy odłączenia biblioteki, a w tym przypadku wyśle komunikat o jej odłączeniu po zakończeniu programu.

Jako komentarz dodałem strukturę security_attributes, która wskakuje jako pierwszy argument do funkcji typy CreateThread. Jeśli wynosi 0, to funkcja przyjmuje domyślne wartości (sa.bInheritHandle, czyli dziedziczenie uchwytu wątku przez obiekty potomne ma wtedy wartość fałszu). I to tyle w kwestii DllMain. Tworzenie okien z użyciem WinAPI opisane jest nieco bardziej szczegółowo choćby w kursie "Od zera do gier kodera", dlatego nie będę się nad tym dużo rozwodził. Ponieważ tworzymy bibliotekę, a nie plik wykonywalny, to pierwszą różnicą będzie u nas brak entry point typowego dla okienkowego exe'ka w postaci procedury WinMain(). Do rejestracji odpowiednich klas, wywołania okna i pętli komunikatów użyjemy funkcji Window wywołanej w DllMain w postaci nowego wątku.

To co nas interesuje z funkcji Window, to:

   hWnd = CreateWindowEx(WS_EX_APPWINDOW | WS_EX_TOOLWINDOW,_T("WindowClass"),_T("Hck Menu"),WS_SYSMENU,CW_USEDEFAULT,CW_USEDEFAULT,180,300,0,0,Module,0);

Ta funkcja tworzy nam okno "matkę".

"Hck Menu", to opis na ramce okienka, a wartości 180 i 300 odpowiednio szerokość i wysokość okna. CW_USEDEFAULT,CW_USEDEFAULT, oznaczają położenie okna na ekranie.

Procedura komunikatów, czyli taka, która przetwarza wszystko co się dzieje z oknem, wygląda następująco:

   LRESULT CALLBACK WndProc (HWND hWnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
   {
       PAINTSTRUCT    ps;
       HDC    hdc;
   
   
           switch (iMsg)
           {
                  case WM_CREATE:
                       button0 = CreateWindow("Button","ESP włączone",BS_PUSHBUTTON | WS_CHILD | WS_VISIBLE ,10,10,150,40,hWnd,(HMENU)ID_BUTTON0,Module,0);    
                       button1 = CreateWindow("Button","ESP wyłączone",BS_PUSHBUTTON | WS_CHILD | WS_VISIBLE ,10,70,150,40,hWnd,(HMENU)ID_BUTTON1,Module,0);
                       infolab = CreateWindow("Edit", NULL, WS_BORDER | NULL | WS_CHILD | WS_VISIBLE | NULL | NULL ,10,120,150,20,hWnd,(HMENU)ID_INFO,Module,0);
                       break;
   
                   case WM_PAINT: 
                       hdc = BeginPaint(hWnd, &ps);
                       EndPaint(hWnd, &ps);
                       return 0;
   
                  case WM_COMMAND: //Command from Child windows and menus are under this message
   
                      switch(wParam) //the ID is wParam
                       {
                       case ID_BUTTON0: //check for our button ID
                           {
                               zapBajt(AdrESP, wartONesp);
                               SetWindowText(infolab,"ESP: włączone");
                           break;
                           }
                       
                       case ID_BUTTON1:
                           {
                               zapBajt(AdrESP, wartOFFesp);
                               SetWindowText(infolab,"ESP: wyłączone");
                           break;
                           }
                      }
                      
                 case WM_KEYDOWN:
                   {
   
                   if (wParam == VK_ESCAPE)
                   if (MessageBoxA(NULL,"Czy na pewno chcesz wyjść?", "Wyjście Hck",MB_YESNO | MB_ICONQUESTION) == IDYES)
                       PostQuitMessage (0);
                   return 0;
               
                   }
                   case WM_CLOSE:
                       DestroyWindow(hWnd);
                       break;
                   case WM_DESTROY:
                       PostQuitMessage(0);
                       break;
   
   
   
           }
           return DefWindowProc(hWnd,iMsg,wParam,lParam);
   }

W tej procedurze stworzymy przyciski, i ramkę z tekstem z informacją o stanie hacka. Wrzuciłem jeszcze przykład z wspomnianego wyżej kursu, który pokazuje jak uwrażliwić procedurę komunikatów na wciśnięcie jakiegoś klawisza. U nas będzie to escape. No ale po kolei:

WM_CREATE: będzie nam tworzył obiekty potomne (dzieci okna "matki") za pomoca funkcji CreateWindow. Pierwsze dwa obiekty, to przyciski, a ostatni etykieta z tekstem. Rozmiar tych obiektów, jak i położenie względem górnego, lewego rogu okna matki opisują 4 parametry (np ...,10,10,150,40,...) oznacza położenie 10 w prawo, 10 w dół do górnego, lewego rogu, 150 - szerokość, 40 - wysokość. Drugi parametr w przypadku przycisku, to etykieta na nim:

button0 = CreateWindow("Button","ESP włączone",BS_PUSHBUTTON | WS_CHILD | WS_VISIBLE ,10,10,150,40,hWnd,(HMENU)ID_BUTTON0,Module,0);

WM_COMMAND: bedzie obsługiwał komunikaty z przycisków. I tak np po wciśnięciu pierwszego przycisku:

                    case ID_BUTTON0: //check for our button ID
                           {
                               zapBajt(AdrESP, wartONesp);
                               SetWindowText(infolab,"ESP: włączone");
                           break;

za pomocą procedury zapBajt nadpisze bajt dla włączonego ESP i zmieni tekst etykiety na "ESP: włączone"

Wszystkie elementy ID_... zapisałem w postaci typu wyliczeniowego na początku programu

   enum {ID_BUTTON0, ID_BUTTON1, ID_INFO};

Pojawiają się one jeszcze w czasie tworzenia okna dziecka, np:

button0 = CreateWindow("Button","ESP włączone",BS_PUSHBUTTON | WS_CHILD | WS_VISIBLE ,10,10,150,40,hWnd,(HMENU)ID_BUTTON0,Module,0);

WM_KEYDOWN: obsługuje zdarzenia klawiszy, czyli np u nas za pomocą Escape można będzie zamknąć okno.

WM_CLOSE: i WM_DESTROY: zamykają okno i "sprzątają" po nim.

Procedura zapBajt() w zasadzie jest prawie taka sama jak w pierwszej dll'ce z ta róznicą, że tu piebiera adres i wartość.

No i to tyle. Podaje to raczej w formie ciekawostki, ale jakby ktoś chciał się pobawić i miał z tym jakieś problemy, to piszcie. Aktualnie pracuje nad czymś podobnym, ale menu będzie w formie zarzadzanej dll'ki napisanej w C#.

Zamieszczam kod całej biblioteki:

#include <windows.h>
#include <tchar.h>

enum {ID_BUTTON0, ID_BUTTON1, ID_INFO};

HMODULE Module;
HWND button0; 
HWND button1;
HWND infolab;
//adresy, wartosci
LONG AdrESP = 0x4F4C4C;
BYTE wartONesp = 0x76;
BYTE wartOFFesp = 0x75;

void zapBajt(LONG Adres, BYTE Wartosc){
        
        HANDLE uchwyt;
        DWORD pid = ::GetCurrentProcessId();
        uchwyt = ::OpenProcess(PROCESS_VM_OPERATION|PROCESS_VM_WRITE, FALSE, pid);

        if (uchwyt != 0)
        {
            
            ::WriteProcessMemory(uchwyt,(LPVOID*)(DWORD)Adres,&Wartosc, sizeof(Wartosc), NULL);
        }
        else
        {
        MessageBoxA(NULL, "Nie udało się nadpisać pamięci", "Hck", MB_OK);
        }
}

LRESULT CALLBACK WndProc (HWND hWnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
    PAINTSTRUCT    ps;
    HDC    hdc;


        switch (iMsg)
        {
               case WM_CREATE:
                    button0 = CreateWindow("Button","ESP włączone",BS_PUSHBUTTON | WS_CHILD | WS_VISIBLE ,10,10,150,40,hWnd,(HMENU)ID_BUTTON0,Module,0);    
                    button1 = CreateWindow("Button","ESP wyłączone",BS_PUSHBUTTON | WS_CHILD | WS_VISIBLE ,10,70,150,40,hWnd,(HMENU)ID_BUTTON1,Module,0);
                    infolab = CreateWindow("Edit", NULL, WS_BORDER | NULL | WS_CHILD | WS_VISIBLE | NULL | NULL ,10,120,150,20,hWnd,(HMENU)ID_INFO,Module,0);
                    break;

                case WM_PAINT: 
                    hdc = BeginPaint(hWnd, &ps);
                    EndPaint(hWnd, &ps);
                    return 0;

               case WM_COMMAND: //Command from Child windows and menus are under this message

                   switch(wParam) //the ID is wParam
                    {
                    case ID_BUTTON0: //check for our button ID
                        {
                            zapBajt(AdrESP, wartONesp);
                            SetWindowText(infolab,"ESP: włączone");

                        //MessageBoxA(NULL, "Przycisk 1 działa", "Hck", MB_OK);
                        break;
                        }
                    
                    case ID_BUTTON1:
                        {
                            zapBajt(AdrESP, wartOFFesp);
                            SetWindowText(infolab,"ESP: wyłączone");
                        //MessageBoxA(NULL, "Przycisk 2 działa", "Hck", MB_OK);
                        break;
                        }
                   }
                   
              case WM_KEYDOWN:
                {

                if (wParam == VK_ESCAPE)
                if (MessageBoxA(NULL,"Czy na pewno chcesz wyjść?", "Wyjście Hck",MB_YESNO | MB_ICONQUESTION) == IDYES)
                    PostQuitMessage (0);
                return 0;
            
                }
                case WM_CLOSE:
                    DestroyWindow(hWnd);
                    break;
                case WM_DESTROY:
                    PostQuitMessage(0);
                    break;



        }
        return DefWindowProc(hWnd,iMsg,wParam,lParam);
}

void ExitWindow()
{
     UnregisterClass(_T("WindowClass"), Module);
     FreeLibraryAndExitThread(Module, 0);
}

int Window()
{
     HWND hWnd;
     MSG iMsg;
     WNDCLASSEX wc;
     
    ZeroMemory(&wc,sizeof(WNDCLASSEX));
     
    wc.cbSize = sizeof(WNDCLASSEX);
    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hbrBackground = (HBRUSH)COLOR_BTNSHADOW;
    wc.hIcon = LoadIcon(NULL,IDI_APPLICATION);
    wc.hCursor = LoadCursor(NULL,IDC_ARROW);
    wc.hInstance = Module;
    wc.lpfnWndProc = WndProc;
    wc.lpszMenuName = NULL;
    wc.lpszClassName = _T("WindowClass");
    wc.hIconSm = LoadIcon(NULL,IDI_APPLICATION);
   
    if (!RegisterClassEx(&wc)){
        MessageBox(0,_T("Failed"),0,0);
        ExitWindow();
        }
    hWnd = CreateWindowEx(WS_EX_APPWINDOW | WS_EX_TOOLWINDOW,_T("WindowClass"),_T("Hck Menu"),WS_SYSMENU,CW_USEDEFAULT,CW_USEDEFAULT,180,300,0,0,Module,0);
    ShowWindow(hWnd,SW_SHOWNORMAL);
    UpdateWindow(hWnd);
   
    while (GetMessage(&iMsg,0,0,0))
    {
           TranslateMessage(&iMsg);
           DispatchMessage(&iMsg);
    }
    return iMsg.wParam;
     //ExitWindow();
}

BOOL APIENTRY DllMain( HMODULE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved)
{
    switch (ul_reason_for_call)
    {
      case DLL_PROCESS_ATTACH:
           MessageBox (0, "Biblioteka została podłączona.\n", "Hck", MB_ICONINFORMATION);
            Module = hModule;
            /*SECURITY_ATTRIBUTES sa;
            sa.bInheritHandle = true;
            sa.lpSecurityDescriptor = NULL;
            sa.nLength = sizeof(SECURITY_ATTRIBUTES);
            */
            CreateThread(0,0,(LPTHREAD_START_ROUTINE)&Window,0,0,0); //&sa
            DisableThreadLibraryCalls(Module);
        break;

      case DLL_PROCESS_DETACH:
           MessageBox (0, "Biblioteka została odłączona.\n", "Hck", MB_ICONINFORMATION);
        break;

      case DLL_THREAD_ATTACH:
           MessageBox (0, "Wątek został podłączony.\n", "Hck", MB_ICONINFORMATION);
        break;

      case DLL_THREAD_DETACH:
           MessageBox (0, "Wątek został odłączony.\n", "Hck", MB_ICONINFORMATION);
        break;
    }
    return TRUE;
}

N1ghtmare · 8 Grudnia 2008

Kiedy proboje kompilowac kod mam takie errory :

Deleting intermediate and output files for project 'Test_Esp', configuration 'Debug|Win32'
Compiling...
main.cpp
d:\moje dokumenty\visual studio 2008\projects\test_esp\test_esp\main.cpp(41) : error C2664: 'CreateWindowExW' : cannot convert parameter 2 from 'const char [7]' to 'LPCWSTR'
        Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast
d:\moje dokumenty\visual studio 2008\projects\test_esp\test_esp\main.cpp(42) : error C2664: 'CreateWindowExW' : cannot convert parameter 2 from 'const char [7]' to 'LPCWSTR'
        Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast
d:\moje dokumenty\visual studio 2008\projects\test_esp\test_esp\main.cpp(43) : error C2664: 'CreateWindowExW' : cannot convert parameter 2 from 'const char [5]' to 'LPCWSTR'
        Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast
d:\moje dokumenty\visual studio 2008\projects\test_esp\test_esp\main.cpp(58) : error C2664: 'SetWindowTextW' : cannot convert parameter 2 from 'const char [14]' to 'LPCWSTR'
        Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast
d:\moje dokumenty\visual studio 2008\projects\test_esp\test_esp\main.cpp(67) : error C2664: 'SetWindowTextW' : cannot convert parameter 2 from 'const char [15]' to 'LPCWSTR'
        Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast
d:\moje dokumenty\visual studio 2008\projects\test_esp\test_esp\main.cpp(144) : error C2664: 'MessageBoxW' : cannot convert parameter 2 from 'const char [32]' to 'LPCWSTR'
        Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast
d:\moje dokumenty\visual studio 2008\projects\test_esp\test_esp\main.cpp(156) : error C2664: 'MessageBoxW' : cannot convert parameter 2 from 'const char [31]' to 'LPCWSTR'
        Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast
d:\moje dokumenty\visual studio 2008\projects\test_esp\test_esp\main.cpp(160) : error C2664: 'MessageBoxW' : cannot convert parameter 2 from 'const char [26]' to 'LPCWSTR'
        Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast
d:\moje dokumenty\visual studio 2008\projects\test_esp\test_esp\main.cpp(164) : error C2664: 'MessageBoxW' : cannot convert parameter 2 from 'const char [25]' to 'LPCWSTR'
        Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast
Build log was saved at "file://d:\Moje dokumenty\Visual Studio 2008\Projects\Test_Esp\Test_Esp\Debug\BuildLog.htm"
Test_Esp - 9 error(s), 0 warning(s)

byc moze to cos z moim programem, bo wczesniej tez mialem problemy. :P

Propagandhi · 8 Grudnia 2008

Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast
d:\moje dokumenty\visual studio 2008\projects\test_esp\test_esp\main.cpp(42) : error C2664: 'CreateWindowExW' : cannot convert parameter 2 from 'const char [7]' to 'LPCWSTR'

(...)

byc moze to cos z moim programem, bo wczesniej tez mialem problemy. :P

Tego typu problemy to właśnie wynik błędów przy konwersji typów. W zasadzie tak jak przy pierwszej Dll'ce spróbuj czegoś takiego:

wciśnij ALT+F7 - wyświetli Ci się okno właściwości projektu. W zakładce "Configuration Properties->General" zmieniamy opcje "Character Set" z "Use Unicode character set" na "Use Multi-Byte character set".

Powinno działać, bo widzę, że innych błędów nie masz. Jak będziesz miał podobne kiedyś, to zrób to samo, albo najlepiej na starcie dla wszystkich projektów ustawić "Use Multi-Byte character set".

N1ghtmare · 8 Grudnia 2008

A no. Zrobilem to za pierwszym razem i myslalem, ze juz nie trzeba. Dzieki.

Propagandhi · 9 Grudnia 2008

To już ostatni pomysł związany z wstrzykiwaniem dynamicznych bibliotek, który udało mi się wprowadzić w życie. Tym razem do niezarządzanego procesu wstrzyknąłem bibliotekę napisaną w C++, która z kolei uruchamia w procesie hosta do obsługi środowiska NET i wywołuje funkcje z biblioteki napisanej w C#. To jest przykład menu, które udało mi się zrobić tą drogą:

1. Biblioteka uruchamiająca .NET

Biblioteka C++, która po wstrzyknięciu uruchamia nam odpowiednie narzędzia do obsługi biblioteki C# wygląda tak:

#define WIN32_LEAN_AND_MEAN
#pragma comment(lib, "MSCorEE.lib")
#include <windows.h>
#include "MSCorEE.h" //LIBPATH:dir C:\Program Files\Microsoft SDKs\Windows\v6.0A\include\MSCorEE.h
#include <tchar.h>

HMODULE Module;


int StartNET()
{    
     //podpinamy sie pod CLR
     ICLRRuntimeHost *pClrHost = NULL;
     HRESULT hr = CorBindToRuntimeEx(
                     NULL, 
                     L"wks",
                     0, 
                     CLSID_CLRRuntimeHost,
                     IID_ICLRRuntimeHost, 
                     (PVOID*)&pClrHost);

     hr = pClrHost->Start();
     //teraz dziala i odpalamy funkcje z biblioteki

     DWORD zwWart = 0;
     hr = pClrHost->ExecuteInDefaultAppDomain(
         L"prop32hckmenu.dll",
         L"prop32hck.hckMenu", L"menuStart", L"pwzArgument", &zwWart);
         
     
     //hr = pClrHost->Stop();
     //pClrHost->Release();
     
     MSG iMsg;
     while (GetMessage(&iMsg,0,0,0))
     {
            TranslateMessage(&iMsg);
            DispatchMessage(&iMsg);
     }
     return iMsg.wParam;
}



BOOL APIENTRY DllMain( HMODULE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved)
{
     switch (ul_reason_for_call)
     {
       case DLL_PROCESS_ATTACH:
            MessageBox (0, "Biblioteka została podłączona.\n", "Hck", MB_ICONINFORMATION);
             Module = hModule;

             CreateThread(0,0,(LPTHREAD_START_ROUTINE)&StartNET,0,0,0); 
             //DisableThreadLibraryCalls(Module);
         break;

       case DLL_PROCESS_DETACH:
            MessageBox (0, "Biblioteka została odłączona.\n", "Hck", MB_ICONINFORMATION);
         break;
         /*
       case DLL_THREAD_ATTACH:
            MessageBox (0, "Wątek został podłączony.\n", "Hck", MB_ICONINFORMATION);
         break;

       case DLL_THREAD_DETACH:
            MessageBox (0, "Wątek został odłączony.\n", "Hck", MB_ICONINFORMATION);
       break;
       */
     }
     return TRUE;
}

Żeby obsługiwać funkcje potrzebne do uruchomienia NET potrzebujemy zaimportować odpowiednią bibliotekę - MSCorEE. Po wstrzyknięciu DllMain tworzy nam nowy wątek w którym wywołuje funkcję StartNET. Pozbyłem się DisableThreadLibraryCalls, bo prawdopodobnie powoduje wycieki pamięci, ale stosunkowo niegroźne przy tak małej aplikacji. Żeby jednak podtrzymać główny wątek przy życiu użyłem pętli do obsługi zdarzeń z poprzedniego projektu(while (GetMessage(&iMsg,0,0,0))...). Ta pętla jest o tyle fajna, że nie zużywa dużo procesora i nie zawiesza wątków. W StartNET najbardziej interesuje nas teraz ta część:

 hr = pClrHost->ExecuteInDefaultAppDomain(
         L"prop32hckmenu.dll",
         L"prop32hck.hckMenu", L"menuStart", L"pwzArgument", &zwWart);

Wywołuje ona konkretną funkcje w zarządzanej bibliotece. prop32hckmenu.dll, to nazwa mojej biblioteki w C#, którą zaraz bardziej szczegółowo opisze. prop32hck - to namespace w bibliotece, hckMenu - nazwa klasy w obrębie danego namespace, menuStart - nazwa funkcji, którą wywołamy. pwzArgument, to argument dla funkcji. Nazwy mogą być dowolne dowolne, jedyne czego nie mozna zmienić, to kontrukcji funkcji, lub prodecury, którą wywołujemy - musi ona pobierać nasz argument jako zmienną string.

2. Biblioteka .NET (na końcu zamieszcze link do całego projektu)

Nie musi to być biblioteka pisana konkretnie w C#. Z powodzeniem może to być biblioteka napisana w formie projektu CLR w C++. Bardzo możliwe nawet, że da się napisać taką dll'ke w VB.NET. Poniżej zamieszczam przykład konstrukcji biblioteki napisanej w C++ pod ten projekt:

#pragma once

using namespace System;
using namespace System::Windows::Forms;

namespace prop32hck {

     public ref class hckMenu
     {

         public: static int menuStart(String^ pwzArgument)
         {
             MessageBox::Show( "Działa.", "Hello",
             MessageBoxButtons::OK, MessageBoxIcon::Exclamation );
             return 0;
         }

     };
}

W tym przypadku po wtrzyknieciu powinno nam wysłac okienko z komunikatem. Kontrukcja tej samej biblioteki w C# wygląda bardzo podobnie:

namespace prop32hck
{
     public class hckMenu
     {

         public static int menuStart(String pwzArgument)
         {
           //tutaj jakies intrukcje
         }

     }
}

Skoro mamy już tę część, to możemy stworzyć menu. Do projektu dodajemy nową formę i w C# wywołujemy ją w taki sposób:

namespace prop32hck
{
     public class hckMenu
     {

         public static int menuStart(String pwzArgument)
         {
             prop32.Form1 f = new prop32.Form1();
             f.Show();
             return 0;
             
         }

     }
}

prop32, to u mnie namespace w pliku Form1.h. Dalej można się już bawić kontrolkami i stworzyć całkiem fajne menu operując na samej formie.

Uzupełniłem moja klasę o funkcje nadpisujące pamięć. Wygląda to teraz tak:

using System;
using System.Diagnostics;
using System.Windows.Forms;
using System.Runtime.InteropServices;

namespace prop32hck
{
     public class hckMenu
     {

         public static int menuStart(String pwzArgument)
         {
             prop32.Form1 f = new prop32.Form1();
             f.Show();
             return 0;
             
         }

     }

     class funkcjeAPI
     {
         [Flags]
         public enum TypDostepu
         {
             PROCESS_TERMINATE = (0x0001),
             PROCESS_CREATE_THREAD = (0x0002),
             PROCESS_SET_SESSIONID = (0x0004),
             PROCESS_VM_OPERATION = (0x0008),
             PROCESS_VM_READ = (0x0010),
             PROCESS_VM_WRITE = (0x0020),
             PROCESS_DUP_HANDLE = (0x0040),
             PROCESS_CREATE_PROCESS = (0x0080),
             PROCESS_SET_QUOTA = (0x0100),
             PROCESS_SET_INFORMATION = (0x0200),
             PROCESS_QUERY_INFORMATION = (0x0400)
         }

         //        HANDLE OpenProcess(
         //            DWORD dwDesiredAccess,  // access flag
         //            BOOL bInheritHandle,    // handle inheritance option
         //            DWORD dwProcessId       // process identifier
         //            );
         [DllImport("kernel32.dll")]
         public static extern IntPtr OpenProcess(UInt32 dwDesiredAccess, Int32 bInheritHandle, Int32 dwProcessId);

         //        BOOL CloseHandle(
         //            HANDLE hObject   // handle to object
         //            );
         [DllImport("kernel32.dll")]
         public static extern Int32 CloseHandle(IntPtr hObject);

         //        BOOL ReadProcessMemory(
         //            HANDLE hProcess,              // handle to the process
         //            LPCVOID lpBaseAddress,        // base of memory area
         //            LPVOID lpBuffer,              // data buffer
         //            SIZE_T nSize,                 // number of bytes to read
         //            SIZE_T * lpNumberOfBytesRead  // number of bytes read
         //            );
         [DllImport("kernel32.dll")]
         public static extern Int32 ReadProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, [In, Out] byte[] buffer, UInt32 size, out IntPtr lpNumberOfBytesRead);

         //        BOOL WriteProcessMemory(
         //            HANDLE hProcess,                // handle to process
         //            LPVOID lpBaseAddress,           // base of memory area
         //            LPCVOID lpBuffer,               // data buffer
         //            SIZE_T nSize,                   // count of bytes to write
         //            SIZE_T * lpNumberOfBytesWritten // count of bytes written
         //            );
         [DllImport("kernel32.dll")]
         public static extern Int32 WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, [In, Out] byte[] buffer, UInt32 size, out IntPtr lpNumberOfBytesWritten);

         //    vKey
         [DllImport("user32.dll")]
         public static extern short GetAsyncKeyState(int vKey);
     }

     public class funkcjeAutorskie
     {
         public int ZapiszPamiec(IntPtr Adres, byte[] Wartosc, out int ileZapisBajt)
         {
         funkcjeAPI.TypDostepu dostep;
         dostep = funkcjeAPI.TypDostepu.PROCESS_VM_OPERATION|funkcjeAPI.TypDostepu.PROCESS_VM_WRIT
;
         IntPtr uchwyt = funkcjeAPI.OpenProcess((uint)dostep, 1, Process.GetCurrentProcess().Id);
         IntPtr BajtyZapisane;
         funkcjeAPI.WriteProcessMemory(uchwyt, Adres, Wartosc, (uint)Wartosc.Length, out BajtyZapisane);
         ileZapisBajt = BajtyZapisane.ToInt32();
         funkcjeAPI.CloseHandle(uchwyt);
         return ileZapisBajt;
         }

         public byte[] CzytajPamiec(IntPtr Adres, uint bajtyDoPrzeczytania, out int ilePrzeczBajt)
         {
             byte[] bufor = new byte[bajtyDoPrzeczytania];
             funkcjeAPI.TypDostepu dostep;
             dostep = funkcjeAPI.TypDostepu.PROCESS_VM_OPERATION | funkcjeAPI.TypDostepu.PROCESS_VM_READ;
             IntPtr uchwyt = funkcjeAPI.OpenProcess((uint)dostep, 1, Process.GetCurrentProcess().Id);
             IntPtr BajtyPrzeczytane;
             funkcjeAPI.ReadProcessMemory(uchwyt, Adres, bufor, bajtyDoPrzeczytania, out BajtyPrzeczytane);
             ilePrzeczBajt = BajtyPrzeczytane.ToInt32();
             funkcjeAPI.CloseHandle(uchwyt);
             return bufor;
         }

         public int ZapiszFloatPointer(IntPtr Adres, short Offset, byte[] Wartosc, uint ileBajtow, out int ileZapisBajt)
         {
             byte[] bufor = new byte[ileBajtow];
             funkcjeAPI.TypDostepu dostep;
             dostep = funkcjeAPI.TypDostepu.PROCESS_VM_OPERATION | funkcjeAPI.TypDostepu.PROCESS_VM_WRITE 
                      |funkcjeAPI.TypDostepu.PROCESS_VM_READ;

             IntPtr uchwyt = funkcjeAPI.OpenProcess((uint)dostep, 1, Process.GetCurrentProcess().Id);

             IntPtr BajtyZapisane;
             IntPtr BajtyPrzeczytane;

             funkcjeAPI.ReadProcessMemory(uchwyt, Adres, bufor, ileBajtow, out BajtyPrzeczytane);
             int bufint = BitConverter.ToInt32(bufor, 0);
             int Adres2 = bufint  + Offset;
             funkcjeAPI.WriteProcessMemory(uchwyt, (IntPtr)Adres2, Wartosc, (uint)Wartosc.Length, out BajtyZapisane);
             ileZapisBajt = BajtyZapisane.ToInt32();
             funkcjeAPI.CloseHandle(uchwyt);
             return ileZapisBajt;
         }
     }

}

Klasa funkcjeAPI zawiera potrzebne do nadpisywania pamięci funkcje API. Żeby móc je zaimportować potrzebna jest na początku deklaracja using System.Runtime.InteropServices. Do klasy publicznej funkcjeAutorskie wrzuciłem dwie funkcje do zapisywania w pamięci tablic bajtów i float pointerów. Żeby z nich korzytsać w kodzie formy trzeba wrzucić taką instacje odwołującą sie do danego namespace i klasy:

prop32hck.funkcjeAutorskie edytpam = new prop32hck.funkcjeAutorskie();

Teraz np zapisanie ESP w kodzie przycisku wygląda tak:

int wynbajt;
byte[] bajtespwl = { 0x76 };
edytpam.ZapiszPamiec((IntPtr)0x4F4C4C, bajtespwl, out wynbajt);

Załączam kod biblioteki a w nim jeszcze dodatkowo przykłady dla opcji Stamina i NoSpread/NoRecoil.

Link: prop1Chash.rar

@edit: W przykładzie dla norecoil pomyliłem adresy. Powinien być playerpointer (offsety są ok).

Zmontowałem jeszcze kilka innych działających opcji, przy czym któraś z nich jest wykrywalna i być może to FAHR. Stamina i No spread/recoil powinny być OK.

Stamina:

int wynbajt;
byte[] bajtstam = { 0,0,0,100 };
edytpam.ZapiszPointer((IntPtr)0x10E8428, 0x2A4,bajtstam,4, out wynbajt);

No Spread/No recoil:

int wynbajt;
            byte[] bajtrecspr = { 0, 0, 0, 0 };
            edytpam.ZapiszPamiec((IntPtr)0xB72C08, bajtrecspr, out wynbajt);
            edytpam.ZapiszPointer((IntPtr)0x10E8428, 0x2F4, bajtrecspr, 4, out wynbajt);
            edytpam.ZapiszPointer((IntPtr)0x10E8428, 0x2F8, bajtrecspr, 4, out wynbajt);
            edytpam.ZapiszPointer((IntPtr)0x10E8428, 0x2FC, bajtrecspr, 4, out wynbajt);

No Spawn Wait:

int wynbajt;
            byte[] bajtspawn = { 0,0,0,0 };
            edytpam.ZapiszPamiec((IntPtr)0xE03348, bajtspawn, out wynbajt);
            edytpam.ZapiszPamiec((IntPtr)0x1C9DBDC, bajtspawn, out wynbajt);
            edytpam.ZapiszPamiec((IntPtr)0x1C9DBD4, bajtspawn, out wynbajt);

No Bounds:

int wynbajt;
            byte[] bajtbounds = { 0, 0, 0, 0 };
            edytpam.ZapiszPamiec((IntPtr)0xE2547C, bajtbounds, out wynbajt);
            edytpam.ZapiszPamiec((IntPtr)0xE25480, bajtbounds, out wynbajt);

No Fall Damage:

int wynbajt;
            byte[] bajtnfd = { 0x30, 0xF8, 0xFF, 0xFF }; //rozbiłem -2000 na bajty
            edytpam.ZapiszPointer((IntPtr)0x10E8428, 0x27C, bajtnfd, 4, out wynbajt);

Sloty:

int wynbajt;
            byte[] bajtslot = { 4, 0, 0, 0 };
            edytpam.ZapiszPamiec((IntPtr)0xDF8B60, bajtslot, out wynbajt);

Bronie: wybieram broń w combobox

public byte i;

        private void bron_Tick(object sender, EventArgs e)
        {
            
            int wynbajt;
            
            if (prop32hck.funkcjeAPI.GetAsyncKeyState((int)0x2D)) //insert
            {
                if (comboBox1.Text == "Winchester")
                {
                    i = 58;
                }
                else if (comboBox1.Text == "Scorpion")
                {
                    i = 39;
                }
                else if (comboBox1.Text == "Adrenalina")
                {
                    i = 82;
                }

                byte[] bajtbron = { i, 0, 0, 0, 0, 0, 0, 0 };
                edytpam.ZapiszPointer((IntPtr)0x10E8428, 0x4C, bajtbron, 8, out wynbajt);
            }

FAHR: fast Flag, Ammo, Health, Repair

int wynbajt;
            byte[] bajtfahr = { 0xC5, 0x7F, 0x22, 0x41 };
            edytpam.ZapiszPamiec((IntPtr)0xB72BBC, bajtfahr, out wynbajt);//ammo
            edytpam.ZapiszPamiec((IntPtr)0xB72BC0, bajtfahr, out wynbajt);//heal
            edytpam.ZapiszPamiec((IntPtr)0xB72BC4, bajtfahr, out wynbajt);//repair
            edytpam.ZapiszPamiec((IntPtr)0xB72BC8, bajtfahr, out wynbajt);//flag

N1ghtmare · 12 Grudnia 2008

Mam pytanie, czy do tego source co dolaczyles trzeba jakas inna wersje vc c++ ? (mam 08 express edition) Kiedy zalaczam projekt pojawia sie taki error:

Propagandhi · 13 Grudnia 2008

Mam pytanie, czy do tego source co dolaczyles trzeba jakas inna wersje vc c++ ? (mam 08 express edition) Kiedy zalaczam projekt pojawia sie taki error: (...)

Projekt drugiej biblioteki dll (.NET) jest napisany w języku C# i do niego trzeba niestety inne środowisko programistyczne , ale też należące do grupy Visual Studio Express Editions. Mogłem namieszać w tekście powyżej, ale chodziło mi o to, że zarówno w C# jak i C++ (CLR) da się to napisać. Podałem przykłady dla obu języków, ale skupiłem się na pomyśle w C#, bo wygodniej mi się z nim pracuje. Dodam, że C# i C++ są pod wieloma względami bardzo podobne. C# funkcjonalnością przypomina VB.NET, łatwo się między kodami w tych językach konwertuje i mają niemal identyczny kod po kompilacji.

Jak będę miał więcej czasu, to wrzucę też kompletny przykład w C++.

sync667 · 13 Grudnia 2008

OOO Ile musiało ci zając pisanie tego ?

Bomba lepiej bym nie napisał.

Nie jestem zbytnio dobry z programowania w .dll

N1ghtmare · 13 Grudnia 2008

Propagandhi, dziala ci off od kazdej opcji ? mi nie chce w zaden sposob czy dam do buttona, czy do checkboxa to samo...

Propagandhi · 13 Grudnia 2008

Propagandhi, dziala ci off od kazdej opcji ? mi nie chce w zaden sposob czy dam do buttona, czy do checkboxa to samo...

Powinno działać. Sprawdziłem teraz szybko na opcji Slots i wyłączyła się bez problemów. Większość opcji musisz wrzucić do timerów i wyłączając timer wyłączasz też daną opcje, bo gra sama sobie już pobiera poprawne dane (np stamina). Inna sprawa to np ESP, bo tu parametr nie zmienia się w czasie gry i wystarczy, ze raz go nadpiszesz i żeby go wyłączyć musisz nadpisać oryginalne bajty.

N1ghtmare · 13 Grudnia 2008

Mam maly problem przy opcji weapon, a dokladniej przy tej linijce :

if (prop32hck.funkcjeAPI.GetAsyncKeyState((int)0x2D)) //insert

error :

Cannot implicitly convert type 'short' to 'bool'

Rozumiem, ze zwiazane jest to z ustawieniami " Use Multi-Byte character set", tylko nigdzie w C# nie moge tego znalezc ;p

Propagandhi · 13 Grudnia 2008

Mam maly problem przy opcji weapon, a dokladniej przy tej linijce :
if (prop32hck.funkcjeAPI.GetAsyncKeyState((int)0x2D)) //insert

error :

Cannot implicitly convert type 'short' to 'bool'

Rozumiem, ze zwiazane jest to z ustawieniami " Use Multi-Byte character set", tylko nigdzie w C# nie moge tego znalezc ;p

Nie, to moja wina. U siebie to poprawiłem, ale zapomniałem o tym tutaj wspomnieć. W klasie funkcjeAPI znajdź sobie import funkcji GetAsyncKeyState, czyli coś takiego:

        [DllImport("user32.dll")]
        public static extern short GetAsyncKeyState(int vKey);

i zmień short na bool, czyli w efekcie na:

[DllImport("user32.dll")]
        public static extern bool GetAsyncKeyState(int vKey);

Teraz powinno działać, przy czym to wciąż jest wykrywalne przez HS.

P.S.: Chodziło o to, że GetAsyncKeyState w oryginale zwraca wartośc prawdy, albo fałszu w zależności, czy przycisk został wciśnięty. Przy importowaniu zaznaczyłem, że zwraca wartość short i dlatego zgłupiało przy kompilowaniu.

P.P.S: Bronie działają prawdopodobnie tylko na mapach CQC

21 Grudnia 2008

ej tam dales wpis calej biblioteki tot to czeba tylko do timera skopiowac i tyle ??

N1ghtmare · 21 Grudnia 2008

ej tam dales wpis calej biblioteki tot to czeba tylko do timera skopiowac i tyle ??

Nie rozumiem o co chodzi ci z tym timerem ale sproboje wytlumaczyc co i jak :

1. Biblioteka uruchamiająca .NET

Tworzysz w C++ Nowy projekt -> win32 project -> potem wyskoczy ci okienko nacikasz next i wybierasz typ projektu dll + empty project

Potem klikasz prawym przyciskiem na source files ( masz po prawej stronie ) klikasz add new item, nazywasz go jakos, klikasz typ cpp i ok

Potem tylko wklejasz ta biblioteke + kompilujesz.

Program do wstrzykiwania biblioteki

http://www.mediafire.com/?sharekey=6791109...2db6fb9a8902bda

Otwierasz ten plik przez c++, tam juz wszystko jest.

Biblioteka .NET

http://www.mediafire.com/?sharekey=6791109...2db6fb9a8902bda

Sciagasz prop1Chash.rar I otwierasz ten projekt przez program C# i modyfikujesz ( czyt. dodajesz opcje.)

Mam dodatkowo jedno pytanie, a mianowicie value Off od opcji glass wall.

Wyczytalem ze jest to zmienna 10000 (float) I probowalem rozbic to na bajty, oto co mi wyszlo :

{ 0x10, 0x27, 0x0, 0x0 }

Jednak to mi nie dziala. ;p

@edit

Udalo mi sie to naprawic, ale mam jescze jedno pytanko :

kiedy robie super jumpa, ustawiam offset na 0x190, playerpointer, 4 bajty : 0xD0, 0x07,0x00,0x00 i to nie dziala przewraca mnie do gory nogami ( lol?) i tak przy kazdej wysokosci, ktora rozbije na bajty ;p pozdro.

Propagandhi · 22 Grudnia 2008

Udalo mi sie to naprawic, ale mam jescze jedno pytanko :
kiedy robie super jumpa, ustawiam offset na 0x190, playerpointer, 4 bajty : 0xD0, 0x07,0x00,0x00 i to nie dziala przewraca mnie do gory nogami ( lol?) i tak przy kazdej wysokosci, ktora rozbije na bajty ;p pozdro.

Nie mam teraz dostępu do swojego komputera i nie mam jak sprawdzić, ale możesz spróbować zapisać tablicę jak dla typu long, czyli 8 bajtów (4 pozostałe wypełnij zerami). Jak to nie pomoże, to spróbuj tablice zapisać w odwrotnej kolejności (stamine wyjątkowo tak zapisałem, bo inaczej nie działała), czyli począwszy od zer.

22 Grudnia 2008

sorki jezeli spamuje ale jak zrobic ta ikonke co ty zrobiles bo jak ja wloncze to sie pojawie wstrzyknij biblioteke to jak to zrobic plis pomozcie

Propagandhi · 24 Stycznia 2009

Przyszło mi do głowy kilka nowych usprawnień i tak jak zacząłem od jakichś drobiazgów to przerobiłem niemal całość.

Strzykawka:

Na początek program do wstrzykiwania. W VC++ koszmarnie konwertuje się typy zmiennych z .NET do klasycznych i odwrotnie, dlatego pomyślałem, żeby zrobić to w C#. Teraz Strzykawke można dostosować do niemal każdej dll'ki i aplikacji. Wstrzykiwanie powinno działać z dowolnej lokacji. Na końcu podam linki do źródełek. Wygląda to teraz tak:

Nazwa pliku Strzykawki jest sprzężona z nazwą wstrzykiwanej biblioteki, tzn jeśli zmienimy jedno, to musimy i zmienić drugie. W kodzie programu za takie działanie odpowiada:

string sciezkaFol = Directory.GetCurrentDirectory();
            Module plikExe = Assembly.GetExecutingAssembly().GetModules()[0];
            string pelnaSciezkaExe = sciezkaFol + "\\" + plikExe.Name;
            pelnaSciezkaDll = pelnaSciezkaExe.Replace("exe", "dll");
            textBox1.Text = pelnaSciezkaExe;
            textBox2.Text = pelnaSciezkaDll;

Pobiera sobie do stringa ścieżkę folderu ze Strzkawką, rozpoznaje nazwę pliku Strzykawki i zapisuje do innego stringa scieżkę do dll'ki o takiej samej nazwie. Oba stringi pojawiają sie automatycznie w pierwszych dwóch textboxach.

Ostatnie dwa textboxy są potrzebne jeśli mamy zamiar użyć przycisku "Uruchom program i wstrzyknij dll". Aplikacje można zdalnie uruchomić za pomocą:

Process gra = new Process();
                gra.StartInfo.FileName = textBox5.Text; // sciezka do .exe
                gra.StartInfo.Arguments = textBox4.Text; // parametry
                gra.Start();

Wszystkie wprowadzone parametry można zapisać do pliku ustawienia.xml. Po uruchomieniu program automatycznie jes wczyta.

Zapis xml:

XmlWriter writer:

            XmlWriterSettings settings = new XmlWriterSettings();
            settings.Indent = true;
            settings.OmitXmlDeclaration = true;
            settings.NewLineOnAttributes = true;

            string plikust = Directory.GetCurrentDirectory() + "\\ustawienia.xml";

            writer = XmlWriter.Create(plikust, settings);

            writer.WriteStartElement("Ustawienia");
            writer.WriteElementString("Proces", textBox3.Text);
            writer.WriteElementString("EXE", textBox5.Text);
            writer.WriteElementString("Parametry", textBox4.Text);
            writer.WriteEndElement();

            writer.Flush();
            writer.Close();

Odczyt xml:

bool istniejeplik = File.Exists(Directory.GetCurrentDirectory() + "\\ustawienia.xml");
            if (istniejeplik == true)
            {
                //XmlReaderSettings settings = new XmlReaderSettings();
                
                XmlReader reader = XmlReader.Create("ustawienia.xml");

                reader.MoveToContent();
                reader.ReadToDescendant("Proces");
                textBox3.Text = reader.ReadElementString("Proces");
                textBox5.Text = reader.ReadElementString("EXE");
                textBox4.Text = reader.ReadElementString("Parametry");
                reader.Close();
            }

Do samego wstrzykiwania użyłem biblioteki samuri25404.

Biblioteka do uruchamiania biblioteki z menu (.NET):

Tutaj kombinowałem, żeby było można z dowolnej lokacji uruchomić dll'ke z menu. Zrobiłem to w ten sposób:

    TCHAR strDLLPath1 [MAX_PATH + 1] = "";
    ::GetModuleFileName((HINSTANCE)&__ImageBase, strDLLPath1, _MAX_PATH);
    ::PathRemoveExtension(strDLLPath1);
    TCHAR *pelnaSciezka = new TCHAR[100];
    TCHAR *biblioteka = _T("\\prop32hckmenu.dll");
    strcpy_s(pelnaSciezka, 100, strDLLPath1); // copy b into a
    strcat_s(pelnaSciezka, 100, biblioteka); // append c to a
    
    LPCSTR pelnaSciezstr = (LPCSTR)pelnaSciezka;
    ULONG dlugosc = strlen(pelnaSciezstr) + 1;
    LPWSTR sciezkaaUnikod = new WCHAR[dlugosc];
    //MessageBox (0, pelnaSciezstr, "Hck", MB_ICONINFORMATION);
    ::MultiByteToWideChar(CP_ACP, 0, pelnaSciezstr, dlugosc, sciezkaaUnikod, dlugosc);

    DWORD zwWart = 0;
    hr = pClrHost->ExecuteInDefaultAppDomain(
        sciezkaaUnikod,
        //L"prop32hckmenu.dll",
        L"prop32hck.hckMenu", L"menuStart", L"pwzArgument", &zwWart);

GetModuleFileName pobiera sobie scieżkę i nazwę naszej pierwszej wstrzyknietej dll'ki. PathRemoveExtension usuwa z nazwy rozszerzenie a na końcu do takiego ciągu znaków dodaje "\\prop32hckmenu.dll". MultiByteToWideChar konwertuje naszą ścieżke do dll'ki z ASCII do Unicode. W efekcie pierwsza biblioteka będzie szukać drugiej o nazwie prop32hckmenu.dll w katalogu o nazwie takiej samej jak nazwa pliku Strzykawki i pierwszej dll'ki (czyli np "asd", jak na skrinie powyżej). Na samym poczętku trzeba jeszcze dodać coś takiego:

#pragma comment(lib, "MSCorEE.lib")
#pragma comment(lib, "shlwapi.lib")
#include <tchar.h>
#include <shlwapi.h>
#include <winnls.h>

HMODULE Module;
EXTERN_C IMAGE_DOS_HEADER __ImageBase;

Biblioteka z menu (.NET):

Logo MPC na skrinie to właśnie to menu, a właściwie forma w której je odpalamy. Samo menu działa kontekstowo, tzn po kliknięciu na formie prawym przyciskiem myszy:

Po dwukrotnym kliknięciu w designerze na jakąs opcje w menu powinno nas przenieśc do odpowiedniej procedury. Dla opcji No Spread (brak odrzutu) wygląda np tak:

private void brakOdrzutuToolStripMenuItem_Click(object sender, EventArgs e)
        {
            contextMenuStrip1.Show(); //ponieważ menu znika po kliknieciu to wywołuje je ponownie

            if (brakOdrzutuToolStripMenuItem.Checked == false) //jeśli opcja nie jest jeszcze znaznaczona...
            {
                brakOdrzutuToolStripMenuItem.Checked = true; //to teraz ją zaznaczam 
                brakOdrzutuToolStripMenuItem.Text = "Brak Odrzutu Wł."; //zmieniam tekst w menu
                nosprrec.Enabled = true; //odpalam odpowiedni timer
            }
            else
            {
                brakOdrzutuToolStripMenuItem.Checked = false; //odznaczam opcje
                brakOdrzutuToolStripMenuItem.Text = "Brak Odrzutu Wył."; //zmieniam opis
                nosprrec.Enabled = false; //wyłaczam timer
            }
      }

Znalazłem też ciekawą klasę, która importujemy dodając na poczatku kodu:

using System.Runtime.InteropServices;

Pozwala ona zapisywać i odczytywać niezarządzaną pamięć z poziomu aplikacji .NET a także alokować nową. Zdaje się, że ma to służyć do usprawnienia pracy między pamięcią zarządzaną i niezarządzaną. Kod w timerze, który zapisuje no spread wygląda teraz tak:

IntPtr spread = (IntPtr)(nospread_Addie1);
            Marshal.WriteInt32(spread, 0);

nospread_Addie1 zadeklarował z resztą adresów na samym poczatku jako integer. Pierwsza linijka tworzy pointer do tego adresu a następna zapisuje Int32 (4 bajty) pod tym adresem z wartością 0.

Wydaje mi się, że dałoby się zapisać analogicznie adresy z offsetami np dla no recoil:

IntPtr rec1 = (IntPtr)(playerpointer_Addie1 + 0x2F4);

IntPtr rec2 = (IntPtr)(playerpointer_Addie1 + 0x2F8);

IntPtr rec3 = (IntPtr)(playerpointer_Addie1 + 0x2FC);

Marshal.WriteInt32(rec1, 0);

Marshal.WriteInt32(rec2, 0);

Marshal.WriteInt32(rec3, 0);

Ciężko mi powiedzieć, czy to działa, ale może kmuś uda sie przetestować.

Inne wariacje funkcji Marshal do zapisywania to:

Marshal.WriteByte (1 bajt)

Marshal.WriteInt16 (2 bajty)

Marshal.WriteInt32 (4 bajty)

Marshal.WriteInt64 (8 bajtów)

Marshal.WriteIntPtr (wskaźnij do adresu, albo uchwytu)

Problem pojawia się, gdy tą metodą próbujemy zapisać coś w pamięci chronionej przed zapisem. ESP np znajduje sie w obszarze takiej pamięci. Wtedy trzeba najpierw zdjąć zabiezpieczenia z takiej lokacji za pomocą VirtualProtectEx. Ta funkcje trzeba już zaiportować. Procedurka z uzyciem VirtualProtectEx, która zdejmuje zabezpieczenia wygląda u mnie tak:

        public void OchronaPamieci(int dwSize, IntPtr pointAdres, uint typNowejOchrony)
        {
            //
            funkcjeAPI.TypDostepu dostep;
            dostep = funkcjeAPI.TypDostepu.PROCESS_VM_OPERATION | funkcjeAPI.TypDostepu.PROCESS_VM_WRITE
                     | funkcjeAPI.TypDostepu.PROCESS_VM_READ;

            IntPtr uchwyt = funkcjeAPI.OpenProcess((uint)dostep, 1, Process.GetCurrentProcess().Id);
            uint lpflOldProtect = 0;
            funkcjeAPI.VirtualProtectEx(uchwyt, pointAdres, (IntPtr)dwSize, (uint)typNowejOchrony, ref lpflOldProtect);
            funkcjeAPI.CloseHandle(uchwyt);
        }

A kod opcji ESP:

        prop32hck.funkcjeAutorskie dzialaj = new prop32hck.funkcjeAutorskie();
        private void nazwyPrzeciwnikówToolStripMenuItem_Click(object sender, EventArgs e)
        {
            contextMenuStrip1.Show();

            if (nazwyPrzeciwnikówToolStripMenuItem.Checked == false)
            {
                nazwyPrzeciwnikówToolStripMenuItem.Checked = true;
                nazwyPrzeciwnikówToolStripMenuItem.Text = "Brak Odrzutu Wł.";
                dzialaj.OchronaPamieci(1, (IntPtr)esp_Addie1, 0x40);
                IntPtr esp = (IntPtr)(esp_Addie1);
                Marshal.WriteByte(esp, 0x76);
            }
            else
            {
                nazwyPrzeciwnikówToolStripMenuItem.Checked = false;
                nazwyPrzeciwnikówToolStripMenuItem.Text = "Brak Odrzutu Wył.";

                dzialaj.OchronaPamieci(1, (IntPtr)esp_Addie1, 0x40);
                IntPtr esp = (IntPtr)(esp_Addie1);
                Marshal.WriteByte(esp, 0x75);
            }
        }

Przy czym HShield niemal natychmiast wykrywa te zmiany ochrony pamięci. W tym punkcie może wartoby było po nadpisaniu pamieci przywrócic oryginalne parametry ochrony pamięci w tym adresie.

W menu działa tylko "Brak odrzutu", ale wrzucam źródełka, więc może ktoś to już dopieści po swojemu.

Projekty:

Skan (jak widać da się zrobić hacka bez jakichkolwiek podejrzanych elementów :-P)

Download

PS: Warrock ze strzykawki odpalamy z parametrem %s. Inaczej nie ruszy.

qbir96 · 3 Marca 2009

Nom duzo a duzo sie napisales szacun dla ceiibe amsz 5*

Zaloguj się

👋 Witaj na MPCForum!

[Pytanie] Wstrzykiwanie bibliotek w VC

Rekomendowane odpowiedzi

Gość

Gość

Gość

Gość

Zarchiwizowany