hacktricks/src/binary-exploitation/stack-overflow/uninitialized-variables.md

# Neinicijalizovane Promenljive

{{#include ../../banners/hacktricks-training.md}}

## Osnovne Informacije

Osnovna ideja ovde je da se razume šta se dešava sa **neinicijalizovanim promenljivama jer će imati vrednost koja je već bila u dodeljenoj memoriji za njih.** Primer:

- **Funkcija 1: `initializeVariable`**: Deklarisemo promenljivu `x` i dodeljujemo joj vrednost, recimo `0x1234`. Ova akcija je slična rezervisanju mesta u memoriji i stavljanju specifične vrednosti u nju.
- **Funkcija 2: `useUninitializedVariable`**: Ovde, deklarisemo još jednu promenljivu `y`, ali joj ne dodeljujemo nikakvu vrednost. U C-u, neinicijalizovane promenljive se automatski ne postavljaju na nulu. Umesto toga, zadržavaju bilo koju vrednost koja je poslednja sačuvana na njihovoj memorijskoj lokaciji.

Kada pokrenemo ove dve funkcije **uzastopno**:

1. U `initializeVariable`, `x` dobija vrednost (`0x1234`), koja zauzima specifičnu adresu u memoriji.
2. U `useUninitializedVariable`, `y` je deklarisana, ali joj nije dodeljena vrednost, pa zauzima memorijsko mesto odmah nakon `x`. Zbog neinicijalizovanja `y`, ona na kraju "nasleđuje" vrednost iz iste memorijske lokacije koju koristi `x`, jer je to poslednja vrednost koja je bila tamo.

Ovo ponašanje ilustruje ključni koncept u niskonivou programiranju: **Upravljanje memorijom je ključno**, a neinicijalizovane promenljive mogu dovesti do nepredvidivog ponašanja ili sigurnosnih ranjivosti, jer mogu nenamerno sadržati osetljive podatke ostavljene u memoriji.

Neinicijalizovane promenljive na steku mogu predstavljati nekoliko sigurnosnih rizika kao što su:

- **Curjenje Podataka**: Osetljive informacije kao što su lozinke, ključevi za enkripciju ili lični podaci mogu biti izloženi ako su sačuvani u neinicijalizovanim promenljivama, omogućavajući napadačima da potencijalno pročitaju ove podatke.
- **Otkrivanje Informacija**: Sadržaj neinicijalizovanih promenljivih može otkriti detalje o rasporedu memorije programa ili unutrašnjim operacijama, pomažući napadačima u razvoju ciljanih eksploatacija.
- **Rušenja i Nestabilnost**: Operacije koje uključuju neinicijalizovane promenljive mogu rezultirati neodređenim ponašanjem, što dovodi do rušenja programa ili nepredvidivih ishoda.
- **Izvršavanje Arbitrarnog Koda**: U određenim scenarijima, napadači bi mogli iskoristiti ove ranjivosti da promene tok izvršavanja programa, omogućavajući im da izvrše arbitrarnu kod, što može uključivati pretnje od daljinskog izvršavanja koda.

### Primer
```c
#include <stdio.h>

// Function to initialize and print a variable
void initializeAndPrint() {
int initializedVar = 100; // Initialize the variable
printf("Initialized Variable:\n");
printf("Address: %p, Value: %d\n\n", (void*)&initializedVar, initializedVar);
}

// Function to demonstrate the behavior of an uninitialized variable
void demonstrateUninitializedVar() {
int uninitializedVar; // Declare but do not initialize
printf("Uninitialized Variable:\n");
printf("Address: %p, Value: %d\n\n", (void*)&uninitializedVar, uninitializedVar);
}

int main() {
printf("Demonstrating Initialized vs. Uninitialized Variables in C\n\n");

// First, call the function that initializes its variable
initializeAndPrint();

// Then, call the function that has an uninitialized variable
demonstrateUninitializedVar();

return 0;
}
```
#### Kako ovo funkcioniše:

- **`initializeAndPrint` Funkcija**: Ova funkcija deklariše celobrojnu promenljivu `initializedVar`, dodeljuje joj vrednost `100`, a zatim ispisuje i adresu u memoriji i vrednost promenljive. Ovaj korak je jednostavan i pokazuje kako se ponaša inicijalizovana promenljiva.
- **`demonstrateUninitializedVar` Funkcija**: U ovoj funkciji, deklarišemo celobrojnu promenljivu `uninitializedVar` bez inicijalizacije. Kada pokušamo da ispišemo njenu vrednost, izlaz može prikazati nasumičan broj. Ovaj broj predstavlja bilo koje podatke koji su prethodno bili na toj memorijskoj lokaciji. U zavisnosti od okruženja i kompajlera, stvarni izlaz može varirati, a ponekad, iz bezbednosnih razloga, neki kompajleri mogu automatski inicijalizovati promenljive na nulu, iako se na to ne treba oslanjati.
- **`main` Funkcija**: `main` funkcija poziva obe gornje funkcije u nizu, demonstrirajući razliku između inicijalizovane i neinicijalizovane promenljive.

## ARM64 Primer

Ovo se uopšte ne menja u ARM64 jer se lokalne promenljive takođe upravljaju na steku, možete [**proveriti ovaj primer**](https://8ksec.io/arm64-reversing-and-exploitation-part-6-exploiting-an-uninitialized-stack-variable-vulnerability/) gde je ovo prikazano.

{{#include ../../banners/hacktricks-training.md}}