[asm]JMP bei Delphi-Inline-Assemlber

[himitsu]

Zitat von Flocke:

Der Opcode für einen direkten unbedingten Sprung ist $E9

nö, dat is der Opcode für einen direkten short jump oder wie dat nochmal hieß.
Also einen sozusagen ein relativer Sprung, von der Stelle aus, wo er steht.

Den Opcode für einen absoluten Sprung hab ich auch gerade nicht im Kopf ... könnte höchstens mal heut abend nachseh ^^

Zitat von SirThornberry:

Desweiteren bin ich davon ausgegangen das "ptr" angibt das es sich um einen Pointer handelt.

im Grunde gibt das PTR (Pointer) ja auch an, daß es sich um einen solchen handelt, aber dieses muß nicht immer angegeben werden, wenn klar ist, worum es sich handelt.

Es ist so ähnlich wie mit Flocke's Code...

Delphi-Quellcode:

mov eax, $11223344
jmp eax

so ginge es ja auch

Delphi-Quellcode:

mov eax, dword $11223344
jmp eax

da [] eh auf 'nen Pointer hinweißt, ist es also nicht nötig ... genauso wie das dword, da im Win32 doch eh alles erstmal als LongInt/LongWord/32-Bit-Pointer angesehn wird.

Delphi-Quellcode:

// das ist also dat "Selbe"
mov eax, dword ptr [$11223344]
mov eax, ptr [$11223344]
mov eax, [$11223344]

// wohingegen das mal was Anderes ist ^^
mov eax, byte ptr [$11223344]

Zitat von SirThornberry:

@Flocke: Bei E9 wird die Differenz angegeben? Das heißt man nimmt keinen "dword" mehr sondern einen Integer? Ist dabei sichergestellt das der Wertebereich des Integers auch groß genug ist?

Na ja, es gibt verschiedene Varianten ... also mit auch solche mitr ShortInt und SmallInt.
Ist praktischer, weil die ja weniger Speicher verbrauchen, man kann damit allerdings nicht so weit springen ... was aber och klar sein sollte ^^

Zitat von SirThornberry:

Ich bin in asm nicht so bewandert. Delphi hat immer rumgemeckert wenn ich die "[]" vergessen hab.

Wie gesagt ... syntaktisch würde es stimmen, aber wie Nico schon sagte will der Delphi-ASM sowas nicht.
Also ich kann höchstens dann nochmal nachgucken was der richtig Opcode hierfür wäre oder du nimmst den indirekten Weg


Aber was ich mich bisher immer grfragt hab ... woher will eigentlich Windows wissen was ein Pointer ist und ob der eventuell gefixt werden muß?
Weil oftmals ist es ja nicht gerade eindeutig, was einer ist, oder ob der schon gefixt wurde.

z.B.
JMP EAX Windows kann doch shcließlich nicht wissen was das für ein Wert in EAX ist

[SirThornberry]

über das Fixen von Windows hab ich mir bisher gar keine Gedanken gemacht. Aber so wie du das schreibst würds mich auch interessieren woher windows weiß was gefixt werden muss und was nicht. Wobei Windows das früh oder Später ja ausführt und von daher schon wissen sollte was durch die Befehle passiert.

[himitsu]

aso

Zitat von SirThornberry:

benötigt hab ich das ganze für folgendes:
http://www.delphipraxis.net/internal...=573675#573675

OK, an dieser Stelle wäre natürlich der direkte Sprung nicht schlecht ^^
Obwohl du dort natürlich auch relativ springen könntest

Code:

JMP (neueFunktion - aktuellePosition)

also in etwa:

Delphi-Quellcode:

lBuffer  : Array[0..4] of Byte; 
...
PByte(@lBuffer)^ := $e9; 
PCardinal(@lBuffer[1])^ := Cardinal(ANewFunction) - Cardinal(AOldFunction);

PS: wenn du es schon so aufschlüsselt, dann wäre es so wohl "richtiger"
lBuffer : Array[0..(2 + 4 + 4) - 1] of Byte;

[himitsu]

[ä bissl OT]

Zitat von SirThornberry:

Wobei Windows das früh oder Später ja ausführt und von daher schon wissen sollte was durch die Befehle passiert.

gerade da ligt ja z.B. eines der Probleme ... es kann es eben nicht wissen.
wenn ich z.B. irgendwo im Quellcode einer Variable einen hardcodierten Wert übergeben, welcher z.B. die Position einer Funktion ist,
Variable := @Funktion; (wenn funktion eine eigene Funktion im eigenem Programm ist, dann wird der Wert ja vom Compiler hardgecodet)

dort vielleicht noch ein bissl rumrechne
Variable := Variable + irgendwas; und dann wohinspringen will,
JMP &Variable dann muß hier gefixt werden, wenn die der Programmcode nicht an seiner vorgesehenen Position ist.

Wenn ich das ganze aber mit aktuellen Werten aus dem laufenden Programm mache, dann sind die Positionen ja schon gefixt (da dort die verwendete Funktion schließlich bereits verschoben wurde) und müssen demnach ja nichtmehr gefixt werden. o.O

[SirThornberry]

@Himitus: das "JMP &Variable" muss eignetlich nicht gefixt werden da der Inhalt der Variablen bereits vorher gefixt wird. Der Inhalt von "Variable" ergibt sich ja aus anderen Adressen und diese sind bereits gefixt.

[brechi]

es gibt keinen assembler befehl für einen 'absoluten' jump so wie du ihn suchst.

entweder

Delphi-Quellcode:

mov eax, addr
jmp eax

oder

Delphi-Quellcode:

push addr
ret

nehmen oder den Umweg über eine globale/lokale variable machem.

jmp [variable] und 0xE9 ist kein relative short distance jump, das wäre 0xEB

und wenn du die einen relativen jump brauchst, die berechnung wäre zieladresse-vonadresse-5

[Boombuler]

PS: http://faydoc.tripod.com/cpu/jmp.htm
Merke: Der Link ist natürlich nur für x86

Wenn ich das nu Spontan Richtig sehe wäre also ein FF ein direkter Jump auf die Addy!

(Nich hauen wenns falsch ist )

Greetz
Boombuler

[SirThornberry]

ich habs jetzt erstmal mit dem ablegen auf dem Stack, und dann mit "ret" zur Adresse "zurück" springen gemacht. Das spaart im Gegensatz zu meiner Ursprünglichen Variante schon ganze 4 Byte.
Den Link werd ich mir gleich mit ansehen.

[Edit]
Ein reines FF reicht nicht aus. Und sobald 1 Byte mehr dazu kommt bin ich wieder bei der gleichen Anzahl wie bei der Variante mit push + ret

Die Variante mit push + ret sieht so aus
$68$33$22$11$00
$C3
[/Edit]

[himitsu]

Variable := @Funktion; entspricht
MOV &Variable, $00123456 hier kann nichts von windows gefixt werden, denn für Windows ist es nur eine "normale" Zahl, welche in irgendeinen peicherbereich kopiert wird ... und da es nicht wissen kann, daß es eigentlich ein Pointer ist, kann es dort definitiv nicht fixen und später fixen ginge och nicht, da dort Windows eigentlich nicht wissen kann, ob gefixt werden muß, oder nicht, da es ja nicht weiß was für ein Wert in der Variable drinsteht, also ob das schon ein gefixter ist, oder eben noch ein ungefixter (aus 'nem hardgecodeten Pointer).

denn wenn ich sowas mache, dann würde ja ein "gefixter" Wert in die Variable geschrieben, da ja die Adresse der bereits verschobenen Prozedur zurückgegeben wird.
Variable := GetProcAddr('irgendwas'); also liebe als letztes nur noch der Jump-Befehl, wo windows fixen könnte, aber da es ja nicht weiß was in Variable für ein Wert ist ... woher soll es denn dann wissen, was es machen soll?
JMP &Variable

[brechi]

Variable := @Funktion; in dem Fall weiß der Compiler, dass er einen Eintrag in die Relocation Table packen muss

MOV &Variable, $00123456 in dem Fall nicht. Wer auch immer nu Recht hat, wollte das nur noch mal sagen.