Криптонасрал

import random
import tkinter as tk
from tkinter import messagebox


class EllipticCurve:
    def __init__(self, a, b, p):
        self.a = a
        self.b = b
        self.p = p

    def is_on_curve(self, point):
        if point is None:
            return True
        x, y = point
        return (y ** 2 - (x ** 3 + self.a * x + self.b)) % self.p == 0

    def add_points(self, P, Q):
        if P is None:
            return Q
        if Q is None:
            return P

        x1, y1 = P
        x2, y2 = Q

        if x1 == x2 and y1 != y2:
            return None

        if x1 == x2:
            m = (3 * x1 ** 2 + self.a) * pow(2 * y1, -1, self.p)
        else:
            m = (y2 - y1) * pow(x2 - x1, -1, self.p)

        x3 = (m ** 2 - x1 - x2) % self.p
        y3 = (m * (x1 - x3) - y1) % self.p

        return (x3, y3)

    def scalar_multiply(self, k, P):
        result = None
        addend = P

        while k:
            if k & 1:
                result = self.add_points(result, addend)
            addend = self.add_points(addend, addend)
            k >>= 1

        return result


def generate_keys(curve, G):
    private_key = random.randint(1, curve.p - 1)
    public_key = curve.scalar_multiply(private_key, G)
    return private_key, public_key


def gronsfeld_encrypt(text, key):
    encrypted_text = ""
    key_length = len(key)
    for i, char in enumerate(text):
        if char.isalpha():
            shift = key[i % key_length]
            if char.isupper():
                encrypted_text += chr((ord(char) - 65 + shift) % 26 + 65)
            else:
                encrypted_text += chr((ord(char) - 97 + shift) % 26 + 97)
        else:
            encrypted_text += char
    return encrypted_text


def gronsfeld_decrypt(text, key):
    decrypted_text = ""
    key_length = len(key)
    for i, char in enumerate(text):
        if char.isalpha():
            shift = key[i % key_length]
            if char.isupper():
                decrypted_text += chr((ord(char) - 65 - shift) % 26 + 65)
            else:
                decrypted_text += chr((ord(char) - 97 - shift) % 26 + 97)
        else:
            decrypted_text += char
    return decrypted_text


class CryptoApp:
    def __init__(self, root):
        self.root = root
        self.root.title("Elliptic Curve & Gronsfeld Cryptosystem")

        # Параметры эллиптической кривой
        self.a = 2
        self.b = 2
        self.p = 17
        self.curve = EllipticCurve(self.a, self.b, self.p)
        self.G = (5, 1)

        # Генерация ключей
        self.private_key, self.public_key = generate_keys(self.curve, self.G)
        self.key = [int(x) for x in str(self.public_key[0])]

        # GUI элементы
        self.create_widgets()

    def create_widgets(self):
        # Метки
        tk.Label(self.root, text="Private Key:").grid(row=0, column=0, sticky="w")
        tk.Label(self.root, text=str(self.private_key)).grid(row=0, column=1, sticky="w")

        tk.Label(self.root, text="Public Key:").grid(row=1, column=0, sticky="w")
        tk.Label(self.root, text=str(self.public_key)).grid(row=1, column=1, sticky="w")

        tk.Label(self.root, text="Gronsfeld Key:").grid(row=2, column=0, sticky="w")
        tk.Label(self.root, text=str(self.key)).grid(row=2, column=1, sticky="w")

        # Поле ввода текста
        tk.Label(self.root, text="Enter Text:").grid(row=3, column=0, sticky="w")
        self.text_entry = tk.Entry(self.root, width=40)
        self.text_entry.grid(row=3, column=1, columnspan=2, pady=5)

        # Кнопки
        tk.Button(self.root, text="Encrypt", command=self.encrypt_text).grid(row=4, column=1, pady=5)
        tk.Button(self.root, text="Decrypt", command=self.decrypt_text).grid(row=4, column=2, pady=5)

        # Поле вывода результата
        tk.Label(self.root, text="Result:").grid(row=5, column=0, sticky="w")
        self.result_text = tk.Text(self.root, height=5, width=40)
        self.result_text.grid(row=5, column=1, columnspan=2, pady=5)

    def encrypt_text(self):
        text = self.text_entry.get()
        if not text:
            messagebox.showwarning("Warning", "Please enter text to encrypt")
            return

        encrypted_text = gronsfeld_encrypt(text, self.key)
        self.result_text.delete(1.0, tk.END)
        self.result_text.insert(tk.END, f"Encrypted Text: {encrypted_text}")

    def decrypt_text(self):
        text = self.text_entry.get()
        if not text:
            messagebox.showwarning("Warning", "Please enter text to decrypt")
            return

        decrypted_text = gronsfeld_decrypt(text, self.key)
        self.result_text.delete(1.0, tk.END)
        self.result_text.insert(tk.END, f"Decrypted Text: {decrypted_text}")


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