Hi,

es tut mir wirklich Leid, wenn es dieses Thema schon mal gab oder man durch Googlen sofort die Antwort findet, aber ich weiß nicht wonach ich suchen soll.
Ich habe eine Frage zum Disassemblieren und/oder "Dateiformaten".
Wenn ich eine kleine Assemblerdatei zu *.bin assembliere und diese Date wieder disassemliere kann ich den Code ohne Problem lesen. Mein Problem tritt auf, wenn ich die Datei über eine *.obj zu einer *.exe mache. Nicht nur, dass der Code jetzt recht schwer zu verstehen ist (was eigentlich klar ist), sondern ich kann Variablen nicht mehr zurückverfolgen.
Ich zeig einfach mal meinen Code:

Meine *.asm

Code asm:

1 2 3 4 5

mov ax, a mov al, 01h int 16h   a db "a"

Das Ergebnis der disassemblierten *.bin

Code asm:

1 2 3 4

00000000  B80700            mov ax,0x7 00000003  B001              mov al,0x1 00000005  CD16              int 0x16 00000007  61                popaw

was ja immer noch zu lesen und verstehen ist.
Wenn ich den Code richtig verstehe wird in der ersten Zeile einfach nur das geladen, was an der Position (?) 00000007 steht.
Jetzt meine erste Frage: Wie kann der Computer entscheiden ob das, was bei 00000007 steht oder 0x7 in das Register geschrieben werden soll?
Ich bin begeistert, wenn jmd. noch bis hier gelesen hat.
OK, weiter.

Das Ergebnis der disassemblierten *.exe

Code asm:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

00000000  4D                dec bp 00000001  5A                pop dx 00000002  48                dec ax 00000003  0001              add [bx+di],al 00000005  0000              add [bx+si],al 00000007  0004              add [si],al 00000009  0000              add [bx+si],al 0000000B  00FF              add bh,bh 0000000D  FF00              inc word [bx+si] 0000000F  0000              add [bx+si],al 00000011  0000              add [bx+si],al 00000013  0000              add [bx+si],al 00000015  0000              add [bx+si],al 00000017  004000            add [bx+si+0x0],al 0000001A  0000              add [bx+si],al 0000001C  0000              add [bx+si],al 0000001E  0000              add [bx+si],al 00000020  0000              add [bx+si],al 00000022  0000              add [bx+si],al 00000024  0000              add [bx+si],al 00000026  0000              add [bx+si],al 00000028  0000              add [bx+si],al 0000002A  0000              add [bx+si],al 0000002C  0000              add [bx+si],al 0000002E  0000              add [bx+si],al 00000030  0000              add [bx+si],al 00000032  0000              add [bx+si],al 00000034  0000              add [bx+si],al 00000036  0000              add [bx+si],al 00000038  0000              add [bx+si],al 0000003A  0000              add [bx+si],al 0000003C  0000              add [bx+si],al 0000003E  0000              add [bx+si],al 00000040  B80700            mov ax,0x7 00000043  B001              mov al,0x1 00000045  CD16              int 0x16 00000047  61                popaw

Jetzt kann ich erkennen, dass wohl nur die letzten vier Zeile wichtig sind. Aber ich kann jetzt nicht mehr zurückverfolgen, was an der Position 00000007 steht, denn "popaw" steht jetzt bei 00000047.
Meine zweite Frage: Gibt es eine Möglichkeit entweder *.exe in *.bin umwandeln oder herauszufinden, was die Position 00000007 ist?

OK, ich hoffe, das ist jetzt nicht zu viel.
Vielen Dank für eure Hilfe!

EDIT:
Falls irgendjemand langweilig sein sollte, kann der mir ja vielleicht erklären, was es mit dem Rest des disassemblierten *.exe Codes auf sich hat.

es ist lange her das ich mich mit assembler beschaeftigt habe, also keine garantie auf korrekte infos

was mir seltsam vorkommt:
du laedst register ax, ein wort register mit einer byte variablen...
mov ax, a (wort)
a db "a" (byte)

auch dass die definition von "a" unterhalb der verwendung steht... hmm, noergelt da nicht der assembler rum?

das > 00000000 B80700 mov ax,0x7
laedt ax mit einer konstanten (0x7 - woher die 0x7 ist mir noch nicht ganz klar, scheinbar aber nicht mit deiner variablen "a"

die steht hier > 00000007 61 popaw (der ascii hex code fuer "a" ist 0x61)

mehr kann ich derzeit leider auch nicht sagen

Hi,

dass ich ein Byte in ein Word lade, kam mir auch komisch vor.
Ich muss es aber sogar, wenn ich in eine *.obj Datei assemblieren will.
Bei binärem Format ist das dem Compiler egal.
Ich arbeite mit NASM, vielleicht ist das der Grund für die seltsame Syntax.
Das mit der 61 ist mir auch schon aufgefallen, hilft mir aber auch nicht wirklich weiter, weil ich eh weiß, dass popaw a bedeutet.

Schonmal danke für deine Hilfe!

Hi.

Zitat von üäpöol

Mein Problem tritt auf, wenn ich die Datei über eine *.obj zu einer *.exe mache. Nicht nur, dass der Code jetzt recht schwer zu verstehen ist (was eigentlich klar ist), sondern ich kann Variablen nicht mehr zurückverfolgen.

Das ist klar. Es gibt keine Variablen in Maschinencode.

Die 7 bei "mov ax, 7" ist einfach die Adresse des Datums "a" ausgehend vom data Segment addressiert.

Schau dir mal IDA Pro an, das bietet eine sehr gute Analyse von Maschinencode.

Gruß

Hm... Das beantwortet zwar meine Frage noch nicht , aber ich denke ich schau mir ma IDA Pro an.

Zitat von üäpöol

Hm... Das beantwortet zwar meine Frage noch nicht

Der Computer entscheidet da gar nichts. Ein mov Befehl hat immer die gleiche Semantik.

Oder welche Frage meintest du jetzt?

Gruß

Ich rede eigentlich von der ersten Frage.

Zitat von üäpöol

Ich rede eigentlich von der ersten Frage.

Also die hier:

Zitat von üäpöol

Wie kann der Computer entscheiden ob das, was bei 00000007 steht oder 0x7 in das Register geschrieben werden soll?

Genau diese Frage habe ich doch damit beantwortet.

Gruß

Dann habe ich mich entweder zu unpräzise ausgedrückt oder die Antwort nicht verstanden:
Nochmal die Frage anders gestellt:
In diesem Fall möchte ich die Zahl 7 in das ax Register stecken.

Code asm:

1 2 3 4 5

mov ax, 7 mov al, 01h int 16h   a db "a"

In diesem Fall möchte ich die Variable a in das ax Register tun.

Code asm:

1 2 3 4 5

mov ax, a mov al, 01h int 16h   a db "a"

Das Ergebnis des Disassemblierens ist in beiden Fällen

Code asm:

1 2 3 4

00000000  B80700            mov ax,0x7 00000003  B001              mov al,0x1 00000005  CD16              int 0x16 00000007  61                popaw

Wie kann ich die beiden Fälle unterscheiden (wie macht das der Computer)?
Ich hoffe, die Frage ist jetzt ein bisschen präziser.

Zitat von üäpöol

Dann habe ich mich entweder zu unpräzise ausgedrückt oder die Antwort nicht verstanden:

Letzteres.

Zitat von üäpöol

Wie kann ich die beiden Fälle unterscheiden (wie macht das der Computer)?

Es gibt keinen Unterschied. "mov ax, 7" bewirkt immer, dass in AX der Wert 7 drin steht.

Entscheidend ist, wie der Wert in AX interpretiert wird.

Gruß

Wenn ich das richtig verstanden habe, muss es einen Unterschied zwischen dem Maschinencode und der disassemblierten Datei geben, weil der Computer sonst nicht wüsste ob 7, oder das was an der Adresse 7 steht, in das Register soll, oder?

es gibt in ASM keine richtigen Varriablen. Du lädst die Offset der Speicherstelle in AX. Den inhalt musst du mit hilfe eines Pointers laden. Das Prinzip nochmal aufgedröselt:

Code :

1 2	varriable db 0 mov ax,varriable

Der Name "varriable" ist nur ein Label welches vom Assembler in eine Adresse (im Realmode Offset da segment:offset) umwandelt. In ASM gibt es keine Varriablen nur Speicherstellen und Register. Wenn du den inhalt der speicherstelle "Varriable" in AX verschieben möchtest geht das so:

Code :

1 2	varriable db 'a' mov ax,[varriable]

Jetzt ist ax='a'
vorhin beinhaltete AX eine adresse.
Zu dem >Rest aus der exe datei: Exe ist vom Aufbau sehr viel Komplexer als ein einfaches Binäres Format. Windows hat ein tool um exe in Binärdateien zu convertieren (exe2bin).
Diese bringt dir jedoch nix da du in deinem System (wenn ich das richtig verstanden habe ) a: noch im realmode bist und die Aktuell gängigen Windows Aplikationen 32bit code enthalten
b: Du in deinem OS die Windows API nicht implementiert hast.

Wenn du Infos zu OSdev oder ASM haben willst kannst dich auch dierekt bei mir per PM melden
LG
Linux best Friend

OK, jetzt fang ich an es zu verstehen.
Dann hätte sich die Sache vorläufig erledigt.

Vielen Dank an Linuxfriend!