MD5

e00cf25ad42683b3df678c61f42c6bda

思路：如题，MD5

flag{admin1}

Url编码

%66%6c%61%67%7b%61%6e%64%20%31%3d%31%7d

思路：同上，如题，URL编码

flag{and 1=1}

看我回旋踢

synt{5pq1004q-86n5-46q8-o720-oro5on0417r1}

思路：回旋

1

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

一眼就解密

ZmxhZ3tUSEVfRkxBR19PRl9USElTX1NUUklOR30=

思路：base64

flag{THE_FLAG_OF_THIS_STRING}

摩丝

.. .-.. — …- . -.– — ..-

思路：摩斯密码

flag{ILOVEYOU}

变异凯撒

afZ_r9VYfScOeO_UL^RWUc

思路：有特殊符号可能是对应 ascll 码，可能是 ascll码进行移位，加上格式为 flag{}

那么a对应f，移位5；f对应l，移位6；Z对应a，移位7

1
2
3
4
5
6
7
8
#变异凯撒
s="afZ_r9VYfScOeO_UL^RWUc"
res=""
j=5
for i in s:
      res=res+chr(ord(i)+j)
      j=j+1
print(res)

flag{Caesar_variation}

Quoted-printable

=E9=82=A3=E4=BD=A0=E4=B9=9F=E5=BE=88=E6=A3=92=E5=93=A6

思路：Quoted-printable

那你也很棒哦

Rabbit

U2FsdGVkX1/+ydnDPowGbjjJXhZxm2MP2AgI

思路：Rabbit

Cute_Rabbit

RSA

p=473398607161，q=4511491，e=17

思路：基础RSA

1
2
3
4
5
6
7
import gmpy2
p=473398607161
q=4511491
e=17
d=gmpy2.invert（e,（q-1）*（p-1））#求逆元 ed=（1 mod （（p-1）*（q-1）））

print(d)

125631357777427553

篱笆墙的影子

felhaagv{ewtehtehfilnakgw}

思路：篱笆相当于栅栏，栅栏密码

flag{wethinkwehavetheflag}

丢失的MD5

1
2
3
4
5
6
7
8
9
10
import hashlib
for i in range(32,127):
    for j in range(32,127):
        for k in range(32,127):
            m=hashlib.md5()
            m.update('TASC'+chr(i)+'O3RJMV'+chr(j)+'WDJKX'+chr(k)+'ZM')
            des=m.hexdigest()
            if 'e9032' in des and 'da' in des and '911513' in des:
                print(des)

思路：直接跑一遍得到

2

flag{e9032994dabac08080091151380478a2}

Alice与Bob

下面是一个大整数:98554799767,请分解为两个素数，分解后，小的放前面，大的放后面，合成一个新的数字，进行md5的32位小写哈希，提交答案。

思路：分解n factor ， MD5 32位小写哈希

101999 · 966233

flag{d450209323a847c8d01c6be47c81811a}

rsarsa

1
2
3
4
5
6
7
8
9
10
11
12
import gmpy2

p =  9648423029010515676590551740010426534945737639235739800643989352039852507298491399561035009163427050370107570733633350911691280297777160200625281665378483
q =  11874843837980297032092405848653656852760910154543380907650040190704283358909208578251063047732443992230647903887510065547947313543299303261986053486569407
e =  65537
c =  83208298995174604174773590298203639360540024871256126892889661345742403314929861939100492666605647316646576486526217457006376842280869728581726746401583705899941768214138742259689334840735633553053887641847651173776251820293087212885670180367406807406765923638973161375817392737747832762751690104423869019034


n=p*q
s=(p-1)*(q-1)
d=gmpy2.invert(e,s)
print(pow(c,d,n))

flag{5577446633554466577768879988}

windows系统密码

在这里插入图片描述

相关知识拓展 :NTLM协议
解码网站

a7fcb22a88038f35a8f39d503e7f0062

flag{good-luck}

大帝的密码武器

在这里插入图片描述

思路：凯撒 SECURITY

在这里插入图片描述

flag{PbzrPuvan}

传统知识+古典密码

在这里插入图片描述

思路：天干地支（60加字年表）古典密码（栅栏密码（不知道几栏）和凯撒密码）

flag{SHUANGYU}

RSA1

思路：RSA 这个师傅写的贼棒！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import gmpy2
from Crypto.Util.number import *
import binascii
p = 8637633767257008567099653486541091171320491509433615447539162437911244175885667806398411790524083553445158113502227745206205327690939504032994699902053229
q = 12640674973996472769176047937170883420927050821480010581593137135372473880595613737337630629752577346147039284030082593490776630572584959954205336880228469
dp = 6500795702216834621109042351193261530650043841056252930930949663358625016881832840728066026150264693076109354874099841380454881716097778307268116910582929
dq = 783472263673553449019532580386470672380574033551303889137911760438881683674556098098256795673512201963002175438762767516968043599582527539160811120550041
c = 24722305403887382073567316467649080662631552905960229399079107995602154418176056335800638887527614164073530437657085079676157350205351945222989351316076486573599576041978339872265925062764318536089007310270278526159678937431903862892400747915525118983959970607934142974736675784325993445942031372107342103852
InvQ=gmpy2.invert(q,p)
mp=pow(c,dp,p)
mq=pow(c,dq,q)
m=(((mp-mq)*InvQ)%p)*q+mq
flag=long_to_bytes(m)
print(flag)

flag{W31c0m3_70_Ch1n470wn}

信息化时代的步伐

在这里插入图片描述

思路：电报码（中文电报)

在这里插入图片描述

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

凯撒？替换？呵呵！

MTHJ{CUBCGXGUGXWREXIPOYAOEYFIGXWRXCHTKHFCOHCFDUCGTXZOHIXOEOWMEHZO} 注意：得到的 flag 请包上 flag{} 提交，flag{小写字母}

思路：没有顺序的凯撒密码，MTHJ对应FLAG 暴力破解吧
quiqqiuq

在这里插入图片描述

flag{substitutioncipherdecryptionisalwayseasyjustlikeapieceofcake}

old-fashion

在这里插入图片描述

思路：这是一段英文，最后一句很可能是So the flag is XXXXXXX。所以直接quipqiup暴力一下
quiqqiuq

在这里插入图片描述

flag{n1_2hen-d3_hu1-mi-ma_a}

权限获得第一步

在这里插入图片描述

思路：Linux下shadow文件，和前面的windows系统密码是同一类型题
NTLM

F4AD50F57683D4260DFD48AA351A17A8

在这里插入图片描述

flag{3617656}

萌萌哒的八戒

在这里插入图片描述

思路：猪圈密码

在这里插入图片描述

WHENTHEPIGWANTTOEAT
flag{whenthepigwanttoeat}

世上无难事

思路：直接无脑quiqqiuq

在这里插入图片描述

flag{640e11012805f211b0ab24ff02a1ed09}

robomunication

思路：音频摩丝
我其实找到了一个可以直接音频转摩丝的网站，但是我试了一下，准确率并不是很高（没有准确率，因为样本为一，淦）就只能强行听力，然后用audacity分析也可以，但我累

…. . .-.. .-.. — .– …. .- - .. … - …. . -.- . -.– .. - .. … -… — — .–. -… . . .–.

hellowhatisthekeyitisboopbeep

flag{BOOPBEEP}

达芬奇密码

在这里插入图片描述

思路：谷歌查一下《达芬奇密码》，然后发现他里面有涉及一些数字，而这些涉及到的数字是跟斐波那契数列有关的
其中数字列恰好都是斐波那契数列中的数字，因此，猜测隐藏在啊蒙娜丽莎中的数字列是又由斐波那契数列位移得到的，且隐藏数字列与神秘数字串都为32个，因此可以合理猜测隐藏数字列中各数字的原位置就是相应神秘数字串中各数字的原位置

在这里插入图片描述

1
2
3
4
5
6
7
8
9
10
11
12
13
fb = '1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040 1346269 2178309'
t = '1 233 3 2584 1346269 144 5 196418 21 1597 610 377 10946 89 514229 987 8 55 6765 2178309 121393 317811 46368 4181 1 832040 2 28657 75025 34 13 17711 '
m = '36968853882116725547342176952286'
s = 'a' * 32
s = list(s)
fb = fb.split(' ')
t = t.split(' ')


for i in range(32):
    s[fb.index(t[i])] = m[i]
for i in range(32):
    print(s[i], end='')

flag{37995588256861228614165223347687}

还原大师

在这里插入图片描述

TASC?O3RJMV?WDJKX?ZM
E903???4DAB????08?????51?80??8A?

1
2
3
4
5
6
7
8
9
10
11
12
13
import hashlib

s='TASC?O3RJMV?WDJKX?ZM'
for i in range(26):
    temp1=s.replace('?',chr(65+i),1)
    for j in range(26):
        temp2=temp1.replace('?',chr(65+j),1)
        for k in range(26):
            temp3=temp2.replace('?',chr(65+k),1)
            res=hashlib.md5(temp3.encode('utf8')).hexdigest().upper()
            if res[:4]=='E903':
                print(res)

flag{E9032994DABAC08080091151380478A2}

传感器

在这里插入图片描述

思路：有提示1：曼联
谷歌搜一下，曼联全称为曼彻斯特联足球俱乐部，然后密码里有一个曼彻斯特编码，nice，解就完事了
曼彻斯特
差分曼彻斯特

在这里插入图片描述

flag{FFFFFED31F645055F9}

Cipher

在这里插入图片描述

Dncnoqqfliqrpgeklwmppu

思路：公平的玩吧，就是指playfair密码

解码

在这里插入图片描述

Itisnotaproblemhavefun

感觉自己好傻逼啊，这题最开始没仔细弄，然后解密时搞成了加密，我说这怎么不是个句子，还去问了其他师傅，淦

rot

在这里插入图片描述

思路：ROT ，左移或者右移几位

1
2
3
4
5
6
7
8
9
import hashlib
a="83 89 78 84 45 86 96 45 115 121 110 116 136 132 132 132 108 128 117 118 134 110 123 111 110 127 108 112 124 122 108 118 128 108 131 114 127 134 108 116 124 124 113 108 76 76 76 76 138 23 90 81 66 71 64 69 114 65 112 64 66 63 69 61 70 114 62 66 61 62 69 67 70 63 61 110 110 112 64 68 62 70 61 112 111 112"
b=a.split(" ")
flag=""
for j in range(0,26):
    flag=""
    for i in range(len(b)):
        flag+=chr(int(b[i])-j)
    print(flag)

在这里插入图片描述

跑完发现他flag出来个????
不过我们注意到他下面有一个md5，我们可以通过md5还原最后四位

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import hashlib

m='38e4c352809e150186920aac37190cbc'
flag='flag{www_shiyanbar_com_is_very_good_????}'

for i in range(21,127):
    temp1=flag.replace('?',chr(i),1)
    for j in range(21,127):
        temp2=temp1.replace('?',chr(j),1)
        for k in range(21,127):
            temp3=temp2.replace('?',chr(k),1)
            for l in range(21,127):
                temp4=temp3.replace('?',chr(l),1)
                #print(temp4)
                res=hashlib.md5(temp4.encode('utf8')).hexdigest()
                #print(res)
                if(res==m):
                    print(temp4)
                    break

在这里插入图片描述

flag{www_shiyanbar_com_is_very_good_@8Mu}

Unencode

在这里插入图片描述

思路：其实这是我在做rot那题的时候发现的一个blog里面有涉及到xxencode&&uuencode解码，我觉得很像就解了。

解码

flag{dsdasdsa99877LLLKK}

密码学的心声

在这里插入图片描述

在这里插入图片描述

思路：埃塞克码（ascll码），八进制

111 114 157 166 145 123 145 143 165 162 151 164 171 126 145 162 171 115 165 143 150

flag{ILoveSecurityVeryMuch}

这是什么

思路：winhex打开，后面一串奇奇怪怪的[+!+[]]……（JSfuck编码）改成txt

在这里插入图片描述

JSfuck

在这里插入图片描述

flag{a0448fd730b62c13ca80200c4529daa2}

一张谍报

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

思路：前两段就是密文和明文，最后一段要根据前两段之间的关系解出明文

在这里插入图片描述

flag{南天菩萨放鹰捉猴头}

RSA

—–BEGIN PUBLIC KEY—–
MDwwDQYJKoZIhvcNAQEBBQADKwAwKAIhAMAzLFxkrkcYL2wch21CM2kQVFpY9+7+
/AvKr1rzQczdAgMBAAE=
—–END PUBLIC KEY—–
公钥解析

在这里插入图片描述

n=86934482296048119190666062003494800588905656017203025617216654058378322103517
e=65537

factor分解n，得到p，q
RSA tools可以拿到d，python也行

python用这个

d=gmpy2.invert(e,(p-1)*(q-1))

d=81176168860169991027846870170527607562179635470395365333547868786951080991441

1
2
3
4
5
6
7
8
9
10
11
import gmpy2
import rsa
e=65537
n=86934482296048119190666062003494800588905656017203025617216654058378322103517
q=304008741604601924494328155975272418463
p=285960468890451637935629440372639283459
d=81176168860169991027846870170527607562179635470395365333547868786951080991441
key=rsa.PrivateKey(n,e,d,p,q)
f=open("flag.enc","rb+")
fr=f.read()
print(rsa.decrypt(fr,key))

flag{decrypt_256}

RSA2

在这里插入图片描述

思路：n、e、dp、c dp泄露安全

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import gmpy2
import rsa
e = 65537
n = 248254007851526241177721526698901802985832766176221609612258877371620580060433101538328030305219918697643619814200930679612109885533801335348445023751670478437073055544724280684733298051599167660303645183146161497485358633681492129668802402065797789905550489547645118787266601929429724133167768465309665906113
dp = 905074498052346904643025132879518330691925174573054004621877253318682675055421970943552016695528560364834446303196939207056642927148093290374440210503657
c = 140423670976252696807533673586209400575664282100684119784203527124521188996403826597436883766041879067494280957410201958935737360380801845453829293997433414188838725751796261702622028587211560353362847191060306578510511380965162133472698713063592621028959167072781482562673683090590521214218071160287665180751
for i in range(1,e):
    if (dp*e-1)%i==0:
        if n%((dp*e-1)//i+1)==0:
            p=((dp*e-1)//i)+1
q=n//p
phi=(p-1)*(q-1)
d=gmpy2.invert(e,phi)
m=pow(c,d,n)
def n2s(num):
    t = hex(num)[2:]
    if len(t) % 2 == 1:
        t = '0' + t
    return ''.join([chr(int(b, 16)) for b in [t[i:i + 2] for i in range(0, len(t), 2)]])
print(n2s(m))

flag{wow_leaing_dp_breaks_rsa?_98924743502}

RSA3

思路：rsa共模攻击

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import gmpy2
import rsa
def agcd(a,b):
    if a==0:
        return(b,0,1)
    else:
        g,y,x=agcd(b%a,a)
    return (g,x-(b//a)*y,y)
def n2s(num):
    t = hex(num)[2:]
    if len(t) % 2 == 1:
        t = '0' + t
    return ''.join([chr(int(b, 16)) for b in [t[i:i + 2] for i in range(0, len(t), 2)]])
c1=22322035275663237041646893770451933509324701913484303338076210603542612758956262869640822486470121149424485571361007421293675516338822195280313794991136048140918842471219840263536338886250492682739436410013436651161720725855484866690084788721349555662019879081501113222996123305533009325964377798892703161521852805956811219563883312896330156298621674684353919547558127920925706842808914762199011054955816534977675267395009575347820387073483928425066536361482774892370969520740304287456555508933372782327506569010772537497541764311429052216291198932092617792645253901478910801592878203564861118912045464959832566051361
n=22708078815885011462462049064339185898712439277226831073457888403129378547350292420267016551819052430779004755846649044001024141485283286483130702616057274698473611149508798869706347501931583117632710700787228016480127677393649929530416598686027354216422565934459015161927613607902831542857977859612596282353679327773303727004407262197231586324599181983572622404590354084541788062262164510140605868122410388090174420147752408554129789760902300898046273909007852818474030770699647647363015102118956737673941354217692696044969695308506436573142565573487583507037356944848039864382339216266670673567488871508925311154801
e1=11187289
c2=18702010045187015556548691642394982835669262147230212731309938675226458555210425972429418449273410535387985931036711854265623905066805665751803269106880746769003478900791099590239513925449748814075904017471585572848473556490565450062664706449128415834787961947266259789785962922238701134079720414228414066193071495304612341052987455615930023536823801499269773357186087452747500840640419365011554421183037505653461286732740983702740822671148045619497667184586123657285604061875653909567822328914065337797733444640351518775487649819978262363617265797982843179630888729407238496650987720428708217115257989007867331698397
e2=9647291
d=agcd(e1,e2)
d1=d[1]
d2=d[2]
if d1<0:
    d1=-d1
    c1=gmpy2.invert(c1,n)
elif d2<0:
    d2=-d2
    c2=gmpy2.invert(c2,n)
m=pow(c1,d1,n)*pow(c2,d2,n)%n
print (n2s(m))

flag{49d91077a1abcb14f1a9d546c80be9ef}

rsa 2

在这里插入图片描述

思路：明确求d
github上有公开轮子

1
2
3
4
5
6
7
8
import RSAwienerHacker
import hashlib
N = 101991809777553253470276751399264740131157682329252673501792154507006158434432009141995367241962525705950046253400188884658262496534706438791515071885860897552736656899566915731297225817250639873643376310103992170646906557242832893914902053581087502512787303322747780420210884852166586717636559058152544979471
e = 46731919563265721307105180410302518676676135509737992912625092976849075262192092549323082367518264378630543338219025744820916471913696072050291990620486581719410354385121760761374229374847695148230596005409978383369740305816082770283909611956355972181848077519920922059268376958811713365106925235218265173085
d=RSAwienerHacker.hack_RSA(e,N)
print(d)
flag = "flag{" + hashlib.md5(hex(d)).hexdigest() + "}"
print(flag)

Hacked!
8920758995414587152829426558580025657357328745839747693739591820283538307445
flag{47bf28da384590448e0b0d23909a25a4}

RSA5

思路：给了多组n、c和一组e,共用一个m
有点低加密指数广播攻击那味儿了
原理

1
2
3
4
5
6
7
8
9
from gmpy2 import *
n=[n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14,n15,n16,n17,n18,n19]
c=[c0,c1,c2,c3,c4,c5,c6,c7,c8,c9,c10,c11,c12,c13,c14,c15,c16,c17,c18,c19]
for i in range(len(n)):
    for j in range(len(n)):
        if(i!=j):
            if(gcd(n[i],n[j])!=1):
                print(i,j)
            print("p=",gcd(n[i],n[j]))

在这里插入图片描述

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from gmpy2 import*
n4 = 22822039733049388110936778173014765663663303811791283234361230649775805923902173438553927805407463106104699773994158375704033093471761387799852168337898526980521753614307899669015931387819927421875316304591521901592823814417756447695701045846773508629371397013053684553042185725059996791532391626429712416994990889693732805181947970071429309599614973772736556299404246424791660679253884940021728846906344198854779191951739719342908761330661910477119933428550774242910420952496929605686154799487839923424336353747442153571678064520763149793294360787821751703543288696726923909670396821551053048035619499706391118145067
c4 = 15406498580761780108625891878008526815145372096234083936681442225155097299264808624358826686906535594853622687379268969468433072388149786607395396424104318820879443743112358706546753935215756078345959375299650718555759698887852318017597503074317356745122514481807843745626429797861463012940172797612589031686718185390345389295851075279278516147076602270178540690147808314172798987497259330037810328523464851895621851859027823681655934104713689539848047163088666896473665500158179046196538210778897730209572708430067658411755959866033531700460551556380993982706171848970460224304996455600503982223448904878212849412357
p = mpz(132585806383798600305426957307612567604223562626764190211333136246643723811046149337852966828729052476725552361132437370521548707664977123165279305052971868012755509160408641100548744046621516877981864180076497524093201404558036301820216274968638825245150755772559259575544101918590311068466601618472464832499)
q = n4//p
phi = (p-1)*(q-1)
e = 65537
d = invert(e,phi)
m = pow(c4,d,n4)
def n2s(num):
    t = hex(num)[2:]
    if len(t) % 2 == 1:
        t = '0' + t
    return ''.join([chr(int(b, 16)) for b in [t[i:i + 2] for i in range(0, len(t), 2)]])
print(n2s(m))

flag{abdcbe5fd94e23b3de429223ab9c2fdf}

RSAROLL

在这里插入图片描述

思路：把数据进行解密(n、e、c)
n分解：18443 * 49891

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import gmpy2
n=920139713
e=19
p=18443
q=49891
phi=(p-1)*(q-1)
d=gmpy2.invert(e,phi)
s=[]
with open("data.txt","r") as f:
    for i in f.readlines():
        i=i.strip('\n')
        s.append(chr(pow(int(i),d,n)))


    print(s)

flag{13212je2ue28fy71w8u87y31r78eu1e2}

Dangerous RSA

在这里插入图片描述

思路：e=3
很容易联想到低加密指数攻击（e非常小（通常为3））
思路：直接爆破或者低指数广播攻击

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import gmpy2
import libnum
n=0x52d483c27cd806550fbe0e37a61af2e7cf5e0efb723dfc81174c918a27627779b21fa3c851e9e94188eaee3d5cd6f752406a43fbecb53e80836ff1e185d3ccd7782ea846c2e91a7b0808986666e0bdadbfb7bdd65670a589a4d2478e9adcafe97c6ee23614bcb2ecc23580f4d2e3cc1ecfec25c50da4bc754dde6c8bfd8d1fc16956c74d8e9196046a01dc9f3024e11461c294f29d7421140732fedacac97b8fe50999117d27943c953f18c4ff4f8c258d839764078d4b6ef6e8591e0ff5563b31a39e6374d0d41c8c46921c25e5904a817ef8e39e5c9b71225a83269693e0b7e3218fc5e5a1e8412ba16e588b3d6ac536dce39fcdfce81eec79979ea6872793
c=0x10652cdfaa6b63f6d7bd1109da08181e500e5643f5b240a9024bfa84d5f2cac9310562978347bb232d63e7289283871efab83d84ff5a7b64a94a79d34cfbd4ef121723ba1f663e514f83f6f01492b4e13e1bb4296d96ea5a353d3bf2edd2f449c03c4a3e995237985a596908adc741f32365
i=0
def n2s(num):
    t = hex(num)[2:]
    if len(t) % 2 == 1:
        t = '0' + t
    return ''.join([chr(int(b, 16)) for b in [t[i:i + 2] for i in range(0, len(t), 2)]])
while 1:
    res=gmpy2.iroot(c+i*n,3)
    if(res[1]==True):
        print(n2s(res[0]))
        break
    i=i+1

flag{25df8caf006ee5db94d48144c33b2c3b}

SameMod

思路：共膜攻击

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import gmpy2
import rsa
def agcd(a,b):
    if a==0:
        return(b,0,1)
    else:
        g,y,x=agcd(b%a,a)
    return (g,x-(b//a)*y,y)
def n2s(num):
    t = hex(num)[2:]
    if len(t) % 2 == 1:
        t = '0' + t
    return ''.join([chr(int(b, 16)) for b in [t[i:i + 2] for i in range(0, len(t), 2)]])
c1=3453520592723443935451151545245025864232388871721682326408915024349804062041976702364728660682912396903968193981131553111537349
n=6266565720726907265997241358331585417095726146341989755538017122981360742813498401533594757088796536341941659691259323065631249
e1=773
c2=5672818026816293344070119332536629619457163570036305296869053532293105379690793386019065754465292867769521736414170803238309535
e2=839
d=agcd(e1,e2)
d1=d[1]
d2=d[2]
if d1<0:
    d1=-d1
    c1=gmpy2.invert(c1,n)
elif d2<0:
    d2=-d2
    c2=gmpy2.invert(c2,n)
m=pow(c1,d1,n)*pow(c2,d2,n)%n
print (m)

#m=1021089710312311910410111011910111610410511010710511610511511211111511510598108101125

感觉m是ascii 拼接起来的

1
2
3
4
5
6
7
8
9
10
11
12
flag=""
i=0
while i < len(m):
    if m[i]=='1':
        c=chr(int(m[i:i+3]))
        i+=3
    else:
        c=chr(int(m[i:i+2]))
        i+=2
    flag+=c
print(flag)

flag{whenwethinkitispossible}

[AFCTF2018]Morse

思路：摩斯密码

61666374667B317327745F73305F333435797D

错了，继续，试一下16进制转字符

afctf{1s’t_s0_345y}

flag{1s’t_s0_345y}

[NCTF2019]Keyboard

在这里插入图片描述

思路：全部都是键盘上第一行字母，但他应该是要对应其他字母的（就是三个o代表一个字母这类的）然后我就想到了九键，因为所用的字母又刚好是九个，重复的字母也不超过四个，然后根据他在26键上的顺序（q为0开始）推测出 ooo 999 即9键的第9格第三个字母

youaresosmartthatthisisjustapieceofcake

flag{youaresosmartthatthisisjustapieceofcake}

[GXYCTF2019]CheckIn

在这里插入图片描述

思路：base64

1
v)*L*_F0<}@H0>F49023@FE0#@EN

无了，不知道了
谷歌找wp了，哦可能是ROT47加密

在这里插入图片描述

GXY{Y0u_kNow_much_about_Rot}

[HDCTF2019]basic_rsa

1
2
3
4
5
6
7
8
9
10
11
12
13
import gmpy2
from Crypto.Util.number import *
from binascii import a2b_hex,b2a_hex
flag = "*****************"
p = 262248800182277040650192055439906580479
q = 262854994239322828547925595487519915551
e = 65533
n = p*q


c = pow(int(b2a_hex(flag),16),e,n)
print c
# 27565231154623519221597938803435789010285480123476977081867877272451638645710

思路：基本都告诉了，上脚本吧

1
2
3
4
5
6
7
8
9
10
import binascii
import gmpy2
p = 262248800182277040650192055439906580479
q = 262854994239322828547925595487519915551
e =65533
c=31154623519221597938803435789010285480123476977081867877272451638645710
n=p*q
d=gmpy2.invert(e,n)
m=pow(c,d,n)
print(binascii.a2b_hex(str(hex(m))[2:]))

b’flag{B4by_Rs4}’

[HDCTF2019]bbbbbbrsa

enc信息

1
2
3
p = 177077389675257695042507998165006460849
n = 37421829509887796274897162249367329400988647145613325367337968063341372726061
c = ==gMzYDNzIjMxUTNyIzNzIjMyYTM4MDM0gTMwEjNzgTM2UTN4cjNwIjN2QzM5ADMwIDNyMTO4UzM2cTM5kDN2MTOyUTO5YDM0czM3MjM

很明显，c是倒叙输出的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

c = ==gMzYDNzIjMxUTNyIzNzIjMyYTM4MDM0gTMwEjNzgTM2UTN4cjNwIjN2QzM5ADMwIDNyMTO4UzM2cTM5kDN2MTOyUTO5YDM0czM3MjM


from binascii import a2b_hex,b2a_hex
from math import gcd
n = 37421829509887796274897162249367329400988647145613325367337968063341372726061
p = 177077389675257695042507998165006460849
q = n//p
phi = (p-1)*(q-1)
c = 2373740699529364991763589324200093466206785561836101840381622237225512234632
def (dividend, divisor):
    if 0 == divisor:
        return 1, 0, dividend
    x2, y2, remainder = ex_gcd(divisor, dividend % divisor)
    x1 = y2
    y1 = x2 - (dividend // divisor) * y2
    return x1, y1, remainder


for e in range(50000,70001):
    if gcd(e, phi) == 1:
        d=ex_gcd(e, phi)[0]
        d=(d+phi)%phi
        m=pow(c,d,n)
        ss=str(hex(m))[2::1]
        if(len(ss)%2==1):
            continue
        print(a2b_hex(ss))

#b'flag{rs4_1s_s1mpl3!#}'

[GUETCTF2019]BaByRsa

思路：给了p+q，给了(p+1)*(q+1) ，简单的数学解方程，然后就直接基本rsa

(p+1) * (q+1) - 1 - (p+q) ==> p * q

(p+q)^2 - 4 * p * q ==> (p-q)^2 ==> (p-q)

( (p+q) +(p-q) ) //2 ==> p ==>q

exp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import gmpy2
from Crypto.Util.number import *

a=0x1232fecb92adead91613e7d9ae5e36fe6bb765317d6ed38ad890b4073539a6231a6620584cea5730b5af83a3e80cf30141282c97be4400e33307573af6b25e2ea
b=0x5248becef1d925d45705a7302700d6a0ffe5877fddf9451a9c1181c4d82365806085fd86fbaab08b6fc66a967b2566d743c626547203b34ea3fdb1bc06dd3bb765fd8b919e3bd2cb15bc175c9498f9d9a0e216c2dde64d81255fa4c05a1ee619fc1fc505285a239e7bc655ec6605d9693078b800ee80931a7a0c84f33c851740
b=b-1-a
b=a*a-4*b
b=gmpy2.iroot(b,2)
print(b)
#1206891232933127609602305376568189465889344728862289868280806218010788124535506961228475050631464152684668039452227906087408687149299374586097705822467212
b=1206891232933127609602305376568189465889344728862289868280806218010788124535506961228475050631464152684668039452227906087408687149299374586097705822467212
p=(a+b)//2
q=a-p
n=p*q
phi=(p-1)*(q-1)
e=0xe6b1bee47bd63f615c7d0a43c529d219
d=0x2dde7fbaed477f6d62838d55b0d0964868cf6efb2c282a5f13e6008ce7317a24cb57aec49ef0d738919f47cdcd9677cd52ac2293ec5938aa198f962678b5cd0da344453f521a69b2ac03647cdd8339f4e38cec452d54e60698833d67f9315c02ddaa4c79ebaa902c605d7bda32ce970541b2d9a17d62b52df813b2fb0c5ab1a5
enc_flag=0x50ae00623211ba6089ddfae21e204ab616f6c9d294e913550af3d66e85d0c0693ed53ed55c46d8cca1d7c2ad44839030df26b70f22a8567171a759b76fe5f07b3c5a6ec89117ed0a36c0950956b9cde880c575737f779143f921d745ac3bb0e379c05d9a3cc6bf0bea8aa91e4d5e752c7eb46b2e023edbc07d24a7c460a34a9a

flag=pow(enc_flag,d,n)
print(long_to_bytes(flag))

flag{cc7490e-78ab-11e9-b422-8ba97e5da1fd}

[NCTF2019]childRSA

源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
from random import choice
from Crypto.Util.number import isPrime, sieve_base as primes
from flag import flag


def getPrime(bits):
    while True:
        n = 2
        while n.bit_length() < bits:
            n *= choice(primes)
        if isPrime(n + 1):
            return n + 1

e = 0x10001
m = int.from_bytes(flag.encode(), 'big')
p, q = [getPrime(2048) for _ in range(2)]
n = p * q
c = pow(m, e, n)

# n = 32849718197337581823002243717057659218502519004386996660885100592872201948834155543125924395614928962750579667346279456710633774501407292473006312537723894221717638059058796679686953564471994009285384798450493756900459225040360430847240975678450171551048783818642467506711424027848778367427338647282428667393241157151675410661015044633282064056800913282016363415202171926089293431012379261585078566301060173689328363696699811123592090204578098276704877408688525618732848817623879899628629300385790344366046641825507767709276622692835393219811283244303899850483748651722336996164724553364097066493953127153066970594638491950199605713033004684970381605908909693802373826516622872100822213645899846325022476318425889580091613323747640467299866189070780620292627043349618839126919699862580579994887507733838561768581933029077488033326056066378869170169389819542928899483936705521710423905128732013121538495096959944889076705471928490092476616709838980562233255542325528398956185421193665359897664110835645928646616337700617883946369110702443135980068553511927115723157704586595844927607636003501038871748639417378062348085980873502535098755568810971926925447913858894180171498580131088992227637341857123607600275137768132347158657063692388249513
# c = 26308018356739853895382240109968894175166731283702927002165268998773708335216338997058314157717147131083296551313334042509806229853341488461087009955203854253313827608275460592785607739091992591431080342664081962030557042784864074533380701014585315663218783130162376176094773010478159362434331787279303302718098735574605469803801873109982473258207444342330633191849040553550708886593340770753064322410889048135425025715982196600650740987076486540674090923181664281515197679745907830107684777248532278645343716263686014941081417914622724906314960249945105011301731247324601620886782967217339340393853616450077105125391982689986178342417223392217085276465471102737594719932347242482670320801063191869471318313514407997326350065187904154229557706351355052446027159972546737213451422978211055778164578782156428466626894026103053360431281644645515155471301826844754338802352846095293421718249819728205538534652212984831283642472071669494851823123552827380737798609829706225744376667082534026874483482483127491533474306552210039386256062116345785870668331513725792053302188276682550672663353937781055621860101624242216671635824311412793495965628876036344731733142759495348248970313655381407241457118743532311394697763283681852908564387282605279108

思路：源码就是一个rsa加密，p，q就是自己写的一个随机数生成，2048位，感觉位数很大，很难分解，但是不要慌，我们先用yaf试一下

image-20201108210236474

image-20201108210257313

nnnnnnnice！！yafu强死了！

这我们就分解出来p，q了

exp

1
2
3
4
5
6
7
8
9
10
11
import gmpy2
from Crypto.Util.number import *
c = 26308018356739853895382240109968894175166731283702927002165268998773708335216338997058314157717147131083296551313334042509806229853341488461087009955203854253313827608275460592785607739091992591431080342664081962030557042784864074533380701014585315663218783130162376176094773010478159362434331787279303302718098735574605469803801873109982473258207444342330633191849040553550708886593340770753064322410889048135425025715982196600650740987076486540674090923181664281515197679745907830107684777248532278645343716263686014941081417914622724906314960249945105011301731247324601620886782967217339340393853616450077105125391982689986178342417223392217085276465471102737594719932347242482670320801063191869471318313514407997326350065187904154229557706351355052446027159972546737213451422978211055778164578782156428466626894026103053360431281644645515155471301826844754338802352846095293421718249819728205538534652212984831283642472071669494851823123552827380737798609829706225744376667082534026874483482483127491533474306552210039386256062116345785870668331513725792053302188276682550672663353937781055621860101624242216671635824311412793495965628876036344731733142759495348248970313655381407241457118743532311394697763283681852908564387282605279108
p = 178449493212694205742332078583256205058672290603652616240227340638730811945224947826121772642204629335108873832781921390308501763661154638696935732709724016546955977529088135995838497476350749621442719690722226913635772410880516639651363626821442456779009699333452616953193799328647446968707045304702547915799734431818800374360377292309248361548868909066895474518333089446581763425755389837072166970684877011663234978631869703859541876049132713490090720408351108387971577438951727337962368478059295446047962510687695047494480605473377173021467764495541590394732685140829152761532035790187269724703444386838656193674253139
q = 184084121540115307597161367011014142898823526027674354555037785878481711602257307508985022577801782788769786800015984410443717799994642236194840684557538917849420967360121509675348296203886340264385224150964642958965438801864306187503790100281099130863977710204660546799128755418521327290719635075221585824217487386227004673527292281536221958961760681032293340099395863194031788435142296085219594866635192464353365034089592414809332183882423461536123972873871477755949082223830049594561329457349537703926325152949582123419049073013144325689632055433283354999265193117288252918515308767016885678802217366700376654365502867
n = p*q
phi=(p-1)*(q-1)
e = 0x10001
d = gmpy2.invert(e,phi)
flag=pow(c,d,n)
print(long_to_bytes(flag))

image-20201108210827482

NCTF{Th3r3_ar3_1ns3cure_RSA_m0duli_7hat_at_f1rst_gl4nce_appe4r_t0_be_s3cur3}

[WUSTCTF2020]佛说：只能四天

1
2
3
4
5
尊即寂修我劫修如婆愍闍嚤婆莊愍耨羅嚴是喼婆斯吶眾喼修迦慧迦嚩喼斯願嚤摩隸所迦摩吽即塞願修咒莊波斯訶喃壽祗僧若即亦嘇蜜迦須色喼羅囉咒諦若陀喃慧愍夷羅波若劫蜜斯哆咒塞隸蜜波哆咤慧聞亦吽念彌諸嘚嚴諦咒陀叻咤叻諦缽隸祗婆諦嚩阿兜宣囉吽色缽吶諸劫婆咤咤喼愍尊寂色缽嘚闍兜阿婆若叻般壽聞彌即念若降宣空陀壽愍嚤亦喼寂僧迦色莊壽吽哆尊僧喼喃壽嘚兜我空所吶般所即諸吽薩咤諸莊囉隸般咤色空咤亦喃亦色兜哆嘇亦隸空闍修眾哆咒婆菩迦壽薩塞宣嚩缽寂夷摩所修囉菩阿伏嘚宣嚩薩塞菩波吶波菩哆若慧愍蜜訶壽色咒兜摩缽摩諦劫諸陀即壽所波咤聞如訶摩壽宣咤彌即嚩蜜叻劫嘇缽所摩闍壽波壽劫修訶如嚩嘇囉薩色嚤薩壽修闍夷闍是壽僧劫祗蜜嚴嚩我若空伏諦念降若心吽咤隸嘚耨缽伏吽色寂喃喼吽壽夷若心眾祗喃慧嚴即聞空僧須夷嚴叻心願哆波隸塞吶心須嘇摩咤壽嘚吶夷亦心亦喃若咒壽亦壽囑囑

圣经分为《旧约全书》和《新约全书》
1.虽然有点不环保，但hint好像是一次性的，得到后就没有利用价值了。
2.凯撒不是最后一步，by the way，凯撒为什么叫做凯撒？

思路：与佛论禅解不出，就用新与佛论禅 ，解出来是社会主义核心编码，解出来的编码后面有提示fence，是栅栏密码，栏数为4(去掉提示再栅栏)，然后末尾提示凯撒密码，然后提示凯撒不是最后一步，那就是还有个编码，是base32

1
2
3
4
5
6
7
8
9
平等文明自由友善公正自由诚信富强自由自由平等民主平等自由自由友善敬业平等公正平等富强平等自由平等民主和谐公正自由诚信平等和谐公正公正自由法治平等法治法治法治和谐和谐平等自由和谐自由自由和谐公正自由敬业自由文明和谐平等自由文明和谐平等和谐文明自由和谐自由和谐和谐平等和谐法治公正诚信平等公正诚信民主自由和谐公正民主平等平等平等平等自由和谐和谐和谐平等和谐自由诚信平等和谐自由自由友善敬业平等和谐自由友善敬业平等法治自由法治和谐和谐自由友善公正法治敬业公正友善爱国公正民主法治文明自由民主平等公正自由法治平等文明平等友善自由平等和谐自由友善自由平等文明自由民主自由平等平等敬业自由平等平等诚信富强平等友善敬业公正诚信平等公正友善敬业公正平等平等诚信平等公正自由公正诚信平等法治敬业公正诚信平等法治平等公正友善平等公正诚信自由公正友善敬业法治法治公正公正公正平等公正诚信自由公正和谐公正平等

 RLJDQTOVPTQ6O6duws5CD6IB5B52CC57okCaUUC3SO4OSOWG3LynarAVGRZSJRAEYEZ_ooe_doyouknowfence

R5UALCUVJDCGD63RQISZTBOSO54JVBORP5SAT2OEQCWY6CGEO53Z67L_doyouknowCaesar

O5RXIZRSGAZDA63ONFPWQYLPL54GSYLOM5PXQ2LBNZTV6ZDBL53W67I

wctf2020{ni_hao_xiang_xiang_da_wo}

[ACTF新生赛2020]crypto-rsa0

怎么办呢，出题人也太坏了，竟然把压缩包给伪加密了！

思路：winhex打开，修改加密位就行，然后解压缩得到py和output，就是简单rsa

image-20201108214453557

exp

1
2
3
4
5
6
7
8
9
10
11
import gmpy2
from Crypto.Util.number import *
p = 9018588066434206377240277162476739271386240173088676526295315163990968347022922841299128274551482926490908399237153883494964743436193853978459947060210411
q = 7547005673877738257835729760037765213340036696350766324229143613179932145122130685778504062410137043635958208805698698169847293520149572605026492751740223
c = 50996206925961019415256003394743594106061473865032792073035954925875056079762626648452348856255575840166640519334862690063949316515750256545937498213476286637455803452890781264446030732369871044870359838568618176586206041055000297981733272816089806014400846392307742065559331874972274844992047849472203390350
n = p*q
phi=(p-1)*(q-1)
e = 65537
d = gmpy2.invert(e,phi)
flag=pow(c,d,n)
print(long_to_bytes(flag))

actf{n0w_y0u_see_RSA}

yxx

image-20201108215037048

思路：除了yxx 啥也没有，谷歌也搜不到，我是用中文打yxx时打成了yxxx，然后就异性相吸，然后就想起了异或，giao！很想知道其他师傅是怎样想到xor的，淦，我真误打误撞，要是比赛的时候也误打误撞就好了，我做梦能笑醒！hhhhhh~

1
2
3
4
5
6
a="lovelovelovelovelovelovelovelove"
b=[0x0A,0x03,0x17,0x02,0x56,0x01,0x15,0x11,0x0A,0x14,0x0E,0x0A,0x1E,0x30,0x0E,0x0A,0x1E,0x30,0x0E,0x0A,0x1E,0x30,0x14,0x0C,0x19,0x0D,0x1F,0x10,0x0E,0x06,0x03,0x18]
flag=""
for i in range(len(a)):
    flag+=chr(ord(a[i])^b[i])
print(flag)

flag:nctf{xor_xor_xor_biubiubiu}

[AFCTF2018]Vigenère

思路：直接vigenere

afctf{Whooooooo_U_Gotcha!}

[GWCTF 2019]BabyRSA

源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import hashlib
import sympy
from Crypto.Util.number import *

flag = 'GWHT{******}'
secret = '******'

assert(len(flag) == 38)

half = len(flag) / 2

flag1 = flag[:half]
flag2 = flag[half:]

secret_num = getPrime(1024) * bytes_to_long(secret)

p = sympy.nextprime(secret_num)
q = sympy.nextprime(p)

N = p * q

e = 0x10001

F1 = bytes_to_long(flag1)
F2 = bytes_to_long(flag2)

c1 = F1 + F2
c2 = pow(F1, 3) + pow(F2, 3)
assert(c2 < N)

m1 = pow(c1, e, N)
m2 = pow(c2, e, N)

output = open('secret', 'w')
output.write('N=' + str(N) + '\n')
output.write('m1=' + str(m1) + '\n')
output.write('m2=' + str(m2) + '\n')
output.close()

思路：RSA，分解 N拿到p、q，然后就可以拿到c1、c2，然后就是解方程

c1=f1+f2

c2=f1^3 + f2^3

EXP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import gmpy2
from z3 import *
import sympy
from Crypto.Util.number import*
p = 797862863902421984951231350430312260517773269684958456342860983236184129602390919026048496119757187702076499551310794177917920137646835888862706126924088411570997141257159563952725882214181185531209186972351469946269508511312863779123205322378452194261217016552527754513215520329499967108196968833163329724620251096080377748737
q = 797862863902421984951231350430312260517773269684958456342860983236184129602390919026048496119757187702076499551310794177917920137646835888862706126924088411570997141257159563952725882214181185531209186972351469946269508511312863779123205322378452194261217016552527754513215520329499967108196968833163329724620251096080377747699
e = 0x10001
n = 636585149594574746909030160182690866222909256464847291783000651837227921337237899651287943597773270944384034858925295744880727101606841413640006527614873110651410155893776548737823152943797884729130149758279127430044739254000426610922834573094957082589539445610828279428814524313491262061930512829074466232633130599104490893572093943832740301809630847541592548921200288222432789208650949937638303429456468889100192613859073752923812454212239908948930178355331390933536771065791817643978763045030833712326162883810638120029378337092938662174119747687899484603628344079493556601422498405360731958162719296160584042671057160241284852522913676264596201906163
m1=90009974341452243216986938028371257528604943208941176518717463554774967878152694586469377765296113165659498726012712288670458884373971419842750929287658640266219686646956929872115782173093979742958745121671928568709468526098715927189829600497283118051641107305128852697032053368115181216069626606165503465125725204875578701237789292966211824002761481815276666236869005129138862782476859103086726091860497614883282949955023222414333243193268564781621699870412557822404381213804026685831221430728290755597819259339616650158674713248841654338515199405532003173732520457813901170264713085107077001478083341339002069870585378257051150217511755761491021553239
m2=487443985757405173426628188375657117604235507936967522993257972108872283698305238454465723214226871414276788912058186197039821242912736742824080627680971802511206914394672159240206910735850651999316100014691067295708138639363203596244693995562780286637116394738250774129759021080197323724805414668042318806010652814405078769738548913675466181551005527065309515364950610137206393257148357659666687091662749848560225453826362271704292692847596339533229088038820532086109421158575841077601268713175097874083536249006018948789413238783922845633494023608865256071962856581229890043896939025613600564283391329331452199062858930374565991634191495137939574539546
phi=(p-1)*(q-1)
d=gmpy2.invert(e,phi)
c1=pow(m1,d,n)
c2=pow(m2,d,n)
print(c1,c2)
#c1=2732509502629189160482346120094198557857912754
#5514544075236012543362261483183657422998274674127032311399076783844902086865451355210243586349132992563718009577051164928513093068525554

a=3*c1
b=-3*pow(c1,2)
c=pow(c1,3)-c2
delta=gmpy2.iroot(pow(b,2)-4*a*c,2)[0]
F2=(-b+delta)//(2*a)
F1=c1-F2

print(long_to_bytes(F2)+long_to_bytes(F1))

GWHT{f709e0e2cfe7e530ca8972959a1033b2}

其他

1
2
3
4
5
6
7
8
9
F1 = sympy.Symbol('F1')#方程组定义变量
F2 = sympy.Symbol('F2')
f1 = F1+F2-c1
f2 = pow(F1,3)+pow(F2,3)-c2
result = sympy.solve([f1,f2],[F1,F2])

flag1 = long_to_bytes(result[0][1])
flag2 = long_to_bytes(result[0][0])
flag  = flag1 + flag2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from z3 import *
 
s = Solver()
 
flag1 = Int('flag1')
flag2 = Int('flag2')
 
s.add(flag1 + flag2 == 2732509502629189160482346120094198557857912754)
s.add(pow(flag1,3)+pow(flag2,3) ==5514544075236012543362261483183657422998274674127032311399076783844902086865451355210243586349132992563718009577051164928513093068525554)
 
if s.check() == sat:
    print s.model()
 
 
print hex(1590956290598033029862556611630426044507841845)[2:-1].decode('hex')+hex(1141553212031156130619789508463772513350070909)[2:-1].decode('hex')

另，sympy真好用~~

[NCTF2019]babyRSA

源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
from Crypto.Util.number import *
from flag import flag

def nextPrime(n):
    n += 2 if n & 1 else 1
    while not isPrime(n):
        n += 2
    return n

p = getPrime(1024)
q = nextPrime(p)
n = p * q
e = 0x10001
d = inverse(e, (p-1) * (q-1))
c = pow(bytes_to_long(flag.encode()), e, n)

# d = 19275778946037899718035455438175509175723911466127462154506916564101519923603308900331427601983476886255849200332374081996442976307058597390881168155862238533018621944733299208108185814179466844504468163200369996564265921022888670062554504758512453217434777820468049494313818291727050400752551716550403647148197148884408264686846693842118387217753516963449753809860354047619256787869400297858568139700396567519469825398575103885487624463424429913017729585620877168171603444111464692841379661112075123399343270610272287865200880398193573260848268633461983435015031227070217852728240847398084414687146397303110709214913
# c = 5382723168073828110696168558294206681757991149022777821127563301413483223874527233300721180839298617076705685041174247415826157096583055069337393987892262764211225227035880754417457056723909135525244957935906902665679777101130111392780237502928656225705262431431953003520093932924375902111280077255205118217436744112064069429678632923259898627997145803892753989255615273140300021040654505901442787810653626524305706316663169341797205752938755590056568986738227803487467274114398257187962140796551136220532809687606867385639367743705527511680719955380746377631156468689844150878381460560990755652899449340045313521804

思路：源码告诉我们e，d，c，然后我们需要求p、q（即n），源码中p、q都是1024位的，相乘后的n至少2048位，

我们知道 ed = 1 % (p-1)*(q-1) ，经过计算我们可以得到ed-1的位数为2064位，那么我们就可以知道k是小于16位的。位数并不大，我们可以对他进行爆破，得到p、q。

exp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
from Crypto.Util.number import *

e = 0x10001
d = 19275778946037899718035455438175509175723911466127462154506916564101519923603308900331427601983476886255849200332374081996442976307058597390881168155862238533018621944733299208108185814179466844504468163200369996564265921022888670062554504758512453217434777820468049494313818291727050400752551716550403647148197148884408264686846693842118387217753516963449753809860354047619256787869400297858568139700396567519469825398575103885487624463424429913017729585620877168171603444111464692841379661112075123399343270610272287865200880398193573260848268633461983435015031227070217852728240847398084414687146397303110709214913
c = 5382723168073828110696168558294206681757991149022777821127563301413483223874527233300721180839298617076705685041174247415826157096583055069337393987892262764211225227035880754417457056723909135525244957935906902665679777101130111392780237502928656225705262431431953003520093932924375902111280077255205118217436744112064069429678632923259898627997145803892753989255615273140300021040654505901442787810653626524305706316663169341797205752938755590056568986738227803487467274114398257187962140796551136220532809687606867385639367743705527511680719955380746377631156468689844150878381460560990755652899449340045313521804

import sympy.crypto
import gmpy2

a=e*d-1
p=0
q=0
for k in range(pow(2,15),pow(2,16)):
    if a%k==0:
        p=sympy.prevprime(gmpy2.iroot(a//k,2)[0])
        q=sympy.nextprime(p)
        if (p-1)*(q-1)*k==a:
            break
n=p*q
print(n)
m=pow(c,d,n)
print(m)
print(long_to_bytes(m))

NCTF{70u2_nn47h_14_v3ry_gOO0000000d}

[NPUCTF2020]这是什么觅码

flag

思路：底部 F1 W1 S22 S21 T12 S11 W1 S13，前面的字母是指星期，由于S、T开头的星期有两个，所以按照先后知道T1=TUE，T2=THU，S1=SAT，S2=SYN，从日历中找相应数字3 1 12 5 14 4 1 18，相应的对应26个字母得calendar

flag{calendar}

[WUSTCTF2020]babyrsa

c = 28767758880940662779934612526152562406674613203406706867456395986985664083182
n = 73069886771625642807435783661014062604264768481735145873508846925735521695159
e = 65537

思路：基本RSA , factor.com可以直接分解n

exp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
from Crypto.Util.number import *

c = 28767758880940662779934612526152562406674613203406706867456395986985664083182
n = 73069886771625642807435783661014062604264768481735145873508846925735521695159
e = 65537
p=189239861511125143212536989589123569301
q=386123125371923651191219869811293586459

import gmpy2
d=gmpy2.invert(e,(p-1)*(q-1))
m=pow(c,d,n)
print(m)
print(long_to_bytes(m))

b’wctf2020{just_@_piece_0f_cak3}’

RSA4

1
2
3
4
5
6
7
8
N = 331310324212000030020214312244232222400142410423413104441140203003243002104333214202031202212403400220031202142322434104143104244241214204444443323000244130122022422310201104411044030113302323014101331214303223312402430402404413033243132101010422240133122211400434023222214231402403403200012221023341333340042343122302113410210110221233241303024431330001303404020104442443120130000334110042432010203401440404010003442001223042211442001413004 
c = 310020004234033304244200421414413320341301002123030311202340222410301423440312412440240244110200112141140201224032402232131204213012303204422003300004011434102141321223311243242010014140422411342304322201241112402132203101131221223004022003120002110230023341143201404311340311134230140231412201333333142402423134333211302102413111111424430032440123340034044314223400401224111323000242234420441240411021023100222003123214343030122032301042243

N = 302240000040421410144422133334143140011011044322223144412002220243001141141114123223331331304421113021231204322233120121444434210041232214144413244434424302311222143224402302432102242132244032010020113224011121043232143221203424243134044314022212024343100042342002432331144300214212414033414120004344211330224020301223033334324244031204240122301242232011303211220044222411134403012132420311110302442344021122101224411230002203344140143044114 
c = 112200203404013430330214124004404423210041321043000303233141423344144222343401042200334033203124030011440014210112103234440312134032123400444344144233020130110134042102220302002413321102022414130443041144240310121020100310104334204234412411424420321211112232031121330310333414423433343322024400121200333330432223421433344122023012440013041401423202210124024431040013414313121123433424113113414422043330422002314144111134142044333404112240344

N = 332200324410041111434222123043121331442103233332422341041340412034230003314420311333101344231212130200312041044324431141033004333110021013020140020011222012300020041342040004002220210223122111314112124333211132230332124022423141214031303144444134403024420111423244424030030003340213032121303213343020401304243330001314023030121034113334404440421242240113103203013341231330004332040302440011324004130324034323430143102401440130242321424020323 
c = 10013444120141130322433204124002242224332334011124210012440241402342100410331131441303242011002101323040403311120421304422222200324402244243322422444414043342130111111330022213203030324422101133032212042042243101434342203204121042113212104212423330331134311311114143200011240002111312122234340003403312040401043021433112031334324322123304112340014030132021432101130211241134422413442312013042141212003102211300321404043012124332013240431242

思路：txt给的数据有点不对劲，发现是5进制的数据，转一下进制，然后就是RSA广播攻击

1
2
3
4
5
6
7
8
9
10
11
N = 645571152526781668485594972550107069575255441127852655215134587752257907823674761543257833618924906619502017130555282685925055966163016480560608218713456781999964849490054138554971754017474595759742118662132957994442198564601721331028207376741563636829858586527045638336958913389271098445317748797982148583144
c = 
112820376318708309511883266356668393396816131447182791445506209031700236878469506355658352414748854472099361508824474365112325602319862842561436679067358900089331778617100580343694334226208753320435002324108477884950933641216044198203776075918323272795752182687450526442079367110656868374931125538339145721573

N =
109269702205029292120022054633721536134438763741801805368759852020529400112797868566931991813909053016228871499067304592740926931055426540840268677218282537450757063806695831503892336975370479004151114020279110611956433492281834217463178735931660370487895538198474855043942908224106013915984721193047940206159
c = 45651293556966072304818630107703140982560165499022836594523320391474750266281527820821435052904791681898782443840766880327957385288649094238886877657228597671521358830021677304123300882210216797719566693160533018601632768048713030788957904378243453859832229603157052843135978639276611231634399594108602071349

N =
650924921034539366628943040335666300053344128720548929948773504346988568447254537130029347276930498912807651236193443235443419268444634453191995435549914833119001323314233615708933927657562263689125661997479199874874420611354737718422688024450888314035068200512748747969830525665558140563712363153927850709814
c = 7145575537980676074780210417817024536632595547590648616669010213946256431795860784357127920679439181517662499063976244238924613193503273987203026894830988537974932336129245277788828190575305229420617551083516420170192425247732269483299819348769856966536443995217830327641185916042049253075074223777360483322

exp：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import gmpy2
import time
import sympy
from functools import reduce 
from Crypto.Util.number import long_to_bytes
 
def CRT(n,a):
    res=0
    N = reduce(lambda x, y: x * y, n)
    for _n,_a in zip(n,a):
        m = N // _n
        res += _a * sympy.invert(m, _n)  * m
    return int( res % N)

n1 = int(str(331310324212000030020214312244232222400142410423413104441140203003243002104333214202031202212403400220031202142322434104143104244241214204444443323000244130122022422310201104411044030113302323014101331214303223312402430402404413033243132101010422240133122211400434023222214231402403403200012221023341333340042343122302113410210110221233241303024431330001303404020104442443120130000334110042432010203401440404010003442001223042211442001413004),5)
c1 = int(str(310020004234033304244200421414413320341301002123030311202340222410301423440312412440240244110200112141140201224032402232131204213012303204422003300004011434102141321223311243242010014140422411342304322201241112402132203101131221223004022003120002110230023341143201404311340311134230140231412201333333142402423134333211302102413111111424430032440123340034044314223400401224111323000242234420441240411021023100222003123214343030122032301042243),5)

n2 = int(str(302240000040421410144422133334143140011011044322223144412002220243001141141114123223331331304421113021231204322233120121444434210041232214144413244434424302311222143224402302432102242132244032010020113224011121043232143221203424243134044314022212024343100042342002432331144300214212414033414120004344211330224020301223033334324244031204240122301242232011303211220044222411134403012132420311110302442344021122101224411230002203344140143044114),5)
c2 = int(str(112200203404013430330214124004404423210041321043000303233141423344144222343401042200334033203124030011440014210112103234440312134032123400444344144233020130110134042102220302002413321102022414130443041144240310121020100310104334204234412411424420321211112232031121330310333414423433343322024400121200333330432223421433344122023012440013041401423202210124024431040013414313121123433424113113414422043330422002314144111134142044333404112240344),5)

n3 = int(str(332200324410041111434222123043121331442103233332422341041340412034230003314420311333101344231212130200312041044324431141033004333110021013020140020011222012300020041342040004002220210223122111314112124333211132230332124022423141214031303144444134403024420111423244424030030003340213032121303213343020401304243330001314023030121034113334404440421242240113103203013341231330004332040302440011324004130324034323430143102401440130242321424020323),5)
c3 = int(str(10013444120141130322433204124002242224332334011124210012440241402342100410331131441303242011002101323040403311120421304422222200324402244243322422444414043342130111111330022213203030324422101133032212042042243101434342203204121042113212104212423330331134311311114143200011240002111312122234340003403312040401043021433112031334324322123304112340014030132021432101130211241134422413442312013042141212003102211300321404043012124332013240431242),5)


n=[n1,n2,n3]
c=[c1,c2,c3]
x= CRT(n,c)
m = gmpy2.iroot(x, 3)[0]
print(long_to_bytes(m))

另，gmpy2.invert 不可逆，然后我换了sympy的

很奇怪的是，sympy就可以出来，但是gmpy就不行，暂时的疑问，mark一下

b’noxCTF{D4mn_y0u_h4s74d_wh47_4_b100dy_b4s74rd!}’

浪里淘沙

image-20201117211700103

image-20201117211858840

思路：词频分析，但是没有合适的工具可以分析无空格的词频，嘤嘤嘤~

然后因为这段英文里大量的重复的单词，外加题目描述里说获得的单词连在一起（一串数字4,8,11,15,16），我们可以合理的猜测是重复单词的频率排序后的4,8,11,15,16的单词连在一起就是flag。嘤嘤嘤无工具啊啊啊啊，哦，对了word里有查找可以用，嘿嘿嘿

word查找替换会有提示多少词。

image-20201117220203274

flag{weshouldlearnthecrypto}

鸡藕椒盐味

公司食堂最新出了一种小吃，叫鸡藕椒盐味汉堡，售价八块钱，为了促销，上面有一个验证码，输入后可以再换取一个汉堡。但是问题是每个验证码几乎都有错误,而且打印的时候倒了一下。小明买到了一个汉堡，准备还原验证码，因为一个吃不饱啊验证码如下：1100 1010 0000 ,而且打印的时候倒了一下。把答案哈希一下就可以提交了。(答案为正确值(不包括数字之间的空格)的32位md5值的小写形式) 注意：得到的 flag 请包上 flag{} 提交

思路：奇偶校验位（海明校检码），md5

从题目可以知道1100 1010 0000这串码需要修正，百度奇偶校验位，海明校验码，将这串数字套入海明校验公式，修正得到 1101 1010 0000

然后在线网站md5

flag{d14084c7ceca6359eaac6df3c234dd3b}

[AFCTF2018]你能看出这是什么加密么

p=0x928fb6aa9d813b6c3270131818a7c54edb18e3806942b88670106c1821e0326364194a8c49392849432b37632f0abe3f3c52e909b939c91c50e41a7b8cd00c67d6743b4f

q=0xec301417ccdffa679a8dcc4027dd0d75baf9d441625ed8930472165717f4732884c33f25d4ee6a6c9ae6c44aedad039b0b72cf42cab7f80d32b74061

e=0x10001

c=0x70c9133e1647e95c3cb99bd998a9028b5bf492929725a9e8e6d2e277fa0f37205580b196e5f121a2e83bc80a8204c99f5036a07c8cf6f96c420369b4161d2654a7eccbdaf583204b645e137b3bd15c5ce865298416fd5831cba0d947113ed5be5426b708b89451934d11f9aed9085b48b729449e461ff0863552149b965e22b6

思路：p，q，e，c 直接RSA

exp：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import gmpy2
import time
import sympy
from functools import reduce 
from Crypto.Util.number import long_to_bytes
 
p=0x928fb6aa9d813b6c3270131818a7c54edb18e3806942b88670106c1821e0326364194a8c49392849432b37632f0abe3f3c52e909b939c91c50e41a7b8cd00c67d6743b4f

q=0xec301417ccdffa679a8dcc4027dd0d75baf9d441625ed8930472165717f4732884c33f25d4ee6a6c9ae6c44aedad039b0b72cf42cab7f80d32b74061

e=0x10001

c=0x70c9133e1647e95c3cb99bd998a9028b5bf492929725a9e8e6d2e277fa0f37205580b196e5f121a2e83bc80a8204c99f5036a07c8cf6f96c420369b4161d2654a7eccbdaf583204b645e137b3bd15c5ce865298416fd5831cba0d947113ed5be5426b708b89451934d11f9aed9085b48b729449e461ff0863552149b965e22b6
n=p*q
phi=(p-1)*(q-1)
d=gmpy2.invert(e,phi)
m=pow(c,d,n)
print(long_to_bytes(m))

image-20201118214740772

afctf{R54_|5_$0_$imp13}

[RoarCTF2019]babyRSA

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import sympy
import random

def myGetPrime():
    A= getPrime(513)
    print(A)
    B=A-random.randint(1e3,1e5)
    print(B)
    return sympy.nextPrime((B!)%A)
p=myGetPrime()
#A1=21856963452461630437348278434191434000066076750419027493852463513469865262064340836613831066602300959772632397773487317560339056658299954464169264467234407
#B1=21856963452461630437348278434191434000066076750419027493852463513469865262064340836613831066602300959772632397773487317560339056658299954464169264467140596

q=myGetPrime()
#A2=16466113115839228119767887899308820025749260933863446888224167169857612178664139545726340867406790754560227516013796269941438076818194617030304851858418927
#B2=16466113115839228119767887899308820025749260933863446888224167169857612178664139545726340867406790754560227516013796269941438076818194617030304851858351026

r=myGetPrime()

n=p*q*r
#n=85492663786275292159831603391083876175149354309327673008716627650718160585639723100793347534649628330416631255660901307533909900431413447524262332232659153047067908693481947121069070451562822417357656432171870951184673132554213690123308042697361969986360375060954702920656364144154145812838558365334172935931441424096270206140691814662318562696925767991937369782627908408239087358033165410020690152067715711112732252038588432896758405898709010342467882264362733
c=pow(flag,e,n)
#e=0x1001
#c=75700883021669577739329316795450706204502635802310731477156998834710820770245219468703245302009998932067080383977560299708060476222089630209972629755965140317526034680452483360917378812244365884527186056341888615564335560765053550155758362271622330017433403027261127561225585912484777829588501213961110690451987625502701331485141639684356427316905122995759825241133872734362716041819819948645662803292418802204430874521342108413623635150475963121220095236776428
#so,what is the flag?

思路：yafu不能直接分解n，那么直接从源码得到p，q，由n出r，再出phi，然后就是老套路了

源码这里生成p，q，r都用了一个！，即阶乘，那么我们可以联想到解密可能要用到威尔逊定理：当且仅当p为素数时，（p-1）！≡ -1 ( mod p )

exp：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import gmpy2
import time
import sympy
from functools import reduce 
from Crypto.Util.number import long_to_bytes

def wilson(A,B):
    t=A-B-1
    k=A-1
    res=-1
    for i in range(t):
        res=(res*gmpy2.invert(k,A)%A)
        k=k-1
    if res<0:
        return res+A
    else:
        return res

A1=21856963452461630437348278434191434000066076750419027493852463513469865262064340836613831066602300959772632397773487317560339056658299954464169264467234407
B1=21856963452461630437348278434191434000066076750419027493852463513469865262064340836613831066602300959772632397773487317560339056658299954464169264467140596
p=sympy.nextprime(wilson(A1,B1))

A2=16466113115839228119767887899308820025749260933863446888224167169857612178664139545726340867406790754560227516013796269941438076818194617030304851858418927
B2=16466113115839228119767887899308820025749260933863446888224167169857612178664139545726340867406790754560227516013796269941438076818194617030304851858351026
q=sympy.nextprime(wilson(A2,B2))
#print(p,q)
n=85492663786275292159831603391083876175149354309327673008716627650718160585639723100793347534649628330416631255660901307533909900431413447524262332232659153047067908693481947121069070451562822417357656432171870951184673132554213690123308042697361969986360375060954702920656364144154145812838558365334172935931441424096270206140691814662318562696925767991937369782627908408239087358033165410020690152067715711112732252038588432896758405898709010342467882264362733
r=n//q//p

e=0x1001
c=75700883021669577739329316795450706204502635802310731477156998834710820770245219468703245302009998932067080383977560299708060476222089630209972629755965140317526034680452483360917378812244365884527186056341888615564335560765053550155758362271622330017433403027261127561225585912484777829588501213961110690451987625502701331485141639684356427316905122995759825241133872734362716041819819948645662803292418802204430874521342108413623635150475963121220095236776428
phi=(p-1)*(q-1)*(r-1)
d=gmpy2.invert(e,phi)
flag=pow(c,d,n)
print(long_to_bytes(flag))
print(flag[2:].decode('hex'))

b’RoarCTF{wm-CongrAtu1ation4-1t4-ju4t-A-bAby-R4A}’

[ACTF新生赛2020]crypto-rsa3

n=177606504836499246970959030226871608885969321778211051080524634084516973331441644993898029573612290095853069264036530459253652875586267946877831055147546910227100566496658148381834683037366134553848011903251252726474047661274223137727688689535823533046778793131902143444408735610821167838717488859902242863683
c=1457390378511382354771000540945361168984775052693073641682375071407490851289703070905749525830483035988737117653971428424612332020925926617395558868160380601912498299922825914229510166957910451841730028919883807634489834128830801407228447221775264711349928156290102782374379406719292116047581560530382210049

e=65537

思路：RSA yafu分解n

exp：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import gmpy2
import time
import sympy
from functools import reduce 
from Crypto.Util.number import long_to_bytes

p = 13326909050357447643526585836833969378078147057723054701432842192988717649385731430095055622303549577233495793715580004801634268505725255565021519817179293
q = 13326909050357447643526585836833969378078147057723054701432842192988717649385731430095055622303549577233495793715580004801634268505725255565021519817179231
n=177606504836499246970959030226871608885969321778211051080524634084516973331441644993898029573612290095853069264036530459253652875586267946877831055147546910227100566496658148381834683037366134553848011903251252726474047661274223137727688689535823533046778793131902143444408735610821167838717488859902242863683
c=1457390378511382354771000540945361168984775052693073641682375071407490851289703070905749525830483035988737117653971428424612332020925926617395558868160380601912498299922825914229510166957910451841730028919883807634489834128830801407228447221775264711349928156290102782374379406719292116047581560530382210049

e=65537
phi=(p-1)*(q-1)
d=gmpy2.invert(e,phi)
m=pow(c,d,n)
print(long_to_bytes(m))

b’actf{p_and_q_should_not_be_so_close_in_value}’

[ACTF新生赛2020]crypto-classic0

哼，压缩包的密码？这是小Z童鞋的生日吧==

Ygvdmq[lYate[elghqvakl}

思路：ARCHPR暴力破解密码，纯数字，范围1970000—20201118

得到密码：19990306

解压缩得到c文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include<stdio.h>

char flag[25] = ***; 

int main()
{
	int i;
	for(i=0;i<25;i++)
	{
		flag[i] -= 3;
		flag[i] ^= 0x7;
		printf("%c",flag[i]);
	}
	return 0; 
}

exp：

1
2
3
4
5
6
cipher='Ygvdmq[lYate[elghqvakl}'
 
for i in range(0,24):
    flag=ord(cipher[i]) ^ 0x7
    flag += 3
    print (chr(flag),end='')

actf{my_naive_encrytion}

mark错误

image-20201118224540138

前几遍出来的时候没有{，后来是发现是cipher那里有问题，中间好像不是空格，我开始把他当空格然后去掉了，之后直接复制上去

image-20201118224724027

救世捷径

一个名叫CPU的神秘大陆有26个国家，有些国家之间会有一条无向路，每条路径都有不同的长度和一段神秘代码，救世主尼奥要从国家1出发，赶往国家26拯救大陆，请你帮助救世主选择最短路径，而走过的路的神秘代码连接起来便是flag。 以下是数行数据，每行第一个，第二个数字代表这条路的两个端点国家，第三个数字代表路途长度，最后一个字符串便是神秘代码。路在附件中~ 帮助救世主尼奥吧，他快被吓尿了。。

思路：图论最短路径问题，用dijkstra算法，或者手动画图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
#dijkstra算法
graph=[]
for i in range(27):
    graph.append([])
for i in range(27):
    for j in range(27):
        graph[i].append(0x3f3f3f)
f=open('dj.txt','r').readlines()
li=[]
for x in f:
    li.append(x.strip().split(' '))
#print(li)
#print(graph)
for x in li:
    graph[int(x[0])][int(x[1])]=int(x[2])
    graph[int(x[1])][int(x[0])]=int(x[2])
#print(graph)
def dijkstra():
    dv=[0x3f3f3f for i in range(27)]
    route=[1 for i in range(27)]
    vis=[0 for i in range(27)]
    for i in range(2,27):
        dv[i]=graph[i][1]
    dv[1]=0
    #print(dv)
    vis[1]=1
    for i in range(26):
        minn=0x3f3f3f
        temp=-1
        for j in range(2,27):
            if vis[j]==0 and minn>dv[j]:
                minn=dv[j]
                temp=j
        vis[temp]=1
        #print(temp)
        for j in range(2,27):
            if dv[j]>dv[temp]+graph[temp][j]:
                dv[j]=dv[temp]+graph[temp][j]
                route[j]=temp
    return (route,dv)
route,dv=dijkstra()
print(dv[26])
print(route)
y=26
while y!=1:
    print(y)
    y=route[y]
# 339
# [1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 5, 5, 5, 4, 4, 4, 6, 6, 6, 25, 9, 11, 12, 6, 18, 22, 25]
# 26
# 25
# 22
# 12
# 5
# 2

#flag{WEIVKASJVLSJCHFSJVHJSDEV}



坏蛋是雷宾

老牌刺客之王混进了女王的住所。一天，女王得到了一个匿名举报，说她的侍卫里有一个刺客，叫做Rabin，而他的信息就在一份文件里，文件中有附带一个Pk，是523798549，密文是162853095，校验码二进制值是110001，根据说明是放在明文后一起加密的，明文与密文长度相同。加密算法和这位老牌刺客同名。快拯救女王，答案是求得的明文，进行32位md5小写哈希字符串，提交即可。

思路：Rabin算法，在四个解中，找到符和题目要求的二进制数据（即末尾为110001），再转。

exp：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import gmpy2
import libnum
import hashlib
from Crypto.Util.number import *
def Rabin_decrypt(c, p, q, e=2):  
    n = p * q  
    mp = pow(c,(p + 1) //4,p)  
    mq = pow(c,(q + 1) //4,q)  
    yp = gmpy2.invert(p, q)  
    yq = gmpy2.invert(q, p)  
    r = (yp * p * mq + yq * q * mp) % n  
    rr = n - r  
    s = (yp * p * mq - yq * q * mp) % n  
    ss = n - s  
    return (r, rr, s, ss)

n=523798549
p=10663
q=49123
c=162853095
#c= int(open('./flag.enc','rb').read().encode('hex'),16)
r,rr,s,ss=Rabin_decrypt(c, p, q, e=2)
flag=10010011100100100101010
m=str(int('10010011100100100101010',2))
md=hashlib.md5()
md.update(m.encode("utf8"))
flag=md.hexdigest()
print('flag{'+str(flag)+'}')
print(bin(r))
print(bin(rr))
print(bin(s))
print(bin(ss))

flag{ca5cec442b2734735406d78c88e90f35}

[RoarCTF2019]RSA

1
2
3
4
5
6
7
A=(((y%x)**5)%(x%y))**2019+y**316+(y+1)/x
p=next_prime(z*x*y)
q=next_prime(z)
A =  2683349182678714524247469512793476009861014781004924905484127480308161377768192868061561886577048646432382128960881487463427414176114486885830693959404989743229103516924432512724195654425703453612710310587164417035878308390676612592848750287387318129424195208623440294647817367740878211949147526287091298307480502897462279102572556822231669438279317474828479089719046386411971105448723910594710418093977044179949800373224354729179833393219827789389078869290217569511230868967647963089430594258815146362187250855166897553056073744582946148472068334167445499314471518357535261186318756327890016183228412253724
n =  117930806043507374325982291823027285148807239117987369609583515353889814856088099671454394340816761242974462268435911765045576377767711593100416932019831889059333166946263184861287975722954992219766493089630810876984781113645362450398009234556085330943125568377741065242183073882558834603430862598066786475299918395341014877416901185392905676043795425126968745185649565106322336954427505104906770493155723995382318346714944184577894150229037758434597242564815299174950147754426950251419204917376517360505024549691723683358170823416757973059354784142601436519500811159036795034676360028928301979780528294114933347127
c =  41971850275428383625653350824107291609587853887037624239544762751558838294718672159979929266922528917912189124713273673948051464226519605803745171340724343705832198554680196798623263806617998072496026019940476324971696928551159371970207365741517064295956376809297272541800647747885170905737868568000101029143923792003486793278197051326716680212726111099439262589341050943913401067673851885114314709706016622157285023272496793595281054074260451116213815934843317894898883215362289599366101018081513215120728297131352439066930452281829446586562062242527329672575620261776042653626411730955819001674118193293313612128

思路：这题有两种思路

1.由于题目告诉我们p，q的生成跟A有关，我们可以通过A算出x，y，然后进而算出p，q的。

2.第二种思路也是我抱着那么一丝丝的希望，因为第一种思路感觉好烦啊，我不会告诉你，我其实是不会用A爆出x，y嘛然后做出来的，就是他可以直接分解，在factor.com上

哦，对了，e 题目是没有给的，我们可以爆破出e，因为一般这样的情况，e不会很大，不然，做个得er，至于我，我是误打误撞，就是很顺手的填了e=65537。尴尬.jpg，然后写wp的时候发现e要爆破。

exp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#最初的payload
from Crypto.Util.number import*
from gmpy2 import *
p=842868045681390934539739959201847552284980179958879667933078453950968566151662147267006293571765463137270594151138695778986165111380428806545593588078365331313084230014618714412959584843421586674162688321942889369912392031882620994944241987153078156389470370195514285850736541078623854327959382156753458569
q=139916095583110895133596833227506693679306709873174024876891023355860781981175916446323044732913066880786918629089023499311703408489151181886568535621008644997971982182426706592551291084007983387911006261442519635405457077292515085160744169867410973960652081452455371451222265819051559818441257438021073941183
e=65537
c=41971850275428383625653350824107291609587853887037624239544762751558838294718672159979929266922528917912189124713273673948051464226519605803745171340724343705832198554680196798623263806617998072496026019940476324971696928551159371970207365741517064295956376809297272541800647747885170905737868568000101029143923792003486793278197051326716680212726111099439262589341050943913401067673851885114314709706016622157285023272496793595281054074260451116213815934843317894898883215362289599366101018081513215120728297131352439066930452281829446586562062242527329672575620261776042653626411730955819001674118193293313612128
d=invert(e,(p-1)*(q-1))
print(long_to_bytes(pow(c,d,p*q)))

#爆破e
from Crypto.Util.number import *
from gmpy2 import *

n =  117930806043507374325982291823027285148807239117987369609583515353889814856088099671454394340816761242974462268435911765045576377767711593100416932019831889059333166946263184861287975722954992219766493089630810876984781113645362450398009234556085330943125568377741065242183073882558834603430862598066786475299918395341014877416901185392905676043795425126968745185649565106322336954427505104906770493155723995382318346714944184577894150229037758434597242564815299174950147754426950251419204917376517360505024549691723683358170823416757973059354784142601436519500811159036795034676360028928301979780528294114933347127
c =  41971850275428383625653350824107291609587853887037624239544762751558838294718672159979929266922528917912189124713273673948051464226519605803745171340724343705832198554680196798623263806617998072496026019940476324971696928551159371970207365741517064295956376809297272541800647747885170905737868568000101029143923792003486793278197051326716680212726111099439262589341050943913401067673851885114314709706016622157285023272496793595281054074260451116213815934843317894898883215362289599366101018081513215120728297131352439066930452281829446586562062242527329672575620261776042653626411730955819001674118193293313612128
p = 139916095583110895133596833227506693679306709873174024876891023355860781981175916446323044732913066880786918629089023499311703408489151181886568535621008644997971982182426706592551291084007983387911006261442519635405457077292515085160744169867410973960652081452455371451222265819051559818441257438021073941183
q = 842868045681390934539739959201847552284980179958879667933078453950968566151662147267006293571765463137270594151138695778986165111380428806545593588078365331313084230014618714412959584843421586674162688321942889369912392031882620994944241987153078156389470370195514285850736541078623854327959382156753458569
phi = (p-1)*(q-1)

e = 2
for e in range(100000):
    if isPrime(e):
        try:
            d = invert(e,phi)
            flag = long_to_bytes(pow(c,d,n))
            flag = str(flag)
            if "RoarCTF" in flag or "flag" in flag:
                print(e,'\n',flag)
        except ZeroDivisionError:
            continue

RoarCTF{wm-l1l1ll1l1l1l111ll}

另，第一种思路我没有试，不过应该是可以出的。
好家伙，我直接开始百谷。

image-20201119212613951

不过这个大大大大大大师傅写的还是很清晰的。

blog地址

[AFCTF2018]可怜的RSA

思路：Crypto.PublicKey 的RSA模块解密

exp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import gmpy2
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
from base64 import b64decode
f=open('./public.key','rb').read()
pub=RSA.importKey(f)
n=pub.n
e=pub.e
print(n,e)
#n=79832181757332818552764610761349592984614744432279135328398999801627880283610900361281249973175805069916210179560506497075132524902086881120372213626641879468491936860976686933630869673826972619938321951599146744807653301076026577949579618331502776303983485566046485431039541708467141408260220098592761245010678592347501894176269580510459729633673468068467144199744563731826362102608811033400887813754780282628099443490170016087838606998017490456601315802448567772411623826281747245660954245413781519794295336197555688543537992197142258053220453757666537840276416475602759374950715283890232230741542737319569819793988431443
#e=65537

p =3133337
q =25478326064937419292200172136399497719081842914528228316455906211693118321971399936004729134841162974144246271486439695786036588117424611881955950996219646807378822278285638261582099108339438949573034101215141156156408742843820048066830863814362379885720395082318462850002901605689761876319151147352730090957556940842144299887394678743607766937828094478336401159449035878306853716216548374273462386508307367713112073004011383418967894930554067582453248981022011922883374442736848045920676341361871231787163441467533076890081721882179369168787287724769642665399992556052144845878600126283968890273067575342061776244939
d=gmpy2.invert(e,(p-1)*(q-1))
print(d)
d=406853230956379689450620815713768871010712825839536410687962650677800895818003893712259622281477453292088146173840036827322518131453630576229976208523593618949818777897059256426591560532784635697190752924923710375949616954069804342573867253630978123632384795587951365482103468722384133084798614863870775897915929475258974188300927376911833763105616386167881813301748585233563049693794370642976326692672223638908164822104832415788577945314264232531947860576966629150456995512932232264881080618006698700677529111454508900582785420549466798020451488168615035256292977390692401388790460066327347700109341639992159475755036449
#key = RSA.construct(n,e,d)
#print(key.exportKey())

key_info = RSA.construct((n, e, d, p, q))
key = RSA.importKey(key_info.exportKey())
key = PKCS1_OAEP.new(key)

c=b64decode(open('./flag.enc','rb').read())
flag=key.decrypt(c)
print(flag)


afctf{R54_|5_$0_B0rin9}