DWORD zu FLOAT



  • Hallo

    Ich versuche mit einer DLL direkt den Speicher einer Anwendung auszulesen.
    Das ganze mache ich mit Multi-Level-Pointer.
    Das Problem ist das ich nun ein Typ DWORD in FLOAT umwandeln muss damit die Daten korrekt angezeigt werden.Wie kann ich das machen

    LG Hans

    WORD thefirst = (DWORD)(*(DWORD*)0xDA8208 +  0x13A8);
    DWORD thesecond = (DWORD)(*(DWORD*)thefirst + 0x04);
    DWORD thesecond2 = (DWORD)(*(DWORD*)thesecond + 0x18);
    
    FLOAT X = (DWORD)(*(DWORD*)thesecond2 + 0x28);
    FLOAT Y = (DWORD)(*(DWORD*)thesecond2 + 0x2C);
    FLOAT Z = (DWORD)(*(DWORD*)thesecond2 + 0x30);
    


  • Sicher, dass dein Code das machst was du möchtest? Wenn ich mir z.B. deine erste Zeile anschaue, dann ließt du die Daten an Adresse 0xDA8208 als DWORD, addierst 0x13A8 zu dem Wert dazu. Wolltest du nicht eher zu dem Pointer was addieren? Der letzte DWORD cast ist auch überflüssig, da beim dereferenzieren von einem DWORD Pointer natürlich ein DWORD rauskommt.

    Nun zu deinem anderen Problem. Wenn du die Bytes eines DWORD als float interpretieren möchtest muss man den Umweg über Pointer gehen:

    DWORD x;
    float fx = *(float*)&x;
    

    Allerdings verletzt man damit streng genommen die strict aliasing rule.



  • Oder einfach statt einem DWORD-Zeiger einen float-Zeiger verwenden 😕



  • Hallo

    Danke für deine schnelle Antwort.
    Ob das ganze funktioniert kann ich nicht genau sagen da meine Werte nicht dem entsprechen was ich erwarte. Allerdings falls was bei den Pointern nicht stimmen würde müsste die .exe ja direkt crashen oder ?

    Aber hier mal das Grundgerüst was ich versuche auszulesen.

    [[[[0xDFCDD8] + 0x13A8] + 0x4] +0x28]

    0xDFCDD8 + 0x13A8 + 0x4 + 0x28

    Bin mir auch nicht sicher ob ich bei 0x40000 + 0xDFCDD8 anfangen soll. Da ich ja die DLL inj. bin ich ja schon im Adressenbereich der Anwendung oder ?



  • Nein, die DLL ist nicht in einem anderen Segment als die Anwendung. Du kannst die Adressen natürlich als ints zusammenrechnen, musst halt entsprechend klammern setzen 😉



  • roflo schrieb:

    Oder einfach statt einem DWORD-Zeiger einen float-Zeiger verwenden 😕 , Du kannst die Adressen natürlich als ints zusammenrechnen, musst halt entsprechend klammern setzen

    Ich dachte man muss die Pointer einzeln berechnen und nicht eindach addieren ?
    kannst du mir ein Beispiel geben wie genau du das mit float-Zeigern meinst



  • Hmm. ArmA 2 hacken wollen, aber keine Ahnung von Programmierung haben. Das geht nicht. Lass es einfach. 😞

    Es ist traurig dass viele Leute wie du in anderen Programmen rumpfuschen wollen, aber nicht die elementarsten Programmierkenntnisse beherrschen. 😞



  • Traurig ist es das du der Meinung bist das jeder der sich mit ARMA 2 beschäftigt ein Hacker ist und nur rumpfuschen will. Um wirklich ARMA 2 zu spielen bin ich denke ich ein wenig zu alt. Es soll auch Menschen geben die sich gerne mit einem Thema beschäftigen einfach nur aus reinem Interesse.Ich habe das Spiel gewählt weil man gute Informationen bzg. Offsets findet bzw mehr als für andere Spiele und Software und man es für 2 Euro kaufen kann.

    Aber wenn wir schon bei traurig sind , ich finde es traurig wenn man in einem Beitrag nichts konstruktives beisteuern möchte und nur sinnlose Kommentare postet.
    Aber jedem das Seine.

    Bin der Meinung mann lernt sehr schnell wenn man sich einfach ein Thema raussucht und dann damit anfängt. Selbst wenn man nie das Ziel erreicht lernt man auf dem Weg sehr viel was man mitnehmen kann.Aber auch hier jeder wie er möchte.

    Back 2 Topic:



  • float *zeiger = reinterpret_cast<float*>(0x123+0x234+0x828282)
    


  • Geht leider auch nicht , keiner noch einen Tip



  • Naja, du kannst die Offsets nicht einfach so addieren, du musst die schon schrittweise dereferenzieren.

    Ich würde es wohl so ähnlich machen:

    template <class T=DWORD> T deref(DWORD addr)
    {
      return reinterpret_cast<T&>(addr);
    }
    
    float f=deref<float>(deref(deref(deref(0xDFCDD8)+0x13A8)+0x4)+0x28);
    


  • Die eine Zeile ist Blödsinn, das sollte return *reinterpret_cast<T*>(addr); sein.



  • Ja stimmt, das 'Multi-Level' habe ich übersehen 😉



  • sebi707 schrieb:

    DWORD x;
    float fx = *(float*)&x;
    

    Allerdings verletzt man damit streng genommen die strict aliasing rule.

    Haha, diese wilde Konstruktion könnte sogar von mir sein.



  • @HansGerohnd:
    Ich will einen Vergleich wagen. Du möchtest einen Schwarzwälder Kirchkuchen backen, kannst aber gerade so eine Dose warm machen.

    Das Thema wird schnell kompliziert. Wie willst du Speicher eines anderen Prozesses manipulieren, wo doch die jeder Prozess seinen eigenen Adressraum hat? Interprozess Kommunikation? Remote Procedure Call? Sockets? Gibts eine Schnittstelle? Oder möchtest du einen Kernel Treiber schreiben, welcher den
    Prozessraum auf eine virtuelle Datei mapped und so die virtuelle Adressierung unterwandert?

    Alles klar du willst DLL Injection die Daten manipulieren. Einfach eine Funktion mittels WriteProcessMemory in den Prozess kopieren. Doch wie stelle ich die Grösse einer Funktion, eines Moduls (HMODULE) fest? Wie ist das Ganze abhängig vom Compiler? Spielt Speicher Alignment (Little Endian,...) eine Rolle? Ist eine Manipulation eines Speicherblock frei von Seiteneffekten? Und ja, wie reagiert man auf 64 Bit Prozesse? Inwiefern spielen Anti-Hacking Techniken (DEP, ALSR,...) eine Rolle? Welche Rolle spielen Signaturen?

    Das alles muss man fragen wenn man sauber einen Anpassung machen möchte.

    Und da muss man sicher auf den C++ Beinen stehen.

    Wieso spielst du nicht einmal Katz und Maus. Du programmierst zwei Programme. Eine einfache GUI, welche eine Schnittstelle anbietet. Und ein anderes Programm welche versucht die GUI mittels de4 Schnittstelle zu manipulieren.



  • Ich danke euch für die vielen Antworten.
    Ich habe eine Lösung gefunden die immoment sehr gut funktioniert.
    Hier der Code falls jemand mit dem selben Problem über diesen Thread stolpert.

    Auslesen des Pointers + Offsets

    int* xpos =  reinterpret_cast<int*>(
                    *reinterpret_cast<uintptr_t*>(
                    *reinterpret_cast<uintptr_t*>(
    				*reinterpret_cast<uintptr_t*>(
                    *reinterpret_cast<uintptr_t*>( 0xDA8208 ) + 0x13A8 ) + 0x4 ) + 0x18 )+ 0x28 );
    

    INT zu FLOAT

    float* XposFloat = reinterpret_cast<float*>(xpos);
    

    Wie ich schon sagte und einige von euch schon festgestellt haben bin ich noch sehr unerfahren in C++. Ob das also eine sehr saubere Methode ist kann ich nicht beurteilen aber sie funktioniert.Immomnet versuche ich das ganze nun eleganter mit Klassen zu lösen.

    Es mag wohl stimmen das man vieleicht besser erst sich an " Hallo World 2 versucht , ich persönlich habe ich allen Bereichen die Erfahrung gemacht das man deutlich bessere Fortschritte macht wenn man sich einfach ein Project sucht und versucht das umzusetzten. Man mag vieleicht nie an das Ziel kommen aber man lernt sehr viel auf dem Weg und kann dann neue realistischere Projecte in Angriff nehmen.



  • Hatte ich ganz vergessen.
    Ich würde mir gerne eine kleine Benutzeroberfläche basteln.
    Ob das ganze von AntiCheats usw erkannt wird ist mir egal da ich nicht aktiv spiele. Wichtiger wäre mir eher das man damit möglichst viele Möglichkeiten hat im Bezug auf andere Projecte usw.
    Falls ihr da ein paar Tips hat was man Benutzen sollte/könnte wäre das Klasse.
    Was haltet ihr also zum Beispiel von D3DX Win API ?



  • Du kannst natürlich die reine WinAPI benutzen, Qt und WxWidgets sind da aber einfacher. Was du jetzt mit DirectX willst weiß ich nicht, es sei denn du willst deine Buttons selber malen...



  • @HansGerohnd

    D3DX würde ich dir zur Zeit nicht empfehlen, denn D3DX ist die DirectX Schnittstelle und die Beispiele hierzu basieren stark auf der WinAPI.

    Zweitens ist DirectX die Schnittstelle für die Entwicklung von 3D Anwendungen wie beispielsweise Blender. Und das ist ein eigenes Gebiet mit Koordinatensysteme, Kamerapositionen, Szenen,...


Log in to reply