MENU
  1. Startseite
  2. Python
  3. Methoden der Verschlüsselung in Python: Eine umfassende Anleitung zur Verwendung der cryptography-Bibliothek

Methoden der Verschlüsselung in Python: Eine umfassende Anleitung zur Verwendung der cryptography-Bibliothek

Python

Um Daten in Python sicher zu schützen, ist eine effektive Verschlüsselung unerlässlich. In diesem Artikel erläutern wir die Verwendung der leistungsstarken cryptography-Bibliothek in Python, von den grundlegenden Verschlüsselungsmethoden bis hin zu praktischen Beispielen. Wir erklären die Konzepte schrittweise, sodass auch Anfänger sie verstehen können, und bieten Übungen und Anwendungsbeispiele, um das Verständnis zu vertiefen. Durch diesen Artikel können Sie die Grundlagen der Datensicherheit lernen und praktische Fähigkeiten entwickeln.

Inhaltsverzeichnis

Installation der cryptography-Bibliothek

Der erste Schritt, um in Python Verschlüsselung durchzuführen, ist die Installation der cryptography-Bibliothek. Sie können sie mit den folgenden einfachen Schritten installieren.

Vorbereitung der Umgebung

Stellen Sie sicher, dass Python installiert ist und das benötigte Paketverwaltungswerkzeug (pip) ebenfalls vorhanden ist.

Überprüfung der Python-Installation

Führen Sie den folgenden Befehl im Terminal oder in der Eingabeaufforderung aus, um zu überprüfen, ob Python installiert ist.

python --version

Überprüfung der pip-Installation

Führen Sie den folgenden Befehl aus, um zu überprüfen, ob pip installiert ist.

pip --version

Installation der cryptography-Bibliothek

Verwenden Sie pip, um die cryptography-Bibliothek zu installieren. Führen Sie den folgenden Befehl im Terminal oder in der Eingabeaufforderung aus.

pip install cryptography

Überprüfung der Installation

Um sicherzustellen, dass die Installation erfolgreich war, öffnen Sie den Python-Interpreter und führen Sie den folgenden Befehl aus.

import cryptography
print(cryptography.__version__)

Wenn die Installation korrekt durchgeführt wurde, wird die Versionsnummer angezeigt. Damit ist die Installation der cryptography-Bibliothek abgeschlossen.

Grundlagen der symmetrischen Verschlüsselung

Die symmetrische Verschlüsselung verwendet denselben Schlüssel sowohl für die Verschlüsselung als auch für die Entschlüsselung. Hier erläutern wir die grundlegende Verwendung der symmetrischen Verschlüsselung mit der cryptography-Bibliothek.

Was ist symmetrische Verschlüsselung?

Bei der symmetrischen Verschlüsselung wird ein Schlüssel verwendet, um Daten zu verschlüsseln, und derselbe Schlüssel wird verwendet, um die Daten zu entschlüsseln. Daher ist die Verwaltung des Schlüssels von entscheidender Bedeutung. Ein Beispiel für symmetrische Verschlüsselung ist AES (Advanced Encryption Standard).

Verschlüsselung und Entschlüsselung mit AES

Hier erklären wir die grundlegenden Schritte zur Verschlüsselung und Entschlüsselung von Daten mit AES.

Importieren der benötigten Module

Zuerst importieren wir die erforderlichen Module aus der cryptography-Bibliothek.

from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.primitives import padding
from cryptography.hazmat.backends import default_backend
import os

Erzeugen von Schlüssel und Initialisierungsvektor

Für die AES-Verschlüsselung benötigen wir einen Schlüssel und einen Initialisierungsvektor (IV). Diese werden erzeugt.

key = os.urandom(32)  # 256-Bit-Schlüssel
iv = os.urandom(16)   # 128-Bit-Initialisierungsvektor

Daten-Padding

Bei Blockverschlüsselungen müssen die Daten ein Vielfaches der Blockgröße haben. Daher fügen wir den Daten Padding hinzu.

def pad(data):
    padder = padding.PKCS7(algorithms.AES.block_size).padder()
    return padder.update(data) + padder.finalize()

Verschlüsselung

Nun verschlüsseln wir die Daten.

def encrypt(data, key, iv):
    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
    encryptor = cipher.encryptor()
    padded_data = pad(data)
    return encryptor.update(padded_data) + encryptor.finalize()

Entschlüsselung

Nun entschlüsseln wir die verschlüsselten Daten.

def decrypt(encrypted_data, key, iv):
    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
    decryptor = cipher.decryptor()
    padded_data = decryptor.update(encrypted_data) + decryptor.finalize()
    unpadder = padding.PKCS7(algorithms.AES.block_size).unpadder()
    return unpadder.update(padded_data) + unpadder.finalize()

Praktisches Beispiel

In folgendem Beispiel verschlüsseln und entschlüsseln wir ein Klartext-Daten.

data = b"Dies ist eine geheime Nachricht"
encrypted_data = encrypt(data, key, iv)
print("Verschlüsselte Daten:", encrypted_data)

decrypted_data = decrypt(encrypted_data, key, iv)
print("Entschlüsselte Daten:", decrypted_data.decode())

So können Sie mit der cryptography-Bibliothek symmetrische Verschlüsselung implementieren und Daten schützen.

Grundlagen der asymmetrischen Verschlüsselung

Asymmetrische Verschlüsselung verwendet verschiedene Schlüssel für die Verschlüsselung und Entschlüsselung. In diesem Abschnitt erläutern wir die grundlegende Verwendung der asymmetrischen Verschlüsselung mit der cryptography-Bibliothek.

Was ist asymmetrische Verschlüsselung?

Asymmetrische Verschlüsselung verwendet ein Paar von Schlüsseln: einen öffentlichen Schlüssel für die Verschlüsselung und einen privaten Schlüssel für die Entschlüsselung. Daten, die mit dem öffentlichen Schlüssel verschlüsselt wurden, können nur mit dem entsprechenden privaten Schlüssel entschlüsselt werden. Ein bekanntes Beispiel für asymmetrische Verschlüsselung ist RSA (Rivest-Shamir-Adleman).

Verschlüsselung und Entschlüsselung mit RSA

Hier erklären wir die grundlegenden Schritte zur Verschlüsselung und Entschlüsselung von Daten mit RSA.

Importieren der benötigten Module

Importieren Sie zuerst die benötigten Module aus der cryptography-Bibliothek.

from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization, hashes
from cryptography.hazmat.primitives.asymmetric import padding

Erzeugen von Schlüsselpaaren

Für die RSA-Verschlüsselung erzeugen wir ein Paar von Schlüsseln: einen privaten Schlüssel und einen öffentlichen Schlüssel.

private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048,
)
public_key = private_key.public_key()

Speichern und Laden von Schlüsseln

Hier zeigen wir, wie man den Schlüssel speichert und später wieder lädt.

# Speichern des privaten Schlüssels
private_pem = private_key.private_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PrivateFormat.TraditionalOpenSSL,
    encryption_algorithm=serialization.NoEncryption()
)

# Speichern des öffentlichen Schlüssels
public_pem = public_key.public_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PublicFormat.SubjectPublicKeyInfo
)

# Laden des Schlüssels
loaded_private_key = serialization.load_pem_private_key(private_pem, password=None)
loaded_public_key = serialization.load_pem_public_key(public_pem)

Verschlüsselung

Mit dem öffentlichen Schlüssel verschlüsseln wir die Daten.

def encrypt(data, public_key):
    return public_key.encrypt(
        data,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(),
            label=None
        )
    )

Entschlüsselung

Mit dem privaten Schlüssel entschlüsseln wir die verschlüsselten Daten.

def decrypt(encrypted_data, private_key):
    return private_key.decrypt(
        encrypted_data,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(),
            label=None
        )
    )

Praktisches Beispiel

In folgendem Beispiel verschlüsseln und entschlüsseln wir eine Nachricht mit RSA.

data = b"Dies ist eine geheime Nachricht"
encrypted_data = encrypt(data, public_key)
print("Verschlüsselte Daten:", encrypted_data)

decrypted_data = decrypt(encrypted_data, private_key)
print("Entschlüsselte Daten:", decrypted_data.decode())

So können Sie mit der cryptography-Bibliothek asymmetrische Verschlüsselung implementieren und sichere Datenkommunikation erreichen.

Grundlagen der Hash-Funktion

Hashing ist der Prozess, bei dem Daten in einen festen Hashwert umgewandelt werden. Der Hashwert ist einseitig und kann nicht zurückverwandelt werden. In diesem Abschnitt erklären wir die grundlegende Verwendung von Hashing mit der cryptography-Bibliothek.

Was ist Hashing?

Hashing wird verwendet, um die Integrität von Daten zu überprüfen oder Passwörter zu speichern. Ein gängiger Hash-Algorithmus ist SHA-256 (Secure Hash Algorithm 256-Bit).

Hashing mit SHA-256

Hier erklären wir die grundlegenden Schritte zum Hashen von Daten mit SHA-256.

Importieren der benötigten Module

Zuerst importieren wir die erforderlichen Module aus der cryptography-Bibliothek.

from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.backends import default_backend

Daten hashen

Nun verwenden wir den SHA-256-Algorithmus, um Daten zu hashen.

def hash_data(data):
    digest = hashes.Hash(hashes.SHA256(), backend=default_backend())
    digest.update(data)
    return digest.finalize()

Praktisches Beispiel

In folgendem Beispiel hashen wir Klartextdaten und zeigen das Ergebnis an.

data = b"Dies sind die zu hashenden Daten"
hashed_data = hash_data(data)
print("Gehashte Daten:", hashed_data.hex())

Verwendung des Hashwerts

Der Hashwert kann verwendet werden, um die Integrität der Daten zu überprüfen. Zum Beispiel können Sie nach dem Herunterladen einer Datei den Hashwert vergleichen, um sicherzustellen, dass die Datei nicht verändert wurde.

# Beispiel zur Berechnung des Hashwerts einer Datei
def hash_file(file_path):
    digest = hashes.Hash(hashes.SHA256(), backend=default_backend())
    with open(file_path, 'rb') as f:
        while chunk := f.read(8192):
            digest.update(chunk)
    return digest.finalize()

# Berechnung und Anzeige des Hashwerts einer Datei
file_path = 'path/to/your/file'
file_hash = hash_file(file_path)
print("Dateihashwert:", file_hash.hex())

So können Sie mit der cryptography-Bibliothek Daten hashen und die Integrität der Daten überprüfen. Hashing spielt eine wichtige Rolle beim Speichern von Passwörtern und der Überprüfung der Integrität von Daten.

Erzeugen von privaten und öffentlichen Schlüsseln

Die Erzeugung von privaten und öffentlichen Schlüsselpaaren ist ein wichtiger Schritt in der asymmetrischen Verschlüsselung. Hier erklären wir, wie man Schlüsselpaaren mit der cryptography-Bibliothek erzeugt und diese speichert und lädt.

Erzeugung eines RSA-Schlüsselpaares

Mit dem RSA-Algorithmus erzeugen wir ein Paar aus öffentlichen und privaten Schlüsseln.

Importieren der benötigten Module

Importieren Sie die benötigten Module aus der cryptography-Bibliothek.

from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization

Erzeugen des Schlüsselpaares

Erzeugen Sie ein Schlüsselpaar mit dem RSA-Algorithmus.

private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048,
)
public_key = private_key.public_key()

Speichern des Schlüssels

Speichern Sie die erzeugten Schlüssel in Dateien. Hier zeigen wir, wie man private und öffentliche Schlüssel separat speichert.

# Speichern des privaten Schlüssels
with open("private_key.pem", "wb") as private_file:
    private_file.write(private_key.private_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PrivateFormat.TraditionalOpenSSL,
        encryption_algorithm=serialization.NoEncryption()
    ))

# Speichern des öffentlichen Schlüssels
with open("public_key.pem", "wb") as public_file:
    public_file.write(public_key.public_bytes(
        encoding=serialization.Encoding.PEM,
        format=serialization.PublicFormat.SubjectPublicKeyInfo
    ))

Laden des Schlüssels

Hier zeigen wir, wie man die gespeicherten Schlüssel aus den Dateien lädt.

# Laden des privaten Schlüssels
with open("private_key.pem", "rb") as private_file:
    loaded_private_key = serialization.load_pem_private_key(
        private_file.read(),
        password=None,
    )

# Laden des öffentlichen Schlüssels
with open("public_key.pem", "rb") as public_file:
    loaded_public_key = serialization.load_pem_public_key(
        public_file.read()
    )

Praktisches Beispiel

In folgendem Beispiel verwenden wir das erzeugte Schlüsselpaar, um Daten zu verschlüsseln und zu entschlüsseln.

from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives import hashes

# Verschlüsselung der Daten
def encrypt(data, public_key):
    return public_key.encrypt(
        data,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(),
            label=None
        )
    )

# Entschlüsselung der Daten
def decrypt(encrypted_data, private_key):
    return private_key.decrypt(
        encrypted_data,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(),
            label=None
        )
    )

# Beispiel für Verschlüsselung und Entschlüsselung
data = b"Dies ist eine geheime Nachricht"
encrypted_data = encrypt(data, loaded_public_key)
print("Verschlüsselte Daten:", encrypted_data)

decrypted_data = decrypt(encrypted_data, loaded_private_key)
print("Entschlüsselte Daten:", decrypted_data.decode())

So können Sie mit der cryptography-Bibliothek ein Schlüsselpaar erzeugen, sicher speichern und für die tatsächliche Datenverschlüsselung und -entschlüsselung verwenden.

Praktische Beispiele für Verschlüsselung und Entschlüsselung

In diesem Abschnitt erklären wir, wie man Daten mit der cryptography-Bibliothek tatsächlich verschlüsselt und entschlüsselt. Wir bieten Beispiele sowohl für symmetrische (AES) als auch asymmetrische (RSA) Verschlüsselung.

Verschlüsselung und Entschlüsselung mit symmetrischer Verschlüsselung

Importieren der benötigten Module

Wir importieren die Module, die für die symmetrische Verschlüsselung benötigt werden.

from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.primitives import padding
from cryptography.hazmat.backends import default_backend
import os

Erzeugen von Schlüssel und Initialisierungsvektor

Für die AES-Verschlüsselung erzeugen wir Schlüssel und einen Initialisierungsvektor (IV).

key = os.urandom(32)  # 256-Bit-Schlüssel
iv = os.urandom(16)   # 128-Bit-Initialisierungsvektor

Daten-Padding

Wir fügen den Daten Padding hinzu, damit ihre Größe ein Vielfaches der Blockgröße ist.

def pad(data):
    padder = padding.PKCS7(algorithms.AES.block_size).padder()
    return padder.update(data) + padder.finalize()

Verschlüsselung der Daten

Nun verschlüsseln wir die gepaddeten Daten.

def encrypt(data, key, iv):
    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
    encryptor = cipher.encryptor()
    padded_data = pad(data)
    return encryptor.update(padded_data) + encryptor.finalize()

Entschlüsselung der Daten

Nun entschlüsseln wir die verschlüsselten Daten und entfernen das Padding.

def decrypt(encrypted_data, key, iv):
    cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
    decryptor = cipher.decryptor()
    padded_data = decryptor.update(encrypted_data) + decryptor.finalize()
    unpadder = padding.PKCS7(algorithms.AES.block_size).unpadder()
    return unpadder.update(padded_data) + unpadder.finalize()

Praktisches Beispiel

Im folgenden Beispiel verschlüsseln und entschlüsseln wir eine Klartextnachricht.

data = b"Dies ist eine geheime Nachricht"
encrypted_data = encrypt(data, key, iv)
print("Verschlüsselte Daten:", encrypted_data)

decrypted_data = decrypt(encrypted_data, key, iv)
print("Entschlüsselte Daten:", decrypted_data.decode())

Verschlüsselung und Entschlüsselung mit asymmetrischer Verschlüsselung

Importieren der benötigten Module

Nun importieren wir die Module für die asymmetrische Verschlüsselung.

from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization, hashes
from cryptography.hazmat.primitives.asymmetric import padding

Erzeugen eines Schlüsselpaares

Erzeugen eines Schlüsselpaares mit dem RSA-Algorithmus.

private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048,
)
public_key = private_key.public_key()

Verschlüsselung der Daten

Wir verschlüsseln die Daten mit dem öffentlichen Schlüssel.

def encrypt(data, public_key):
    return public_key.encrypt(
        data,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(),
            label=None
        )
    )

Entschlüsselung der Daten

Wir entschlüsseln die verschlüsselten Daten mit dem privaten Schlüssel.

def decrypt(encrypted_data, private_key):
    return private_key.decrypt(
        encrypted_data,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(),
            label=None
        )
    )

Praktisches Beispiel

Im folgenden Beispiel verschlüsseln und entschlüsseln wir eine Nachricht mit RSA.

data = b"Dies ist eine geheime Nachricht"
encrypted_data = encrypt(data, public_key)
print("Verschlüsselte Daten:", encrypted_data)

decrypted_data = decrypt(encrypted_data, private_key)
print("Entschlüsselte Daten:", decrypted_data.decode())

So können Sie mit der cryptography-Bibliothek symmetrische und asymmetrische Verschlüsselung in echten Projekten umsetzen. Lernen Sie grundlegende Fähigkeiten zum Schutz Ihrer Daten.

Verwendung in echten Projekten

In diesem Abschnitt erklären wir, wie man Verschlüsselung mit der cryptography-Bibliothek in echten Projekten einsetzt. Wir behandeln Beispiele wie API-Kommunikation, Datenbankverschlüsselung und Dateiverschlüsselung.

Verschlüsselung der API-Kommunikation

In diesem Abschnitt erklären wir, wie man Daten in der API-Kommunikation sicher sendet und empfängt.

Verwendung von HTTPS

API-Kommunikation sollte immer HTTPS verwenden, um die Verbindung zu verschlüsseln und Datenabfang zu verhindern.

Daten verschlüsseln

Durch zusätzliche Verschlüsselung der zu sendenden Daten können wir die Sicherheit weiter erhöhen.

import requests

# Verschlüsselung der Daten mit öffentlichem Schlüssel
data = b"wichtige API-Anfragedaten"
encrypted_data = encrypt(data, public_key)

# Verschicken der verschlüsselten Daten per API
response = requests.post('https://api.example.com/data', data=encrypted_data)

Datenbankverschlüsselung

In diesem Abschnitt erklären wir, wie man wichtige Daten in einer Datenbank verschlüsselt speichert.

Verschlüsselung der Daten bei Speicherung

Wir verschlüsseln die Daten vor dem Speichern in der Datenbank und entschlüsseln sie bei Bedarf.

import sqlite3

# Verbindung zur Datenbank
conn = sqlite3.connect('example.db')
cursor = conn.cursor()

# Verschlüsselung der Daten
data = b"geheime Daten speichern"
encrypted_data = encrypt(data, key, iv)

# Speichern der verschlüsselten Daten
cursor.execute("INSERT INTO secrets (data) VALUES (?)", (encrypted_data,))
conn.commit()

# Entschlüsselung der Daten
cursor.execute("SELECT data FROM secrets")
encrypted_data = cursor.fetchone()[0]
decrypted_data = decrypt(encrypted_data, key, iv)
print("Entschlüsselte Daten:", decrypted_data.decode())

Dateiverschlüsselung

In diesem Abschnitt erklären wir, wie man Dateien sicher speichert, indem man sie verschlüsselt.

Verschlüsselung von Dateien

Wir verschlüsseln den Inhalt einer Datei und speichern ihn sicher, um die Datei später zu entschlüsseln.

# Verschlüsseln der Datei
with open('example.txt', 'rb') as file:
    file_data = file.read()
    encrypted_data = encrypt(file_data, key, iv)

# Speichern der verschlüsselten Datei
with open('example_encrypted.txt', 'wb') as file:
    file.write(encrypted_data)

# Entschlüsseln der Datei
with open('example_encrypted.txt', 'rb') as file:
    encrypted_data = file.read()
    decrypted_data = decrypt(encrypted_data, key, iv)

# Schreiben der entschlüsselten Datei
with open('example_decrypted.txt', 'wb') as file:
    file.write(decrypted_data)

Schlüsselmanagement im Projekt

In diesem Abschnitt erklären wir die Bedeutung des sicheren Schlüsselmanagements und wie man Schlüssel sicher speichert.

Sichere Speicherung von Schlüsseln

Schlüssel sollten sicher gespeichert werden, zum Beispiel mit einem Hardware-Sicherheitsmodul (HSM) oder einem sicheren Schlüsselverwaltungsdienst. Außerdem können Umgebungsvariablen verwendet werden, um Schlüssel zu verwalten.

import os

# Abrufen von Schlüsseln aus Umgebungsvariablen
key = os.environ.get('SECRET_KEY').encode()
iv = os.environ.get('SECRET_IV').encode()

Zusammenfassung

Wir haben die Grundlagen der cryptography-Bibliothek behandelt, von der symmetrischen und asymmetrischen Verschlüsselung bis hin zum Hashing und Schlüsselmanagement. Mit diesen Techniken können Sie die Sicherheit Ihrer Projekte verbessern und Daten sicher verschlüsseln. Nutzen Sie die cryptography-Bibliothek, um robuste Sicherheitslösungen in Ihren Projekten zu implementieren.

Anwendungsbeispiele und Übungen

In diesem Abschnitt stellen wir verschiedene Anwendungsbeispiele und Übungen vor, die Ihnen helfen, Ihre Kenntnisse in der Verschlüsselung zu vertiefen.

Beispiel 1: Verschlüsselte Chat-App

Ein Beispiel für eine sichere Chat-Anwendung, die verschlüsselte Nachrichten verwendet.

Verschlüsselung und Entschlüsselung von Nachrichten

In einer Chat-App müssen die gesendeten Nachrichten verschlüsselt und die empfangenen Nachrichten entschlüsselt werden.

# Verschlüsselung der Nachricht
def encrypt_message(message, public_key):
    return encrypt(message.encode(), public_key)

# Entschlüsselung der Nachricht
def decrypt_message(encrypted_message, private_key):
    return decrypt(encrypted_message, private_key).decode()

# Beispiel
message = "Hallo, dies ist eine geheime Nachricht"
encrypted_message = encrypt_message(message, public_key)
print("Verschlüsselte Nachricht:", encrypted_message)

decrypted_message = decrypt_message(encrypted_message, private_key)
print("Entschlüsselte Nachricht:", decrypted_message)

Beispiel 2: Sichere Dateifreigabe

Ein Beispiel für ein System zur sicheren Dateifreigabe unter Verwendung von Verschlüsselung.

Verschlüsselung und Entschlüsselung von Dateien

Bevor eine Datei freigegeben wird, verschlüsseln wir sie und entschlüsseln sie auf der Empfängerseite.

# Verschlüsseln der Datei
def encrypt_file(file_path, key, iv):
    with open(file_path, 'rb') as file:
        file_data = file.read()
    encrypted_data = encrypt(file_data, key, iv)
    with open(file_path + '.enc', 'wb') as file:
        file.write(encrypted_data)

# Entschlüsseln der Datei
def decrypt_file(encrypted_file_path, key, iv):
    with open(encrypted_file_path, 'rb') as file:
        encrypted_data = file.read()
    decrypted_data = decrypt(encrypted_data, key, iv)
    with open(encrypted_file_path.replace('.enc', ''), 'wb') as file:
        file.write(decrypted_data)

# Beispiel
encrypt_file('shared_document.pdf', key, iv)
decrypt_file('shared_document.pdf.enc', key, iv)

Übungen

Hier finden Sie Übungen, um Ihr Verständnis der Verschlüsselung zu vertiefen. Versuchen Sie, den Code selbst zu schreiben.

Übung 1: Implementierung eines Passwortmanagementsystems mit symmetrischer Verschlüsselung

Erstellen Sie eine Funktion, die das Passwort eines Benutzers mit AES verschlüsselt und speichert. Erstellen Sie auch eine Funktion, die das verschlüsselte Passwort entschlüsselt.

  1. Erstellen Sie eine Funktion, die das Passwort eines Benutzers empfängt und es mit AES verschlüsselt.
  2. Erstellen Sie eine Funktion, die das verschlüsselte Passwort speichert und es bei Bedarf entschlüsselt.

Übung 2: Implementierung eines sicheren Nachrichtensystems mit asymmetrischer Verschlüsselung

Erstellen Sie ein sicheres Nachrichtensystem unter Verwendung von RSA, das die Nachrichten sicher verschlüsselt.

  1. Erstellen Sie ein Schlüsselpaar mit öffentlichem und privatem Schlüssel.
  2. Erstellen Sie eine Funktion, die eine Nachricht mit dem öffentlichen Schlüssel verschlüsselt.
  3. Erstellen Sie eine Funktion, die die verschlüsselte Nachricht mit dem privaten Schlüssel entschlüsselt.

Übung 3: Implementierung eines Systems zur Erkennung von Dateimanipulationen mit Hashing

Erstellen Sie ein System zur Erkennung von Dateiänderungen unter Verwendung von SHA-256.

  1. Erstellen Sie eine Funktion, die den Hashwert einer Datei berechnet.
  2. Ändern Sie eine Datei und berechnen Sie ihren Hashwert erneut, um festzustellen, ob die Datei manipuliert wurde.

Diese Anwendungsbeispiele und Übungen helfen Ihnen dabei, den praktischen Umgang mit der cryptography-Bibliothek zu erlernen und Ihre Fähigkeiten in der Datensicherheit zu verbessern.

Zusammenfassung

In diesem Artikel haben wir die Verwendung der cryptography-Bibliothek in Python zur Verschlüsselung und Hashing ausführlich erklärt. Wir haben die grundlegenden Konzepte der symmetrischen und asymmetrischen Verschlüsselung sowie des Hashings behandelt und gezeigt, wie diese in echten Projekten angewendet werden können. Verschlüsselungstechniken sind von entscheidender Bedeutung für die Datensicherheit, und das Verständnis dieser Techniken hilft Ihnen, Ihre Projekte sicherer zu gestalten. Nutzen Sie die cryptography-Bibliothek, um zuverlässige Sicherheitsmaßnahmen in Ihren Projekten umzusetzen.

Python
AES Asymmetrische Verschlüsselung cryptography-Bibliothek datensicherheit Datenverschlüsselung Hashing Projektanwendungen Python Python-Tutorial RSA Symmetrische Verschlüsselung Verschlüsselungsmethoden
Inhaltsverzeichnis