secure_app.py

import tkinter as tk
from tkinter import ttk, messagebox
import math
import random
import time

class EncryptionApp:
    def __init__(self, root):
        self.root = root
        self.root.title("🔒 Secure Message Transmitter")
        self.root.geometry("600x600")
        self.root.configure(bg="#1e1e2f")

        self.setup_styles()

        self.transmitted_cipher = ""
        self.transmitted_key = ""

        self.frames = {}
        for name in ("Encrypt", "Decrypt"):
            frame = ttk.Frame(self.root, style="Card.TFrame", padding=20)
            self.frames[name] = frame
            frame.grid(row=0, column=0, sticky="nsew")

        self.create_encrypt_screen()
        self.create_decrypt_screen()

        self.show_frame("Encrypt")

    def setup_styles(self):
        style = ttk.Style()
        style.theme_use("clam")

        style.configure("Card.TFrame", background="#2a2a40")
        style.configure("TLabel", background="#2a2a40", foreground="#f8f8f2", font=("Segoe UI", 12))
        style.configure("Header.TLabel", font=("Segoe UI", 16, "bold"), foreground="#50fa7b")
        style.configure("TButton", font=("Segoe UI", 11, "bold"), padding=6, background="#44475a", foreground="#f8f8f2")
        style.map("TButton", background=[("active", "#6272a4")])

        style.configure("TText", relief="flat", borderwidth=1)

    def show_frame(self, name):
        self.frames[name].tkraise()

    def create_encrypt_screen(self):
        frame = self.frames["Encrypt"]

        ttk.Label(frame, text="🔐 Message Encryption", style="Header.TLabel").pack(pady=10)

        ttk.Label(frame, text="Enter Message to Encrypt:").pack(anchor="w", pady=5)
        self.entry_message = tk.Text(frame, height=4, width=70, bg="#1e1e2f", fg="#f8f8f2", insertbackground="white")
        self.entry_message.pack(pady=5)

        ttk.Button(frame, text="Encrypt", command=self.encrypt_message).pack(pady=10)

        ttk.Label(frame, text="Encrypted Cipher Text:").pack(anchor="w", pady=5)
        self.entry_cipher = tk.Text(frame, height=4, width=70, bg="#1e1e2f", fg="#f8f8f2", state='disabled')
        self.entry_cipher.pack(pady=5)

        ttk.Label(frame, text="Private Key:").pack(anchor="w", pady=5)
        self.entry_key = tk.Text(frame, height=4, width=70, bg="#1e1e2f", fg="#f8f8f2", state='disabled')
        self.entry_key.pack(pady=5)

        ttk.Button(frame, text="➡ Go to Decryption Screen", command=lambda: self.show_frame("Decrypt")).pack(pady=15)

    def create_decrypt_screen(self):
        frame = self.frames["Decrypt"]

        ttk.Label(frame, text="🔓 Message Decryption", style="Header.TLabel").pack(pady=10)

        ttk.Label(frame, text="Cipher Text:").pack(anchor="w", pady=5)
        self.decrypt_cipher = tk.Text(frame, height=4, width=70, bg="#1e1e2f", fg="#f8f8f2", insertbackground="white")
        self.decrypt_cipher.pack(pady=5)

        ttk.Label(frame, text="Private Key:").pack(anchor="w", pady=5)
        self.decrypt_key = tk.Text(frame, height=4, width=70, bg="#1e1e2f", fg="#f8f8f2", insertbackground="white")
        self.decrypt_key.pack(pady=5)

        ttk.Button(frame, text="Decrypt", command=self.decrypt_message).pack(pady=10)

        ttk.Label(frame, text="Decrypted Message:").pack(anchor="w", pady=5)
        self.decrypted_message = tk.Text(frame, height=4, width=70, bg="#1e1e2f", fg="#f8f8f2", state='disabled')
        self.decrypted_message.pack(pady=5)

        ttk.Button(frame, text="⬅ Back to Encryption Screen", command=lambda: self.show_frame("Encrypt")).pack(pady=15)

    def encrypt_message(self):
        message = self.entry_message.get("1.0", "end-1c").strip()
        if not message:
            messagebox.showerror("Error", "Message cannot be empty!")
            return

        cipher, private_key = encrypt_message(message)
        self.transmitted_cipher = cipher
        self.transmitted_key = private_key

        self.entry_cipher.config(state='normal')
        self.entry_cipher.delete("1.0", "end")
        self.entry_cipher.insert("1.0", cipher)
        self.entry_cipher.config(state='disabled')

        self.entry_key.config(state='normal')
        self.entry_key.delete("1.0", "end")
        self.entry_key.insert("1.0", private_key)
        self.entry_key.config(state='disabled')

        self.decrypt_cipher.delete("1.0", "end")
        self.decrypt_cipher.insert("1.0", cipher)
        self.decrypt_key.delete("1.0", "end")
        self.decrypt_key.insert("1.0", private_key)

        messagebox.showinfo("Success", "Message encrypted successfully!")

    def decrypt_message(self):
        cipher = self.decrypt_cipher.get("1.0", "end-1c").strip()
        private_key = self.decrypt_key.get("1.0", "end-1c").strip()

        if not cipher or not private_key:
            messagebox.showerror("Error", "Cipher text and key must not be empty.")
            return

        try:
            message = decrypt_message(cipher, private_key)
        except Exception as e:
            messagebox.showerror("Error", f"Decryption failed: {e}")
            return

        self.decrypted_message.config(state='normal')
        self.decrypted_message.delete("1.0", "end")
        self.decrypted_message.insert("1.0", message)
        self.decrypted_message.config(state='disabled')

# Encryption and Decryption logic
def encrypt_message(message):
    len_msg = len(message)
    n = math.ceil(math.sqrt(len_msg))
    padding_char = chr(0)

    mat = [[padding_char] * n for _ in range(n)]
    idx = 0
    for i in range(n):
        for j in range(n):
            if idx < len_msg:
                mat[i][j] = message[idx]
                idx += 1

    ptm = [[ord(mat[i][j]) for j in range(n)] for i in range(n)]

    random.seed(time.time())
    pvkm = [[0] * n for _ in range(n)]
    for i in range(n):
        for j in range(n):
            ld = ptm[i][j] % 10
            hd = ptm[i][j] // 10
            fd = random.randint(3, max(3, hd))  # Ensure fd >= 3
            pvkm[i][j] = fd * 10 + ld

    private_key = ''.join(chr(pvkm[i][j]) for i in range(n) for j in range(n))
    private_key += f":{len_msg}"

    enc_mat = [[0] * n for _ in range(n)]
    for i in range(n):
        for j in range(n):
            a = ptm[i][j] % 10
            hd = ptm[i][j] // 10
            fd = pvkm[i][j] // 10
            difference = hd - fd
            enc_value = a + 10 * (difference + 10)
            enc_mat[i][j] = enc_value

    # Apply row rotation (left by 2)
    for i in range(n):
        enc_mat[i] = enc_mat[i][2:] + enc_mat[i][:2]

    # Subtract from 200
    for i in range(n):
        for j in range(n):
            enc_mat[i][j] = 200 - enc_mat[i][j]

    cipher = ''.join(chr(enc_mat[i][j]) for i in range(n) for j in range(n))
    return cipher, private_key

def decrypt_message(cipher, private_key):
    try:
        private_key_part, length_str = private_key.rsplit(":", 1)
        original_length = int(length_str)
    except:
        raise ValueError("Private key format invalid")

    n = int(math.isqrt(len(private_key_part)))
    if n * n != len(private_key_part):
        raise ValueError("Invalid private key length")

    # Reconstruct pvkm_dec
    pvk_vals = [ord(c) for c in private_key_part]
    pvkm_dec = [[0] * n for _ in range(n)]
    idx = 0
    for i in range(n):
        for j in range(n):
            pvkm_dec[i][j] = pvk_vals[idx]
            idx += 1

    # Process cipher text
    cipher_len = len(cipher)
    if cipher_len != n * n:
        raise ValueError("Cipher length does not match matrix size")

    mat_dec = [[0] * n for _ in range(n)]
    idx = 0
    for i in range(n):
        for j in range(n):
            mat_dec[i][j] = ord(cipher[idx])
            idx += 1

    # Reverse subtraction from 200
    for i in range(n):
        for j in range(n):
            mat_dec[i][j] = 200 - mat_dec[i][j]

    # Reverse row rotation (right by 2)
    for i in range(n):
        mat_dec[i] = mat_dec[i][-2:] + mat_dec[i][:-2]

    ptm_dec = [[0] * n for _ in range(n)]
    for i in range(n):
        for j in range(n):
            enc_value = mat_dec[i][j]
            a = enc_value % 10
            difference_plus_10 = enc_value // 10
            difference = difference_plus_10 - 10
            fd_pvkm = pvkm_dec[i][j] // 10
            ld_pvkm = pvkm_dec[i][j] % 10
            # Validate that a matches the ld from private key
            if a != ld_pvkm:
                raise ValueError("Private key does not match cipher")
            hd_ptm = fd_pvkm + difference
            ptm_dec[i][j] = hd_ptm * 10 + a

    # Convert back to characters
    chars = []
    for i in range(n):
        for j in range(n):
            chars.append(chr(ptm_dec[i][j]))

    return ''.join(chars)[:original_length]

# Run the app
if __name__ == "__main__":
    root = tk.Tk()
    app = EncryptionApp(root)
    root.mainloop()