¿Cómo hago un ejemplo funcional de un exploit de "Dangling Pointers"? (o donde lo encuentro en línea)

Acabo de escribir un ejemplo muy simple para demostrar una posible forma de vulnerabilidad de puntero colgante. Puede ejecutarlo directamente y escribir "aaaaaaaaS" para alcanzar la declaración del objetivo. Espero que sea de ayuda.

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;
}

En C o C ++, un puntero colgante es lo que usted (como programador) obtiene cuando tiene un puntero a la memoria asignada dinámicamente, borra / libera esa memoria, pero sigue usando el puntero.

El puntero ahora apunta a la memoria no asignada y tratar de acceder a ella probablemente bloqueará el programa. Sin embargo, bajo ciertas circunstancias, puede suceder que la memoria se reasigne a algo completamente diferente. El puntero ahora es repentinamente válido nuevamente, pero apunta a datos a los que no se supone que debe apuntar, como a los datos a los que el usuario no debe acceder.