Chiffrement de fichiers en Python : exploration approfondie des techniques symétriques et asymétriques

Dans le monde moderne, nous partageons constamment des informations privées, confidentielles et sensibles par voie numérique. Le chiffrement de fichiers est un élément fondamental de ces échanges : il consiste à transformer les données en un format illisible à l’aide d’algorithmes de chiffrement.

Il existe deux principaux types de chiffrement : symétrique et asymétrique. Le chiffrement symétrique ressemble à un coffre doté d’une seule clé. Si deux personnes possèdent cette clé, elles peuvent se passer le coffre en sachant que seules elles pourront l’ouvrir. Le chiffrement asymétrique, quant à lui, utilise une paire de clés. Imaginez un coffre que l’on peut verrouiller avec une clé, mais que l’on ne peut ouvrir qu’avec une deuxième clé. Vous pouvez partager la clé de verrouillage (la clé publique) en toute sécurité, car personne ne peut ouvrir le coffre (déchiffrer les données) sans la clé d’ouverture (la clé privée).

Cet article explore le chiffrement en Python. Pour le chiffrement symétrique, nous nous intéressons à Amazon Key Management Service (KMS) et à SecretBox de PyNaCl. Nous examinons ensuite le chiffrement asymétrique et la boîte à clés publique/privée de PyNaCl.

Prérequis

Pour suivre ce tutoriel, vous avez besoin des éléments suivants :

• Python installé (v3.7 ou ultérieure)

• pipenv installé. Ce gestionnaire de dépendances Python vous aidera à éviter les conflits entre les versions des packages. Installez-le avec pip install pipenv.

• Installation des packages nécessaires (aws-encryption-sdk, PyNaCl et cryptography) en exécutant pipenv install aws-encryption-sdk pynacl cryptography. 

• Un compte AWS fonctionnel et une clé KMS (gardez l’ID de la clé et la région AWS à portée de main : nous les utiliserons lors de l’exécution du programme Python).

• L’outil de ligne de commande AWS (awscli) installé. Exécutez aws configure pour configurer les paramètres AWS sur votre machine. 

• Un nouveau projet configuré dans un environnement isolé, créé à l’aide de la commande suivante :

mkdir python_encryption && cd python_encryption
pipenv shell

Pour voir le résultat final, consultez le code complet du projet.

Chiffrement symétrique en Python

Le chiffrement symétrique utilise la même clé pour chiffrer et déchiffrer les données. Simple, rapide et efficace, il est idéal pour sécuriser de grandes quantités de données.

Dans ce tutoriel, nous utiliserons Amazon KMS et PyNaCl SecretBox pour mettre en œuvre le chiffrement symétrique en Python. Amazon KMS nous aide à créer, contrôler et gérer des clés de chiffrement dans le cloud Amazon Web Services (AWS). Imaginez un trousseau de clés dans le cloud, avec une couche de sécurité supplémentaire. SecretBox est une bibliothèque Python qui simplifie le chiffrement et le rend accessible. Imaginez votre propre coffre-fort.

Utiliser Amazon KMS et les SDK de chiffrement pour le chiffrement symétrique

Amazon KMS est un service cloud de gestion des clés cryptographiques. Il fonctionne parfaitement avec les autres services AWS et les kits de développement logiciel (SDK) de chiffrement, et tire parti de la sécurité robuste offerte par AWS. Son intégration étroite avec les services AWS et les SDK de chiffrement en fait une solution idéale pour les applications basées sur AWS. 

La principale raison d’utiliser KMS pour le chiffrement symétrique est la gestion des clés secrètes partagées. La gestion sécurisée de ces clés peut être l’aspect le plus difficile du chiffrement. Amazon KMS contourne élégamment ces difficultés en adoptant un modèle de chiffrement par enveloppe. Dans cette approche, les clés elles-mêmes sont chiffrées avec les données. Vous dépendez donc principalement d’une clé maîtresse stockée dans un module de sécurité matériel, inaccessible aux entités non autorisées. Ce mécanisme d’encapsulation de clé simplifie le processus de chiffrement et permet d’éviter les difficultés liées à la gestion et à la rotation des clés, ainsi que les autres problèmes associés.

Cependant, Amazon KMS n’est peut-être pas nécessaire si vous avez simplement besoin d’une solution simple et de petite envergure. Il s’agit également d’un service payant : les coûts peuvent donc grimper en cas d’utilisation intensive.

Utilisons maintenant Amazon KMS pour chiffrer un fichier dans une application Python.

Importer les modules nécessaires

Pour interagir avec Amazon KMS, nous devons d’abord installer et importer aws-encryption-sdk, le SDK AWS Encryption pour Python qui simplifie le chiffrement et le déchiffrement. 

Créez un fichier nommé main.py et ajoutez-y le code suivant :

1import aws_encryption_sdk
2
3# Configuration
4KEY_ARNs = [
5    'arn:aws:kms:<REGION>:xxx:key/<KMS-KEY-ID>'
6]
7
8client = aws_encryption_sdk.EncryptionSDKClient()
9kms_key_provider = aws_encryption_sdk.StrictAwsKmsMasterKeyProvider(
10    key_ids=KEY_ARNs)
11

Remarque : vous pouvez copier l’ARN de la clé KMS depuis le tableau de bord AWS KMS.

Chiffrer le fichier

Nous allons utiliser AWS Encryption SDK pour effectuer le chiffrement. Le SDK s’intègre étroitement à AWS KMS et offre une expérience de chiffrement fluide.

Ajoutez le code suivant à main.py :

1def encrypt_file(file_path, encrypted_path):
2    with open(file_path, 'rb') as pt_file, open(encrypted_path, 'wb') as ct_file:
3        with client.stream(
4            mode='e',
5            source=pt_file,
6            key_provider=kms_key_provider
7        ) as encryptor:
8            for chunk in encryptor:
9                ct_file.write(chunk)

Déchiffrer le fichier

Nous allons de nouveau utiliser AWS Encryption SDK pour déchiffrer le fichier. Le processus lit le fichier chiffré, puis utilise les clés KMS pour déchiffrer les données en toute simplicité.

Ajoutez les commandes suivantes à main.py :

1def decrypt_file(encrypted_path, decrypted_path):
2    with open(encrypted_path, 'rb') as ct_file, open(decrypted_path, 'wb') as pt_file:
3        with client.stream(
4            mode='d',
5            source=ct_file,
6            key_provider=kms_key_provider
7        ) as decryptor:
8            for chunk in decryptor:
9                pt_file.write(chunk)

Appeler les fonctions

Nous avons créé les fonctions. Il nous faut maintenant les appeler et exécuter le programme Python. Commencez par créer un fichier nommé myfile.txt et ajoutez-y du contenu aléatoire.

Appelez ensuite les fonctions suivantes dans main.py :

1encrypt_file('myfile.txt', 'encrypted_file.txt')
2decrypt_file('encrypted_file.txt', 'decrypted_file.txt')

Lorsque nous exécutons python main.py pour lancer le script, nous chiffrons puis déchiffrons myfile.txt sans en modifier le contenu. 

Remarque : pour simplifier, nous avons codé en dur l’ID de la clé (dans l’ARN de la clé). Veuillez utiliser le fichier .env pour stocker les informations sensibles.

Utiliser SecretBox de PyNaCl pour le chiffrement symétrique

PyNaCl est une liaison Python à la bibliothèque de réseau et de cryptographie libsodium. Elle regorge d’outils cryptographiques, dont SecretBox, qui permet d’effectuer un chiffrement symétrique. SecretBox a l’avantage d’être simple : une seule clé suffit pour chiffrer et déchiffrer nos données.

Voyons comment chiffrer un fichier sensible dans une application Python à l’aide de SecretBox. 

Commencez par créer un fichier nacl.txt et ajoutez-y du texte fictif. Importez ensuite les modules nécessaires dans un nouveau fichier de programme Python nommé sym.py :

1from nacl import utils
2from nacl.secret import SecretBox
3import os

L’étape suivante consiste à générer et à charger la clé secrète. La fonction generate_key génère une clé aléatoire, et la fonction load_key charge la clé générée depuis le chemin du fichier et la renvoie :

1def generate_key(secret_key_file):
2    secret_key = utils.random(SecretBox.KEY_SIZE)
3    with open(secret_key_file, 'wb') as f:
4        f.write(secret_key)
5    return secret_key
6
7def load_key(secret_key_file):
8    if not os.path.exists(secret_key_file):
9        print(f"Key file {secret_key_file} not found.")
10    with open(secret_key_file, 'rb') as f:
11        key = f.read()
12    if len(key) != SecretBox.KEY_SIZE:
13        print("Incorrect key length.")
14    return key

Nous allons maintenant chiffrer le fichier. La fonction encrypt_file a besoin du file_path et de la clé pour chiffrer le fichier sensible. Elle localise le fichier à l’aide de son file_path, puis lit et chiffre son contenu avec la clé secrète avant d’écrire le texte chiffré dans un nouveau fichier portant l’extension .enc :

1def encrypt_file(file_path, key):
2    if not os.path.exists(file_path):
3        print(f"Key file {secret_key_file} not found.")
4    secret_box = SecretBox(key)
5    with open(file_path, 'rb') as f:
6        plaintext = f.read()
7    ciphertext = secret_box.encrypt(plaintext)
8    with open(file_path+'.enc', 'wb') as f:
9        f.write(ciphertext)

Tout comme nous avons une fonction de chiffrement, nous avons également besoin d’une fonction similaire pour le déchiffrement. La fonction decrypt_file prend le file_path et la key pour déchiffrer un fichier. Elle vérifie d’abord qu’un fichier chiffré avec l’extension .enc existe (c’est le cas : nous l’avons généré à l’étape précédente). Elle lit ensuite son contenu et le déchiffre à l’aide de la même clé secrète. Enfin, elle écrit le contenu déchiffré dans un nouveau fichier portant l’extension .dec :

1def decrypt_file(file_path, key):
2    if not os.path.exists(file_path+'.enc'):
3        print(f"Key file {secret_key_file} not found.")
4    secret_box = SecretBox(key)
5    with open(file_path+'.enc', 'rb') as f:
6        ciphertext = f.read()
7    plaintext = secret_box.decrypt(ciphertext)
8    with open(file_path+'.dec', 'wb') as f:
9        f.write(plaintext)

Dernière étape : appeler les fonctions que nous venons de créer :

1secret_key_file = 'secret.key'
2
3# generate key for encryption
4key = generate_key(secret_key_file)
5encrypt_file('nacl.txt', key)
6
7# load key for decryption
8key = load_key(secret_key_file)
9decrypt_file('nacl.txt', key)

Vous pouvez maintenant exécuter le programme Python avec la commande sym.py dans votre terminal.

Remarque : ce code n’est pas prêt à être utilisé dans une application réelle ou un environnement de production. La gestion sécurisée des clés de chiffrement est une tâche complexe qui nécessite des mesures supplémentaires, comme la rotation régulière des clés. Ce code ne comprend pas ces mesures de sécurité essentielles.

Chiffrement asymétrique en Python

Alors que le chiffrement symétrique utilise une seule clé, le chiffrement asymétrique en utilise deux : une clé publique pour le chiffrement et une clé privée pour le déchiffrement. C’est comme une boîte aux lettres verrouillable. Tout le monde peut y déposer une lettre par la fente (chiffrement), mais seule la personne possédant la clé appropriée peut l’ouvrir pour lire la lettre (déchiffrement).

Le chiffrement asymétrique est particulièrement adapté aux communications sécurisées sur Internet. Si vous souhaitez envoyer un message secret à un ami, vous pouvez le chiffrer avec sa clé publique. Seul cet ami pourra le déchiffrer avec sa clé privée. Le chiffrement asymétrique sécurise les signatures numériques et les certificats, qui constituent le fondement de l’authentification dans le monde numérique.

Utiliser la primitive Box publique/privée de PyNaCl pour le chiffrement asymétrique

Alors, comment effectuer un chiffrement asymétrique en Python ? Découvrons un autre outil de PyNaCl : la boîte à clés publique/privée. 

La boîte à clés publique/privée de PyNaCl ressemble à une boîte aux lettres personnelle. Il s’agit d’une interface permettant de chiffrer et de déchiffrer des messages à l’aide de deux clés : une clé publique et une clé privée. Nous pouvons partager librement la clé publique utilisée pour chiffrer les messages. En revanche, nous devons garder secrète la clé privée utilisée pour le déchiffrement.

Commencez par créer le fichier asym_nacl.txt et ajoutez-y du texte fictif. Nous devons permettre le stockage et la récupération sécurisés des clés de chiffrement. La fonction save_key écrit la clé dans le file_path, tandis que load_key récupère et renvoie la clé depuis le file_path. 

Ajoutez le code suivant à un nouveau fichier nommé asym.py :

1from nacl.public import PrivateKey, Box
2import pickle
3
4def save_key(file_path, key):
5    with open(file_path, 'wb') as f:
6        pickle.dump(key, f)
7
8def load_key(file_path):
9    with open(file_path, 'rb') as f:
10        key = pickle.load(f)
11    return key

Nous devons maintenant implémenter des fonctions pour chiffrer et déchiffrer notre fichier sensible. La fonction encrypt_file utilise des clés publiques pour chiffrer le fichier et le stocker dans un fichier .enc contenant le texte chiffré. La fonction decrypt_file utilise des clés privées pour ouvrir le fichier (le déchiffrer) et le stocker dans un fichier .dec. 

Ajoutez les fonctions suivantes à asym.py :

1def encrypt_file(file_path, public_key):
2    private_key = PrivateKey.generate()
3    box = Box(private_key, public_key)
4
5    with open(file_path, 'rb') as f:
6        plaintext = f.read()
7
8    ciphertext = box.encrypt(plaintext)
9
10    with open(file_path+'.enc', 'wb') as f:
11        f.write(ciphertext)
12
13    return private_key
14
15def decrypt_file(file_path, private_key, public_key):
16    box = Box(private_key, public_key)
17
18    with open(file_path+'.enc', 'rb') as f:
19        ciphertext = f.read()
20
21    plaintext = box.decrypt(ciphertext)
22
23    with open(file_path+'.dec', 'wb') as f:
24        f.write(plaintext)

Enfin, le moment est venu de voir le résultat de tout notre travail. Nous générons deux clés : la clé publique, qui nous permet de verrouiller notre fichier, et une clé privée, que nous enregistrons. Lorsque nous devons accéder au fichier, nous chargeons la clé privée enregistrée ainsi que la clé publique correspondante pour le déchiffrer. 

Ajoutez les derniers appels de fonction au fichier asym.py :

1private_key = PrivateKey.generate()
2public_key = private_key.public_key
3
4encryption_private_key = encrypt_file('asym_nacl.txt', public_key)
5save_key('private.key', encryption_private_key)
6
7encryption_private_key = load_key('private.key')
8decrypt_file('asym_nacl.txt', private_key, encryption_private_key.public_key)

Exécutez le programme depuis votre terminal local avec python asym.py.

Remarque : le code ci-dessus illustre le fonctionnement du chiffrement et du déchiffrement. Cependant, il ne peut pas être utilisé en toute sécurité dans des applications réelles. Le fichier de clé n’est pas protégé : si quelqu’un y accède, il peut déverrouiller vos fichiers.

Avantages et inconvénients de la boîte à clés publique/privée de PyNaCl

La boîte à clés publique/privée de PyNaCl offre une sécurité robuste. Elle permet également des communications sécurisées, même sur des canaux non sécurisés, ce qui la rend idéale pour les échanges sur Internet.

En revanche, la gestion des clés peut s’avérer délicate avec la boîte à clés publique/privée. Nous devons stocker les clés privées en toute sécurité et veiller à utiliser les bonnes clés publiques pour le chiffrement. Le chiffrement asymétrique peut également être plus lent que le chiffrement symétrique, car il repose sur des opérations plus complexes.

Pour conclure notre exploration

Dans cet article, nous avons découvert des outils Python performants pour mettre en œuvre des méthodes de chiffrement. Amazon KMS et SecretBox de PyNaCl sont excellents pour le chiffrement symétrique, tandis que la boîte à clés publique/privée de PyNaCl excelle dans le chiffrement asymétrique.

Ces outils offrent divers avantages pour gérer les données de manière sécurisée. Amazon KMS se distingue par son évolutivité, SecretBox de PyNaCl par ses performances et sa large compatibilité, et la boîte à clés publique/privée de PyNaCl par ses capacités de communication hautement sécurisée. Ensemble, ces outils constituent une boîte à outils complète pour le chiffrement.

Pour choisir une méthode de chiffrement, nous devons tenir compte de la sensibilité de nos données, de l’environnement dans lequel nous les transmettrons et de la façon dont nous gérerons les clés. Il n’existe pas de méthode de chiffrement parfaite, mais nous pouvons facilement trouver celle qui répond le mieux à nos besoins.