Dateien mit OpenSSL verschlüsseln

Einführung

In diesem Lab lernen Sie, wie Sie OpenSSL zur Dateiverschlüsselung und -entschlüsselung verwenden, eine entscheidende Fähigkeit in der Cybersicherheit. Sie üben die Generierung symmetrischer Schlüssel und die Anwendung der AES-Verschlüsselung (Advanced Encryption Standard), um sensible Daten durch praktische Übungen zu schützen.

Das Lab führt Sie durch die Installation von OpenSSL, die Erstellung von Testdateien und die Durchführung vollständiger Verschlüsselungs-Entschlüsselungs-Zyklen. Diese praktische Erfahrung wird Ihnen helfen, grundlegende Techniken zum Schutz von Daten zu verstehen, die in realen Anwendungen eingesetzt werden.

Skills Graph

Installieren von OpenSSL

In diesem Schritt installieren Sie OpenSSL, ein leistungsstarkes Toolkit zur Implementierung sicherer Kommunikation. OpenSSL bietet essentielle kryptografische Funktionen, die wir später in diesem Lab zur Verschlüsselung und Entschlüsselung von Dateien verwenden werden. Es wird weit verbreitet zur Sicherung von Datenübertragungen und -speicherungen eingesetzt.

Bevor wir beginnen, ist es wichtig zu verstehen, dass OpenSSL in den meisten Linux-Distributionen normalerweise standardmäßig enthalten ist. Dennoch gehen wir durch den Installationsprozess, um sicherzustellen, dass Sie die richtige Version und alle erforderlichen Komponenten haben. Hier ist, was wir tun werden:

Zunächst müssen wir die Paketliste aktualisieren. Dies stellt sicher, dass Ihr System über die neuesten verfügbaren Softwareversionen informiert ist:
```
sudo apt update
```
Jetzt installieren wir OpenSSL. Das -y-Flag bestätigt die Installation automatisch und erspart Ihnen, während des Prozesses 'yes' einzugeben:
```
sudo apt install openssl -y
```
Nach der Installation überprüfen wir, ob die Installation erfolgreich war, indem wir die Version prüfen. Dieser Befehl zeigt an, welche Version von OpenSSL derzeit auf Ihrem System aktiv ist:
```
openssl version
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
OpenSSL 3.0.2 15 Mar 2022 (Library: OpenSSL 3.0.2 15 Mar 2022)
```
Schließlich überprüfen wir das Hilfemenü. Dies zeigt alle verfügbaren OpenSSL-Befehle an und bestätigt, dass die Installation ordnungsgemäß funktioniert:
```
openssl help
```
Die Hilfsausgabe zeigt Ihnen die verschiedenen kryptografischen Operationen, die OpenSSL ausführen kann, die wir in den folgenden Schritten dieses Labs erkunden werden.

Erstellen einer Beispiel-Datei

In diesem Schritt erstellen Sie eine einfache Textdatei, die als Testdaten für unsere Verschlüsselungs- und Entschlüsselungsübungen dienen wird. Die Arbeit mit einer bekannten Textdatei hilft dabei, zu überprüfen, ob unser Verschlüsselungsprozess korrekt funktioniert, da wir die ursprünglichen und die entschlüsselten Inhalte leicht vergleichen können.

Beginnen wir damit, diese Beispiel-Datei in Ihrem Projektverzeichnis zu erstellen. Wir verwenden den Texteditor nano, der für Anfänger benutzerfreundlich ist, aber Sie können auch jeden anderen Texteditor verwenden, mit dem Sie sich wohlfühlen.

Navigieren Sie zunächst zu Ihrem Projektverzeichnis. Dies stellt sicher, dass alle Ihre Dateien an einem Ort organisiert bleiben:
```
cd ~/project
```
Erstellen und öffnen Sie jetzt eine neue Datei namens sample.txt mit nano:
```
nano sample.txt
```
Wenn nano geöffnet ist, sehen Sie einen leeren Bearbeitungsbereich. Geben Sie genau die folgenden zwei Zeilen ein, wie sie gezeigt werden:
```
This is a sample text file for encryption testing.
LabEx Cybersecurity Lab - AES Encryption Demo.
```
Um Ihre Arbeit in nano zu speichern:
- Drücken Sie Strg+O (den Buchstaben O, nicht die Null), um die Datei "auszuschreiben" (speichern)
- Drücken Sie Enter, um den Dateinamen sample.txt zu bestätigen
- Drücken Sie Strg+X, um den Editor zu verlassen
Überprüfen wir, ob die Datei korrekt erstellt wurde, indem wir ihren Inhalt anzeigen:
```
cat sample.txt
```
Im Terminal sollten genau die beiden Zeilen angezeigt werden, die Sie eingegeben haben. Wenn etwas anders aussieht, müssen Sie möglicherweise die Datei erneut bearbeiten.
Überprüfen Sie schließlich die Details der Datei, um zu bestätigen, dass sie existiert und Inhalt hat:
```
ls -l sample.txt
```
Dieser Befehl zeigt die Dateiberechtigungen, den Besitzer, die Größe und andere Details an. Eine Größe ungleich Null (typischerweise 80 - 100 Bytes) bestätigt, dass Ihr Text richtig gespeichert wurde.

Das Vorhandensein dieser Beispiel-Datei ist für die nächsten Schritte von entscheidender Bedeutung, in denen wir sie verschlüsseln und entschlüsseln werden. Dadurch können wir deutlich sehen, dass der Verschlüsselungsprozess funktioniert, wenn wir nach der Entschlüsselung unseren ursprünglichen Text wieder erhalten.

Generieren eines symmetrischen Schlüssels

In diesem Schritt generieren Sie einen symmetrischen Verschlüsselungsschlüssel mit OpenSSL, den wir im nächsten Schritt zur Verschlüsselung unserer Beispiel-Datei verwenden werden. Symmetrische Verschlüsselung bedeutet, dass für das Verschlüsseln und Entschlüsseln der Daten derselbe Schlüssel verwendet wird, im Gegensatz zur asymmetrischen Verschlüsselung, die separate Schlüssel verwendet. Dies macht den Schlüsselgenerierungsprozess besonders wichtig für die Sicherheit.

Lassen Sie uns aufschlüsseln, was wir tun werden: Wir werden einen starken Zufallsschlüssel mit OpenSSL's kryptografischen Funktionen erstellen, ihn sicher speichern und seine Eigenschaften überprüfen. Der Schlüssel wird die AES-256-Verschlüsselung verwenden, die derzeit für die meisten Zwecke als sehr sicher angesehen wird.

Folgen Sie diesen Schritten sorgfältig, um einen sicheren AES-256-Verschlüsselungsschlüssel zu generieren:

Stellen Sie zunächst sicher, dass Sie sich im richtigen Arbeitsverzeichnis befinden, in dem wir unsere Schlüsseldatei speichern werden. Dies hilft, Ihre Projekt-Dateien organisiert zu halten:
```
cd ~/project
```
Jetzt generieren wir den eigentlichen Schlüssel. Der Befehl openssl rand erzeugt kryptografisch starke Zufallsdaten. Wir fordern 32 Bytes (256 Bits) an Zufallsdaten an und formatieren sie als Hexadezimalzahl (Basis-16) für die Lesbarkeit:
```
openssl rand -hex 32 > symmetric_key.hex
```
Lassen Sie uns den generierten Schlüssel anzeigen, um zu bestätigen, dass er korrekt erstellt wurde. Der Schlüssel sollte als lange Zeichenfolge aus Zufallszeichen erscheinen:
```
cat symmetric_key.hex
```
Sie sollten eine 64-Zeichen-Hexadezimalzeichenfolge (repräsentierend 32 Bytes) ähnlich der folgenden sehen:
```
a1b2c3d4e5f67890a1b2c3d4e5f67890a1b2c3d4e5f67890a1b2c3d4e5f67890
```
Da dieser Schlüssel Ihre verschlüsselten Daten entschlüsseln kann, müssen wir ihn schützen. Der Befehl chmod 600 stellt sicher, dass nur Sie diese Datei lesen oder schreiben können:
```
chmod 600 symmetric_key.hex
```
Schließlich überprüfen wir die Eigenschaften der Schlüsseldatei, um zu bestätigen, dass alles korrekt eingerichtet ist:
```
ls -l symmetric_key.hex
```
Die Ausgabe sollte Folgendes zeigen:
- Ihren Benutzernamen als Besitzer
- -rw--------Berechtigungen (nur Sie können lesen/schreiben)
- 65 Bytes Größe (64 Zeichen + Zeilenumbruchzeichen)

Denken Sie daran, diese Schlüsseldatei sicher aufzubewahren - jeder, der sie hat, kann Ihre verschlüsselten Dateien entschlüsseln. In realen Szenarien möchten Sie sie möglicherweise an einem sichereren Ort als in Ihrem Projektverzeichnis speichern.

Verschlüsseln der Datei mit AES

In diesem Schritt verwenden Sie den im vorherigen Schritt generierten symmetrischen Schlüssel, um Ihre Beispiel-Datei mit AES-256-CBC zu verschlüsseln. AES (Advanced Encryption Standard) ist ein weit verbreitetes symmetrisches Verschlüsselungsalgorithmus, der eine hohe Sicherheit bietet. Die 256-Bit-Schlüssellänge bietet einen hohen Schutz, während der CBC-Modus (Cipher Block Chaining) sicherstellt, dass jedes Datenblock nacheinander sicher verarbeitet wird.

Bevor wir beginnen, verstehen wir zunächst, was wir tun: Wir nehmen Ihre ursprüngliche lesbare Textdatei und transformieren sie in eine verschlüsselte Version, die wie Zufallsdaten aussieht. Nur jemand mit dem richtigen Schlüssel kann sie wieder in die ursprüngliche Form entschlüsseln.

Folgen Sie diesen Schritten, um Ihre Datei zu verschlüsseln:

Stellen Sie zunächst sicher, dass Sie sich im richtigen Arbeitsverzeichnis befinden, in dem sich Ihre Beispiel-Datei befindet. Dies ist wichtig, da OpenSSL sowohl Ihre Eingabedatei als auch die Schlüsseldatei finden muss:
```
cd ~/project
```
Jetzt verwenden wir OpenSSL's Verschlüsselungsbefehl. -aes-256-cbc gibt den Algorithmus an, -in zeigt auf unsere Eingabedatei, -out gibt an, wo die verschlüsselte Version gespeichert werden soll, und -pass file: teilt OpenSSL mit, wo es den Verschlüsselungsschlüssel finden kann:
```
openssl enc -aes-256-cbc -in sample.txt -out sample.enc -pass file:symmetric_key.hex
```
Nach dem Ausführen des Verschlüsselungsbefehls überprüfen wir, ob die verschlüsselte Datei korrekt erstellt wurde. Die verschlüsselte Datei sollte aufgrund des Verschlüsselungsprozesses, der einige zusätzliche Daten hinzufügt, etwas größer als die ursprüngliche sein:
```
ls -l sample.enc
```
Die Ausgabe sollte Folgendes zeigen:
- Ihren Benutzernamen als Besitzer
- Eine Dateigröße, die größer als die ursprüngliche ist (aufgrund des Verschlüsselungsaufwands)
Um zu bestätigen, dass die Verschlüsselung funktioniert hat, versuchen wir, den verschlüsselten Inhalt anzuzeigen. Im Gegensatz zu Ihrer ursprünglichen Textdatei sollte dies wie zufällige Binärdaten erscheinen, da es jetzt sicher verschlüsselt ist:
```
cat sample.enc
```
Sie sollten zufällig aussehende Binärdaten sehen, was bestätigt, dass die Verschlüsselung erfolgreich war.
Zur zusätzlichen Überprüfung können wir überprüfen, wie das System den Dateityp identifiziert. Der Befehl file untersucht den Dateiinhalt, um seinen Typ zu bestimmen:
```
file sample.enc
```
Die Ausgabe sollte anzeigen, dass es sich um "Daten" handelt (nicht um "ASCII-Text" wie die ursprüngliche), was wir von einer verschlüsselten Datei erwarten.

Entschlüsseln und Überprüfen der Datei

In diesem letzten Schritt entschlüsseln Sie die verschlüsselte Datei mit dem symmetrischen Schlüssel und überprüfen, ob der entschlüsselte Inhalt mit der ursprünglichen Datei übereinstimmt. Dies schließt den Verschlüsselungs- und Entschlüsselungsprozess ab und bestätigt, dass unsere kryptografischen Operationen korrekt funktioniert haben. Die Entschlüsselung ist im Wesentlichen der umgekehrte Prozess der Verschlüsselung – sie nimmt die unleserlichen Daten und wandelt sie mit demselben Schlüssel, der für die Verschlüsselung verwendet wurde, wieder in ihre ursprüngliche Form zurück.

Folgen Sie diesen Schritten, um Ihre Datei zu entschlüsseln und zu überprüfen:

Stellen Sie zunächst sicher, dass Sie sich im richtigen Arbeitsverzeichnis befinden, in dem sich Ihre verschlüsselte Datei und der Schlüssel befinden:
```
cd ~/project
```
Entschlüsseln Sie die verschlüsselte Datei mit demselben symmetrischen Schlüssel. Das -d-Flag teilt OpenSSL mit, dass wir entschlüsseln, während die anderen Parameter denen entsprechen, die während der Verschlüsselung verwendet wurden:
```
openssl enc -d -aes-256-cbc -in sample.enc -out sample.dec -pass file:symmetric_key.hex
```
Überprüfen Sie, ob die entschlüsselte Datei erstellt wurde. Der Befehl ls -l zeigt detaillierte Dateiinformationen, einschließlich ihrer Größe und Erstellungszeit:
```
ls -l sample.dec
```
Vergleichen Sie die entschlüsselte Datei mit der ursprünglichen. Der Befehl diff prüft Zeile für Zeile, ob es Unterschiede zwischen den Dateien gibt:
```
diff sample.txt sample.dec
```
Wenn die Dateien identisch sind (wie es sein sollte), gibt dieser Befehl keine Ausgabe. Jede Ausgabe würde auf eine Diskrepanz zwischen ursprünglichem und entschlüsseltem Inhalt hinweisen.
Zeigen Sie den entschlüsselten Inhalt an, um zu bestätigen, dass er mit dem Original übereinstimmt. Der Befehl cat zeigt den gesamten Dateiinhalt in Ihrem Terminal an:
```
cat sample.dec
```
Sie sollten genau denselben Text wie in Ihrer ursprünglichen sample.txt-Datei sehen. Diese visuelle Bestätigung ist wichtig, um zu überprüfen, ob die Entschlüsselung richtig funktioniert hat.
Überprüfen Sie zur zusätzlichen Bestätigung den Dateityp. Der Befehl file untersucht den Inhalt der Datei, um ihren Typ zu bestimmen:
```
file sample.dec
```
Die Ausgabe sollte anzeigen, dass es sich um "ASCII-Text" wie das Original handelt, was bestätigt, dass die Entschlüsselung die Datei erfolgreich in ihr ursprüngliches Textformat zurückgesetzt hat.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie Dateien mit OpenSSL verschlüsseln und entschlüsseln können, indem Sie praktische Übungen durchgeführt haben. Die Übungen umfassten die Installation von OpenSSL, die Erstellung von Testdateien und die Ausführung von Verschlüsselungs- und Entschlüsselungsoperationen mit AES-symmetrischen Schlüsseln.

Das Lab hat den gesamten Arbeitsablauf von der Schlüsselgenerierung über die Dateiverschlüsselung bis zur Entschlüsselungsüberprüfung gezeigt. Diese praktische Erfahrung hilft, das Verständnis von grundlegenden kryptografischen Operationen in Cybersicherheitsanwendungen zu festigen.