Erstellen eines einfachen Bildverschlüsselungstools mit Python

Heute tauchen wir in ein spannendes Projekt ein, das Bildverarbeitung mit grundlegenden Verschlüsselungstechniken kombiniert. Wir werden ein Python-Programm untersuchen, das Bilder mit einer einfachen, aber effektiven Methode ver- und entschlüsseln kann. Lass es uns Schritt für Schritt aufschlüsseln!

Voraussetzungen

Um mitzumachen, sollten Sie Folgendes haben:

1. Grundkenntnisse der Python-Programmierung.
2. Python auf Ihrem Computer installiert.

3. Pillow-Bibliothek, eine Python-Bildbibliothek, die für die Verarbeitung von Bildern verwendet wird. Verwenden Sie zum Installieren das Pip Install Pillow.

4. Tkinter ist eine Python-Bibliothek, die zum Erstellen grafischer Benutzeroberflächen (GUIs) verwendet wird. Verwenden Sie zur Installation pip install tk.

Was macht dieses Programm?

Dieses Programm erstellt eine grafische Benutzeroberfläche (GUI), die Benutzern Folgendes ermöglicht:

• Wählen Sie eine Bilddatei aus
• Wählen Sie einen Ausgabeort
• Geben Sie einen Startschlüssel ein
• Das Bild verschlüsseln oder entschlüsseln

Der Verschlüsselungsprozess mischt die Pixel des Bildes basierend auf einem Startschlüssel, wodurch das Bild nicht mehr erkennbar ist. Der Entschlüsselungsprozess macht dies rückgängig und stellt das Originalbild wieder her.

Code-Erklärung

Erforderliche Bibliotheken importieren

import os
from tkinter import Tk, Button, Label, Entry, filedialog, messagebox
from PIL import Image
import random

• os bietet Funktionen zur Interaktion mit dem Betriebssystem.
• tkinter bietet GUI-Elemente wie Schaltflächen, Beschriftungen und Eingabefelder.
• Mit PIL (Pillow) können wir Bilder öffnen, bearbeiten und speichern.
• Random hilft uns, die Pixel auf deterministische Weise zu mischen, indem wir einen Seed.
verwenden

Gesäte Zufallsgeneratorfunktion

def get_seeded_random(seed):
    """Returns a seeded random generator."""
    return random.Random(seed)

Die Funktion get_seeded_random gibt ein zufälliges Objekt zurück, das Elemente jedes Mal auf die gleiche Weise mischen kann, wenn ihm derselbe Startwert gegeben wird.

Dies ist der Schlüssel zum konsistenten Verschlüsseln und Entschlüsseln von Bildern.

Bildverschlüsselung

def encrypt_image(input_image_path, output_image_path, seed):
    """Encrypts the image by manipulating pixel values."""
    image = Image.open(input_image_path)
    width, height = image.size
    # Get pixel data as a list
    pixels = list(image.getdata())
    random_gen = get_seeded_random(seed)

    # Create a list of pixel indices
    indices = list(range(len(pixels)))
    # Shuffle the indices using the seeded random generator
    random_gen.shuffle(indices)

    # Reorder pixels based on shuffled indices
    encrypted_pixels = [pixels[i] for i in indices]

    # Create new image
    encrypted_image = Image.new(image.mode, (width, height))
    # Apply encrypted pixels to the new image
    encrypted_image.putdata(encrypted_pixels)
    # Save the encrypted image
    encrypted_image.save(output_image_path)
    return True

In dieser encrypt_image-Funktion:

• Wir laden das Bild und extrahieren seine Pixeldaten.
• Die Pixelreihenfolge wird mithilfe eines Zufallsgenerators gemischt, um sicherzustellen, dass beim Entschlüsseln dieselbe Mischreihenfolge beibehalten wird.
• Wir erstellen ein neues Bild mit den gemischten Pixelwerten und speichern es als verschlüsseltes Bild.

Bildentschlüsselung

def decrypt_image(input_image_path, output_image_path, seed):
    """Decrypts the image by reversing the encryption process."""
    image = Image.open(input_image_path)
    width, height = image.size
    # Get encrypted pixel data as a list
    encrypted_pixels = list(image.getdata())
    random_gen = get_seeded_random(seed)

    # Create a new list to hold pixel indices in their original order
    indices = list(range(len(encrypted_pixels)))
    # Shuffle the indices again to get the original order
    random_gen.shuffle(indices)

    # Create a new image to hold the decrypted data
    decrypted_pixels = [None] * len(encrypted_pixels)

    # Restore original pixels using the shuffled indices
    for original_index, shuffled_index in enumerate(indices):
        decrypted_pixels[shuffled_index] = encrypted_pixels[original_index]

    # Save the decrypted image
    decrypted_image = Image.new(image.mode, (width, height))
    decrypted_image.putdata(decrypted_pixels)
    decrypted_image.save(output_image_path)
    return True

Diese decrypt_image-Funktion funktioniert, indem sie den Verschlüsselungsprozess umkehrt. Es:

• Lädt das verschlüsselte Bild.
• Verwendet denselben zufälligen Startwert, um die Pixel wieder in ihre ursprüngliche Reihenfolge zu bringen.
• Erstellt und speichert ein neues Bild mit den entschlüsselten Pixeln.

Dateiauswahlfunktionen

def select_input_image():
    """Opens a file dialog to select an input image."""
    input_image_path = filedialog.askopenfilename(title="Select Image")
    input_image_label.config(text=input_image_path)

def select_output_image():
    """Opens a file dialog to select an output image path."""
    output_image_path = filedialog.asksaveasfilename(defaultextension=".png", filetypes=[("PNG files", "*.png"),("JPEG files", "*.jpg;*.jpeg"),("All files", "*.*")], title="Save Encrypted/Decrypted Image")

    output_image_label.config(text=output_image_path)

Mit der Funktion „select_input_image“ kann der Benutzer mithilfe eines Dateidialogs das Bild auswählen, das er verschlüsseln oder entschlüsseln möchte.

Der ausgewählte Bildpfad wird dann auf der GUI angezeigt.

In ähnlicher Weise können Benutzer mit der Funktion „select_output_image“ auswählen, wo das Ausgabebild gespeichert werden soll.

Funktionen der Schaltflächen „Verschlüsseln“ und „Entschlüsseln“.

def encrypt():
    input_image_path = input_image_label.cget("text")
    output_image_path = output_image_label.cget("text")
    seed = seed_entry.get()

    if not input_image_path or not output_image_path:
        messagebox.showerror("Error", "Please select input and output images.")
        return

    if encrypt_image(input_image_path, output_image_path, seed):
        messagebox.showinfo("Success", "Image encrypted successfully!")

def decrypt():
    input_image_path = input_image_label.cget("text")
    output_image_path = output_image_label.cget("text")
    seed = seed_entry.get()

    if not input_image_path or not output_image_path:
        messagebox.showerror("Error", "Please select input and output images.")
        return

    if decrypt_image(input_image_path, output_image_path, seed):
        messagebox.showinfo("Success", "Image decrypted successfully!")

Die Verschlüsselungs- und Entschlüsselungsfunktionen:

• Ruft die ausgewählten Dateipfade und den vom Benutzer eingegebenen Startwert ab.
• Stellt sicher, dass der Benutzer sowohl Eingabe- als auch Ausgabebildpfade ausgewählt hat, bevor er fortfährt.
• Ruft die jeweiligen Funktionen encrypt_image() oder decrypt_image() auf und zeigt Erfolgsmeldungen an, sobald dies erledigt ist.

Erstellen der GUI

root = Tk()
root.title("Image Encryption Tool")

# Create and place widgets
Label(root, text="Select Image to Encrypt/Decrypt:").pack(pady=5)
input_image_label = Label(root, text="No image selected")
input_image_label.pack(pady=5)

Button(root, text="Browse", command=select_input_image).pack(pady=5)

Label(root, text="Output Image Path:").pack(pady=5)
output_image_label = Label(root, text="No output path selected")
output_image_label.pack(pady=5)

Button(root, text="Save As", command=select_output_image).pack(pady=5)

Label(root, text="Enter Seed Key:").pack(pady=5)
seed_entry = Entry(root)
seed_entry.pack(pady=5)

Button(root, text="Encrypt Image", command=encrypt).pack(pady=5)
Button(root, text="Decrypt Image", command=decrypt).pack(pady=5)

root.mainloop()

Beschriftungen, Schaltflächen und Texteingabefelder werden mit pack() platziert.

Die Funktion root.mainloop hält das Fenster geöffnet und reagiert auf Benutzereingaben.

Programm in Aktion

Abschluss

Dieses Programm zeigt, wie wir digitale Bilder auf Pixelebene manipulieren und Pseudozufallszahlengeneratoren für grundlegende Verschlüsselungsaufgaben verwenden können.

Viel Spaß beim Codieren und bleiben Sie sicher!

Das obige ist der detaillierte Inhalt vonErstellen eines einfachen Bildverschlüsselungstools mit Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!