Création d'un outil de cryptage d'image simple à l'aide de Python

Aujourd'hui, nous allons nous plonger dans un projet passionnant qui combine le traitement d'images avec des techniques de cryptage de base. Nous allons explorer un programme Python capable de crypter et de décrypter des images à l'aide d'une méthode simple mais efficace. Décomposons-le étape par étape !

Conditions préalables

Pour suivre, vous devriez avoir :

1. Connaissance de base de la programmation Python.
2. Python installé sur votre ordinateur.

3. Bibliothèque Pillow qui est une bibliothèque d'imagerie Python utilisée pour gérer les images. Utilisez l'oreiller pip install pour l'installer.

4. Tkinter qui est une bibliothèque Python utilisée pour créer des interfaces utilisateur graphiques (GUI). Utilisez pip install tk pour installer.

Que fait ce programme ?

Ce programme crée une interface utilisateur graphique (GUI) qui permet aux utilisateurs de :

• Sélectionnez un fichier image
• Choisissez un emplacement de sortie
• Entrez une clé de départ
• Crypter ou décrypter l'image

Le processus de cryptage mélange les pixels de l'image en fonction d'une clé de départ, rendant l'image méconnaissable. Le processus de décryptage inverse cette situation et restaure l'image originale.

Explication du code

Importation des bibliothèques requises

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

• os fournit des fonctions pour interagir avec le système d'exploitation.
• tkinter fournit des éléments d'interface graphique tels que des boutons, des étiquettes et des champs de saisie.
• PIL (Pillow) nous permet d'ouvrir, de manipuler et de sauvegarder des images.
• random nous aide à mélanger les pixels de manière déterministe, en utilisant une graine.

Fonction de générateur aléatoire ensemencé

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

La fonction get_seeded_random renvoie un objet aléatoire qui peut mélanger les éléments de la même manière à chaque fois si on lui donne la même valeur de départ.

C'est la clé pour crypter et déchiffrer les images de manière cohérente.

Cryptage d'images

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

Dans cette fonction encrypt_image :

• Nous chargeons l'image et extrayons ses données de pixels.
• L'ordre des pixels est mélangé à l'aide d'un générateur aléatoire prédéfini pour garantir que le même ordre de lecture aléatoire est maintenu lors du décryptage.
• Nous créons une nouvelle image avec les valeurs de pixels mélangées et l'enregistrons en tant qu'image cryptée.

Décryptage d'images

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

Cette fonction decrypt_image fonctionne en inversant le processus de cryptage. Il :

• Charge l'image cryptée.
• Utilise la même graine aléatoire pour remanier les pixels dans leur ordre d'origine.
• Crée et enregistre une nouvelle image avec les pixels déchiffrés.

Fonctions de sélection de fichiers

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)

La fonction select_input_image permet à l'utilisateur de sélectionner l'image qu'il souhaite crypter ou déchiffrer à l'aide d'une boîte de dialogue de fichier.

Le chemin de l'image sélectionné est ensuite affiché sur l'interface graphique.

De même, la fonction select_output_image permet aux utilisateurs de choisir où enregistrer l'image de sortie.

Fonctions des boutons de cryptage et de décryptage

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

Les fonctions de cryptage et de décryptage :

• Obtient les chemins de fichiers sélectionnés et la valeur de départ saisie par l'utilisateur.
• S'assure que l'utilisateur a sélectionné les chemins d'image d'entrée et de sortie avant de continuer.
• Appelle les fonctions respectives encrypt_image() ou decrypt_image() et affiche les messages de réussite une fois terminé.

Création de l'interface graphique

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

Les étiquettes, boutons et champs de saisie de texte sont placés à l'aide de pack().

La fonction root.mainloop maintient la fenêtre ouverte et réactive aux entrées de l'utilisateur.

Programme en action

Conclusion

Ce programme montre comment manipuler des images numériques au niveau des pixels et comment utiliser des générateurs de nombres pseudo-aléatoires pour les tâches de cryptage de base.

Bon codage et restez en sécurité !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!