Spielernamen in Spielen rausfinden..

Flutscherino

Hiho,

Wonach muss ich suchen um Spielernamen in Spielen rauszufinden? Ich glaube zu wissen das ich dazu das Spiel "hooken" muss und dann kann ich irgendwie rausfinden wo welche Namen gespeichert sind... aber mehr glaub ich auch nicht zu wissen

darum würd ich gerne mal wissen was ich da googlen soll um in diese Richtung mehr erfahurng zu sammeln?

Konkret ginge es mir z.b. in Spielen wie LoL (League of Legends) oder DotA die Namen meiner Kollegen + Feinde raus zu finden..

Noch konkreter würd ich mir gerne ein kleines Tool schreiben für meine Persönliche Banliste zu erstellen, will heissen das mich das Tool mal warnt wenn ich schonmal mit einem gewissen Spieler gezockt hab und der halt nicht so meinen Vorstellungen entspricht

Danke!

C++ Forumbot

Dieser Thread wurde von Moderator/in SeppJ aus dem Forum C++ (auch C++0x und C++11) in das Forum Rund um die Programmierung verschoben.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

Jonas OSDever

Das ist von Spiel zu spiel komplett verschieden. Ob man da Funktionen hooken muss, wuerde ich im Allgemeinen eher bezweifeln. Theoretisch sollte es schon ausreichen eine Bestimmte Speicher-Adresse zu lesen. Die kannst du mit irgendwelchen Cheat-Programmen rausfinden. Sprich nach der Zeichenkette im Prozesspeicher suchen, bei mehreren Ergebnissen filtern bis du eine eindeutige Adresse hast.
Die kann sich aber auch jedesmal Aendern, abhaengig davon ob besagter Speicher auf dem Heap reserviert wird (duerfte meist der Fall sein) und was alles davor reserviert wird; ob das davor reservierte variabel gross sein kann.
Eine andere Moeglichkeit waere das Protokoll des Spiels dahingehend zu untersuchen wie die Namen in den Paketen rein kommen und dann die Pakete abzufangen. Wie man letzteres bewerkstelligt weiss ich nicht.

Am besten nimmst du fuer sowas fertige Programme.

Flutscherino

Ja es geht mir halt auch ums lernen, darum versuh ich das selber mal in die hand zu nehmen, nur fehlt mir der anfangspunkt

Aber danke jedenfalls

cooky451

Hier mal eine Klasse die ich vor Ewigkeiten geschrieben habe. Ist aber wie gesagt schon ziemlich alt, also ist der Programmierstil eher mit Vorsicht zu genießen. Helfen könnte es dir aber trotzdem. :xmas1:

class ProcessMemoryReader
{
private:
  static void GetProcessSnapshot(std::vector<PROCESSENTRY32>& process_list);
public:
  static std::size_t GetProcessId(const std::string& name);
  static void GetProcessNames(std::vector<std::string>& buf);
  static void FindValue(std::size_t process_id, const void* val, 
    std::size_t valsize, std::vector<std::size_t>& offsets);
  static void FindValue(const std::string& process_name, const void* val, 
    std::size_t valsize, std::vector<std::size_t>& offsets);
};

#include <string>
#include <vector>
#include <Windows.h>
#include <tlhelp32.h>
#include "ProcessMemoryReader.h"

void ProcessMemoryReader::GetProcessSnapshot(std::vector<PROCESSENTRY32>& process_list)
{
  HANDLE hsnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
  if (hsnap == INVALID_HANDLE_VALUE)
    throw std::exception("CreateToolhelp32Snapshot");

  PROCESSENTRY32 l_process_entry = {0};
  l_process_entry.dwSize = sizeof(l_process_entry);

  process_list.clear();

  Process32First(hsnap, &l_process_entry);
  process_list.push_back(l_process_entry);

  while (Process32Next(hsnap, &l_process_entry))
    process_list.push_back(l_process_entry);
}

std::size_t ProcessMemoryReader::GetProcessId(const std::string& name)
{
  std::vector<PROCESSENTRY32> process_list;
  GetProcessSnapshot(process_list);
  for (std::size_t i = 0; i < process_list.size(); ++i)
    if (name.compare(process_list[i].szExeFile) == 0)
      return process_list[i].th32ProcessID;
  return 0;
}

void ProcessMemoryReader::GetProcessNames(std::vector<std::string>& names)
{
  std::vector<PROCESSENTRY32> process_list;
  GetProcessSnapshot(process_list);
  names.clear();
  for (std::size_t i = 0; i < process_list.size(); ++i)
    names.push_back(process_list[i].szExeFile);
}

void ProcessMemoryReader::FindValue(std::size_t process_id, const void* val, 
  std::size_t valsize, std::vector<std::size_t>& offsets)
{
  // open process
  HANDLE hprocess = OpenProcess(PROCESS_VM_READ | 
    PROCESS_QUERY_INFORMATION, 0, process_id);
  if (!hprocess)
    return;

  SYSTEM_INFO sysinfo;
  GetSystemInfo(&sysinfo);

  LPVOID lpmem = 0;
  MEMORY_BASIC_INFORMATION mbi;
  offsets.clear();
  // while lpmem < virtual address space
  while (lpmem < sysinfo.lpMaximumApplicationAddress)
  {
    // get memory section info
    if (!VirtualQueryEx(hprocess, lpmem, &mbi, sizeof(mbi)))
      throw std::exception("VirtualQueryEx");

    // if we have access to memory section
    if (mbi.Protect != 0 && !(mbi.Protect & (PAGE_NOACCESS | PAGE_GUARD)))
    {
      std::vector<char> tempbuf(mbi.RegionSize);

      // read full memory section
      if (!ReadProcessMemory(hprocess, lpmem, &tempbuf[0], tempbuf.size(), 0))
        throw std::exception("ReadProcessMemory");

      // search for value
      for (std::size_t i = 0; i < tempbuf.size(); ++i)
        if (memcmp(&tempbuf[i], val, valsize) == 0)
          offsets.push_back((std::size_t)mbi.BaseAddress + i);
    }

    // set lpmem to next memory region
    lpmem = (LPVOID)((DWORD)mbi.BaseAddress + mbi.RegionSize);
  }
}

void ProcessMemoryReader::FindValue(const std::string& process_name, 
  const void* val, std::size_t valsize, std::vector<std::size_t>& offsets)
{
  std::size_t process_id = GetProcessId(process_name);
  FindValue(process_id, val, valsize, offsets);
}

Die Idee bei so etwas ist eigentlich immer gleich. Man sucht nach dem Wert der Variable, und bekommt einige Adressen. Dann verändert man den Wert, und sucht innerhalb der voher gefunden Adressen wieder. Jetzt hat man meistens nur noch eine Adresse, ansonsten wiederholt man den Schritt.

Flutscherino

Oh Vielen Dank, werd das dann mal anschauen!

KN4CK3R

ich kann dir den Tutorialbereich auf der Seite in meiner Signatur empfehlen

greetz KN4CK3R

Ich glaub das richtige Stichwort lautet: Player Structure

Such mal bei Google nach: How to find player structures

Oder sowas in der Art ich denke da wird man fündig.

Und Hooken ... wieso willst du was Hooken?^^
Mit so Sachen sollte man in Online-Multiplayer spielen etwas aufpassen. In der Regel wollen die Entwickler nicht das im Speicher ihrer Spiele rumgefuscht wird, im schlimmsten Fall endet das alles mit einer Account sperre.

Mir is da noch ein Link eingefallen:

http://www.vivid-abstractions.net/category/programming/tutorials/

Scroll da mal etwas runter da steht irgendwo was von Structures in memory vielleicht hilft dir das weiter.

Flutscherino

Danke vielmals, mir wurde der Tipp gegeben mich mal nach Sniffern rumzugooglen, und ich denke ich werd diese Richtung einschlagen..

Ich will halt wirklich nur die Namen der spieler, und im Memory rumpfuschen ist mir 1. VIEL zu schwirig und 2. auch gefährlich (ban incoming! )

Ich weis schon das Sniffer auch sehr schwirig sind zu schreiben, aber ich habe jetzt doch schonmal Winpcap zum laufen gebracht sodas es mir in der Console ausgibt welche Daten grad kommen..

Muss halt jetzt schaun, denke die Daten werden verschlüsselt sein, muss ich genauer unter die Lupe nehmen aber bin erst Freitag wieder zuhause

Wieso selber einen Sniffer bauen? Schau doch erstmal ob du mit den empfangenen Daten überhaupt was Anfangen kannst.

Ich mein nicht das du Stundenlang an deinem Sniffer rumprogrammierst und am Ende mit dem Traffic doch nichts anfangen kannst.^^

Flutscherino

naja ich mache es ja zum lernen, da is nix umsonst