Comment écrire du code Auto-modifiable dans l'assemblage x86

Puisque vous écrivez un compilateur JIT, vous ne voulez probablement pas de code auto-modificateur , vous voulez générer du code exécutable au moment de l'exécution. Ce sont deux choses différentes. Le code auto-modificateur est le code qui est modifié après qu'il a déjà commencé à fonctionner . Le code auto-modificateur a une grande pénalité de performance sur les processeurs modernes, et serait donc indésirable pour un compilateur JIT.

Générer du code exécutable à l'exécution devrait être une simple question de mmap() mémoire avec les autorisations PROT_EXEC et PROT_WRITE. Vous pouvez également appeler mprotect () sur une mémoire que vous vous êtes allouée, comme dwelch l'a fait ci-dessus.

Vous pouvez également regarder des projets comme GNU Lightning . Vous lui donnez du code pour une machine de type RISC simplifiée, et elle génère dynamiquement la machine correcte.

Un problème très réel auquel vous devriez penser est l'interfaçage avec des bibliothèques étrangères. Vous aurez probablement besoin de prendre en charge au moins certains appels/opérations au niveau du système pour que votre machine virtuelle soit utile. Le Conseil de Kitsune est un bon début pour vous aider à penser aux appels au niveau du système. Vous utiliseriez probablement mprotect pour vous assurer que le la mémoire que vous avez modifiée devient légalement exécutable. (@KitsuneYMG)

Certains FFI permettant des appels à des bibliothèques dynamiques écrites en C devraient suffire à masquer beaucoup de détails spécifiques au système d'exploitation. Tous ces problèmes peuvent avoir un impact sur votre conception un peu, il est donc préférable de commencer à y penser tôt.

Un exemple un peu plus simple basé sur l'exemple ci-dessus. Merci à dwelch a beaucoup aidé.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/mman.h>

char buffer [0x2000];
void* bufferp;

char* hola_mundo = "Hola mundo!";
void (*_printf)(const char*,...);

void hola()
{ 
    _printf(hola_mundo);
}

int main ( void )
{
    //Compute the start of the page
    bufferp = (void*)( ((unsigned long)buffer+0x1000) & 0xfffff000 );
    if(mprotect(bufferp, 1024, PROT_READ|PROT_EXEC|PROT_WRITE))
    {
        printf("mprotect failed\n");
        return(1);
    }
    //The printf function has to be called by an exact address
    _printf = printf;

    //Copy the function hola into buffer
    memcpy(bufferp,(void*)hola,60 //Arbitrary size);


    ((void (*)())bufferp)();  

    return(0);
}

Je travaille sur un jeu auto-modifiable pour enseigner l'assemblage x86, et j'ai dû résoudre ce problème exact. J'ai utilisé les deux bibliothèques suivantes:

Assembleur FASM https://github.com/ZenLulz/Fasm.NET

UDIS86 désassembleur: https://github.com/vmt/udis86

Les Instructions sont lues avec Udis86, l'utilisateur peut les éditer en tant que chaîne, puis FASM est utilisé pour assembler les nouveaux octets. Ceux-ci peuvent être écrits en mémoire, et comme d'autres utilisateurs l'ont souligné, le la réécriture nécessite L'utilisation de VirtualProtect sous Windows ou mprotect sous Unix.

Les exemples de code sont un peu longs pour StackOverflow, donc je vais vous référer à un article que j'ai écrit avec des exemples de code:

Https://medium.com/squallygame/how-we-wrote-a-self-hacking-game-in-c-d8b9f97bfa99

Un repo Windows fonctionnel est ici (très léger):

Https://github.com/Squalr/SelfHackingApp

Ces exemples sont sur Windows, mais c'est juste un question de permuter VirtualProtect vers mprotect pour que cela fonctionne sous Linux

Ceci est écrit dans l'assemblage AT&T. Comme vous pouvez le voir à partir de l'exécution du programme, la sortie a changé en raison du code Auto-modificateur.

Compilation: gcc-M32 modifier.s modifier.c

L'option-m32 est utilisée car l'exemple fonctionne sur des machines 32 bits

Aessembly:

.globl f4
.data     

f4:
    pushl %ebp       #standard function start
    movl %esp,%ebp

f:
    movl $1,%eax # moving one to %eax
    movl $0,f+1  # overwriting operand in mov instuction over
                 # the new immediate value is now 0. f+1 is the place
                 # in the program for the first operand.

    popl %ebp    # standard end
    ret

C test-programme:

 #include <stdio.h>

 // assembly function f4
 extern int f4();
 int main(void) {
 int i;
 for(i=0;i<6;++i) {
 printf("%d\n",f4());
 }
 return 0;
 }

Sortie:

1
0
0
0
0
0

Je n'ai jamais écrit de code Auto-modifiable, bien que j'aie une compréhension de base de son fonctionnement. Fondamentalement, vous écrivez sur la mémoire les instructions que vous voulez exécuter puis sautez là. Le processeur interprète ces octets que vous avez écrits une instruction et (essaie) de les exécuter. Par exemple, les virus et les programmes anti-copie peuvent utiliser cette technique.
En ce qui concerne les appels système, vous aviez raison, les arguments sont passés via des registres. Pour une référence des appels système linux et leur argument il suffit de cocher ici.