Script Python di Steganografia con GUI

Questo script Python implementa un’applicazione di steganografia con GUI utilizzando tkinter. Permette agli utenti di codificare e decodificare messaggi all’interno di immagini, utilizzando metodi di conversione binaria.

Struttura e Funzionalità

Funzioni di Conversione:

message_to_bin e bin_to_message convertono messaggi in binario e viceversa.

Codifica e Decodifica Immagine:

encode_image e decode_image implementano la logica per nascondere/estrarre il messaggio dall’immagine.

Interfaccia Grafica (GUI):

Un’interfaccia utente grafica per interagire con le funzioni di steganografia.

import tkinter as tk
from tkinter import filedialog, messagebox
from PIL import Image

def message_to_bin(message):
    """Convert a string message to binary."""
    return ''.join(format(ord(i), '08b') for i in message)

def bin_to_message(binary_message):
    """Convert a binary message to string."""
    message = ""
    for i in range(0, len(binary_message), 8):
        byte = binary_message[i:i+8]
        message += chr(int(byte, 2))
    return message

def encode_image(img_path, message, output_path="encoded_image.png"):
    """Encode a binary message into an image."""
    image = Image.open(img_path)
    encoded = image.copy()
    width, height = image.size
    binary_message = message_to_bin(message) + '1111111111111110'  # Add a 16-bit delimiter which indicates end of the message
    data_index = 0
    
    for y in range(height):
        for x in range(width):
            pixel = list(image.getpixel((x, y)))
            for n in range(3):  # Iterate over RGB
                if data_index < len(binary_message):
                    pixel[n] = int(format(pixel[n], '08b')[:-1] + binary_message[data_index], 2)
                    data_index += 1
            encoded.putpixel((x, y), tuple(pixel))
            if data_index == len(binary_message):
                break

    encoded.save(output_path)
    return output_path

def decode_image(img_path):
    """Decode the binary message from an image."""
    image = Image.open(img_path)
    width, height = image.size
    binary_message = ""

    for y in range(height):
        for x in range(width):
            pixel = image.getpixel((x, y))
            for n in range(3):  # Iterate over RGB
                binary_message += format(pixel[n], '08b')[-1]

    # Find the delimiter and extract the message
    delimiter_index = binary_message.find('1111111111111110')
    if delimiter_index != -1:
        binary_message = binary_message[:delimiter_index]

    return bin_to_message(binary_message)

# Classe GUI

class SteganographyGUI:
    def __init__(self, root):
        self.root = root
        self.root.title("Steganography Tool")
        
        # Message input/output
        self.message_label = tk.Label(root, text="Messaggio:")
        self.message_label.pack(pady=10)
        
        self.message_entry = tk.Text(root, height=5, width=40)
        self.message_entry.pack(pady=10)
        
        # Image selection
        self.image_path = tk.StringVar()
        self.select_image_button = tk.Button(root, text="Seleziona Immagine", command=self.select_image)
        self.select_image_button.pack(pady=10)
        
        # Encode/Decode buttons
        self.encode_button = tk.Button(root, text="Codifica", command=self.encode)
        self.encode_button.pack(pady=5)
        
        self.decode_button = tk.Button(root, text="Decodifica", command=self.decode)
        self.decode_button.pack(pady=5)

    def select_image(self):
        file_path = filedialog.askopenfilename(filetypes=[("Image files", "*.png;*.jpg;*.jpeg")])
        if file_path:
            self.image_path.set(file_path)

    def encode(self):
        message = self.message_entry.get("1.0", tk.END).strip()
        if not message:
            messagebox.showerror("Errore", "Inserisci un messaggio da codificare.")
            return
        
        if not self.image_path.get():
            messagebox.showerror("Errore", "Seleziona un'immagine.")
            return
        
        encoded_image_path = encode_image(self.image_path.get(), message)
        messagebox.showinfo("Successo", f"Immagine codificata salvata come {encoded_image_path}")

    def decode(self):
        if not self.image_path.get():
            messagebox.showerror("Errore", "Seleziona un'immagine.")
            return
        
        decoded_message = decode_image(self.image_path.get())
        self.message_entry.delete("1.0", tk.END)
        self.message_entry.insert(tk.END, decoded_message)

# Avvia la GUI

if __name__ == "__main__":
    root = tk.Tk()
    app = SteganographyGUI(root)
    root.mainloop()

Valutazione Tecnica

Semplicità e Usabilità: L’interfaccia utente è intuitiva e ben organizzata, rendendo l’applicazione accessibile agli utenti.

Funzionalità di Steganografia: Le funzioni di codifica e decodifica sono ben implementate, offrendo un metodo efficace per nascondere messaggi all’interno delle immagini.

Gestione degli Errori: Include messaggi di errore per guide l’utente in caso di input mancante.

Conclusioni

Lo script è un esempio eccellente di come utilizzare Python e tkinter per creare strumenti di steganografia sofisticati ma accessibili. L’applicazione è funzionale, user-friendly e può essere estesa o personalizzata ulteriormente.