Chiffrer des fichiers avec OpenSSL

Introduction

Dans ce laboratoire, vous apprendrez à utiliser OpenSSL pour le chiffrement et le déchiffrement de fichiers, une compétence essentielle en cybersécurité. Vous allez pratiquer la génération de clés symétriques et l'application du chiffrement AES pour protéger les données sensibles grâce à des exercices pratiques.

Ce laboratoire vous guidera tout au long de l'installation d'OpenSSL, de la création de fichiers de test et de la réalisation de cycles complets de chiffrement-déchiffrement. Cette expérience pratique vous aidera à comprendre les techniques fondamentales de protection des données utilisées dans les applications du monde réel.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL wireshark(("Wireshark")) -.-> wireshark/WiresharkGroup(["Wireshark"]) wireshark/WiresharkGroup -.-> wireshark/decrypt_ssl_tls("Decrypting SSL/TLS") subgraph Lab Skills wireshark/decrypt_ssl_tls -.-> lab-549935{{"Chiffrer des fichiers avec OpenSSL"}} end

Installer OpenSSL

Dans cette étape, vous allez installer OpenSSL, qui est un puissant ensemble d'outils pour implémenter des communications sécurisées. OpenSSL fournit des fonctions cryptographiques essentielles que nous utiliserons pour chiffrer et déchiffrer des fichiers plus tard dans ce laboratoire. Il est largement utilisé pour sécuriser la transmission et le stockage des données.

Avant de commencer, il est important de comprendre qu'OpenSSL est généralement inclus par défaut dans la plupart des distributions Linux. Cependant, nous allons parcourir le processus d'installation pour vous assurer que vous avez la bonne version et tous les composants nécessaires. Voici ce que nous allons faire :

Tout d'abord, nous devons mettre à jour la liste des paquets. Cela permet à votre système de connaître les dernières versions de logiciels disponibles :
```
sudo apt update
```
Maintenant, nous allons installer OpenSSL. Le drapeau -y confirme automatiquement l'installation, vous évitant d'avoir à taper 'yes' pendant le processus :
```
sudo apt install openssl -y
```
Après l'installation, vérifions que cela a fonctionné en vérifiant la version. Cette commande montre quelle version d'OpenSSL est actuellement active sur votre système :
```
openssl version
```
Vous devriez voir une sortie similaire à :
```
OpenSSL 3.0.2 15 Mar 2022 (Library: OpenSSL 3.0.2 15 Mar 2022)
```
Enfin, nous allons vérifier le menu d'aide. Cela affiche toutes les commandes OpenSSL disponibles et confirme que l'installation fonctionne correctement :
```
openssl help
```
La sortie de l'aide vous montre les diverses opérations cryptographiques que OpenSSL peut effectuer, que nous explorerons dans les étapes suivantes de ce laboratoire.

Créer un fichier d'exemple

Dans cette étape, vous allez créer un simple fichier texte qui servira de données de test pour les exercices de chiffrement et de déchiffrement. Travailler avec un fichier texte connu permet de vérifier que notre processus de chiffrement fonctionne correctement, car nous pouvons facilement comparer le contenu original et le contenu déchiffré.

Commençons par créer ce fichier d'exemple dans votre répertoire de projet. Nous allons utiliser l'éditeur de texte nano, qui est convivial pour les débutants, mais vous pouvez utiliser n'importe quel éditeur de texte avec lequel vous êtes à l'aise.

Tout d'abord, accédez à votre répertoire de projet. Cela permet de garder tous vos fichiers organisés en un seul endroit :
```
cd ~/project
```
Maintenant, créez et ouvrez un nouveau fichier appelé sample.txt en utilisant nano :
```
nano sample.txt
```
Lorsque nano s'ouvre, vous verrez un espace d'édition vide. Tapez exactement les deux lignes suivantes :
```
This is a sample text file for encryption testing.
LabEx Cybersecurity Lab - AES Encryption Demo.
```
Pour enregistrer votre travail dans nano :
- Appuyez sur Ctrl+O (la lettre O, pas le zéro) pour "Écrire" (enregistrer) le fichier
- Appuyez sur Entrée pour confirmer le nom de fichier sample.txt
- Appuyez sur Ctrl+X pour quitter l'éditeur
Vérifions que le fichier a été créé correctement en affichant son contenu :
```
cat sample.txt
```
Le terminal devrait afficher exactement les deux lignes que vous avez saisies. Si quelque chose semble différent, vous devrez peut-être éditer le fichier à nouveau.
Enfin, vérifiez les détails du fichier pour confirmer qu'il existe et qu'il contient du contenu :
```
ls -l sample.txt
```
Cette commande affiche les autorisations, le propriétaire, la taille et d'autres détails du fichier. Une taille non nulle (généralement de 80 à 100 octets) confirme que votre texte a été correctement enregistré.

Avoir ce fichier d'exemple prêt est crucial pour les étapes suivantes où nous allons le chiffrer et le déchiffrer, ce qui nous permettra de voir clairement le fonctionnement du processus de chiffrement lorsque nous récupérerons notre texte original après le déchiffrement.

Générer une clé symétrique

Dans cette étape, vous allez générer une clé de chiffrement symétrique à l'aide d'OpenSSL que nous utiliserons pour chiffrer notre fichier d'exemple à l'étape suivante. Le chiffrement symétrique signifie que la même clé est utilisée pour verrouiller (chiffrer) et déverrouiller (déchiffrer) les données, contrairement au chiffrement asymétrique qui utilise des clés distinctes. Cela rend le processus de génération de clé particulièrement important pour la sécurité.

Découpons ce que nous allons faire : nous allons créer une clé aléatoire forte en utilisant les fonctions cryptographiques d'OpenSSL, la stocker en toute sécurité et vérifier ses propriétés. La clé utilisera le chiffrement AES-256, qui est actuellement considéré comme très sûr pour la plupart des usages.

Suivez attentivement ces étapes pour générer une clé de chiffrement AES-256 sécurisée :

Tout d'abord, assurez-vous que vous êtes dans le bon répertoire de travail où nous allons stocker notre fichier de clé. Cela permet de garder vos fichiers de projet organisés :
```
cd ~/project
```
Maintenant, nous allons générer la clé elle-même. La commande openssl rand crée des données aléatoires cryptographiquement fortes. Nous demandons 32 octets (256 bits) de données aléatoires et les formatons en hexadécimal (base-16) pour plus de lisibilité :
```
openssl rand -hex 32 > symmetric_key.hex
```
Affichons la clé générée pour confirmer qu'elle a été créée correctement. La clé devrait apparaître sous forme d'une longue chaîne de caractères aléatoires :
```
cat symmetric_key.hex
```
Vous devriez voir une chaîne hexadécimale de 64 caractères (représentant 32 octets) similaire à :
```
a1b2c3d4e5f67890a1b2c3d4e5f67890a1b2c3d4e5f67890a1b2c3d4e5f67890
```
Étant donné que cette clé peut déverrouiller vos données chiffrées, nous devons la protéger. La commande chmod 600 assure que seul vous pouvez lire ou écrire dans ce fichier :
```
chmod 600 symmetric_key.hex
```
Enfin, vérifions les propriétés du fichier de clé pour confirmer que tout est configuré correctement :
```
ls -l symmetric_key.hex
```
La sortie devrait montrer :
- Votre nom d'utilisateur comme propriétaire
- Des autorisations -rw------- (seul vous pouvez lire/écrire)
- Une taille de 65 octets (64 caractères + caractère de nouvelle ligne)

N'oubliez pas de garder ce fichier de clé en sécurité - toute personne qui l'aura pourra déchiffrer vos fichiers chiffrés. Dans des scénarios réels, vous voudrez peut-être le stocker dans un emplacement plus sécurisé que votre répertoire de projet.

Chiffrer le fichier avec AES

Dans cette étape, vous utiliserez la clé symétrique générée à l'étape précédente pour chiffrer votre fichier d'exemple en utilisant AES-256-CBC. AES (Advanced Encryption Standard, Standard de chiffrement avancé) est un algorithme de chiffrement symétrique largement utilisé qui offre une forte sécurité. La longueur de clé de 256 bits offre une protection élevée, tandis que le mode CBC (Cipher Block Chaining, Chaînage de blocs de chiffrement) garantit que chaque bloc de données est traité en toute sécurité en séquence.

Avant de commencer, comprenons ce que nous allons faire : nous allons prendre votre fichier texte lisible d'origine et le transformer en une version chiffrée qui ressemble à des données aléatoires. Seule une personne ayant la bonne clé peut le déchiffrer pour le ramener à sa forme d'origine.

Suivez ces étapes pour chiffrer votre fichier :

Tout d'abord, assurez-vous que vous êtes dans le bon répertoire de travail où se trouve votre fichier d'exemple. Cela est important car OpenSSL doit trouver à la fois votre fichier d'entrée et le fichier de clé :
```
cd ~/project
```
Maintenant, nous allons utiliser la commande de chiffrement d'OpenSSL. L'option -aes-256-cbc spécifie l'algorithme, -in pointe vers notre fichier d'entrée, -out spécifie où enregistrer la version chiffrée, et -pass file: indique à OpenSSL où trouver la clé de chiffrement :
```
openssl enc -aes-256-cbc -in sample.txt -out sample.enc -pass file:symmetric_key.hex
```
Après avoir exécuté la commande de chiffrement, vérifions que le fichier chiffré a été correctement créé. Le fichier chiffré devrait être légèrement plus volumineux que l'original en raison du processus de chiffrement qui ajoute des données supplémentaires :
```
ls -l sample.enc
```
La sortie devrait montrer :
- Votre nom d'utilisateur comme propriétaire
- Une taille de fichier supérieure à l'original (en raison des surcharges de chiffrement)
Pour confirmer que le chiffrement a fonctionné, essayons d'afficher le contenu chiffré. Contrairement à votre fichier texte d'origine, cela devrait apparaître sous forme de données binaires aléatoires car il est maintenant chiffré en toute sécurité :
```
cat sample.enc
```
Vous devriez voir des données binaires qui semblent aléatoires, ce qui confirme que le chiffrement a réussi.
Pour une vérification supplémentaire, nous pouvons vérifier comment le système identifie le type de fichier. La commande file examine le contenu des fichiers pour déterminer leur type :
```
file sample.enc
```
La sortie devrait indiquer qu'il s'agit de "données" (et non de "texte ASCII" comme l'original), ce qui est ce que nous attendons d'un fichier chiffré.

Déchiffrer et vérifier le fichier

Dans cette étape finale, vous allez déchiffrer le fichier chiffré en utilisant la clé symétrique et vérifier que le contenu déchiffré correspond au fichier original. Cela termine le cycle de chiffrement/déchiffrement et valide que nos opérations cryptographiques ont fonctionné correctement. Le déchiffrement est essentiellement le processus inverse du chiffrement - il prend les données brouillées et les transforme en leur forme d'origine en utilisant la même clé que celle utilisée pour le chiffrement.

Suivez ces étapes pour déchiffrer et vérifier votre fichier :

Tout d'abord, assurez-vous que vous êtes dans le bon répertoire de travail où sont stockés votre fichier chiffré et votre clé :
```
cd ~/project
```
Déchiffrez le fichier chiffré en utilisant la même clé symétrique. Le drapeau -d indique à OpenSSL que nous effectuons un déchiffrement, tandis que les autres paramètres correspondent à ceux utilisés lors du chiffrement :
```
openssl enc -d -aes-256-cbc -in sample.enc -out sample.dec -pass file:symmetric_key.hex
```
Vérifiez que le fichier déchiffré a été créé. La commande ls -l affiche des informations détaillées sur le fichier, notamment sa taille et sa date de création :
```
ls -l sample.dec
```
Comparez le fichier déchiffré avec l'original. La commande diff vérifie s'il existe des différences entre les fichiers ligne par ligne :
```
diff sample.txt sample.dec
```
Si les fichiers sont identiques (comme ils devraient l'être), il n'y aura pas de sortie pour cette commande. Toute sortie indiquerait une discordance entre le contenu original et le contenu déchiffré.
Affichez le contenu déchiffré pour confirmer qu'il correspond à l'original. La commande cat affiche tout le contenu du fichier dans votre terminal :
```
cat sample.dec
```
Vous devriez voir exactement le même texte que dans votre fichier original sample.txt. Cette confirmation visuelle est importante pour vérifier que le déchiffrement a fonctionné correctement.
Pour une vérification supplémentaire, vérifiez le type de fichier. La commande file examine le contenu du fichier pour déterminer son type :
```
file sample.dec
```
La sortie devrait indiquer qu'il s'agit de "texte ASCII" comme l'original, confirmant que le déchiffrement a restauré avec succès le fichier dans son format texte d'origine.

Résumé

Dans ce laboratoire, vous avez appris à chiffrer et déchiffrer des fichiers en utilisant OpenSSL grâce à des exercices pratiques. Les exercices ont couvert l'installation d'OpenSSL, la création de fichiers de test et l'exécution d'opérations de chiffrement/déchiffrement avec des clés symétriques AES.

Le laboratoire a démontré le flux de travail complet, de la génération de clé à l'encryption de fichier et à la vérification du déchiffrement. Cette expérience pratique contribue à consolider la compréhension des opérations cryptographiques fondamentales dans les applications de cybersécurité.