Wie man opcodes von einem c-Programm

Weiß ich, wie man die Assembler-Quellcode von meinem Programm mit gdb, aber wie bekomme ich den opcode?
Ich brauche es für hack ein linux-server (keine Sorge, es ist ein Teil der Klasse, ich habe also keinen echten server geschädigt wird). Eigentlich war ich zu Lesen diese Artikel und ich Frage mich, wie kann ich von der Montage:

[aleph1]$ gcc -o shellcodeasm -g -ggdb shellcodeasm.c
[aleph1]$ gdb shellcodeasm

(gdb) disassemble main
Dump of assembler code for function main:
0x8000130 <main>:       pushl  %ebp
0x8000131 <main+1>:     movl   %esp,%ebp
0x8000133 <main+3>:     jmp    0x800015f <main+47>
0x8000135 <main+5>:     popl   %esi
0x8000136 <main+6>:     movl   %esi,0x8(%esi)
0x8000139 <main+9>:     movb   $0x0,0x7(%esi)
0x800013d <main+13>:    movl   $0x0,0xc(%esi)
0x8000144 <main+20>:    movl   $0xb,%eax
0x8000149 <main+25>:    movl   %esi,%ebx
0x800014b <main+27>:    leal   0x8(%esi),%ecx
0x800014e <main+30>:    leal   0xc(%esi),%edx
0x8000151 <main+33>:    int    $0x80
0x8000153 <main+35>:    movl   $0x1,%eax
0x8000158 <main+40>:    movl   $0x0,%ebx
0x800015d <main+45>:    int    $0x80
0x800015f <main+47>:    call   0x8000135 <main+5>
0x8000164 <main+52>:    das
0x8000165 <main+53>:    boundl 0x6e(%ecx),%ebp
0x8000168 <main+56>:    das
0x8000169 <main+57>:    jae    0x80001d3 <__new_exitfn+55>
0x800016b <main+59>:    addb   %cl,0x55c35dec(%ecx)
End of assembler dump.

folgende:

testsc.c
------------------------------------------------------------------------------
char shellcode[] =
    "\xeb\x2a\x5e\x89\x76\x08\xc6\x46\x07\x00\xc7\x46\x0c\x00\x00\x00"
    "\x00\xb8\x0b\x00\x00\x00\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80"
    "\xb8\x01\x00\x00\x00\xbb\x00\x00\x00\x00\xcd\x80\xe8\xd1\xff\xff"
    "\xff\x2f\x62\x69\x6e\x2f\x73\x68\x00\x89\xec\x5d\xc3";

Das system ist linux-x86-und die Sprache, die ich verwenden werde C. ich würde wirklich gerne eine automatisierte Methode, aber eine manuelle Lösung würde auch funktionieren.

Ich meine, wie kann ich konvertieren, %ebp, %esi, %esp usw.. gibt es eine map die ich verwenden kann? oder ein automatisiertes programm?

Sind Sie auf der Suche nach einem x86 disassembler?
Ich denke, dass der disassembler macht das Gegenteil von dem, was ich versuche zu tun,
Eine Auflistung der x86-Befehlssatz hat den Zuordnungen, es kann verwendet werden, zu zerlegen 0xEB (das ist JMP) oder Umgekehrt (Montage, oder "kompilieren", JMP zu 0xEB etc).
Wissen Sie, wo ich es finden kann?
Was ist mehr, wie kann ich konvertieren, sagen <main+47> zu opcode?
Jeder anständige übersicht über den Befehlssatz erläutert die verschiedenen Adressierungsarten etc. Aber wenn alles, was Sie interessiert, ist das Endergebnis, Sie brauchen nur ein assembler. gas Ich glaube, dass ist in der GCC-suite.
Haben Sie versucht, wie Google?

InformationsquelleAutor George Panic | 2012-03-21

Hier gehen Sie:

Disassembly of section .data:

00000000 <shellcode>:
   0:       eb 2a                   jmp    2c <shellcode+0x2c>
   2:       5e                      pop    %esi
   3:       89 76 08                mov    %esi,0x8(%esi)
   6:       c6 46 07 00             movb   $0x0,0x7(%esi)
   a:       c7 46 0c 00 00 00 00    movl   $0x0,0xc(%esi)
  11:       b8 0b 00 00 00          mov    $0xb,%eax
  16:       89 f3                   mov    %esi,%ebx
  18:       8d 4e 08                lea    0x8(%esi),%ecx
  1b:       8d 56 0c                lea    0xc(%esi),%edx
  1e:       cd 80                   int    $0x80
  20:       b8 01 00 00 00          mov    $0x1,%eax
  25:       bb 00 00 00 00          mov    $0x0,%ebx
  2a:       cd 80                   int    $0x80
  2c:       e8 d1 ff ff ff          call   2 <shellcode+0x2>
  31:       2f                      das
  32:       62 69 6e                bound  %ebp,0x6e(%ecx)
  35:       2f                      das
  36:       73 68                   jae    a0 <shellcode+0xa0>
  38:       00 89 ec 5d c3 00       add    %cl,0xc35dec(%ecx)

Beachten Sie, wie der Letzte, 00 in diesem add %cl Anweisung kommt von der string null terminator byte; es ist nicht explizit.

Wie ich war, habe ich einfach zusammengestellt deine Erklärung mit

gcc testsc.c -c

dann

objdump -D testsc.o

ich denke, das ist das Gegenteil von dem, was ich tun will...
Das mag so sein, aber die Antwort ist die gleiche. Kann man zerlegen, dass shellcodeasm Programm mit objdump zu tun, anstatt es im inneren gcc. Wie Sie sehen können, die Ausgabe-format gibt Ihnen die Demontage-Liste, und die opcodes. Können Sie einige text-Verarbeitung schneiden Sie die Spalte bytes und automatisch transformieren Sie in eine C-Deklaration.

InformationsquelleAutor Kaz

6

Können Sie verwenden:
```
gcc -S -c tst.c -o -
```
oder
```
gcc -g -ggdb -c tst.c
objdump -S tst.o
```
um die Demontage des Programms mit den opcodes.

Um die Demontage Ihres char-array verwenden, können Sie:
```
gcc -c tst.c
objdump -D -j .data tst.o
```
- Sind Sie sicher? objdump nicht zerlegen-data-Bereich standardmäßig aktiviert und der gcc nicht konvertieren von beliebigen Zeichenketten zu opcodes.
- aktualisiert meine Antwort, ich habe nicht bemerkt, anfangs wollte er die Demontage des Arrays bytes.
- Wenn objdump nicht zerlegen Abschnitte standardmäßig, wie ich zu produzieren, dass die Antwort?
- als -d nur zerlegt .text aber -D zerlegt Sie die anderen Abschnitte auch.
- Die GNU binutils objdump nicht zerlegen jede Abschnitt standardmäßig. In der Tat, standardmäßig druckt eine Hilfe-Bildschirm.
- gcc -c tst.c && objdump -S tst.o arbeitete für mich auf Linux 2.6.32-5-und gcc 4.7.1. Aber nur tun gcc -S -c tst.c -o - ohne die objdump-Schritt erzeugt nur die Montage mnemonics auf meinem system, nicht den opcodes
InformationsquelleAutor ouah
3

Gefunden! Zuerst zerlegen, dann geben :
x/bx drücken Sie die EINGABETASTE und erhalten, indem man die hex-Darstellung des Montage-Befehle!
- Sie können tun es alle auf einmal, indem Sie mit x /100bx start_address, geben Sie die hex-Darstellung der nächsten 100 bytes ab start_address. Ändern Sie 100, um die Anzahl der bytes, die Ihr zerlegt-code umfasst.
InformationsquelleAutor George Panic
0

Erstellen Sie eine kleine assembly-Datei, sagen code.s. Dann fügen Sie den folgenden hinein:
```
.text
.byte 0xeb, 0x2a, 0x5e, ..
```
Montage mit as code.s -o code.o und verwenden objdump zum disassemblieren Sie das Ergebnis.

InformationsquelleAutor zvrba

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.