Visionary Vault Python GUI

import tkinter as tk
from tkinter import ttk, filedialog, messagebox
import os
import hashlib
import json

class VisionaryVaultApp:
    def __init__(self, master):
        self.master = master
        master.title("Visionary Vault")
        master.geometry("600x400")

        self.notebook = ttk.Notebook(master)
        self.notebook.pack(expand=True, fill='both', padx=10, pady=10)

        # File Encryption/Decryption Tab
        self.file_tab = ttk.Frame(self.notebook)
        self.notebook.add(self.file_tab, text='File Encryption')
        self.create_file_tab(self.file_tab)

        # Password Generator Tab
        self.password_tab = ttk.Frame(self.notebook)
        self.notebook.add(self.password_tab, text='Password Generator')
        self.create_password_tab(self.password_tab)
        
        # Text Encryption/Decryption Tab
        self.text_tab = ttk.Frame(self.notebook)
        self.notebook.add(self.text_tab, text='Text Encryption')
        self.create_text_tab(self.text_tab)

        # Settings (JSON) Editor
        self.settings_tab = ttk.Frame(self.notebook)
        self.notebook.add(self.settings_tab, text='Settings Editor')
        self.create_settings_tab(self.settings_tab)


        # Details Button
        self.details_button = tk.Button(master, text="Details", command=self.show_details)
        self.details_button.pack(pady=5)

    def create_file_tab(self, tab):
        # File Selection
        self.file_label = tk.Label(tab, text="Select File:")
        self.file_label.grid(row=0, column=0, padx=5, pady=5, sticky='w')
        self.file_path = tk.StringVar()
        self.file_entry = tk.Entry(tab, textvariable=self.file_path, width=40)
        self.file_entry.grid(row=0, column=1, padx=5, pady=5)
        self.file_button = tk.Button(tab, text="Browse", command=self.browse_file)
        self.file_button.grid(row=0, column=2, padx=5, pady=5)

        # Key Input
        self.file_key_label = tk.Label(tab, text="Encryption Key:")
        self.file_key_label.grid(row=1, column=0, padx=5, pady=5, sticky='w')
        self.file_key = tk.StringVar()
        self.file_key_entry = tk.Entry(tab, textvariable=self.file_key, width=40, show="*")
        self.file_key_entry.grid(row=1, column=1, padx=5, pady=5)

        # Encrypt/Decrypt Buttons
        self.encrypt_button = tk.Button(tab, text="Encrypt", command=self.encrypt_file)
        self.encrypt_button.grid(row=2, column=1, padx=5, pady=5, sticky='e')
        self.decrypt_button = tk.Button(tab, text="Decrypt", command=self.decrypt_file)
        self.decrypt_button.grid(row=2, column=2, padx=5, pady=5, sticky='w')

    def create_password_tab(self, tab):
        # Password Length
        self.password_length_label = tk.Label(tab, text="Password Length:")
        self.password_length_label.grid(row=0, column=0, padx=5, pady=5, sticky='w')
        self.password_length = tk.IntVar(value=12)
        self.password_length_entry = tk.Entry(tab, textvariable=self.password_length, width=5)
        self.password_length_entry.grid(row=0, column=1, padx=5, pady=5, sticky='w')

        # Include Options
        self.include_lower = tk.BooleanVar(value=True)
        self.include_upper = tk.BooleanVar(value=True)
        self.include_digits = tk.BooleanVar(value=True)
        self.include_symbols = tk.BooleanVar(value=True)

        self.lower_check = tk.Checkbutton(tab, text="Lowercase", variable=self.include_lower)
        self.lower_check.grid(row=1, column=0, padx=5, pady=5, sticky='w')
        self.upper_check = tk.Checkbutton(tab, text="Uppercase", variable=self.include_upper)
        self.upper_check.grid(row=1, column=1, padx=5, pady=5, sticky='w')
        self.digits_check = tk.Checkbutton(tab, text="Digits", variable=self.include_digits)
        self.digits_check.grid(row=2, column=0, padx=5, pady=5, sticky='w')
        self.symbols_check = tk.Checkbutton(tab, text="Symbols", variable=self.include_symbols)
        self.symbols_check.grid(row=2, column=1, padx=5, pady=5, sticky='w')

        # Generate Button and Result
        self.generate_button = tk.Button(tab, text="Generate Password", command=self.generate_password)
        self.generate_button.grid(row=3, column=0, columnspan=2, padx=5, pady=5)

        self.password_result = tk.StringVar()
        self.password_entry = tk.Entry(tab, textvariable=self.password_result, width=40, state='readonly')
        self.password_entry.grid(row=4, column=0, columnspan=2, padx=5, pady=5)

    def create_text_tab(self, tab):
        # Text Input/Output
        self.text_input_label = tk.Label(tab, text="Enter Text:")
        self.text_input_label.grid(row=0, column=0, padx=5, pady=5, sticky='w')
        self.text_input = tk.Text(tab, width=40, height=5)
        self.text_input.grid(row=1, column=0, padx=5, pady=5, columnspan=2)

        self.text_key_label = tk.Label(tab, text="Encryption Key:")
        self.text_key_label.grid(row=2, column=0, padx=5, pady=5, sticky='w')
        self.text_key = tk.StringVar()
        self.text_key_entry = tk.Entry(tab, textvariable=self.text_key, width=40, show="*")
        self.text_key_entry.grid(row=2, column=1, padx=5, pady=5)

        self.encrypt_text_button = tk.Button(tab, text="Encrypt Text", command=self.encrypt_text)
        self.encrypt_text_button.grid(row=3, column=0, padx=5, pady=5)
        self.decrypt_text_button = tk.Button(tab, text="Decrypt Text", command=self.decrypt_text)
        self.decrypt_text_button.grid(row=3, column=1, padx=5, pady=5)

        self.text_output_label = tk.Label(tab, text="Result:")
        self.text_output_label.grid(row=4, column=0, padx=5, pady=5, sticky='w')
        self.text_output = tk.Text(tab, width=40, height=5, state='disabled')
        self.text_output.grid(row=5, column=0, padx=5, pady=5, columnspan=2)

    def create_settings_tab(self, tab):
        self.settings_text = tk.Text(tab, width=60, height=15)
        self.settings_text.pack(padx=10, pady=10)

        self.load_button = tk.Button(tab, text="Load Settings", command=self.load_settings)
        self.load_button.pack(side=tk.LEFT, padx=5, pady=5)

        self.save_button = tk.Button(tab, text="Save Settings", command=self.save_settings)
        self.save_button.pack(side=tk.LEFT, padx=5, pady=5)

        self.default_settings = {
            "default_password_length": 16,
            "include_lowercase": True,
            "include_uppercase": True,
            "include_digits": True,
            "include_symbols": True
        }

        self.load_settings()

    def load_settings(self):
        try:
            with open("settings.json", "r") as f:
                settings = json.load(f)
            self.default_settings = settings # Update with loaded settings
        except FileNotFoundError:
            pass # Use default settings

        self.settings_text.delete("1.0", tk.END)
        self.settings_text.insert(tk.END, json.dumps(self.default_settings, indent=4))


    def save_settings(self):
        try:
            settings_data = json.loads(self.settings_text.get("1.0", tk.END))
            with open("settings.json", "w") as f:
                json.dump(settings_data, f, indent=4)
            messagebox.showinfo("Settings Saved", "Settings saved successfully!")
        except json.JSONDecodeError:
            messagebox.showerror("Error", "Invalid JSON format.")
        except Exception as e:
            messagebox.showerror("Error", f"Error saving settings: {e}")

    def browse_file(self):
        filename = filedialog.askopenfilename()
        self.file_path.set(filename)

    def encrypt_file(self):
        file_path = self.file_path.get()
        key = self.file_key.get()

        if not file_path or not key:
            messagebox.showerror("Error", "Please select a file and enter a key.")
            return

        try:
            key = hashlib.sha256(key.encode()).digest()
            with open(file_path, "rb") as f:
                data = f.read()

            encrypted_data = bytearray()
            for i, byte in enumerate(data):
                encrypted_data.append(byte ^ key[i % len(key)])

            with open(file_path + ".enc", "wb") as f:
                f.write(encrypted_data)
            messagebox.showinfo("Success", "File encrypted successfully!")

        except Exception as e:
            messagebox.showerror("Error", f"Encryption failed: {e}")

    def decrypt_file(self):
        file_path = self.file_path.get()
        key = self.file_key.get()

        if not file_path or not key:
            messagebox.showerror("Error", "Please select a file and enter a key.")
            return

        if not file_path.endswith(".enc"):
            messagebox.showerror("Error", "Please select an encrypted file (.enc).")
            return

        try:
            key = hashlib.sha256(key.encode()).digest()
            with open(file_path, "rb") as f:
                data = f.read()

            decrypted_data = bytearray()
            for i, byte in enumerate(data):
                decrypted_data.append(byte ^ key[i % len(key)])

            with open(file_path[:-4], "wb") as f:
                f.write(decrypted_data)
            messagebox.showinfo("Success", "File decrypted successfully!")

        except Exception as e:
            messagebox.showerror("Error", f"Decryption failed: {e}")


    def generate_password(self):
        import secrets
        import string

        length = self.password_length.get()
        include_lower = self.include_lower.get()
        include_upper = self.include_upper.get()
        include_digits = self.include_digits.get()
        include_symbols = self.include_symbols.get()

        characters = ""
        if include_lower:
            characters += string.ascii_lowercase
        if include_upper:
            characters += string.ascii_uppercase
        if include_digits:
            characters += string.digits
        if include_symbols:
            characters += string.punctuation

        if not characters:
            messagebox.showerror("Error", "Please select at least one character type.")
            return

        password = ''.join(secrets.choice(characters) for _ in range(length))
        self.password_result.set(password)

    def encrypt_text(self):
        text = self.text_input.get("1.0", tk.END).strip()
        key = self.text_key.get()

        if not text or not key:
            messagebox.showerror("Error", "Please enter text and a key.")
            return

        try:
            key = hashlib.sha256(key.encode()).digest()
            text_bytes = text.encode('utf-8')
            encrypted_bytes = bytearray()
            for i, byte in enumerate(text_bytes):
                encrypted_bytes.append(byte ^ key[i % len(key)])

            encrypted_text = encrypted_bytes.hex()  # Convert to hexadecimal string
            self.text_output.config(state='normal')  # Enable text widget for editing
            self.text_output.delete("1.0", tk.END)
            self.text_output.insert(tk.END, encrypted_text)
            self.text_output.config(state='disabled')  # Disable text widget again

        except Exception as e:
            messagebox.showerror("Error", f"Encryption failed: {e}")

    def decrypt_text(self):
        text = self.text_input.get("1.0", tk.END).strip()
        key = self.text_key.get()

        if not text or not key:
            messagebox.showerror("Error", "Please enter text and a key.")
            return

        try:
            key = hashlib.sha256(key.encode()).digest()
            encrypted_bytes = bytes.fromhex(text)  # Convert from hexadecimal string
            decrypted_bytes = bytearray()
            for i, byte in enumerate(encrypted_bytes):
                decrypted_bytes.append(byte ^ key[i % len(key)])

            decrypted_text = decrypted_bytes.decode('utf-8')
            self.text_output.config(state='normal')  # Enable text widget for editing
            self.text_output.delete("1.0", tk.END)
            self.text_output.insert(tk.END, decrypted_text)
            self.text_output.config(state='disabled')  # Disable text widget again

        except Exception as e:
            messagebox.showerror("Error", f"Decryption failed: {e}")

    def show_details(self):
        details_text = """
        Visionary Vault is a versatile security tool that offers a range of functionalities:

        1.  **File Encryption/Decryption:** Securely encrypt and decrypt files using a key-based XOR encryption method.
        2.  **Password Generator:** Generate strong, customizable passwords with options for length, lowercase, uppercase, digits, and symbols.
        3.  **Text Encryption/Decryption:** Encrypt and decrypt text messages using a key-based XOR encryption method.
        4.  **Settings Editor:** Allows users to modify default settings (such as password length or character sets) via a JSON editor and save them to a settings.json file.

        This application uses SHA-256 hashing for key strengthening.
        """
        messagebox.showinfo("Details", details_text)

root = tk.Tk()
app = VisionaryVaultApp(root)
root.mainloop()