Hilfe bei dynamischer Sprungberechnung

[sILeNt heLLsCrEAm]

Ein ganz herzliches Hallo an die Community und einen schönen guten Morgen.

Durch Google bin ich schon mehrmals auf dieses Forum gestoßen und erhoffe mir bei meinem derzeitigen Problem die Hilfe der Erfahrenen Nutzer/Programmierer unter euch.

Um mein Problem genauer zu beschreiben hol ich mal etwas weiter aus damit ihr seht um was es geht. Es dreht sich kurz gesagt da drum um einen Trainer für ein Spiel, bzw. für Spiele zu erstellen.
Das erstellen selbst ist kein Problem, habe auch schon etliche geschrieben. Die Daten die ich durch die Trainer in einen Spieleprozess schreibe sind allesamt in normalen Arrays abgelegt, beispielsweise so...
GeldJumpCodecave: array [0..4] of byte = ($E9,$55,$92,$70,$FF); Das wiederrum schreibe ich weiterhin so...

Delphi-Quellcode:

// Hier ist die Funktion um Adressen des Speichers zu beschreiben
// Das geschieht mittels WriteProcessMemory
Function WriteCheat (Adresse: PByte; ZuSchreiben: Array of Byte; WievielSchreiben: Integer): String;
Begin
  WriteProcessMemory(ProcOpen, Pointer(Adresse), @ZuSchreiben[0], WievielSchreiben, Write);
end;
...
...
WriteCheat(DLLBaseAddy+$8F7336, GeldJumpCodecave, 5);

Das Problem ist nun wenn ich z.B. einen Trainer mit sehr viel Optionen schreibe ich auch sehr viele Arrays ändern müsste. Das heißt mit klaren Worten das der Sprung zur Codecave (wo z.B. Geld ercheatet wird) und die Codecave selbst geändert werden müssen.

Nun zum eigentlichen Anliegen...
Meine Überlegung ist nun das ich die Sprünge von einer Adresse zur Codecave und von der Codecave zurück an die nächste Stelle im Code dynamisch, also durch den Trainer berrechnen lasse. Die Berechnung ist auch kein Problem. Diese sieht so aus...

Delphi-Quellcode:

NewWert:= Integer(DLLBaseAddy+$83D07C);
Merker:= Integer(DLLBaseAddy+$400) - NewWert - 5;

Um diese Bytes umzukehren nutze ich ganz simple "BSWAP". Davor dann noch das HEX Zeichen "E9" vorangestellt und der Sprung ist komplett berrechnet.
Problem ist aber nur das, wenn ich diesen Sprung (Integer) per "WriteProcessMemory" schreibe dann wird das im Speicher wieder komplett umgekehrt geschrieben.
Jetzt wäre meine Frage an euch ob es eine einfachere Möglichkeit gibt das Ganze zu realisieren? Oder gibt es eine Möglichkeit zu einer Integer Zahl eine weitere Zahl nicht hinzuzuaddieren sondern hinzuzufügen?

Ich hoffe ihr könnt mir folgen und verbleibe vorerst
Mit Freundlichen Grüßen
sILeNt heLLsCrEAm

[Aphton]

Edit: Scheint nicht der Fall zu sein..

[Daniel]

Den "Trainer" selbst hast Du ja im Wesentlichen, Deine Frage dreht sich ja lediglich um Fuddeln im Speicher, der prinzipiell auch Dein eigener Speicherbereich sein könnte.

Allerdings weiß ich nicht, wie genau Du den Unterschied zwischen "addieren" und "hinzufügen" im Zusammenhang mit Integer-Typen definierst?

[Zacherl]

Warum so kompliziert?

1) Wenn es umbedingt Jumps sein müssen, caste beide Adressen (Quelle und Ziel) in einen unsigned Datentyp z.b. DWord und führe dort ganz normal deine Berechnung durch. Dann schreibst du dein 0xE9 gefolgt vom Ergebnis der vorherigen Berechnung. Das "Umdrehen" ist komplett unnötig, da die interne Darstellung der Zahlen schon korrekt ist. Du verfälschst das Ergebnis durch dein Swap. Big Endian und Little Endian sind hier zwei Stichworte für dich, die du dir mal anschauen solltest

2) Verbesserungsvorschlag: Wenn du die Adressberechnung vermeiden willst, kannst du einen kleinen Trick verwenden und mit "PUSH ZielAdresse; RETN;" arbeiten. Wirkt genau wie ein Sprung, ist aber absolut, von daher keine zusätzliche Berechnungen notwendig.

[sirius]

Zitat von Zacherl:

2) Verbesserungsvorschlag: Wenn du die Adressberechnung vermeiden willst, kannst du einen kleinen Trick verwenden und mit "PUSH ZielAdresse; RETN;" arbeiten. Wirkt genau wie ein Sprung, ist aber absolut, von daher keine zusätzliche Berechnungen notwendig.

Es gibt auch einen Absoluten Sprungbefehl, sowie einen absoluten Call-Befehl,

[brechi]

Und der wäre?

Es gibt nen
JMP [ADDRESS]
wobei dann an bei ADDRESS die Sprung-Adresse stehen muss, einen direkten absoluten Jump kenne ich auch nicht.

Schau dir mal meine Collection an:
http://uall.cheat-project.com/uallCollection/

die ist zwar alt, aber da ist auch ein Beispiel mit dem RETN Jump drin. (uallHook.HookCode)

[sILeNt heLLsCrEAm]

Erstmal Dankeschön an euch für eure Antworten. An dieser Stelle werde ich mal allgemein darauf antworten.
In erster Linie folgendes... Ich hatte in verschiedene Richtungen Versuche gestartet. Um an den "ByteSwap" festzuhalten... Mein Versuch war eben die Bytes, bzw. den 4-Byte großen Hex-Wert, umzukehren und dazu den Wert $E900000000 hinzuzuaddieren. So stimmt das Ganze und korrekt berrechnete Sprung ist zur weiteren Verabeitung verfügbar. Problem ist eben allerdings das, wenn man den Integerwert in den Speicher schreibt, aus z.B. $E9 08 15 FF 79 einfach mal $79 FF 15 08 E9 wird.
Deswegen war mein zweiter Versuch eben jenen ByteSwap wegzulassen. Allerdings kann man dann nicht einfach den Wert $E900000000 hinzuaddieren, da wirds ja dann auch wieder Mist. Daraufhin schrieb ich ja hier ob es eine elegante Lösung gibt statt einen Wert hinzuaddieren einfach einen Wert, in diesem Falle Byte hinzuzufügen?
Beispiel (wirklich nur Beispiel)...
Ich habe die korrekte Sprungweite $87 65 43 21. Damit ein korrekter Sprung draus würde muss, um es korrekt in den Speicher zu schreiben ein $E9 nicht hinzuaddiert werden sondern angehangen werden. Also so $87 65 43 21 E9.

Eine Lösung hätte ich ja bereits gehabt. Nämlich zuerst das Byte $E9 schreiben und dann die swapped Sprungweite. Allerdings müsste ich dazu 2x auf die WriteProcess API zurückgreifen was ich eigentlich vermeiden wollte.

Eine Adresse zu Pushen gefolgt von einem Return ist mir durchaus geläufig. Wäre dann auch meine letzte Möglichkeit um alles in einem Rutsch zu schreiben. Sind zwar Kleinigkeiten, aber dadurch werden ja 6 Bytes geschrieben anstatt nur 5.
Aber, um das mal noch etwas weiter zu vertiefen. Ich könnte ebenfalls z.B. schreiben...

Zitat:

mov eax, [adresse]
jump eax

Natürlich muss dabei das Register gesichert und später wiederhergestellt werden. Verbraucht aber alles in allem 9 Bytes die geschrieben werden müssten.

Ich habe jetzt nochmal ne Stunde dran gebaut und wahrscheinlich ist es wohl doch so das man manchmal den Wald vor lauter Bäume nicht sieht. Ich hab mir insofern ne simple ASM Anweisung gestrickt...

Delphi-Quellcode:

function CompleteJMPCalc(const Wert: Int64): Int64;
asm
  mov eax, dword [Wert]
  mov dword [result+1],eax
  mov byte [result], $E9
end;

Da ein Sprung aber nur 5 Bytes hat und ich per API dann auch nur 5 Bytes schreibe werden die letzten 3 Bytes des 8 Byte großen Integer-Wertes abgeschnitten. Also soweit erstmal kein Problem.

Und zum Thema Absoluter Sprungbefehl...
Die "einzigen" Sprünge die ich kenne sind eben die absoluten (explizit handelt sich's dabei nur um JMP) oder bedingten Jumps, wie z.B. JE, JNE usw...


Abschließend dazu möchte ich nochmal zusammenfassen...
Wie ich die Sprünge berrechne und wie diese dann im Speicher zu stehen haben das dass funktioniert ist kein Problem.
Hauptsächlich habe/hatte ich damit ein Problem wie ich die Sprungweiten und das Byte ($E9), laienhaft ausgedrückt - zusammenkriege.
Die oben gennante ASM Lösung ist soweit funktionabel, aber interessehalbe frage ich mal ob es noch eine elegantere Lösung gibt?!


Viele Grüße
sILeNt heLLsCrEAm


Nachtrag:
Wollte mir mal deine UALL Collection anschauen, aber mein Security Tool beruhigt sich ja garnet mehr.
Ich werde mal im Netz nach einem alt. Download googeln. Es sei denn Du hast aus dem stehgreif noch einen da?
Wenn ich mal ganz lieb frag

[brechi]

Ne nur den von cheatproject.

Um direkt 5 Bytes zu schreiben sollte es so gehen:

Delphi-Quellcode:

type
  TJumpRec = packed record
     Jmp: Byte;
     Distance: Cardinal;
  end;

procedure Hook(ToAddress, FromAddress: pointer);
var
  jmpRec: TJmprec;
begin
  jmprec.jmp := $E9;
  jmprec.Distance := Cardinal(ToAddress) - Cardinal(FromAddress) - 5;

  WriteProcessMemory(..., @jmprec, SizeOf(jmprec), ...)

[sirius]

Zitat von brechi:

Und der wäre?

Nicht in ASM, sondern im Intel-Maschinencode. Aber den Müsste ich raussuchen, es war ein zwei-Byte-Befehl.