Shellcode um in Datei zu schreiben
-
Hallo ich wollte einen Shellcode erzeugen,welcher Test\n in eine Datei schreibt. dazu habe ich zuerst ein Assembler Programm geschrieben:
section .data msg db "Test",0x0a,0x0d file db "./test.txt" section .text global _start _start: xor eax,eax mov eax,8 mov ebx,file mov ecx,0x700 int 0x80 mov ebx,eax mov eax,4 mov ecx,msg xor edx,edx mov edx,6 int 0x80 mov eax,6 int 0x80 mov eax,1 xor ebx,ebx int 0x80Dieses funktioniert auch. Dann habe ich versucht, daraus Shellcode zu erstellen:
BITS 32 jmp short file file2: xor eax,eax mov al,8 pop ebx mov ch,0x7 int 0x80 mov ebx,eax mov al,4 jmp short msg msg2: pop ecx xor edx,edx mov dl,6 int 0x80 mov al,6 int 0x80 mov al,1 xor ebx,ebx int 0x80 msg: call msg2 db "Test",0x0a,0x0d file: call file2 db "./test.txt"Doch dieser funktioniert leider nicht und ich weiß nicht wieso!
Bitte um Hilfe!
-
So jetzt funktionierts! Habe jetzt jedoch ein anderes Problem:
Die Zugriffsrechte stimmen nicht. Hier der open syscall aufruf:pop ebx
push ebx
mov eax,ebx
xor ecx,ecx
mov [eax+16],cl
lea ebx,[eax+6]
mov cx,0777
xor eax,eax
mov al,8
int 0x80Ich möchte 777 oder 666 als Zugriffsrechte einstellen. So sehen die
Rechte in Textform momentan aus: -r----x--t
Woher kommt das t und was bedeutet es? Was ist falsch an meinen Rechten
und wie stelle ich das ganze richtig? Bitte um Hilfe
-
Kann es sein dass du nicht wirklich weißt was du da machst.. ?
Was hast du denn jetzt geändert dass es geht ?
Hier trotzdem noch meine Korrektur, schau dir die Kommentare an:BITS 32 jmp short file file2: pop ebx xor eax,eax ;set eax 0 mov [ebx+0xa], al ;nullterminate string! (nullbytes are forbidden, so this way) mov al,8 xor ecx,ecx ; clear ecx ?! mov ch,0x7 int 0x80 mov ebx,eax mov al,4 jmp short msg msg2: pop ecx xor edx,edx mov dl,6 int 0x80 mov al,6 int 0x80 mov al,1 xor ebx,ebx int 0x80 msg: call msg2 db 'Test',0x0a,0x0d db '$' ;char index: 6 file: call file2 db './test.txt' db '$' ;char index: 10Zu deinem Zugriffsrecht t schau mal hier: http://de.wikipedia.org/wiki/Sticky_bit
Ich kenn mich mit Linux nicht sonderlich aus und habe auch keine großartige Lust mich da jetzt reinzuarbeiten, daher mal ne allgemeine Frage:
- Sind die Zahlen im richtigen Format oder vermischt du Hex/Dec/Oct ?
-
Jetzt geht alles!
Hier der Code:BITS 32 jmp short file file2: pop ebx push ebx mov eax,ebx xor ecx,ecx mov [eax+16],cl lea ebx,[eax+6] mov cx,666o xor eax,eax mov al,8 int 0x80 pop ecx mov ebx,eax mov al,0x0a mov [ecx+4],al mov al,0x0d mov [ecx+5],al xor eax,eax mov al,4 xor edx,edx mov dl,6 int 0x80 mov al,6 int 0x80 mov al,1 xor ebx,ebx int 0x80 file: call file2 db "Test##./test.txt#"
-
Noch mal etwas zusammengefasst (ungetested):
jmp short file file2: pop ebx push ebx xor ecx,ecx mov [ebx+0x6],cl mov [ebx+0x11],cl lea ebx,[ebx+7] mov cx,666o xor eax,eax mov al,8 int 0x80 pop ecx mov ebx,eax xor eax,eax mov al,4 xor edx,edx mov dl,6 int 0x80 mov al,6 int 0x80 mov al,1 xor ebx,ebx int 0x80 file: call file2 db 'Test', 0x0a, 0x0d,'#./test.txt#'Hab die Nachricht auch gleich nullterminiert, das hast du vergessen.
Allerdings ist es doch besser die zwei strings zu trennen, dann kannst du auch schwerer vergessen irgendwelche offsets anzupassen wenn du sie mal änderst.
Und du solltest dir dringen angewöhnen Kommentare zu machen !
-
Du willst doch wohl kein Knacker Programm erstellen oder?!
-
DarkShadow44 schrieb:
Hab die Nachricht auch gleich nullterminiert, das hast du vergessen.
wenn es sich um Shellcode handelt, so dürfen in der Regel keine Bytes mit Wert 0 vorkommen.
Shellcode wird im befallenen Programm ja normalerweise mit strcpy oder ähnlichen Funktionen in den Puffer kopiert. Und strcpy hört auf Zeichen zu kopieren, sobald ein 0 Byte gefunden wird.
Der gesamte Shellcode mitsamt NOP Sled und sich wiederholender Rücksprungadresse hier als Skizze:
+------+-----------+----------------+ | NOPs | Shellcode | Return Adresse | +------+-----------+----------------+Sind 0er bereits im Shellcode zu finden, so wird die Rücksprungadresse am Stack nicht überschrieben und dein Code wird niemals ausgeführt.
Im Übrigen übergibt man dem Syscall write ja eh die Länge des Strings, somit kann man sich das terminierende 0 Byte ohnehin sparen.
Du willst doch wohl kein Knacker Programm erstellen oder?!
uhhh böse da interessiert sich jemand für Assembler, Reverse Engineering und Shellcode. Das muss ein böser Hacker sein
-
wenn es sich um Shellcode handelt, so dürfen in der Regel keine Bytes mit Wert 0 vorkommen.Nullterminiert müssen Strings für API Aufrufe ja trotzdem sein, darum ja der Trick mit dem Nullterminieren per XOR.
Der Asmcode den ich gepostet hab erzeugt kein einziges Nullbyte.
-
DarkShadow44 schrieb:
wenn es sich um Shellcode handelt, so dürfen in der Regel keine Bytes mit Wert 0 vorkommen.Nullterminiert müssen Strings für API Aufrufe ja trotzdem sein, darum ja der Trick mit dem Nullterminieren per XOR.
Der Asmcode den ich gepostet hab erzeugt kein einziges Nullbyte.ah ok sorry da hab ich nicht genau genug geschaut.
wenn man das byte zur laufzeit auf 0 setzt ist das natürlich ok!
-
Du willst doch wohl kein Knacker Programm erstellen oder?!
uhhh böse da interessiert sich jemand für Assembler, Reverse Engineering und Shellcode. Das muss ein böser Hacker sein :D[/quote]
Tja, Bürschchen wir von GData sind schon ein paar schlaue Füchse !
Dein Shellcode kann nix mehr machen der ist nämlich auf unserer Blacklist !
Da besteht GAR KEIN ZWEIFEL das du da Schwindluder treiben willst.Ich kenn mich aus ich weiss wovon ich rede !
Den ich habe ein Computer Bild Abonnement und lese die Zeitung jeden Monat von vorne bis hinten durch !GUTEN TAG !
-
Hallo.
Ich dachte Shellcode ist ein Begriff aus der Software-Programmierung und bezeichnet die bereits schon in Opcodes umgewandelte Form von Assemblersprachenbefehlen.Zb. so etwas aus dem Shellscript von Herbert Kleebauer(Most of the code is stolen from Frank Kotler):
http://coding.derkeiler.com/Archive/Assembler/alt.lang.asm/2007-07/msg00440.htmlLinux Xdemo
7f454c4601010100000000000000000002000300010000007480040834000000 0000000000000000340020000200000000000000010000000000000000800408 0080040858020000580200000500000000100000010000005802000058920408 58920408340000002004000006000000001000006a006a016a0189e1bb010000 00b866000000cd8083c40c85c00f88a401000089c76813000000684482040857 89e1bb03000000b866000000cd8083c40c85c00f887e01000089fbb903000000 b837000000cd8085c00f886801000089fbb90400000089c281ca00080000b837 000000cd8085c00f884a0100006a00680c00000068589204085789e1bb090000 00b866000000cd8083c41085c00f88240100006a0068e8030000689092040857 89e1bb0a000000b866000000cd8083c4103df5ffffff74db85c00f88f7000000 be909204088b460ca368920408a3889204080fb7461883c02b24fc0fb6561dc1 e20301d08b0406a36c9204086a00682000000068649204085789e1bb09000000 b866000000cd8083c41085c00f88a50000006a0068e803000068909204085789 e1bb0a000000b866000000cd8083c4103df5ffffff740885c00f88780000006a 00680800000068849204085789e1bb09000000b866000000cd8083c41085c00f 88520000006a0068e803000068909204085789e1bb0a000000b866000000cd80 83c4103df5ffffff740885c00f88250000006a0068e803000068909204085789 e1bb0a000000b866000000cd8083c4103df5ffffff74dbbb00000000b8010000 00cd800001002f746d702f2e5831312d756e69782f5830006c000b0000000000 00000000010008000000000000000000640032009001c8000a00000000000000 000000000800020000000000Dirk
-
IHR HAB DOCH ALLE GAR KEINE AHNUNG IHR SCRIPT KIDDYS !
Sowas schreibe ich in HTML in 1 Minute !
-
Naja in "Opcodes umgewandelt" ist falsch ausgedrückt. Aber ja, es ist maschinencode (meist einfach binär oder als string durch angabe der hex-kodierten Bytes) der normalerweise dazu genutzt wird um Schwachstellen auszunutzen.
Allerdinds würde ich den Assemblercode aus dem er entstanden ist auch noch als Shellcode bezeichnen.@1337 H4CkEr
Ach du schreibst uns jetzt in HTML ausführlich die Definition von Shellcode ? :p
-
@ DarkShadow44
Ich h4b m4l mIt HTML eIn BeTrIeBsYsTem geScHriEben
für nur 4000€ pro Tag kannst du an einem meiner HACKER KURSE teilnehmen !
Der Kurs geht 13,37 Tage
-
freecrac schrieb:
Hallo.
Ich dachte Shellcode ist ein Begriff aus der Software-Programmierung und bezeichnet die bereits schon in Opcodes umgewandelte Form von Assemblersprachenbefehlen.Zb. so etwas aus dem Shellscript von Herbert Kleebauer(Most of the code is stolen from Frank Kotler):
http://coding.derkeiler.com/Archive/Assembler/alt.lang.asm/2007-07/msg00440.htmlLinux Xdemo
7f454c4601010100000000000000000002000300010000007480040834000000 0000000000000000340020000200000000000000010000000000000000800408 0080040858020000580200000500000000100000010000005802000058920408 58920408340000002004000006000000001000006a006a016a0189e1bb010000 00b866000000cd8083c40c85c00f88a401000089c76813000000684482040857 89e1bb03000000b866000000cd8083c40c85c00f887e01000089fbb903000000 b837000000cd8085c00f886801000089fbb90400000089c281ca00080000b837 000000cd8085c00f884a0100006a00680c00000068589204085789e1bb090000 00b866000000cd8083c41085c00f88240100006a0068e8030000689092040857 89e1bb0a000000b866000000cd8083c4103df5ffffff74db85c00f88f7000000 be909204088b460ca368920408a3889204080fb7461883c02b24fc0fb6561dc1 e20301d08b0406a36c9204086a00682000000068649204085789e1bb09000000 b866000000cd8083c41085c00f88a50000006a0068e803000068909204085789 e1bb0a000000b866000000cd8083c4103df5ffffff740885c00f88780000006a 00680800000068849204085789e1bb09000000b866000000cd8083c41085c00f 88520000006a0068e803000068909204085789e1bb0a000000b866000000cd80 83c4103df5ffffff740885c00f88250000006a0068e803000068909204085789 e1bb0a000000b866000000cd8083c4103df5ffffff74dbbb00000000b8010000 00cd800001002f746d702f2e5831312d756e69782f5830006c000b0000000000 00000000010008000000000000000000640032009001c8000a00000000000000 000000000800020000000000Dirk
der name shellcode kommt daher, dass diese codes oft dazu verwendet werden, ein programm welches mit root rechten läuft dazu zu bekommen, eine shell (terminal, konsole) zu starten, welche auch mit root rechten läuft.
dann hat man plötzlich als otto normal user root rechte, kann also so ziemlich alles mit dem system anstellen.shellcode wird meist in asm programmiert und dann in maschinencode übersetzt (die übersetzungsarbeit nimmt einem z.b. das programm nasm ab).
oft muss man darauf achten, dass der maschinencode keine 0 bytes enthält, da der schadcode oft vom befallenen programm mit strcpy in den angegriffenen puffer kopiert wird.
also dinge wie mov eax,0 sollte man vermeiden, und stattdessen etwa xor eax,eax verwenden.
-
Wenn ihr was über Shellcodes lernen wollt dann schaut mal hier vorbei:
http://www.projectshellcode.com
4ber nIcHt d4s IhR miR d4miT UnFuG treiBt !!!
-
Danke für die Erklärung.
Nun habe ich nur noch zwei Fragen dazu:Werden mit dem Begriff Shellcode nun eigentlich die in Opcodes umgewandelte Form von Assemblerbefehlen definiert, oder gehören Assemblerbefehle die noch nicht zu Opcodes umgewandelt wurden auch mit zum Shellcode und sind ein Teil davon?
Und besteht ein Shellcode wirklich schon selber aus ausführbaren Opcodes, oder werden diese Opcode-Bytes doch nur in ihrer für uns lesbaren Form als Werte in Ziffern dargestellt und nur damit gebildet?
Weil reine Opcodes als ASCIIs können vergleichsweise nur so, oder ähnlich als Text dargestellt werden:
[url]https://groups.google.com/forum/#!msg/alt.msdos.batch.nt/KTQaCTUKG3Q/9Vv8XtKESncJ[/url]Dirk
-
Warum willst du jetzt so genau wissen, wie es definiert ist? So genau ist es nicht definiert, und selbst wenn das jemand definiert hätte, wär mir das egal. Den fertigen Binärcode würde ich als Shellcode bezeichnen. Genauso aber auch den Asemblerquellcode davon. Und niemand kann mich daran hindern
-
Moin.
Mechanics schrieb:
Warum willst du jetzt so genau wissen, wie es definiert ist?
Deine Frage lautet doch eigentlich, wofür gibt es überhaupt genaue Definitionen? Antwort: Damit wir eine gemeinsame Sprache verwenden können und diese auch verstanden wird, denn was nützt es sonst, wenn man nur Bahnhof versteht und nicht wirklich weiss was genau gemeint ist? Damit dürfte dieser Punkt, wofür eine präzise Definition wichtig ist, auch hoffentlich ausreichend geklärt sein.
In diesem speziellen Fall geht es auch darum, die Risiken die von einem Shellcodes ausgehen können, besser beurteilen zu können.
So genau ist es nicht definiert, und selbst wenn das jemand definiert hätte, wär mir das egal. Den fertigen Binärcode würde ich als Shellcode bezeichnen. Genauso aber auch den Asemblerquellcode davon. Und niemand kann mich daran hindern
Ich wüsste jetzt nicht wen es genau interessieren könnte, ob dir eine allgemeingültige Definition gleichgültig ist, oder auch nicht und ob du auch die Fähigkeit dazu hast einem Wort eine beliebige und eigenwillige Bedeutung beizumessen und/oder ob dich daran keiner hindern kann. Wen soll das eigentlich genau interessieren? Ich meine das sind Dinge mit denen man sich schon in seiner Kindheit beschäftig und die bei meiner Frage eigentlich nicht von so grosser Bedeutung sind. Eher das genaue Gegenteil davon trifft zu.
Wichtiger wäre die Frage, ob ein fertigen Binärcode in einem Schellcode überhaupt möglich ist, oder doch nur Assemblerbefehle und repräsentative Werte eines Opcodes als ASCII-Ziffern aufgelistet?
Beispiel: Encoded into a string using percent-encoding (using the unescape() function to decode): unescape("%u9090");
Diese Werte der Opcodes werden hier nur als lesbare Ziffern in Textform angegeben und dieser Text ist selber noch kein Opcode und kann so in dieser Form nicht von einer CPU als Opcodes ausgeführt werden.Ich möchte schlicht es nur wissen woraus ein Shellcode ganz genau bestehen kann und welche Bestandteile dort möglich und anzutreffen sind. Bisher habe ich selber noch keinen Shellcode gesehen wo tatsächlich ausführbare Opcodes enthalten sind, die von der CPU in dieser Form auch ausgeführt werden können.
Dirk
-
Der Shellcode selber sind einfach nur Bytes die zusammengenommen lauffähigen Maschinencode bilden. Ob diese Bytes jetzt direkt binär in einer Datei stecken, Hexkodiert in einen string eingebunden, percent-encoded sind, oder einfach zur Laufzeit aus einem bild reconstruiert werden ist doch egal ?
Wichtiger wäre die Frage, ob ein fertigen Binärcode in einem Schellcode überhaupt möglich ist, oder doch nur Assemblerbefehle und repräsentative Werte eines Opcodes als ASCII-Ziffern aufgelistet?
Bitte was ?
Shellcode ist letztlich >immer< Maschinencode. Und Maschinencode sind Bytes. ASCII-Zeichen sind Bytes. Das heißt du kannst jede ASCII Zeichenfolge auch als Maschinencode interpretieren. Das macht natürlich nur Sinn wenn es dann auch lauffähigen Machinencode bildet. Das merkt man dann aber meistens, weil die Zeichenfolge dann als Zeichenfolge betrachtet keinen Sinn mehr ergibt, gerne mal voll mit Sonderzeichen ist. Und weil es mit Sonderzeichen in Zeichenketten oft mal Probleme gibt (z.B. der Editor/Browser Zeichen 'verschluckt'/umwandelt oder was auch immer) verwendet man Hex oder Prozent Kodierung. Wäre für nen Angriff ja blöd wenn dein schöner Shellcode vom Browser des Ziels plötzlich verändert und damit zerstört wird.