OldSchoolHack

Registrieren / Anmelden Deutsch
deutschDeutsch
englishEnglish
Neue Beiträge Erweiterte Suche

External Tutorials [CS:S|CS:GO]

icon Thema: External Tutorials [CS:S|CS:GO]

Anmeldungsdatum: Sep 2012

Beiträge: 9

 Hallo OSH:User,
ich bin neu hier, habe aber Erfahrung was das Thema Coden angeht. Sowohl Interne Cheats, als auch Externe Cheats.

In diesem Tutorial will ich euch zeigen, wie Ihr einen External Triggerbot & Bunnyhop schreibt.
Gegebenfalls werde ich noch mehr adden, deswegen auch der Thread Name!

Was wir benötigen:
• CheatEngine
• OllyDBG
• Visual Studio / QT (Ich bevorzuge QT)
• Eine Programmiersprache (C++ , Visual Basic - eher C++)

Schritt 1.0 -Der Umgang mit OllyDbg- :
Im Schritt 1 müsst ihr den Spieler (euch) suchen. Den so genannten localplayer. Dazu startet Ihr Counter-Srike Source und erstellt einen Lokalen Server und joint drauf. Dannach öffnet ihr OllyDBG und Attacht den Process. Im Spoiler ist die Schritt - für - Schritt Erklärung für OllyDbg.

Spoiler
Schritt 1.1:
Spoiler
Ihr startet Counter-Strike: Source und startet OllyDbg. Klickt auf File -> Attach und wählt hl2 aus.
Um Links zu sehen, musst du dich registrieren

Schritt 1.2
Spoiler
Drückt in OllyDbg auf das [E] für Executable modules und klickt dann doppelklick auf "client"
Um Links zu sehen, musst du dich registrieren

Schritt 1.3
Spoiler
Drückt [C] für CPU threads -> rechtsklick ins Feld -> Search for -> All references Text Strings
Um Links zu sehen, musst du dich registrieren

Schritt 1.4
Spoiler
Rechtsklick in das neue Fenster und nach "localplayer" suchen.. da wird es dann mehrere Ergebnisse geben.
Das Richtige ist das erste wo nur localplayer steht.
Um Links zu sehen, musst du dich registrierenUm Links zu sehen, musst du dich registrieren

Schritt 1.5
Spoiler
Darauf macht ihr Doppelklick und im CPU Fenster scrollt ihr nach oben wo CMP DWORD PTR DS: steht und Notiert euch das was in der Klammer steht..
Um Links zu sehen, musst du dich registrieren

Schritt 1.6
Spoiler
Scrollt ganz nach oben und in der ersten Spalte links, die Zahl notiert ihr euch auch. So nun rechnet ihr die Zahl die ihr ganz oben Gefunden habt - 1000 und notiert euch die. Dann rechnet ihr LocalplayerZahl - DieNeueZahl = BaseEntity
Um Links zu sehen, musst du dich registrieren

Schritt 1.7
Spoiler
Nun benötigen wir noch die netVars m_lifestate und m_fFlags. Einfach im TextStrings Popup [R] nach oben Scrollen und von oben aus eine neue suche Starten. m_fFlags -> Doppelclick drauf und eine Spalte drüber steht ein Push Wert.. das ist euer offset.
Um Links zu sehen, musst du dich registrieren

Schritt 2.0 -Pointer to Enemy via CheatEngine-:
Startet CheatEngine und wählt hl2.exe aus. Macht es nach diesem VideoTutorial.
Vorab inforamtion: Wenn der Gegner Sichtbar ist (1) müsst ihr nach 2 suchen. Da die SourceEngine irgendwas hat, das die ID +1 ist.. (falls das YT Video hier nicht zusehen ist: youtu.be/m13X5c3IJ7E )




Schritt 3.0 -Let's begin with the code!-
So was das Coden angeht, hoffe ich das ihr schon Erfahrung habt. Denn ich will jetzt hier keine C++ Basic Stunde geben oder so.
Ich stelle euch den CProcess.h Header zu verfügung. Angeblich gehört er Excidium, aber wenn man mal googlet findet man da mehrere Ergebnisse Mr.Excidium. Nunja, da ich es eigentlich etwas anders mache, aber es nicht genau erklären will benutze ich jetzt für das Tutorial die CProces Klasse..

CProcess Header:
Spoiler
CPP Code:
  1. #pragma once
  2. #include <Windows.h>
  3. #include <TlHelp32.h>
  4.  
  5. class CProcess
  6. {
  7. public:
  8.  
  9.     PROCESSENTRY32 pGame;
  10.     HANDLE hProcess;
  11.     HWND hwndCss;
  12.  
  13.     DWORD dwClient;
  14.     DWORD dwEngine;
  15.     DWORD dwOverlay;
  16.     DWORD dwVGui;
  17.     DWORD dwLibCef;
  18.     DWORD dwSteam;
  19.  
  20.  
  21.  
  22.     DWORD FindProcess(const char *ccName, PROCESSENTRY32 *pEntry)
  23. {
  24.         PROCESSENTRY32 pEntry32;
  25.         pEntry32.dwSize = sizeof(PROCESSENTRY32);
  26.  
  27.         HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
  28.         if (hSnapshot == INVALID_HANDLE_VALUE) return 0;
  29.  
  30.         if (!Process32First(hSnapshot, &pEntry32))
  31.         {
  32.                 CloseHandle(hSnapshot);
  33.                 return 0;
  34.         }
  35.  
  36.         do
  37.         {
  38.                 if (!strcmpi(pEntry32.szExeFile, ccName))
  39.                 {
  40.                         memcpy((void *)pEntry, (void *)&pEntry32, sizeof(PROCESSENTRY32));
  41.                         CloseHandle(hSnapshot);
  42.                         return pEntry32.th32ProcessID;
  43.                 }
  44.         } while (Process32Next(hSnapshot, &pEntry32));
  45.  
  46.         CloseHandle(hSnapshot);
  47.         return 0;
  48. }
  49.     DWORD FindThread(DWORD dwProcess)
  50. {
  51.         THREADENTRY32 tEntry32;
  52.         tEntry32.dwSize = sizeof(THREADENTRY32);
  53.  
  54.         HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
  55.         if (hSnapshot == INVALID_HANDLE_VALUE) return 0;
  56.  
  57.         if (!Thread32First(hSnapshot, &tEntry32))
  58.         {
  59.                 CloseHandle(hSnapshot);
  60.                 return 0;
  61.         }
  62.  
  63.         do
  64.         {
  65.                 if (tEntry32.th32OwnerProcessID == dwProcess)
  66.                 {
  67.                         CloseHandle(hSnapshot);
  68.                         return tEntry32.th32ThreadID;
  69.                 }
  70.         } while (Thread32Next(hSnapshot, &tEntry32));
  71.  
  72.         CloseHandle(hSnapshot);
  73.         return 0;
  74. }
  75.     DWORD GetModuleBase(LPSTR lpModuleName, DWORD dwProcessId)
  76. {  MODULEENTRY32 lpModuleEntry = {0};
  77.    HANDLE hSnapShot = CreateToolhelp32Snapshot( TH32CS_SNAPMODULE, dwProcessId);
  78.    if(!hSnapShot)
  79.       return NULL;
  80.    lpModuleEntry.dwSize = sizeof(lpModuleEntry);
  81.    BOOL bModule = Module32First( hSnapShot, &lpModuleEntry );
  82.      while(bModule)
  83.    {
  84.            if(!strcmp(lpModuleEntry.szModule, lpModuleName ) )
  85.       {CloseHandle( hSnapShot );
  86.          return (DWORD)lpModuleEntry.modBaseAddr;
  87.       }
  88.       bModule = Module32Next( hSnapShot, &lpModuleEntry );
  89.    }
  90.    CloseHandle( hSnapShot );
  91.    return NULL;
  92. }
  93.     void Initialize()
  94.     {
  95.  
  96.     while (!FindProcess("hl2.exe", &pGame)) Sleep(10);
  97.     while (!(FindThread(pGame.th32ProcessID))) Sleep(10);
  98.  
  99.     hProcess = OpenProcess(PROCESS_ALL_ACCESS, false, pGame.th32ProcessID);
  100.     dwClient = GetModuleBase("client.dll", pGame.th32ProcessID);
  101.     dwEngine = GetModuleBase("engine.dll", pGame.th32ProcessID);
  102.     dwOverlay = GetModuleBase("GameOverlayRenderer.dll", pGame.th32ProcessID);
  103.     dwVGui = GetModuleBase("vguimatsurface.dll", pGame.th32ProcessID);
  104.     dwLibCef = GetModuleBase("libcef.dll", pGame.th32ProcessID);
  105.     dwSteam = GetModuleBase("steam.dll", pGame.th32ProcessID);
  106.     hwndCss = FindWindow(NULL, "Counter-Strike Source");
  107.     }
  108. };
  109.  
  110. extern CProcess gProcess;

Ich erstelle mir immer einen Header wo alle Includes reinkoemmen.. Ich nenne ihn allshit.h
und er sieht bei mir so aus:
Spoiler

Um Links zu sehen, musst du dich registrieren
CPP Code:
  1. #include <iostream>
  2. #include <Windows.h>
  3. #include <conio.h>
  4.  
  5. using namespace std;

Gut weiter in die main.cpp.
Dort schreiben wir erstmal rein:
CPP Code:
  1. #include "CProcess.h"
  2. #include "allshit.h"
  3.  
  4. CProcess gProcess;

Und dann erstellen wir unser Player Struct. Es sollte BasEntity, m_fFlags, m_lifestate, TriggerID enthalten.
CPP Code:
  1. struct LocalPlayer_t
  2. {
  3.     DWORD BaseEntity;
  4.     int m_fFlags;
  5.     int m_lifestate;
  6.     int TriggerID;
  7. }LocalPlayer;

Dann Fangen wir mal an den ganzen Kram via ReadProcessMemory auszulesen..
Dazu erstellen wir ein neuen Block und ich nenne ihn ReadProcessMemory()
CPP Code:
  1. void ReadProcessMemory()
  2. {
  3.     ReadProcessMemory(gProcess.hProcess, (LPCVOID)(gProcess.dwClient+0x73B29C), &LocalPlayer.BaseEntity, 4, 0);         // BaseEntity
  4.     ReadProcessMemory(gProcess.hProcess, (LPCVOID)(LocalPlayer.BaseEntity+0x314), &LocalPlayer.m_fFlags, 4, 0);         // m_fFlags
  5.     ReadProcessMemory(gProcess.hProcess, (LPCVOID)(LocalPlayer.m_lifestate+0x8F), &LocalPlayer.m_lifestate, 4, 0);      // m_lifestate
  6.     ReadProcessMemory(gProcess.hProcess, (LPCVOID)(LocalPlayer.TriggerID+0x14A8), &LocalPlayer.TriggerID, 4, 0);      // EnemyID to Trigger
  7. }

So nun gibt es zwei Möglichkeiten wie ihr es macht.. Entweder mit CreateThread (Bessere Performance) oder ihr schreibt alles in eine While Schleife.. Ich erkläre euch hier beides!

CreateThread Methode:
Spoiler

Wir erstellen 2 Threads. Einmal der Thread für den Triggerbot:
CPP Code:
  1. DWORD WINAPI Thread_Trigger( LPVOID lpParam )
  2. {
  3.     while(true)
  4.     {
  5.         ReadProcessMemory();
  6.         LocalPlayer.TriggerID--;    // TriggerID -1
  7.         if(LocalPlayer.TriggerID >= 0 && LocalPlayer.PlayerID < 64)
  8.         {
  9.             if(GetASyncKeyState(6)) // Mouse5
  10.             {
  11.                 Sleep(15); // TriggerDelay
  12.                 mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
  13.                 Sleep(10);
  14.                 mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
  15.             }
  16.         }
  17.     }
  18. }

Und der Thread für den Bunnyhop:
CPP Code:
  1. DWORD WINAPI Thread_Bhop( LPVOID lpParam )
  2. {
  3.     while(true)
  4.     {
  5.         ReadProcessMemory();
  6.         if( GetASyncKeyState(0x20)) // Leertaste
  7.         {
  8.             if( GetForegroundWindow() != gProcess.hwndCss ) // Wenn man aufm Desktop ist
  9.             {
  10.                 return;
  11.             }
  12.             if( LocalPlayer.m_lifestate == 257 )
  13.             {
  14.                 return;
  15.             }
  16.             if( LocalPlayer.m_fFlags == 257 || LocalPlayer.m_fFlags == 259 || LocalPlayer.m_fFlags == 261 || LocalPlayer.m_fFlags == 263 )
  17.             {
  18.                 SendMessage(gProcess.hwndCss, WM_KEYDOWN, VK_SPACE, 0x390000);
  19. 				Sleep(10);
  20. 				SendMessage(gProcess.hwndCss, WM_KEYUP, VK_SPACE, 0x390000);
  21.             }
  22.         }
  23.     }
  24. }

Dann müssen wir nur noch in der Main die beiden Threads Erstellen. Das Geht via CreateThread.
CPP Code:
  1. int main()
  2. {
  3.     gProcess.Initialize();
  4.     CreateThread(0, 0, Thread_Trigger, 0, 0, 0);
  5.     CreateThread(0, 0, Thread_Bhop, 0, 0, 0);
  6. }

Die andere Methode:
Spoiler

Wieder 2 Blöcke erstellen. Der Bunnyhop Block:
CPP Code:
  1. void Bunnyhop()
  2. {
  3.     ReadProcessMemory();
  4.     if( GetASyncKeyState(0x20)) // Leertaste
  5.     {
  6.         if( GetForegroundWindow() != gProcess.hwndCss ) // Wenn man aufm Desktop ist
  7.         {
  8.             return;
  9.         }
  10.         if( LocalPlayer.m_lifestate == 257 )
  11.         {
  12.             return;
  13.         }
  14.         if( LocalPlayer.m_fFlags == 257 || LocalPlayer.m_fFlags == 259 || LocalPlayer.m_fFlags == 261 || LocalPlayer.m_fFlags == 263 )
  15.         {
  16.             SendMessage(gProcess.hwndCss, WM_KEYDOWN, VK_SPACE, 0x390000);
  17.             Sleep(10);
  18.             SendMessage(gProcess.hwndCss, WM_KEYUP, VK_SPACE, 0x390000);
  19.         }
  20.     }
  21. }

Und der Triggerbot Block:
CPP Code:
  1. void Triggerbot()
  2. {
  3.     ReadProcessMemory();
  4.     LocalPlayer.TriggerID--;    // TriggerID -1
  5.     if(LocalPlayer.TriggerID >= 0 && LocalPlayer.PlayerID < 64)
  6.     {
  7.         if(GetASyncKeyState(6)) // Mouse5
  8.         {
  9.             Sleep(15); // TriggerDelay
  10.             mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
  11.             Sleep(10);
  12.             mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
  13.         }
  14.     }
  15. }

So und in der Main müsst ihr nun eine While True schleife erstellen.
CPP Code:
  1. int main()
  2. {
  3.     while(true)
  4.     {
  5.         Bunnyhop();
  6.         Triggerbot();
  7.     }
  8. }

Der Ent-Code sieht bei mir nun so aus:
Spoiler
Um Links zu sehen, musst du dich registrieren
So das ganze nun Compilen und ihr habt einen External Bunnyhop & Triggerbot.
Ja mir ist bewusst, dass ich einen kompletten SourceCode Public gemacht hab, inkl. Offsets. Wobei das euch nicht viel bringen wird wenn ein neues Update draußen ist, dann müsst ihr nur noch das Teil hier Updaten.

Ich würde es nett Finden, wenn ihr mir Credits geben werdet, wenn ihr das Tutorial irgendwo C&P -> und postet. Bzw was released.

Inspiriert hat mich sMp, da er das Ganze in VB.net gemacht hat -> und im Forum jemand es in C++ umsetzten wollte!

Falls was ist, einfach hier in Thread schreiben! :>
Gruß, sKy.

sKy. ist offline