3. Disassembling - ich checks einfach nicht!

Disassembling - ich checks einfach nicht!

  • ?

    CTMN schrieb:

    Ähh ehrlich gesagt wär's toll wenn du mal klar und verständlich schreiben würdest was deine Frage ist. Vielleicht hab ich dich mißverstanden und du denkst, dass das kein Assembler wär. Aber für mich sieht es sehr nach Assembler aus.

    ja natürlich ist das assembler, das ist nicht die frage.

    meine frage ist eher, wo ich anfangen soll, bzw. wie man an so einen disassembled-code rangeht.

    0
  • ?

    disasm schrieb:

    CTMN schrieb:

    Ähh ehrlich gesagt wär's toll wenn du mal klar und verständlich schreiben würdest was deine Frage ist. Vielleicht hab ich dich mißverstanden und du denkst, dass das kein Assembler wär. Aber für mich sieht es sehr nach Assembler aus.

    ja natürlich ist das assembler, das ist nicht die frage.

    meine frage ist eher, wo ich anfangen soll, bzw. wie man an so einen disassembled-code rangeht.

    die frage nochmal einfacher:
    was wäre jetzt als nächstes zu tun? was ist wichtig, was nicht? ich weiß garnicht, was ich da jetzt machen soll!

    0
  • Mod

    Wenn du nicht weißt, was es ist oder wozu es gut ist oder wie es geht, dann lass es doch einfach! Anscheinend besteht ja kein Bedarf, sonst wüsstest du ja wenigstens, was du überhaupt erreichen willst. Nur weil du mal gehört hast, dass die coolen Kinder mit Disassemblern spielen heißt das nicht, dass du cool wirst, wenn du mitspielst.

    0
  • ?

    es geht nicht darum, dass ich kein assembler kann, sondern darum, dass ich nicht versteh, warum gcc gerade das macht, was er macht (z.b. das ganze glibc zeugs, oder warum 14 mal nacheinander nop wiederholt wird, was die ganzen überflüssigen (?) sections sollen...

    aber danke für den "freundlichen" umgang hier. 🙄

    0
  • ?

    disasm schrieb:

    warum 14 mal nacheinander nop wiederholt wird

    Die nop s sollen gar nicht ausgeführt werden, die sind nur zum Auffüllen da, damit deregister_tm_clones auf einer geraden (durch 16 teilbaren) Adresse sitzt.

    Das ganze glibc-Zeugs ist Initialisierungs- und Abschlusscode plus evtl ein paar Funktionen, die printf noch aufruft.

    Was als nächstes zu tun ist, hängt davon ab, was du überhaupt erreichen willst 😉

    0
  • R

    GCC kann dir direkt den Assembleroutput ausgeben und sogar den Code als Kommentar einbauen. Da brauchst du gar keinen extra Disassembler: gcc -S -fverbose-asm -fno-dwarf2-cfi-asm -Wa,-ahl foo.c -o foo.s

    Und spam bitte nicht das Forum mit Zeilenweise nutzlosem Output voll! 👎

    0
  • ?

    Guck doch deinen Disassemblercode mal an, es ist doch offensichtlich:

    .file	"foo.c"
# GNU C (Ubuntu/Linaro 4.5.2-8ubuntu4) version 4.5.2 (x86_64-linux-gnu)
#	compiled by GNU C version 4.5.2, GMP version 4.3.2, MPFR version 3.0.0-p8, MPC version 0.9
# GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
# options passed:  foo.c -D_FORTIFY_SOURCE=2 -mtune=generic -march=x86-64
# -auxbase-strip foo.s -fverbose-asm -fno-dwarf2-cfi-asm -fstack-protector
# options enabled:  -falign-loops -fargument-alias
# -fasynchronous-unwind-tables -fauto-inc-dec -fbranch-count-reg -fcommon
# -fdelete-null-pointer-checks -fearly-inlining
# -feliminate-unused-debug-types -ffunction-cse -fgcse-lm -fident
# -finline-functions-called-once -fira-share-save-slots
# -fira-share-spill-slots -fivopts -fkeep-static-consts
# -fleading-underscore -fmath-errno -fmerge-debug-strings
# -fmove-loop-invariants -fpeephole -freg-struct-return
# -fsched-critical-path-heuristic -fsched-dep-count-heuristic
# -fsched-group-heuristic -fsched-interblock -fsched-last-insn-heuristic
# -fsched-rank-heuristic -fsched-spec -fsched-spec-insn-heuristic
# -fsched-stalled-insns-dep -fshow-column -fsigned-zeros
# -fsplit-ivs-in-unroller -fstack-protector -fstrict-volatile-bitfields
# -ftrapping-math -ftree-cselim -ftree-forwprop -ftree-loop-im
# -ftree-loop-ivcanon -ftree-loop-optimize -ftree-parallelize-loops=
# -ftree-phiprop -ftree-pta -ftree-reassoc -ftree-scev-cprop
# -ftree-slp-vectorize -ftree-vect-loop-version -funit-at-a-time
# -funwind-tables -fvect-cost-model -fverbose-asm -fzero-initialized-in-bss
# -m128bit-long-double -m64 -m80387 -maccumulate-outgoing-args
# -malign-stringops -mfancy-math-387 -mfp-ret-in-387 -mfused-madd -mglibc
# -mieee-fp -mmmx -mno-sse4 -mpush-args -mred-zone -msse -msse2
# -mtls-direct-seg-refs

# Compiler executable checksum: 9755ab75799195519479ef699703b13b

	.section	.rodata
.LC0:
	.string	"Hello world!"
	.text
.globl main
	.type	main, @function
main:
.LFB0:
	pushq	%rbp	#
.LCFI0:
	movq	%rsp, %rbp	#,
.LCFI1:
	movl	$.LC0, %edi	#,
	call	puts	#
	movl	$0, %eax	#, D.3278
	leave
.LCFI2:
	ret
.LFE0:
	.size	main, .-main
	.section	.eh_frame,"a",@progbits
.Lframe1:
	.long	.LECIE1-.LSCIE1
.LSCIE1:
	.long	0x0
	.byte	0x1
	.string	"zR"
	.uleb128 0x1
	.sleb128 -8
	.byte	0x10
	.uleb128 0x1
	.byte	0x3
	.byte	0xc
	.uleb128 0x7
	.uleb128 0x8
	.byte	0x90
	.uleb128 0x1
	.align 8
.LECIE1:
.LSFDE1:
	.long	.LEFDE1-.LASFDE1
.LASFDE1:
	.long	.LASFDE1-.Lframe1
	.long	.LFB0
	.long	.LFE0-.LFB0
	.uleb128 0x0
	.byte	0x4
	.long	.LCFI0-.LFB0
	.byte	0xe
	.uleb128 0x10
	.byte	0x86
	.uleb128 0x2
	.byte	0x4
	.long	.LCFI1-.LCFI0
	.byte	0xd
	.uleb128 0x6
	.byte	0x4
	.long	.LCFI2-.LCFI1
	.byte	0xc
	.uleb128 0x7
	.uleb128 0x8
	.align 8
.LEFDE1:
	.ident	"GCC: (Ubuntu/Linaro 4.5.2-8ubuntu4) 4.5.2"
	.section	.note.GNU-stack,"",@progbits

    Triviales Zeugs. :Kaffe trinken geh:

    0
  • ?

    Ich bin zwar kein Expertem wie die meisten hier, aber ich habe früher in Assembler programmiert und kann die vielleicht mal eine Richtung geben, was die Komplexität erklärt die du im Assemblercode gegenüber dem C Code siehst.

    C mag dir LowLevel erscheinen, ist es in meinen Augen aber nicht. C und auch C++ sind Hochsprachen die erst in die eigentliche Sprache des Rechners und damit der CPU übersetzt/kompiliert werden muss. Diese Sprache nennt sich Maschinensprache und wird zur besseren Lesbarkeit in Assemblerbefehlen dargestellt, die aber 1:1 widerspiegeln was passiert.

    Da C selbst auf anderen C Funktionen zurückgreift, passiert schon bei einem nicht trivialen Befehl wie printf eine ganze Menge. Wenn du möchtest kannst du dir ja mal eine Implementierung von printf anschauen? Hier ist ein Link zu vprintf welches von printf aufgerufen wird:http://sourceware.org/git/?p=glibc.git;a=blob;f=stdio-common/vfprintf.c;h=fc370e8cbc4e9652a2ed377b1c6f2324f15b1bf9;hb=3321010338384ecdc6633a8b032bb0ed6aa9b19a

    In deinem fertigen Programm ist also das ganze C-Programm und die Implementierung der genutzten C-Befehle, aus Bibliotheken wie cstdio, mit drin. Zusätzlich optimiert der Compiler noch etwas oder lässt Sachen weg, die nicht gebraucht werden.

    Dazu kommt dann noch ein Startupcode von deinem Betriebssystem. Dein Programm, so wie du es siehst, ist bei weitem nicht alleine auf einem Computer lauffähig. Selbst dieses Assemblerprogramm bedient sich Betriebssystemfunktionen und die wiederum nutzen Funktionen aus Treibern etc. Den wirklichen Ausführungscode hast du mit deinem kleinen Programm also noch gar nicht gesehen. Sondern du kennst jetzt nur den Teil, mit dem dann das Betriebssystem was anfangen kann.

    Nun zu der berechtigten Frage hier, was wolltest du mit dem Anschauen deines Programms in Assembler erreichen? Schauen wie Compiler arbeiten? Dies ist einer der Königsdisziplinen der Informatik und bestimmt nicht mal eben in ein paar Wochen zu verstehen. Oder wolltest du schauen wie printf wirklich funktioniert? Auch dies ist mit Sicherheit nicht gerade ein leichtes Unterfangen.

    Der Ausschnitt, den du hier gepostet hast, ist ein Produkt von vielen theoretischen und praktischen Gebieten der Informatikgeschichte und wer dies alles im Detail versteht, ist bestimmt nicht nur ein x-beliebiger Programmierer, sondern schon ein Experte.

    0
  • Mod

    Butterbrot schrieb:

    In deinem fertigen Programm ist also das ganze C-Programm und die Implementierung der genutzten C-Befehle, aus Bibliotheken wie cstdio, mit drin.

    Die Runtime statisch zu linken ist zwar technisch möglich, aber eher ungewöhnlich.

    0
  • B

    @ Disasm

    Schau dir mal IDA Pro an das ist ein guter Disassembler, auf der Hexrays Homepage kannst du eine abgespeckte kostenlose Windows Version finden die aber auch schon das ELF Dateiformat unterstützt. Kannst dir ja mal Windows iner VM installieren und dann dein Programm mit IDA anschauen.

    Oder du kaufst dir IDA Pro (ist aber nicht ganz billig^^) die alternative zum kauf ist wie immer Googel. 😃

    0
  • K

    disasm schrieb:

    ich versteh das mit disassembling einfach nicht!

    Aha.

    Also, wenn ich deinen Code kompiliere (nur kompilieren, nicht linken), dann erhalte ich folgendes:

    $ cat test.c
#include <stdio.h>

int main()
{
      printf("Hello world!\n");
      return 0;
}

$ gcc -c test.c
$ objdump -d test.o

test.o:     file format pe-x86-64

Disassembly of section .text:

0000000000000000 <main>:
   0:   55                      push   %rbp
   1:   48 89 e5                mov    %rsp,%rbp
   4:   48 83 ec 20             sub    $0x20,%rsp
   8:   e8 00 00 00 00          callq  d <main+0xd>
   d:   48 8d 0d 00 00 00 00    lea    0x0(%rip),%rcx        # 14 <main+0x14>
  14:   e8 00 00 00 00          callq  19 <main+0x19>
  19:   b8 00 00 00 00          mov    $0x0,%eax
  1e:   48 83 c4 20             add    $0x20,%rsp
  22:   5d                      pop    %rbp
  23:   c3                      retq
  24:   90                      nop
  25:   90                      nop
  26:   90                      nop
  27:   90                      nop
  28:   90                      nop
  29:   90                      nop
  2a:   90                      nop
  2b:   90                      nop
  2c:   90                      nop
  2d:   90                      nop
  2e:   90                      nop
  2f:   90                      nop
    0
  • G

    Wenn du was über Compiler hören willst hier:
    http://cre.fm/cre122
    http://cre.fm/cre114

    0
  • E

    Bassmaster schrieb:

    @ Disasm

    Schau dir mal IDA Pro an das ist ein guter Disassembler, auf der Hexrays Homepage kannst du eine abgespeckte kostenlose Windows Version finden die aber auch schon das ELF Dateiformat unterstützt. Kannst dir ja mal Windows iner VM installieren und dann dein Programm mit IDA anschauen.

    Oder du kaufst dir IDA Pro (ist aber nicht ganz billig^^) die alternative zum kauf ist wie immer Googel. 😃

    IDA ist nicht gut, IDA ist der Überhammer.
    Dürfte neben Ollydbg eins der killertools für reverser sein. 😉

    0
  • ?

    ich hab mir jetzt die letzte freeware, bzw. testversion von ida geholt.

    eine frage:
    warum wird in einer ".idata"-section immer ein db mit dem wert 0 reserviert?

    also

    db   0
db   0
db   0
db   0
.
.
.
    0
Anmelden zum Antworten