BUUCTF Crypto RSA详解《1~32》刷题记录

一、Crypto

1、 一眼就解密

base64解码在线链接：https://www.toolhelper.cn/EncodeDecode/Base64

flag{THE_FLAG_OF_THIS_STRING}

2、MD5

链接：https://www.cmd5.com/default.aspx

flag{admin1}

3、Url编码

链接：https://www.toolhelper.cn/EncodeDecode/Url

flag{and 1=1}

4、看我回旋踢

rot13在线解码链接：https://lzltool.cn/Tools/Rot13

简单分析一下；synt{5pq1004q-86n5-46q8-o720-oro5on0417r1}

1. 直接百度可疑字符：synt编码
2. 看到搜索栏里跳出rot13
3. 在线解密：https://lzltool.cn/Tools/Rot13
4. 得到flag：flag{5cd1004d-86a5-46d8-b720-beb5ba0417e1}

小结：

ROT13（回转13位，rotate by 13 places，有时中间加了个连字符称作ROT-13）是一种简易的替换式密码。
ROT13被描述成“杂志字谜上下颠倒解答的Usenet点对点体”。ROT13 也是过去在古罗马开发的凯撒加密的一种变体。

ROT13特点：

套用ROT13到一段文字上仅仅只需要检查字元字母顺序并取代它在13位之后的对应字母， 有需要超过时则重新绕回26英文字母开头即可。

参考文章：https://blog.csdn.net/weixin_47869330/article/details/110940053

很好很基础的解释推荐大家可以去看看；

flag{5cd1004d-86a5-46d8-b720-beb5ba0417e1}

5、摩丝

链接：https://www.lddgo.net/encrypt/morse

flag{ILOVEYOU}

6、password

小结：flag{姓名首拼小写+出生年月日}

flag{zs19900315}

7、变异凯撒

下载得到；

加密密文：afZ_r9VYfScOeO_UL^RWUc
格式：flag{ }

根据题目名字可知已不是普通的凯撒，对照ASCll码表；

码表链接：https://c.biancheng.net/c/ascii/

发现规律，a移动5位，f移动6位，Z移动7位；
而且又是变异凯撒那就很明显了，就是以此类推每个向后移的位数是前一个加1

脚本：

# 待解密的字符串
a = "afZ_r9VYfScOeO_UL^RWUc"
# 初始偏移量
k = 5

# 遍历待解密的字符串中的每个字符
for i in a:
    # 将字符转换为对应的ASCII值，并增加偏移量k
    # 然后将得到的ASCII值转换回字符并打印出来
    print(chr(ord(i) + k), end='')
    # 处理下一个字符时，偏移量增加1
    k += 1

简单使用python一个for循环即可；

flag{Caesar_variation} 

8、Quoted-printable

链接：https://try8.cn/tool/code/qp

flag{那你也很棒哦}

9、篱笆墙的影子

方法一；

找规律；
f l a g
e h a v

对照写出全部flag{wethinkwehavetheflag}；

方法二；

使用随波逐流工具进行解码，找到最接近的一个秒了；

flag{wethinkwehavetheflag}

10、Rabbit

链接：https://www.sojson.com/encrypt_rabbit.html

无秘钥直接秒；

flag{Cute_Rabbit}

11、RSA

没什么好说的RSA-Tools梭哈，按照图片填入即可；

如果想更多了解RSA请看此文章；

https://blog.csdn.net/m0_51607907/article/details/123884953

工具下载链接；https://www.123pan.com/s/q2J1jv-2Havd.html提取码:0905

flag{125631357777427553}

12、丢失的MD5

补全脚本如下；

import hashlib

# 循环遍历 ASCII 表中可打印字符的可能值
for i in range(32, 127):
    for j in range(32, 127):
        for k in range(32, 127):
            # 创建 md5 哈希对象
            m = hashlib.md5()
            # 构建特定格式的字符串，插入循环变量 i, j, k 对应的字符
            m.update(('TASC' + chr(i) + 'O3RJMV' + chr(j) + 'WDJKX' + chr(k) + 'ZM').encode('utf-8'))
            # 获取哈希值的十六进制表示
            des = m.hexdigest()
            # 检查哈希值是否包含特定的子串
            if 'e9032' in des and 'da' in des and '911513' in des:
                # 如果包含，则打印出来
                print(des)

简单分析一下这个脚本；

这个脚本是一个用于破解特定MD5哈希值的Python程序。它通过穷举ASCII码表中可打印字符的所有可能的三个字符组合，并将这些字符插入到一个预定义的字符串模板中。对于每个生成的字符串，脚本计算其MD5哈希值，并检查该哈希值是否包含特定的子串。如果找到一个哈希值包含所有给定的子串，脚本会将这个哈希值打印出来。

脚本的工作流程如下：

1. 使用三层嵌套循环遍历ASCII码表中的可打印字符（从空格（32）到波浪号（126））。

2. 在每次循环中，构建一个包含循环字符的字符串，按照 'TASC' + chr(i) + 'O3RJMV' + chr(j) + 'WDJKX' + chr(k) + 'ZM' 的格式。

3. 计算构建字符串的MD5哈希值。

4. 检查该哈希值是否包含特定的子串：‘e9032’、‘da’ 和 ‘911513’。

5. 如果哈希值包含所有这些子串，则打印该哈希值。

   flag{e9032994dabac08080091151380478a2}

13、Alice与Bob

根据题已知合数：98554799767

找一个在线网站进行质因数分解；

网站：https://www.imathtool.com/jisuanqi/zhiyinshu/

101999 x 966233

接着将小的放前面，大的放后面，合成一个新的数字，进行md5的32位小写哈希；

链接：https://www.lddgo.net/encrypt/hash

flag{d450209323a847c8d01c6be47c81811a}

14、大帝的密码武器

链接：https://www.lddgo.net/encrypt/caesar-cipher

打开txt根据提示得到一个有意义的单词，在根目题目名称可以得知这是一个凯撒加密；

在偏移13次之后终于得到一个有意义的单词：security（安全）

根据这个单词我们可以得知密文也是13；

flag{PbzrPuvan}

15、rsarsa

import gmpy2
e = 65537
p = 9648423029010515676590551740010426534945737639235739800643989352039852507298491399561035009163427050370107570733633350911691280297777160200625281665378483
q = 11874843837980297032092405848653656852760910154543380907650040190704283358909208578251063047732443992230647903887510065547947313543299303261986053486569407
n = p*q
#密文
C = 83208298995174604174773590298203639360540024871256126892889661345742403314929861939100492666605647316646576486526217457006376842280869728581726746401583705899941768214138742259689334840735633553053887641847651173776251820293087212885670180367406807406765923638973161375817392737747832762751690104423869019034
 
d =gmpy2.invert(e,(p-1)*(q-1))
#求明文
M = pow(C,d,n)    #快速求幂取模运算
print(M)

运行即可flag，更多RSA知识点请转此处；

https://blog.csdn.net/m0_51607907/article/details/123884953

flag{5577446633554466577768879988}

16、Windows系统密码

右键记事本打开；

结合文件名字pass.hash我们可以知道这需要转MD5；

在线：https://www.cmd5.com/default.aspx

最后一个一个尝试得到；

flag{good-luck}

17、信息化时代的步伐

打开txt得到一串数字，根据分析得知：中文电码

解中文电码在线网站：http://code.mcdvisa.com/

flag{计算机要从娃娃抓起}

18、凯撒？替换？呵呵!

MTHJ{CUBCGXGUGXWREXIPOYAOEYFIGXWRXCHTKHFCOHCFDUCGTXZOHIXOEOWMEHZO}

凯撒密码一般就是26个字母经过单纯的按字母顺序来位移的加密方法（一般）
如：abc=def
进阶版的凯撒就不按照字母顺序的加密
如：abc=dhj
所以就要经过暴力破解出每一种可能的对应加密

参考：https://blog.csdn.net/YIHAHUHA/article/details/103108361

所以这里我们直接使用在线网站；

https://quipqiup.com/?spm=a2c6h.12873639.article-detail.8.2dfd471fDXupH4

（注意如有打不开的情况可能是需要开梯子）

注意无空格；

flag{substitutioncipherdecryptionisalwayseasyjustlikeapieceofcake}

19、萌萌哒的八戒

猪圈密码，找个在线解码秒了；

链接：https://www.metools.info/code/c90.html

flag{whenthepigwanttoeat}

20、权限获得第一步

Administrator:500:806EDC27AA52E314AAD3B435B51404EE:F4AD50F57683D4260DFD48AA351A17A8:::

解析；

这行数据是从Windows系统的SAM（安全账户管理器）数据库中提取的一个用户账户的哈希条目。SAM数据库存储了Windows系统中用户的登录凭据，通常以哈希形式保存。这条记录的格式遵循NTLM（NT LAN Manager）哈希的典型表示方式，用于Windows系统的网络协议和密码存储。

这里是这条记录的分解：

• Administrator：这是用户账户的名称，这里指的是系统管理员账户。
• 500：这是用户的安全标识符（SID）的一部分，500通常代表内置的管理员账户。
• 806EDC27AA52E314AAD3B435B51404EE：这是用户密码的LM（LAN Manager）哈希。LM哈希被认为是非常不安全的，因为它将密码转换成大写，分成7字符的块进行哈希，很容易被暴力破解。
• F4AD50F57683D4260DFD48AA351A17A8：这是用户密码的NTLM哈希，它比LM哈希更安全，但现代方法也能有效地破解它。
• :::：这些冒号用作字段分隔符，可能在这个上下文中的其他字段为空。

总的来说，这行数据提供了足够的信息来尝试破解用户的密码，尤其是如果使用像rainbow table这样的工具来对付弱密码。

flag{3617656}

21、传统知识+古典密码

下载附件得到；

既然说是古典加密，那就找一个古典加密表；

这里“+甲子”就是加60；

所以一个一个对照着出来得到：88 90 83 68 77 70 76 90

这里一看就是ASCLL；

解码得到：XZSDMFLZ

开始分析，古典密码最常见的无非栅栏和凯撒,先栅栏一下；

接着我们接着使用栅栏；

链接：https://www.qqxiuzi.cn/bianma/zhalanmima.php

所以；

2栏：
XSMLZDFZ
4栏：
XMZFSLDZ

接着我们对上面的两个结果分别进行恺撒解密：

工具随波逐流；（工具在主页ISCC那篇文章评论区）

最后；

flag{SHUANGYU}

22、RSA1

import gmpy2

# 已知的 RSA 参数
p = 8637633767257008567099653486541091171320491509433615447539162437911244175885667806398411790524083553445158113502227745206205327690939504032994699902053229
q = 12640674973996472769176047937170883420927050821480010581593137135372473880595613737337630629752577346147039284030082593490776630572584959954205336880228469
dp = 6500795702216834621109042351193261530650043841056252930930949663358625016881832840728066026150264693076109354874099841380454881716097778307268116910582929
dq = 783472263673553449019532580386470672380574033551303889137911760438881683674556098098256795673512201963002175438762767516968043599582527539160811120550041
c = 24722305403887382073567316467649080662631552905960229399079107995602154418176056335800638887527614164073530437657085079676157350205351945222989351316076486573599576041978339872265925062764318536089007310270278526159678937431903862892400747915525118983959970607934142974736675784325993445942031372107342103852

# 计算 m1 和 m2
m1 = pow(c, dp, p)
m2 = pow(c, dq, q)

# 计算 q 的逆元 qInv
qInv = gmpy2.invert(q, p)

# 使用 CRT 公式来计算 m
m = (m1 + (qInv * (m2 - m1) % p) * q) % (p*q)

# 将结果转换为十六进制字符串，去除前缀 '0x'
hex_message = hex(m)[2:]

# 将十六进制字符串转换为ASCII文本
text_message = bytes.fromhex(hex_message).decode('ascii')

print(text_message)

简单分析一下；

这段脚本首先进行RSA解密，得到明文的整数表示，然后将这个整数转换为十六进制字符串，最后将十六进制字符串转换为ASCII文本。bytes.fromhex(hex_message).decode('ascii') 这行代码将十六进制字符串转换为对应的文本字符串。这样，text_message 将包含最终的解密文本，可以直接打印出来。

详细：https://blog.csdn.net/m0_51607907/article/details/123884953

最后

flag{W31c0m3_70_Ch1n470wn}

23、世上无难事

注意题目给的关键词：

找到key作为答案提交、flag是32位、包含小写字母；

所以这里我们直接使用Q爆破；

链接：https://quipqiup.com/

（注意需要梯子）

所以这里我们只需要将将 PIO 替换为 key即可；

flag{640E11012805F211B0AB24FF02A1ED09}

发现提交不对，那我们就尝试全部改小写；

发现正确

flag{640e11012805f211b0ab24ff02a1ed09}

24、old-fashion

链接：https://quipqiup.com/

直接使用爆破梭哈即可；

flag{n1_2hen-d3_hu1-mi-ma_a}

25、Unencode

链接：http://www.hiencode.com/uu.html

既然题目名字说了Unencode，那就Unencode解码没什么好说的；

flag{dsdasdsa99877LLLKK}

26、[AFCTF2018]Morse

摩丝链接：http://moersima.00cha.net/

很明显是摩丝解码得到一串十六进制；

61666374667b317327745f73305f333435797d

十六进制转文本链接：https://www.sojson.com/hexadecimal.html

flag{1s't_s0_345y}

27、RSA3

import gmpy2
from Crypto.Util.number import long_to_bytes

# 提供的RSA参数
c1 = 22322035275663237041646893770451933509324701913484303338076210603542612758956262869640822486470121149424485571361007421293675516338822195280313794991136048140918842471219840263536338886250492682739436410013436651161720725855484866690084788721349555662019879081501113222996123305533009325964377798892703161521852805956811219563883312896330156298621674684353919547558127920925706842808914762199011054955816534977675267395009575347820387073483928425066536361482774892370969520740304287456555508933372782327506569010772537497541764311429052216291198932092617792645253901478910801592878203564861118912045464959832566051361

n = 22708078815885011462462049064339185898712439277226831073457888403129378547350292420267016551819052430779004755846649044001024141485283286483130702616057274698473611149508798869706347501931583117632710700787228016480127677393649929530416598686027354216422565934459015161927613607902831542857977859612596282353679327773303727004407262197231586324599181983572622404590354084541788062262164510140605868122410388090174420147752408554129789760902300898046273909007852818474030770699647647363015102118956737673941354217692696044969695308506436573142565573487583507037356944848039864382339216266670673567488871508925311154801

e1 = 11187289

c2 = 18702010045187015556548691642394982835669262147230212731309938675226458555210425972429418449273410535387985931036711854265623905066805665751803269106880746769003478900791099590239513925449748814075904017471585572848473556490565450062664706449128415834787961947266259789785962922238701134079720414228414066193071495304612341052987455615930023536823801499269773357186087452747500840640419365011554421183037505653461286732740983702740822671148045619497667184586123657285604061875653909567822328914065337797733444640351518775487649819978262363617265797982843179630888729407238496650987720428708217115257989007867331698397

e2 = 9647291

# 使用扩展欧几里得算法检查e1和e2是否互质，并计算s和t
# gcd为最大公因数，s和t是满足s*e1 + t*e2 = gcd(e1, e2)的系数
gcd, s, t = gmpy2.gcdext(e1, e2)

# 如果gcd为1，说明e1和e2互质，可以继续共模攻击
if gcd == 1:
    # 如果s是负数，需要取c1的逆元
    if s < 0:
        s = -s
        c1 = gmpy2.invert(c1, n)
    # 如果t是负数，需要取c2的逆元
    if t < 0:
        t = -t
        c2 = gmpy2.invert(c2, n)

    # 根据中国剩余定理计算最终的明文m
    # 这里利用了s和t来组合c1和c2，得到原始消息的模n的一个幂
    m = (pow(c1, s, n) * pow(c2, t, n)) % n
    # 将解密的消息m转换为字节串
    message = long_to_bytes(m)
    print(message)
else:
    # 如果e1和e2不互质，不能使用共模攻击
    print("e1和e2不是互质的，无法使用共模攻击")

简单分析一下；

这个脚本实现了RSA算法中的共模攻击（Common Modulus Attack）。当两个不同的公钥（具有相同的模数n但不同的指数e1和e2）用来加密相同的消息时，如果e1和e2互质，即使没有私钥，也可以恢复出原始消息。这种方法利用了数学上的中国剩余定理（CRT）。

共模攻击的关键点在于找到两个系数s和t，它们满足s_e1 + t_e2 = 1。这个等式表明，可以通过组合两个密文的适当乘方来恢复出原始消息，即使不知道私钥。这种攻击方法突出了在实际应用中，对于同一消息不应使用相同模数n的不同公钥进行加密的重要性。

flag{49d91077a1abcb14f1a9d546c80be9ef}

28、RSA2

关键点；dp泄露

相关解析链接：https://blog.csdn.net/MikeCoke/article/details/106095234

import gmpy2 as gp

e = 65537
n = 248254007851526241177721526698901802985832766176221609612258877371620580060433101538328030305219918697643619814200930679612109885533801335348445023751670478437073055544724280684733298051599167660303645183146161497485358633681492129668802402065797789905550489547645118787266601929429724133167768465309665906113
dp = 905074498052346904643025132879518330691925174573054004621877253318682675055421970943552016695528560364834446303196939207056642927148093290374440210503657

c = 140423670976252696807533673586209400575664282100684119784203527124521188996403826597436883766041879067494280957410201958935737360380801845453829293997433414188838725751796261702622028587211560353362847191060306578510511380965162133472698713063592621028959167072781482562673683090590521214218071160287665180751


for i in range(1,e):                   #在范围(1,e)之间进行遍历
    if(dp*e-1)%i == 0:
        if n%(((dp*e-1)//i)+1) == 0:   #存在p，使得n能被p整除
            p=((dp*e-1)//i)+1
            q=n//(((dp*e-1)//i)+1)
            phi=(q-1)*(p-1)            #欧拉定理
            d=gp.invert(e,phi)         #求模逆
            m=pow(c,d,n)               #快速求幂取模运算
           
print(m)                               #10进制明文
print('------------')
print(hex(m)[2:])                      #16进制明文
print('------------')
print(bytes.fromhex(hex(m)[2:]))       #16进制转文本

参考文章：https://blog.csdn.net/MikeCoke/article/details/105967809

简单分析一下大佬的脚本；

这个脚本是一个更全面的RSA解密过程，它不仅仅尝试直接解密密文，而是首先尝试从已知的公钥参数（e, n）和部分私钥参数（dp）来推导出模数n的质因数p和q。这是通过一个数学技巧实现的，该技巧利用了dp实际上是私钥d模p-1的结果这一事实。通过这种方法，脚本能够在没有直接给出p和q的情况下，重新构建完整的RSA私钥。

脚本的关键步骤和它们的分析：

1. 寻找质因数p和q：脚本通过遍历i的值来尝试找到一个满足(dp * e - 1) % i == 0的i，这是基于dp = d mod (p-1)的性质。如果找到这样的i，那么可以通过p = ((dp * e - 1) // i) + 1来计算出p，进而得到q = n / p。

2. 计算欧拉函数φ(n)：一旦得到p和q，就可以计算φ(n) = (p-1)(q-1)。

3. 计算私钥d：通过求模逆gp.invert(e, phi)来得到私钥d。

4. 解密密文c：使用私钥d来解密密文，m = pow(c, d, n)。

5. 输出：脚本最后输出解密后的明文m的十进制表示、十六进制表示以及转换成字节串的文本表示。

总结而言，这个脚本展示了一种在知道部分私钥信息（如dp）的情况下重建RSA私钥并解密信息的方法。这种方法的成功依赖于能够找到满足特定数学条件的p和q，它揭示了RSA加密机制中的数学原理和潜在的安全考虑。

最后运行得到；

3670434958110785066911905751469631231338751225710158680692616521935747246580688484040488309932916523151997
------------
666c61677b776f775f6c65616b696e675f64705f627265616b735f7273613f5f39383932343734333530327d
------------
b'flag{wow_leaking_dp_breaks_rsa?_98924743502}'

仅供参考，方法不唯一；

29、还原大师

要解决这个问题，我们需要编写一个脚本，该脚本遍历所有可能的大写字母组合，将这些字母填充到神秘字符串的问号部分，然后计算每个可能字符串的MD5哈希值，并与给定的残缺MD5码进行比较。如果哈希值符合给定的模式，则找到了正确的字符串。

脚本：

import hashlib
import itertools

# 给定的字符串模板和残缺的MD5码
template = "TASC?O3RJMV?WDJKX?ZM"
incomplete_md5 = "e903???4dab????08?????51?80??8a?"

# 生成所有可能的大写字母组合
letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
possible_replacements = itertools.product(letters, repeat=template.count('?'))

for replacement in possible_replacements:
    # 构造当前的字符串
    current_str = template
    for ch in replacement:
        current_str = current_str.replace('?', ch, 1)
    
    # 计算当前字符串的MD5哈希值
    current_md5 = hashlib.md5(current_str.encode()).hexdigest()
    
    # 检查当前MD5哈希值是否符合给定的残缺MD5码
    match = True
    for i in range(len(incomplete_md5)):
        if incomplete_md5[i] != '?' and incomplete_md5[i] != current_md5[i]:
            match = False
            break
    
    # 如果找到匹配的MD5码，打印结果并退出循环
    if match:
        print("找到匹配的字符串:", current_str)
        print("完整的MD5码:", current_md5)
        break

简单分析一下这个脚本；

这个脚本首先定义了一个模板字符串和一个残缺的MD5码。然后，它使用itertools.product生成所有可能的大写字母组合，并逐一将这些字母填充到模板字符串的问号部分。对于每个生成的字符串，脚本计算其MD5哈希值，并将这个哈希值与给定的残缺MD5码进行比较。如果找到一个匹配，脚本将打印出找到的字符串和对应的完整MD5码。

最后运行得到；

找到匹配的字符串: TASCJO3RJMVKWDJKXLZM
完整的MD5码: e9032994dabac08080091151380478a2

但是提交发现不对，在仔细观察题目，发现字母都是大写，那我们也尝试把字母全改为大写试试看；

flag{E9032994DABAC08080091151380478A2}

30、异性相吸

参考文章：https://blog.csdn.net/qq_64338708/article/details/131426121

下载得到key、密文，根据题目名字就可以猜测是xor；

因为题目叫“异性”相吸，标题和题目描述都着重强调着“异性”一词，这个词中的“异”代表一种不同的，对立的东西。在计算机的世界里，我们最熟悉的一对相异的东西就是二进制的0和1了。所以我们先将密文和key都转换成二进制的01代码。

这里使用010打开直接转换二进制较为便捷；

转换得到key：

0110000101110011011000010110010001110011011000010111001101100100011000010111001101100100011000010111001101100100011000010111001101100100011000010111001101100100011000010111001101100100011000010111001101100100011000010111001101100100011000010111001101100100011100010111011101100101011100110111000101100110

密文：

0000011100011111000000000000001100001000000001000001001001010101000000110001000001010100010110000100101101011100010110000100101001010110010100110100010001010010000000110100010000000010010110000100011000000110010101000100011100000101010101100100011101010111010001000001001001011101010010100001010000011011

丢给GPT写一个脚本；

脚本条件：

1. 定义密文和密钥的二进制字符串。

2. 确保密钥长度与密文相匹配，如果不匹配，需要截断或重复密钥。

3. 对密文和密钥进行逐位XOR操作。

4. 将XOR操作的结果转换为字节串。

5. 将字节串解码为文本。

    # 给定的二进制密文和密钥
    binary_cipher = "0000011100011111000000000000001100001000000001000001001001010101000000110001000001010100010110000100101101011100010110000100101001010110010100110100010001010010000000110100010000000010010110000100011000000110010101000100011100000101010101100100011101010111010001000001001001011101010010100001010000011011"
    binary_key = "0110000101110011011000010110010001110011011000010111001101100100011000010111001101100100011000010111001101100100011000010111001101100100011000010111001101100100011000010111001101100100011000010111001101100100011000010111001101100100011000010111001101100100011100010111011101100101011100110111000101100110"
    
    # 确保密钥长度与密文相同
    if len(binary_cipher) != len(binary_key):
        print("密文和密钥的长度不匹配！")
    else:
        # 进行XOR操作
        xor_result = int(binary_cipher, 2) ^ int(binary_key, 2)
        # 将XOR结果转换为二进制字符串，去除前缀'0b'
        xor_binary_str = bin(xor_result)[2:].zfill(len(binary_cipher))
        # 将二进制字符串转换为字节串
        xor_bytes = int(xor_binary_str, 2).to_bytes(len(xor_binary_str) // 8, byteorder='big')
        # 将字节串解码为文本
        text = xor_bytes.decode('utf-8')
    
        print("解密后的文本:", text)
   

运行得到；

flag{ea1bc0988992276b7f95b54a7435e89e}

31、RSA

右键选择记事本打开pub.key；

得到

丢进公钥解析；

链接：http://www.hiencode.com/pub_asys.html

得到N，继续丢进factordb进行质因数分解得到pq；

链接：http://factordb.com/index.php?query=8693448229604811919066606200349480058890565601720302561721665405+8378322103517

得到p，q接着我们使用工具RSA Tool2进行计算d值；

条件全部集齐；

直接上脚本求flag

参考文章：https://blog.csdn.net/MikeCoke/article/details/106122531

脚本；

注意装个rsa的库：pip3 install rsa

import rsa

e= 65537
n= 86934482296048119190666062003494800588905656017203025617216654058378322103517
p= 285960468890451637935629440372639283459
q= 304008741604601924494328155975272418463
d= 81176168860169991027846870170527607562179635470395365333547868786951080991441

key = rsa.PrivateKey(n,e,d,q,p)         #在pkcs标准中,pkcs#1规定,私钥包含(n,e,d,p,q)

with open("C:\\Users\\MIKEWYW\\Desktop\\flagenc.txt","rb") as f:  #以二进制读模式，读取密文  
    f = f.read()
    print(rsa.decrypt(f,key))           # f:公钥加密结果  key:私钥

简单分析一下大佬的脚本；

1. 导入rsa模块：这是Python的一个库，用于处理RSA加密和解密。

2. 定义RSA参数：这包括公钥的模数n和指数e，以及私钥的参数d、p、q。在RSA中，n是两个大素数p和q的乘积，e是公钥指数，d是私钥指数。

3. 创建私钥对象：rsa.PrivateKey构造函数用来创建一个私钥对象。根据给出的脚本，参数顺序是(n, e, d, q, p)，但这可能是不正确的，因为通常私钥的参数顺序应该是(n, e, d, p, q)。

4. 读取加密文件：脚本尝试打开一个路径为"C:\\Users\\MIKEWYW\\Desktop\\flagenc.txt"的文件，这个文件应该包含加密的数据。文件以二进制模式打开，这对于加密数据是必要的。

5. 解密操作：使用rsa.decrypt函数和私钥对象对读取的加密数据进行解密。

6. 打印解密结果：脚本将打印解密后的数据。由于解密数据通常是二进制数据，所以直接打印可能不会显示为可读的字符串。

注意如报错：AttributeError: module ‘rsa’ has no attribute ‘PrivateKey’
可能需要检查你安装的rsa模块版本，并确保它是最新的，或者按照模块的文档来使用它。可以通过以下命令安装或更新rsa模块：

pip install rsa --upgrade

如果问题仍然存在，可能需要查找其他的方法来创建私钥对象，或者使用不同的库来处理RSA加密和解密。

最后运行得到；

flag{decrypt_256}

32、RSAROLL

下载得到

题目.txt：

RSA roll！roll！roll！
Only number and a-z
（don’t use editor
which MS provide）

data.txt：

{920139713,19}

704796792
752211152
274704164
18414022
368270835
483295235
263072905
459788476
483295235
459788476
663551792
475206804
459788476
428313374
475206804
459788476
425392137
704796792
458265677
341524652
483295235
534149509
425392137
428313374
425392137
341524652
458265677
263072905
483295235
828509797
341524652
425392137
475206804
428313374
483295235
475206804
459788476
306220148

参考大佬文章：https://blog.csdn.net/xiao__1bai/article/details/123567209

简单分析一下逻辑；

题目中的"roll"或"滚动拼接flag"的意思可能是指，解密出来的每个密文c对应flag的一部分，需要将这些部分按顺序拼接起来，以获得最终的完整flag。
题目给出了多个RSA参数，是为了增加解题的复杂度，或者是每个密文c使用了不同的参数进行加密。在一些更复杂的RSA题目中，可能还会涉及到RSA参数的共享（例如两个不同的公钥共用相同的模数n）。

借一下大佬脚本；

import libnum
from Crypto.Util.number import long_to_bytes

# 密文列表
list1 = [704796792,
752211152,
274704164,
18414022,
368270835,
483295235,
263072905,
459788476,
483295235,
459788476,
663551792,
475206804,
459788476,
428313374,
475206804,
459788476,
425392137,
704796792,
458265677,
341524652,
483295235,
534149509,
425392137,
428313374,
425392137,
341524652,
458265677,
263072905,
483295235,
828509797,
341524652,
425392137,
475206804,
428313374,
483295235,
475206804,
459788476,
306220148
]

# 最终明文字符串初始化为空
flag = ""

# RSA参数
n = 920139713  # 模数
q = 18443      # 质因数之一
p = 49891      # 质因数之一
e = 19         # 公钥指数

# 对每个密文进行解密
for i in list1:
    c = i
    # 计算私钥指数d，即e关于(p-1)*(q-1)的模逆
    d = libnum.invmod(e, (p - 1) * (q - 1))
    # 解密得到明文数字
    m = pow(c, d, n)
    # 将明文数字转换为字节串
    string = long_to_bytes(m)
    # 解码字节串为字符串，并追加到最终明文字符串
    flag += string.decode()

# 打印最终的明文
print(flag)

简单分析一下大佬脚本；

脚本使用了libnum和Crypto.Util.number库来进行RSA解密。它首先定义了一系列的密文数字，然后使用RSA的参数（模数n、质因数p和q、公钥指数e）来计算私钥指数d。接着，对每个密文数字进行解密，将解密后的数字转换为字节串，然后解码为字符串。最后，将所有解码后的字符串拼接起来得到最终的明文。

脚本的主要步骤如下：

1. 导入所需的模块。
2. 定义RSA的参数和密文列表。
3. 对每个密文进行解密：
   • 使用libnum.invmod计算私钥指数d。
   • 使用pow函数进行解密，得到明文数字。
   • 使用long_to_bytes将明文数字转换为字节串。
   • 解码字节串为字符串。
4. 将解码后的字符串拼接，得到完整的明文。

注意！！！
请确保已经安装了libnum和pycryptodome（Crypto.Util.number来自于pycryptodome），如果没有安装，可以使用以下命令安装：

pip install libnum 
pip install pycryptodome

最后运行得到：

flag{13212je2ue28fy71w8u87y31r78eu1e2}