Stack Pivoting - EBP2Ret - EBP chaining
Basiese Inligting
Hierdie tegniek benut die vermoë om die Base Pointer (EBP) te manipuleer om die uitvoering van verskeie funksies te ketting deur versigtige gebruik van die EBP-register en die leave; ret
instruksie-sekwensie.
Ter herinnering, leave
beteken basies:
And as the EBP is in the stack before the EIP it's possible to control it controlling the stack.
EBP2Ret
Hierdie tegniek is veral nuttig wanneer jy die EBP-register kan verander, maar geen direkte manier het om die EIP-register te verander nie. Dit benut die gedrag van funksies wanneer hulle klaar is met uitvoer.
As jy, tydens die uitvoering van fvuln
, daarin slaag om 'n valse EBP in die stapel in te spuit wat na 'n area in geheue wys waar jou shellcode se adres geleë is (plus 4 bytes om rekening te hou met die pop
-operasie), kan jy indirek die EIP beheer. Terwyl fvuln
terugkeer, word die ESP op hierdie vervaardigde ligging gestel, en die daaropvolgende pop
-operasie verminder ESP met 4, wat dit effektief laat wys na 'n adres wat deur die aanvaller daar gestoor is.
Let daarop dat jy 2 adresse moet weet: Die een waarheen ESP gaan, waar jy die adres moet skryf wat deur ESP aangedui word.
Exploit Konstruksie
Eerstens moet jy 'n adres weet waar jy arbitrêre data / adresse kan skryf. Die ESP sal hierheen wys en die eerste ret
uitvoer.
Dan moet jy die adres weet wat deur ret
gebruik word wat arbitrêre kode sal uitvoer. Jy kan gebruik:
'n Geldige ONE_GADGET adres.
Die adres van
system()
gevolg deur 4 rommel bytes en die adres van"/bin/sh"
(x86 bits).Die adres van 'n
jump esp;
gadget (ret2esp) gevolg deur die shellcode om uit te voer.Sommige ROP ketting
Onthou dat daar voor enige van hierdie adresse in die beheerde deel van die geheue, 4
bytes moet wees as gevolg van die pop
deel van die leave
instruksie. Dit sal moontlik wees om hierdie 4B te misbruik om 'n tweede valse EBP in te stel en voort te gaan om die uitvoering te beheer.
Off-By-One Exploit
Daar is 'n spesifieke variant van hierdie tegniek bekend as 'n "Off-By-One Exploit". Dit word gebruik wanneer jy slegs die minste betekenisvolle byte van die EBP kan verander. In so 'n geval moet die geheue ligging wat die adres stoor om na te spring met die ret
die eerste drie bytes met die EBP deel, wat 'n soortgelyke manipulasie met meer beperkte toestande moontlik maak.
Gewoonlik word die byte 0x00 verander om so ver as moontlik te spring.
Dit is ook algemeen om 'n RET-sled in die stapel te gebruik en die werklike ROP-ketting aan die einde te plaas om dit meer waarskynlik te maak dat die nuwe ESP binne die RET SLED wys en die finale ROP-ketting uitgevoer word.
EBP Ketting
Daarom, deur 'n beheerde adres in die EBP
-invoer van die stapel te plaas en 'n adres na leave; ret
in EIP
, is dit moontlik om die ESP
na die beheerde EBP
-adres van die stapel te beweeg.
Nou is die ESP
beheers wat na 'n gewenste adres wys en die volgende instruksie om uit te voer is 'n RET
. Om dit te misbruik, is dit moontlik om in die beheerde ESP plek dit te plaas:
&(next fake EBP)
-> Laai die nuwe EBP as gevolg vanpop ebp
van dieleave
instruksiesystem()
-> Geroep deurret
&(leave;ret)
-> Geroep nadat die stelsel eindig, dit sal ESP na die valse EBP beweeg en weer begin&("/bin/sh")
-> Param virsystem
Basies is dit op hierdie manier moontlik om verskeie valse EBPs te ketting om die vloei van die program te beheer.
Dit is soos 'n ret2lib, maar meer kompleks sonder enige ooglopende voordeel, maar kan interessant wees in sommige randgevalle.
Boonop het jy hier 'n voorbeeld van 'n uitdaging wat hierdie tegniek gebruik met 'n stapel lek om 'n wenfunksie aan te roep. Dit is die finale payload van die bladsy:
EBP mag dalk nie gebruik word nie
Soos in hierdie pos verduidelik, as 'n binêre met sekere optimaliseringe gecompileer word, kry EBP nooit beheer oor ESP nie, daarom sal enige eksploit wat werk deur EBP te beheer basies misluk omdat dit nie 'n werklike effek het nie. Dit is omdat die proloog en epiloog verander as die binêre geoptimaliseer is.
Nie geoptimaliseer nie:
Geoptimaliseer:
Ander maniere om RSP te beheer
pop rsp
gadget
pop rsp
gadgetOp hierdie bladsy kan jy 'n voorbeeld vind wat hierdie tegniek gebruik. Vir hierdie uitdaging was dit nodig om 'n funksie met 2 spesifieke argumente aan te roep, en daar was 'n pop rsp
gadget en daar is 'n leak van die stapel:
xchg <reg>, rsp gadget
jmp esp
Kyk na die ret2esp tegniek hier:
Ret2esp / Ret2regVerwysings & Ander Voorbeelde
64 bits, off by one uitbuiting met 'n rop ketting wat met 'n ret sled begin
64 bit, geen relro, canary, nx en pie. Die program bied 'n lek vir die stapel of pie en 'n WWW van 'n qword. Kry eers die stapel lek en gebruik die WWW om terug te gaan en die pie lek te kry. Gebruik dan die WWW om 'n ewige lus te skep wat misbruik maak van
.fini_array
inskrywings + die aanroep van__libc_csu_fini
(meer inligting hier). Deur hierdie "ewige" skrywe te misbruik, word 'n ROP ketting in die .bss geskryf en eindig op om dit te bel met pivoting met RBP.
ARM64
In ARM64, die proloog en epiloge van die funksies stoor en herwin nie die SP registrasie in die stapel nie. Boonop, die RET
instruksie keer nie terug na die adres wat deur SP aangedui word nie, maar na die adres binne x30
.
Daarom, per standaard, deur net die epiloog te misbruik, sal jy nie in staat wees om die SP registrasie te beheer deur sommige data binne die stapel te oorskry nie. En selfs as jy daarin slaag om die SP te beheer, sal jy steeds 'n manier nodig hê om die x30
registrasie te beheer.
proloog
epiloge
Die manier om iets soortgelyks aan stapel pivoting in ARM64 uit te voer, sou wees om in staat te wees om die SP
te beheer (deur 'n registrasie te beheer waarvan die waarde aan SP
oorgedra word of omdat om een of ander rede SP
sy adres van die stapel neem en ons 'n oorskrywing het) en dan die epiloog te misbruik om die x30
registrasie van 'n beheerde SP
te laai en RET
daarheen.
Ook op die volgende bladsy kan jy die ekwivalent van Ret2esp in ARM64 sien:
Ret2esp / Ret2regLast updated