CryptexLab CTF密码学工具

import tkinter as tk
from tkinter import scrolledtext
import math

import re
import base64
import base58
import base91

from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.backends import default_backend
from Crypto.Util.number import long_to_bytes
from collections import Counter, defaultdict
import string
import hashlib


# ------------------ 攻击/辅助函数 ------------------
def fermat_factor(n, max_iter=1000000):
    a = math.isqrt(n)
    if a * a < n:
        a += 1
    for _ in range(max_iter):
        b2 = a*a - n
        b = math.isqrt(b2)
        if b*b == b2:
            return a - b, a + b
        a += 1
    return None


def pollard_p1(n, B=1000000):
    a = 2
    for j in range(2, B):
        a = pow(a, j, n)
    g = math.gcd(a-1, n)
    if 1 < g < n:
        return g, n // g
    return None


def continued_fraction(numerator, denominator):
    cf = []
    while denominator:
        a = numerator // denominator
        cf.append(a)
        numerator, denominator = denominator, numerator - a * denominator
    return cf


def convergents_from_cf(cf):
    n0, d0 = cf[0], 1
    yield (n0, 1)
    if len(cf) == 1:
        return
    n1 = cf[1] * cf[0] + 1
    d1 = cf[1]
    yield (n1, d1)
    for i in range(2, len(cf)):
        ni = cf[i] * n1 + n0
        di = cf[i] * d1 + d0
        yield (ni, di)
        n0, d0, n1, d1 = n1, d1, ni, di


def is_perfect_square(x):
    if x < 0:
        return False
    s = math.isqrt(x)
    return s * s == x


def wiener_attack(e, n):
    cf = continued_fraction(e, n)
    for k, d in convergents_from_cf(cf):
        if k == 0:
            continue
        if (e * d - 1) % k != 0:
            continue
        phi = (e * d - 1) // k
        s = n - phi + 1
        discr = s*s - 4*n
        if discr >= 0 and is_perfect_square(discr):
            t = math.isqrt(discr)
            p = (s + t) // 2
            q = (s - t) // 2
            if p * q == n:
                return d
    return None

# ------------------ 初始化窗口 ------------------
root = tk.Tk()
root.title("CryptexLab")
root.geometry("800x800")
font_title = ('微软雅黑', 12, 'bold')
font_text = ('微软雅黑', 10)

# ------------------ 菜单栏 ------------------
menubar = tk.Menu(root)
root.config(menu=menubar)

# 每加一个新的页面都记得在这里更新
def show_frame(frame):
    for f in (encode_frame, decode_frame, RailFence_frame, Caesar_frame,Vigenere_frame, rsa_generate_pem_frame, rsa_pem_frame, rsa_crack_frame, sha256_frame, md5_frame):
        f.pack_forget()
    frame.pack(fill=tk.BOTH, expand=True)

# ------------------ 编码界面 ------------------
def encode_input():
    raw = encode_input_text.get('1.0', tk.END).strip()
    encode_output_text.delete('1.0', tk.END)
    if not raw:
        return
    
    # 获取选中的编码方式
    selected_encoding = encode_var.get()
    
    try:
        if selected_encoding == 'Base64':
            result = base64.b64encode(raw.encode()).decode()
        elif selected_encoding == 'Base32':
            result = base64.b32encode(raw.encode()).decode()
        elif selected_encoding == 'Base58':
            result = base58.b58encode(raw.encode()).decode()
        elif selected_encoding == 'Base91':
            result = base91.encode(raw.encode())
        elif selected_encoding == 'Binary':
            result = ''.join(format(ord(c), '08b') for c in raw)
        elif selected_encoding == 'Hex':
            result = raw.encode().hex()
        else:
            result = "请选择编码方式"
        
        encode_output_text.insert(tk.END, result)
    except Exception as e:
        encode_output_text.insert(tk.END, f"编码失败: {e}")

encode_frame = tk.Frame(root)
# 布局
tk.Label(encode_frame, text='请输入要编码的内容：', font=font_title).pack(pady=(10, 0))
encode_input_text = scrolledtext.ScrolledText(encode_frame, height=6, font=font_text, wrap=tk.WORD)
encode_input_text.pack(fill=tk.BOTH, padx=20, pady=5, expand=True)

# 编码选项
encode_options_frame = tk.Frame(encode_frame)
tk.Label(encode_options_frame, text='选择编码方式：', font=font_text).pack(side=tk.LEFT, padx=(0, 10))
encode_var = tk.StringVar(value='Base64')
encode_radio_frame = tk.Frame(encode_options_frame)
encode_options = ['Base64', 'Base32', 'Base58', 'Base91', 'Binary', 'Hex']
for option in encode_options:
    tk.Radiobutton(encode_radio_frame, text=option, variable=encode_var, value=option, font=font_text).pack(side=tk.LEFT, padx=5)
encode_radio_frame.pack(side=tk.LEFT)
encode_options_frame.pack(pady=10)

tk.Button(encode_frame, text='开始编码', font=font_title, bg='#4CAF50', fg='white', command=encode_input).pack(pady=10)
tk.Label(encode_frame, text='编码结果：', font=font_title).pack()
encode_output_text = scrolledtext.ScrolledText(encode_frame, height=10, font=font_text, wrap=tk.WORD)
encode_output_text.pack(fill=tk.BOTH, padx=20, pady=5, expand=True)

# ------------------ 解码界面 ------------------
def is_binary(s):
    return all(c in '01' for c in s) and len(s) % 8 == 0

def decode_bytes(byte_data):
    try:
        text = byte_data.decode('utf-8')
        return text, True
    except UnicodeDecodeError:
        return byte_data.hex(), False

def looks_like_base64(s):
    return len(s) % 4 == 0 and re.fullmatch(r'[A-Za-z0-9+/=]+', s) is not None

def looks_like_base32(s):
    return len(s) % 8 == 0 and re.fullmatch(r'[A-Z2-7=]+', s, re.IGNORECASE) is not None

def looks_like_base58(s):
    return all(c in base58.alphabet.decode() for c in s)

def looks_like_base91(s):
    return all(33 <= ord(c) <= 126 for c in s)

def try_decode(s, func):
    decoded = func(s)
    return decode_bytes(decoded)

def recursive_decode(s, path=None, all_paths=None, max_depth=10):
    if path is None:
        path = []
    if all_paths is None:
        all_paths = []
    if len(path) >= max_depth:
        return all_paths

    decoders = [
        ('Base64', looks_like_base64, base64.b64decode),
        ('Base32', looks_like_base32, base64.b32decode),
        ('Base58', looks_like_base58, base58.b58decode),
        ('Base91', looks_like_base91, base91.decode),
        ('Binary', is_binary, lambda x: bytes(int(x[i:i + 8], 2) for i in range(0, len(x), 8))),
        ('Hex', lambda x: True, lambda x: bytes.fromhex(x)),
    ]

    for name, detector, func in decoders:
        if detector(s):
            try:
                text, is_utf8 = try_decode(s, func)
            except Exception:
                continue
            mode = '(UTF-8)' if is_utf8 else '(hex)'
            new_path = path + [(name, text, mode)]
            all_paths.append(new_path)
            if is_utf8:
                recursive_decode(text, new_path, all_paths, max_depth)
    return all_paths

def select_final_path(paths):
    utf_paths = [p for p in paths if p[-1][2] == '(UTF-8)']
    if utf_paths:
        max_len = max(len(p) for p in utf_paths)
        for p in utf_paths:
            if len(p) == max_len:
                return p
    max_len = max(len(p) for p in paths)
    for p in paths:
        if len(p) == max_len:
            return p

def decode_input():
    raw = input_text.get('1.0', tk.END).strip().replace(' ', '')
    decode_output_text.delete('1.0', tk.END)
    if not raw:
        return

    paths = recursive_decode(raw)
    if not paths:
        decode_output_text.insert(tk.END, '无法识别或解码此内容。')
        return

    final = select_final_path(paths)
    for i, (name, text, mode) in enumerate(final, 1):
        decode_output_text.insert(tk.END, f"第{i}步 - {name} {mode}\n结果：{text}\n\n")

    if len(final) == 1 and final[0][2] == '(UTF-8)':
        s = final[0][1]
        extra_decoders = [
            ('Base64', looks_like_base64, base64.b64decode),
            ('Base32', looks_like_base32, base64.b32decode),
            ('Base58', looks_like_base58, base58.b58decode),
            ('Base91', looks_like_base91, base91.decode),
            ('Binary', is_binary, lambda x: bytes(int(x[i:i + 8], 2) for i in range(0, len(x), 8)))
        ]
        for name, detector, func in extra_decoders:
            if detector(s):
                try:
                    data = func(s)
                    hex_out = data.hex()
                    decode_output_text.insert(tk.END, f"第2步 - {name} (hex)\n结果：{hex_out}\n")
                    break
                except Exception:
                    continue

# 布局
decode_frame = tk.Frame(root)
tk.Label(decode_frame, text='请输入编码内容：', font=font_title).pack(pady=(10, 0))
input_text = scrolledtext.ScrolledText(decode_frame, height=6, font=font_text, wrap=tk.WORD)
input_text.pack(fill=tk.BOTH, padx=20, pady=5, expand=True)
tk.Button(decode_frame, text='开始解码', font=font_title, bg='#4CAF50', fg='white', command=decode_input).pack(pady=10)
tk.Label(decode_frame, text='输出结果：', font=font_title).pack()
decode_output_text = scrolledtext.ScrolledText(decode_frame, height=10, font=font_text, wrap=tk.WORD)
decode_output_text.pack(fill=tk.BOTH, padx=20, pady=5, expand=True)


# ------------------ 凯撒解密界面 ------------------
def caesar_decrypt(text, shift):
    result = ''
    for ch in text:
        if 'A' <= ch <= 'Z':
            result += chr((ord(ch)-ord('A')-shift)%26+ord('A'))
        elif 'a' <= ch <= 'z':
            result += chr((ord(ch)-ord('a')-shift)%26+ord('a'))
        else:
            result += ch
    return result

def decrypt_caesar():
    text = caesar_input.get('1.0', tk.END).strip()
    caesar_output_text.delete('1.0', tk.END)
    keyword = keyword_entry.get().strip()
    if var_traverse.get():
        for k in range(26):
            dec = caesar_decrypt(text, k)
            if not keyword or keyword.lower() in dec.lower():
                caesar_output_text.insert(tk.END, f"Key={k}:\n{dec}\n\n")
    else:
        try:
            k = int(key_entry.get())
            dec = caesar_decrypt(text, k)
            caesar_output_text.insert(tk.END, dec)
        except ValueError:
            caesar_output_text.insert(tk.END, "密钥应为整数。")

Caesar_frame = tk.Frame(root)
# 布局
tk.Label(Caesar_frame, text='凯撒密文输入：', font=font_title).pack(pady=(10,0))
caesar_input = scrolledtext.ScrolledText(Caesar_frame, height=5, font=font_text)
caesar_input.pack(fill=tk.BOTH, padx=20, pady=5, expand=True)
key_row = tk.Frame(Caesar_frame)
tk.Label(key_row, text='密钥 (0-25):', font=font_text).pack(side=tk.LEFT)
key_entry = tk.Entry(key_row, width=5)
key_entry.pack(side=tk.LEFT, padx=(5,15))
tk.Label(key_row, text='关键词 (可选):', font=font_text).pack(side=tk.LEFT)
keyword_entry = tk.Entry(key_row, width=20)
keyword_entry.pack(side=tk.LEFT, padx=5)
key_row.pack(pady=10)
var_traverse = tk.BooleanVar(value=True)
tk.Checkbutton(Caesar_frame, text='遍历所有可能', variable=var_traverse).pack()
tk.Button(Caesar_frame, text='开始解密', font=font_title, bg='#2196F3', fg='white', command=decrypt_caesar).pack(pady=10, fill='x', padx=20)
tk.Label(Caesar_frame, text='输出结果：', font=font_title).pack()
caesar_output_text = scrolledtext.ScrolledText(Caesar_frame, height=10, font=font_text)
caesar_output_text.pack(fill=tk.BOTH, padx=20, pady=5, expand=True)


# ------------------ 栅栏密码界面 ------------------

def rail_fence_encrypt(text, rails):
    if rails <= 1 or not text:
        return text
    rows = [''] * rails
    r, step = 0, 1
    for ch in text:
        rows[r] += ch
        if r == 0: step = 1
        elif r == rails - 1: step = -1
        r += step
    return ''.join(rows)

def rail_fence_decrypt(cipher, rails):
    if rails <= 1 or not cipher:
        return cipher
    n = len(cipher)
    # 先跑一遍得到每个位置所在“栏”的序列
    pattern = []
    r, step = 0, 1
    for _ in range(n):
        pattern.append(r)
        if r == 0: step = 1
        elif r == rails - 1: step = -1
        r += step
    # 统计每一栏有多少字符
    counts = [pattern.count(i) for i in range(rails)]
    # 按栏把密文切片回填
    idx = 0
    rows = []
    for c in counts:
        rows.append(list(cipher[idx: idx + c]))
        idx += c
    # 再按 pattern 顺序重建明文
    pos_in_row = [0] * rails
    res = []
    for row_id in pattern:
        res.append(rows[row_id][pos_in_row[row_id]])
        pos_in_row[row_id] += 1
    return ''.join(res)

def rf_do(op):
    rf_output_text.delete('1.0', tk.END)
    text = rf_input.get('1.0', tk.END).strip()
    rails_str = rf_key_entry.get().strip()
    if not text:
        rf_output_text.insert(tk.END, "请输入文本。")
        return
    try:
        rails = int(rails_str)
        if rails < 2:
            raise ValueError
    except ValueError:
        rf_output_text.insert(tk.END, "栏数应为整数且 ≥ 2。")
        return

    if op == 'enc':
        out = rail_fence_encrypt(text, rails)
    else:
        out = rail_fence_decrypt(text, rails)
    rf_output_text.insert(tk.END, out)

RailFence_frame = tk.Frame(root)
# 布局
tk.Label(RailFence_frame, text='栅栏密码 - 输入：', font=font_title).pack(pady=(10,0))
rf_input = scrolledtext.ScrolledText(RailFence_frame, height=6, font=font_text, wrap=tk.WORD)
rf_input.pack(fill=tk.BOTH, padx=20, pady=5, expand=True)

rf_mid = tk.Frame(RailFence_frame)
tk.Label(rf_mid, text='密钥：', font=font_text).pack(side=tk.LEFT)
rf_key_entry = tk.Entry(rf_mid, width=10)
rf_key_entry.insert(0, '3')  # 默认 3 栏
rf_key_entry.pack(side=tk.LEFT, padx=(5,15))

op_var = tk.StringVar(value='enc')
# tk.Label(rf_mid, text='操作：', font=font_text).pack(side=tk.LEFT, padx=(10,0))
tk.Radiobutton(rf_mid, text='加密', variable=op_var, value='enc').pack(side=tk.LEFT)
tk.Radiobutton(rf_mid, text='解密', variable=op_var, value='dec').pack(side=tk.LEFT)
rf_mid.pack(pady=8)

btn_row = tk.Frame(RailFence_frame)
tk.Button(btn_row, text='加解密', font=font_title, bg='#4CAF50', fg='white',
          command=lambda: rf_do(op_var.get())).pack(side=tk.LEFT, padx=8)
btn_row.pack(pady=6)

tk.Label(RailFence_frame, text='输出结果：', font=font_title).pack()
rf_output_text = scrolledtext.ScrolledText(RailFence_frame, height=10, font=font_text, wrap=tk.WORD)
rf_output_text.pack(fill=tk.BOTH, padx=20, pady=5, expand=True)

# ------------------ 维吉尼亚解密界面 ------------------

# 词频分析

# 英文字母频率（归一化）
ENG_FREQ_RAW = {
    'A': 8.167, 'B': 1.492, 'C': 2.782, 'D': 4.253, 'E':12.702,
    'F': 2.228, 'G': 2.015, 'H': 6.094, 'I': 6.966, 'J': 0.153,
    'K': 0.772, 'L': 4.025, 'M': 2.406, 'N': 6.749, 'O': 7.507,
    'P': 1.929, 'Q': 0.095, 'R': 5.987, 'S': 6.327, 'T': 9.056,
    'U': 2.758, 'V': 0.978, 'W': 2.360, 'X': 0.150, 'Y': 1.974,
    'Z': 0.074,
}
ENG_FREQ = {k: v / sum(ENG_FREQ_RAW.values()) for k, v in ENG_FREQ_RAW.items()}
ALPHABET = string.ascii_uppercase

# 工具函数
def index_of_coincidence(text):
    N = len(text)
    if N < 2: return 0.0
    freq = Counter(text)
    return sum(n * (n - 1) for n in freq.values()) / (N * (N - 1))

def avg_ic_for_len(cipher, k):
    return sum(index_of_coincidence(cipher[i::k]) for i in range(k)) / k

def chi_square_list(col):
    N = len(col)
    observed = Counter(col)
    result = []
    for shift in range(26):
        chi = 0.0
        for i, c in enumerate(ALPHABET):
            expected = ENG_FREQ[c] * N
            shifted = ALPHABET[(i + shift) % 26]
            observed_count = observed.get(shifted, 0)
            chi += ((observed_count - expected) ** 2) / expected
        result.append(chi)
    return result

def kasiski_candidates(cipher, n_min=3, n_max=6, key_lo=10, key_hi=50, top_n=8):
    positions = defaultdict(list)
    for n in range(n_min, n_max + 1):
        for i in range(len(cipher) - n + 1):
            gram = cipher[i:i+n]
            positions[gram].append(i)
    votes = {}
    for locs in positions.values():
        if len(locs) < 2: continue
        for i in range(len(locs)):
            for j in range(i + 1, len(locs)):
                dist = locs[j] - locs[i]
                for k in range(key_lo, key_hi + 1):
                    if dist % k == 0:
                        votes[k] = votes.get(k, 0) + 1
    return sorted(votes, key=votes.get, reverse=True)[:top_n]

def recover_key(cipher, key_lo=10, key_hi=50, kasiski_top=8, ic_top=3):
    cipher = ''.join(filter(str.isalpha, cipher.upper()))
    candidates = kasiski_candidates(cipher, key_lo=key_lo, key_hi=key_hi, top_n=kasiski_top)
    if not candidates:
        candidates = list(range(key_lo, key_hi + 1))
    ic_scores = {k: avg_ic_for_len(cipher, k) for k in candidates}
    top_lengths = sorted(ic_scores, key=ic_scores.get, reverse=True)[:ic_top]

    best_key = None
    best_score = float('inf')
    for k in top_lengths:
        key = []
        total_chi = 0.0
        for i in range(k):
            col = cipher[i::k]
            chis = chi_square_list(col)
            best_shift = chis.index(min(chis))
            key.append(ALPHABET[best_shift])
            total_chi += chis[best_shift]
        if total_chi < best_score:
            best_key = ''.join(key)
            best_score = total_chi
    return best_key, best_score

#普通
def vigenere_decrypt(cipher, key):
    vigenere_result = ''
    klen = len(key)
    j = 0  # 用于密钥索引，只对字母递增
    for c in cipher:
        if c.isalpha():
            k = key[j % klen]
            ki = ord(k.upper()) - ord('A')  # 统一处理大小写密钥
            if c.isupper():
                vigenere_result += chr((ord(c) - ord('A') - ki) % 26 + ord('A'))
            else:
                vigenere_result += chr((ord(c) - ord('a') - ki) % 26 + ord('a'))
            j += 1
        else:
            vigenere_result += c  # 非字母直接加
    return vigenere_result


def decrypt_vigenere():
    text = vigenere_input.get('1.0', tk.END).strip()
    key = vigenere_key_entry.get().strip()
    vigenere_output_text.delete('1.0', tk.END)

    if not text:
        vigenere_output_text.insert(tk.END, "请输入密文。")
        return

    # 如果没有密钥，就使用频率分析恢复
    if not key:
        key, score = recover_key(text)
        vigenere_output_text.insert(tk.END, f"[自动识别密钥]：{key}  (χ²得分={score:.2f})\n\n")

    result = vigenere_decrypt(text, key)
    vigenere_output_text.insert(tk.END, result)


Vigenere_frame = tk.Frame(root)
# 布局
tk.Label(Vigenere_frame, text='维吉尼亚密文输入：', font=font_title).pack(pady=(10,0))
vigenere_input = scrolledtext.ScrolledText(Vigenere_frame, height=5, font=font_text)
vigenere_input.pack(fill=tk.BOTH, padx=20, pady=5, expand=True)
key_row = tk.Frame(Vigenere_frame)
tk.Label(key_row, text='密钥：', font=font_text).pack(side=tk.LEFT)
vigenere_key_entry = tk.Entry(key_row, width=20)
vigenere_key_entry.pack(side=tk.LEFT, padx=5)
key_row.pack(pady=10)
tk.Label(Vigenere_frame, text='（如果没有密钥则默认进行词频分析）', font=font_text, fg='gray').pack()

tk.Button(Vigenere_frame, text='开始解密', font=font_title, bg='#009688', fg='white', command=decrypt_vigenere).pack(pady=10, fill='x', padx=20)
tk.Label(Vigenere_frame, text='输出结果：', font=font_title).pack()
vigenere_output_text = scrolledtext.ScrolledText(Vigenere_frame, height=10, font=font_text)
vigenere_output_text.pack(fill=tk.BOTH, padx=20, pady=5, expand=True)

# ------------------ RSA - 生成PEM界面 ------------------
def generate_pem():
    rsa_generate_pem_output.delete('1.0', tk.END)
    
    def get_int(name):
        txt = rsa_generate_entries[name].get().strip().replace(" ", "")
        return int(txt) if txt else None
    
    p = get_int('p')
    q = get_int('q')
    e = get_int('e')
    
    if None in (p, q, e):
        rsa_generate_pem_output.insert(tk.END, "请填写所有必需参数：p, q, e\n")
        return
    
    try:
        # 计算其他参数
        n = p * q
        phi = (p - 1) * (q - 1)
        d = pow(e, -1, phi)
        
        # 生成私钥
        from cryptography.hazmat.primitives.asymmetric import rsa
        from cryptography.hazmat.primitives import serialization
        
        private_key = rsa.RSAPrivateNumbers(
            p=p, q=q, d=d, dmp1=d % (p-1), dmq1=d % (q-1), iqmp=pow(q, -1, p),
            public_numbers=rsa.RSAPublicNumbers(e=e, n=n)
        ).private_key(backend=default_backend())
        
        # 生成公钥
        public_key = private_key.public_key()
        
        # 输出PEM格式
        private_pem = private_key.private_bytes(
            encoding=serialization.Encoding.PEM,
            format=serialization.PrivateFormat.PKCS8,
            encryption_algorithm=serialization.NoEncryption()
        ).decode()
        
        public_pem = public_key.public_bytes(
            encoding=serialization.Encoding.PEM,
            format=serialization.PublicFormat.SubjectPublicKeyInfo
        ).decode()
        
        rsa_generate_pem_output.insert(tk.END, "=== RSA 私钥 (PEM格式) ===\n\n", "bold")
        rsa_generate_pem_output.insert(tk.END, private_pem)
        rsa_generate_pem_output.insert(tk.END, "\n\n=== RSA 公钥 (PEM格式) ===\n\n", "bold")
        rsa_generate_pem_output.insert(tk.END, public_pem)
        rsa_generate_pem_output.insert(tk.END, "\n\n=== 参数信息 ===\n", "bold")
        rsa_generate_pem_output.insert(tk.END, f"n = {n}\n")
        rsa_generate_pem_output.insert(tk.END, f"e = {e}\n")
        rsa_generate_pem_output.insert(tk.END, f"d = {d}\n")
        rsa_generate_pem_output.insert(tk.END, f"p = {p}\n")
        rsa_generate_pem_output.insert(tk.END, f"q = {q}\n")
        
    except Exception as e:
        rsa_generate_pem_output.insert(tk.END, f"生成失败: {e}\n")

rsa_generate_pem_frame = tk.Frame(root)
# 布局
tk.Label(rsa_generate_pem_frame, text='请输入 RSA 参数（十进制整数）：', font=font_title).pack(pady=(10,5))
rsa_generate_entries = {}
for label in ['p','q','e']:
    row = tk.Frame(rsa_generate_pem_frame)
    tk.Label(row, text=f"{label} =", font=font_text, width=3).pack(side=tk.LEFT)
    entry = tk.Entry(row, font=font_text, width=40)
    entry.pack(side=tk.LEFT, fill=tk.X, expand=True, padx=5)
    rsa_generate_entries[label] = entry
    row.pack(padx=20, pady=3, fill=tk.X)

# 生成按钮
tk.Button(rsa_generate_pem_frame, text='生成PEM', font=font_title, bg='#9C27B0', fg='white', command=generate_pem).pack(pady=10)
tk.Label(rsa_generate_pem_frame, text='生成的PEM：', font=font_title).pack()
rsa_generate_pem_output = scrolledtext.ScrolledText(rsa_generate_pem_frame, height=15, font=font_text)
rsa_generate_pem_output.tag_configure("bold", font=('微软雅黑', 10, 'bold'))
rsa_generate_pem_output.pack(fill=tk.BOTH, padx=20, pady=5, expand=True)

# ------------------ RSA - PEM解析界面 ------------------
def parse_pem():
    global parsed_pem_values  # 添加全局变量存储
    parsed_pem_values = {}  # 初始化字典
    rsa_pem_output.delete('1.0', tk.END)
    pem_data = pem_input.get('1.0', tk.END).strip().encode()
    try:
        if b'BEGIN PUBLIC KEY' in pem_data:
            pub_key = serialization.load_pem_public_key(pem_data, backend=default_backend())
            nums = pub_key.public_numbers()
            rsa_pem_output.insert(tk.END, f"类型：公钥\nn={nums.n}\ne={nums.e}\n")
            parsed_pem_values = {'n': nums.n, 'e': nums.e}
        else:
            priv_key = serialization.load_pem_private_key(pem_data, password=None, backend=default_backend())
            nums = priv_key.private_numbers()
            rsa_pem_output.insert(tk.END, f"类型：私钥\nn={nums.public_numbers.n}\ne={nums.public_numbers.e}\nd={nums.d}\np={nums.p}\nq={nums.q}\n")
            parsed_pem_values = {
                'n': nums.public_numbers.n, 'e': nums.public_numbers.e, 'd': nums.d,
                'p': nums.p, 'q': nums.q
            }
    except Exception as e:
        rsa_pem_output.insert(tk.END, f"解析失败: {e}")
        
def transfer_to_rsa_crack():
    # 首先切换到RSA破解界面
    show_frame(rsa_crack_frame)
    # 把保存的parsed_pem_values赋值到rsa_crack_frame对应输入框
    for key, entry in rsa_entries.items():
        if key in parsed_pem_values:
            entry.delete(0, tk.END)
            entry.insert(0, str(parsed_pem_values[key]))

rsa_pem_frame = tk.Frame(root)
# 布局
tk.Label(rsa_pem_frame, text='请输入 PEM 格式的密钥：', font=font_title).pack(pady=(10,0))
pem_input = scrolledtext.ScrolledText(rsa_pem_frame, height=10, font=font_text)
pem_input.pack(fill=tk.BOTH, padx=20, pady=5, expand=True)
tk.Button(rsa_pem_frame, text='解析 PEM', font=font_title, bg='#9C27B0', fg='white', command=parse_pem).pack(pady=10)
tk.Label(rsa_pem_frame, text='解析结果：', font=font_title).pack()
rsa_pem_output = scrolledtext.ScrolledText(rsa_pem_frame, height=10, font=font_text)
rsa_pem_output.pack(fill=tk.BOTH, padx=20, pady=5, expand=True)

tk.Button(rsa_pem_frame, text='传递到RSA破解', font=font_title, bg='#FF9800', fg='white', command=lambda: transfer_to_rsa_crack()).pack(pady=10)


# ------------------ RSA - 破解界面 ------------------
def reset_rsa_entries():
    """重置所有RSA参数输入框"""
    for entry in rsa_entries.values():
        entry.delete(0, tk.END)
    # 重置攻击选项的复选框
    for var, _ in attack_vars.values():
        var.set(False)
    # 重置循环上限输入框
    for _, param_entry in attack_vars.values():
        param_entry.delete(0, tk.END)
        param_entry.insert(0, '1000000')
    # 清空输出结果
    rsa_crack_output.delete('1.0', tk.END)

def rsa_crack_handler():
    rsa_crack_output.delete('1.0', tk.END)
    def get_int(name):
        txt = rsa_entries[name].get().strip().replace(" ", "")
        return int(txt) if txt else None
    n = get_int('n')
    p = get_int('p')
    q = get_int('q')
    d = get_int('d')
    e = get_int('e')
    c = get_int('c')
    # 1. 全部参数
    if None not in (n,d,c):
        m = pow(c, d, n)
        try:
            text = long_to_bytes(m).decode('utf-8', errors='ignore')
        except:
            text = str(long_to_bytes(m))
        rsa_crack_output.insert(tk.END, f"解密结果: {text}\n")
        return
    # 2. 计算 d
    if None not in (n,p,q,e):
        phi = (p-1)*(q-1)
        d_calc = pow(e, -1, phi)
        rsa_crack_output.insert(tk.END, f"计算出的 d: {d_calc}\n")
        if c is not None:
            m = pow(c, d_calc, n)
            try:
                text = long_to_bytes(m).decode('utf-8', errors='ignore')
            except:
                text = str(long_to_bytes(m))
            rsa_crack_output.insert(tk.END, f"解密结果: {text}\n")
        return
    # 3. 攻击
    if n is not None:
        attack_executed = False
        
        if None not in (n,e):
            if attack_vars["Wiener's Attack"][0].get():
                rsa_crack_output.insert(tk.END, "执行 Wiener 攻击...\n")
                d_w = wiener_attack(e,n)
                if d_w:
                    rsa_crack_output.insert(tk.END, f"成功: d={d_w}\n")
                else:
                    rsa_crack_output.insert(tk.END, "失败。\n")
                attack_executed = True
        
        if attack_vars['Fermat Factorization'][0].get():
            lim = int(attack_vars['Fermat Factorization'][1].get())
            rsa_crack_output.insert(tk.END, "执行 Fermat 分解...\n")
            res = fermat_factor(n, lim)
            if res:
                rsa_crack_output.insert(tk.END, f"成功: p={res[0]}, q={res[1]}\n")
            else:
                rsa_crack_output.insert(tk.END, "失败。\n")
            attack_executed = True
            
        if attack_vars["Pollard's p-1"][0].get():
            B = int(attack_vars["Pollard's p-1"][1].get())
            rsa_crack_output.insert(tk.END, "执行 Pollard p-1...\n")
            res = pollard_p1(n, B)
            if res:
                rsa_crack_output.insert(tk.END, f"成功: p={res[0]}, q={res[1]}\n")
            else:
                rsa_crack_output.insert(tk.END, "失败。\n")
            attack_executed = True
        
        if not attack_executed:
            rsa_crack_output.insert(tk.END, "请选择至少一种攻击方法。\n")
        return
    
    
    rsa_crack_output.insert(tk.END, "请至少输入 n 或更多参数。\n")
        
rsa_crack_frame = tk.Frame(root)
# 布局
tk.Label(rsa_crack_frame, text='请输入 RSA 参数（十进制整数）：', font=font_title).pack(pady=(10,5))
rsa_entries = {}
for label in ['n','p','q','d','e','c']:
    row = tk.Frame(rsa_crack_frame)
    tk.Label(row, text=f"{label} =", font=font_text, width=3).pack(side=tk.LEFT)
    entry = tk.Entry(row, font=font_text, width=40)
    entry.pack(side=tk.LEFT, fill=tk.X, expand=True, padx=5)
    rsa_entries[label] = entry
    row.pack(padx=20, pady=3, fill=tk.X)
# 攻击选项
attack_vars = {}
for name in ['Fermat Factorization',"Pollard's p-1","Wiener's Attack"]:
    row = tk.Frame(rsa_crack_frame)
    var_enable = tk.BooleanVar(value=False)
    tk.Checkbutton(row, text=name, variable=var_enable, font=font_text).pack(side=tk.LEFT)
    tk.Label(row, text='循环上限:', font=font_text).pack(side=tk.LEFT, padx=5)
    param_entry = tk.Entry(row, width=10)
    param_entry.insert(0,'1000000')
    param_entry.pack(side=tk.LEFT)
    attack_vars[name] = (var_enable,param_entry)
    row.pack(anchor='w', padx=40, pady=3)
# 计算按钮
button_frame = tk.Frame(rsa_crack_frame)
tk.Button(button_frame, text='破解', font=font_title, bg='#FF9800', fg='white', command=rsa_crack_handler).pack(side=tk.LEFT, padx=(0, 10))
tk.Button(button_frame, text='重置', font=font_title, bg='#607D8B', fg='white', command=lambda: reset_rsa_entries()).pack(side=tk.LEFT)
button_frame.pack(pady=10)
tk.Label(rsa_crack_frame, text='输出结果：', font=font_title).pack()
rsa_crack_output = scrolledtext.ScrolledText(rsa_crack_frame, height=12, font=font_text)
rsa_crack_output.pack(fill=tk.BOTH, padx=20, pady=5, expand=True)


# ------------------ 哈希 - SHA256 界面 ------------------
def compute_sha256():
    sha256_output_text.delete('1.0', tk.END)
    raw = sha256_input_text.get('1.0', tk.END).strip()
    if not raw:
        sha256_output_text.insert(tk.END, "请输入文本内容。")
        return
    h = hashlib.sha256(raw.encode()).hexdigest()
    sha256_output_text.insert(tk.END, h)

sha256_frame = tk.Frame(root)
# 布局
tk.Label(sha256_frame, text='请输入文本内容：', font=font_title).pack(pady=(10,0))
sha256_input_text = scrolledtext.ScrolledText(sha256_frame, height=6, font=font_text)
sha256_input_text.pack(fill=tk.BOTH, padx=20, pady=5, expand=True)
tk.Button(sha256_frame, text='计算哈希', font=font_title, bg='#E91E63', fg='white', command=compute_sha256).pack(pady=10)
tk.Label(sha256_frame, text='SHA256 结果：', font=font_title).pack()
sha256_output_text = scrolledtext.ScrolledText(sha256_frame, height=6, font=font_text)
sha256_output_text.pack(fill=tk.BOTH, padx=20, pady=5, expand=True)

# ------------------ 哈希 - MD5 界面 ------------------
def compute_md5():
    md5_output_text.delete('1.0', tk.END)
    raw = md5_input_text.get('1.0', tk.END).strip()
    if not raw:
        md5_output_text.insert(tk.END, "请输入文本内容。")
        return
    h = hashlib.md5(raw.encode()).hexdigest()
    md5_output_text.insert(tk.END, h)

md5_frame = tk.Frame(root)
# 布局
tk.Label(md5_frame, text='请输入文本内容：', font=font_title).pack(pady=(10,0))
md5_input_text = scrolledtext.ScrolledText(md5_frame, height=6, font=font_text)
md5_input_text.pack(fill=tk.BOTH, padx=20, pady=5, expand=True)
tk.Button(md5_frame, text='计算哈希', font=font_title, bg='#7E57C2', fg='white', command=compute_md5).pack(pady=10)
tk.Label(md5_frame, text='MD5 结果：', font=font_title).pack()
md5_output_text = scrolledtext.ScrolledText(md5_frame, height=6, font=font_text)
md5_output_text.pack(fill=tk.BOTH, padx=20, pady=5, expand=True)

# ------------------ 菜单配置 ------------------
encoding_menu = tk.Menu(menubar, tearoff=0)
menubar.add_cascade(label='编码', menu=encoding_menu)
encoding_menu.add_command(label='编码', command=lambda: show_frame(encode_frame))
encoding_menu.add_command(label='解码', command=lambda: show_frame(decode_frame))

classical_menu = tk.Menu(menubar, tearoff=0)
menubar.add_cascade(label='古典密码', menu=classical_menu)
classical_menu.add_command(label='栅栏密码', command=lambda: show_frame(RailFence_frame))
classical_menu.add_command(label='凯撒密码', command=lambda: show_frame(Caesar_frame))
classical_menu.add_command(label='维吉尼亚密码', command=lambda: show_frame(Vigenere_frame))

rsa_menu = tk.Menu(menubar, tearoff=0)
menubar.add_cascade(label='RSA', menu=rsa_menu)
pem_menu = tk.Menu(rsa_menu, tearoff=0)
rsa_menu.add_cascade(label='PEM', menu=pem_menu)
pem_menu.add_command(label='生成PEM', command=lambda: show_frame(rsa_generate_pem_frame))
pem_menu.add_command(label='解析PEM', command=lambda: show_frame(rsa_pem_frame))
rsa_menu.add_command(label='破解 RSA', command=lambda: show_frame(rsa_crack_frame))

hash_menu = tk.Menu(menubar, tearoff=0)
menubar.add_cascade(label='哈希', menu=hash_menu)
hash_menu.add_command(label='SHA256', command=lambda: show_frame(sha256_frame))
hash_menu.add_command(label='MD5', command=lambda: show_frame(md5_frame))

# 默认显示页面
show_frame(decode_frame)
root.mainloop()