Come faccio a fare un esempio funzionante di un exploit "Dangling Pointers"? (o dove lo trovo online)

Question

Come faccio a fare un esempio funzionante di un exploit "Dangling Pointers"? (o dove lo trovo online)

#1 da (3 voti)
#2 da (1 voti)

2

Recentemente ho letto dei buffer overflow e dei puntatori penzolanti. Ho letto "Smashing the stack for fun and Profit" di Aleph1 e quel documento era molto chiaro e conciso nella spiegazione. Al contrario, quando cerco dei puntatori penzoloni, ottengo delle risorse su quello che sono. Ho anche trovato una presentazione di BlackHat su di esso e l'ho capito (non totalmente però). Offre una panoramica di alto livello su come funzionerebbe l'exploit. C'è un tipo di "fracassare la pila" di spiegazione dei puntatori penzolanti usando un programma C / C ++? O qualcuno potrebbe spiegare come sfruttare i puntatori penzolanti in un modo semplice che testo usando un mio codice?

c++ c exploit

posta Pervy Sage 26.06.2014 - 22:35

fonte

2 risposte

1

In C o C ++, un puntatore penzolante è ciò che ottieni (come programmatore) quando hai un puntatore per allocare dinamicamente la memoria, cancella / libera quella memoria, ma continua a usare il puntatore.

Il puntatore ora punta alla memoria non allocata e tentare di accedervi probabilmente manderà in crash il programma. Tuttavia, in determinate circostanze può accadere che la memoria venga riallocata a qualcosa di completamente diverso. Il puntatore ora è di nuovo valido, ma punta a dati a cui non dovrebbe puntare, come i dati a cui l'utente non deve accedere.

risposta data 26.06.2014 - 22:59

fonte

Leggi altre domande sui tag c++ c exploit

Come si mantiene l'autenticazione di base HTTP tra le pagine visualizzate? Utilità di bcrypt (UUIDv4 ())

score 3 · Accepted Answer

Ho appena scritto un esempio molto semplice per dimostrare una possibile forma di vulnerabilità legata al puntatore. Puoi eseguirlo direttamente e digitare "aaaaaaaaS" per raggiungere la dichiarazione dell'obiettivo. Spero che sarebbe utile.

int main(){

    char* data = (char *)malloc(32); // Assuming that the 9th char is critical...

    data[8] = 'L';

    printf("data buffer at address %x\n", data);

    /*  ...
     *  some complex program code here
     *  ...
     */
    free(data); //the data buffer could be accidentially freed.
    /*  ...
     *  some complex program code here
     *  ...
     */

    /* Here, the allocator could allocate the chunk of data buffer for the input buffer.
     * Whether this will happen depends on multiple factors (allocation algorithm,
     * the size of the buffer, etc.). For example, if you set the input buffer with 
     * size 64, this might not happen because the allocator will use a new chunk 
     * instead of reusing the old one.  
     */
    char* input = (char *)malloc(32);

    printf("input buffer at address %x\n", input);

    /* Assuming that the attacker can control the input. Now, the attacker can 
     * type aaaaaaaaS to write char 'S' to the critical space.  
     */
    scanf("%s", input); 

    /* The dangling pointer is used here to do a critical operation.
     * Note that this bug might be hard to find because it will  
     * almost never trigger a crash.
     */
    if(data[8] == 'S'){ 
        printf("Pwn!\n"); // This is the goal of the attacker
    }else{
        printf("Pew!\n");
    }    

    return 0;
}