Chiffrement symétrique ou asymétrique : exemples pratiques en Python

Le chiffrement symétrique et le chiffrement asymétrique sont les deux méthodes les plus courantes pour protéger les données sensibles à l’aide de la cryptographie. Ces méthodes utilisent une ou plusieurs clés pour transformer un message non chiffré en message chiffré (un texte chiffré), extrêmement difficile à déchiffrer sans la ou les clés appropriées. Le chiffrement symétrique utilise une seule clé pour chiffrer et déchiffrer les données. À l’inverse, le chiffrement asymétrique utilise une paire de clés, une clé publique et une clé privée, pour chiffrer et déchiffrer les données sensibles.

Les systèmes sécurisés de transmission et de stockage des données, qui privilégient la confidentialité, utilisent fréquemment ces méthodes de chiffrement. Par exemple, les applications de messagerie chiffrée de bout en bout chiffrent les messages avant leur envoi. Cette approche empêche un attaquant d’intercepter et de lire des messages en clair lors d’une attaque de l’homme du milieu. Le contenu d’un message chiffré est illisible pour un attaquant.

Le chiffrement symétrique et le chiffrement asymétrique sont également utiles dans d’autres cas, comme le stockage d’informations sensibles telles que les mots de passe et les dossiers médicaux. En général, les systèmes chiffrent ces informations avant de les stocker sur des serveurs ou de les partager entre ordinateurs.

Des applications comme TLS/SSL utilisent également ces méthodes. Pendant la négociation, lorsque le serveur envoie sa clé publique au client, celui-ci génère un secret pré-maître aléatoire et le chiffre à l’aide de la clé publique du serveur. Le serveur déchiffre ensuite ce secret pré-maître avec sa clé privée. Le serveur et le client génèrent alors chacun le secret maître à partir du secret pré-maître et d’autres paramètres de la négociation.

Comme ils utilisent les mêmes paramètres, le client et le serveur génèrent le même secret maître, que l’application utilise pour générer les clés de session. Ces clés symétriques permettent de chiffrer et de déchiffrer les données pendant la session, garantissant une communication sécurisée entre le serveur et le client. Ce processus s’appuie sur le chiffrement asymétrique pour échanger les clés de manière sécurisée et sans confiance préalable, puis sur le partage sécurisé de clés symétriques pour transmettre les données rapidement et de façon fiable.

Les deux méthodes contribuent à atténuer les risques de sécurité qui compromettent les données, comme les accès non autorisés, l’interception et la falsification, le vol et les atteintes à la confidentialité. Dans ce guide, nous aborderons le chiffrement symétrique et asymétrique, nous les mettrons en œuvre en Python et nous examinerons les bonnes pratiques associées.

Prérequis

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

• Une bonne maîtrise de Python

• Une chaîne d’outils Python (version 3.7 ou ultérieure), notamment pip, installée

• Un compte Amazon Web Services (AWS). La création d’un compte et l’utilisation de certains services sont gratuites.

Comprendre le chiffrement symétrique

Le chiffrement symétrique utilise la même clé pour chiffrer et déchiffrer les données. Il est donc plus rapide et plus efficace que le chiffrement asymétrique. Il suit généralement les étapes ci-dessous.

1. Génération de la clé : l’expéditeur ou un tiers de confiance génère une clé secrète, puis la partage de manière sécurisée avec le destinataire prévu.

2. Chiffrement : l’expéditeur applique un algorithme de chiffrement symétrique, comme le Data Encryption Standard (DES), le Triple DES (3DES) ou l’Advanced Encryption Standard (AES), au message en clair et à la clé secrète partagée. Ce processus convertit le texte en clair en texte chiffré.

3. Transmission des données : l’expéditeur transmet le texte chiffré au destinataire par un canal non sécurisé, comme Internet.

4. Déchiffrement : le destinataire applique le même algorithme de chiffrement symétrique en sens inverse à l’aide de la clé partagée. Ce processus déchiffre le texte chiffré pour récupérer le message d’origine en clair.

Grâce à son efficacité et à sa rapidité supérieures, le chiffrement symétrique est préférable au chiffrement asymétrique pour les tâches lourdes, comme le chiffrement de fichiers, de bases de données ou même de partitions de disque entières. Ainsi, même si ces données au repos sont compromises, elles restent illisibles et chiffrées sans la clé appropriée.

Algorithmes de chiffrement symétrique

Examinons plus en détail DES, 3DES et AES, et voyons comment le chiffrement par enveloppe facilite la gestion des clés.

Data Encryption Standard (DES)

DES est un algorithme de chiffrement symétrique populaire depuis les années 1970. Il utilise une clé de 56 bits, ce qui limite l’espace des clés à 2⁵⁶ (2 puissance 56) clés possibles. DES a été relativement sûr pendant une vingtaine d’années, mais les attaques par force brute sont désormais faciles à mener grâce à la puissance de calcul moderne.

Triple Data Encryption Standard (3DES)

3DES est une version améliorée de DES qui utilise trois clés DES. Il offre un niveau de sécurité supérieur, de 112 bits. Il reste toutefois inefficace, car la clé doit faire 168 bits pour garantir une sécurité de 112 bits.

Advanced Encryption Standard (AES)

AES remonte aux années 1990 et constitue la norme moderne du chiffrement symétrique. Ses clés offrent des niveaux de sécurité de 128, 196 ou 256 bits. La plupart des applications utilisent des clés de 128 bits, car la différence de sécurité entre 128 et 256 bits est négligeable. AES est plus rapide et plus sûr que 3DES.

Chiffrement par enveloppe

La gestion des clés est l’un des principaux problèmes du chiffrement symétrique. Une fuite de clé est catastrophique, puisque le chiffrement et le déchiffrement utilisent la même clé. Le chiffrement par enveloppe résout ce problème. Il utilise une clé de chiffrement des données (DEK) et une clé de chiffrement de clé (KEK). La DEK est la clé principale utilisée par l’application pour chiffrer les données, tandis que la KEK chiffre la DEK.

Ce chiffrement à deux niveaux renforce la sécurité, car une attaque réussie nécessiterait les deux clés. Les environnements de cloud computing utilisent généralement le chiffrement par enveloppe pour bénéficier d’une sécurité, d’une flexibilité et d’une évolutivité accrues. Comme vous le découvrirez plus loin, les fournisseurs cloud proposent souvent des interfaces pratiques pour utiliser le chiffrement par enveloppe et protéger la clé maître (KEK) des regards indiscrets.

Mettre en œuvre le chiffrement symétrique en Python

Créons une application Python de chiffrement et de déchiffrement reposant sur le chiffrement symétrique par enveloppe. AWS Key Management Service (KMS) fournit le chiffrement par enveloppe pour la gestion des clés ainsi que l’AWS Encryption SDK pour communiquer avec le service.

Pour commencer

Pour commencer, créez un répertoire pour votre projet :

$ mkdir encryption-demo && cd encryption-demo

Suivez ensuite ces étapes pour créer une clé KMS symétrique dans votre tableau de bord AWS. Cette clé KMS est votre clé maître client (CMK).

Configurez les autorisations d’accès à votre clé, puis copiez le nom de ressource Amazon (ARN) depuis la section Configuration générale du tableau de bord de la clé.

L’ARN est l’identifiant de votre CMK, utilisé pour interagir avec l’AWS Encryption SDK. Il s’agit de la KEK qui chiffre la DEK générée.

Installez ensuite AWS CLI et configurez-le à l’aide de la commande suivante :

$ aws configure

Lors de la configuration d’AWS CLI, vérifiez que le profil dispose des autorisations appropriées sur la CMK. Cette configuration permet à l’application de communiquer correctement avec AWS KMS à l’aide des identifiants enregistrés.

Créer le reste de l’application

Nous utilisons les packages aws-encryption-sdk et argparse pour créer le reste de notre application. aws-encryption-sdk est une implémentation de l’AWS Encryption SDK pour Python. Installez ces packages à l’aide de cette commande pip :

$ pip install aws-encryption-sdk argparse

Créez ensuite un fichier sym_encryptor.py et ajoutez-y ce code pour importer les modules nécessaires :

import aws_encryption_sdk
from aws_encryption_sdk.exceptions import GenerateKeyError
import argparse

Ajoutez ensuite le code suivant pour créer les classes client et fournisseur de clés :

client = aws_encryption_sdk.EncryptionSDKClient()

kms_key_provider = aws_encryption_sdk.StrictAwsKmsMasterKeyProvider(key_ids=[
    "<your-kms-ARN>"
])

La classe EncryptionSDKClient fournit des méthodes client de haut niveau, comme encrypt, decrypt et stream, pour le chiffrement des données. Le code configure la classe StrictAwsKmsMasterKeyProvider avec une liste de clés maîtres AWS KMS pour le chiffrement et le déchiffrement.

Transmettez l’identifiant ARN de la CMK que vous avez créée précédemment. Le code peut ainsi dériver une clé de la CMK pour chiffrer le texte en clair.

aws-encryption-sdk génère, chiffre et déchiffre automatiquement la clé de données à partir de la CMK. Cette automatisation simplifie la gestion des clés.

Créer la fonction de chiffrement

Ajoutez la fonction suivante à votre script pour créer la fonction de chiffrement :

1def encrypt(message):
2    """
3    Encrypts the passed message using the provided key.
4    Returns the ciphertext of the message.
5    """
6    try:
7        ciphertext, encryptor_header = client.encrypt(
8            source=message,
9            key_provider=kms_key_provider,
10            encryption_context={
11                'this is': 'not a secret',
12                'but adds': 'some authentication'
13            }
14        )
15
16        with open("encrypted.bin", "wb") as f:
17            f.write(ciphertext)
18        print("encryption complete")
19    except GenerateKeyError:
20        print("Error: data key generation from CMK failed, check ARN")

Cette fonction prend le message sous forme de données binaires et le chiffre à l’aide de la méthode encrypt() du client. La méthode encrypt prend en paramètres les données à chiffrer, la classe du fournisseur de clés et le contexte de chiffrement.

En transmettant la classe du fournisseur de clés créée précédemment, le client génère une clé de chiffrement des données à partir de la CMK et chiffre les données. Le client renvoie le texte chiffré et un en-tête de chiffrement, qui contient des informations permettant de vérifier l’authenticité. Le contexte de chiffrement est un dictionnaire contenant des informations tirées de l’en-tête de chiffrement renvoyé par le client.

Créer la fonction de déchiffrement

Ajoutez les lignes de code suivantes au script pour créer la fonction de déchiffrement :

1def decrypt(ciphertext):
2    """
3    Decrypts the passed ciphertext using the provided key.
4    Returns the original decrypted message.
5    """   
6    try:
7        original_text, decryptor_header = client.decrypt(
8            source=ciphertext,
9            key_provider=kms_key_provider,
10        )
11
12        with open("decrypted.bin", "wb") as f:
13            f.write(original_text)
14        print("decryption complete")
15    except GenerateKeyError:
16        print("Error: data key generation from CMK failed, check ARN")

Cette fonction prend le texte chiffré et appelle la méthode decrypt() du client en lui transmettant le fournisseur de clés et le texte chiffré. La méthode decrypt fonctionne comme la méthode encrypt. Elle dérive une clé de données à partir de la CMK configurée et annule le chiffrement en appliquant aux données la même clé et le même algorithme. Cette méthode renvoie le texte déchiffré et un en-tête de déchiffrement similaire à l’en-tête de chiffrement. Dans les applications réelles, ces en-têtes permettent de vérifier les données, car ils contiennent les mêmes informations, notamment la suite de chiffrement, l’ARN et le contexte de chiffrement.

Créer une application en ligne de commande

Pour faciliter les tests, transformons notre application en application en ligne de commande en analysant les arguments de la ligne de commande. Ajoutez le code suivant :

1def parse_arguments():
2    parser = argparse.ArgumentParser(description="Encrypt/Decrypt files")
3    parser.add_argument("-i", metavar="[file]", type=str, required=False, help="file to encrypt/decrypt")
4
5    group = parser.add_mutually_exclusive_group()
6    group.add_argument("-e", "--encrypt", action="store_true", help="encrypt mode")
7    group.add_argument("-d", "--decrypt", action="store_true", help="decrypt mode")
8
9    args = parser.parse_args()
10    return args
11
12# Parse command-line arguments
13args = parse_arguments()
14
15file_name = args.i
16if file_name:
17    with open(file_name, "rb") as f:
18        data = f.read()
19    if args.encrypt:
20        encrypt(data)
21    elif args.decrypt:
22        decrypt(data)
23    else:
24        print("must provide encryption/decryption mode: (-e/-d)")

Ce code analyse les arguments de la ligne de commande. Il définit une option de clé et des options permettant de choisir entre les modes de chiffrement et de déchiffrement. Enregistrez le fichier et exécutez la commande suivante :

$ python sym_encryptor.py --help

Le résultat est le suivant :

usage: sym_encryptor.py [-h] [-i [file]] [-e | -d]

Encrypt/Decrypt files

options:
  -h, --help 	    show this help message and exit
  -i [file]  	    file to encrypt/decrypt
  -e, --encrypt  encrypt mode
  -d, --decrypt  decrypt mode

Tester l’application

Pour tester l’application, créez d’abord un fichier texte quelconque, comme celui ci-dessous :

$ cat > test
Hello World!

Traitez le fichier avec l’application en indiquant son nom et l’option de mode de chiffrement -e.

$ python sym_encryptor.py -e -i test

Cette opération crée un nouveau fichier encrypted.bin.

$ cat encrypted.bin

Le résultat sera similaire à ce qui suit :

���/Oֶ7E.~RoZР�IT2ƺ�0r%...

Ce fichier correspond au texte chiffré créé par notre application. Nous pouvons transmettre ce fichier chiffré au destinataire. Celui-ci, comme toute autre partie, doit disposer des autorisations d’accès KMS appropriées à la CMK.

Déchiffrer le fichier

Pour simuler le processus de déchiffrement, traitez le fichier chiffré avec l’application :

$ python sym_encryptor.py -d -i encrypted.bin

Une notification indiquant decryption complete s’affiche.

Le code crée un nouveau fichier nommé decrypted.file dans votre répertoire, comme suit :

$ cat decrypted.bin
Output:
Hello World!

Nous avons récupéré avec succès le texte d’origine après avoir chiffré et déchiffré le message à l’aide du chiffrement symétrique par enveloppe avec AWS KMS.

Comprendre le chiffrement asymétrique

Alors que le chiffrement symétrique étudié précédemment utilise la même clé pour chiffrer et déchiffrer, le chiffrement asymétrique s’appuie sur une paire de clés : une clé publique (que l’utilisateur peut partager publiquement sur Internet ou par d’autres canaux) et une clé privée (que l’utilisateur doit garder secrète).

Sécurité et gestion des clés

Le chiffrement symétrique est généralement plus rapide et plus efficace, mais le chiffrement asymétrique permet de surmonter les vulnérabilités liées au partage sécurisé d’une clé entre l’expéditeur et le destinataire. Avec le chiffrement asymétrique, vous pouvez partager librement la clé publique avec n’importe qui, même par des canaux non sécurisés, car seuls les détenteurs de la clé privée correspondante peuvent déchiffrer les fichiers. Le destinataire garde cette clé secrète.

Si Alice souhaite recevoir des fichiers chiffrés de Bob en toute sécurité, elle doit générer une paire de clés publique et privée, puis envoyer la clé publique à Bob. Une fois cette clé reçue, Bob peut chiffrer les fichiers et les transmettre par Internet. Alice, qui détient la clé privée, est la seule à pouvoir les déchiffrer.

Si Alice souhaite ensuite envoyer un fichier chiffré à Bob, celui-ci doit créer sa propre paire de clés publique et privée. Lorsqu’il envoie la clé publique à Alice, elle peut chiffrer le fichier avec cette clé, puis l’envoyer à Bob. Bob utilise alors sa propre clé privée pour le déchiffrer.

Pour utiliser le chiffrement asymétrique, chaque personne doit posséder sa propre paire de clés publique et privée.

Cas d’utilisation

Les applications utilisent principalement le chiffrement asymétrique pour l’échange sécurisé de clés dans les protocoles TLS/SSL, la communication sécurisée par e-mail avec Pretty Good Privacy (PGP) et les certificats numériques qui vérifient l’identité de l’expéditeur ou du destinataire d’un message. Le chiffrement asymétrique offre un niveau de sécurité élevé sans nécessiter de partage sécurisé des clés.

Algorithmes de chiffrement asymétrique

Découvrons quelques algorithmes de chiffrement asymétrique populaires pour générer des paires de clés, notamment RSA, ElGamal et Curve25519.

Rivest-Shamir-Adleman (RSA)

RSA est l’un des algorithmes de chiffrement asymétrique les plus anciens et les plus populaires. Il repose sur la difficulté mathématique de factoriser de grands nombres composites en facteurs premiers.

La génération de clés RSA consiste à sélectionner deux grands nombres premiers, à calculer le module et la fonction indicatrice d’Euler, puis à dériver les composantes de la clé privée et de la clé publique. RSA est utilisé presque partout. Il est extrêmement sécurisé lorsque les clés sont suffisamment longues — 2 048 bits ou plus — mais son coût de calcul est supérieur à celui d’autres algorithmes.

ElGamal

ElGamal repose sur la résolution du problème du logarithme discret. Cet algorithme est plus rapide que RSA, mais moins sécurisé et nécessite des clés plus longues pour offrir une meilleure sécurité. La génération de clés ElGamal consiste à sélectionner un groupe cyclique et un générateur, puis à calculer les clés publique et privée à l’aide de l’exponentiation modulaire. Le chiffrement randomise le texte en clair et le multiplie par la clé publique du destinataire.

Curve25519

Curve25519 est l’un des algorithmes de cryptographie à courbe elliptique (ECC) les plus rapides et les plus sécurisés. Il sert aux échanges de clés et aux signatures numériques. Les algorithmes ECC offrent une sécurité élevée avec des clés plus courtes que celles de RSA.

L’ECC utilise les propriétés mathématiques des courbes elliptiques sur des corps finis. La génération de clés consiste à sélectionner une courbe elliptique et un point de base, puis à calculer les clés publique et privée à partir de la multiplication scalaire sur la courbe.

L’ECC est principalement utilisé dans les environnements et appareils aux ressources limitées, comme les systèmes IoT et les systèmes blockchain. Il nécessite moins de calculs tout en offrant un niveau de sécurité comparable à celui de RSA.

Implémenter le chiffrement asymétrique en Python

Commencez par créer un nouveau fichier asym_encryptor.py dans le répertoire de votre projet à l’aide de la commande suivante :

$ touch asym_encryptor.py

Importez les bibliothèques suivantes :

from nacl.public import PrivateKey, PublicKey, SealedBox
from nacl.exceptions import TypeError, CryptoError
import argparse

Le module nacl.public contient des classes permettant de générer des paires de clés privée/publique, ainsi que des méthodes associées pour gérer le chiffrement et le déchiffrement. Les classes PrivateKey et PublicKey initialisent les clés correspondantes à partir d’une séquence d’octets, tandis que SealedBox chiffre et déchiffre les messages destinés à une paire de clés spécifique. La commande importe également les classes d’exception TypeError et CryptoError pour la gestion des erreurs.

Créer une fonction utilitaire

Créez ensuite une fonction utilitaire pour générer des paires de clés :

1def generate_keys():
2    """
3    Generates a new key pair
4    """
5    private_key = PrivateKey.generate()
6    public_key = private_key.public_key
7    with open("prv.key", "wb") as f:
8        f.write(private_key.encode())
9    with open("pub.key", "wb") as f:
10        f.write(public_key.encode())
11    print("generated private/public key pair")

À l’aide de l’algorithme ECC Curve25519, cette fonction génère un objet PrivateKey aléatoire avec la méthode generate(), ainsi que la clé publique correspondante. Elle écrit ensuite les clés générées dans les fichiers correspondants.

Créer une fonction de chiffrement des messages

Ajoutez maintenant la fonction suivante pour chiffrer des messages à l’aide de la clé publique :

1def encrypt(message, receiver_public_key):
2    """
3    Encrypts the given message with the public key.
4    Returns the ciphertext of the message.
5    """
6    try:
7        with open(receiver_public_key, "rb") as f:
8            rpk = PublicKey(f.read())
9
10        box = SealedBox(rpk)
11        ciphertext = box.encrypt(message)
12
13        with open("encrypted.bin", "wb") as f:
14            f.write(ciphertext)
15        print("public key encryption completed")
16    except ValueError:
17        print("Error: public key must be exactly 32 bytes long, check keys")

Cette fonction prend un message en clair encodé en binaire à chiffrer et une chaîne indiquant l’emplacement de la clé publique. Elle charge et initialise ensuite la clé publique avec la classe PublicKey, puis initialise un objet SealedBox à l’aide de la clé publique.

Créer la fonction de déchiffrement

PyNaCl prend en charge le chiffrement asymétrique au moyen de deux classes : Box et SealedBox. Box crée une clé partagée à partir de la clé privée de l’expéditeur et de la clé publique du destinataire pour le chiffrement. Le déchiffrement nécessite les clés privée et publique, ce qui fournit une preuve cryptographique que le message a été envoyé par son auteur.

Nous utilisons la classe SealedBox pour créer la fonction de déchiffrement. Elle permet de chiffrer et de déchiffrer avec une simple paire de clés, sans preuve cryptographique de l’identité de l’expéditeur. Nous initialisons SealedBox avec la clé publique pour le chiffrement, puis appelons la méthode encrypt() avec le message à chiffrer. Nous écrivons ensuite le texte chiffré correspondant dans un fichier du répertoire de travail.

Ajoutez le code suivant à l’application :

1def decrypt(ciphertext, receiver_private_key):
2    """
3    Decrypts the given message with the private key.
4    Returns the original decrypted message.
5    """
6    with open(receiver_private_key, "rb") as f:
7        secret_key = PrivateKey(f.read())
8
9    try:
10        box = SealedBox(secret_key)
11        decrypted_text = box.decrypt(ciphertext)
12
13        with open("decrypted.file", "wb") as f:
14            f.write(decrypted_text)
15        print("private key decryption completed")
16    except TypeError:
17        print("Error: invalid ciphertext")
18    except CryptoError:
19        print("Error: decryption failed, make sure keys are correct")

Cette fonction prend le texte chiffré à déchiffrer et la clé privée. Elle charge et initialise la clé privée avec la classe PrivateKey, puis initialise un objet SealedBox à l’aide de la clé privée pour le déchiffrement. La fonction déchiffre le message avec la méthode decrypt(), puis enregistre le texte déchiffré dans un fichier du répertoire de travail.

Ajouter l’analyse des arguments de la ligne de commande

Ajoutez l’analyse des arguments de la ligne de commande avec le code suivant pour faciliter les tests de votre application :

1def parse_arguments():
2    parser = argparse.ArgumentParser(description="Encrypt/Decrypt messages with Asymmetric Encryption")
3    parser.add_argument("-i", metavar="[file]", type=str, required=False, help="file to encrypt/decrypt")
4    parser.add_argument("-g", "--generate", action="store_true", help="generate keys")
5    parser.add_argument("-p", metavar="[key]", type=str, required=False, help="key file")
6
7    group = parser.add_mutually_exclusive_group()
8    group.add_argument("-e", "--encrypt", action="store_true", help="encrypt mode")
9    group.add_argument("-d", "--decrypt", action="store_true", help="decrypt mode")
10
11    args = parser.parse_args()
12    return args
13
14# Parse command-line arguments
15args = parse_arguments()
16
17if args.generate:
18    generate_keys()
19else:
20    file_name = args.i
21    if file_name:
22        with open(file_name, "rb") as f:
23            data = f.read()
24        key = args.p
25        if key:
26            if args.encrypt:
27                encrypt(data, key)
28            elif args.decrypt:
29                decrypt(data, key)
30            else:
31                print("must provide encryption/decryption mode: (-e/-d)")
32        else:
33            print("provide key for encryption/decryption with -p flag")

Ce code analyse les arguments de la ligne de commande et définit des options permettant de choisir entre les modes de chiffrement et de déchiffrement, de générer des paires de clés et de transmettre des fichiers.

Enregistrez le fichier, puis exécutez la commande suivante :

$ python asym_encryptor.py --help

Voici le résultat :

usage: asym_encryptor.py [-h] [-i [file]] [-g] [-p [key]] [-e | -d]

Encrypt/Decrypt messages with Asymmetric Encryption

options:
  -h, --help  	show this help message and exit
  -i [file]   	file to encrypt/decrypt
  -g, --generate  generate keys
  -p [key]    	key file
  -e, --encrypt   encrypt mode
  -d, --decrypt   decrypt mode

Tester l’application

Pour tester l’application, créez un fichier texte quelconque, comme celui ci-dessous :

$ cat > test
Hello World!!!

Avant de lancer le fichier dans le processus de chiffrement, exécutez la commande suivante pour générer des paires de clés de test :

$ python asym_encryptor.py -g

Voici le résultat :

generated private/public key pair

Cette commande crée les paires de clés privée/publique dans le répertoire du projet.

Exécutez maintenant la commande suivante pour chiffrer le fichier texte à l’aide de la clé publique générée :

$ python asym_encryptor.py -e -p pub.key -i test

Le résultat affiché est le suivant :

public key encryption completed

L’application crée le texte chiffré et l’enregistre sous le nom encrypted.bin dans le répertoire du projet. Ce fichier chiffré est totalement illisible. Seule la clé privée correspondant à la clé publique permet de le déchiffrer, comme ci-dessous :

$ python asym_encryptor.py -d -p prv.key -i encrypted.bin

Voici le résultat : 

private key decryption completed

L’application a maintenant enregistré le fichier déchiffré sous le nom decrypted.file dans le répertoire du projet. Lisez le fichier déchiffré à l’aide de la commande ci-dessous :

$ cat decrypted.file

Une fois l’opération terminée, le résultat affiché est “Hello World!!!”. 

Nous avons maintenant chiffré et déchiffré avec succès un fichier en clair à l’aide du chiffrement asymétrique.

Enjeux de sécurité et bonnes pratiques pour le chiffrement symétrique et asymétrique

L’un des principaux inconvénients du chiffrement symétrique est la difficulté de partager les clés de manière sécurisée. Plus le nombre de participants au système augmente, plus la distribution des clés devient complexe. Le chiffrement asymétrique contourne ce problème grâce aux paires de clés publique/privée, tandis que le chiffrement symétrique peut recourir à des méthodes comme le chiffrement enveloppe pour renforcer la sécurité.

Voici quelques bonnes pratiques à suivre pour le chiffrement symétrique et asymétrique :

• Pour gérer les clés des applications à chiffrement symétrique, utilisez des outils de fournisseurs comme Google Cloud Platform (GCP) ou AWS, par exemple AWS KMS.

• Dans la mesure du possible, évitez le chiffrement RSA pour pérenniser vos applications. Les risques pour sa sécurité incluent des clés trop courtes (moins de 2 048 bits), que les pirates peuvent casser, et des paramètres d’initialisation inadaptés. Il est difficile de mettre en œuvre RSA correctement.

• Pour les fichiers volumineux, privilégiez le chiffrement symétrique, plus performant que les solutions asymétriques.

• Lors du choix des clés, optez pour une longueur adaptée à l’algorithme de chiffrement. Les clés trop courtes créent des failles. N’utilisez pas d’algorithmes non sécurisés comme DES.

• Ne développez pas vos propres solutions cryptographiques : il est facile de commettre des erreurs.

Utilisez des outils comme Snyk pour détecter les problèmes de sécurité dans votre code et obtenir des recommandations. La plateforme Snyk vous permet d’analyser, de corriger et de hiérarchiser les vulnérabilités de sécurité dans votre code, vos dépendances open source, vos images de conteneur et vos configurations d’infrastructure as code (IaC).

Tenez compte de ces facteurs pour choisir le type de chiffrement à utiliser, car chaque technique a ses forces et ses faiblesses. En pratique, vous pouvez combiner chiffrement symétrique et asymétrique pour trouver le bon équilibre entre efficacité et sécurité.

Utiliser Snyk

Pour découvrir comment Snyk peut détecter les vulnérabilités pendant le développement, utilisons-le pour analyser notre code.

Commencez par créer un compte Snyk. L’inscription est gratuite.

Après votre inscription, Snyk vous redirige vers la page suivante, qui vous demande où se trouve le code à analyser : sur GitHub, dans Bitbucket Cloud ou via une CLI.

Sélectionnez CLI, puis cliquez sur Next step.

Sur l’écran suivant, suivez l’une des étapes proposées pour installer la CLI Snyk, puis cliquez sur Next step :

Exécutez ensuite la commande suivante pour authentifier votre machine :

$ snyk auth

Cette commande ouvre une fenêtre de navigateur vous invitant à vous connecter. Une fois cette étape terminée, la CLI Snyk affiche un message confirmant la réussite de l’authentification.

Cliquez maintenant sur Next step.

Cliquez sur Source code, puis suivez le lien Settings > Snyk Code vers votre tableau de bord. Activez l’option Enable Snyk Code dans votre tableau de bord pour exécuter la CLI Snyk sur votre code. Cliquez ensuite sur Save changes.

Pour analyser votre code, exécutez la commande suivante dans le répertoire du projet :

$ snyk code test

Cette commande téléverse automatiquement vos fichiers de code et les analyse à la recherche de vulnérabilités :

La capture d’écran ci-dessus montre que notre application présente une vulnérabilité de traversée de répertoires, qui permet à un attaquant de lire des fichiers arbitraires. Nous pouvons laisser cette vulnérabilité dans le code de notre application de démonstration, mais elle représente un vecteur d’attaque dans des bases de code plus fonctionnelles.

Nous avons utilisé Snyk avec succès pour analyser notre projet à la recherche de vulnérabilités.

Résumé

Le chiffrement symétrique et le chiffrement asymétrique se distinguent par la manière dont ils utilisent les clés pour chiffrer et déchiffrer des fichiers. Le premier utilise une clé partagée unique, tandis que le second s’appuie sur une paire de clés publique/privée.

Grâce à sa mise en œuvre et à son efficacité en matière de calcul, le chiffrement symétrique convient mieux au chiffrement de grandes quantités de données au repos. Le chiffrement asymétrique est adapté aux transmissions de données à petite échelle, comme TLS/SSL et les certificats numériques.

Dans ce guide, nous avons mis en œuvre le chiffrement enveloppe (qui combine les chiffrements symétrique et asymétrique) à l’aide de l’AWS Encryption SDK. Nous avons également mis en œuvre le chiffrement et le déchiffrement asymétriques avec la bibliothèque Python pynacl. Nous avons examiné les forces et les faiblesses des deux types de chiffrement, notamment avec des clés plus courtes. Nous avons aussi montré comment utiliser des plateformes comme Snyk pour analyser nos applications à la recherche de vulnérabilités.

Maintenant que vous en savez plus sur le chiffrement, vous pouvez utiliser ces méthodes pour mieux protéger vos applications et leurs utilisateurs. Utilisez ensuite Snyk pour vérifier la sécurité de votre approche.