SYMULATOR MARTA-CRYPTO AES KOMUNIKATOR

Question

CZEŚĆ STWORZYŁEM NIKOMU NIE POTRZEBNY SYMULATOR KOMUNIKATORA Z SZYFROWANIEM PLIKÓW, WERSJA EDUKACYJNA MAM RÓWNIEŻ WERSJE EXE,(WINDOWS TRAKTUJE GO JAK WIRUSA HE HE)

Kod w Pythonie

import tkinter as tk
from tkinter import messagebox, filedialog
import base64
import math
import random
import hashlib
import json
import os
from sympy import primerange, isprime
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.primitives import padding
from cryptography.hazmat.backends import default_backend

# === Marta-Crypto AES ===

def tekst_na_sume_ascii(tekst):
    return sum(ord(znak) for znak in tekst)

def znajdz_szyfr_marta(tekst):
    suma_ascii = tekst_na_sume_ascii(tekst)
    if suma_ascii <= 10:
        return None
    
    r = random.randint(1, 7)
    s = int(math.log(suma_ascii) + r)
    k = max(2, int(math.log(s)) if s > 0 else 2)

    liczby_pierwsze = list(primerange(2, suma_ascii))
    if len(liczby_pierwsze) < k:
        return None

    szyfr = random.choices(liczby_pierwsze, k=k)
    aktualna_suma = sum(szyfr)
    roznica = suma_ascii - aktualna_suma
    if roznica != 0:
        poprawiona = szyfr[-1] + roznica
        if poprawiona > 1 and isprime(poprawiona):
            szyfr[-1] = poprawiona

    return szyfr

def generuj_klucz_aes(klucz_uzytkownika, szyfr_marta):
    dane = klucz_uzytkownika + ''.join(str(p) for p in szyfr_marta)
    return hashlib.sha256(dane.encode()).digest()

def szyfruj_aes(tekst, klucz_aes):
    iv = os.urandom(16)
    cipher = Cipher(algorithms.AES(klucz_aes), modes.CBC(iv), backend=default_backend())
    encryptor = cipher.encryptor()
    padder = padding.PKCS7(128).padder()
    if isinstance(tekst, str):
        tekst = tekst.encode()
    padded_data = padder.update(tekst) + padder.finalize()
    zaszyfrowane = encryptor.update(padded_data) + encryptor.finalize()
    return base64.b64encode(iv + zaszyfrowane).decode()

def odszyfruj_aes(tekst_b64, klucz_aes):
    dane = base64.b64decode(tekst_b64)
    iv = dane[:16]
    zaszyfrowane = dane[16:]
    cipher = Cipher(algorithms.AES(klucz_aes), modes.CBC(iv), backend=default_backend())
    decryptor = cipher.decryptor()
    odszyfrowane_padded = decryptor.update(zaszyfrowane) + decryptor.finalize()
    unpadder = padding.PKCS7(128).unpadder()
    return unpadder.update(odszyfrowane_padded) + unpadder.finalize()

def zapisz_wiadomosc(nadawca, odbiorca, szyfr, zaszyfrowane_b64, hash_val):
    dane = {
        "nadawca": nadawca,
        "odbiorca": odbiorca,
        "szyfr": szyfr,
        "zaszyfrowane": zaszyfrowane_b64,
        "hash": hash_val
    }
    filepath = filedialog.asksaveasfilename(defaultextension=".json",
                                            filetypes=[("Pliki JSON", "*.json")],
                                            title="Zapisz wiadomość jako")
    if filepath:
        with open(filepath, "w", encoding="utf-8") as f:
            json.dump(dane, f, indent=2)
        return filepath
    return None

def wczytaj_wiadomosc():
    filepath = filedialog.askopenfilename(defaultextension=".json",
                                          filetypes=[("Pliki JSON", "*.json")],
                                          title="Wybierz plik z wiadomością")
    if filepath:
        try:
            with open(filepath, "r", encoding="utf-8") as f:
                return json.load(f)
        except FileNotFoundError:
            return None
    return None

def szyfruj_plik():
    klucz = entry_klucz.get()
    if not klucz:
        messagebox.showwarning("Błąd", "Podaj klucz przed szyfrowaniem pliku!")
        return

    filepath = filedialog.askopenfilename(
        title="Wybierz plik do zaszyfrowania",
        filetypes=[("Wszystkie pliki", "*.*")]
    )
    if not filepath:
        return

    with open(filepath, "rb") as f:
        dane_bin = f.read()

    # Generujemy szyfr Marta na podstawie nazwy pliku (lub możesz zmienić na dane_bin jeśli chcesz)
    szyfr = znajdz_szyfr_marta(os.path.basename(filepath))
    if not szyfr:
        messagebox.showerror("Błąd", "Nie udało się wygenerować szyfru!")
        return

    klucz_aes = generuj_klucz_aes(klucz, szyfr)
    iv = os.urandom(16)
    cipher = Cipher(algorithms.AES(klucz_aes), modes.CBC(iv), backend=default_backend())
    encryptor = cipher.encryptor()
    padder = padding.PKCS7(128).padder()
    padded = padder.update(dane_bin) + padder.finalize()
    zaszyfrowane = encryptor.update(padded) + encryptor.finalize()

    zaszyfrowane_b64 = base64.b64encode(iv + zaszyfrowane).decode()
    hash_val = hashlib.sha256(dane_bin).hexdigest()

    dane = {
        "szyfr": szyfr,
        "nazwa_pliku": os.path.basename(filepath),
        "zaszyfrowane": zaszyfrowane_b64,
        "hash": hash_val
    }
    savepath = filedialog.asksaveasfilename(
        defaultextension=".json",
        filetypes=[("Pliki JSON", "*.json")],
        title="Zapisz zaszyfrowany plik jako"
    )
    if savepath:
        with open(savepath, "w", encoding="utf-8") as f:
            json.dump(dane, f, indent=2)
        messagebox.showinfo("Sukces", f"Plik został zaszyfrowany i zapisany: {savepath}")

def odszyfruj_plik():
    klucz = entry_klucz.get()
    if not klucz:
        messagebox.showwarning("Błąd", "Podaj klucz przed odszyfrowaniem pliku!")
        return

    filepath = filedialog.askopenfilename(
        defaultextension=".json",
        filetypes=[("Pliki JSON", "*.json")],
        title="Wybierz zaszyfrowany plik do odszyfrowania"
    )
    if not filepath:
        return

    try:
        with open(filepath, "r", encoding="utf-8") as f:
            dane = json.load(f)
    except Exception as e:
        messagebox.showerror("Błąd", f"Nie udało się wczytać pliku:\n{e}")
        return

    szyfr = dane.get("szyfr")
    zaszyfrowane_b64 = dane.get("zaszyfrowane")
    nazwa_pliku = dane.get("nazwa_pliku", "plik_odszyfrowany")
    _, ext = os.path.splitext(nazwa_pliku)
    if ext == "":
        ext = ".bin"  # domyślne rozszerzenie, jeśli brak oryginalnego

    if not szyfr or not zaszyfrowane_b64:
        messagebox.showerror("Błąd", "Niepoprawny format pliku zaszyfrowanego!")
        return

    klucz_aes = generuj_klucz_aes(klucz, szyfr)
    try:
        odszyfrowane_bytes = odszyfruj_aes(zaszyfrowane_b64, klucz_aes)
    except Exception as e:
        messagebox.showerror("Błąd", f"Nieprawidłowy klucz lub uszkodzone dane:\n{e}")
        return

    hash_sprawdzenie = hashlib.sha256(odszyfrowane_bytes).hexdigest()
    if hash_sprawdzenie != dane.get("hash"):
        messagebox.showwarning("Uwaga", "Hash pliku nie zgadza się! Plik może być uszkodzony lub zły klucz.")

    savepath = filedialog.asksaveasfilename(
        initialfile="odszyfrowany" + ext,
        title="Zapisz odszyfrowany plik jako",
        filetypes=[("Wszystkie pliki", "*.*")]
    )
    if not savepath:
        return

    # Dopisz rozszerzenie, jeśli użytkownik go nie podał
    if not os.path.splitext(savepath)[1]:
        savepath += ext

    try:
        with open(savepath, "wb") as f:
            f.write(odszyfrowane_bytes)
        messagebox.showinfo("Sukces", f"Plik odszyfrowany i zapisany:\n{savepath}")
    except Exception as e:
        messagebox.showerror("Błąd", f"Nie udało się zapisać pliku:\n{e}")

# === GUI ===

root = tk.Tk()
root.title(" Marta-Crypto AES Komunikator")

tk.Label(root, text=" Nadawca").grid(row=0, column=0)
entry_nadawca = tk.Entry(root, width=40)
entry_nadawca.grid(row=0, column=1)

tk.Label(root, text=" Odbiorca").grid(row=1, column=0)
entry_odbiorca = tk.Entry(root, width=40)
entry_odbiorca.grid(row=1, column=1)

tk.Label(root, text=" Wiadomość").grid(row=2, column=0)
text_wiadomosc = tk.Text(root, height=10, width=60)
text_wiadomosc.grid(row=2, column=1)

tk.Label(root, text=" Klucz").grid(row=3, column=0)
entry_klucz = tk.Entry(root, show="*", width=40)
entry_klucz.grid(row=3, column=1)

def nadaj_wiadomosc():
    nadawca = entry_nadawca.get()
    odbiorca = entry_odbiorca.get()
    wiadomosc = text_wiadomosc.get("1.0", tk.END).strip()
    klucz = entry_klucz.get()

    if not wiadomosc or not klucz:
        messagebox.showwarning("Błąd", "Podaj wiadomość i klucz!")
        return

    szyfr = znajdz_szyfr_marta(wiadomosc)
    if not szyfr:
        messagebox.showerror("Błąd", "Nie udało się wygenerować szyfru!")
        return

    klucz_aes = generuj_klucz_aes(klucz, szyfr)
    zaszyfrowane_b64 = szyfruj_aes(wiadomosc, klucz_aes)
    hash_val = hashlib.sha256(wiadomosc.encode()).hexdigest()
    filepath = zapisz_wiadomosc(nadawca, odbiorca, szyfr, zaszyfrowane_b64, hash_val)
    if filepath:
        messagebox.showinfo("Sukces", f"Wiadomość zaszyfrowana i zapisana do pliku:\n{filepath}")

def odbierz_wiadomosc():
    klucz = entry_klucz.get()
    dane = wczytaj_wiadomosc()
    if not klucz or not dane:
        messagebox.showwarning("Błąd", "Brak klucza lub wiadomości!")
        return

    klucz_aes = generuj_klucz_aes(klucz, dane["szyfr"])
    try:
        wiadomosc = odszyfruj_aes(dane["zaszyfrowane"], klucz_aes).decode()
    except Exception:
        messagebox.showerror("Błąd", "Nieprawidłowy klucz lub dane!")
        return

    hash_sprawdzenie = hashlib.sha256(wiadomosc.encode()).hexdigest()
    zgodnosc = hash_sprawdzenie == dane["hash"]
    messagebox.showinfo("Odszyfrowano",
                        f"Nadawca: {dane['nadawca']}\nOdbiorca: {dane['odbiorca']}\n\nTreść: {wiadomosc}\n\nHash zgodny: {zgodnosc}")

tk.Button(root, text=" Nadaj wiadomość", command=nadaj_wiadomosc, bg="lightgreen").grid(row=4, column=0, pady=10)
tk.Button(root, text=" Odbierz wiadomość", command=odbierz_wiadomosc, bg="lightblue").grid(row=4, column=1)

tk.Button(root, text=" Szyfruj plik", command=szyfruj_plik, bg="lightgray").grid(row=5, column=0, pady=10)
tk.Button(root, text=" Odszyfruj plik", command=odszyfruj_plik, bg="lightyellow").grid(row=5, column=1)

root.mainloop()

 

Tutaj jest wersja exe: 

https://drive.google.com/drive/folders/1DIGX8wIGqpDm_UH0zIqCD_z8Kb1kHkWW?usp=sharing

Można tym programem szyfrować i odszyfrowywać pliki, tekstowe i inne również, oczywiście pewnie nie działa dobrze wszystko, ale dla zabawy może do czegoś komuś posłużyć. 

Comments

Stworzyłem też leki komunikator na bazie dzielenia L**2//2, 

https://drive.google.com/drive/folders/148x8BgLTVH7joZJmGrX-Y_c0vc4ABkPC?usp=sharing

import tkinter as tk
from tkinter import messagebox, filedialog
import hashlib
import random
import math
import json
import os

# --- Protokół Marta-Crypto prosty ---

def licz_dzielenia_logarytmicznie(n):
    if n <= 1:
        return 0
    return int(2 * math.log2(n))

def f(L, salt, challenge):
    input_str = f"{L}-{salt}-{challenge}"
    hash_obj = hashlib.sha256(input_str.encode())
    hash_hex = hash_obj.hexdigest()
    hash_int = int(hash_hex, 16)
    val = (hash_int % (10**12)) + 1  # unikamy zera
    dzielenia = licz_dzielenia_logarytmicznie(val)
    return hash_hex, dzielenia

def szyfruj_protokol(wiadomosc, klucz_uzytkownika):
    L = int(hashlib.sha256(klucz_uzytkownika.encode()).hexdigest(), 16)
    salt = random.randint(1, 10**12)
    challenge = 0
    pub_hash, dzielenia = f(L, salt, challenge)

    dane = {
        "wiadomosc": wiadomosc,
        "pub_hash": pub_hash,
        "dzielenia": dzielenia,
        "salt": salt
    }
    return dane

def odszyfruj_protokol(dane, klucz_uzytkownika):
    wiadomosc = dane.get("wiadomosc")
    pub_hash = dane.get("pub_hash")
    dzielenia = dane.get("dzielenia")
    salt = dane.get("salt")

    L = int(hashlib.sha256(klucz_uzytkownika.encode()).hexdigest(), 16)
    challenge = 0
    sprawdz_hash, sprawdz_dzielenia = f(L, salt, challenge)

    if pub_hash == sprawdz_hash and dzielenia == sprawdz_dzielenia:
        return wiadomosc, True
    else:
        return wiadomosc, False

# --- Funkcje do zapisu/odczytu wiadomości ---

def zapisz_wiadomosc(nadawca, odbiorca, szyfr, zaszyfrowane_b64, hash_val):
    dane = {
        "nadawca": nadawca,
        "odbiorca": odbiorca,
        "szyfr": szyfr,
        "zaszyfrowane": zaszyfrowane_b64,
        "hash": hash_val
    }
    filepath = filedialog.asksaveasfilename(defaultextension=".json",
                                            filetypes=[("Pliki JSON", "*.json")],
                                            title="Zapisz wiadomość jako")
    if filepath:
        with open(filepath, "w", encoding="utf-8") as f:
            json.dump(dane, f, indent=2)
        return filepath
    return None

def wczytaj_wiadomosc():
    filepath = filedialog.askopenfilename(defaultextension=".json",
                                          filetypes=[("Pliki JSON", "*.json")],
                                          title="Wybierz plik z wiadomością")
    if filepath:
        try:
            with open(filepath, "r", encoding="utf-8") as f:
                return json.load(f)
        except Exception:
            return None
    return None

# --- Funkcje szyfrowania plików (protokół Marta-Crypto) ---

def szyfruj_plik_protokol():
    klucz = entry_klucz.get()
    if not klucz:
        messagebox.showwarning("Błąd", "Podaj klucz przed szyfrowaniem pliku!")
        return

    filepath = filedialog.askopenfilename(
        title="Wybierz plik do zaszyfrowania",
        filetypes=[("Wszystkie pliki", "*.*")]
    )
    if not filepath:
        return

    try:
        with open(filepath, "rb") as f:
            dane_bin = f.read()
    except Exception as e:
        messagebox.showerror("Błąd", f"Nie udało się odczytać pliku:\n{e}")
        return

    tekst_bin = dane_bin.hex()
    szyfrowane_dane = szyfruj_protokol(tekst_bin, klucz)
    hash_val = hashlib.sha256(dane_bin).hexdigest()

    dane_do_zapisu = {
        "szyfr": None,
        "nazwa_pliku": os.path.basename(filepath),
        "zaszyfrowane": szyfrowane_dane,
        "hash": hash_val
    }

    savepath = filedialog.asksaveasfilename(
        defaultextension=".json",
        filetypes=[("Pliki JSON", "*.json")],
        title="Zapisz zaszyfrowany plik jako"
    )
    if savepath:
        try:
            with open(savepath, "w", encoding="utf-8") as f:
                json.dump(dane_do_zapisu, f, indent=2)
            messagebox.showinfo("Sukces", f"Plik został zaszyfrowany i zapisany: {savepath}")
        except Exception as e:
            messagebox.showerror("Błąd", f"Nie udało się zapisać pliku:\n{e}")

def odszyfruj_plik_protokol():
    klucz = entry_klucz.get()
    if not klucz:
        messagebox.showwarning("Błąd", "Podaj klucz przed odszyfrowaniem pliku!")
        return

    filepath = filedialog.askopenfilename(
        defaultextension=".json",
        filetypes=[("Pliki JSON", "*.json")],
        title="Wybierz zaszyfrowany plik do odszyfrowania"
    )
    if not filepath:
        return

    try:
        with open(filepath, "r", encoding="utf-8") as f:
            dane = json.load(f)
    except Exception as e:
        messagebox.showerror("Błąd", f"Nie udało się wczytać pliku:\n{e}")
        return

    zaszyfrowane = dane.get("zaszyfrowane")
    nazwa_pliku = dane.get("nazwa_pliku", "plik_odszyfrowany")
    hash_oryginal = dane.get("hash")

    if not zaszyfrowane:
        messagebox.showerror("Błąd", "Niepoprawny format pliku zaszyfrowanego!")
        return

    try:
        tekst_hex, zgodnosc = odszyfruj_protokol(zaszyfrowane, klucz)
        dane_bin = bytes.fromhex(tekst_hex)
    except Exception as e:
        messagebox.showerror("Błąd", f"Nieprawidłowy klucz lub uszkodzone dane:\n{e}")
        return

    hash_sprawdzenie = hashlib.sha256(dane_bin).hexdigest()
    if hash_sprawdzenie != hash_oryginal:
        messagebox.showwarning("Uwaga", "Hash pliku nie zgadza się! Plik może być uszkodzony lub zły klucz.")

    savepath = filedialog.asksaveasfilename(
        initialfile="odszyfrowany_" + nazwa_pliku,
        title="Zapisz odszyfrowany plik jako",
        filetypes=[("Wszystkie pliki", "*.*")]
    )
    if not savepath:
        return

    # Dodaj rozszerzenie oryginalnego pliku jeśli użytkownik go nie podał
    if not os.path.splitext(savepath)[1]:
        ext = os.path.splitext(nazwa_pliku)[1]
        if ext:
            savepath += ext

    try:
        with open(savepath, "wb") as f:
            f.write(dane_bin)
        messagebox.showinfo("Sukces", f"Plik odszyfrowany i zapisany:\n{savepath}\nWeryfikacja poprawna: {zgodnosc}")
    except Exception as e:
        messagebox.showerror("Błąd", f"Nie udało się zapisać pliku:\n{e}")

# --- GUI ---

root = tk.Tk()
root.title(" Marta-Crypto Protokół Komunikator")

tk.Label(root, text=" Nadawca").grid(row=0, column=0)
entry_nadawca = tk.Entry(root, width=40)
entry_nadawca.grid(row=0, column=1)

tk.Label(root, text=" Odbiorca").grid(row=1, column=0)
entry_odbiorca = tk.Entry(root, width=40)
entry_odbiorca.grid(row=1, column=1)

tk.Label(root, text=" Wiadomość").grid(row=2, column=0)
text_wiadomosc = tk.Text(root, height=10, width=60)
text_wiadomosc.grid(row=2, column=1)

tk.Label(root, text=" Klucz").grid(row=3, column=0)
entry_klucz = tk.Entry(root, show="*", width=40)
entry_klucz.grid(row=3, column=1)

def nadaj_wiadomosc():
    nadawca = entry_nadawca.get()
    odbiorca = entry_odbiorca.get()
    wiadomosc = text_wiadomosc.get("1.0", tk.END).strip()
    klucz = entry_klucz.get()

    if not wiadomosc or not klucz:
        messagebox.showwarning("Błąd", "Podaj wiadomość i klucz!")
        return

    dane = szyfruj_protokol(wiadomosc, klucz)
    hash_val = hashlib.sha256(wiadomosc.encode()).hexdigest()

    filepath = zapisz_wiadomosc(nadawca, odbiorca, szyfr=None,
                                zaszyfrowane_b64=dane, hash_val=hash_val)
    if filepath:
        messagebox.showinfo("Sukces", f"Wiadomość zapisana z protokołem: {filepath}")

def odbierz_wiadomosc():
    klucz = entry_klucz.get()
    dane = wczytaj_wiadomosc()
    if not klucz or not dane:
        messagebox.showwarning("Błąd", "Brak klucza lub wiadomości!")
        return

    wiadomosc, zgodnosc = odszyfruj_protokol(dane["zaszyfrowane"], klucz)

    if zgodnosc:
        messagebox.showinfo("Odszyfrowano",
                            f"Nadawca: {dane['nadawca']}\nOdbiorca: {dane['odbiorca']}\n\nTreść: {wiadomosc}\n\nWeryfikacja: OK")
    else:
        messagebox.showwarning("Błąd weryfikacji",
                               f"Nadawca: {dane['nadawca']}\nOdbiorca: {dane['odbiorca']}\n\nTreść: {wiadomosc}\n\nWeryfikacja: NIEZGODNA")

tk.Button(root, text=" Nadaj wiadomość", command=nadaj_wiadomosc, bg="lightgreen").grid(row=4, column=0, pady=10)
tk.Button(root, text=" Odbierz wiadomość", command=odbierz_wiadomosc, bg="lightblue").grid(row=4, column=1)

tk.Button(root, text=" Szyfruj plik", command=szyfruj_plik_protokol, bg="lightgray").grid(row=5, column=0, pady=10)
tk.Button(root, text=" Odszyfruj plik", command=odszyfruj_plik_protokol, bg="lightyellow").grid(row=5, column=1)

root.mainloop()

 

Podsumowanie:

• Wykorzystanie L**2//2 to sposób na skalowanie i przetwarzanie liczby bazowej (pochodzącej z klucza) do wartości użytecznej do weryfikacji i generowania losowych parametrów protokołu.

• To matematyczne „oczko” protokołu, które zapewnia:

  • Nietrywialność,

  • Rozproszenie wartości,

  • Trudność przewidzenia poprawnej wartości bez znajomości klucza.

• To element twojej lekkiej, niestandardowej metody „szyfrowania” / weryfikacji.