[ASM] Prologue Epilogue ou comment récupérer sa stack

[Junky]

Bonjour,

Bon je me mets doucement à l'ASM afin de pouvoir joujouter avec les crackme.
Comme souvent la première chose que l'on apprend c'est le fameux 'Hello world' mais il ne s'agirat pas de lui dans ce petit thread.

J'ai dans l'idée de faire un prog ASM qui aura comme fonction de convertir des chaines de char en hexa.

Code :

The Game
#en
\x54\x68\x65\x20\x47\x61\x6d\x65

Le programme se lancera de la sorte:

Code :

./app The Game

Donc il devra récupérer les arguments et les transaltes correctement.

En parmant un peu sur IRC, aaSSffxxx m'a parlé de 'prologue'. Ne connaissant pas j'ai du RTFM un peu.

So en cherchant, il s'avère que ce Proloque n'est qu'en faite une 'nouvelle' stack qui n'effectura aucun chagement sur la stack actuelle. Le prologue est suivi d'un Epilgue qui remet la stack en état après un 'call'

Bref un exemple sera le mieux.

Code ASM :


;on déclare les chaines que nous désirons afficher
section .data
str1: db "Chaine 1", 0xa
str2: db "Chaine 2", 0xa

section .text
global _start

_start:
  ;déclaration d'un nouvelle stack.
  ;celui-ci n'est pas obligatoire, mais je pense (je me trompe peut-être)
  ;qu'il est mieux de commencer avec une stack propre neuve.
  push ebp
  mov ebp, esp
 
  ;alors ici on push sur la pile notre str1
  ;afin de voir si on peut la récupérer après
  ;notre fonction
  push str1

  ; on appel notre fonction pour afficher la str2
  call aff_str2

  ;normalement ici on retrouve notre stack d'avant le call
  ;donc comme nous avons push au préalable str1, elle doit
  ;se trouver au dessus de la stack donc on la pop dans ecx

  pop ecx
  mov eax, 4
  mov ebx, 1
  mov edx, 9
 
  int 80h
  call exit

aff_str2:
  ;le fameux prologue qui nous permet de travailler
  ;avec une nouvelle stack bien fraiche
  push ebp
  mov ebp, esp

  ;on push str2 sur la pile et on la pop dans ecx
  ; j'aurai très bin pu faire un
  ;mov ecx, str2
  ;mais on travaille avec notre stack neuve.
  push str2
  pop ecx
  mov eax, 4
  mov ebx, 1
  mov edx, 9
  int 80h

  ;alors ici si j'ai ben compris, c'est l'épilogue
  ;le leave permet de récupérer l'ancienne stack
  ;et le leave équivaut a
  ;mov esp, ebp
  ;pop ebp
  leave
  ret

exit:
  mov eax, 1
  xor ebx, ebx
  int 80h

 

Et pour montrer que tout ceci fonctionne voici l'output:

Code BASH :


0 ✓ silentd@G3nt00 ~/work/ASM $ nasm -f elf prolog.asm -o prolog.o
0 ✓ silentd@G3nt00 ~/work/ASM $ ld -I /lib/ld-linux.so.2 -m elf_i386 -s -o prolog prolog.o -lc
0 ✓ silentd@G3nt00 ~/work/ASM $ ./prolog
Chaine 2
Chaine 1
 

On s'appercoit donc bien qu'a la sortie de notre 'call aff_str2', nous récupérons notre 'ancienne' stack.

Voici une première expérience.

N'hésitez pas a faire des remarques. Débutant + ou - en ASM, j'ai surement dit/fait des choses pas bien...

Junky,

[gruik]

effectivement c'est mieux/plus propre de travailler dans une nouvelle stack frame, le prologue sert précisément à ça, créer une nouvelle stack frame ("cadre de pile" en bon françois, c'est néanmoins assez parlant je trouve), en sauvegardant le pointeur de base précédent (le début de la frame précédente donc) et en mettant le pointeur de base au sommet de la pile (esp)
c'est un peu comme pour construire une tour, on pose un échafaudage, on remplit/construit dans l’échafaudage, on déplace l'échafaudage vers le haut et ainsi de suite...

on a l'habitude dans la foulée de soustraire la taille de la nouvelle pile ensuite du pointeur de pile (sub esp, xyz) de manière à allouer une pile en bonne et due forme

on manipule alors les données à travers des mov [ebp+toto] (...), tandis que lorsqu'on push une valeur, on empile la valeur à l'adresse d'esp qu'on incrémente, faisant donc grandir la pile, et inversément avec le pop

l'épilogue comme tu l'as dit c'est juste l'opération inverse, l'instruction leave se substituant finalement au combo mov esp, ebp; pop ebp;

[octarin]

J'ai fait l'implémentation assembleur de ton projet de programme qui affiche
l'équivalent hexadécimal d'une chaine de caractère passée en argument.

De plus, une astuce: lorsque tu codes en assembleur, tu peux parfaitement
utiliser des fonctions de la libc, ce qui facilite le débuggage, nottament pour
les fonctions d'entrée-sortie, qui sont fort utiles et qui remplacent les appels
systèmes, peu pratiques à manipuler.

Code ASM :


;
; nasm -f elf32 -o str2hex.o str2hex.nasm
; gcc -m32 -o str2hex str2hex.o
;

section .data

hexasym db "0123456789abcdef"
hexaprefix db "\x"
hexaspace db "20"

section .bss

buf resb 50000

section .text

extern puts
global main

main:
    push ebp
    mov ebp, esp

    mov ebx, 1          ; on initialise le compteur de boucle de manière à ne pas afficher le nom du programmme
    mov esi, buf        ; le pointeur sur la chaine de sortie

    .argloop:

        mov eax, dword [ebp + 0xc]
        mov eax, dword [eax + 4 * ebx]    ; eax contient l'adresse de l'argument courant

        test eax, eax                    
        jz .end                           ; On arrête si argv[ebx] == NULL

        call str2hex                      ; ebx n'est pas modifié, esi pointe sur la fin de la chaine ce qui
                                          ; permet de concaténer les arguments entre eux

        inc ebx
        jmp .argloop

    .end:
    push buf
    call puts                             ; affiche la chaine de sortie

    mov eax, 0
    leave
    ret

; Notre fonction pour afficher les strings en hexadécimal
; eax: adresse de la string
; ebx: si supérieur à un entraine l'ajout d'un séparateur (un espace)
str2hex:
    cmp ebx, 1
    je .carloop

    ; ebx > 1 => on rajoute un espace
    mov edx, dword [hexaprefix]     ;hexaprefix+hexaspace
    mov dword [esi], edx
    add esi, 4

    .carloop:

        xor edx, edx

        mov dl, byte [eax]          ; dl contient le caractère
        test dl, dl
        jz .end

        mov word [esi], '\x'
        add esi, 2                  ; écrit "\x" avant chaque nombre en hexa

        mov ecx, edx

        ; 4 bits de poids fort
        shr dl, 4
        and dl, 0xf
        mov dl, byte [hexasym + edx]
        mov byte [esi], dl
        inc esi

        ; 4 bits de poids faible
        mov dl, cl
        and dl, 0xf
        mov dl, byte [hexasym + edx]
        mov byte [esi], dl
        inc esi

        inc eax                     ; on passe au caractère suivant
        jmp .carloop

    .end:


    mov byte [esi], 0               ; rajout d'un octet nul à la fin du buffer de manière à le rendre affichable par puts

    ret