【密码学】RSA破解方法汇总（PYTHON实现）

源自于密码学的一次大作业~

RSA破解

💡 Alice使用的RSA密码体制，有以下事项需要说明：

1）模数𝑁=𝑝𝑞规模为1024比特，其中𝑝，𝑞为素数；

2）每次加密最多8个明文字符；

3）明文超过8个字符时，对明文分片，每个分片不超过8个字符；

4）分片明文填充为512比特消息后再进行加密，填充规则为高位添加64比特标志位，随后加上32比特通信序号，再添加若干个0，最后64比特为明文分片字符对应的ASCII码（注：填充方式参见加密案例，但注意每次通信的标志位可能变化）；

5)分片加密后发送一个加密帧数据，帧数据文件名称为FrameXX，其中XX表示接收序号，该序号不一定等于通信序号；

6）帧数据的数据格式如下，其中数据都是16进制表示，结构如下

1024bit模数N|1024bit加密指数e|1024bit密文。

7）由于Alice初次使用该软件，可能会重复发送某一明文分片。

请您尝试恢复每个帧数据的p和q，以及明文M

输入：若干帧文件

文件的格式： 1024bit模数 N | 1024bit加密指数 e | 1024bit密文

一、低指数攻击——中国剩余定理

题目

💡 给定五个密文，存在五个文件中，这5个密文（都是16进制）是同一明文m用RSA算法模不同N得到的，加密指数e=5(即公钥为5)，每个密文的格式： 1024bit模数 N | 1024bit加密指数 e | 1024bit密文。请利用中国剩余定理恢复明文m (求解5个同余方程的同余方程组)

from mpmath import mp
import gmpy2
import functoolsdef chinese_remainder_theorem(n, a):# n 是模数列表，a 是同余方程组的余数列表# 求模数的积N = functools.reduce(gmpy2.mul, n)  # 使用 functools.reduce 计算乘积# 求每个模数 Ni 和 Ni 在模数 n 中的商 si 和余数 tix = 0for ni, ai in zip(n, a):si = N // niti = gmpy2.invert(si, ni)xi = gmpy2.mul(gmpy2.mul(si, ti), ai)  # 分别计算 si * ti 和结果再与 ai 相乘x = gmpy2.add(x, xi)# 将 x 转化为模数为 N 的余数，作为最小非负整数解return x % N# 示例输入
a = []
n = []
f=[]
f.append(r'file1')
f.append(r'file2')
f.append(r'file3')
f.append(r'file4')
f.append(r'file5')for file_path in f:# 读取数据with open(file_path, 'r') as f:data = f.read().strip()# 解析数据hex_length = len(data) // 3N = int(data[:hex_length], 16)e = int(data[hex_length:2*hex_length], 16)ct = int(data[2*hex_length:], 16)# 打印数据# print(f"Modulus N: {N}\\n")# print(f"Public exponent e: {e}\\n")# print(f"Ciphertext: {ct}\\n")n.append(N)a.append(ct)
mp.dps=1000
nn = [gmpy2.mpz(i) for i in n]  # 模数列表
aa = [gmpy2.mpz(i) for i in a]  # 同余方程组的余数列表
m = chinese_remainder_theorem(n, a)
res,exa=gmpy2.iroot(gmpy2.mpz(m),5)def parse_8_pairs_16_bytes(s):# 将字符串截取为最后 16 个字节bytes_16 = s[-16:]# 定义一个空列表，用于保存解析出的字符对pairs = []# 分组解析每两个字节for i in range(0, 16, 2):byte1, byte2 = bytes_16[i], bytes_16[i + 1]char1 = chr(int(byte1 + byte2, 16))pairs.append((char1,))# 将所有字符对连接起来，并返回字符串return ''.join(char for pair in pairs for char in pair)
print(hex(res))
print(parse_8_pairs_16_bytes(hex(res)))

二、费马分解

摘自 RSA-p和q挨得很近(费马分解)_rsa费马分解_爱码蔡蔡子的博客-CSDN博客

1.p,q为邻居素数

p，q是两个素数，而且他俩在素数序列里面就是一前一后的关系。所以我们要把他俩的乘积开根号得到的结果一定是在p，q之间的一个数字，（而且一定不是素数，因为p，q就是紧邻的两个素数）。那我们找这个开方出来的数字的下一个素数，一定是q，因此我们再让n/q就可以得到两个素数

示例：

'''生成两个挨得近的素数p，q'''
p = getPrime(512)
q = gmpy2.next_prime(p)
n=p*q
print(p)
print(q)
print(n)'''开始破解'''
# gmpy2的iroot函数，这个函数专门用来进行大数开根号，gmpy2.iroot(n,t)。
# n是大整数，t是幂次。
temp=gmpy2.iroot(n,2)[0]  
p=gmpy2.next_prime(temp)
q=n//p
print(p)
print(q)

2.平方差遍历法

令a是n的"中间值"sqrt(n),然后让a以步长为1自增遍历，直到pow(a,2)-n的结果可以正好开方为止。那个结果开方就是b。

$$ p=a-b;q=a+b;n=pq=a^2-b^2 $$

$$ b^2=a^2-n $$

因此，可以令a的初始值为sqrt(n)，不断增大a直至满足上述条件即可

示例：

'''生成两个挨得近的素数p，q'''
p = getPrime(512)
q = gmpy2.next_prime(p)
n=p*q
print(p)
print(q)
print(n)print('开始破解')
'''开始破解'''
a=gmpy2.iroot(n,2)[0]
while 1:   #破解出来一组就行了，一般也就一组，挨得很近的话很快就出来了，如果长时间还没出来就可以换方法了，不要指望着他遍历所有的，到死也弄不完。B2=pow(a,2)-na+=1if gmpy2.is_square(B2):b=gmpy2.iroot(B2,2)[0]p=a+bq=a-bprint(p)print(q)break

题目

💡 给定密文的格式： 1024bit模数 N | 1024bit加密指数 e | 1024bit密文。已知密文产生的RSA算法中的pq很接近


import gmpy2
import gmpy2def fermat_factorization(n):a = gmpy2.isqrt(n) + 1  # 取 n 的平方根并向上取整b2 = a * a - nwhile not gmpy2.is_square(b2):# 迭代计算直到 b2 是一个完全平方数a += 1b2 = a * a - np = a + gmpy2.isqrt(b2)q = a - gmpy2.isqrt(b2)return p, q
f=[]
f.append(r'file1')
f.append(r'file2')for file_path in f:# 读取数据with open(file_path, 'r') as f:data = f.read().strip()# 解析数据hex_length = len(data) // 3n = gmpy2.mpz(int(data[:hex_length], 16))e = int(data[hex_length:2*hex_length], 16)ct = int(data[2*hex_length:], 16)# # 打印数据# print(f"================================\\nModulus N: {n}\\n")# print(f"Public exponent e: {e}\\n")# print(f"Ciphertext: {ct}\\n")# input()p, q = fermat_factorization(n)if p is None or q is None:print("无法分解质因数")else:print("质因数分解结果:")print("p =", p)print("q =", q)d=gmpy2.invert(e,(q-1)*(p-1))m=gmpy2.powmod(ct,d,n)def parse_8_pairs_16_bytes(s):# 将字符串截取为最后 16 个字节bytes_16 = s[-16:]# 定义一个空列表，用于保存解析出的字符对pairs = []# 分组解析每两个字节for i in range(0, 16, 2):byte1, byte2 = bytes_16[i], bytes_16[i + 1]char1 = chr(int(byte1 + byte2, 16))pairs.append((char1,))# 将所有字符对连接起来，并返回字符串return ''.join(char for pair in pairs for char in pair)print(hex(m))print(parse_8_pairs_16_bytes(hex(m)))

三、共模攻击

【密码学RSA】共模攻击原理详解_已知e1*e2的共模攻击题_rsa共模攻击原理-CSDN博客

RSA共模攻击(包括原理)-CSDN博客

💡 共模是指：就是明文m,相同。用两个公钥e1,e2加密得到两个私钥d1,d2 和两个密文c1,c2

共模攻击，即当m不变的情况下，知道n,e1,e2,c1,c2, 可以在不知道d1,d2的情况下，解出m

利用条件为=> gcd(e1,e2)=1

def hack(n, c1, c2, e1, e2):def egcd(a, b):if b == 0:return a, 0else:x, y = egcd(b, a % b)return y, x - (a // b) * ys = egcd(e1, e2)s1 = s[0]s2 = s[1]# 求模反元素if s1 < 0:s1 = - s1c1 = invert(c1, n)elif s2 < 0:s2 = - s2c2 = invert(c2, n)m = pow(c1, s1, n) * pow(c2, s2, n) % nreturn m


from gmpy2 import invert
def hack(n, c1, c2, e1, e2):def egcd(a, b):if b == 0:return a, 0else:x, y = egcd(b, a % b)return y, x - (a // b) * ys = egcd(e1, e2)s1 = s[0]s2 = s[1]# 求模反元素if s1 < 0:s1 = - s1c1 = invert(c1, n)elif s2 < 0:s2 = - s2c2 = invert(c2, n)m = pow(c1, s1, n) * pow(c2, s2, n) % nreturn mf1=r'file1'
f2=r'file2'# 读取数据
with open(f1, 'r') as f:data = f.read().strip()
# 解析数据
hex_length = len(data) // 3
n1 = int(data[:hex_length], 16)
e1 = int(data[hex_length:2*hex_length], 16)
c1 = int(data[2*hex_length:], 16)
f.close()# 读取数据
with open(f2, 'r') as f:data = f.read().strip()
# 解析数据
hex_length = len(data) // 3
n2 = int(data[:hex_length], 16)
e2 = int(data[hex_length:2*hex_length], 16)
c2 = int(data[2*hex_length:], 16)
f.close()if n1==n2:m=hack(n1,c1,c2,e1,e2)
# print("m={}".format(hex(m)))
def parse_8_pairs_16_bytes(s):# 将字符串截取为最后 16 个字节bytes_16 = s[-16:]# 定义一个空列表，用于保存解析出的字符对pairs = []# 分组解析每两个字节for i in range(0, 16, 2):byte1, byte2 = bytes_16[i], bytes_16[i + 1]char1 = chr(int(byte1 + byte2, 16))pairs.append((char1,))# 将所有字符对连接起来，并返回字符串return ''.join(char for pair in pairs for char in pair)
print(hex(m))
print(parse_8_pairs_16_bytes(hex(m)))

四、rho、rho p-1分解pq

【快速因数分解】Pollard's Rho 算法 - Koshkaaa (cnblogs.com)

import gmpy2
from gmpy2 import mpz
import random
import time# Rho算法
def rho(n, timeout=3):if n % 2 == 0:return 2start_time = time.time()while True:if time.time() - start_time > timeout:  # 超时处理,替换判环return Nonex, y, c, d = random.randint(1, n-1), random.randint(1, n-1), random.randint(1, n-1), 1f = lambda x: (x * x + c) % nwhile d == 1:x = f(x)y = f(f(y))d = gmpy2.gcd(abs(x-y), n)if d != n:return df=[]
f.append(r'file1')
f.append(r'file2')for file_path in f:# 读取数据with open(file_path, 'r') as f:data = f.read().strip()# 解析数据hex_length = len(data) // 3n = int(data[:hex_length], 16)e = int(data[hex_length:2*hex_length], 16)ct = int(data[2*hex_length:], 16)p = rho(n)while p is None:  # 超时，重新选择随机数p = rho(n)q=n//pd=gmpy2.invert(e,(q-1)*(p-1))m=gmpy2.powmod(ct,d,n)def parse_8_pairs_16_bytes(s):# 将字符串截取为最后 16 个字节bytes_16 = s[-16:]# 定义一个空列表，用于保存解析出的字符对pairs = []# 分组解析每两个字节for i in range(0, 16, 2):byte1, byte2 = bytes_16[i], bytes_16[i + 1]char1 = chr(int(byte1 + byte2, 16))pairs.append((char1,))# 将所有字符对连接起来，并返回字符串return ''.join(char for pair in pairs for char in pair)print(hex(m))print(parse_8_pairs_16_bytes(hex(m)))

# rho p-1
import math
import random
import time
import gmpy2def rho_pminus1(n, B, timeout=10):a = 2start_time = time.time()# 计算 a^q-1for q in range(2, B+1):if (time.time() - start_time) > timeout:  # 超时处理,替换判环return Nonea = pow(a, q, n)# 计算 a^q-1 和 n 的最大公约数d = math.gcd(a - 1, n)if d > 1 and d < n:return dreturn Nonedef factorize_large_number(n, B, timeout=10):factors = []while n > 1:p = rho_pminus1(n, B, timeout)if p is None:factors.append(n)  # 无法找到质因数，将n作为一个质因数breakelse:factors.append(p)n //= preturn factors# 指数的范围B和超时时间
B = 100000
timeout = 10# 读取数据
with open(r'file1', 'r') as f:data = f.read().strip()# 解析数据
hex_length = len(data) // 3
n = int(data[:hex_length], 16)
e = int(data[hex_length:2*hex_length], 16)
ct = int(data[2*hex_length:], 16)# 分解非常大的数
factors = factorize_large_number(n, B, timeout)p,q=factors
d=gmpy2.invert(e,(q-1)*(p-1))
m=gmpy2.powmod(ct,d,n)
def parse_8_pairs_16_bytes(s):# 将字符串截取为最后 16 个字节bytes_16 = s[-16:]# 定义一个空列表，用于保存解析出的字符对pairs = []# 分组解析每两个字节for i in range(0, 16, 2):byte1, byte2 = bytes_16[i], bytes_16[i + 1]char1 = chr(int(byte1 + byte2, 16))pairs.append((char1,))# 将所有字符对连接起来，并返回字符串return ''.join(char for pair in pairs for char in pair)
print(hex(m))
print(parse_8_pairs_16_bytes(hex(m)))