Désactiver la protection de la stack sur Ubuntu pour un débordement de la memory tampon sans les drapeaux du compilateur C

Je voudrais essayer quelques codes shell et je veux désactiver les protections Linux.

Je sais que je pourrais comstackr en utilisant des drapeaux mais je sais qu'il existe une autre façon de désactiver ces protections en général, je ne me souviens tout simplement pas. Pouvez-vous m'aider?

    La protection de la stack est effectuée par le compilateur (ajoutez quelques données supplémentaires à la stack et rangez-en quelques-unes lors de l'appel, vérifiez la santé lors du return). Ne peut pas désactiver cela sans recomstackr. Cela fait partie du point, vraiment …

    Pour développer ce que vonbrand a (correctement, +1) dit, il y a deux parties à la protection de la stack de Linux.

    Stack canaris

    Stack canaries sont la fonction imposée par le compilateur vonbrand. Ceux-ci ne peuvent pas être désactivés sans recomstackr.

    Pour le prouver à vous-même et voir comment ils fonctionnent, prenez le code suivant:

    #include <stdio.h> #include <stdint.h> #include <stdlib.h> #include <ssortingng.h> int mybadfunction(char* a_bad_idea) { char what[100]; strcpy(what, a_bad_idea); printf("You passed %s\n", what); } int main(int argc, char** argv) { printf("Tralalalaala\n"); mybadfunction(argv[1]); } 

    gcc -fstack-protector -masm=intel -S test.c maintenant ( gcc -fstack-protector -masm=intel -S test.c ) en quelque chose de gnu comme il serait heureux d'assembler et de lire la sortie. Le point important est qu'à la sortie de la fonction mybadfunction , il y a ce petit morceau de code:

      mov edx, DWORD PTR [ebp-12] xor edx, DWORD PTR gs:20 je .L2 call __stack_chk_fail 

    Comme vous pouvez le deviner, cela prend un cookie [ebp-12] de [ebp-12] et le compare à la valeur à gs:20 . Ne correspond pas? Il appelle alors une fonction __stack_chk_fail dans la glibc qui tue votre programme là.

    Il y a des façons de contourner ce problème en termes d'écriture d'exploits, mais la manière simple de build un scénario de test shellcode est de comstackr votre programme avec -fno-stack-protector .

    Pages non exécutables

    Il y a d'autres considérations sur les systèmes Linux modernes. Si vous prenez le stub de test shellcode habituel:

     char buffer[] = {...}; typedef void (* func)(void); int main(int argc, char** argv) { func f = (func) buffer; f(); return 0; } 

    GCC / Linux moderne .rodata section .rodata du file PE en lecture seule sans autorisation d'exécution. Vous devez désactiver cela, ce qui peut être fait en utilisant l'exemple de code de ce blog . Idée de base: vous utilisez mprotect pour append les permissions que vous souhaitez aux pages dans lesquelles résident datatables shellcode.

    Piles non exécutables

    Si vous tentez de tester un scénario d'exploitation traditionnel, par exemple mon mauvais code ci-dessus, avec votre shellcode, vous devez également vous assurer que la stack est exécutable pour les cas simples. Le format de file PE contient un champ permettant de déterminer si la stack est exécutable – vous pouvez l'interroger et le contrôler avec execstack . Pour activer une stack exécutable, exécutez

     execstack -s /path/to/myprog 

    Cela peut être fait sur des programmes arbitraires sans nécessiter de recomstackr, mais ne désactivera pas automatiquement les canaris de stack car ceux-ci sont cuits lors de la compilation.

    Bonus ajouté: aslr:

    Pour désactiver cela, echo 0 > /proc/sys/kernel/randomize_va_space .

    Avez-vous juste dit à quelqu'un comment exploiter mon précieux pingouin?

    Non. Tout exploit doit fonctionner autour de la stack de canaris (très peu sortingvial) et soit find un programme avec execstack , soit le définir (autrement dit, il peut déjà exécuter des commands arbitraires) ou utiliser des techniques plus difficiles, programmation orientée return.