Les Heap Overflow

L'objectif de cet article est de se servir d'un programme simple et faillible pour y introduire le concept du heap-based buffer overflow. N'y comprenant pas grand chose non plus de mon côté j'ai cru bon d'étudier ce sujet avec mon ami google, Phrack, exploit-db et quelques autre sources.
Je ne vais bien entendu pas réinventer la roue qui roule déjà très bien, il faut l'avouer :)
Ce qui est bien c'est qu'il s'agit bien là d'une faille type buffer overflow sauf qu'on ne cible pas nécessairement le pointeur d'exécution EIP comme dans ceux qui sont orientés stack et dont j'ai fait une petite description il y a quelques temps.
Pour le moment je vais rester très théorique étant donné l'avancée de mes recherches, puis plus dans le technique avec enfin un exemple comme il se doit.

Tout d'abords qu'est-ce qu'un Heap ?

C'est en fait un espace de stockage où un processus store des données dynamiquement.
Chaque processus alloue ou retire de la mémoire selon son besoin et pendant son exécution.
C'est tout comme une allocation d'un tableau dynamique en C++ par exemple.
Chaque Heap constitue un bloc dans une pile qui va de 0x00000000 à 0xFFFFFFFF et chaque autre allocations dans le programme sera allouée après le dernier bloc. Si un problème (comme un overflow) sur le premier survient, alors il est grandement possible qu'il déborde sur les autres.
Quand un Heap est créé deux pointeurs sont aussi automatiquement créés et pointent vers le premier espace mémoire libre dispo. Et à l'adresse vers laquelle ils pointent se trouvent 2 pointeurs vers leurs position.
Arf, j'ai perdu le fil ! Un petit dessin s'impose :

[0x00000000------------------------STACK-------------------------------------0xFFFFFFFF]
HeapAllocate() ---> Pointeurs A et B contenus dans FreeLists[0]  --> 0x00000005 <---- Pointeurs C et D qui pointent vers A et B dans FreeLists[0]
[0x00000000[HEAP -----STACK-----]0x00000005-----------STACK---------0xFFFFFFFF]

Quand une allocation se produit les pointeurs A et B se mettent à pointer vers le prochain bloc qui sera alloué et les deux autres pointeurs C et D vont pointer vers l'adresse de fin du bloc alloué en dernier.
Donc, à chaque allocation ou libération de mémoire ces 4 pointeurs seront changés dynamiquement dans une liste doublement chaînée.

En quoi réside le principe du Heap-based buffer overflow ?

Prenons le cas du malloc.
Si, lors de l'écriture d'un code il vous prend de vouloir faire un tableau dynamique ou autre, le malloc allouera automatiquement un bloc qu'on appelle un Chunk.
Chunk = Gros morceau en Français (oui je sais c'est pas très parlant)
Ce "gros morceau" est en fait composé de plusieurs parties dont, une petite pile de données où est stocké le buffer.

En fait, il existe deux types de chunk :
-Le chunk virtuellement alloué
-Le chunk libre.

Ce sont des structures au final d'après ce que j'ai pu en lire ICI.
Si un chunk est alloué il contient :
[l'adresse du chunk précédemment alloué]+[La taille de ses datas ainsi que 3 bits déjà alloués]

________
|                 |
|adresse    |
|_______ |
|                |
|                |
|Taille       |
|                |
|+ 0 0 0     | <== Ces trois Bits [A,M,P] prennent 1 ou 0 selon certaines conditions. Par exemple :
|_______|                    si le tas contient l'adresse d'un bloc précédemment alloué alors P=1

Si il y a débordement sur cette partie du Chunk alors il est possible de contrôler les pointeurs contenus dans cette fameuse double liste chaînée :) .                       
Du coup, possibilité de les faire pointer où on veut, et donc de pouvoir modifier le bon déroulement du programme et finalement se faire monter en privilèges entre autre.

Quelles sont les conditions qui doivent apparaitre pour pouvoir déborder sur un Heap ?

Maintenant que mes recherches sont faites sur les éléments du décors qui m'intéressaient et après nombre de remarque pertinente sur le fait qu'un article extrêmement complet sur Phrack existe pour donner l'exemple d'une exploitation, je ne vais pas m'embêter à faire une traduction bête et méchante :D


http://www.phrack.org/issues.html?issue=66&id=6 Si vous avez du courage, et que, comme moi vous vous
intéressez un temps soit peu à la sécurité ça devrait passer ! ;)
Je m'arrête donc ici pour mes recherches sur les Heap-based buffer overflow, surtout qu'au départ je voulais juste comprendre les grandes lignes ^^ et voila j'ai encore merdé !