1. ๋ฆฌ๋ ์ค ๋ฉ๋ชจ๋ฆฌ ๊ตฌ์กฐ(Memory Layout)
ํ๋ก์ธ์ค ๊ฐ์๋ฉ๋ชจ๋ฆฌ์ ๊ฐ ๊ตฌ์ญ์ด ์ด๋ค ์ ๋ณด๋ฅผ ๋ด๊ณ ์๋์ง ์ดํดํ๋ ๊ฒ์ด ํต์ฌ!
๐๊ฐ์๐
- ์ธ๊ทธ๋จผํธ๋
- ์ฝ๋ ์ธ๊ทธ๋จผํธ
- ๋ฐ์ดํฐ ์ธ๊ทธ๋จผํธ
- BSS ์ธ๊ทธ๋จผํธ
- ์คํ ์ธ๊ทธ๋จผํธ
- ํ ์ธ๊ทธ๋จผํธ
CPU๋ ์คํํ ๋ช ๋ น์ด์ ๋ช ๋ น์ด ์ฒ๋ฆฌ์ ํ์ํ ๋ฐ์ดํฐ๋ฅผ ๋ฉ๋ชจ๋ฆฌ์์ ์ฝ๊ณ , Instruction Set Architecture(ISA)์
๋ฐ๋ผ ์ด๋ฅผ ์ฒ๋ฆฌํฉ๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ฐ์ฐ์ ๊ฒฐ๊ณผ๋ฅผ ๋ค์ ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฌํฉ๋๋ค.
CPU์ ๋์๊ณผ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ด์ ๋ฐ์ ํ ์ฐ๊ด์ด ์์์ ์๋ฏธ
๊ณต๊ฒฉ์๊ฐ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ ์์ ์ผ๋ก ์กฐ์ํ ์ ์๋ค๋ฉด ์กฐ์๋ ๋ฉ๋ชจ๋ฆฌ ๊ฐ์ ์ํด CPU๋ ์๋ชป๋ ๋์ํ ์ ์์ต๋๋ค.
์ด๋ฅผ ๋ฉ๋ชจ๋ฆฌ๊ฐ ์ค์ผ๋๋ค๊ณ ํํํ๋ฉฐ, ์ด๋ฅผ ์ ๋ฐํ๋ ์ทจ์ฝ์ ์ ๋ฉ๋ชจ๋ฆฌ ์ค์ผ(Memory Corruption) ์ทจ์ฝ์ !
2. ์ธ๊ทธ๋จผํธ(Segment)
์ ์ฌ๋๋ ๋ฐ์ดํฐ์ ์ฉ๋๋ณ๋ก ๋ฉ๋ชจ๋ฆฌ์ ๊ตฌํ์ ๋๋ ๊ฒ
โ๏ธ์ธ๊ทธ๋จผํธ ์ข ๋ฅ
-
- ์ฝ๋ ์ธ๊ทธ๋จผํธ(Code Segment)
- ๋ฐ์ดํฐ ์ธ๊ทธ๋จผํธ(Data Segment)
- BSS ์ธ๊ทธ๋จผํธ(BSS Segment, Block Started By Symbol Segment)
- ํ ์ธ๊ทธ๋จผํธ(Heap Segment)
- ์คํ ์ธ๊ทธ๋จผํธ(Stack Segment)
์ธ๊ทธ๋จผํธ์์์ ๊ถํ์ ์ฝ๊ธฐ, ์ฐ๊ธฐ, ์คํ์ผ๋ก ์กด์ฌํ๋ฉฐ CPU๋ ๋ฉ๋ชจ๋ฆฌ์ ๋ํด ๊ถํ์ ๋ถ์ฌํฉ๋๋ค.
์๋ฅผ ๋ค์ด, ๋ฐ์ดํฐ ์ธ๊ทธ๋จผํธ์๋ ํ๋ก๊ทธ๋จ์ด ์คํ๋๋ฉด์ ์ฌ์ฉํ๋ ๋ฐ์ดํฐ๋ฅผ ์ ์ฌํฉ๋๋ค. CPU๋ ์ด๊ณณ์
๋ฐ์ดํฐ๋ฅผ ์ฝ์ ์ ์์ด์ผ ํ๋ ์ฝ๊ธฐ ๊ถํ์ ๋ถ์ฌํ๋ ์์ด์ง์.
์ธ๊ทธ๋จผํธ๋ฅผ ์์ธํ ์ดํดํ ๋ ค๋ฉด OS์ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ ๊ธฐ๋ฒ ์ค ํ๋์ธ ์ธ๊ทธ๋จผํ ์ด์ ๊ธฐ๋ฒ๊ณผ
์ธํ x86-64(x64)์ ๊ด๋ จ๋ HW์ ์ค๊ณ๋ฅผ ์์์ผํ๋ฏ๋ก
์ผ๋จ '์คํ ์ค์ธ ํ๋ก์ธ์ค์ ๋ฉ๋ชจ๋ฆฌ๊ฐ ์์ ๊ฐ์ด 5๊ฐ์ ์์ญ์ผ๋ก ๊ตฌ๋ถ๋๋ค..' ์ ๋๋ก๋ง ์ดํดํฉ์๋ค
์ฝ๋ ์ธ๊ทธ๋จผํธ(Code Segment)
์คํ ๊ฐ๋ฅํ ๊ธฐ๊ณ ์ฝ๋๊ฐ ์์นํ๋ ์์ญ์ผ๋ก ํ ์คํธ ์ธ๊ทธ๋จผํธ(Text Segment)๋ผ๊ณ ๋ ๋ถ๋ฆผ
ํ๋ก๊ทธ๋จ์ด ๋์ํ๋ ค๋ฉด ์ฝ๋๋ฅผ ์คํํด์ผ ํ๋ฏ๋ก ์ด ์ธ๊ทธ๋จผํธ์๋ ์ฝ๊ธฐ ๊ถํ๊ณผ ์คํ ๊ถํ์ด ๋ถ์ฌ!
๋ฐ๋ฉด, ์ฐ๊ธฐ ๊ถํ์ ๊ณต๊ฒฉ์๊ฐ ์ ์์ ์ธ ์ฝ๋๋ฅผ ์ฝ์ ํ๊ธฐ ์ฌ์์ง๋ฏ๋ก, ์์ฆ ๋๋ถ๋ถ์ ์ฐ๊ธฐ ๊ถํ์ ์ ๊ฑฐํจ
int main() { return 31337; }
์ ์ ์ 31337์ ๋ฐํํ๋ mainํจ์๊ฐ ์ปดํ์ผ ๋๋ฉด 554889e5b8697a00005dc3๋ผ๋ ๊ธฐ๊ณ ์ฝ๋๋ก๋ณํ๋๋๋ฐ,
์ด ๊ธฐ๊ณ ์ฝ๋๊ฐ ์ฝ๋ ์ธ๊ทธ๋จผํธ์ ์์นํจ
๋ฐ์ดํฐ ์ธ๊ทธ๋จผํธ(Data Segment)
์ปดํ์ผ ์์ ์ ๊ฐ์ด ์ ํด์ง ์ ์ญ ๋ณ์ ๋ฐ ์ ์ญ ์์๋ค์ด ์์น
CPU๊ฐ ์ด ์ธ๊ทธ๋จผํธ์ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ ์ ์์ด์ผ ํ๋ฏ๋ก, ์ฝ๊ธฐ ๊ถํ์ด ๋ถ์ฌ๋ฉ๋๋ค.
๋ฐ์ดํฐ ์ธ๊ทธ๋จผํธ๋ ์ฐ๊ธฐ ๊ฐ๋ฅํ ์ธ๊ทธ๋จผํธ์ ์ฐ๊ธฐ ๋ถ๊ฐ๋ฅํ ์ธ๊ทธ๋จผํธ๋ก ๋ค์ ๋ถ๋ฅ๋๋๋ฐ,
์ฐ๊ธฐ ๊ฐ๋ฅํ ์ ์ญ๋ณ์์ ๊ฐ์ด ํ๋ก๊ทธ๋จ์ด ์คํ๋๋ฉด์ ๊ฐ์ด ๋ณํ ์ ์๋ ๋ฐ์ดํฐ๋ค์ด ์์นํ๋ data ์ธ๊ทธ๋จผํธ
์ฐ๊ธฐX ํ๋ก๊ทธ๋จ์ด ์คํ๋๋ฉด์ ๊ฐ์ด ๋ณํ๋ฉด ์๋๋ ์ ์ญ์์์ฒ๋ผ ๋ฐ์ดํฐ๋ค์ด ์์นํ๋ rodata(read-only data)์ธ๊ทธ๋จผํธ
์๋ ์ฝ๋๋ ๋ฐ์ดํฐ ์ธ๊ทธ๋จผํธ์ ํฌํจ๋๋ ์ฌ๋ฌ ๋ฐ์ดํฐ์ ์ ํ์ ๋๋ค. ์ฌ๊ธฐ์ ์ค์ํ ๋ณ์๋ str_ptr์ ๋๋ค.
str_ptr์ ๋ฌธ์์ด์ ์์ ๋ฌธ์์ด๋ก ์ทจ๊ธ๋์ด rodata์ ์์นํ๋ฉฐ ์ด๋ฅผ ๊ฐ๋ฅดํค๋ str_ptr์ ์ ์ญ ๋ณ์๋ก์จ data์์น
int data_num = 31337; // data
char data_rwstr[] = "writable_data"; // data
const char data_rostr[] = "readonly_data"; // rodata
char *str_ptr = "readonly"; // str_ptr์ data, ๋ฌธ์์ด์ rodata
int main() { ... }
BSS ์ธ๊ทธ๋จผํธ(Segment, Block Started By Symbol Segment)
์ปดํ์ผ ์์ ์ ๊ฐ์ด ์ ํด์ง์ง ์์ ์ ์ญ ๋ณ์๊ฐ ์์นํ ๋ฉ๋ชจ๋ฆฌ ์์ญ
์ฌ๊ธฐ์๋ ๊ฐ๋ฐ์๊ฐ ์ ์ธ๋ง ํ๊ณ ์ด๊ธฐํX ์ ์ญ๋ณ์ ๋ฑ์ด ํฌํจ
์ด ์ธ๊ทธ๋จผํธ์ ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ํ๋ก๊ทธ๋จ์ด ์์๋ ๋, ๋ชจ๋ 0์ผ๋ก ๊ฐ์ด ์ด๊ธฐํ
์ด ์ธ๊ทธ๋จผํธ์๋ ์ฝ๊ธฐ ๊ถํ ๋ฐ ์ฐ๊ธฐ ๊ถํ์ด ๋ถ์ฌ๋ฉ๋๋ค.
์๋ ์ฝ๋์์ ์ด๊ธฐํ๋์ง ์์ ์ ์ญ ๋ณ์์ธ bss_data๊ฐ BSS ์ธ๊ทธ๋จผํธ์ ์์นํ๊ฒ ๋ฉ๋๋ค.
int bss_data;
int main() {
printf("%d\n", bss_data); // 0
return 0;
}
์ ์ฝ๋์์ ์ด๊ธฐํ๋์ง ์์ ์ ์ญ ๋ณ์์ธ bss_data๊ฐ BSS ์ธ๊ทธ๋จผํธ์ ์์นํ๊ฒ ๋ฉ๋๋ค.
์ด ์ธ๊ทธ๋จผํธ์๋ ์ฝ๊ธฐ ๊ถํ ๋ฐ ์ฐ๊ธฐ ๊ถํ์ด ๋ถ์ฌ๋ฉ๋๋ค.
์คํ ์ธ๊ทธ๋จผํธ(Stack Segment)
ํ๋ก์ธ์ค์ ์คํ์ด ์์นํ๋ ์์ญ์ผ๋ก ํจ์์ ์ธ์๋ ์ง์ญ ๋ณ์์ ๊ฐ์ ์์ ๋ณ์๋ค์ด ์คํ์ค์ ์ฌ๊ธฐ์ ์ ์ฅ
์คํ ์ธ๊ทธ๋จผํธ๋ ์คํ ํ๋ ์(Stack Frame)์ด๋ผ๋ ๋จ์๋ก ์ฌ์ฉ
ํจ์๊ฐ ํธ์ถ๋ ๋ ์์ฑ๋๊ณ , ๋ฐํ๋ ๋ ํด์
ํ๋ก๊ทธ๋จ์ ์ ์ฒด ์คํ ํ๋ฆ์ ์ฌ์ฉ์์ ์ ๋ ฅ์ ๋น๋กฏํ ์ฌ๋ฌ ์์ธ์ ์ํฅ์ ์ค๋๋ค.
๐์ ์ ๊ฐ ์ ๋ ฅํ choice์ ๋ฐ๋ผ call_true()๊ฐ ํธ์ถ๋ ์๋, call_false()๊ฐ ํธ์ถ ๊ฐ๋ฅ
๋ฐ๋ผ์, ์ด๋ค ํ๋ก์ธ์ค๊ฐ ์คํ๋ ๋ ์ด ํ๋ก์ธ์ค์ ์คํ ํ๋ ์ ์ฌ์ฉ์ ๋ฏธ๋ฆฌ ๊ณ์ฐํ๋ ๊ฑด ์ผ๋ฐ์ ์ผ๋ก ๋ถ๊ฐ๋ฅํจ
๊ทธ๋์ OS๋ ํ๋ก์ธ์ค๋ฅผ ์์ํ ๋ ์์ ํฌ๊ธฐ์ ์คํ ์ธ๊ทธ๋จผํธ๋ฅผ ๋จผ์ ํ ๋นํด์ฃผ๊ณ , ๋ถ์กฑํ ๋๋ง๋ค ์ด๋ฅผ ํ์ฅํจ
์คํ์ด ํ์ฅ๋ ๋, ๊ธฐ์กด ์ฃผ์๋ณด๋ค ๋ฎ์ ์ฃผ์๋ก ํ์ฅ๋๋ค๋ ํน์ง
์ด ์์ญ์๋ CPU๊ฐ ์์ ๋กญ๊ฒ ๊ฐ์ ์ฝ๊ณ ์ธ ์ ์์ด์ผ ํ๋ฏ๋ก, ์ฝ๊ธฐ์ ์ฐ๊ธฐ ๊ถํ์ด ๋ถ์ฌ๋จ
์๋ ์ฝ๋์์๋ ์ง์ญ๋ณ์ choice๊ฐ ์คํ์ ์ ์ฅ๋จ
void func() {
int choice = 0;
scanf("%d", &choice);
if (choice)call_true();
else call_false();
return 0;
}
ํ ์ธ๊ทธ๋จผํธ(Heap Segment)
ํ ๋ฐ์ดํฐ๊ฐ ์์นํ๋ ์ธ๊ทธ๋จผํธ
์คํ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ์คํ ์ค์ ๋์ ์ผ๋ก ํ ๋น ๊ฐ๋ฅ
linux์์๋ ์คํ ์ธ๊ทธ๋จผํธ์ ๋ฐ๋ ๋ฐฉํฅ์ผ๋ก ์๋
๐ก ํ๊ณผ ์คํ ์ธ๊ทธ๋จผํธ๊ฐ ์๋ผ๋ ๋ฐฉํฅ์ด ๋ฐ๋์ธ ์ด์ ?
๋ ์ธ๊ทธ๋จผํธ๊ฐ ๋์ผํ ๋ฐฉํฅ์ผ๋ก ์๋ผ๋ฉฐ, ์ฐ์๋ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์์ ๊ฐ๊ฐ ํ ๋น๋๋ค๊ณ ๊ฐ์ ํด๋ณด๋ฉด
์ด ๊ฒฝ์ฐ, ๊ธฐ์กด์ ํ ์ธ๊ทธ๋จผํธ๋ฅผ ๋ชจ๋ ์ฌ์ฉํ๊ณ ๋๋ฉด ํ์ฅํ๋ ๊ณผ์ ์์ ์คํ ์ธ๊ทธ๋จผํธ์ ์ถฉ๋
์ด๋ฅผ ์ฝ๊ฒ ํด๊ฒฐํ๊ธฐ ์ํด ๋ฆฌ๋ ์ค๋ ์คํ์ ๋ฉ๋ชจ๋ฆฌ์ ๋์ ์์น์ํค๊ณ , ํ๊ณผ ์คํ์ ๋ฐ๋๋ก ์๋๋ค๋ฉด
ํ๊ณผ ์คํ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ต๋ํ ์์ ๋กญ๊ฒ ์ฌ์ฉํ ์ ์์ผ๋ฉฐ, ์ถฉ๋ ๋ฌธ์ ๋ก ๋ถํฐ๋ ๋น๊ต์ ์์ !!
C์ธ์ด์์ malloc(), calloc() ๋ฑ์ด ํ ๋น๋ฐ๋ ๋ฉ๋ชจ๋ฆฌ๊ฐ ์ด ์ธ๊ทธ๋จผํธ์ ํด๋น๋๋ฉฐ.
์ผ๋ฐ์ ์ผ๋ก ์ฝ๊ธฐ์ ์ฐ๊ธฐ ๊ถํ์ด ๋ถ์ฌ๋จ
์๋ ์ฝ๋๋ heap_data_ptr์ malloc()์ผ๋ก ๋์ ํ ๋นํ ์์ญ์ ์ฃผ์๋ฅผ ๋์ ํ๊ณ , ๊ทธ ์์ญ์ ๊ฐ ์ฌ์ฉ
heap_data_ptr์ ์ง์ญ๋ณ์์ด๋ฏ๋ก ์คํ์ ์์นํ๋ฉฐ, malloc์ผ๋ก ํ ๋น๋ฐ์ ํ ์ธ๊ทธ๋จผํธ์ ์ฃผ์๋ฅผ ๊ฐ๋ฅดํด
int main() {
int *heap_data_ptr =
malloc(sizeof(*heap_data_ptr)); // ๋์ ํ ๋นํ ํ ์์ญ์ ์ฃผ์๋ฅผ ๊ฐ๋ฆฌํด
*heap_data_ptr = 31337; // ํ ์์ญ์ ๊ฐ์ ์
printf("%d\n", *heap_data_ptr); // ํ ์์ญ์ ๊ฐ์ ์ฌ์ฉํจ
return 0;
}
๊ฒฐ๋ก
์ธ๊ทธ๋จผํธ | ์ญํ | ์ผ๋ฐ์ ์ธ ๊ถํ | ์ฌ์ฉ ์ |
์ฝ๋ ์ธ๊ทธ๋จผํธ | ์คํ ๊ฐ๋ฅํ ์ฝ๋๊ฐ ์ ์ฅ๋ ์์ญ | ์ฝ๊ธฐ, ์คํ | main() ๋ฑ์ ํจ์ ์ฝ๋ |
๋ฐ์ดํฐ ์ธ๊ทธ๋จผํธ | ์ด๊ธฐํ๋ ์ ์ญ ๋ณ์ ๋๋ ์์๊ฐ ์์นํ๋ ์์ญ | ์ฝ๊ธฐ์ ์ฐ๊ธฐ ๋๋ ์ฝ๊ธฐ ์ ์ฉ | ์ด๊ธฐํ๋ ์ ์ญ ๋ณ์, ์ ์ญ ์์ |
BSS ์ธ๊ทธ๋จผํธ | ์ด๊ธฐํ๋์ง ์์ ๋ฐ์ดํฐ๊ฐ ์์นํ๋ ์์ญ | ์ฝ๊ธฐ, ์ฐ๊ธฐ | ์ด๊ธฐํ๋์ง ์์ ์ ์ญ ๋ณ์ |
์คํ ์ธ๊ทธ๋จผํธ | ์์ ๋ณ์๊ฐ ์ ์ฅ๋๋ ์์ญ | ์ฝ๊ธฐ, ์ฐ๊ธฐ | ์ง์ญ ๋ณ์, ํจ์์ ์ธ์ ๋ฑ |
ํ ์ธ๊ทธ๋จผํธ | ์คํ์ค์ ๋์ ์ผ๋ก ์ฌ์ฉ๋๋ ์์ญ | ์ฝ๊ธฐ, ์ฐ๊ธฐ | malloc(), calloc() ๋ฑ์ผ๋ก ํ ๋น ๋ฐ์ ๋ฉ๋ชจ๋ฆฌ |
์ฐธ๊ณ ์๋ฃ(๋จ, ์ ๋ถ๋ถ์ ์ ๊ฐ ๋ฐฐ์ด ๋ด์ฉ ์์ฝ์ ๊ฐ๊น๊ธฐ ๋๋ฌธ์ ๊ฑฐ์ ์ ๋ด์ฉ๊ณผ ๊ฐ์ต๋๋ค.)
์ฐธ๊ณ ์ด๋ฏธ์ง
'๐โSystem_Study > ๐โDreamhack_Hacking' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
Tool: pwntools (4) | 2022.04.04 |
---|---|
Tool: gdb (0) | 2022.03.29 |
Quiz: x86 Assembly (0) | 2022.03.27 |
x86 Assembly: Essential Part (0) | 2022.03.24 |
Computer Architecture (0) | 2022.03.21 |