Upload app.py

app.py

@@ -0,0 +1,601 @@
+import streamlit as st
+import qrcode
+from io import BytesIO
+from PIL import Image, ImageDraw, ImageFont
+from Crypto.Cipher import AES, DES, Blowfish
+from Crypto.Util.Padding import pad, unpad
+from Crypto.Random import get_random_bytes
+from Crypto.PublicKey import DSA, RSA
+from Crypto.Signature import DSS, pkcs1_15
+from Crypto.Hash import SHA256, SHA512, MD5
+import base64
+import hashlib
+from ecdsa import SigningKey, VerifyingKey, SECP256k1, BadSignatureError
+from sympy import Matrix
+import numpy as np
+import string
+
+def generate_key(algo, length):
+    if algo == "AES":
+        return get_random_bytes(length)
+    elif algo == "DES":
+        return get_random_bytes(8)
+    elif algo == "Blowfish":
+        return get_random_bytes(length)
+    elif algo == "ویژینر" or algo == "پلایفیر":
+        return ''.join(np.random.choice(list(string.ascii_uppercase), length))
+    elif algo == "اسکیتال":
+        return np.random.randint(1, 100)
+    elif algo == "رمزنگاری هیل":
+        return np.random.randint(1, 25, (length, length))
+    return None
+def generate_qr_code_with_copyright(data, copyright_text):
+    qr = qrcode.QRCode(
+        version=1,
+        error_correction=qrcode.constants.ERROR_CORRECT_H,
+        box_size=10,
+        border=4,
+    )
+    qr.add_data(data)
+    qr.make(fit=True)
+    
+    img = qr.make_image(fill='black', back_color='white').convert('RGB')
+    draw = ImageDraw.Draw(img)
+    font_size = 20
+    try:
+        font = ImageFont.truetype("arial.ttf", font_size)
+    except IOError:
+        font = ImageFont.load_default()
+
+    textbbox = draw.textbbox((0, 0), copyright_text, font=font)
+    textwidth, textheight = textbbox[2] - textbbox[0], textbbox[3] - textbbox[1]
+    width, height = img.size
+    x = (width - textwidth) / 2
+    y = height - textheight - 10
+    draw.text((x, y), copyright_text, font=font, fill="black")
+    
+    return img
+    
+def encrypt_aes(data, key):
+    cipher = AES.new(key, AES.MODE_CBC)
+    ct_bytes = cipher.encrypt(pad(data.encode(), AES.block_size))
+    return base64.b64encode(cipher.iv + ct_bytes).decode('utf-8')
+
+def encrypt_des(data, key):
+    cipher = DES.new(key, DES.MODE_CBC)
+    ct_bytes = cipher.encrypt(pad(data.encode(), DES.block_size))
+    return base64.b64encode(cipher.iv + ct_bytes).decode('utf-8')
+
+def encrypt_blowfish(data, key):
+    cipher = Blowfish.new(key, Blowfish.MODE_CBC)
+    ct_bytes = cipher.encrypt(pad(data.encode(), Blowfish.block_size))
+    return base64.b64encode(cipher.iv + ct_bytes).decode('utf-8')
+
+def decrypt_aes(enc_data, key):
+    enc_data = base64.b64decode(enc_data)
+    iv = enc_data[:AES.block_size]
+    ct = enc_data[AES.block_size:]
+    cipher = AES.new(key, AES.MODE_CBC, iv)
+    pt = unpad(cipher.decrypt(ct), AES.block_size)
+    return pt.decode('utf-8')
+
+def decrypt_des(enc_data, key):
+    enc_data = base64.b64decode(enc_data)
+    iv = enc_data[:DES.block_size]
+    ct = enc_data[DES.block_size:]
+    cipher = DES.new(key, DES.MODE_CBC, iv)
+    pt = unpad(cipher.decrypt(ct), DES.block_size)
+    return pt.decode('utf-8')
+
+def decrypt_blowfish(enc_data, key):
+    enc_data = base64.b64decode(enc_data)
+    iv = enc_data[:Blowfish.block_size]
+    ct = enc_data[Blowfish.block_size:]
+    cipher = Blowfish.new(key, Blowfish.MODE_CBC, iv)
+    pt = unpad(cipher.decrypt(ct), Blowfish.block_size)
+    return pt.decode('utf-8')
+
+def hash_md5(data):
+    return hashlib.md5(data.encode()).hexdigest()
+
+def hash_sha256(data):
+    return hashlib.sha256(data.encode()).hexdigest()
+
+def hash_sha512(data):
+    return hashlib.sha512(data.encode()).hexdigest()
+
+def generate_ecc_keys():
+    private_key = SigningKey.generate(curve=SECP256k1)
+    public_key = private_key.get_verifying_key()
+    return private_key, public_key
+
+def sign_ecc(private_key, data):
+    return private_key.sign(data.encode()).hex()
+
+def verify_ecc(public_key, signature, data):
+    try:
+        public_key.verify(bytes.fromhex(signature), data.encode())
+        return True
+    except BadSignatureError:
+        return False
+
+def generate_dsa_keys():
+    key = DSA.generate(1024)
+    return key, key.publickey()
+
+def sign_dsa(private_key, data):
+    hash_obj = SHA256.new(data.encode())
+    signer = DSS.new(private_key, 'fips-186-3')
+    return signer.sign(hash_obj).hex()
+
+def verify_dsa(public_key, signature, data):
+    hash_obj = SHA256.new(data.encode())
+    verifier = DSS.new(public_key, 'fips-186-3')
+    try:
+        verifier.verify(hash_obj, bytes.fromhex(signature))
+        return True
+    except ValueError:
+        return False
+
+def generate_rsa_keys():
+    key = RSA.generate(2048)
+    return key, key.publickey()
+
+def sign_rsa(private_key, data):
+    hash_obj = SHA256.new(data.encode())
+    signer = pkcs1_15.new(private_key)
+    return signer.sign(hash_obj).hex()
+
+def verify_rsa(public_key, signature, data):
+    hash_obj = SHA256.new(data.encode())
+    verifier = pkcs1_15.new(public_key)
+    try:
+        verifier.verify(hash_obj, bytes.fromhex(signature))
+        return True
+    except (ValueError, TypeError):
+        return False
+        
+st.title("رمزگذاری و رمزگشایی متن")
+menu = ["رمزگذاری", "رمزگشایی", "هش کردن", "امضای دیجیتال", "تولید کد QR", "تولید کلید"]
+choice = st.sidebar.selectbox("انتخاب عملیات", menu)
+
+if choice == "تولید کلید":
+    st.subheader("تولید کلید")
+    algo = st.selectbox("انتخاب الگوریتم", ["AES", "DES", "Blowfish", "رمزنگاری هیل", "ویژینر", "اسکیتال", "پلایفیر"])
+    
+    if algo in ["AES", "Blowfish"]:
+        key_length = st.number_input("طول کلید (AES: 16، 24، یا 32 بایت | Blowfish: بین 4 تا 56 بایت)", min_value=4, max_value=56, step=1, value=16)
+    elif algo == "رمزنگاری هیل":
+        key_length = st.number_input("اندازه ماتریس کلید (به عنوان مثال: 3 برای ماتریس 3x3)", min_value=2, max_value=10, step=1)
+    elif algo in ["ویژینر", "پلایفیر"]:
+        key_length = st.number_input("طول کلید", min_value=1, max_value=32, step=1)
+    elif algo == "اسکیتال":
+        key_length = st.number_input("کلید رمزگذاری (تعداد ردیف‌ها)", min_value=1, max_value=100, step=1)
+    else:
+        key_length = None
+
+    if key_length is not None and st.button("تولید کلید"):
+        key = generate_key(algo, key_length)
+        st.text("کلید تولید شده:")
+        st.text(key if isinstance(key, str) else key.hex() if isinstance(key, bytes) else key)
+
+elif choice == "رمزگذاری":
+    st.subheader("رمزگذاری")
+    algo = st.selectbox("انتخاب الگوریتم", ["AES", "DES", "Blowfish", "رمزنگاری هیل", "ویژینر", "اسکیتال", "پلایفیر"])
+    text_to_encrypt = st.text_area("متن مورد نظر برای رمزگذاری", "")
+    if algo == "AES":
+        key = st.text_input("کلید رمزگذاری (باید 16، 24، یا 32 بایت باشد)", max_chars=32).encode()
+        if st.button("رمزگذاری"):
+            if len(key) in [16, 24, 32]:
+                encrypted_text = encrypt_aes(text_to_encrypt, key)
+                st.text_area("متن رمزگذاری شده:", encrypted_text)
+            else:
+                st.error("طول کلید باید 16، 24 یا 32 بایت باشد.")
+
+    elif algo == "DES":
+        key = st.text_input("کلید رمزگذاری (باید 8 بایت باشد)", max_chars=8).encode()
+        if st.button("رمزگذاری"):
+            if len(key) == 8:
+                encrypted_text = encrypt_des(text_to_encrypt, key)
+                st.text_area("متن رمزگذاری شده:", encrypted_text)
+            else:
+                st.error("طول کلید باید 8 بایت باشد.")
+    elif algo == "Blowfish":
+        key = st.text_input("کلید رمزگذاری (بین 4 تا 56 بایت باشد)", max_chars=56).encode()
+        if st.button("رمزگذاری"):
+            if 4 <= len(key) <= 56:
+                encrypted_text = encrypt_blowfish(text_to_encrypt, key)
+                st.text_area("متن رمزگذاری شده:", encrypted_text)
+            else:
+                st.error("طول کلید باید بین 4 تا 56 بایت باشد.")
+    elif algo == "رمزنگاری هیل":
+        key_matrix_str = st.text_area("ماتریس کلید (به عنوان مثال: 3x3)", "6 24 1\n13 16 10\n20 17 15")
+        key_matrix = np.array([list(map(int, row.split())) for row in key_matrix_str.split('\n')])
+        if st.button("رمزگذاری"):
+            encrypted_text = encrypt_hill(text_to_encrypt.upper().replace(" ", ""), key_matrix)
+            st.text_area("متن رمزگذاری شده:", encrypted_text)
+    elif algo == "ویژینر":
+        key = st.text_input("کلید رمزگذاری", max_chars=32)
+        if st.button("رمزگذاری"):
+            encrypted_text = encrypt_vigenere(text_to_encrypt, key)
+            st.text_area("متن رمزگذاری شده:", encrypted_text)
+    elif algo == "اسکیتال":
+        key = st.number_input("کلید رمزگذاری (تعداد ردیف‌ها)", min_value=1, max_value=100, step=1)
+        if st.button("رمزگذاری"):
+            encrypted_text = encrypt_scytale(text_to_encrypt.replace(" ", ""), key)
+            st.text_area("متن رمزگذاری شده:", encrypted_text)
+    elif algo == "پلایفیر":
+        key = st.text_input("کلید رمزگذاری", max_chars=32)
+        if st.button("رمزگذاری"):
+            encrypted_text = encrypt_playfair(text_to_encrypt.replace(" ", ""), key)
+            st.text_area("متن رمزگذاری شده:", encrypted_text)
+
+elif choice == "رمزگشایی":
+    st.subheader("رمزگشایی")
+    algo = st.selectbox("انتخاب الگوریتم", ["AES", "DES", "Blowfish", "رمزنگاری هیل", "ویژینر", "اسکیتال", "پلایفیر"])
+    text_to_decrypt = st.text_area("متن مورد نظر برای رمزگشایی", "")
+    if algo == "AES":
+        key = st.text_input("کلید رمزگشایی (باید 16، 24، یا 32 بایت باشد)", max_chars=32).encode()
+        if st.button("رمزگشایی"):
+            if len(key) in [16, 24, 32]:
+                try:
+                    decrypted_text = decrypt_aes(text_to_decrypt, key)
+                    st.text_area("متن رمزگشایی شده:", decrypted_text)
+                except Exception as e:
+                    st.error(f"خطا در رمزگشایی: {e}")
+            else:
+                st.error("طول کلید باید 16، 24 یا 32 بایت باشد.")
+    elif algo == "DES":
+        key = st.text_input("کلید رمزگشایی (باید 8 بایت باشد)", max_chars=8).encode()
+        if st.button("رمزگشایی"):
+            if len(key) == 8:
+                try:
+                    decrypted_text = decrypt_des(text_to_decrypt, key)
+                    st.text_area("متن رمزگشایی شده:", decrypted_text)
+                except Exception as e:
+                    st.error(f"خطا در رمزگشایی: {e}")
+            else:
+                st.error("طول کلید باید 8 بایت باشد.")
+    elif algo == "Blowfish":
+        key = st.text_input("کلید رمزگشایی (بین 4 تا 56 بایت باشد)", max_chars=56).encode()
+        if st.button("رمزگشایی"):
+            if 4 <= len(key) <= 56:
+                try:
+                    decrypted_text = decrypt_blowfish(text_to_decrypt, key)
+                    st.text_area("متن رمزگشایی شده:", decrypted_text)
+                except Exception as e:
+                    st.error(f"خطا در رمزگشایی: {e}")
+            else:
+                st.error("طول کلید باید بین 4 تا 56 بایت باشد.")
+    elif algo == "رمزنگاری هیل":
+        key_matrix_str = st.text_area("ماتریس کلید (به عنوان مثال: 3x3)", "6 24 1\n13 16 10\n20 17 15")
+        key_matrix = np.array([list(map(int, row.split())) for row in key_matrix_str.split('\n')])
+        if st.button("رمزگشایی"):
+            try:
+                decrypted_text = decrypt_hill(text_to_decrypt.upper().replace(" ", ""), key_matrix)
+                st.text_area("متن رمزگشایی شده:", decrypted_text)
+            except Exception as e:
+                st.error(f"خطا در رمزگشایی: {e}")
+    elif algo == "ویژینر":
+        key = st.text_input("کلید رمزگشایی", max_chars=32)
+        if st.button("رمزگشایی"):
+            try:
+                decrypted_text = decrypt_vigenere(text_to_decrypt, key)
+                st.text_area("متن رمزگشایی شده:", decrypted_text)
+            except Exception as e:
+                st.error(f"خطا در رمزگشایی: {e}")
+    elif algo == "اسکیتال":
+        key = st.number_input("کلید رمزگشایی (تعداد ردیف‌ها)", min_value=1, max_value=100, step=1)
+        if st.button("رمزگشایی"):
+            try:
+                decrypted_text = decrypt_scytale(text_to_decrypt.replace(" ", ""), key)
+                st.text_area("متن رمزگشایی شده:", decrypted_text)
+            except Exception as e:
+                st.error(f"خطا در رمزگشایی: {e}")
+    elif algo == "پلایفیر":
+        key = st.text_input("کلید رمزگشایی", max_chars=32)
+        if st.button("رمزگشایی"):
+            try:
+                decrypted_text = decrypt_playfair(text_to_decrypt.replace(" ", ""), key)
+                st.text_area("متن رمزگشایی شده:", decrypted_text)
+            except Exception as e:
+                st.error(f"خطا در رمزگشایی: {e}")
+
+elif choice == "هش کردن":
+    st.subheader("هش کردن")
+    algo = st.selectbox("انتخاب الگوریتم", ["MD5", "SHA-256", "SHA-512"])
+    text_to_hash = st.text_area("متن مورد نظر برای هش کردن", "")
+    if st.button("هش کردن"):
+        if algo == "MD5":
+            hashed_text = hash_md5(text_to_hash)
+        elif algo == "SHA-256":
+            hashed_text = hash_sha256(text_to_hash)
+        elif algo == "SHA-512":
+            hashed_text = hash_sha512(text_to_hash)
+        st.text_area("متن هش شده:", hashed_text)
+
+elif choice == "امضای دیجیتال":
+    st.subheader("امضای دیجیتال")
+    algo = st.selectbox("انتخاب الگوریتم", ["ECC", "DSA", "RSA"])
+    text_to_sign = st.text_area("متن مورد نظر برای امضا", "")
+    if algo == "ECC":
+        private_key, public_key = generate_ecc_keys()
+        if st.button("امضا کردن"):
+            signature = sign_ecc(private_key, text_to_sign)
+            st.text_area("امضای دیجیتال:", signature)
+        if st.button("تأیید امضا"):
+            signature_to_verify = st.text_input("امضای دیجیتال برای تأیید", "")
+            is_verified = verify_ecc(public_key, signature_to_verify, text_to_sign)
+            st.text(f"نتیجه تأیید: {'موفقیت آمیز' if is_verified else 'ناموفق'}")
+    elif algo == "DSA":
+        private_key, public_key = generate_dsa_keys()
+        if st.button("امضا کردن"):
+            signature = sign_dsa(private_key, text_to_sign)
+            st.text_area("امضای دیجیتال:", signature)
+        if st.button("تأیید امضا"):
+            signature_to_verify = st.text_input("امضای دیجیتال برای تأیید", "")
+            is_verified = verify_dsa(public_key, signature_to_verify, text_to_sign)
+            st.text(f"نتیجه تأیید: {'موفقیت آمیز' if is_verified else 'ناموفق'}")
+    elif algo == "RSA":
+        private_key, public_key = generate_rsa_keys()
+        if st.button("امضا کردن"):
+            signature = sign_rsa(private_key, text_to_sign)
+            st.text_area("امضای دیجیتال:", signature)
+        if st.button("تأیید"):
+            signature_to_verify = st.text_input("امضای دیجیتال برای تأیید", "")
+            is_verified = verify_rsa(public_key, signature_to_verify, text_to_sign)
+            st.text(f"نتیجه تأیید: {'موفقیت آمیز' if is_verified else 'ناموفق'}")
+
+elif choice == "تولید کد QR":
+    st.subheader("تولید کد QR با حق کپی‌رایت")
+    data_to_encode = st.text_area("متن مورد نظر برای تبدیل به کد QR", "")
+    copyright_text = st.text_input("متن حق کپی‌رایت (مثال: © 2023 طاها تهرانی نسب)", "© 2023 طاها تهرانی نسب")
+    if st.button("تولید کد QR"):
+        img = generate_qr_code_with_copyright(data_to_encode, copyright_text)
+        buffered = BytesIO()
+        img.save(buffered, format="PNG")
+        img_str = base64.b64encode(buffered.getvalue()).decode()
+        st.image(img, caption='QR Code', use_column_width=True)
+        st.markdown(f"![QR Code](data:image/png;base64,{img_str})")
+
+def hash_md5(data):
+    return hashlib.md5(data.encode()).hexdigest()
+
+def hash_sha256(data):
+    return hashlib.sha256(data.encode()).hexdigest()
+
+def hash_sha512(data):
+    return hashlib.sha512(data.encode()).hexdigest()
+
+def encrypt_aes(data, key):
+    cipher = AES.new(key, AES.MODE_CBC)
+    ct_bytes = cipher.encrypt(pad(data.encode(), AES.block_size))
+    iv = base64.b64encode(cipher.iv).decode('utf-8')
+    ct = base64.b64encode(ct_bytes).decode('utf-8')
+    return iv + ct
+
+def decrypt_aes(data, key):
+    iv = base64.b64decode(data[:24])
+    ct = base64.b64decode(data[24:])
+    cipher = AES.new(key, AES.MODE_CBC, iv=iv)
+    pt = unpad(cipher.decrypt(ct), AES.block_size)
+    return pt.decode('utf-8')
+
+def encrypt_des(data, key):
+    cipher = DES.new(key, DES.MODE_CBC)
+    ct_bytes = cipher.encrypt(pad(data.encode(), DES.block_size))
+    iv = base64.b64encode(cipher.iv).decode('utf-8')
+    ct = base64.b64encode(ct_bytes).decode('utf-8')
+    return iv + ct
+
+def decrypt_des(data, key):
+    iv = base64.b64decode(data[:12])
+    ct = base64.b64decode(data[12:])
+    cipher = DES.new(key, DES.MODE_CBC, iv=iv)
+    pt = unpad(cipher.decrypt(ct), DES.block_size)
+    return pt.decode('utf-8')
+
+def encrypt_blowfish(data, key):
+    cipher = Blowfish.new(key, Blowfish.MODE_CBC)
+    ct_bytes = cipher.encrypt(pad(data.encode(), Blowfish.block_size))
+    iv = base64.b64encode(cipher.iv).decode('utf-8')
+    ct = base64.b64encode(ct_bytes).decode('utf-8')
+    return iv + ct
+
+def decrypt_blowfish(data, key):
+    iv = base64.b64decode(data[:12])
+    ct = base64.b64decode(data[12:])
+    cipher = Blowfish.new(key, Blowfish.MODE_CBC, iv=iv)
+    pt = unpad(cipher.decrypt(ct), Blowfish.block_size)
+    return pt.decode('utf-8')
+
+def encrypt_hill(data, key_matrix):
+    data_vector = np.array([ord(char) - 65 for char in data])
+    data_vector = data_vector.reshape(-1, key_matrix.shape[0])
+    encrypted_vector = np.dot(data_vector, key_matrix) % 26
+    encrypted_text = ''.join(chr(int(num) + 65) for num in encrypted_vector.flatten())
+    return encrypted_text
+
+def decrypt_hill(data, key_matrix):
+    encrypted_vector = np.array([ord(char) - 65 for char in data])
+    encrypted_vector = encrypted_vector.reshape(-1, key_matrix.shape[0])
+    key_matrix_inv = Matrix(key_matrix).inv_mod(26)
+    decrypted_vector = np.dot(encrypted_vector, np.array(key_matrix_inv).astype(float)) % 26
+    decrypted_text = ''.join(chr(int(round(num)) + 65) for num in decrypted_vector.flatten())
+    return decrypted_text
+
+def encrypt_vigenere(data, key):
+    key = (key * (len(data) // len(key)) + key[:len(data) % len(key)]).upper()
+    encrypted_text = ''.join(chr(((ord(a) + ord(b)) % 26) + 65) for a, b in zip(data.upper(), key))
+    return encrypted_text
+
+def decrypt_vigenere(data, key):
+    key = (key * (len(data) // len(key)) + key[:len(data) % len(key)]).upper()
+    decrypted_text = ''.join(chr(((ord(a) - ord(b) + 26) % 26) + 65) for a, b in zip(data.upper(), key))
+    return decrypted_text
+
+def encrypt_scytale(data, key):
+    columns = [''] * key
+    for i, char in enumerate(data):
+        columns[i % key] += char
+    encrypted_text = ''.join(columns)
+    return encrypted_text
+
+def decrypt_scytale(data, key):
+    rows, remainder = divmod(len(data), key)
+    columns = [''] * key
+    start = 0
+    for i in range(key):
+        end = start + rows + (1 if i < remainder else 0)
+        columns[i] = data[start:end]
+        start = end
+    decrypted_text = ''.join(''.join(pair) for pair in zip(*columns))
+    return decrypted_text
+
+def encrypt_playfair(data, key):
+    def generate_key_square(key):
+        alphabet = "ABCDEFGHIKLMNOPQRSTUVWXYZ"
+        key_square = ""
+        for char in key.upper():
+            if char not in key_square and char in alphabet:
+                key_square += char
+        for char in alphabet:
+            if char not in key_square:
+                key_square += char
+        return key_square
+    
+    def chunk_text(data):
+        data = data.upper().replace('J', 'I')
+        chunks = []
+        i = 0
+        while i < len(data):
+            a = data[i]
+            b = data[i + 1] if i + 1 < len(data) else 'X'
+            if a == b:
+                chunks.append(a + 'X')
+                i += 1
+            else:
+                chunks.append(a + b)
+                i += 2
+        return chunks
+
+    def find_position(key_square, char):
+        index = key_square.index(char)
+        return divmod(index, 5)
+    
+    key_square = generate_key_square(key)
+    chunks = chunk_text(data)
+    encrypted_text = ""
+    for a, b in chunks:
+        row1, col1 = find_position(key_square, a)
+        row2, col2 = find_position(key_square, b)
+        if row1 == row2:
+            encrypted_text += key_square[row1 * 5 + (col1 + 1) % 5]
+            encrypted_text += key_square[row2 * 5 + (col2 + 1) % 5]
+        elif col1 == col2:
+            encrypted_text += key_square[((row1 + 1) % 5) * 5 + col1]
+            encrypted_text += key_square[((row2 + 1) % 5) * 5 + col2]
+        else:
+            encrypted_text += key_square[row1 * 5 + col2]
+            encrypted_text += key_square[row2 * 5 + col1]
+    return encrypted_text
+
+def decrypt_playfair(data, key):
+    def generate_key_square(key):
+        alphabet = "ABCDEFGHIKLMNOPQRSTUVWXYZ"
+        key_square = ""
+        for char in key.upper():
+            if char not in key_square and char in alphabet:
+                key_square += char
+        for char in alphabet:
+            if char not in key_square:
+                key_square += char
+        return key_square
+    
+    def chunk_text(data):
+        return [data[i:i + 2] for i in range(0, len(data), 2)]
+
+    def find_position(key_square, char):
+        index = key_square.index(char)
+        return divmod(index, 5)
+    
+    key_square = generate_key_square(key)
+    chunks = chunk_text(data)
+    decrypted_text = ""
+    for a, b in chunks:
+        row1, col1 = find_position(key_square, a)
+        row2, col2 = find_position(key_square, b)
+        if row1 == row2:
+            decrypted_text += key_square[row1 * 5 + (col1 - 1) % 5]
+            decrypted_text += key_square[row2 * 5 + (col2 - 1) % 5]
+        elif col1 == col2:
+            decrypted_text += key_square[((row1 - 1) % 5) * 5 + col1]
+            decrypted_text += key_square[((row2 - 1) % 5) * 5 + col2]
+        else:
+            decrypted_text += key_square[row1 * 5 + col2]
+            decrypted_text += key_square[row2 * 5 + col1]
+    return decrypted_text
+
+def generate_ecc_keys():
+    private_key = SigningKey.generate(curve=SECP256k1)
+    public_key = private_key.verifying_key
+    return private_key, public_key
+
+def sign_ecc(private_key, data):
+    signature = private_key.sign(data.encode())
+    return base64.b64encode(signature).decode()
+
+def verify_ecc(public_key, signature, data):
+    try:
+        signature = base64.b64decode(signature)
+        return public_key.verify(signature, data.encode())
+    except BadSignatureError:
+        return False
+
+def generate_dsa_keys():
+    key = DSA.generate(1024)
+    private_key = key
+    public_key = key.publickey()
+    return private_key, public_key
+
+def sign_dsa(private_key, data):
+    hasher = SHA256.new(data.encode())
+    signer = DSS.new(private_key, 'fips-186-3')
+    signature = signer.sign(hasher)
+    return base64.b64encode(signature).decode()
+
+def verify_dsa(public_key, signature, data):
+    try:
+        hasher = SHA256.new(data.encode())
+        verifier = DSS.new(public_key, 'fips-186-3')
+        signature = base64.b64decode(signature)
+        verifier.verify(hasher, signature)
+        return True
+    except (ValueError, TypeError):
+        return False
+
+def generate_rsa_keys():
+    key = RSA.generate(2048)
+    private_key = key
+    public_key = key.publickey()
+    return private_key, public_key
+
+def sign_rsa(private_key, data):
+    hasher = SHA256.new(data.encode())
+    signer = pkcs1_15.new(private_key)
+    signature = signer.sign(hasher)
+    return base64.b64encode(signature).decode()
+
+def verify_rsa(public_key, signature, data):
+    try:
+        hasher = SHA256.new(data.encode())
+        verifier = pkcs1_15.new(public_key)
+        signature = base64.b64decode(signature)
+        verifier.verify(hasher, signature)
+        return True
+    except (ValueError, TypeError):
+        return False
+
+if __name__ == '__main__': 
+    st.write("© 2023 طاها تهرانی نسب")
+    #main()