app.py

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(plaintext, key_matrix):
    plaintext_vector = [ord(char) - ord('A') for char in plaintext]
    key_matrix = Matrix(key_matrix)
    plaintext_matrix = Matrix(plaintext_vector)
    ciphertext_matrix = key_matrix * plaintext_matrix % 26
    ciphertext = ''.join(chr(int(num) + ord('A')) for num in ciphertext_matrix)
    return ciphertext

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(plaintext, key):
    key_length = len(key)
    key_as_int = [ord(i) for i in key]
    plaintext_int = [ord(i) for i in plaintext]
    ciphertext = ''
    for i in range(len(plaintext_int)):
        value = (plaintext_int[i] + key_as_int[i % key_length]) % 26
        ciphertext += chr(value + 65)
    return ciphertext

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()