Linux find a string in a file, une astuce pour les audits de sécurité web

Imaginez la scène : une application web vulnérable, une base de données compromise, des données sensibles exposées comme des adresses emails ou numéros de cartes bancaires. Tout cela aurait pu être évité si une simple recherche de chaîne de caractères dans un fichier de configuration avait été effectuée. Les audits de sécurité web, bien que souvent perçus comme complexes, peuvent parfois révéler des failles béantes grâce à des techniques simples et efficaces, notamment en exploitant les puissants outils de recherche de Linux.

La sécurité des applications web est un enjeu majeur pour toutes les entreprises, petites ou grandes, avec des coûts moyens de violations de données s'élevant à 4,24 millions de dollars en 2021. Des audits réguliers sont indispensables pour identifier et corriger les vulnérabilités avant qu'elles ne soient exploitées par des acteurs malveillants. L'une des techniques les plus fondamentales et pourtant incroyablement puissantes est la recherche de chaînes de caractères spécifiques dans les fichiers de configuration et les fichiers sources, une méthode qui peut réduire le temps d'audit de 50% ou plus. Linux, avec ses outils en ligne de commande, offre des solutions robustes et automatisables pour cette tâche, permettant d'analyser des milliers de fichiers en quelques minutes. La combinaison des commandes `find` et `grep` constitue un atout majeur dans l'arsenal de tout professionnel de la sécurité, permettant de cibler des configurations non sécurisées, des mots de passes en clair, des clés API oubliées ou des fragments de code vulnérable. Nous allons explorer dans cet article comment cette combinaison permet de dénicher des vulnérabilités potentielles avec une efficacité redoutable, transformant des heures de travail manuel en quelques commandes simples.

Les fondamentaux: `find` et `grep` pour les débutants

Avant de plonger dans des scénarios d'audit de sécurité complexes, il est essentiel de comprendre les bases des commandes `find` et `grep`. Ces deux outils, présents sur la plupart des distributions Linux, offrent des fonctionnalités complémentaires pour la recherche de fichiers et de contenu. Maîtriser ces bases permet de construire des commandes plus élaborées et de les adapter à des besoins spécifiques, optimisant ainsi le processus d'audit de sécurité web. L'objectif est de transformer le processus de recherche d'éléments suspects en une tâche simple et automatisable, facilitant ainsi le travail des équipes de sécurité.

Introduction à `find`

La commande `find` est utilisée pour rechercher des fichiers et des répertoires dans un système de fichiers Linux, un outil indispensable pour localiser rapidement des fichiers de configuration spécifiques ou des répertoires de code source. Sa syntaxe de base est `find [chemin] [options] [critères]`. Le chemin indique le point de départ de la recherche, les options permettent de modifier le comportement de la commande, et les critères définissent les conditions que les fichiers doivent remplir pour être affichés.

Par exemple, pour trouver tous les fichiers nommés `config.ini` dans le répertoire courant, vous pouvez utiliser la commande `find . -name config.ini`. L'option `-name` spécifie le nom du fichier à rechercher. Pour trouver tous les fichiers de type fichier (et non des répertoires), vous pouvez utiliser `find . -type f`. L'option `-type` accepte différentes valeurs, comme `f` pour fichier, `d` pour répertoire, et `l` pour lien symbolique. Il est également possible d'utiliser l'option `-size` pour cibler des fichiers de taille spécifique, par exemple, trouver les fichiers de plus de 10 Mo avec `find . -type f -size +10M`.

Voici quelques options courantes de `find` :

• `-name` : Recherche par nom de fichier.
• `-type` : Recherche par type de fichier (f, d, l, etc.).
• `-mtime` : Recherche par date de modification (en jours), utile pour identifier les fichiers récemment modifiés.
• `-size` : Recherche par taille de fichier, permettant de cibler les fichiers volumineux ou suspects.
• `-print` : Affiche le résultat de la recherche (comportement par défaut).
• `-exec` : Exécute une commande sur chaque fichier trouvé, permettant d'intégrer `grep` pour une recherche plus approfondie.

Si vous souhaitez trouver tous les fichiers `.php` modifiés dans les dernières 24 heures, vous pouvez utiliser la commande `find . -name "*.php" -mtime -1`. La valeur `-1` après `-mtime` indique que la recherche doit porter sur les fichiers modifiés il y a moins d'un jour. La commande `find` permet d'effectuer des recherches très précises et ciblées dans l'arborescence des fichiers. L'efficacité de `find` réside dans sa capacité à filtrer rapidement de grands ensembles de fichiers, réduisant le temps de recherche de vulnérabilités potentielles. Le nombre de fichiers à analyser peut être réduit de 70% en utilisant correctement les options de `find`, ce qui permet d'économiser des ressources et du temps.

Introduction à `grep`

La commande `grep` est utilisée pour rechercher des chaînes de caractères dans un ou plusieurs fichiers, un outil crucial pour identifier des motifs spécifiques dans le code source ou les fichiers de configuration. Sa syntaxe de base est `grep [options] "chaîne" [fichier(s)]`. Elle affiche les lignes contenant la chaîne recherchée.

Par exemple, pour rechercher la chaîne `password` dans le fichier `config.txt`, vous pouvez utiliser la commande `grep "password" config.txt`. Pour rechercher la chaîne sans tenir compte de la casse (majuscules/minuscules), vous pouvez utiliser l'option `-i` : `grep -i "password" config.txt`. L'option `-v` permet d'afficher les lignes qui *ne* contiennent *pas* la chaîne recherchée, utile pour exclure des résultats non pertinents. L'option `-r` permet une recherche récursive dans un répertoire, analysant tous les fichiers du répertoire et de ses sous-répertoires.

Voici quelques options courantes de `grep` :

• `-i` : Recherche insensible à la casse, essentiel pour ignorer les variations de majuscules/minuscules.
• `-v` : Inverser la recherche (afficher les lignes qui ne contiennent pas la chaîne), permettant d'exclure des configurations spécifiques.
• `-r` : Recherche récursive dans un répertoire, assurant l'analyse complète de tous les fichiers.
• `-n` : Afficher le numéro de ligne avec chaque résultat, facilitant la localisation des vulnérabilités.
• `-w` : Rechercher des mots entiers uniquement, évitant les faux positifs et ciblant des configurations spécifiques.

Pour trouver toutes les lignes contenant le mot "password" (et non une partie d'un mot comme "my_password"), vous pouvez utiliser la commande `grep -w "password" config.txt`. Cette option est très utile pour éviter les faux positifs. La flexibilité de `grep` en fait un outil indispensable pour analyser les fichiers et identifier des informations spécifiques, réduisant le temps d'audit de 40% en éliminant les résultats non pertinents. La version GNU de grep, présente sur la majorité des distributions Linux, offre une compatibilité étendue avec les expressions régulières, permettant des recherches encore plus sophistiquées.

Combiner `find` et `grep`

La puissance de `find` et `grep` est décuplée lorsqu'elles sont combinées, créant un flux de travail automatisé pour l'audit de sécurité web. Le pipe (`|`) permet de rediriger la sortie d'une commande vers l'entrée d'une autre. Ainsi, on peut utiliser `find` pour trouver des fichiers et ensuite utiliser `grep` pour rechercher des chaînes spécifiques dans ces fichiers, une méthode qui permet de cibler rapidement des vulnérabilités potentielles dans un ensemble de fichiers. La combinaison de ces deux outils permet de créer des audits personnalisés et automatisés, réduisant le temps de travail manuel et augmentant la couverture de l'audit.

Il existe plusieurs façons de combiner `find` et `grep`. L'une d'elles est d'utiliser l'option `-exec` de `find` : `find [chemin] [options] -exec grep [options_grep] "chaîne" {} ;`. Une autre méthode, plus efficace, consiste à utiliser `find ... -print0 | xargs -0 grep ...`. La première méthode exécute `grep` une fois pour chaque fichier trouvé, ce qui peut être lent, surtout avec un grand nombre de fichiers. La deuxième méthode utilise `xargs` pour regrouper plusieurs fichiers trouvés par `find` et les passer à `grep` en une seule commande, ce qui est plus rapide et plus efficace. L'utilisation de `xargs` permet de réduire le temps d'exécution de l'audit de 60% ou plus.

La différence entre `-print0` et `-print` (l'option par défaut de `find`) réside dans la manière dont les noms de fichiers sont séparés. `-print` utilise des espaces, ce qui pose problème si un nom de fichier contient des espaces. `-print0` utilise un caractère nul ( `` ), qui n'est pas autorisé dans les noms de fichiers, ce qui évite les problèmes d'interprétation. De même, `xargs -0` s'attend à ce que les noms de fichiers soient séparés par des caractères nuls. Cette combinaison garantit un traitement correct des noms de fichiers, même s'ils contiennent des espaces ou d'autres caractères spéciaux. Cette nuance peut paraître technique, mais elle est cruciale pour éviter des erreurs lors de l'automatisation des audits. Par exemple, un fichier nommé "Configuration avec espaces.ini" serait correctement traité avec `-print0` et `xargs -0` mais pas avec `-print` et `xargs`.

Par exemple, pour trouver tous les fichiers `.php` contenant la chaîne `eval(` dans le répertoire courant et ses sous-répertoires, vous pouvez utiliser la commande `find . -name "*.php" -print0 | xargs -0 grep "eval("`. Il est impératif de bien comprendre le contexte de chaque résultat trouvé par `grep`. Une simple occurrence de `eval(` ne signifie pas nécessairement une vulnérabilité, mais elle doit être examinée attentivement. De même, la présence d'adresses IP dans des fichiers de configuration peut être légitime, comme une adresse de serveur DNS, mais elle peut aussi indiquer une configuration incorrecte ou une tentative d'accès non autorisé. La vigilance et l'analyse contextuelle sont donc essentielles pour interpréter correctement les résultats des audits de sécurité.

Audit de sécurité web avancé avec `find` et `grep`

Maintenant que nous avons les bases, voyons comment `find` et `grep` peuvent être utilisés pour identifier des vulnérabilités spécifiques dans les applications web. L'audit de sécurité web est un processus itératif qui consiste à rechercher des motifs de code ou de configuration qui pourraient potentiellement conduire à une exploitation malveillante. Il est crucial de comprendre les vulnérabilités les plus courantes et les chaînes de recherche associées, une connaissance qui permet de cibler efficacement les recherches et de gagner du temps.

Vulnérabilités courantes et chaînes de recherche associées

L'efficacité d'un audit de sécurité dépend de la connaissance des vulnérabilités et des signatures associées. Savoir quelles chaînes de caractères rechercher permet de cibler efficacement les recherches et d'identifier les problèmes potentiels. L'intégration de listes de chaînes de recherche pré-définies, basées sur des vulnérabilités connues, permet d'accélérer le processus d'audit et d'assurer une couverture maximale. Ces listes peuvent être mises à jour régulièrement pour tenir compte des nouvelles vulnérabilités et des nouvelles techniques d'attaque.

SQL injection

La SQL Injection est une vulnérabilité qui permet à un attaquant d'injecter du code SQL malveillant dans une requête de base de données. Cela peut permettre à l'attaquant de lire, modifier ou supprimer des données sensibles, compromettant l'intégrité et la confidentialité des informations stockées. Pour rechercher des potentielles vulnérabilités de SQL Injection, on peut rechercher des fonctions d'accès à la base de données qui ne sont pas correctement protégées contre l'injection de code, un point de contrôle crucial pour assurer la sécurité des applications web.

Les chaînes de recherche courantes incluent : `mysql_query`, `mysqli_query`, `PDO->query`, `prepare`, `execute`. Par exemple, la commande `find . -name "*.php" -print0 | xargs -0 grep -iE "mysql_query|mysqli_query|PDO->query"` permet de rechercher ces fonctions dans tous les fichiers `.php`. Il est ensuite crucial de vérifier si les données passées à ces fonctions sont correctement échappées ou paramétrées pour éviter l'injection de code SQL. La recherche d'échappements de données comme `mysqli_real_escape_string` ou `PDO::quote` est également importante, mais il faut vérifier que ces fonctions sont utilisées correctement et de manière cohérente. L'utilisation d'ORM (Object-Relational Mapping) peut également réduire le risque de SQL injection, car ils gèrent l'échappement des données automatiquement. Les entreprises peuvent réduire les risques de SQL Injection de 60% en utilisant des pratiques de développement sécurisées et des outils d'analyse statique de code.

Cross-site scripting (XSS)

Le Cross-Site Scripting (XSS) est une vulnérabilité qui permet à un attaquant d'injecter du code JavaScript malveillant dans une page web. Ce code peut être exécuté par le navigateur de l'utilisateur, ce qui peut permettre à l'attaquant de voler des cookies, de rediriger l'utilisateur vers un site malveillant, ou de modifier le contenu de la page web. La recherche de sorties non échappées est primordiale, car elle permet d'identifier les points d'entrée potentiels pour les attaques XSS.

Les chaînes de recherche courantes incluent : `echo`, `print`, `<script>`, `innerHTML`, `document.write`. Par exemple, la commande `find . -name "*.php" -o -name "*.js" -print0 | xargs -0 grep -iE "echo|print|