House of Rabbit

Reading time: 5 minutes

Exigences

1. Capacité à modifier le pointeur fd du fast bin ou sa taille : Cela signifie que vous pouvez changer le pointeur avant d'un chunk dans le fastbin ou sa taille.
2. Capacité à déclencher malloc_consolidate : Cela peut être fait en allouant un grand chunk ou en fusionnant le chunk supérieur, ce qui force le tas à consolider les chunks.

Objectifs

1. Créer des chunks qui se chevauchent : Avoir un chunk qui se chevauche avec un autre, permettant d'autres manipulations du tas.
2. Forger de faux chunks : Tromper l'allocateur pour qu'il traite un faux chunk comme un chunk légitime lors des opérations sur le tas.

Étapes de l'attaque

POC 1 : Modifier la taille d'un chunk de fast bin

Objectif : Créer un chunk qui se chevauche en manipulant la taille d'un chunk de fastbin.

• Étape 1 : Allouer des Chunks

unsigned long* chunk1 = malloc(0x40);  // Allocates a chunk of 0x40 bytes at 0x602000
unsigned long* chunk2 = malloc(0x40);  // Allocates another chunk of 0x40 bytes at 0x602050
malloc(0x10);                          // Allocates a small chunk to change the fastbin state

Nous allouons deux morceaux de 0x40 octets chacun. Ces morceaux seront placés dans la liste des fast bins une fois libérés.

• Étape 2 : Libérer les morceaux

free(chunk1);  // Frees the chunk at 0x602000
free(chunk2);  // Frees the chunk at 0x602050

Nous libérons les deux morceaux, les ajoutant à la liste fastbin.

• Étape 3 : Modifier la taille du morceau

chunk1[-1] = 0xa1;  // Modify the size of chunk1 to 0xa1 (stored just before the chunk at chunk1[-1])

Nous changeons les métadonnées de taille de chunk1 à 0xa1. C'est une étape cruciale pour tromper l'allocateur lors de la consolidation.

• Étape 4 : Déclencher malloc_consolidate

malloc(0x1000);  // Allocate a large chunk to trigger heap consolidation

Allouer un grand morceau déclenche la fonction malloc_consolidate, fusionnant de petits morceaux dans le fast bin. La taille manipulée de chunk1 provoque un chevauchement avec chunk2.

Après la consolidation, chunk1 chevauche chunk2, permettant une exploitation supplémentaire.

POC 2 : Modifier le pointeur fd

Objectif : Créer un faux morceau en manipulant le pointeur fd du fast bin.

• Étape 1 : Allouer des morceaux

unsigned long* chunk1 = malloc(0x40);  // Allocates a chunk of 0x40 bytes at 0x602000
unsigned long* chunk2 = malloc(0x100); // Allocates a chunk of 0x100 bytes at 0x602050

Explication : Nous allouons deux morceaux, un plus petit et un plus grand, pour préparer le tas pour le faux morceau.

• Étape 2 : Créer un faux morceau

chunk2[1] = 0x31;  // Fake chunk size 0x30
chunk2[7] = 0x21;  // Next fake chunk
chunk2[11] = 0x21; // Next-next fake chunk

Nous écrivons de fausses métadonnées de chunk dans chunk2 pour simuler des chunks plus petits.

• Étape 3 : Libérer chunk1

free(chunk1);  // Frees the chunk at 0x602000

Explication : Nous libérons chunk1, l'ajoutant à la liste fastbin.

• Étape 4 : Modifier fd de chunk1

chunk1[0] = 0x602060;  // Modify the fd of chunk1 to point to the fake chunk within chunk2

Explication : Nous changeons le pointeur avant (fd) de chunk1 pour qu'il pointe vers notre faux chunk à l'intérieur de chunk2.

• Étape 5 : Déclencher malloc_consolidate

malloc(5000);  // Allocate a large chunk to trigger heap consolidation

Allouer à nouveau un gros morceau déclenche malloc_consolidate, qui traite le faux morceau.

Le faux morceau devient partie de la liste fastbin, en faisant un morceau légitime pour une exploitation ultérieure.

Résumé

La technique House of Rabbit implique soit de modifier la taille d'un morceau fast bin pour créer des morceaux qui se chevauchent, soit de manipuler le pointeur fd pour créer des morceaux factices. Cela permet aux attaquants de forger des morceaux légitimes dans le tas, permettant diverses formes d'exploitation. Comprendre et pratiquer ces étapes améliorera vos compétences en exploitation de tas.