buffer overflow / shellcode - linux

L

loose

0
Ich beschäftige mich gerade ein wenig mit buffer overflows, bzw. shellcode unter linux (Ubuntu 7.10). Dazu einige Fragen:

Wenn ich zu Testzwecken ein C-Programm mit einer Sicherheitslücke (bspw gets(kleinerpuffer)) übersetze, und versuche einen buffer-overflow herbeizuführen, bekomme ich "*** stack smashing detected ***"
Wenn ich ein ähnliches Programm in Assembler schreibe funzt alles wie es soll. also denke ich, dass gcc irgendeine anti-stacksmash lib mitlinkt (bitte korrigiert mich, wenn ich falsch liege). Frage dazu: Wie kann ich das verhindern?

Dann noch eine weitere Frage. Wenn ein Programm aufgrund eines buffer-overflows crasht bekomme ich die Meldung (core dumped) (so wie es sein soll). Nur leider ist die core-Datei nirgens zu finden. Weiß jemand woran das liegt?

mfg, loose
 
"-fno-stack-protector" -> das habe ich gesucht, danke! Warum komme ich eigentlich nie darauf, auf der englischen Wiki-Seite zu suchen...

Wenn mir jetzt noch einer mit den core-files, bzw. warum ich keine bekomme, helfen kann, bin ich glücklich.

mfg, loose
 
Dass keine Core-Files erstellt werden, kann mehrere Ursachen haben. Meist ist es via ulimit deaktiviert:

Code: 
ulimit -S -c 0 > /dev/null 2>1

Dann kann man es recht einfach wieder aktivieren:

Code: 
ulimit -S -c unlimited > /dev/null 2>1

Evtl. ist es auch in der /etc/security/limits.conf deaktiviert, dann dort den Eintrag entsprechend auf unlimited setzen.

Manche Distros nutzen das ProcFS um Core-Files zu unterbinden. In diesem Fall kann man einfach die ProcFS-Datei entsprechend ändern:

Code: 
echo 1 > /proc/sys/kernel/core_setuid_ok

Oder du aktivierst es direkt in der Applikation:

Code: 
#include <sys/prctl.h>

int debug = 1;
...
int main(int argc, char **argv) {
  ...
  if(debug == 1) {
    prctl(PR_SET_DUMPABLE, 1);
  }
  ...
}

Und zu guter Letzt kann es sein, dass in der /proc/sys/kernel/core_pattern einfach ein Pfad gesetzt ist, so dass die Core-Files z.B. in /tmp erstellt werden oder ähnliches. Dann hilft hier das Setzen eines Dateinamens:

Code: 
echo "core" > /proc/sys/kernel/core_pattern

Mehr fällt mir momentan nicht ein.
 
Shellcode

Hallo,

ich versuche gerade einen Bufferoverflow zu erstellen.
Den Shellcode habe ich bereits, auch frei von Nullen.

Mein Testprogramm liest einen String von einem UDP Socket und steckt ihn in einen Puffer. Dieser wird dann in eine Funktion (a) übergeben wo dieser geparsed werden soll.

Das große Problem was ich habe ist, dass ich versuche die Rücksprungadresse im Stack von a zu verändern.
Ich habe also versucht den Puffer per nop's voll laufen zu lassen um damit an die Rücksprungadresse zu kommen. Das sollte demnach so aussehen:

fffffffff
ret addr
old ebp -> aktueller ebp
nop
...
...
nop
[shellcode] -> top of stack
0000000

Mein Problem ist nun, dass ich den alten ebp ja auch überschreiben muss, um an die Rücksprungadresse zu kommen. Ich weiß nicht so richtig was ich dagegen tun kann.
Ich habe versucht einen annährend gültigen Wert dafür einzusetzen. Mitunter führt das aber natürlich zu einem Segfault.
Jedenfalls komme ich damit an die Rücksprungadresse, welche ich dann auf meinen Shellcode setzen kann.
Nach dem LEAVE sollte beim RET dann meine modifizierte Rücksprungadresse im EIP liegen und damit mein Code ausgeführt werden. Klappt bisher aber leider nicht.

Den String übergebe ich per NetCat an das Programm. Das ganze soll also später eine Remote Shell werden.
Für das Programm wird im übrigen gcc-3.4 verwendet.

Ist meine Vorgehensweise jetzt annährend korrekt oder mach ich hier was grundlegendes falsch?
Ich steh momentan ziemlich auf dem Schlauch.
 
Hmm also:

du rufst function(x, y) auf.

x und y werden auf denn Stack gepusht.
dann wird die funktion aufgerufen, ret wird auf denn stack gepusht,
in der Funktion wird nun der Wert des ebp gespeichert, (push ebp) damit haben wir denn Safed Frame Pointer,
dann wird die Addresse vom Esp in den Ebp kopiert, (somit unser neuer Framepointer für diesen Stack)

Ob du nun denn Safed Frame Pointer mit der Returnaddresse überschreibst, ist vollkommen egal weil der Kontext sich danach ja sowieso ändert.

also der Stack sieht so aus


ff..
.
.Hier sind die anderen Stackframes
.
--------
Argumente der Funktion
<RET>
<SFP>
--------------------------------Hier Zeigt der aktuelle EBP hin.
Lokale
Variablen
<ESP>
-----------------
Du überschreibst eigentlich nicht ebp sondern nur denn gespeicherten Wert von EBP,
das sollte eigtl kein Problem darstellen.

Aber ohne Code kann ich dir nicht sagen was sonst das Problem ist.
 
@prEs: ich glaube, er meint, dass vor dem RET ein LEAVE kommt (anders gesagt ein
Code: 
mov    esp, ebp
pop     ebp
dadurch, dass er mit seinem Shellcode den alten EBP Wert überschreibt, funktioniert der RET nicht, da dann (vor dem ersehnten RET) ESP Wert geändert wird.

@Topic:
probiere doch mal aus statt die Rücksprungadresse zu überschreiben nur den "alten EBP" Wert auf die Anfangsadresse Deines Shellcodes zu setzen:
Code: 
fffffffff
ret addr
old ebp == shellcodeanfang
nop
...
...
nop
[shellcode] -> top of stack
0000000
Dann ist ESP=Shellcodeanfang
Den Shellcode beginnst Du dann entsprechend mit
Code: 
_0x_richtige_adresse des Codes
Code
 
Danke für die Hinweise.

Das mit ebp überschreiben macht Sinn. Letztlich brauch ich die Stelle mit der alten Rücksprungadresse gar nicht. Ich sollte den EBP aber doch besser auf n kleines Stück vor meinen Code setzen, damit dann auch wirklich der Anfang des Shellcodes im EIP landet, oder ?

Ich werde das mal ausprobieren.

Kleiner Zusatz noch: Ein kleinen Check mit strlen() prüft, ob der übergebene String länger als der Puffer ist. Ich habe um das zu umgehen mitten in meine Füll-Nops eine Binärnull gesteckt. Das sollte keine Probleme verursachen, oder?
 
Moment, hab was falsches geschrieben:
RET nimmt die Adresse vom Stack mittels [ESP].
D.h der alte EBP Wert sollte eigentlich keine Rolle spielen (er wird zwar vom Stack geladen, aber erst nach dem ESP geändert wurde) und insgesamt sollte LEAVE nicht das Problem sein.

Ein kleinen Check mit strlen() prüft, ob der übergebene String länger als der Puffer ist. Ich habe um das zu umgehen mitten in meine Füll-Nops eine Binärnull gesteckt. Das sollte keine Probleme verursachen, oder?
Zum Vergrößern anklicken....
kommt darauf an, wie das Testprogramm den String kopiert - viele Stringfunktionen orientieren sich eben an der 0 Terminierung (und kopieren nicht weiter).
 
Noch mal zur Theorie:

Da ist doch ein kleiner Haken. Im LEAVE kommt MOV ESP, EBP.
Der ESP bekommt dabei doch den Wert im Register EBP zugewiesen. NICHT den von mir im Stack überschriebenen old EBP der auf meinen Code verweiset.
Beim anschließenden POP EBP kann ich den EBP in meinen Code setzen.
Das bringt mir aber nicht viel denn ESP liegt immernoch auf der ursprünglichen Rücksprungadresse.

Damit kann ich dann beim RET auch nicht in meinem Code landen...sondern mir nur den Stack zerschießen, sodass es in nem SEGFAULT endet.
 
Schwachsinn, es ist egal ob du denn SFP überschreibst oder nicht.(was du ja musst, sonst wärs kein BOF)

Dein Problem ist wahrscheinlich das du die addresse vom Shellcode falsch kalkuliert hast, und deswegen ein segmation fault kriegst.

Nochmal zur theorie.

SFP = der EBP vom alten Stackframe, du überschreibst ihn samt RET-Addr, EIP springt zu deinem Shellcode. code wird ausgeführt fertig.

Nochwas EBP != SFP

Der Wert vor der Rücksprungaddresse ist nicht EBP sondern nur eine ! KOPIE ! des alten, sodass der EBP nach RET wieder auf die richtige Position im alten Frame gesetzt werden kann.

mov ESP EBP sorgt nur dass die lokalen Vars der Funktion vom Stack wegkommen.
aber da du denn alten EBP ja nicht brauchst, sondern gleich der Shellcode augeführt wird ist das egal.

also lieber nochmal bisschen nachlesen. (ich glaub phrack 49 smashing the stack for fun and profit fast das ganz gut zussamen)

mfg prEs
 
Die Theorie is mir klar.

Mein Problem war welchen Wert ich für den SFP eintragen soll. Nach Möglichkeit sollte das ja eine Adresse sein, wo ich dann auch einen Stack für meinen Shellcode aufsetzen kann.
Sonst gibts ja wieder Zugriffsfehler.

Ich hab EBP und EIP jetz sozusagen Rücken an Rücken platziert. So wird in Richtung der hohen Adressen der Code ausgeführt und in Richtung der niedrigen kann der Stack gebaut werden.

Das funktioniert auch.
 
Du hast es immernoch nicht verstanden, es ist egal mit welchem Wert du den SFP überschreibst ,
weil nach dem LEAVE dein shellcode ausgeführt wird, wenn da ein Stackframe erstellt wird, wird der SBP mit mov EBP ESP eingestellt.
Es ist vollkommen egal ob der SFP richtig ist, weil sich der Kontext danach sowieso ändert, und dass hab ich jetzt in allen 3 Posts so geschrieben.

Also du musst die RET mit einem gültigen Wert überschreiben, der zb auf denn NOP-Sled oder direkt auf denn Shellcode zeigt, und das mit dem SFP vergiss erstmal, sind einfach nur 4 bytes die am anfang noch nicht so wichtig sind .


Also wenn du an der Addresse 0xbfffffe0 per Env-Variable denn Shellcode hast,
und du weist das du mit 24 bytes, die RET überschreibst,

kannst du entweder

./vuln `perl -e 'print "\xe0\xff\xff\xbf" x 6'`
oder eben
./vuln `perl -e 'print "A"x20 . "\xe0\xff\xff\xbf"'`
benutzen, und beides wird funktionieren, obwohl der Wert des SFP nun 0x41414141 ist, und wenn du mir das nicht glaubst dann probiers aus.

mfg pres
 
Um antworten zu können musst du eingeloggt sein.
Zurück
Oben