TOC

So überprüfen Sie Code und verschlüsseln Daten mit Python-GnuPG und Python 3

Der Autor hat Open Internet / Free Speech Fund ausgewählt, um eine Spende im Rahmen von https://do.co/w4do-cta zu erhalten [Write for DOnations] program.

Einführung

Das GnuPG package bietet eine Komplettlösung zum Generieren und Speichern von kryptografischen Schlüsseln. Sie können damit auch Daten und Kommunikation verschlüsseln und signieren.

In diesem Tutorial erstellen Sie eine Reihe von Skripten, die Python 3 mit dem Modul python-gnupg verwenden. Mit diesen Skripten können Sie mehrere Dateien signieren und verschlüsseln sowie die Integrität eines Skripts überprüfen, bevor Sie es ausführen.

Voraussetzungen

Bevor Sie mit diesem Lernprogramm fortfahren, müssen Sie die folgenden Voraussetzungen erfüllen:

  • Richten Sie einen Ubuntu 16.04-Server gemäß dem Initial Server Setup for Ubuntu 16.04 -Tutorial ein. Nachdem Sie dieses Tutorial befolgt haben, sollten Sie Zugriff auf ein Nicht-Root-Sudo-Benutzerkonto haben. In diesem Tutorial wird unser Benutzer * sammy * genannt.

  • Stellen Sie sicher, dass Python 3 und "+ pip +" installiert sind, indem Sie Schritt 1 von https://www.digitalocean.com/community/tutorials/how-to-install-python-3-and-set-up-a-local ausführen -Programmierumgebung-auf-Ubuntu-16-04 # step-1-% E2% 80% 94-Einrichten-von-Python-3 [Installieren von Python 3 und Einrichten einer lokalen Programmierumgebung unter Ubuntu 16.04].

  • Erstellen Sie ein GnuPG-Schlüsselpaar, indem Sie diesem GnuPG tutorial folgen.

Schritt 1 - Schlüsselpaarinformationen abrufen

Nach Abschluss des GnuPG-Tutorials in den Voraussetzungen wird ein Schlüsselpaar in "+ .gnupg " in Ihrem Home-Verzeichnis gespeichert. GnuPG speichert Schlüssel mit einem Benutzernamen und einer E-Mail, um Schlüsselpaare zu identifizieren. In diesem Beispiel lautet unser Benutzername * sammy * und unsere E-Mail-Adresse `+`.

Führen Sie den folgenden Befehl aus, um eine Liste Ihrer verfügbaren Schlüssel abzurufen:

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

Notieren Sie sich die E-Mail-Adresse, die in der Zeile "+ UID +" Ihrer Ausgabe angezeigt wird. Sie benötigen es später, um Ihre Schlüssel zu identifizieren.

Schritt 2 - Installieren von Python-GnuPG und Signieren von Dateien

Mit Ihren Schlüsseln können Sie das + python-gnupg + - Modul installieren, das als Wrapper für GnuPG fungiert, um die Interaktion zwischen GnuPG und Python 3 zu ermöglichen. Mit diesem Modul können Sie Python-Skripte erstellen, die folgende Aufgaben ausführen:

  • Erstellen Sie getrennte Signaturen für Dateien, und fügen Sie dem Signaturprozess eine Sicherheitsebene hinzu, indem Sie Signaturen von Dateien entkoppeln.

  • Dateien verschlüsseln.

  • Dateien entschlüsseln.

  • Überprüfen Sie getrennte Signaturen und Skripte.

Sie erstellen zuerst die Skripte und einige Testdateien, bevor Sie mit dem Testen der Skripte für diese Dateien fortfahren.

Installieren Sie zunächst das Modul "+ python-gnupg " zusammen mit dem Paket " fs ", mit dem Sie Ihre Testdateien öffnen, lesen und schreiben können. Aktualisieren Sie Ihren Paketindex und installieren Sie diese Pakete mit ` pip +`:

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

Mit diesen Paketen können wir mit dem Erstellen der Skripte und Testdateien fortfahren.

Erstellen Sie zum Speichern der Skripts und Testdateien einen Ordner in Ihrem Ausgangsverzeichnis mit dem Namen "+ python-test +":

cd ~/
mkdir python-test

In dieses Verzeichnis verschieben:

cd python-test/

Als Nächstes erstellen wir drei Testdateien:

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

Um getrennte Signaturen für unsere Testdateien zu erstellen, erstellen wir ein Skript mit dem Namen "+ signdetached.py", das auf alle Dateien in dem Verzeichnis abzielt, in dem es ausgeführt wird. Eine Signatur dient als Zeitstempel und bescheinigt die Echtheit des Dokuments.

Die abgelösten Signaturen werden in einem neuen Ordner mit dem Namen "+ signatures / +" gespeichert, der bei Ausführung des Skripts erstellt wird.

Öffnen Sie eine neue Datei mit dem Namen "+ signdetach.py ​​" mit " nano +" oder Ihrem bevorzugten Texteditor:

nano signdetach.py

Importieren wir zunächst alle erforderlichen Module für das Skript. Dazu gehören die Pakete "+ os " und " fs ", die die Dateinavigation ermöglichen, und " gnupg +":

~ / python-test / signdetach.py

#!/usr/bin/env python3

import os
import fs
from fs import open_fs
import gnupg

Legen wir nun das Verzeichnis fest, in dem GnuPG seine Verschlüsselungsschlüssel findet. GnuPG speichert seine Schlüssel standardmäßig in "+ .gnupg +". Konfigurieren wir dies also mit unserem Benutzernamen. Achten Sie darauf, * sammy * durch den Namen Ihres Nicht-Root-Benutzers zu ersetzen:

~ / python-test / signdetach.py

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

Als Nächstes erstellen wir eine Variable "+ home_fs +", um den aktuellen Verzeichnisspeicherort als Dateiobjekt zu speichern. Auf diese Weise kann das Skript in dem Verzeichnis ausgeführt werden, in dem es ausgeführt wird:

~ / python-test / signdetach.py

...
home_fs = open_fs(".")

Inzwischen sieht Ihr Skript so aus:

~ / 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(".")

Dieser Konfigurationsblock ist die grundlegende Vorlage, die Sie in Ihren Skripten verwenden, wenn Sie sich durch dieses Tutorial bewegen.

Fügen Sie als Nächstes Code hinzu, um zu überprüfen, ob ein Ordner mit dem Namen "+ signatures / +" vorhanden ist, und erstellen Sie ihn, falls er nicht vorhanden ist:

~ / python-test / signdetach.py

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

Erstellen Sie ein leeres Array, in dem die Dateinamen gespeichert werden, und durchsuchen Sie dann das aktuelle Verzeichnis, indem Sie alle Dateinamen an das Array + files_dir + anhängen:

~ / 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)

Als Nächstes generiert das Skript getrennte Signaturen für die Dateien. Durch Durchlaufen des Arrays "+ files_dir " wird eine Signatur für jede Datei mit dem ersten privaten Schlüssel auf Ihrem Schlüsselbund erstellt. Um auf den privaten Schlüssel zuzugreifen, müssen Sie ihn mit der von Ihnen festgelegten Passphrase entsperren. Ersetzen Sie `+` durch die Passphrase, die Sie bei der Generierung des Schlüsselpaares in den folgenden Voraussetzungen verwendet haben:

~ / 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)

Wenn Sie fertig sind, werden alle Signaturen in den Ordner "+ signatures / +" verschoben. Das fertige Skript sieht folgendermaßen aus:

~ / 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)

Jetzt können wir mit dem Verschlüsseln von Dateien fortfahren.

Schritt 3 - Dateien verschlüsseln

Wenn Sie das Verschlüsselungsskript in einem Ordner ausführen, werden alle Dateien in diesem Ordner in einem neuen Ordner mit dem Namen "+ encrypted / +" kopiert und verschlüsselt. Der öffentliche Schlüssel, der zum Verschlüsseln der Dateien verwendet wird, entspricht der E-Mail-Adresse, die Sie in Ihrer Schlüsselpaarkonfiguration angegeben haben.

Öffnen Sie eine neue Datei mit dem Namen "+ encrypt files.py":

nano encryptfiles.py

Importieren Sie zunächst alle erforderlichen Module, legen Sie das Ausgangsverzeichnis von GnuPG fest und erstellen Sie die aktuelle Arbeitsverzeichnisvariable:

~ / 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(".")

Fügen Sie als Nächstes Code hinzu, um zu überprüfen, ob das aktuelle Verzeichnis bereits einen Ordner mit dem Namen "+ encrypted / +" enthält, und um ihn zu erstellen, falls er nicht vorhanden ist:

~ / python-test / encryptfiles.py

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

Erstellen Sie vor der Suche nach zu verschlüsselnden Dateien ein leeres Array, in dem die Dateinamen gespeichert werden:

~ / python-test / encryptfiles.py

...
files_dir = []

Erstellen Sie als Nächstes eine Schleife, um den Ordner nach Dateien zu durchsuchen und diese an das Array anzuhängen:

~ / python-test / encryptfiles.py

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

Erstellen wir zum Schluss eine Schleife, um alle Dateien im Ordner zu verschlüsseln. Wenn der Vorgang abgeschlossen ist, werden alle verschlüsselten Dateien in den Ordner "+ encrypted / " übertragen. In diesem Beispiel ist "+" die E-Mail-ID für den Schlüssel, der während der Verschlüsselung verwendet werden soll. Achten Sie darauf, dies durch die E-Mail-Adresse zu ersetzen, die Sie in Schritt 1 notiert haben:

~ / 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")

Wenn in Ihrem Ordner "+ .gnupg " mehrere Schlüssel gespeichert sind und Sie einen bestimmten öffentlichen Schlüssel oder mehrere öffentliche Schlüssel zur Verschlüsselung verwenden möchten, müssen Sie das Array " recipient +" ändern, indem Sie entweder die zusätzlichen Empfänger hinzufügen oder den aktuellen ersetzen .

Ihre Skriptdatei + encryptfiles.py + sieht dann so aus:

~ / 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")

Betrachten wir nun den zweiten Teil des Vorgangs: Entschlüsseln und Überprüfen mehrerer Dateien gleichzeitig.

Schritt 4 - Entschlüsseln von Dateien

Das Entschlüsselungsskript funktioniert ähnlich wie das Verschlüsselungsskript, nur dass es in einem "+ verschlüsselten / " - Verzeichnis ausgeführt werden soll. Beim Start identifiziert " decryptfiles.py " zuerst den verwendeten öffentlichen Schlüssel und sucht dann nach dem entsprechenden privaten Schlüssel im Ordner " .gnupg ", um die Datei zu entschlüsseln. Entschlüsselte Dateien werden in einem neuen Ordner mit dem Namen " decrypted / +" gespeichert.

Öffne eine neue Datei mit dem Namen "+ decrypt files.py " mit " nano +" oder deinem Lieblingseditor:

nano decryptfiles.py

Beginnen Sie mit dem Einfügen der Konfigurationseinstellungen:

~ / 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(".")

Erstellen Sie als Nächstes zwei leere Arrays, um Daten während der Skriptausführung zu speichern:

~ / python-test / decryptfiles.py

...
files_dir = []
files_dir_clean = []

Ziel ist es, dass das Skript die entschlüsselten Dateien in einem eigenen Ordner ablegt. Andernfalls werden die verschlüsselten und entschlüsselten Dateien gemischt, wodurch es schwierig wird, eine bestimmte entschlüsselte Datei zu finden. Um dieses Problem zu beheben, können Sie Code hinzufügen, der den aktuellen Ordner durchsucht, um festzustellen, ob ein entschlüsselter / + -Ordner vorhanden ist.

~ / python-test / decryptfiles.py

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

Durchsuchen Sie den Ordner und hängen Sie alle Dateinamen an das Array + files_dir + an:

~ / python-test / decryptfiles.py

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

Alle verschlüsselten Dateien haben die Erweiterung "+ .gpg +", die ihrem Dateinamen hinzugefügt wird, um anzuzeigen, dass sie verschlüsselt sind. Beim Entschlüsseln möchten wir sie jedoch ohne diese Erweiterung speichern, da sie nicht mehr verschlüsselt sind.

Führen Sie dazu eine Schleife durch das Array + files_dir + und entfernen Sie die Erweiterung + .gpg + von jedem Dateinamen:

~ / 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)

Die neuen "aufgeräumten" Dateinamen werden im Array "+ file_dir_clean +" gespeichert.

Als nächstes durchlaufen wir die Dateien und entschlüsseln sie. Ersetzen Sie "++" durch Ihre Passphrase, um den privaten Schlüssel zu entsperren:

~ / 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)])

Ihre Skriptdatei sieht dann so aus:

~ / 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)])

Mit unserem Entschlüsselungsskript können wir losgelöste Signaturen für mehrere Dateien überprüfen.

Schritt 5 - Überprüfen der getrennten Signaturen

Um die getrennten digitalen Signaturen mehrerer Dateien zu überprüfen, schreiben wir ein Skript "+ verifydetach.py ​​". Dieses Skript sucht nach einem " signatures / +" - Ordner im Arbeitsverzeichnis und überprüft jede Datei mit ihrer Signatur.

Öffnen Sie eine neue Datei mit dem Namen "+ verifydetach.py ​​+":

nano verifydetach.py

Importieren Sie alle erforderlichen Bibliotheken, legen Sie das Arbeitsverzeichnis und das Basisverzeichnis fest und erstellen Sie das leere Array + files_dir +, wie in den vorherigen Beispielen dargestellt:

~ / 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 = []

Als Nächstes scannen wir den Ordner, der die zu überprüfenden Dateien enthält. Die Dateinamen werden an das leere Array + files_dir + angehängt:

~ / python-test / verifydetach.py

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

Lassen Sie uns abschließend jede Datei mit ihrer eigenen getrennten Signatur überprüfen. Verwenden Sie dazu eine Schleife, die durch das Array "+ files_dir " navigiert, um nach der getrennten Signatur jeder Datei im Ordner " signatures / +" zu suchen. Wenn die getrennte Signatur gefunden wird, wird die Datei damit überprüft. In der letzten Zeile wird der Status der Überprüfung jeder Datei ausgedruckt:

~ / 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)

Wenn Sie fertig sind, sieht Ihr Skript folgendermaßen aus:

~ / 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)

Lassen Sie uns als Nächstes untersuchen, wie Sie die Signatur einer Datei überprüfen, bevor sie auf Ihrem Server ausgeführt wird.

Schritt 6 - Überprüfen der Dateien

Das endgültige Skript überprüft die Skripte, bevor sie ausgeführt werden. In diesem Sinne ist es ähnlich wie "+ verifydetach +", bietet jedoch zusätzlich die Möglichkeit, verifizierte Skripte zu starten. Dies funktioniert, indem der Name eines Skripts als Argument verwendet und anschließend die Signatur dieser Datei überprüft wird. Wenn die Überprüfung erfolgreich ist, sendet das Skript eine Nachricht an die Konsole und startet das überprüfte Skript. Sollte der Überprüfungsprozess fehlschlagen, sendet das Skript den Fehler an die Konsole und bricht die Dateiausführung ab.

Erstellen Sie eine neue Datei mit dem Namen "+ verifyfile.py +":

nano verifyfile.py

Importieren Sie zunächst die erforderlichen Bibliotheken und legen Sie die Arbeitsverzeichnisse fest:

~ / 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(".")

Damit das Skript funktioniert, muss der Name der zu überprüfenden und auszuführenden Datei gespeichert werden. Dazu erstellen wir eine neue Variable mit dem Namen "+ script_to_run +":

~ / python-test / verifyfile.py

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

Diese Variable übernimmt das erste Argument und speichert es in der neu erstellten Variablen. Als nächstes öffnet das Skript die abgetrennte Signaturdatei, überprüft die Datei in "+ script_to_run +" mit ihrer Signatur und führt sie dann aus, wenn sie die Überprüfung besteht:

~ / 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")

Das fertige Skript sieht dann so aus:

~ / 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")

Wir haben die Erstellung der Skripte abgeschlossen, aber im Moment können sie nur aus dem aktuellen Ordner heraus gestartet werden. Im nächsten Schritt werden wir ihre Berechtigungen ändern, um sie global zugänglich zu machen.

Schritt 7 - Systemweite Verfügbarkeit der Skripte

Machen Sie die Skripte zur Vereinfachung der Verwendung in einem beliebigen Verzeichnis oder Ordner des Systems ausführbar und platzieren Sie sie in unserem + $ PATH +. Verwenden Sie den Befehl + chmod +, um dem Eigentümer der Dateien, Ihrem Nicht-Root-Benutzer, ausführbare Berechtigungen zu erteilen:

chmod +x *.py

Führen Sie nun den folgenden Befehl aus, um die Einstellungen für "+ $ PATH +" zu ermitteln:

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

Dateien, die in Ihrem + $ PATH gespeichert sind, können von jedem Ordner Ihres Systems aus aufgerufen werden, sofern die Berechtigungen des Verzeichnisses dies zulassen. Sie können Ihre Skripte an einer beliebigen Stelle in Ihrem + $ PATH + platzieren, aber jetzt wollen wir die Skripte aus dem + python-test / + -Verzeichnis nach + / usr / local / bin / + verschieben.

Beachten Sie, dass wir beim Kopieren der Dateien die Erweiterung "+ .py " löschen. Wenn Sie sich die erste Zeile der von uns erstellten Skripte ansehen, sehen Sie " #! Usr / bin / env python3 +". Diese Zeile wird als shebang bezeichnet und hilft dem Betriebssystem, den Bash-Interpreter oder die Umgebung zu identifizieren, die beim Ausführen des Codes verwendet werden sollen. Wenn wir das Skript ausführen, merkt das Betriebssystem, dass wir Python als unsere Umgebung angegeben haben, und übergibt den Code zur Ausführung an Python. Dies bedeutet, dass wir keine Dateierweiterungen mehr benötigen, um die Umgebung zu identifizieren, in der wir arbeiten möchten:

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

Jetzt können die Skripte überall im System ausgeführt werden, indem Sie einfach den Skriptnamen zusammen mit den Argumenten ausführen, die das Skript möglicherweise von der Befehlszeile übernimmt. Im nächsten Schritt sehen wir uns einige Beispiele für die Verwendung dieser Skripte an.

Schritt 8 - Testen der Skripte

Nachdem wir die Skripte in unser + $ PATH + verschoben haben, können wir sie von jedem Ordner auf dem Server ausführen.

Überprüfen Sie zunächst mit dem Befehl "+ pwd", ob Sie noch im Verzeichnis "+ python-test" arbeiten:

pwd

Die Ausgabe sollte sein:

Output/home//python-test

Sie haben zuvor im Lernprogramm drei Testdateien erstellt. Führen Sie den Befehl + ls -l + aus, um die Dateien im Ordner aufzulisten:

ls -l

Sie sollten drei Dateien in Ihrem "+ Python-Test" -Ordner sehen:

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

Wir werden die Skripte für diese drei Dateien testen. Sie können den Inhalt der Dateien vor der Verschlüsselung mit dem Befehl "+ cat +" wie folgt schnell anzeigen:

cat test1.txt
OutputThis is the first test file

Beginnen wir damit, getrennte Signaturen für alle Dateien zu erstellen. Führen Sie dazu das Skript + signdetach + im aktuellen Ordner aus:

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

Beachten Sie in der Ausgabe, dass das Skript festgestellt hat, dass das Verzeichnis + signatures / + nicht vorhanden ist, und es erstellt hat. Anschließend wurden die Dateisignaturen erstellt.

Wir können dies bestätigen, indem wir den Befehl + ls -l + erneut ausführen:

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

Beachten Sie das neue Verzeichnis "+ Signaturen +" unter den Elementen in der Liste. Lassen Sie uns den Inhalt dieses Ordners auflisten und eine der Signaturen genauer betrachten.

Geben Sie Folgendes ein, um alle Signaturen aufzulisten:

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

Getrennte Signaturdateien können durch die Erweiterung "+ .sig " gekennzeichnet werden. Auch hier kann der Befehl " cat " den Inhalt einer dieser Signaturen anzeigen. Sehen wir uns den Inhalt der Signatur " test1.txt.sig +" an:

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-----

Diese Ausgabe ist die getrennte Signatur für "+ test1.txt +".

Wenn die Signaturen vorhanden sind, können Sie mit der Verschlüsselung unserer Dateien fortfahren. Führen Sie dazu das Skript + encryptfiles + aus:

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

Beachten Sie in der Ausgabe, dass das Skript den Ordner + encrypted / + erstellt hat. Beachten Sie auch, dass alle Dateien erfolgreich verschlüsselt wurden. Führen Sie den Befehl + ls -l + erneut aus und beachten Sie den neuen Ordner im Verzeichnis:

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

Sehen wir uns an, wie die Nachricht in "+ test1.txt +" jetzt aussieht, da sie verschlüsselt wurde:

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-----

Der in der Originaldatei gespeicherte Satz wurde durch den Verschlüsselungsprozess in eine komplexe Folge von Zeichen und Zahlen umgewandelt.

Nachdem die Dateien signiert und verschlüsselt wurden, können die Originale gelöscht und die Originalnachrichten aus den verschlüsselten Dateien wiederhergestellt werden.

Geben Sie Folgendes ein, um die Originale zu löschen:

rm *.txt *.py

Führen Sie den Befehl + ls -l + erneut aus, um sicherzustellen, dass alle Originaldateien gelöscht wurden:

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

Nachdem die Originaldateien entfernt wurden, entschlüsseln und überprüfen wir die verschlüsselten Dateien. Wechseln Sie in den Ordner "+ encrypted +" und listen Sie alle Dateien auf:

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

Um die Dateien zu entschlüsseln, führen Sie das Skript + decryptfiles + im aktuellen Ordner aus:

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

Das Skript gab für jede Datei "+ status: decryption ok +" zurück, was bedeutet, dass jede Datei erfolgreich entschlüsselt wurde.

Wechseln Sie in den neuen Ordner "+ decrypted / " und zeigen Sie den Inhalt von " test1.txt " mit dem Befehl " cat +" an:

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

Wir haben die Nachricht wiederhergestellt, die in der von uns gelöschten Datei "+ test1.txt" gespeichert ist.

Bestätigen wir als nächstes, dass es sich bei dieser Nachricht tatsächlich um die ursprüngliche Nachricht handelt, indem wir ihre Signatur mit dem Skript "+ verifydetach +" überprüfen.

Die Signaturdatei enthält die Identität des Unterzeichners sowie einen Hashwert, der anhand der Daten aus dem signierten Dokument berechnet wird. Während der Überprüfung wird + gpg + den öffentlichen Schlüssel des Absenders nehmen und ihn zusammen mit einem Hash-Algorithmus verwenden, um den Hash-Wert für die Daten zu berechnen. Der berechnete Hash-Wert und der in der Signatur gespeicherte Wert müssen übereinstimmen, damit die Überprüfung erfolgreich ist.

Jede Manipulation der Originaldatei, der Signaturdatei oder des öffentlichen Schlüssels des Absenders führt dazu, dass sich der Hashwert ändert und der Überprüfungsprozess fehlschlägt.

Führen Sie das Skript aus dem Ordner "+ decrypted +" aus:

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

Sie können der Ausgabe entnehmen, dass alle Dateien eine gültige Signatur haben, was bedeutet, dass die Dokumente während dieses Vorgangs nicht manipuliert wurden.

Schauen wir uns nun an, was passiert, wenn Sie Änderungen an Ihrem Dokument vornehmen, nachdem Sie es signiert haben. Öffne die + test1.txt Datei mit` + nano`:

nano test1.txt

Fügen Sie nun den folgenden Satz in die Datei ein:

~ / python-test / verschlüsselt / entschlüsselt / test1.txt

This is the first test file

Speichern und schließen Sie die Datei.

Führen Sie nun das Skript + verify detach erneut aus und stellen Sie fest, wie sich die Ausgabe geändert hat:

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

Beachten Sie, dass GnuPG bei der Überprüfung von "+ test1.txt " " Signatur schlecht " zurückgegeben hat. Dies liegt daran, dass wir Änderungen an der Datei vorgenommen haben, nachdem diese signiert wurde. Denken Sie daran, dass ` gpg ` während des Überprüfungsprozesses den in der Signaturdatei gespeicherten Hash-Wert mit dem Hash-Wert vergleicht, den es aus dem von Ihnen signierten Dokument berechnet. Die Änderungen, die wir am Dokument vorgenommen haben, haben dazu geführt, dass " gpg " einen anderen Hashwert für " test1.txt " berechnet hat. Eine ausführlichere Beschreibung der Funktionsweise von Hashing-Algorithmen finden Sie unter http://etutorials.org/Programming/Programming.net+security/Part+III+.NET+Cryptography/Chapter+13.+Hashing+Algorithms/13.1+Hashing+Algorithms + Erklärt / [hier].

Verwenden Sie für unseren letzten Test "+ verifyfile ", um ein Skript zu überprüfen, bevor es ausgeführt wird. Dieses Skript kann als Erweiterung des Skripts " verifydetach " angesehen werden, jedoch mit dem folgenden Unterschied: Wenn ein Skript den Überprüfungsprozess besteht, wird es mit " verifyfile +" gestartet.

Das Skript + test2.py + gibt beim Start einen String an die Konsole aus. Lassen Sie uns damit demonstrieren, wie das Skript "+ verifyfile +" funktioniert.

Führen Sie das Skript + test.py mit` + verify file` aus:

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

Anhand der Ausgabe können Sie erkennen, dass das Skript die Signatur der Datei überprüft, ein entsprechendes Ergebnis auf der Grundlage dieser Überprüfung gedruckt und dann das Skript gestartet hat.

Testen Sie den Überprüfungsprozess, indem Sie der Datei eine zusätzliche Codezeile hinzufügen. Öffne + test2.py + und füge die folgende Codezeile ein:

nano test2.py

~ / python-test / verschlüsselt / entschlüsselt / test2.py

print "The second test file is a Python script"

Führen Sie nun das Skript + verifyfile + erneut aus:

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

Die Überprüfung des Skripts ist fehlgeschlagen und der Skriptstart wurde abgebrochen.

Fazit

Das + python-gnupg + - Modul ermöglicht die Integration einer Vielzahl von kryptografischen Werkzeugen in Python. Die schnelle Verschlüsselung oder Überprüfung der Integrität von Datenströmen ist in bestimmten Situationen von entscheidender Bedeutung, z. B. beim Abfragen oder Speichern von Daten auf einem entfernten Datenbankserver. GnuPG-Schlüssel können auch für Dinge wie creating verwendet werden Backups und SSH-Authentifizierung oder kombiniert mit einem VPN-Setup.

Um mehr über das + python-gnupg + Modul zu erfahren, besuchen Sie die python-gnupg project page. Weitere Informationen zum Datei-Hashing finden Sie in diesem Handbuch unter How To Verify Downloaded Files.

Related