Contourner le 'Sefmentation Fault'

Bonjour,

j’aimerai faire un programme qui lit la RAM à partir d’un endroit. Quelque sorte du genre :

1
2
3
4

int * pnt;
for(int i=0; i<1000; i++){
    printf("%c",*(pnt++));
}

Évidemment, j’obtiens un SegFault. Question : est-il possible d’executer ce programme de tel sorte à ce que l’OS lui permette cela ? Je suis sous Linux.

Merci d’avance !

Merci bien, je vais explorer ca !

pourquoi tu veux faire ça ?

Curiosité, pour commencer.

Je me permets d’un peu d’auto-publicité:

J’ai une erreur 403 quand je clique le lien …

J’ai une erreur 403 quand je clique le lien …

https://zestedesavoir.com/articles/97/introduction-a-la-retroingenierie-de-binaires/

Merci Hugo, j’avais attrapé l’adresse privée du contenu, visiblement…

Edit : curiosité, bien.

Tu peux commencer par récupérer de manière intelligente une adresse mémoire qui correspond à une position dans la pilce d’exécution et, selon l’architecture cible sur laquelle ton binaire est compilé, faire un masque pour aligner les adresses mémoire jusqu’à tomber sur ton en-tête ELF.

Pour éviter de te faire jeter par un segfault, tu pourrais écrire un handler de signal qui fait que ton programme ignore les accès invalides en lecture et continue de scanner la mémoire. Mmmh… Je vais essayer de te faire un PoC. Ça n’aura pas d’intérêt mais ça sera un début de piste.

C’est encore moi !

J’ai fait un PoC inutile qui scanne sa propre mémoire jusqu’à trouver le mot magique qui indique qu’on a un ELF. Tu peux me dire ce que tu obtiens sur ta machine ?

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <linux/elf.h>

void sigsegv_handler(int signal);
uint64_t* pointer = NULL; // Our pointer to browse memory

int main(int argc, const char* argv[])
{
    signal(SIGSEGV, sigsegv_handler);

    pointer = (uint64_t*)main; // Why not? :P
    printf("[*] main is at %p\n", main);

    // Align the address
    pointer = (uint64_t*)((uint64_t)(pointer) & 0xfffffffffffffff0);
    printf("[*] Align address is %p\n", pointer);

    while(pointer != NULL && memcmp(pointer, ELFMAG, sizeof(uint32_t)))
    {
        pointer--;
    }

    printf("[!] Elf header is at %p\n", pointer);

    return EXIT_SUCCESS;
}


void sigsegv_handler(int signal) {
    printf("Invalid read at %p. Skipping.\n", pointer);
}

Chez moi :

1
2
3
4

ge0@ventari /tmp » gcc -o autoscan autoscan.c
ge0@ventari /tmp » ./autoscan 
[*] main is at 0x5555555546da
[!] Elf header is at 0x555555554000

Si tu affiches la mémoire à 0x555555554000, tu y trouveras la valeur de ELFMAG telle que définie ici : https://github.com/torvalds/linux/blob/master/include/uapi/linux/elf.h#L342

J’ai lancé le PoC en désactivant l’ASLR sur mon système, mais en l’activant ça ne change rien, c’est juste les bits de poids fort des adresses qui changent aléatoirement à chaque exécution pour des raisons de sécurité.

À voir ce que tu veux vraiment faire…