Membina Alat Penyulitan Imej Mudah Menggunakan Python

Hari ini, kami akan menyelami projek menarik yang menggabungkan pemprosesan imej dengan teknik penyulitan asas. Kami akan meneroka program Python yang boleh menyulitkan dan menyahsulit imej menggunakan kaedah yang mudah tetapi berkesan. Mari kita pecahkan langkah demi langkah!

Prasyarat

Untuk mengikuti, anda sepatutnya mempunyai:

1. Pengetahuan asas pengaturcaraan Python.
2. Python dipasang pada komputer anda.

3. Perpustakaan bantal yang merupakan Perpustakaan pengimejan python yang digunakan untuk mengendalikan imej. Gunakan bantal pasang pip untuk memasang.

4. Tkinter iaitu perpustakaan python yang digunakan untuk membina antara muka pengguna grafik (GUI). Gunakan pip install tk untuk memasang.

Apa yang Program Ini Lakukan?

Atur cara ini mencipta antara muka pengguna grafik (GUI) yang membolehkan pengguna:

• Pilih fail imej
• Pilih lokasi output
• Masukkan kunci benih
• Sulitkan atau nyahsulit imej

Proses penyulitan merombak piksel imej berdasarkan kekunci benih, menjadikan imej tidak dapat dikenali. Proses penyahsulitan membalikkan ini, memulihkan imej asal.

Penerangan Kod

Mengimport Perpustakaan yang Diperlukan

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

• os menyediakan fungsi untuk berinteraksi dengan sistem pengendalian.
• tkinter menyediakan elemen GUI seperti butang, label dan medan input.
• PIL (Bantal) membolehkan kami membuka, memanipulasi dan menyimpan imej.
• rawak membantu kami mengocok piksel dengan cara yang pasti, menggunakan benih.

Fungsi Penjana Rawak Berbiji

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

Fungsi get_seeded_random mengembalikan objek rawak yang boleh mengocok item dengan cara yang sama setiap kali jika diberi nilai benih yang sama.

Ini adalah kunci untuk menyulitkan dan menyahsulit imej secara konsisten.

Penyulitan Imej

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

Dalam fungsi encrypt_image ini:

• Kami memuatkan imej dan mengekstrak data pikselnya.
• Turutan piksel dikocok menggunakan penjana rawak berbiji untuk memastikan susunan shuffle yang sama dikekalkan semasa menyahsulit.
• Kami mencipta imej baharu dengan nilai piksel yang dikocok dan menyimpannya sebagai imej yang disulitkan.

Penyahsulitan Imej

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

Fungsi decrypt_image ini berfungsi dengan membalikkan proses penyulitan. Ia:

• Memuatkan imej yang disulitkan.
• Menggunakan benih rawak yang sama untuk merombak semula piksel ke dalam susunan asalnya.
• Mencipta dan menyimpan imej baharu dengan piksel yang dinyahsulit.

Fungsi Pemilihan Fail

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)

Fungsi select_input_image membolehkan pengguna memilih imej yang ingin disulitkan atau dinyahsulit dengan menggunakan dialog fail.

Laluan imej yang dipilih kemudiannya dipaparkan pada GUI.

Begitu juga, fungsi select_output_image membolehkan pengguna memilih tempat untuk menyimpan imej output.

Fungsi Butang Sulit dan Nyahsulit

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!")

Fungsi penyulitan dan nyahsulit:

• Dapatkan laluan fail yang dipilih dan nilai benih yang dimasukkan oleh pengguna.
• Memastikan pengguna telah memilih kedua-dua laluan imej input dan output sebelum meneruskan.
• Panggil fungsi encrypt_image() atau decrypt_image() masing-masing dan memaparkan mesej kejayaan setelah selesai.

Mencipta 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()

Label, butang dan medan entri teks diletakkan menggunakan pek().

Fungsi root.mainloop memastikan tetingkap terbuka dan responsif kepada input pengguna.

Program dalam Tindakan

Kesimpulan

Program ini menunjukkan cara kami boleh memanipulasi imej digital pada tahap piksel dan cara kami boleh menggunakan penjana nombor rawak pseudo untuk tugas penyulitan asas.

Selamat pengekodan, dan kekal selamat!

Atas ialah kandungan terperinci Membina Alat Penyulitan Imej Mudah Menggunakan Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!