Exploitation du Dirty Pipe du noyau Linux (Bogue logique)

par : Antonius (w1sdom)
https://www.bluedragonsec.com
https://github.com/bluedragonsecurity

Dirty Pipe (CVE-2022-0847) est l'une des vulnérabilités de sécurité les plus importantes dans le noyau Linux 5.8 – 5.15.24, découverte par Max Kellermann en 2022. Cette vulnérabilité permet aux utilisateurs ordinaires (sans privilèges spéciaux) d'écraser des données dans des fichiers qui devraient être en lecture seule. Comprendre les concepts de base

Avant de discuter de Dirty Pipe en détail, voici quelques concepts internes du noyau Linux qui doivent être compris :

1. Pagination
La pagination est un mécanisme de gestion de la mémoire dans le noyau Linux où le système mémoire divise la mémoire physique en petits blocs de taille fixe appelés cadres de page (page frames), et la mémoire virtuelle est divisée en blocs de même taille appelés pages. Ce mécanisme permet au noyau de mapper l'espace d'adressage virtuel des processus vers la mémoire physique de manière non séquentielle, ce qui est crucial pour l'efficacité et la sécurité des systèmes modernes.

2. Page (Mémoire virtuelle)
Sous Linux, une page est la plus petite unité de gestion de la mémoire physique manipulée par le noyau. Analogie : la RAM est comme un livre géant. Une page est une feuille de papier dans ce livre. Le noyau ne déplace pas les données bit par bit, mais feuille par feuille (page par page). Généralement, sur les architectures de systèmes modernes (comme x86_64), la taille standard d'une page est de 4 Ko (4096 octets).

3. Cache de pages
C'est une partie cruciale. Linux ne lit pas les fichiers directement depuis le disque à chaque fois car c'est lent. Le noyau copie le contenu des fichiers dans la RAM, appelé le Cache de pages.

• Lorsque nous lisons un fichier, le noyau le charge dans le cache de pages.
• Si un autre processus veut lire le même fichier, le noyau fournit seulement une référence à la page qui existe déjà dans cette mémoire.

Le cache de pages réside dans l'espace noyau.

4. Pipe Buffer
Le tube (pipe) est un mécanisme de communication inter-processus (IPC). En interne, le noyau gère les tubes à l'aide de la structure de données pipe_inode_info. Les données à l'intérieur d'un tube sont stockées dans un « tampon » appelé Pipe Buffer.

• Tampon circulaire : Le noyau utilise une structure circulaire (anneau) pour gérer ce tampon. Un tampon circulaire est une structure de données qui utilise un seul tableau de taille fixe comme si sa fin était reconnectée à son début. Cela crée un flux de données qui « tourne » indéfiniment.
• Drapeaux : Chaque tampon possède des attributs ou « drapeaux » qui déterminent son comportement (par exemple, si le tampon peut être fusionné).

Le Pipe Buffer réside dans l'espace noyau.

5. Drapeau de Pipe Buffer (PIPE_BUF_FLAG_CAN_MERGE)
Le drapeau PIPE_BUF_FLAG_CAN_MERGE a été introduit dans le noyau Linux version 5.8. C'est là que se trouve la vulnérabilité principale. Le drapeau nommé PIPE_BUF_FLAG_CAN_MERGE.

• Sa fonction : Indique au noyau que les nouvelles données écrites dans le tube peuvent être fusionnées dans un tampon existant.
• Le problème : Avant le correctif Dirty Pipe, le noyau n'effaçait pas correctement (réinitialisait) ce drapeau lors de l'exécution de splice().

6. Splice
splice() est un appel système pour déplacer des données entre deux descripteurs de fichier sans copier les données entre l'espace noyau et l'espace utilisateur. Ceci est souvent appelé un mécanisme de zéro-copie. L'appel système splice() est le « acteur principal » de Dirty Pipe :

• Au lieu de copier physiquement les données, splice() effectue une optimisation en faisant pointer le Pipe Buffer directement vers la page dans le cache de pages.
• Cela signifie que le tube ne contient pas une copie des données du fichier, mais seulement un « pointeur » vers la mémoire physique du fichier.

7. Copie sur écriture (CoW)
Le mécanisme de copie sur écriture (CoW) est une stratégie d'optimisation de gestion de la mémoire utilisée par le noyau Linux pour retarder la copie des données jusqu'à ce qu'elle soit absolument nécessaire. La relation entre la copie sur écriture (CoW) et l'exploit Dirty Pipe (CVE-2022-0847) concerne la manière dont un petit bogue dans le noyau Linux « trompe » avec succès le mécanisme CoW, permettant d'écrire des données dans des fichiers qui devraient être en lecture seule.

8. Page sale
Une page sale est une page mémoire en RAM qui a été modifiée par une application, mais les modifications n'ont pas encore été réécrites sur le stockage secondaire (tel qu'un SSD ou un disque dur).

Analyse de la vulnérabilité Dirty Pipe

Dirty Pipe est un type de bogue logique dans la gestion des Pipe Buffers du noyau Linux 5.8 au noyau Linux 5.15.24. Le problème principal réside dans le mécanisme de tube (canal de communication inter-processus) et la manière dont le noyau gère le cache de pages (mémoire qui stocke les copies des données du fichier provenant du disque). Le problème central est un bogue dans le drapeau PIPE_BUF_FLAG_CAN_MERGE.

Le problème principal réside dans l'incapacité du noyau à réinitialiser correctement ce drapeau (bogue logique). Voici l'analyse du code : Dans les fonctions copy_page_to_iter_pipe et push_to_pipe du noyau Linux avant la version 5.16.11, lors des opérations splice, le noyau prépare la structure pipe_buffer mais oublie de nettoyer le membre .flags.

Structure de code vulnérable :

// Emplacement du problème : fs/pipe.c ou include/linux/pipe_fs_i.h
struct pipe_buffer {
    struct page *page;
    unsigned int offset, len;
    const struct pipe_buf_operations *ops;
    unsigned int flags; // <--- CE DRAPEAU N'EST PAS RÉINITIALISÉ
    unsigned long private;
};

Code avant le correctif (vulnérable) :

// lib/iov_iter.c - Avant le correctif CVE-2022-0847
static size_t copy_page_to_iter_pipe(struct page *page,
    size_t offset, size_t bytes, struct iov_iter *i) {
    // ---------snip-----------
    struct pipe_buffer *buf = &pipe->bufs[head & mask];