4. Wie kann ich eine .exe Datei in Maschinensprache betrachten ?

Wie kann ich eine .exe Datei in Maschinensprache betrachten ?

  • B

    Ich glaube der .exe debugger Befehl heißt debug.
    Damit kannst du auch assembler programmieren.
    .exe ist komplizierter aber .com fängt bei 100 an.

    0
  • ?

    OllyDebugger, Immunity Debugger, IDA Pro, Soft ICE

    Nimm einfach den Immunity Debugger.
    - Ist Kostenlos
    - Hat von Haus aus das Graph Plugin
    - Hat von Haus aus colored Syntax
    - Ist einfacher zu bedienen als IDA Pro (IDA Pro hat auch alles diesen kram ich glaub die kostenlose Version hat auch diesen Graph View kram (Ist ganz praktisch)

    0
  • N

    Ich würde vorschlagen, erstmal die intergrierten Werkzeuge vom Visual Studio zu nutzen, Debugger, Disassembler, Profiler usw.
    Wenn man mehr sehen will, also den ganzen Execode inclusive Header und mitgeschleppte Bibliothek usw., dann muss man sich einen Hexeditor zu Anschauen schreiben.

    In Windows xp steht das Windowsinterne(bis 32 Bit) Systemwerkzeug "debug" zur Verfügung. Debug ist eine Assemblerentwicklungsumgebung(mit Assembler) für 16 Bit, aber der Hexcode bleibt ja der gleiche, kann man also für Hexediting und Assemblerlernen mißbrauchen(und man kann auch kleine 64/256 Bit Programme mit Debug schreiben bzw. 128 Bit SSE programme für 32Bit). Aber es gibt auch einen sehr guten Debug-Clone für 32 Bit von Paul Vojta
    http://math.berkeley.edu/~vojta/
    den hatte er für das OS Free Dos geschrieben.

    Versuch aber erstmal zu gucken, wie weit du mit den VS Tools kommst, und schreib den Hexeditor selber.

    0
  • ?

    nachtfeuer schrieb:

    (bis 32 Bit) Systemwerkzeug "debug" zur Verfügung. Debug ist eine Assemblerentwicklungsumgebung(mit Assembler) für 16 Bit, aber der Hexcode bleibt ja der gleiche, kann man also für Hexediting und Assemblerlernen mißbrauchen(und man kann auch kleine 64/256 Bit Programme mit Debug schreiben bzw. 128 Bit SSE programme für 32Bit).

    Da hast du wohl mal wieder einen Troll-Anfall erlitten 🙄

    0
  • E

    Tail11Gunner schrieb:

    Hi, bin noch ziemlicher Anfänger...

    nachtfeuer schrieb:

    ... und schreib den Hexeditor selber.

    Das ist ja mal ein suuuper Tip für einen Anfänger.

    0
  • N

    masm schrieb:

    nachtfeuer schrieb:

    (bis 32 Bit) Systemwerkzeug "debug" zur Verfügung. Debug ist eine Assemblerentwicklungsumgebung(mit Assembler) für 16 Bit, aber der Hexcode bleibt ja der gleiche, kann man also für Hexediting und Assemblerlernen mißbrauchen(und man kann auch kleine 64/256 Bit Programme mit Debug schreiben bzw. 128 Bit SSE programme für 32Bit).

    Da hast du wohl mal wieder einen Troll-Anfall erlitten 🙄

    Nein, jetzt habe eher ich einen Lachanfall erlitten. Geht deine panische Angst vor Dos/16 Bit nicht ein bißchen weit, wenn sie schon anfängt, die Wahrnehmung oder das Assembler Grundwissen zu verzerren?

    @EOP
    Ein Hexeditor setzt sich aus mehreren einfachen Elementen zusammen, die zum Grundwissen der Programmierung gehören. Der Hexeditor ist schnell geschrieben und darüberhinaus recht nützlich, also eine sehr praktische (begleitende) Anfängeraufgabe.

    0
  • ?

    nachtfeuer schrieb:

    Nein, jetzt habe eher ich einen Lachanfall erlitten. Geht deine panische Angst vor Dos/16 Bit nicht ein bißchen weit, wenn sie schon anfängt, die Wahrnehmung oder das Assembler Grundwissen zu verzerren?

    - "Debug ist eine Assemblerentwicklungsumgebung" 😮
    - "[...]256 Bit Programme mit Debug schreiben bzw. 128 Bit SSE programme[...]" 😕

    0
  • N

    Dass man daraus so ein Theater machen muss, wirkt merkwürdig. Willst du vorgeben, du wüßtest nicht, wie das geht? Oder weiß du es nicht besser? Mal angenommen, du weißt es nicht besser, könnte sein, dann könnte man in etwa so anfangen:

    C:\Users\nachtfeuer>debug
-a
1A04:0100 dw 0
1A04:0102 dw 0
1A04:0104 db 0
1A04:0105 mov ax,1
1A04:0108 dw 0
1A04:010A mov bx,200
1A04:010D dw 0
1A04:010F mov cx,16
1A04:0112 dw 0
1A04:0114 db "hallo",24
1A04:011A
-d 100
1A04:0100  00 00 00 00 00 B8 01 00-00 00 BB 00 02 00 00 B9   ................
1A04:0110  16 00 00 00 68 61 6C 6C-6F 24 00 00 34 00 F3 19   ....hallo$..4...
1A04:0120  00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00   ................
1A04:0130  00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00   ................
1A04:0140  00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00   ................
1A04:0150  00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00   ................
1A04:0160  00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00   ................
1A04:0170  00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00   ................
-

    Man kann dann z.B., um Daten zu füllen, statt Assemblerdirektiven direkt Assemblerbefehle benutzen. Und wie oben gezeigt, kann man Platzhalter für Maschinenbefehle wie movdqa xmm0,[Word](z.B. = 0F6F061401) benutzen. Man muß allerdings darauf achten, die Operandengrößen-Präfixe richtig zu setzen.

    0
  • ?

    Fassen wir doch mal Zusammen: Debug ist keine Entwicklungsumgebung (wie der Name schon impliziert) und man kann damit weder 32 noch 64 Bit Programme schreiben, geschweigen den das man damit irgendwelche SIMD Befehlsätze benutzen kann.
    Es ist lächerlich beim eingeben beim opcodes von Programmieren zu reden!
    Und ganz neben bei, debug.exe war und ist ganz sich kein Windows-internes Systemwerkzeug - es ist ein Überbleibsel aus DOS Zeiten.

    👎

    0
  • N

    Lächerlich ist allenfalls zu sehen wie du versuchst, anderen Leuten einzureden, was geht, und was nicht. Lächerlich sind die Versuche, Grundlagen Know How zu negieren. Es kommt der Verdacht auf, das geschieht nur um entweder A: Von gewissen Wissenslücken abzulenken, oder B: um lediglich herumzuprollen oder zu trollen.

    Und du brauchst hier auch gar nicht groß mit Smilies und Emoticons um dich werfen, um zu versuchen, (in Richtung Offtopic) Stimmung zu machen. Letztlich vermute ich mal, du hast gar keine andere Zielsetzung. Und das nennt man, glaube ich, trollen.

    0
  • N

    Bleibt mal friedlich Jungs... 😃

    ...
    dennoch muss ich hier masm ausnahmsweise zustimmen: debug ist ein olles DOS-Relikt, das man nach landlaeufiger Definition nicht ernsthaft als "Entwicklungsumgebung" bezeichnen kann und bestenfalls die gleiche "Unterstuetzung" fuer auch nur annaehernd als aktuell zu betrachtende Befehlssaetze des x86 bietet wie jeder 0815-Hexeditor auch.

    ...Wie hing das nun noch gleich mit der Ursprungsfrage zusammen? Nur marginal... Da die "Diskussion" ohnehin keinen Wert hat, denke ich, die Sache ist damit erledigt.

    0
  • N

    Letztlich ist das eine Meinung. masm dabei zu bestärken, unsachlich und offtopic herumzuprollen, ist nicht gerade der Sinn eines Forenmoderators.
    Wenn man anfängt mit dem Programmieren, braucht man Editor + Compiler, eventuell einen Debugger und einen Disassembler oder einen Linker. Debug hat Asminterpreter, Asmeditor, Compiler, (Linker...?)Debugger, Disassembler, Assembler zum Speicherfüllen, Rip-Mode 😉 und einiges mehr, und man kann Programme und Assembleralgorithmen damit entwickeln. Und debug ist nun mal bei allen Windowsversionen bis 32 Bit mit an Board.
    Ob oll oder nicht, das spielt hier tatsächlich keine Rolle.

    0
  • N

    Wer hier trollt ist Ansichtssache (im Zweifel erstmal meine Ansicht 😉 ) und was hier der Sinn eines Moderators ist, lass mal meine Sorge sein. Weitere Diskussion ab vom Thema werde ich ab jetzt kommentarlos entfernen.

    0
  • N

    Du Scherzkeks.
    Eigentlich wurde die Frage des TEs schon ausreichend bis üppig beantwortet. Man könnte den Thread also schließen und ab {unsachlich offtopic} alle Postings löschen. Nun, und wäre ich Moderator und hätte die Einstellung, dass Dos alter vergammelter Quark ist und debug eine miese müffelnde Mumie, nun, dann wüßte ich schon, welchen Beitrag ich noch..., so ganz versehentlich... Huch!? 😉

    0
  • V

    Tail11Gunner schrieb:

    bin noch ziemlicher Anfänger würde gerne wissen wie das aussieht was mein Compiler erzeugt.

    Tail11Gunner schrieb:

    MS Visual c++ 10
    Win xp

    Dazu mach Folgendes:
    Geh mit dem Cursor auf die interessante Stelle.

    Drück Strg+F10.
    Das compiliert und bindet bei Bedarf Dein Programm, setzt auf der Cursorposition einen Breakpoint, startet den Debugger, startet darin Dein Programm, und wenn das Programm endlich auf den Breakpoint läuft, wird es angehalten und der Breakpoint automatisch entfernt.

    Drück Alt+F8.
    Das zeigt im Debugger den Assemblercode an, der zu Deinem Sourcecode gehört.

    Das sieht dann ungefähr so aus:
    http://img830.imageshack.us/img830/654/asmx.png
    Also immer die C++-Zeile und drunter der daraus entstandene (und disassemblierte) Maschinencode. Hier (im Debugmodus) haut er gerne Variablen in den Speicher. Viel Aussagekraft hat das dann nicht, wenn man abschätzen mag, wie schnell sich was anfühlt.

    Manchmal wird die Zuordnung von C++ zu Maschinencode ein wenig durcheinandergewürfelt, weil der Compiler Optimierungen macht. Das ist normal, anfangs verwirrend, und kein Bug.

    Im Release-Modus wird übrigens das hier draus:
    http://img846.imageshack.us/img846/1121/asm2.png

    Wie man sieht, liegt i in EAX.

    xor ecx,ecx setzt ECX auf 0. ECX ist also s.

    Außerdem hat der Optimierer die Schleife vierfach entrollt.
    Also

    int s=0;
for(int i=0;i<=100;i+=4){
   s+=i;
   s+=i+1;
   s+=i+2;
   s+=i+3;
}

    draus gemacht. Schlauer Compiler.

    Das nop dient dazu, daß das Spungziel auf einer gut ausgerichteten Adresse liegt. Das könnte den Sprung beschleunigen. Netter Compiler.

    Im Prinzip schau immer nur den Release-Code an.

    Zum Vergleich: gcc macht frecherweise das da draus:
    (Achtung, AT&T-Syntax: mov und Konsorten tragen einen Postfix, der den Typ angibt, "movl" heißt "move long", außerdem sind bei zwei Parametern die Parameter vertauscht)

    movl	$5050, %esi
	movl	$_ZSt4cout, %edi
	call	_ZNSolsEi
    0
  • A

    volkard schrieb:

    Zum Vergleich: gcc macht frecherweise das da draus:
    (Achtung, AT&T-Syntax: mov und Konsorten tragen einen Postfix, der den Typ angibt, "movl" heißt "move long", außerdem sind bei zwei Parametern die Parameter vertauscht)

    movl	$5050, %esi
	movl	$_ZSt4cout, %edi
	call	_ZNSolsEi

    Die komischen Zeichen "$_ZSt4cout" und "_ZNSolsEi" lassen sich mit dem Tool c++filt "filtern". Interessanterweise, ich bin grade unter Windows und nutze mingw 3.4.5, musste ich zwei Unterstriche setzen, damit c++filt lesbare Strings liefert:
    D.h. aus diesem Code:

    movl	$5050, %esi
	movl	$__ZSt4cout, %edi
	call	__ZNSolsEi

    wird mit c++filt das hier:

    movl    $5050, %esi 
     movl    std::cout, %edi 
     call    std::basic_ostream<char, std::char_traits<char> >::operator<<(int)

    und das ist in C++ so was hier:

    cout << 5050;
    0
  • A

    volkard schrieb:

    int s=0;
for(int i=0;i<=100;i+=4){
   s+=i;
   s+=i+1;
   s+=i+2;
   s+=i+3;
}

    Darf ich fragen, warum Du keine Leerzeichen benutzt 😕 Wenn keine Leerzeichen und so einfache Schleife, warum dann nicht gleich so:

    int s=0;
for(int i=0;i<=100;s+=i,s+=i+1,+=i+2,s+=i+3,i+=4);

    man hat damit dem Compiler einen ganzen Block mit Leerzeichen gespart... und - damit es noch mehr hackermäßig aussieht - gleich das hier einbauen für gcc:

    int s=0;
for(int i=0;__builtin_expect(i<=100,true);s+=i,s+=i+1,+=i+2,s+=i+3,i+=4);

    🙄

    0
  • V

    abc.w schrieb:

    Darf ich fragen, warum Du keine Leerzeichen benutzt 😕

    Weil es ohne Leerzeichen besser lesbar ist. Dafür benutze ich große Schriftarten.

    0
  • N

    Vielleicht noch als Ergänzung zu dem, was volkard schreibt:

    normalerweise ist eine for Schleife in asm etwa so:

    01 mov cx,100 ;CX = Cindy = zählgeile Tochter vom Graf Zahl
02 mach was...
03 loop 02    ;Cindy zählt jetzt voller Vergnügen von 100 rückwärts (kann das auch einer in Hex? ;)

    oder, falls der Anfangswert nicht 0, ...

    mov cx,upper ;oder mov rcx,var1
sub cx,lower ;oder sub rcx,var2,
mov bx,step  ;oder mov rbx,step
...
040 cmp cx,0      ;oder or rcx,rcx bzw. ist für Cindy das Zählvergnügen vorbei?
041 jz irgendwohin wo es schöner ist; und das ist natürlich für Cindy genau da, wo es noch mehr zu zählen gibt...
042 mach was
043 sub cx, bx    ;oder sub rcx,rbx;
044 jmp 040

    oder man benutzt z.B. einen Stringbefehl mit "rep" davor um Speichergedöns von DS:Esi nach ES:Edi zu kopieren, wobei die beiden Indexregister automatisch hoch bzw. heruntergezählt werden. Die Richtung selbst (also hoch oder runterzählen) kann man im Richtungsflag festlegen.

    Eine Schleife wie

    int s=0;
for(int i=0;i<=100;i+=4){
   s+=i;
   s+=i+1;
   s+=i+2;
   s+=i+3;
}

    könnt man auch übersetzten in Standardregister AX + Indexregister, also z.B. BX:

    mov cx 100 ;Zählen
mov bx,0   ;schrittweise
mov si,0   ;falls man jemanden zum Mitzählen braucht, dann inc si oder add si,1 oder mov ax,si, inc si usw. z.B.  
;und da sich die Schrittweise vergrößert, brauchen wir das auch noch also sowas wie
lea bx,[bx+4] ;bx=bx + 4...erinnert mich an irgendwas...
...;siehe oben bzw. weiter unten ;)
1 mov ax,bx
2 add ax,1
3 inc ax
4 lea ax,[ax+1]

    Und um komplexere Indexerei zu veranstalten, kann man zum Beispiel sowas wie
    add ebx,[edi + esi + c] oder add ebx,[edi+esi*8+2] und solcherlei Befehle nutzen.

    Ein besonderer Befehl ist Lea, siehe hierzu auch
    http://www.df.lth.se/~john_e/gems/gem0009.html

    normalerweise reicht ein mov bx,200 - aber lea kann auch rechnen und macht das sogar recht schnell oder kann dadurch mehrere Befehle zusammenfassen.

    Und das schon genannte Debugx von Paul Vojta zeigt eigentlich ganz gut, wie der Lea-Befehl im einzelnen funktioniert

    -rn                        ;fpu register anzeigen
CW=037F SW=0000 TW=FFFF OPC=0000 IP=00000000 DP=00000000
ST0=empty                 ST1=empty
ST2=empty                 ST3=empty
ST4=empty                 ST5=empty
ST6=empty                 ST7=empty
-rm                        ;mmx register anzeigen
MM0=00 00-00 00-00 00-00 00  MM1=00 00-00 00-00 00-00 00
MM2=00 00-00 00-00 00-00 00  MM3=00 00-00 00-00 00-00 00
MM4=00 00-00 00-00 00-00 00  MM5=00 00-00 00-00 00-00 00
MM6=00 00-00 00-00 00-00 00  MM7=00 00-00 00-00 00-00 00
-rx                          ;auf 32 Bit Register umschalten
386 regs on
-r                           ;Register + Flags + Addi + Opcode angucken
EAX=00000000 EBX=00000000 ECX=00000000 EDX=00000000 ESP=0000FFFE EBP=00000000
ESI=00000000 EDI=00000000 EIP=00000100 EFL=000B0286 NV UP EI NG NZ NA PE NC
DS=1B22 ES=1B22 SS=1B22 CS=1B22 FS=0000 GS=0000
1B22:0100 C3                RET
-a                           ;assemblerbefehle eingeben
1B22:0100 mov eax,fffffffe
1B22:0106 sub eax,1
1B22:010A lea eax,[eax+1]
1B22:010F add eax,1
1B22:0113 mov esi,4
1B22:0119 add eax,esi
1B22:011C lea eax,[esi+esi*4]
1B22:0121
-t                           ;schrittweise testen bzw. angucken, was vor sich geht
EAX=FFFFFFFE EBX=00000000 ECX=00000000 EDX=00000000 ESP=0000FFFE EBP=00000000
ESI=00000000 EDI=00000000 EIP=00000106 EFL=00033286 NV UP EI NG NZ NA PE NC
DS=1B22 ES=1B22 SS=1B22 CS=1B22 FS=0000 GS=0000
1B22:0106 6683E801          SUB     EAX,+01
-t
EAX=FFFFFFFD EBX=00000000 ECX=00000000 EDX=00000000 ESP=0000FFFE EBP=00000000
ESI=00000000 EDI=00000000 EIP=0000010A EFL=00033282 NV UP EI NG NZ NA PO NC
DS=1B22 ES=1B22 SS=1B22 CS=1B22 FS=0000 GS=0000
1B22:010A 67668D4001        LEA     EAX,01[EAX]
-t
EAX=FFFFFFFE EBX=00000000 ECX=00000000 EDX=00000000 ESP=0000FFFE EBP=00000000
ESI=00000000 EDI=00000000 EIP=0000010F EFL=00033282 NV UP EI NG NZ NA PO NC
DS=1B22 ES=1B22 SS=1B22 CS=1B22 FS=0000 GS=0000
1B22:010F 6683C001          ADD     EAX,+01
-t
EAX=FFFFFFFF EBX=00000000 ECX=00000000 EDX=00000000 ESP=0000FFFE EBP=00000000
ESI=00000000 EDI=00000000 EIP=00000113 EFL=00033286 NV UP EI NG NZ NA PE NC
DS=1B22 ES=1B22 SS=1B22 CS=1B22 FS=0000 GS=0000
1B22:0113 66BE04000000      MOV     ESI,00000004
-t
EAX=FFFFFFFF EBX=00000000 ECX=00000000 EDX=00000000 ESP=0000FFFE EBP=00000000
ESI=00000004 EDI=00000000 EIP=00000119 EFL=00033286 NV UP EI NG NZ NA PE NC
DS=1B22 ES=1B22 SS=1B22 CS=1B22 FS=0000 GS=0000
1B22:0119 6601F0            ADD     EAX,ESI
-t
EAX=00000003 EBX=00000000 ECX=00000000 EDX=00000000 ESP=0000FFFE EBP=00000000
ESI=00000004 EDI=00000000 EIP=0000011C EFL=00033217 NV UP EI PL NZ AC PE CY
DS=1B22 ES=1B22 SS=1B22 CS=1B22 FS=0000 GS=0000
1B22:011C 67668D04B6        LEA     EAX,[ESI][ESI*4]
-t
EAX=00000014 EBX=00000000 ECX=00000000 EDX=00000000 ESP=0000FFFE EBP=00000000
ESI=00000004 EDI=00000000 EIP=00000121 EFL=00033217 NV UP EI PL NZ AC PE CY
DS=1B22 ES=1B22 SS=1B22 CS=1B22 FS=0000 GS=0000
1B22:0121 0000              ADD     [BX+SI],AL                       DS:0004=00
-

    Der letzte Wert in eax weist darauf hin, dass man beim lea Befehl nicht genau weiß, ob er nur rechnet, oder befehle gruppiert oder tatsächlich eine Adresse läd. Meistens kann mans schon sehen, wie hier, im Debugbeispiel aber eben nicht immer sofort, man braucht ein wenig Übung damit.

    0
  • ?

    masm schrieb:

    Fassen wir doch mal Zusammen: Debug ist keine Entwicklungsumgebung (wie der Name schon impliziert) und man kann damit weder 32 noch 64 Bit Programme schreiben, geschweigen den das man damit irgendwelche SIMD Befehlsätze benutzen kann.

    Vergleichsweise wie es auch möglich ist von einer Batchdatei, oder einem Shellscript heraus Dateien zu erzeugen in denen ein x86-Operationscode enthalten ist, kann mit debug sogar beliebiger Opoerationscode erzeugt und dann ggf. ausgeführt, oder als Datei gespeichert werden.

    Es ist lächerlich beim eingeben beim opcodes von Programmieren zu reden!

    Jo, diese Vermutung von dir ist völlig lächerlich.

    Hier geht es ja weniger darum zu programmieren, sondern darum geeignete Hilsmittel zu verwenden, um Assemblernbefehle auf die schnelle quasi unmittelbar mittels "Try and Error" auszuprobieren.
    Und ohne entsprechende Mnemonics zu verwenden können solche Routinen mit den entsprechenden Opcodes für SIMD doch ebenfalls dafür dienen, um die Funktionsweise der Befehle einmal auszuprobieren und kennen zu lernen.
    Im Assemblemode von Debug kann man dafür beispielsweise die "DB"-Anweisung benutzen.

    Und ganz neben bei, debug.exe war und ist ganz sich kein Windows-internes Systemwerkzeug - es ist ein Überbleibsel aus DOS Zeiten.

    👎

    Internes Systemwerkzeug hin oder her, ich finde debug.exe unter Windows XP in *C:\Windows\System32* 👍

    Auch können Dateien mit langen Dateinamen und Leerzeichen darin über öffnen mit debug innerhalb von Debug (unter Windows) eingeladen werden. Und es muss ja auch kein Windows sein, ein pures DOS ohne GUI genügt schon für debug.

    Um auf die schnelle einige wenige Assemblerbefehle auszuprobieren, ob nun mit Eingabe von Mnemonics, oder auch als Bytefolgen eingegeben, ist debug bestens dafür geeignet noch vor dem eigentlichen Lernen des "Programmierens" anhand von kleinen Befehlsfolgen die Funktionsweise der CPU und der verwendeten Befehle kennen zu lernen.

    http://www.angelfire.com/electronic/tristar/downloads/j/Debug.doc
    http://www.armory.com/~rstevew/Public/Tutor/Debug/debug-manual.html

    Dirk

    0
Anmelden zum Antworten