4. Cheats für Spiele, Aimbot, Wallhack

Cheats für Spiele, Aimbot, Wallhack

  • C

    WinAPI Zeugs halt. Bei simplen Spielen kannst du zB. wenn du im Spiel 233 Lebenspunkte hast alle Offsets an denen 233 steht auslesen. Dann änderst du deine Lebenspunkte einfach mal (zB. auf 100). Dann guckst Du ob in einem der vorher gefundenen Offsets die Zahl 100 steht. Meistens bleibt schon jetzt nur noch ein Offset übrig, hier stehen also deine Lebenspunkte. Die könntest du ja jetzt zB. immer mit 10000 überschreiben und wärst somit unsterblich.

    Weiter würde es dann wahrscheinlich mit Injection gehen, viel mehr weiß ich aber auch nicht, habe mich eigentlich nie viel damit beschäftigt 😉

    0
  • S

    aber mal ganz ehrlich, auch wenn ich wzar leidenschaftlicher spieler bin, aber stirkt gegen cheater, interessiert mich die materie auch. gibt es keinen der davon ahnung hat und sich mit sowas mal beschäftigt hat?

    0
  • A

    Ähm, siehe vorige Posts. Mehr als Speichergeschubse sind viele Cheats nicht. Da geht es nur darum, die Addressen zu finden, an denen interessante Werte gespiechert werden oder gezielt bestimmte Instruktionen auszuschalten (d.h. mit NOP zu überschreiben) oder durch andere zu ersetzen.
    Außer Programmierkenntnissen benötigt man bis dahin kein Vorwissen, auch wenn es evtl. den Einstieg erleichtern mag, wenn jemand, der das schon länger macht, seine bisherigen Erkenntnisse darlegt.

    Bei Onlinespielen kommt u.a. die Möglichkeit hinzu, ausgehende (oder auch eingehende) Pakete zu manipulieren.

    0
  • F

    ausserdem gibts da verschiedene Ansätze. Viele spiele bringen ja eigene erweiterungsmöglichkeiten mit. Darauf setzen ja einige Aimbots. man könnte das wohl auch über Bilderkennung und Fremdsoftware machen die sich zwischen den Spiel und der Maus hängt. Wallhacks sind wohl meist auch nur modifikationen an der Spielengine so das eben Texturen nicht richtig dargestellt werden. Echte Cheats, sind meist von den Programmierern für Debuggingzwecke eingebaut worden. Um wirklich ein konkretes Ziel zu verfolgen muss man sich also erstmal im klaren sein was man wirklich will.

    0
  • O

    Wallhacks wurden früher einfach über modifizierte opengl oder d3d dlls realisiert.

    0
  • ?

    Deshalb sollten Positionen von Spielern, die gar nicht sichtbar sind, auch nicht empfangen werden.
    Aber es scheint sich niemand diese Mühe machen zu wollen.

    Ist natürlich nur ein Beispiel, zb für Shooter, und wenn es die Mechanik zulässt.

    0
  • C

    So einfach ist das nicht. Es müssen ja auch Schritte, Schaden durch Wände, Schussgeräusch etc. berechnet werden, wenn der Gegner nicht sichtbar ist. Soll das alles der Server berechnen? Das macht nicht wirklich viel Sinn 😉

    0
  • Mod

    Eine ganz simple Manipulation ist auch das Verändern der Spieldateien. So kann man z.B. Gegnern eine rot leuchtende Fadenkreuztextur verpassen (so etwas kann ein Aimbot auch ganz wunderbar per Screencapturing erfassen) oder den Wänden einen Alphawert geben.

    0
  • ?

    Wer Cheats coden möchte, lernt Reverse Engineering. Hat man dessen Basics erlernt, versucht man in das Spiel eine DLL zu injecten, deren Ziel es ist, die Werte hinter den Adressen auszulesen / zu verändern.

    Hierbei muss unterschieden werden zwischen

    • Simplen Adressen, die nicht einsortiert sind in Klassen
    #define ADDRESS 0x...
*(typename*)(ADDRESS) = ...;
    • sowie Membern von Klassen:
    #define CLASS_POINTER 0x...
#define MEMBER_OFFSET 0x...
*(typename*)(*(unsigned long*)(CLASS_POINTER) + MEMBER_OFFSET) = ...

    Ein Aimbot verändert Yaw, Pitch & Roll des lokalen Spielers mit denjenigen Werten, die er brauch um auf das Ziel zu zielen. Kurz: die VIEW-Matrix wird kalkuliert nach POSITIONS-Matrizen von lokalen Spieler und dem Ziel sowie dessen BONE-Matrix, die die anzuvisierende Position auf dem Ziel angibt.
    Dahinter steckt häufig eine Menge Mathematik, die nicht unterschätzt werden will.

    Der Visible Check, der auch bereits genannt wurde, lässt sich mit dem z-Buffer des 3D-Devices machen. Ist eigentlich keine schwierige Sache. Viele Spiele enthalten außerdem noch einen eigenen Visiblecheck, diese Funktion kann dann z.B. Member der PlayerClass sein.

    Fortgeschrittene Coder verwenden zumeist das Programm ReClass, um Klassen nachzubilden.

    0
  • O

    hier ein simplen header für einen triggerbot

    #pragma once
    #define WIN32_LEAN_AND_MEAN
    #include <Windows.h>
    #include <TlHelp32.h>

    #include <cstdint>
    #include <string_view>

    class Memory
    {
    private:
    std::uintptr_t processId = 0;
    void* processHandle = nullptr;

    public:
    // Constructor that finds the process id
    // and opens a handle
    Memory(const std::string_view processName) noexcept
    {
    ::PROCESSENTRY32 entry = { };
    entry.dwSize = sizeof(::PROCESSENTRY32);

    	const auto snapShot = ::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

	while (::Process32Next(snapShot, &entry))
	{
		if (!processName.compare(entry.szExeFile))
		{
			processId = entry.th32ProcessID;
			processHandle = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, processId);
			break;
		}
	}

	// Free handle
	if (snapShot)
		::CloseHandle(snapShot);
}

// Destructor that frees the opened handle
~Memory()
{
	if (processHandle)
		::CloseHandle(processHandle);
}

// Returns the base address of a module by name
const std::uintptr_t GetModuleAddress(const std::string_view moduleName) const noexcept
{
	::MODULEENTRY32 entry = { };
	entry.dwSize = sizeof(::MODULEENTRY32);

	const auto snapShot = ::CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, processId);

	std::uintptr_t result = 0;

	while (::Module32Next(snapShot, &entry))
	{
		if (!moduleName.compare(entry.szModule))
		{
			result = reinterpret_cast<std::uintptr_t>(entry.modBaseAddr);
			break;
		}
	}

	if (snapShot)
		::CloseHandle(snapShot);

	return result;
}

// Read process memory
template <typename T>
constexpr const T Read(const std::uintptr_t& address) const noexcept
{
	T value = { };
	::ReadProcessMemory(processHandle, reinterpret_cast<const void*>(address), &value, sizeof(T), NULL);
	return value;
}

// Write process memory
template <typename T>
constexpr void Write(const std::uintptr_t& address, const T& value) const noexcept
{
	::WriteProcessMemory(processHandle, reinterpret_cast<void*>(address), &value, sizeof(T), NULL);
}

    };

    0

  • Hast du echt 13 Jahre für 87 Zeilen Code gebraucht? Das sind 6.69 Zeilen pro Jahr, 0.56 Zeilen pro Monat und etwa 0.018 Zeilen pro Tag. Ich hoffe, du hast dich nicht überanstrengt bei der ganzen Tipperei.

    0
Anmelden zum Antworten