Démonstration de la validation des entrées et de l'intégrité du code

Introduction

Dans ce laboratoire, vous explorerez deux concepts fondamentaux de sécurité : la validation des entrées (input validation) et l'intégrité du code (code integrity). La validation des entrées est la pratique consistant à s'assurer que toute entrée qu'un programme reçoit est sûre et bien formée avant d'être traitée. C'est une défense essentielle contre un large éventail d'attaques, y compris l'injection de commandes (command injection). L'intégrité du code implique de vérifier que le code de votre application n'a pas été altéré ou corrompu par une partie non autorisée.

Vous apprendrez ces concepts par une approche pratique. Premièrement, vous créerez un script shell simple qui est intentionnellement vulnérable à l'injection de commandes. Ensuite, vous exploiterez cette vulnérabilité pour comprendre le risque. Puis, vous sécuriserez le script en implémentant une désinfection appropriée des entrées (input sanitization). Enfin, vous apprendrez à utiliser des fonctions de hachage cryptographiques pour vérifier l'intégrité de votre script, garantissant qu'il n'a pas été falsifié.

Créer un script simple avec entrée utilisateur

Dans cette étape, vous allez créer un script Bash simple qui demande à l'utilisateur un nom de fichier, puis affiche des informations détaillées sur ce fichier à l'aide de la commande ls -l. Cette version initiale du script n'aura aucune vérification de sécurité.

Tout d'abord, utilisez l'éditeur nano pour créer un nouveau fichier nommé check_file.sh dans le répertoire ~/project.

nano ~/project/check_file.sh

Maintenant, ajoutez le code suivant au fichier. Ce script demandera un nom de fichier, lira l'entrée dans une variable nommée filename, puis exécutera ls -l sur ce nom de fichier en utilisant la commande eval. Notez que l'utilisation de eval avec une entrée utilisateur constitue une grave vulnérabilité de sécurité.

#!/bin/bash

echo "Please enter a filename to check:"
read filename
echo "Checking details for: $filename"
eval "ls -l $filename"

Appuyez sur Ctrl+X, puis sur Y, et enfin sur Entrée pour enregistrer le fichier et quitter nano.

Ensuite, vous devez rendre le script exécutable afin de pouvoir l'exécuter. Utilisez la commande chmod pour ajouter les permissions d'exécution.

chmod +x ~/project/check_file.sh

Maintenant, exécutons le script pour le voir en action. Nous utiliserons testfile.txt, qui a été créé pour vous dans l'environnement de laboratoire.

./check_file.sh

Le script vous demandera une entrée. Tapez testfile.txt et appuyez sur Entrée.

Please enter a filename to check:
testfile.txt
Checking details for: testfile.txt
-rw-rw-r-- 1 labex labex 0 Aug  4 15:19 testfile.txt

Vous avez créé et exécuté avec succès un script simple qui prend une entrée utilisateur. Dans la prochaine étape, vous verrez comment ce script peut être exploité.

Simuler une attaque basique par injection de commande

Dans cette étape, vous verrez comment le script créé à l'étape précédente est vulnérable à une attaque par injection de commande (command injection). L'injection de commande se produit lorsqu'un attaquant est capable d'exécuter des commandes arbitraires sur le système d'exploitation hôte via une application vulnérable.

Notre script est vulnérable car il utilise eval pour exécuter une commande qui inclut l'entrée utilisateur ($filename) sans vérifier au préalable si l'entrée est sûre. La commande eval traite la chaîne entière comme une commande à exécuter, ce qui la rend particulièrement dangereuse. Un attaquant peut exploiter cela en fournissant une entrée qui inclut des commandes shell supplémentaires.

Exécutons à nouveau le script.

./check_file.sh

Cette fois, lorsqu'on vous demande un nom de fichier, entrez la chaîne suivante. Le point-virgule (;) est un caractère spécial dans le shell qui sépare les commandes.

testfile.txt; whoami

Après avoir appuyé sur Entrée, vous verrez la sortie suivante :

Please enter a filename to check:
testfile.txt; whoami
Checking details for: testfile.txt; whoami
-rw-rw-r-- 1 labex labex 0 Aug  4 15:19 testfile.txt
labex

Remarquez ce qui s'est passé. Le script a d'abord exécuté ls -l testfile.txt comme prévu. Cependant, en raison du point-virgule et de l'utilisation de eval, le shell a ensuite exécuté la deuxième commande, whoami, qui a affiché le nom d'utilisateur actuel (labex). Cela démontre une injection de commande réussie. La commande eval a rendu cela possible en traitant l'intégralité de l'entrée comme du code exécutable. Un attaquant pourrait utiliser cette vulnérabilité pour exécuter des commandes beaucoup plus dangereuses.

Note : Si vous aviez utilisé ls -l $filename sans eval (comme dans la version originale), l'attaque n'aurait pas fonctionné car le shell aurait traité testfile.txt; whoami comme des arguments séparés pour ls, ce qui aurait entraîné des messages d'erreur tels que "cannot access 'testfile.txt;'" et "cannot access 'whoami'". La commande eval est ce qui rend l'injection de commande possible dans cet exemple.

Implémenter la validation des entrées pour prévenir les injections

Dans cette étape, vous allez modifier le script pour prévenir les attaques par injection de commande en désinfectant l'entrée utilisateur et en supprimant la commande dangereuse eval. La désinfection des entrées (input sanitization) est le processus de nettoyage ou de filtrage des entrées pour supprimer ou neutraliser les caractères potentiellement malveillants.

Notre stratégie sera de :

1. Supprimer la commande dangereuse eval et utiliser l'exécution directe de commandes avec un échappement approprié.
2. Vérifier si le nom de fichier entré ne contient que des caractères autorisés. Pour un nom de fichier typique, nous pouvons créer une liste blanche de caractères, tels que les lettres, les chiffres, les underscores, les tirets et les points. Nous rejetterons toute entrée contenant d'autres caractères, comme le point-virgule.

Ouvrez à nouveau le script check_file.sh avec nano.

nano ~/project/check_file.sh

Modifiez le script pour inclure une vérification de validation à l'aide d'une expression régulière. Remplacez le contenu existant par le code suivant :

#!/bin/bash

echo "Please enter a filename to check:"
read filename

## Input sanitization: only allow alphanumeric characters, underscores, hyphens, and dots.
if [[ "$filename" =~ ^[a-zA-Z0-9_.-]+$ ]]; then
  echo "Checking details for: $filename"
  ls -l "$filename"
else
  echo "Error: Invalid filename. Malicious input detected."
fi

Les changements clés sont :

1. Suppression de la commande dangereuse eval.
2. Ajout d'un échappement approprié autour de "$filename" dans la commande ls.
3. L'instruction if avec la validation des entrées. L'expression [[ "$filename" =~ ^[a-zA-Z0-9_.-]+$ ]] vérifie si la variable filename ne contient que les caractères de l'ensemble spécifié, du début (^) à la fin ($).

Appuyez sur Ctrl+X, Y, puis Entrée pour enregistrer les modifications.

Maintenant, essayons à nouveau la même attaque. Exécutez le script :

./check_file.sh

Entrez l'entrée malveillante testfile.txt; whoami et appuyez sur Entrée.

Please enter a filename to check:
testfile.txt; whoami
Error: Invalid filename. Malicious input detected.

Comme vous pouvez le constater, le script détecte maintenant les caractères invalides et affiche un message d'erreur au lieu d'exécuter la commande malveillante whoami. L'attaque est ainsi empêchée avec succès.

Vérifier l'intégrité du script avec le hachage

Dans cette étape, vous apprendrez comment vérifier l'intégrité de votre script à l'aide d'un hachage cryptographique. Cela garantit que le script n'a pas été modifié ou altéré par un attaquant après que vous l'ayez sécurisé. Nous utiliserons l'utilitaire sha256sum, qui calcule un hachage SHA-256.

Tout d'abord, générons un hachage pour notre script sécurisé check_file.sh et sauvegardons-le dans un fichier. Ce fichier servira de notre signature "connue et valide".

sha256sum ~/project/check_file.sh > ~/project/check_file.sha256

Cette commande calcule le hachage SHA-256 de check_file.sh et redirige la sortie vers un nouveau fichier nommé check_file.sha256. Visualisons le contenu de ce fichier.

cat ~/project/check_file.sha256

Vous verrez une longue chaîne de caractères suivie du nom du fichier. Cette chaîne est le hachage unique de votre script.

e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  /home/labex/project/check_file.sh

(Note : Votre valeur de hachage sera différente.)

Maintenant, simulons une modification non autorisée. Nous allons ajouter un simple commentaire à la fin du script. Même un petit changement comme celui-ci devrait altérer complètement le hachage.

echo "## A harmless comment" >> ~/project/check_file.sh

Le script a maintenant été modifié. Pour vérifier son intégrité, nous pouvons utiliser sha256sum avec l'option -c (check), qui lit le hachage de notre fichier de signature et le compare au hachage actuel du script.

sha256sum -c ~/project/check_file.sha256

La commande signalera un échec car le fichier a été modifié.

/home/labex/project/check_file.sh: FAILED
sha256sum: WARNING: 1 computed checksum did NOT match

Cela confirme que l'intégrité du script a été compromise. Cette technique est essentielle pour garantir que le code que vous exécutez est le code auquel vous faites confiance.

Résumé

Félicitations pour avoir terminé ce laboratoire ! Vous avez acquis une expérience pratique de deux principes de sécurité essentiels.

Vous avez appris à identifier et à prévenir les vulnérabilités d'injection de commande en implémentant la désinfection des entrées. En validant les entrées utilisateur par rapport à une liste blanche de caractères autorisés, vous avez sécurisé avec succès un script shell vulnérable.

Vous avez également appris à garantir l'intégrité du code à l'aide de hachages cryptographiques. En générant une somme de contrôle SHA-256 pour votre script, vous avez pu créer une signature vérifiable capable de détecter toute modification non autorisée.

Ces compétences sont fondamentales pour écrire du code sécurisé et maintenir la sécurité de tout système.