挺久没有做过CTF了，明天就要打比赛了，临时抱佛脚，撸两道rsa，找找手感。
公钥文件泄露
题目给了两个文件：pub.key和flag.enc:
pub.key
-----BEGIN PUBLIC KEY-----
MDwwDQYJKoZIhvcNAQEBBQADKwAwKAIhAMAzLFxkrkcYL2wch21CM2kQVFpY9+7+
/AvKr1rzQczdAgMBAAE=
-----END PUBLIC KEY-----
flag.enc（乱码）
ZF:9Mw 骓骼)P恂黮?沕悴[嘟??
解题思路挺多的，这个没啥好说的（虽然因为很久没有做过，卡了很久）
-
只想简单解题的话，直接找个在线解密的解密的网站（我就不提供了，自己找吧），然后把这两个文件放上去解密就行了。
-
稍微复杂点的化，就是用openssl可以查看到公钥(n，e），大数分解n，得到p，q，然后写个python脚本
openssl rsa -pubin -in pub.key -text
写个脚本，将上面的modulus里的的字符做个分割，组成16进制数。
from rsa import PublicKey, transform, core, common import rsa import gmpy2 """第一种方法""" temp = [] temp = hex("00:aa:08".split(':')) n = '' for i in temp: n += i n = eval(n) print(n) # 将n进行大数分解，得到p，q p = 285960468890451637935629440372639283459 q = 304008741604601924494328155975272418463 e = 65537 phi = (p-1)*(q-1) # 欧拉函数 d = gmpy2.invert(e,phi) #计算模逆元d key = rsa.PrivateKey(n,e,int(d),p,q) # 有了n，e，d，p，q之后 使用rsa模块生成私钥 with open('./flag.enc','rb+') as f: f = f.read() print(rsa.decrypt(f,key)) # 解密文件 """ 第二中方法:直接使用rsa模块去查看n，e """ whit open("./pub.key","rb+") as k, open('./flag.enc','rb+') as f: k = k.read() public_key = PublicKey.load_pkcs1_openssl_pem(k) #通过rsa模块的内容去读取公钥的信息 print(public_key) # 这里会输出一个 n 和 e 的元组 # 将n进行大数分解，得到p，q p = 285960468890451637935629440372639283459 q = 304008741604601924494328155975272418463 e = 65537 key = rsa.PrivateKey(n, e, int(d), p, q) f = f.read() print(rsa.decrypt(f,key)) """ # 在使用第二种方法的是后，其实是有个坑的。因为我自己很久没有做rsa了。 # 很多东西都要重新开始学，这个脚本最初也是照着网上的脚本写的（网上的脚本贴贴在下面） # 他用的是core.decrypt_int()方法去解密的。这没有什么问题，只是需要做个数据格式转换。 # 但是 PublicKey.load_pkcs1(PUBLIC_KEY) 这个地方就有坑了。 # rsa使用的密钥文件有两种格式： # 第一种： -----BEGIN PUBLIC KEY----- ......... -----END PUBLIC KEY----- # 第二中 -----BEGIN RSA PUBLIC KEY----- ......... -----END RSA PUBLIC KEY----- # PublicKey.load_pkcs1()方法都的是第二种密钥格式 # PublicKey.load_pkcs1_openssl_pem() 方法的的是第一种密钥格式 # 而且： # # 两种方法返回的数据是不同的！ # 两种方法返回的数据是不同的！ # 两种方法返回的数据是不同的！ # # 重要的事情说三遍（你细品我现在的心情） # """脚本在这里摘自 作者：窗户
#! /usr/bin/env python # -*- coding: utf-8 -*- import sys #rsa from rsa import PublicKey, common, transform, core def f(cipher, PUBLIC_KEY): public_key = PublicKey.load_pkcs1(PUBLIC_KEY) encrypted = transform.bytes2int(cipher) decrypted = core.decrypt_int(encrypted, public_key.e, public_key.n) text = transform.int2bytes(decrypted) if len(text) > 0 and text[0] == '\x01': pos = text.find('\x00') if pos > 0: return text[pos+1:] else: return None fn = sys.stdin.readline()[:-1] public_key = sys.stdin.readline()[:-1] x = f(open(fn).read(), open(public_key).read()) print x
Baby_RSA(我也不知道应该算什么分类)
题目直接给了一个加密脚本。或不多说，先上脚本：（原脚本里面没有任何注释，大部分的东西都在注释里了）
## 看着上面一堆的导入库，然后用到的却不多，头秃
import sympy # 这个是解题的核心库，pip装一下就好了
import random
from gmpy2 import gcd, invert # gmpy2，没啥好说的，rsa加解密的核心库
from Crypto.Util.number import getPrime, isPrime, getRandomNBitInteger, bytes_to_long, long_to_bytes
# Crypto 这个库有点恶心人。网上大部分教程都是直接 pip install pycryptodemo 完事了
# 然后你会发现，屁，照样报错，解决办法是：
# 你去python库安装的目录的Python38\Lib\site-packages
# （找不到的话CMD，where python，就能去到python的根目录里）
# 把 crypto 目录改成 Crypto 就能用了
# 原因我也不知道，还没有去查过库
from z3 import *
flag = b"nsfocus{xxxx}" # 这个flag的样式是很重要（记号1）
base = 65537
# 这个函数全程没有用到过，我不知道他是干嘛用的，迷惑我们的？迷茫
def GCD(A):
B = 1
for i in range(1, len(A)):
B = gcd(A[i-1], A[i])
return B
# 取 p 的函数，挺有意思的
def gen_p():
P = [0 for i in range(16)]
# 获取了一个随机的质数赋给 P[0] ,而后的每个个值都是前一个质数的下一个质素
P[0] = getPrime(128)
for i in range(1, 17): # 做题的的时候眼抽了，没看到这里重新更新了P[]的大小
P[i] = sympy.nextprime(P[i-1]) # 还很蒙蔽的说下面循环给17不是超界了
# sympy.nextprime() 获取参数的下一个质数
# 我很自然的想到了 获取前一个质数方法，然后发现真的有，这是这个题目的解题核心
print("P_p :", P[9]) ##### 注意 这个P[9],这样我们就能把整个P[]都给不全了
n = 1
for i in range(17):
n *= P[i]
p = getPrime(1024)
factor = pow(p, base, n)
# 看到这里，有没有发现点什么？
# 没错，就是在这个地方做了 rsa加密，加密了p。一个简单的欧拉函数(phi)变形的加密
# 数学解题思路在下面
print("P_factor :", factor)
##### 注意 这里返回的是 p 的下一个质数
return sympy.nextprime(p) ##### 注意 这里返回的是 p 的下一个质数
##### 注意 这里返回的是 p 的下一个质数
##### 你没想错，我又踩坑了
# 取 Q 的函数，这个就真的有意思了。
def gen_q():
sub_Q = getPrime(1024)
Q_1 = getPrime(1024)
Q_2 = getPrime(1024)
# 上面去了三个质数，没啥好说的，下面的这个表达式
#做个记号，后面要用（记号2）
Q = sub_Q ** Q_2 % Q_1 ##### 没错就是这里,整个题目最精妙的地方
# 下面的这些都没啥好说的
print("Q_1: ", Q_1)
print("Q_2: ", Q_2)
print("sub_Q: ", sub_Q)
return sympy.nextprime(Q) # 这个地方返回的也是 Q 的下一个 质数
if __name__ == "__main__":
_E = base
_P = gen_p()
_Q = gen_q()
# 这个地方是用来保证 _E 和 phi（欧拉函数）互质用的（方便求d）
assert (gcd(E, (_P - 1) * (_Q - 1)) == 1)
M = bytes_to_long(flag) # 做了个数据类型转换，方便加密
# 最终的加密
_C = pow(M, _E, P * Q) ### 这个地方小坑， P 是 _P, Q 是 _Q
### 我当时傻乎乎以为是上面的 return 里面的p和q
print("Ciphertext = ", _C)
# 下面是一大串数据，看看就好了
'''
P_p : 206027926847308612719677572554991143421
P_factor : 213671742765908980787116579976289600595864704574134469173111790965233629909513884704158446946409910475727584342641848597858942209151114627306286393390259700239698869487469080881267182803062488043469138252786381822646126962323295676431679988602406971858136496624861228526070581338082202663895710929460596143281673761666804565161435963957655012011051936180536581488499059517946308650135300428672486819645279969693519039407892941672784362868653243632727928279698588177694171797254644864554162848696210763681197279758130811723700154618280764123396312330032986093579531909363210692564988076206283296967165522152288770019720928264542910922693728918198338839
Q_1: 103766439849465588084625049495793857634556517064563488433148224524638105971161051763127718438062862548184814747601299494052813662851459740127499557785398714481909461631996020048315790167967699932967974484481209879664173009585231469785141628982021847883945871201430155071257803163523612863113967495969578605521
Q_2: 151010734276916939790591461278981486442548035032350797306496105136358723586953123484087860176438629843688462671681777513652947555325607414858514566053513243083627810686084890261120641161987614435114887565491866120507844566210561620503961205851409386041194326728437073995372322433035153519757017396063066469743
sub_Q: 168992529793593315757895995101430241994953638330919314800130536809801824971112039572562389449584350643924391984800978193707795909956472992631004290479273525116959461856227262232600089176950810729475058260332177626961286009876630340945093629959302803189668904123890991069113826241497783666995751391361028949651
Ciphertext = 3456235890998996195610328576070818608212146115114054814560270509307541871219901924317906285783345502450407903297515749909925247057656479099156326718535149969298044687730717978909742604675188350201879798460569721955402966098556911054579289216533244883556427607787129063524341478675272236515424795594246542809803123825660181435151517009926989152291239580046450083599706908982941859840129662960907854690675582551816049328631412344203956716526620975585430081122484860480186571618841845367637670136996691613216081512920967200668918375537812973064141095933513440342389661883780888908448851245758659782134089407794948873910
'''
ok，看到这里，基本上代码都读懂了，那我们就开始填坑了。
第一个坑 —— get_p() 函数：
def gen_p():
P = [0 for i in range(16)]
P[0] = getPrime(128)
for i in range(1, 17):
P[i] = sympy.nextprime(P[i-1])
n = 1
print("P_p :", P[9])
for i in range(17):
n *= P[i]
p = getPrime(1024)
factor = pow(p, base, n)
print("P_factor :", factor)
return sympy.nextprime(p)
上面也说了这是一个简单的欧拉函数的加密。
首先，已知 P[9],也就是P_p，我们就能给整个P[]数组给初始化。所以 n 的值也就能够计算出来了。
import sympy
import gmpy2
P = []
P[9] = P_p
for i in range(8,-1,-1):
P[i] = sympy.prevprime(P[i+1])
for i in range(10,17):
P[i] = sympy.nextprime(P[i-1])
n = 1
for i in range(1,17):
n *= P[i]
接下来就到了欧拉函数部分了，已知n，e，要求d，最简单的方法就是通过欧拉函数。那么，欧拉函数是多少？
提醒一下，碰到简单n，e题目的时候，我们通过将将n分解曾p，q两个质数，然后用 phi = （p-1)*(q-1) 来计算。那这个地方呢？也去分解n？
其实，出题的时候就已经给你分好了。P[]数组里面的值都是质数！
而 n = P[1] * p[2] * …*P[16]
所以 phi(n) = phi(P[1]) * phi(P[2]) * … * phi(P[16])
所以 phi(n) = (P[1] - 1)*(P[2] -1)*(P[3] - 1)* … * (P[16] - 1)
所以 欧拉函数也有了，p，不久放出来了吗！（咳，有点味道）
phi = 1
for i in range(1,17):
phi *= (P[i] - 1)
d = gmpy2.invert(base, phi)
p = pow(factor, d, n)
return sympy.nextprime(p)
OK,接下来第二个坑（天坑）
get_q()函数
def gen_q():
sub_Q = getPrime(1024)
Q_1 = getPrime(1024)
Q_2 = getPrime(1024)
Q = sub_Q ** Q_2 % Q_1
print("Q_1: ", Q_1)
print("Q_2: ", Q_2)
print("sub_Q: ", sub_Q)
return sympy.nextprime(Q)
看到上面的算法，你第一件想到的事情是什么？我想到的是sub_Q,Q_1,Q_2的结果都给了，跑不久完事了。如果你也是这样想的，那恭喜你，和我一样掉坑了，等到宇宙爆炸的都不一定能拿到结果。
让我们来看看（记号2），这里的运算时乘方，不是乘法，注意 是乘方，乘方，乘方。
一个1024位的数字做1024为数值次的乘方。怎么算？拿头算？
而这个地方精妙的就是后面的取模了。这就在告诉我们，Q你是拿不到了，但Q肯定是 Q_1 > Q > 0 之间的质数。
没了。
所以，到了这里，就是在变相的告诉你，最后的加密用到的q。而且q要么很小，靠近0，要么很大，靠近Q_1。
那思路不久清晰了吗：
p 已知了，Q_1已知，q自己去爆破 (用sympy.nextprime() 方法和sympy.prevprime()方法) ,e 已知了。
所以代码可以撸起来了。
import gmpy2
import sympy
from Crypto.Util.number import long_to_bytes
p = return sympy.nextprime(p)
q = Q_1 # 或者 q = 1
c = Ciphertext
Q_2 = 1
while True:
n = p * q
phi = (p-1) * (q-1)
d = gmpy2.invert(e, phi)
m = pow(c, d, n)
m = long_to_bytes(m).decode('utf-8','ignore')
print(m)
q = sympy.prevprime(q) # q = sympy.nextprime(q) 和前面的q=1配套使用
这样就可以爆破出结果了，不过还有一个问题，就是它没有终止条件。所以，这个时候就要用到（记号1）的flag格式了
# 只需要在 m = long_to_bytes(m).decode('utf-8','ignore')之后的任意位置加一个if判断就行了
if "nsfocus" in m:
break
为了高效的爆出结果，我们肯定是选在两头都跑（1和Q_1）,所以可以加个多线程上去。不过我比较菜，不会多线程，所以我选择开两个文件，嘿嘿，技术不够，脚本来凑。
完整脚本：
import sympy
import gmpy2
from Crypto.Util.number import long_to_bytes
e = 65537
P = [0 for i in range(17)]
P_p = 206027926847308612719677572554991143421
P[9] = P_p
P_factor = 213671742765908980787116579976289600595864704574134469173111790965233629909513884704158446946409910475727584342641848597858942209151114627306286393390259700239698869487469080881267182803062488043469138252786381822646126962323295676431679988602406971858136496624861228526070581338082202663895710929460596143281673761666804565161435963957655012011051936180536581488499059517946308650135300428672486819645279969693519039407892941672784362868653243632727928279698588177694171797254644864554162848696210763681197279758130811723700154618280764123396312330032986093579531909363210692564988076206283296967165522152288770019720928264542910922693728918198338839
n = P[9]
phi = P[9] - 1
for i in range(8,0,-1):
P[i] = sympy.prevprime(P[i+1])
n *= P[i]
phi *= (P[i] - 1)
for i in range(10,17,1):
P[i] = sympy.nextprime(P[i-1])
n *= P[i]
phi *= (P[i] - 1)
d = gmpy2.invert(e,phi)
final_p = pow(P_factor, d, n)
final_p = sympy.nextprime(final_p)
Q_1 = 103766439849465588084625049495793857634556517064563488433148224524638105971161051763127718438062862548184814747601299494052813662851459740127499557785398714481909461631996020048315790167967699932967974484481209879664173009585231469785141628982021847883945871201430155071257803163523612863113967495969578605521
final_q = 1 #final_q = Q_1
Ciphertext = 3456235890998996195610328576070818608212146115114054814560270509307541871219901924317906285783345502450407903297515749909925247057656479099156326718535149969298044687730717978909742604675188350201879798460569721955402966098556911054579289216533244883556427607787129063524341478675272236515424795594246542809803123825660181435151517009926989152291239580046450083599706908982941859840129662960907854690675582551816049328631412344203956716526620975585430081122484860480186571618841845367637670136996691613216081512920967200668918375537812973064141095933513440342389661883780888908448851245758659782134089407794948873910
while True:
n = final_p * final_q
phi = (final_p - 1) * (final_q - 1)
try:
d = gmpy2.invert(e,phi)
m = pow(Ciphertext, d, n)
m = long_to_bytes(m).decode('utf-8',"ignore")
if "nsfocus" in m:
print("m: ",m)
break
except:
pass
final_q = sympy.nextprime(final_q) # final_q = sympy.prevprime(final_q)
其实，这题目就真的是在考数学。一手拓展欧几里得算法求逆元，然后同模余的运算法则。会了这一题，应该算是rsa算法有了初步的认知了。
先上解题代码：
import gmpy2
from gmpy2 import gcd
from Crypto.Util.number import long_to_bytes
n = 17083941230213489700426636484487738282426471494607098847295335339638177583685457921198569105417734668692072727759139358207667248703952436680183153327606147421932365889983347282046439156176685765143620637107347870401946946501620531665573668068349080410807996582297505889946205052879002028936125315312256470583622913646319779125559691270916064588684997382451412747432722966919513413709987353038375477178385125453567111965259721484997156799355617642131569095810304077131053588483057244340742751804935494087687363416921314041547093118565767609667033859583125275322077617576783247853718516166743858265291135353895239981121
gift = 2135492653776686212553329560560967285303308936825887355911916917454772197960682240149821138177216833586509090969892419775958406087994054585022894165950768427741545736247918410255804894522085720642952579638418483800243368312702566458196708508543635051350999572787188236243275631609875253617015664414032058822919469443284453403064076232765024248435543326597418851751586308514540124571309152787559712950209357825576896132278045112177910266019741013995106579484868768251084453338417115483515132869594712162052362083414163954681306259137057581036657441897428432575924018950961141822554251369262248368899977337886190114104
c = 11896048663970780362228781837489466486466282266282525774268696785272105376496162776613405022882264737932390195829622289249358353406571295574018064222013763168773667801755802797093469517945242168621127603773017861402501708822613876791515803039151959944370904767218422806768104905816096919472743978664055791890321098068209891550854674116923626647321385265228978238829509815935768090750750110601100943820432504952197382099637084090991156423394140353352175855468352060270942119322431162691631220150197779269032493785754953460073099974345959080880071039856065496031922388307631138393107747419702153992404456267795192911174
e_orign = 54722
e = 27361
for k in range(1,8):
d = gmpy2.invert(e,k*gift)
m = gmpy2.powmod( c, d, n)
m = gmpy2.iroot(m,2)
m = long_to_bytes(m[0]).decode('utf-8','ignore')
print('m : ',m)
先自己试着去理解一以下把，解析后面再补。我困了。该睡觉了。
4901
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
