Assurer l'intégrité et l'authenticité des données avec la cryptographie

Introduction

Dans le monde numérique, il est crucial de s'assurer que les données n'ont pas été altérées (intégrité) et qu'elles proviennent d'une source fiable (authenticité). La cryptographie fournit les outils pour atteindre ces objectifs.

Ce laboratoire vous introduira aux pratiques cryptographiques fondamentales sur un système Linux. Vous apprendrez :

• Le Hachage (Hashing) : Créer une "empreinte digitale" unique et de taille fixe d'un fichier. Si le fichier change, même d'un seul bit, le hachage changera complètement. Nous utiliserons les algorithmes MD5 et SHA256.
• Les Signatures Numériques (Digital Signatures) : Utiliser une clé privée pour "signer" un fichier, ce qui permet à quiconque possédant la clé publique correspondante de vérifier que le fichier est authentique et n'a pas été modifié.
• Le Chiffrement (Encryption) : Brouiller le contenu d'un fichier de manière à ce qu'il ne puisse être lu que par une personne possédant la clé correcte pour le déchiffrer, garantissant ainsi la confidentialité.

Nous utiliserons des outils standard en ligne de commande sous Linux, notamment md5sum, sha256sum et GnuPG (gpg), l'implémentation GNU de la norme Pretty Good Privacy (PGP). À la fin de ce laboratoire, vous serez en mesure de hacher, signer, vérifier, chiffrer et déchiffrer des fichiers en toute confiance.

Calculer les sommes de contrôle des fichiers (MD5 et SHA256)

Dans cette étape, vous apprendrez à calculer des hachages cryptographiques pour un fichier. Une fonction de hachage prend une entrée (comme un fichier) et renvoie une chaîne d'octets de taille fixe, connue sous le nom de valeur de hachage ou digest. Cette valeur agit comme une empreinte digitale numérique.

Tout d'abord, nous utiliserons la commande md5sum pour calculer le hachage MD5 du fichier important_data.txt qui a été pré-créé dans votre répertoire ~/project.

Exécutez la commande suivante dans votre terminal :

md5sum important_data.txt

Vous verrez une sortie composée de la valeur du hachage suivie du nom du fichier :

d9e21981521545759153147864347199  important_data.txt

Bien que le MD5 soit rapide, il est maintenant considéré comme non sécurisé à des fins cryptographiques en raison de vulnérabilités. Une alternative plus sécurisée et couramment utilisée est la famille SHA-2, spécifiquement SHA256.

Maintenant, calculons le hachage SHA256 en utilisant la commande sha256sum :

sha256sum important_data.txt

La sortie sera un hachage plus long et plus sécurisé :

a39b2c414f234246a2535321238863141b1a4849443b9992994b4189317e8591  important_data.txt

Si vous modifiiez quoi que ce soit dans important_data.txt, les hachages MD5 et SHA256 changeraient complètement, vous permettant de détecter facilement toute modification non autorisée.

Installer et configurer GnuPG (GPG)

Dans cette étape, vous allez installer GnuPG (GPG), l'outil que nous utiliserons pour les signatures numériques et le chiffrement. Bien que GPG soit souvent pré-installé sur les distributions Linux modernes, il est bon de s'assurer qu'il est présent et à jour.

Tout d'abord, mettez à jour votre liste de paquets en utilisant apt-get update. Vous devez utiliser sudo car la gestion des paquets nécessite des privilèges administratifs.

sudo apt-get update

Ensuite, installez le paquet gnupg. L'option -y répond automatiquement "oui" à toutes les invites, rendant l'installation non interactive.

sudo apt-get install -y gnupg

Une fois l'installation terminée, vous pouvez vérifier que GPG est correctement installé en consultant sa version.

gpg --version

Vous devriez voir une sortie similaire à la suivante, confirmant l'installation. Les numéros de version et les détails peuvent varier légèrement.

gpg (GnuPG) 2.2.27
libgcrypt 1.9.4
Copyright (C) 2021 Free Software Foundation, Inc.
License GNU GPL-3.0-or-later <https://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Home: /home/labex/.gnupg
Supported algorithms:
Pubkey: RSA, ELG, DSA, ECDH, ECDSA, EDDSA
Cipher: IDEA, 3DES, CAST5, BLOWFISH, AES, AES192, AES256, TWOFISH,
        CAMELLIA128, CAMELLIA192, CAMELLIA256
Hash: SHA1, RIPEMD160, SHA256, SHA384, SHA512, SHA224
Compression: Uncompressed, ZIP, ZLIB, BZIP2

Maintenant que GPG est prêt, nous pouvons passer à la création de nos propres clés cryptographiques.

Générer une paire de clés GPG pour les signatures numériques

Dans cette étape, vous allez générer votre propre paire de clés GPG, qui se compose d'une clé privée et d'une clé publique.

• Clé Privée : Doit être gardée secrète. Elle est utilisée pour déchiffrer les messages et créer des signatures numériques.
• Clé Publique : Peut être partagée librement. Elle est utilisée pour chiffrer les messages qui vous sont destinés et pour vérifier vos signatures numériques.

Normalement, gpg --full-generate-key lance une configuration interactive. Pour rendre ce processus plus simple et non interactif pour le laboratoire, nous utiliserons le mode batch de GPG. Tout d'abord, créez un fichier de paramètres qui spécifie les détails de notre clé.

Utilisez la commande cat suivante avec un "here document" pour créer instantanément le fichier gen-key-params :

cat << EOF > gen-key-params
%echo Generating a basic key
Key-Type: RSA
Key-Length: 2048
Subkey-Type: RSA
Subkey-Length: 2048
Name-Real: LabEx User
Name-Email: user@labex.io
Expire-Date: 0
%no-protection
%commit
%echo done
EOF

Ce fichier indique à GPG de créer une clé RSA de 2048 bits pour un utilisateur nommé "LabEx User" avec l'adresse e-mail "user@labex.io". La clé n'expirera jamais, et nous utilisons %no-protection pour créer la clé sans phrase de passe par souci de simplicité (dans un scénario réel, vous devriez toujours utiliser une phrase de passe forte).

Maintenant, générez la clé en utilisant le fichier de paramètres :

gpg --batch --gen-key gen-key-params

GPG utilisera les paramètres pour générer la paire de clés. Cela peut prendre quelques instants. Une fois terminé, vous pouvez lister vos clés pour confirmer que la paire de clés a été créée avec succès.

gpg --list-keys

La sortie devrait afficher votre nouvelle clé publique, similaire à ceci :

/home/labex/.gnupg/pubring.kbx
-------------------------------
pub   rsa2048 2023-10-27 [SC]
      XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
uid           [ultimate] LabEx User <user@labex.io>
sub   rsa2048 2023-10-27 [E]

Vous disposez maintenant d'une paire de clés GPG prête à signer et chiffrer des fichiers.

Signer et vérifier numériquement un fichier avec GPG

Dans cette étape, vous utiliserez votre clé privée pour créer une signature numérique pour un fichier. Cette signature prouve que le fichier provient de vous et n'a pas été modifié depuis que vous l'avez signé.

Nous allons créer une signature "détachée", qui est stockée dans un fichier séparé. Ceci est utile car le fichier original reste intact.

Pour signer important_data.txt, exécutez la commande suivante. GPG utilisera automatiquement la clé privée par défaut que vous venez de générer.

gpg --detach-sign important_data.txt

Étant donné que nous avons créé la clé sans phrase de passe, vous ne serez pas invité à en saisir une. Maintenant, listez les fichiers de votre répertoire pour voir le nouveau fichier de signature.

ls

Vous verrez le fichier original et sa signature :

gen-key-params  important_data.txt  important_data.txt.sig

Maintenant, imaginez que vous êtes un destinataire qui a reçu à la fois important_data.txt et important_data.txt.sig, ainsi que votre clé publique. Pour vérifier l'authenticité et l'intégrité du fichier, il exécuterait la commande gpg --verify.

Effectuons la vérification vous-même :

gpg --verify important_data.txt.sig important_data.txt

La sortie confirmera que la signature est valide :

gpg: Signature made Mon Aug  4 16:39:30 2025 CST
gpg:                using RSA key 8765265B14E42532B9CBAE6DE2120C9784C69814
gpg: Good signature from "LabEx User <user@labex.io>" [ultimate]

Le message "Good signature" confirme que le fichier est authentique et non modifié.

Chiffrer et déchiffrer un fichier avec GPG

Dans cette étape, vous apprendrez comment chiffrer un fichier pour assurer sa confidentialité. Contrairement à la signature (qui utilise votre clé privée), le chiffrement d'un fichier pour quelqu'un nécessite sa clé publique. Le destinataire utilise ensuite sa clé privée pour le déchiffrer.

Ici, nous allons chiffrer important_data.txt pour nous-mêmes, nous utiliserons donc notre propre clé publique comme clé du destinataire.

Utilisez la commande suivante pour chiffrer le fichier. L'indicateur --recipient spécifie quelle clé publique utiliser pour le chiffrement, et --output définit le nom du fichier chiffré.

gpg --encrypt --recipient "user@labex.io" --output important_data.txt.gpg important_data.txt

Si vous essayez de visualiser le contenu du nouveau fichier chiffré, important_data.txt.gpg, vous verrez des données binaires illisibles.

cat important_data.txt.gpg

Maintenant, déchiffrons le fichier. Cette action nécessite la clé privée correspondante. Comme vous possédez la clé privée, vous pouvez déchiffrer le message. Nous allons enregistrer le contenu déchiffré dans un nouveau fichier nommé decrypted_data.txt.

gpg --decrypt --output decrypted_data.txt important_data.txt.gpg

GPG utilisera votre clé privée pour déchiffrer le fichier. Vous verrez des informations de GPG sur votre terminal, y compris une confirmation que le fichier a été chiffré avec votre clé.

Enfin, visualisez le contenu du fichier déchiffré pour confirmer que le processus a réussi.

cat decrypted_data.txt

La sortie devrait être le message original et lisible :

This is a secret message that needs to be protected.

Vous avez réussi à chiffrer un fichier pour protéger son contenu, puis à le déchiffrer pour récupérer les informations originales.

Résumé

Dans ce laboratoire, vous avez acquis une expérience pratique des outils et concepts cryptographiques essentiels sur un système Linux. Vous avez accompli avec succès les tâches suivantes :

• Calculé les sommes de contrôle de fichiers à l'aide de md5sum et sha256sum pour garantir l'intégrité des données.
• Installé et configuré GnuPG (gpg), l'outil standard pour la cryptographie open-source.
• Généré une paire de clés GPG personnelle (clés publique et privée).
• Créé une signature numérique avec gpg --detach-sign pour assurer l'authenticité et l'intégrité.
• Vérifié une signature numérique avec gpg --verify.
• Chiffré un fichier pour la confidentialité en utilisant gpg --encrypt.
• Déchiffré le fichier pour accéder à son contenu original en utilisant gpg --decrypt.

Ces compétences sont fondamentales pour sécuriser les données, vérifier les téléchargements de logiciels et protéger les communications dans une grande variété de contextes professionnels et personnels.