# Lecture d’un fichier système via un fichier préprocesseur en C

En langage C, le **préprocesseur** est la première étape de la compilation. Il traite les directives comme `#include`, `#define` ou `#ifdef`, modifiant le code source avant sa compilation. Une fonctionnalité puissante – mais parfois détournée – consiste à inclure directement le contenu d’un fichier système via le préprocesseur, à l’aide de `#include`.

Ce write-up explique comment lire un fichier système via un fichier préprocesseur en C, avec exemples et mise en garde.

### **Start of the Chaos**

Dans l'image ci-dessous, nous pouvons observer la création d'un fichier **`secret.txt`** situé dans le dossier **`/home/hacksparo/Desktop`**. L'objectif de cette démonstration est de **lire ce fichier** en utilisant la compilation avec `gcc` et l'option `-E`.

L'option `-E` de `gcc` permet d'arrêter la compilation au stade du préprocesseur, ce qui signifie qu'elle affiche la sortie après que le préprocesseur ait traité les directives, sans compiler le code. Cela nous donne l'opportunité d'inclure le contenu de fichiers directement dans le code source à l'étape de prétraitement.


### **Création du script Hello World et insertion de `#include`**

Maintenant, nous allons créer un script simple en C, "Hello World". Ensuite, nous allons insérer une directive `#include` qui pointera vers notre fichier `secret.txt`, que nous avons précédemment créé dans le dossier **`/home/hacksparo/Desktop`**.

Le but ici est d'inclure directement le contenu de ce fichier dans notre code source pendant l'étape de prétraitement, avant même que le programme soit compilé.

Voici un exemple de code pour le script :

Une fois le script Hello World créé, nous allons utiliser le préprocesseur avec le flag `-E` pour voir le code après traitement des directives, comme l'inclusion de **`secret.txt`**.

### **The LOLLLLLLLLLLLLLL**

Maintenant, nous pouvons bien voir que le fichier **`secret.txt`** a été consulté et que son contenu est clairement visible dans le fichier de sortie **`init.i`** généré par le préprocesseur. Le contenu de **`secret.txt`** est inclus directement dans le code, et cela peut être observé dans le fichier **`init.i`**.

### **Le Pourqoui**

Bon, maintenant une question : pourquoi cela causerait-il un risque ? Je vais répondre.

Si nous créons une application permettant aux utilisateurs de compiler directement sur notre instance et de leur fournir le fichier **`init.i`** en sortie, cela peut poser un risque majeur. En effet, un utilisateur malintentionné pourrait exploiter cette fonctionnalité pour lire des fichiers sur notre instance.

Voici les risques spécifiques :

- **Accès non autorisé aux fichiers** : Un utilisateur pourrait inclure des fichiers sensibles en utilisant `#include`, comme des fichiers de configuration, des mots de passe, ou d'autres informations privées stockées sur le système.

- **Escalade de privilèges** : Un utilisateur ayant des privilèges limités pourrait potentiellement exploiter cette technique pour accéder à des fichiers système critiques ou sensibles, ce qui pourrait faciliter une escalade de privilèges.

L'utilisation de la commande `gcc -E` sans contrôle adéquat permet à un utilisateur de récupérer des données qu'il ne devrait pas avoir accès, ce qui représente un risque de sécurité grave.

---

**J'ai sommeil, je vais me coucher.**
_Signer : hacksparo_