Rabin算法python实现附源码| “朝闻道”知识分享大赛

[不知名11]

这是我参加朝闻道知识分享大赛的第四篇文章

Rabin算法是一种基于数论的大整数加密算法，其安全性依赖于大整数因式分解的困难性。这种算法最早由Michael O. Rabin提出，是一种公钥密码体制，与RSA算法类似，但在解密阶段具有独特的特点，即每个密文会对应四种可能的解。这使得Rabin算法具有较高的安全性，但也带来了额外的解密验证需求。

本文将通过Rabin算法的背景介绍、应用场景、伪代码、Python实现和实验结果，深入探讨其实现与应用。

---

一、Rabin算法背景与应用场景

1. 背景

Rabin算法的核心基于模平方计算和大整数因式分解问题：

• 加密过程：将明文转化为数值并进行平方取模运算生成密文。
• 解密过程：利用模平方根运算，还原出四个可能的解。
  Rabin算法的数学基础简单，运算效率高，被广泛用于对安全性要求较高的场景。

2. 应用场景

Rabin算法主要应用于以下场景：

1. 数据加密：保护机密信息，例如电子邮件和文件传输。
2. 数字签名：通过大整数运算生成签名，提高身份验证的安全性。
3. 密钥交换：在公开信道中安全地交换密钥。

---

二、Rabin算法伪代码

Rabin 加密算法
输入: 明文m，密钥 p 和 q
输出: 密文
（1）计算公钥 n←p⋅q
（2）加密过程 将明文 m 转换为密文

c←m² mod n

Rabin解密算法
输入: 密文c，密钥 p 和 q，公钥n
输出: 四种解密结果
计算平方根模 p 和模 q

b1 ← Sqrt(c,p) 
b2 ← Sqrt(c,q)

 使用P34的辗转相除法求解模逆

s1,t1 ← Gcd(p,q) 
s2,t2 ← Gcd(q,p)

 根据公式计算四个解

 X1← (b1 * t1 * q + b2 * t2 * p)   mod  n
X2← (b1 * t1 * q - b2 * t2 * p)   mod  n
   X3← (-b1 * t1 * q + b2 * t2 * p)  mod  n
   X4← (-b1 * t1 * q - b2 * t2 * p)  mod  n

三、Python实现

核心代码

以下是Rabin算法的完整实现，包含加密、解密以及图形化界面设计：

import tkinter as tk
from tkinter import messagebox
import math


# 扩展欧几里得算法
def extended_gcd(a, b):
    x, y = 1, 0
    x1, y1 = 0, 1
    while b != 0:
        q = a // b
        a, b = b, a % b
        x, x1 = x1, x - q * x1
        y, y1 = y1, y - q * y1
    return x, y


# Rabin 加密算法实现
def rabin_encrypt_decrypt(plaintext, p, q):
    n = p * q  # 计算模数 n
    # 将明文转换为 ASCII 码
    pt_ascii = [ord(c) for c in plaintext]
    # 进行加密，得到密文并将其转换为字符形式
    ct_ciphers = [(x * x) % n for x in pt_ascii]
    ct_chars = [chr(c) if 0 <= c <= 0x10FFFF else '?' for c in ct_ciphers]  # 转换为字符形式

    # 解密过程，存储四组解密结果
    decrypted_results = [[], [], [], []]
    for cipher in ct_ciphers:
        b1 = int(math.sqrt(cipher % p))
        b2 = int(math.sqrt(cipher % q))

        # 使用扩展欧几里得算法求解
        x1, y1 = extended_gcd(p, q)
        x2, y2 = extended_gcd(q, p)

        # 计算四个可能的解
        x1_result = (b1 * y1 * q + b2 * y2 * p) % n
        x2_result = (b1 * y1 * q - b2 * y2 * p) % n
        x3_result = (-b1 * y1 * q + b2 * y2 * p) % n
        x4_result = (-b1 * y1 * q - b2 * y2 * p) % n

        # 过滤掉不在合法字符范围内的结果
        for idx, res in enumerate([x1_result, x2_result, x3_result, x4_result]):
            if 0 <= res <= 0x10FFFF:  # 确保结果在合法的字符范围内
                decrypted_results[idx].append(chr(res))
            else:
                decrypted_results[idx].append('?')  # 超出范围用问号代替

    # 将解密结果分别组成四个字符串
    decrypted_texts = [''.join(group) for group in decrypted_results]

    return decrypted_texts, pt_ascii, ct_chars  # 返回解密结果、明文 ASCII 码和字符形式的密文


# UI 界面设计
def on_encrypt_decrypt():
    plaintext = entry_text.get()  # 获取用户输入的明文
    try:
        p = int(entry_p.get())  # 获取素数 p
        q = int(entry_q.get())  # 获取素数 q
    except ValueError:
        messagebox.showerror("输入错误", "请输入有效的素数!")
        return

    if not plaintext:  # 确保明文不为空
        messagebox.showerror("输入错误", "请输入明文文本!")
        return

    decrypted_results, pt_ascii, ct_chars = rabin_encrypt_decrypt(plaintext, p, q)

    # 显示结果
    ascii_plaintext.set(', '.join(map(str, pt_ascii)))  # 显示明文 ASCII 码
    encrypted_text.set(''.join(ct_chars))  # 显示加密后的密文（字符形式）

    # 格式化解密结果
    decrypted_display = ""
    for i, result in enumerate(decrypted_results):
        decrypted_display += f"解密答案 {i + 1}: {''.join(result)}\n"

    decrypted_text_display.set(decrypted_display)  # 更新解密文本显示


# 创建主窗口
root = tk.Tk()
root.title("Rabin 加密算法")
root.geometry("800x800")  # 设置窗口大小
root.configure(bg="#f0f0f0")  # 设置背景颜色

# 创建输入框和标签
label_text = tk.Label(root, text="请输入明文:", bg="#f0f0f0")
label_text.pack(pady=10)

entry_text = tk.Entry(root, width=50)
entry_text.pack(pady=10)

# 输入素数 p 和 q
label_p = tk.Label(root, text="请输入素数 p:", bg="#f0f0f0")
label_p.pack(pady=5)
entry_p = tk.Entry(root, width=20)
entry_p.pack(pady=5)

label_q = tk.Label(root, text="请输入素数 q:", bg="#f0f0f0")
label_q.pack(pady=5)
entry_q = tk.Entry(root, width=20)
entry_q.pack(pady=10)

# 加密和解密按钮
button = tk.Button(root, text="加密并解密", command=on_encrypt_decrypt, bg="#4CAF50", fg="white")
button.pack(pady=20)

# 显示加密前后结果
ascii_plaintext = tk.StringVar()
encrypted_text = tk.StringVar()
decrypted_text_display = tk.StringVar()

label_ascii = tk.Label(root, text="明文ASCII码:", bg="#f0f0f0")
label_ascii.pack()

ascii_label = tk.Label(root, textvariable=ascii_plaintext, width=50, height=2, anchor="w", bg="#f0f0f0")
ascii_label.pack()

label_encrypted = tk.Label(root, text="加密后的密文:", bg="#f0f0f0")
label_encrypted.pack()

encrypted_label = tk.Label(root, textvariable=encrypted_text, width=50, height=2, anchor="w", bg="#f0f0f0")
encrypted_label.pack()

label_decrypted = tk.Label(root, text="解密后的明文 (四个解密结果):", bg="#f0f0f0")
label_decrypted.pack()

decrypted_label = tk.Label(root, textvariable=decrypted_text_display, width=50, height=10, anchor="w", justify="left", bg="#f0f0f0")
decrypted_label.pack()

# 运行主循环
root.mainloop()

---

四、实验结果分析

1. 加密与解密流程

1. 用户输入明文与密钥：通过界面输入明文与两个素数 p,qp, qp,q。
2. 加密过程：系统通过平方取模操作生成密文。
3. 解密过程：系统计算每个密文块的四个可能解，并筛选出有效的字符。

2. Rabin算法的特点

• 安全性：基于大整数分解问题，具备较高的安全性。
• 解密复杂性：每个密文对应四种可能解，需验证合法性。
• 扩展欧几里得算法的应用：用于模反元素计算，确保解密结果正确。