TOC

Comment vérifier le code et chiffrer les données avec Python-GnuPG et Python 3

L’auteur a sélectionné le Open Internet / Free Speech Fund pour recevoir un don dans le cadre du https://do.co/w4do-cta Programme [Write for DOnations] .

introduction

Le paquet GnuPG offre une solution complète pour la génération et le stockage de clés cryptographiques. Il vous permet également de chiffrer et de signer des données et des communications.

Dans ce didacticiel, vous allez créer une série de scripts utilisant Python 3 avec le module python-gnupg. Ces scripts vous permettront de signer et de chiffrer plusieurs fichiers et de vérifier l’intégrité d’un script avant de l’exécuter.

Conditions préalables

Avant de poursuivre ce didacticiel, remplissez les conditions préalables suivantes:

Étape 1 - Récupération des informations de paire de clés

Après avoir terminé le tutoriel GnuPG dans les prérequis, vous aurez une paire de clés stockée dans + .gnupg + sous votre répertoire personnel. GnuPG stocke les clés avec un nom d’utilisateur et un courrier électronique pour aider à identifier les paires de clés. Dans cet exemple, notre nom d’utilisateur est * sammy * et notre adresse électronique est ++.

Exécutez la commande ci-dessous pour obtenir une liste de vos clés disponibles:

gpg --list-keys
Output/home//.gnupg/pubring.gpg
-----------------------------
pub   2048R/4920B23F 2018-04-23
uid
sub   2048R/50C06279 2018-04-23

Notez l’adresse e-mail affichée dans la ligne + uid + de votre sortie. Vous en aurez besoin plus tard pour identifier vos clés.

Étape 2 - Installation de Python-GnuPG et signature des fichiers

Avec vos clés en place, vous pouvez installer le module + python-gnupg +, qui agit comme un wrapper autour de GnuPG pour permettre l’interaction entre GnuPG et Python 3. En utilisant ce module, vous pourrez créer des scripts Python qui ont les effets suivants:

  • Créez des signatures détachées pour les fichiers, en ajoutant une couche de sécurité au processus de signature en dissociant les signatures des fichiers.

  • Crypter des fichiers.

  • Décrypter les fichiers.

  • Vérifiez les signatures et les scripts détachés.

Vous allez d’abord créer les scripts, ainsi que des fichiers de test, avant de tester les scripts de ces fichiers.

Pour commencer, installons le module + python-gnupg +, ainsi que le paquetage + fs +, qui vous permettra d’ouvrir, de lire et d’écrire vos fichiers de test. Mettez à jour votre index de paquets et installez ces paquets avec + pip +:

sudo apt-get update
sudo pip3 install python-gnupg fs

Une fois ces packages en place, nous pouvons passer à la création des scripts et des fichiers de test.

Pour stocker les scripts et les fichiers de test, créez un dossier dans votre répertoire personnel appelé + python-test +:

cd ~/
mkdir python-test

Déplacer vers ce répertoire:

cd python-test/

Ensuite, créons trois fichiers de test:

echo "This is the first test file" > test1.txt
echo "print('This test file is a Python script')" > test2.py
echo "This is the last test file" > test3.txt

Pour créer des signatures détachées pour nos fichiers de test, créons un script appelé + signdetached.py, qui ciblera tous les fichiers du répertoire où il est exécuté. Une signature fait office d’horodatage et certifie l’authenticité du document.

Les signatures détachées seront stockées dans un nouveau dossier appelé + signatures / +, qui sera créé lors de l’exécution du script.

Ouvrez un nouveau fichier appelé + signdetach.py ​​+ en utilisant + nano + ou votre éditeur de texte préféré:

nano signdetach.py

Commençons par importer tous les modules requis pour le script. Ceux-ci incluent les paquets + os + et + fs +, qui permettent la navigation dans les fichiers, et + gnupg +:

~ / python-test / signdetach.py

#!/usr/bin/env python3

import os
import fs
from fs import open_fs
import gnupg

Définissons maintenant le répertoire où GnuPG trouvera ses clés de chiffrement. GnuPG stocke ses clés dans + .gnupg + par défaut, nous allons donc configurer ceci avec notre nom d’utilisateur. Assurez-vous de remplacer * sammy * par le nom de votre utilisateur non root:

~ / python-test / signdetach.py

...
gpg = gnupg.GPG(gnupghome="/home//.gnupg")

Créons ensuite une variable + home_fs + pour stocker l’emplacement du répertoire actuel en tant qu’objet fichier. Cela permettra au script de fonctionner dans le répertoire où il est exécuté:

~ / python-test / signdetach.py

...
home_fs = open_fs(".")

A ce stade, votre script ressemblera à ceci:

~ / python-test / signdetach.py

#!/usr/bin/env python3

import os
import fs
from fs import open_fs
import gnupg

gpg = gnupg.GPG(gnupghome="/home//.gnupg")
home_fs = open_fs(".")

Ce bloc de configuration est le modèle de base que vous utiliserez dans vos scripts tout au long de ce didacticiel.

Ajoutez ensuite du code pour vérifier s’il existe un dossier nommé + signatures / + et créez-le s’il n’existe pas:

~ / python-test / signdetach.py

...
if os.path.exists("signatures/"):
       print("Signatures directory already created")
else:
       home_fs.makedir(u"signatures")
       print("Created signatures directory")

Créez un tableau vide dans lequel stocker les noms de fichiers, puis analysez le répertoire en cours en ajoutant tous les noms de fichiers au tableau + rép_fichier +:

~ / python-test / signdetach.py

...
files_dir = []

files = [f for f in os.listdir(".") if os.path.isfile(f)]
for f in files:
   files_dir.append(f)

La prochaine étape du script consiste à générer des signatures détachées pour les fichiers. Boucler dans le tableau + rép_fichier + créera une signature pour chaque fichier en utilisant la première clé privée de votre trousseau. Pour accéder à la clé privée, vous devez la déverrouiller avec la phrase secrète que vous avez définie. Remplacez ++ par le mot de passe que vous avez utilisé lorsque vous avez généré la paire de clés dans les conditions préalables:

~ / python-test / signdetach.py

...
for x in files_dir:
   with open(x, "rb") as f:
       stream = gpg.sign_file(f,passphrase=,detach = True, output=files_dir[files_dir.index(x)]+".sig")
       os.rename(files_dir[files_dir.index(x)]+".sig", "signatures/"+files_dir[files_dir.index(x)]+".sig")
       print(x+" ", stream.status)

Une fois terminé, toutes les signatures seront déplacées dans le dossier + signatures / +. Votre script fini ressemblera à ceci:

~ / python-test / signdetach.py

#!/usr/bin/env python3

import os
import fs
from fs import open_fs
import gnupg

gpg = gnupg.GPG(gnupghome="/home//.gnupg")
home_fs = open_fs(".")

if os.path.exists("signatures/"):
   print("Signatures directory already created")
else:
   home_fs.makedir(u"signatures")
   print("Created signatures directory")

files_dir = []

files = [f for f in os.listdir(".") if os.path.isfile(f)]
for f in files:
   files_dir.append(f)

for x in files_dir:
   with open(x, "rb") as f:
       stream = gpg.sign_file(f,passphrase=,detach = True, output=files_dir[files_dir.index(x)]+".sig")
       os.rename(files_dir[files_dir.index(x)]+".sig", "signatures/"+files_dir[files_dir.index(x)]+".sig")
       print(x+" ", stream.status)

Nous pouvons maintenant passer au cryptage des fichiers.

Étape 3 - Cryptage des fichiers

L’exécution du script de chiffrement dans un dossier entraînera la copie et le chiffrement de tous les fichiers de ce dossier dans un nouveau dossier appelé + crypté / +. La clé publique utilisée pour chiffrer les fichiers est celle qui correspond au courrier électronique que vous avez spécifié dans la configuration de votre paire de clés.

Ouvrez un nouveau fichier nommé + encrypt files.py:

nano encryptfiles.py

Commencez par importer tous les modules requis, définissez le répertoire de base de GnuPG et créez la variable de répertoire de travail actuelle:

~ / python-test / encryptfiles.py

#!/usr/bin/env python3

import os
import fs
from fs import open_fs
import gnupg

gpg = gnupg.GPG(gnupghome="/home//.gnupg")
home_fs = open_fs(".")

Ensuite, ajoutons du code pour vérifier si le répertoire en cours a déjà un dossier nommé + encrypted / +, et pour le créer s’il n’existe pas:

~ / python-test / encryptfiles.py

...
if os.path.exists("encrypted/"):
       print("Encrypt directory exists")
else:
       home_fs.makedir(u"encrypted")
       print("Created encrypted directory")

Avant de rechercher les fichiers à chiffrer, créons un tableau vide pour stocker les noms de fichiers:

~ / python-test / encryptfiles.py

...
files_dir = []

Ensuite, créez une boucle pour analyser le dossier à la recherche de fichiers et les ajouter au tableau:

~ / python-test / encryptfiles.py

...
files = [f for f in os.listdir(".") if os.path.isfile(f)]
for f in files:
   files_dir.append(f)

Enfin, créons une boucle pour chiffrer tous les fichiers du dossier. Une fois terminé, tous les fichiers cryptés seront transférés dans le dossier + encrypted / +. Dans cet exemple, "++" est l’ID de messagerie de la clé à utiliser lors du chiffrement. Assurez-vous de remplacer ceci par l’adresse de messagerie notée à l’étape 1:

~ / python-test / encryptfiles.py

...
for x in files_dir:
   with open(x, "rb") as f:
       status = gpg.encrypt_file(f,recipients=[],output= files_dir[files_dir.index(x)]+".gpg")
       print("ok: ", status.ok)
       print("status: ", status.status)
       print("stderr: ", status.stderr)
       os.rename(files_dir[files_dir.index(x)] + ".gpg", 'encrypted/' +files_dir[files_dir.index(x)] + ".gpg")

Si vous avez plusieurs clés stockées dans votre dossier + .gnupg + et que vous souhaitez utiliser une clé publique spécifique ou plusieurs clés publiques pour le chiffrement, vous devez modifier le tableau + destinataires + en ajoutant les destinataires supplémentaires ou en remplaçant le destinataire actuel. .

Votre fichier de script + encrypt files.py ressemblera à ceci lorsque vous aurez terminé:

~ / python-test / encryptfiles.py

#!/usr/bin/env python3

import os
import fs
from fs import open_fs
import gnupg

gpg = gnupg.GPG(gnupghome="/home//.gnupg")
home_fs = open_fs(".")

if os.path.exists("encrypted/"):
   print("Encrypt directory exists")
else:
   home_fs.makedir(u"encrypted")
   print("Created encrypted directory")

files_dir = []

files = [f for f in os.listdir(".") if os.path.isfile(f)]
for f in files:
   files_dir.append(f)

for x in files_dir:
   with open(x, "rb") as f:
       status = gpg.encrypt_file(f,recipients=[],output= files_dir[files_dir.index(x)]+".gpg")
       print("ok: ", status.ok)
       print("status: ", status.status)
       print("stderr: ", status.stderr)
       os.rename(files_dir[files_dir.index(x)] + ".gpg", "encrypted/" +files_dir[files_dir.index(x)] + ".gpg")

Voyons maintenant la deuxième partie du processus: décrypter et vérifier plusieurs fichiers à la fois.

Étape 4 - Déchiffrer des fichiers

Le script de déchiffrement fonctionne de la même manière que le script de chiffrement, à la différence qu’il doit être exécuté dans un répertoire + crypté / +. Une fois lancé, + decryptfiles.py + identifiera d’abord la clé publique utilisée, puis recherchera la clé privée correspondante dans le dossier + .gnupg + pour déchiffrer le fichier. Les fichiers décryptés seront stockés dans un nouveau dossier appelé + décrypté / +.

Ouvrez un nouveau fichier nommé + decrypt files.py + avec + nano + ou votre éditeur préféré:

nano decryptfiles.py

Commencez par insérer les paramètres de configuration:

~ / python-test / decryptfiles.py

#!/usr/bin/env python3

import os
import fs
from fs import open_fs
import gnupg

gpg = gnupg.GPG(gnupghome="/home//.gnupg")
home_fs = open_fs(".")

Ensuite, créez deux tableaux vides pour stocker les données lors de l’exécution du script:

~ / python-test / decryptfiles.py

...
files_dir = []
files_dir_clean = []

Le but ici est que le script place les fichiers déchiffrés dans leur propre dossier; sinon, les fichiers chiffrés et déchiffrés seront mélangés, ce qui rendra difficile la localisation d’un fichier déchiffré spécifique. Pour résoudre ce problème, vous pouvez ajouter du code qui analysera le dossier actuel pour voir s’il existe un dossier + déchiffré / +, en le créant s’il ne le fait pas:

~ / python-test / decryptfiles.py

...
if os.path.exists("decrypted/"):
   print("Decrypted directory already exists")
else:
   home_fs.makedir(u"decrypted/")
   print("Created decrypted directory")

Parcourez le dossier et ajoutez tous les noms de fichiers au tableau + files_dir +:

~ / python-test / decryptfiles.py

...
files = [f for f in os.listdir(".") if os.path.isfile(f)]
for f in files:
   files_dir.append(f)

L’extension + .gpg + est ajoutée à tous les fichiers cryptés pour indiquer qu’ils sont cryptés. Cependant, lors du déchiffrement, nous voulons les sauvegarder sans cette extension, car ils ne sont plus chiffrés.

Pour ce faire, parcourez le tableau + files_dir + et supprimez l’extension + .gpg + de chaque nom de fichier:

~ / python-test / decryptfiles.py

...
   for x in files_dir:
           length = len(x)
           endLoc = length - 4
           clean_file = x[0:endLoc]
           files_dir_clean.append(clean_file)

Les nouveaux noms de fichiers «nettoyés» sont stockés dans le tableau + file_dir_clean +.

Ensuite, parcourons les fichiers et les décryptez. Remplacez ++ par votre phrase secrète pour déverrouiller la clé privée:

~ / python-test / decryptfiles.py

...
for x in files_dir:
   with open(x, "rb") as f:
      status = gpg.decrypt_file(f, passphrase=,output=files_dir_clean[files_dir.index(x)])
      print("ok: ", status.ok)
      print("status: ", status.status)
      print("stderr: ", status.stderr)
      os.rename(files_dir_clean[files_dir.index(x)], "decrypted/" + files_dir_clean[files_dir.index(x)])

Votre fichier de script ressemblera à ceci lorsque vous aurez terminé:

~ / python-test / decryptfiles.py

#!/usr/bin/env python3

import os
import fs
from fs import open_fs
import gnupg

gpg = gnupg.GPG(gnupghome="/home//.gnupg")
home_fs = open_fs(".")

files_dir = []
files_dir_clean = []

if os.path.exists("decrypted/"):
   print("Decrypted directory already exists")
else:
   home_fs.makedir(u"decrypted/")
   print("Created decrypted directory")

files = [f for f in os.listdir(".") if os.path.isfile(f)]
for f in files:
   files_dir.append(f)

for x in files_dir:
   length = len(x)
   endLoc = length - 4
   clean_file = x[0:endLoc]
   files_dir_clean.append(clean_file)

for x in files_dir:
   with open(x, "rb") as f:
      status = gpg.decrypt_file(f, passphrase=,output=files_dir_clean[files_dir.index(x)])
      print("ok: ", status.ok)
      print("status: ", status.status)
      print("stderr: ", status.stderr)
      os.rename(files_dir_clean[files_dir.index(x)], "decrypted/" + files_dir_clean[files_dir.index(x)])

Avec notre script de déchiffrement en place, nous pouvons passer à la vérification des signatures détachées pour plusieurs fichiers.

Étape 5 - Vérification des signatures détachées

Pour vérifier les signatures numériques détachées de plusieurs fichiers, écrivons un script + verifydetach.py ​​+. Ce script recherchera un dossier + signatures / + dans le répertoire de travail et vérifiera chaque fichier avec sa signature.

Ouvrez un nouveau fichier nommé + verifydetach.py ​​+:

nano verifydetach.py

Importez toutes les bibliothèques nécessaires, définissez les répertoires de travail et de base, et créez le tableau + files_dir + vide, comme dans les exemples précédents:

~ / python-test / verifydetach.py

#!/usr/bin/env python3

import os
import fs
from fs import open_fs
import gnupg

gpg = gnupg.GPG(gnupghome="/home//.gnupg")
home_fs = open_fs(".")

files_dir = []

Ensuite, analysons le dossier contenant les fichiers à vérifier. Les noms de fichiers seront ajoutés au tableau + files_dir + vide:

~ / python-test / verifydetach.py

...
files = [f for f in os.listdir(".") if os.path.isfile(f)]
for f in files:
files_dir.append(f)

Enfin, vérifions chaque fichier avec sa propre signature détachée, en utilisant une boucle qui parcourt le tableau + files_dir + pour rechercher la signature détachée de chaque fichier dans le dossier + signatures / +. Quand il trouvera la signature détachée, il vérifiera le fichier avec. La dernière ligne affiche l’état de la vérification de chaque fichier:

~ / python-test / verifydetach.py

...
for i in files_dir:
    with open("../../signatures/" + i + ".sig", "rb") as f:
        verify = gpg.verify_file(f, i)
        print(i + " ", verify.status)

Lorsque vous aurez terminé, votre script ressemblera à ceci:

~ / python-test / verifydetach.py

#!/usr/bin/env python3

import os
import fs
from fs import open_fs
import gnupg

gpg = gnupg.GPG(gnupghome="/home//.gnupg")
home_fs = open_fs(".")

files_dir = []

files = [f for f in os.listdir(".") if os.path.isfile(f)]
for f in files:
   files_dir.append(f)

for i in files_dir:
   with open("../../signatures/" + i + ".sig", "rb") as f:
       verify = gpg.verify_file(f, i)
       print(i + " ", verify.status)

Ensuite, voyons comment vérifier la signature d’un fichier avant qu’il ne soit exécuté sur votre serveur.

Étape 6 - Vérification des fichiers

Le script final vérifiera les scripts avant leur exécution. En ce sens, il est similaire à + ​​verifydetach +, mais il a la possibilité supplémentaire de lancer des scripts vérifiés. Cela fonctionne en prenant comme argument un nom de script puis en vérifiant la signature de ce fichier. Si la vérification réussit, le script publiera un message sur la console et lancera le script vérifié. Si le processus de vérification échoue, le script enregistre l’erreur sur la console et interrompt l’exécution du fichier.

Créez un nouveau fichier nommé + verifyfile.py +:

nano verifyfile.py

Commençons par importer les bibliothèques nécessaires et définissons les répertoires de travail:

~ / python-test / verifyfile.py

#!/usr/bin/env python3

import os
import fs
from fs import open_fs
import gnupg

gpg = gnupg.GPG(gnupghome="/home//.gnupg")
home_fs = open_fs(".")

Pour que le script fonctionne, il est nécessaire de stocker le nom du fichier à vérifier et à exécuter. Pour ce faire, créons une nouvelle variable appelée + script_to_run +:

~ / python-test / verifyfile.py

...
script_to_run = str(sys.argv[1])

Cette variable prend le premier argument et le stocke dans la variable nouvellement créée. Ensuite, le script ouvrira le fichier de signature détaché, vérifiera le fichier dans + script_to_run + avec sa signature, puis l’exécutera s’il réussit la vérification:

~ / python-test / verifyfile.py

...
with open("../../signatures/" + script_to_run + ".sig", "rb") as f:
    verify = gpg.verify_file(f, script_to_run)
    print(script_to_run + " ", verify.status)
    if verify.status == "signature valid":
         print("Signature valid, launching script...")
         exec(open(script_to_run).read())
    else:
          print("Signature invalid or missing, ")
          print("aborting script execution")

Le script fini ressemblera à ceci:

~ / python-test / verifyfile.py

#!/usr/bin/env python3

import os
import sys
import fs
from fs import open_fs
import gnupg

gpg = gnupg.GPG(gnupghome="/home//.gnupg")
home_fs = open_fs(".")

script_to_run = str(sys.argv[1])

with open("../../signatures/" + script_to_run + ".sig", "rb") as f:
   verify = gpg.verify_file(f, script_to_run)
   print(script_to_run + " ", verify.status)
   if verify.status == "signature valid":
       print("Signature valid, launching script...")
       exec(open(script_to_run).read())
   else:
       print("Signature invalid or missing, ")
       print("aborting script execution")

Nous avons fini de créer les scripts, mais pour le moment, ils ne peuvent être lancés qu’à partir du dossier en cours. Dans l’étape suivante, nous modifierons leurs autorisations pour les rendre globalement accessibles.

Étape 7 - Rendre les scripts disponibles à l’échelle du système

Pour plus de facilité, rendons les scripts exécutables depuis n’importe quel répertoire ou dossier du système et plaçons-les dans notre + $ PATH +. Utilisez la commande + chmod + pour octroyer des autorisations d’exécution au propriétaire des fichiers, votre utilisateur non root:

chmod +x *.py

Maintenant, pour trouver vos paramètres + $ PATH +, exécutez la commande suivante:

echo $PATH
Output-bash: /home//bin:/home//.local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin

Les fichiers stockés dans votre + $ PATH seront accessibles à partir de n’importe quel dossier de votre système, si les autorisations du répertoire le permettent. Vous pouvez placer vos scripts n’importe où dans votre + $ PATH +, mais pour l’instant, déplaçons les scripts du répertoire + python-test / + vers + / usr / local / bin / +.

Notez que nous supprimons l’extension + .py + lors de la copie des fichiers. Si vous regardez la première ligne des scripts que nous avons créés, vous verrez + #! Usr / bin / env python3 +. Cette ligne est appelée shebang et aide le système d’exploitation à identifier l’interprète ou l’environnement bash à utiliser lors de l’exécution du code. Lorsque nous exécutons le script, le système d’exploitation notera que nous avons spécifié Python comme environnement et transmettra le code à Python pour exécution. Cela signifie que nous n’avons plus besoin d’extensions de fichiers pour identifier l’environnement dans lequel nous souhaitons travailler:

sudo mv encryptfiles.py /usr/local/bin/encryptfiles
sudo mv decryptfiles.py /usr/local/bin/decryptfiles
sudo mv signdetach.py /usr/local/bin/signdetach
sudo mv verifyfile.py /usr/local/bin/verifyfile
sudo mv verifydetach.py /usr/local/bin/verifydetach

Désormais, les scripts peuvent être exécutés n’importe où sur le système en exécutant simplement le nom du script, ainsi que tous les arguments que le script peut utiliser à partir de la ligne de commande. Dans la prochaine étape, nous examinerons quelques exemples d’utilisation de ces scripts.

Étape 8 - Test des scripts

Maintenant que nous avons déplacé les scripts vers notre + $ PATH +, nous pouvons les exécuter à partir de n’importe quel dossier du serveur.

Tout d’abord, vérifiez si vous travaillez toujours dans le répertoire + python-test avec la commande` + pwd`:

pwd

Le résultat devrait être:

Output/home//python-test

Vous avez créé trois fichiers de test plus tôt dans le tutoriel. Exécutez la commande + ls -l + pour répertorier les fichiers du dossier:

ls -l

Vous devriez voir trois fichiers stockés dans votre dossier + python-test:

Output-rw-rw-r-- 1 sammy sammy 15 Apr 15 10:08 test1.txt
-rwxrwxr-x 1 sammy sammy 15 Apr 15 10:08 test2.py
-rw-rw-r-- 1 sammy sammy 15 Apr 15 10:08 test3.txt

Nous allons tester les scripts sur ces trois fichiers. Vous pouvez rapidement afficher le contenu des fichiers avant le cryptage à l’aide de la commande + cat +, comme suit:

cat test1.txt
OutputThis is the first test file

Commençons par créer des signatures détachées pour tous les fichiers. Pour ce faire, exécutez le script + signdetach + depuis le dossier actuel:

signdetach
OutputCreated signatures directory
test2.py  signature created
test1.txt  signature created
test3.txt  signature created

Notez dans la sortie que le script a détecté que le répertoire + signatures / + n’était pas présent et l’a créé. Il a ensuite créé les signatures de fichiers.

Nous pouvons le confirmer en réexécutant la commande + ls -l +:

ls -l
Outputtotal 16

-rw-rw-r-- 1 sammy sammy 15 Apr 15 10:08 test1.txt
-rwxrwxr-x 1 sammy sammy 15 Apr 15 10:08 test2.py
-rw-rw-r-- 1 sammy sammy 15 Apr 15 10:08 test3.txt

Notez le nouveau répertoire + signatures + parmi les éléments de la liste. Listons le contenu de ce dossier et examinons de plus près l’une des signatures.

Pour lister toutes les signatures, tapez:

ls -l signatures/
Outputtotal 12
-rw-rw-r-- 1 sammy sammy 473 Apr 21 14:11 test1.txt.sig
-rw-rw-r-- 1 sammy sammy 473 Apr 21 14:11 test2.py.sig
-rw-rw-r-- 1 sammy sammy 473 Apr 21 14:11 test3.txt.sig

Les fichiers de signature détachés peuvent être identifiés par l’extension + .sig +. Encore une fois, la commande + cat + peut afficher le contenu de l’une de ces signatures. Jetons un coup d’œil au contenu de la signature + test1.txt.sig +:

cat signatures/test1.txt.sig
Output-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1

iQEcBAABAgAGBQJa20aGAAoJENVtx+Y8cX3mMhMH+gOZsLJX3aEgUPZzDlKRWYec
AyrXEGp5yIABj7eoLDKGUxftwGt+c4HZud1iEUy8AhtW/Ea6eRlMFPTso2hb9+cw
/MyffTrWGpa0AGjNvf4wbxdq7TNpAlw4nmcwKpeYqkUu2fP3c18oZ3G3R3+P781w
GWori9FK3eTyVPs9E0dVgdo7S8G1pF/ECo8Cl4Mrj80rERAitQAMbSaN/dF0wUKu
okRZPJPVjd6GwqRRkXoqwh0vm4c+p3nAhFV+v7uK2BOUIJKPFbbn58vmmn+LVaBS
MFWSb+X85KwwftIezqCV/hqsMKAuhkvfIi+YQFCDXElJMtjPBxxuvZFjQFjEHe8=
=4NB5
-----END PGP SIGNATURE-----

Cette sortie est la signature détachée pour + test1.txt +.

Avec les signatures en place, il est possible de passer au cryptage de nos fichiers. Pour ce faire, exécutez le script + encryptfiles +:

encryptfiles
OutputCreated encrypted directory
ok:  True
status:  encryption ok
stderr:  [GNUPG:] BEGIN_ENCRYPTION 2 9
[GNUPG:] END_ENCRYPTION

ok:  True
status:  encryption ok
stderr:  [GNUPG:] BEGIN_ENCRYPTION 2 9
[GNUPG:] END_ENCRYPTION

ok:  True
status:  encryption ok
stderr:  [GNUPG:] BEGIN_ENCRYPTION 2 9
[GNUPG:] END_ENCRYPTION

Dans la sortie, notez que le script a créé le dossier + encrypted / +. Notez également que tous les fichiers ont été cryptés avec succès. Exécutez à nouveau la commande + ls -l + et notez le nouveau dossier dans le répertoire:

ls -l
Outputtotal 20

drwxrwxr-x 2 sammy sammy 4096 Apr 21 14:11 signatures
-rw-rw-r-- 1 sammy sammy   15 Apr 15 10:08 test1.txt
-rw-rw-r-- 1 sammy sammy   15 Apr 15 10:08 test2.py
-rw-rw-r-- 1 sammy sammy   15 Apr 15 10:08 test3.txt

Voyons à quoi ressemble le message + test1.txt + maintenant qu’il a été chiffré:

cat encrypted/test1.txt.gpg
Output-----BEGIN PGP MESSAGE-----
Version: GnuPG v1

hQEMA9Vtx+Y8cX3mAQf9FijeaCOKFRUWOrwOkUw7efvr5uQbSnxxbE/Dkv0y0w8S
Y2IxQPv4xS6VrjhZQC6K2R968ZQDvd+XkStKfy6NJLsfKZM+vMIWiZmqJmKxY2OT
8MG/b9bnNCORRI8Nm9etScSYcRu4eqN7AeUdWOXAFX+mo7K00IdEQH+0Ivyc+P1d
53WBgWstt8jHY2cn1sLdoHh4m70O7v1rnkHOvrQW3AAsBbKzvdzxOa0/5IKGCOYF
yC8lEYfOihyEetsasx0aDDXqrMZVviH3KZ8vEiH2n7hDgC5imgJTx5kpC17xJZ4z
LyEiNPu7foWgVZyPzD2jGPvjW8GVIeMgB+jXsAfvEdJJAQqX6qcHbf1SPSRPJ2jU
GX5M/KhdQmBcO9Sih9IQthHDXpSbSVw/UejheVfaw4i1OX4aaOhNJlnPSUDtlcl4
AUoBjuBpQMp4RQ==
=xJST
-----END PGP MESSAGE-----

La phrase stockée dans le fichier d’origine a été transformée en une série complexe de caractères et de chiffres à la suite du processus de cryptage.

Maintenant que les fichiers ont été signés et cryptés, il est possible de supprimer les originaux et de récupérer les messages originaux à partir des fichiers cryptés.

Pour supprimer les originaux, tapez:

rm *.txt *.py

Exécutez à nouveau la commande + ls -l + pour vous assurer que tous les fichiers d’origine ont été supprimés:

ls -l
Outputtotal 8
drwxrwxr-x 2 sammy sammy 4096 Apr 21 14:42 encrypted
drwxrwxr-x 2 sammy sammy 4096 Apr 21 14:11 signatures

Une fois les fichiers originaux supprimés, décryptons et vérifions les fichiers cryptés. Allez dans le dossier + crypté + et listez tous les fichiers:

cd encrypted/ && ls -l
Outputtotal 12
-rw-rw-r-- 1 sammy sammy 551 Apr 21 14:42 test1.txt.gpg
-rw-rw-r-- 1 sammy sammy 551 Apr 21 14:42 test2.py.gpg
-rw-rw-r-- 1 sammy sammy 551 Apr 21 14:42 test3.txt.gpg

Pour déchiffrer les fichiers, exécutez le script + decryptfiles + à partir du dossier actuel:

decryptfiles
OutputCreated decrypted directory
ok:  True
status:  decryption ok
stderr:  [GNUPG:] ENC_TO D56DC7E63C717DE6 1 0
[GNUPG:] USERID_HINT D56DC7E63C717DE6 Autogenerated Key <[email protected]>
[GNUPG:] NEED_PASSPHRASE D56DC7E63C717DE6 D56DC7E63C717DE6 1 0
[GNUPG:] GOOD_PASSPHRASE
gpg: encrypted with 2048-bit RSA key, ID 3C717DE6, created 2018-04-15
     "Autogenerated Key <[email protected]>"
[GNUPG:] BEGIN_DECRYPTION
[GNUPG:] DECRYPTION_INFO 2 9
[GNUPG:] PLAINTEXT 62 1524321773
[GNUPG:] PLAINTEXT_LENGTH 15
[GNUPG:] DECRYPTION_OKAY
[GNUPG:] GOODMDC
[GNUPG:] END_DECRYPTION

ok:  True
status:  decryption ok
stderr:  [GNUPG:] ENC_TO D56DC7E63C717DE6 1 0
[GNUPG:] USERID_HINT D56DC7E63C717DE6 Autogenerated Key <[email protected]>
[GNUPG:] NEED_PASSPHRASE D56DC7E63C717DE6 D56DC7E63C717DE6 1 0
[GNUPG:] GOOD_PASSPHRASE
gpg: encrypted with 2048-bit RSA key, ID 3C717DE6, created 2018-04-15
     "Autogenerated Key <[email protected]>"
[GNUPG:] BEGIN_DECRYPTION
[GNUPG:] DECRYPTION_INFO 2 9
[GNUPG:] PLAINTEXT 62 1524321773
[GNUPG:] PLAINTEXT_LENGTH 15
[GNUPG:] DECRYPTION_OKAY
[GNUPG:] GOODMDC
[GNUPG:] END_DECRYPTION

ok:  True
status:  decryption ok
stderr:  [GNUPG:] ENC_TO D56DC7E63C717DE6 1 0
[GNUPG:] USERID_HINT D56DC7E63C717DE6 Autogenerated Key <[email protected]>
[GNUPG:] NEED_PASSPHRASE D56DC7E63C717DE6 D56DC7E63C717DE6 1 0
[GNUPG:] GOOD_PASSPHRASE
gpg: encrypted with 2048-bit RSA key, ID 3C717DE6, created 2018-04-15
     "Autogenerated Key <[email protected]>"
[GNUPG:] BEGIN_DECRYPTION
[GNUPG:] DECRYPTION_INFO 2 9
[GNUPG:] PLAINTEXT 62 1524321773
[GNUPG:] PLAINTEXT_LENGTH 15
[GNUPG:] DECRYPTION_OKAY
[GNUPG:] GOODMDC
[GNUPG:] END_DECRYPTION

Le script a renvoyé + status: decryption ok + pour chaque fichier, ce qui signifie que chaque fichier a été déchiffré avec succès.

Accédez au nouveau dossier + decrypted / + et affichez le contenu de + test1.txt + à l’aide de la commande + cat +:

cd decrypted/ && cat test1.txt
OutputThis is the first test file

Nous avons récupéré le message stocké dans le fichier + test1.txt que nous avons supprimé.

Ensuite, confirmons que ce message est bien le message original en vérifiant sa signature avec le script + verifydetach +.

Le fichier de signature contient l’identité du signataire ainsi qu’une valeur de hachage calculée à l’aide des données du document signé. Pendant la vérification, + gpg + utilisera la clé publique de l’expéditeur et l’utilisera avec un algorithme de hachage pour calculer la valeur de hachage des données. La valeur de hachage calculée et la valeur stockée dans la signature doivent correspondre pour que la vérification aboutisse.

Toute falsification du fichier d’origine, du fichier de signature ou de la clé publique de l’expéditeur entraînera une modification de la valeur de hachage et un échec du processus de vérification.

Exécutez le script à partir du dossier + decrypted +:

verifydetach
Outputtest2.py  signature valid
test1.txt  signature valid
test3.txt  signature valid

Vous pouvez voir dans la sortie que tous les fichiers ont une signature valide, ce qui signifie que les documents n’ont pas été falsifiés au cours de ce processus.

Voyons maintenant ce qui se passe lorsque vous apportez des modifications à votre document après l’avoir signé. Ouvrez le fichier + test1.txt avec` + nano`:

nano test1.txt

Ajoutez maintenant la phrase suivante au fichier:

~ / python-test / crypté / décrypté / test1.txt

This is the first test file

Enregistrez et fermez le fichier.

Maintenant, exécutez à nouveau le script + verify detach et notez comment la sortie a changé:

verifydetach
Outputtest2.py  signature valid
test1.txt  signature bad
test3.txt  signature valid

Notez que GnuPG a renvoyé + signature bad + lors de la vérification de + test1.txt +. En effet, nous avons apporté des modifications au fichier après sa signature. N’oubliez pas qu’au cours du processus de vérification, + gpg + compare la valeur de hachage stockée dans le fichier de signature avec la valeur de hachage calculée à partir du document que vous avez signé. Les modifications apportées au document ont abouti à + ​​gpg + calculant une valeur de hachage différente pour + test1.txt +. Une discussion plus détaillée sur le fonctionnement des algorithmes de hachage peut être consultée http://etutorials.org/Programming/Programming+.net+security/Part+III+.NET+Cryptography/Chapter+13.+Hashing+Algorithms/13.1+Hashing+Algorithms + Expliqué / [ici].

Pour notre dernier test, utilisons ` verifyfile + `pour vérifier un script avant qu’il ne soit exécuté. Ce script peut être vu comme une extension du script `+ verifydetach +, à la différence suivante: si un script réussit le processus de vérification, + verifyfile + le lancera.

Le script + test2.py + affiche une chaîne sur la console lors de son lancement. Utilisons-le pour montrer comment fonctionne le script verify.fichier +.

Exécutez le script + test2.py + avec + verifyfile +:

verifyfile test2.py
Outputtest2.py  signature valid
Signature valid, launching script...
The second test file is a Python script

Dans la sortie, vous pouvez voir que le script a vérifié la signature du fichier, imprimé un résultat approprié en fonction de cette vérification, puis lancé le script.

Testons le processus de vérification en ajoutant une ligne de code supplémentaire au fichier. Ouvrez + test2.py + et insérez la ligne de code suivante:

nano test2.py

~ / python-test / crypté / décrypté / test2.py

print "The second test file is a Python script"

Maintenant, relancez le script + verifyfile +:

verifyfile test2.py
Outputtest2.py signature bad
Signature invalid,
aborting script execution

La vérification du script a échoué et le lancement du script a été annulé.

Conclusion

Le module + python-gnupg + permet l’intégration entre un large éventail d’outils cryptographiques et Python. La possibilité de chiffrer ou de vérifier rapidement l’intégrité des flux de données est cruciale dans certaines situations, telles que l’interrogation ou le stockage de données sur un serveur de base de données distant. Les clés GnuPG peuvent également être utilisées pour des choses telles que creating sauvegardes et authentification SSH, ou combinées avec une configuration VPN.

Pour en savoir plus sur le module + python-gnupg +, vous pouvez visiter la page de projet python-gnupg. Pour plus d’informations sur le hachage de fichiers, consultez ce guide à l’adresse Comment vérifier les fichiers téléchargés.

Related