๋ค์ด๊ฐ๋ฉฐ
์ฐ๋ฆฌ์ ๋ชฉ์ ์ ์ปดํจํฐ์ ์์คํ ์ ์ ์ดํดํ๊ณ , ์ทจ์ฝ์ ์ ์์๋ด๋ ๊ฒ์ด๋ค. ์ปดํจํฐ์ ๋ฐ์ดํฐ๋ค์ ๋ฉ๋ชจ๋ฆฌ๋ผ๋ ๊ณต๊ฐ์ ๋ค์ด์๋ค. ํ๊ฐ ์์ด ๋ฉ๋ชจ๋ฆฌ๋ค์ ์์ ํ๊ฑฐ๋, ๋ฎ์ด์ฐ๊ฑฐ๋ ํ๋ ๋ฑ์ ํ์๋ฅผ ํ๊ธฐ ์ํด์๋ ๋ฉ๋ชจ๋ฆฌ์ ๋ฐ์ดํฐ๋ค์ด ์ด๋ป๊ฒ ๋๋์ด์ ์ ์ฅ๋์ด ์์ผ๋ฉฐ, ๊ทธ ๋ฐ์ดํฐ๋ค์ ์ฉ๋๋ ๋ฌด์์ด๊ณ ์ผ๋ง๋ ์ ๊ทผ๊ฐ๋ฅํ์ง์ ๋ํ์ฌ ์์์ผํ๋ค.
- ์ปดํจํฐ๋ CPU์์ ์ฐ์ฐ์ ํ์ง๋ง, ๋ฉ๋ชจ๋ฆฌ์์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์ ์ฐ์ฐ์ ํ๋ค.
- ๊ทธ๋ฆฌ๊ณ ISA์ ๋ฐ๋ผ์ ๋ช ๋ น์ด๋ฅผ ์ฒ๋ฆฌํ๋ค.
- ๋ฐ๋ผ์ ๋ง์ฝ ๋ฉ๋ชจ๋ฆฌ๊ฐ ์ค์ผ๋๋ค๋ฉด, ์ด์ํ ๋ฐ์ดํฐ๋ก CPU๊ฐ ์ด์ํ ์ฐ์ฐ์ ํ๊ฒ ๋์ด๋ฒ๋ฆฐ๋ค. ์ด๋ฅผ ๋ฉ๋ชจ๋ฆฌ ์ค์ผ(Memory Corruption)์ด๋ผ๊ณ ํ๋ค.
- ๋ฐ๋ผ์ ๋ฉ๋ชจ๋ฆฌ ์ค์ผ์ ๋ฐฉ์ด/ํน์ ์ ๋ฐํ๋ ค๋ฉด ๋ฉ๋ชจ๋ฆฌ ๋ ์ด์์์ ๋ํ ์ดํด๊ฐ ํ์์ ์ด๋ค.
CPU๋ ๋ฉ๋ชจ๋ฆฌ, ๋ ์ง์คํฐ์ ๊ฐ์ ์ ๋ฐ์ ์ธ ์ปดํจํฐ ๊ตฌ์กฐ์ ๋ํด ์ ๋ชจ๋ฅธ๋ค๋ฉด ์ฌ๊ธฐ๋ฅผ ์ฐธ๊ณ ํ์!
๐ ๋ฉ๋ชจ๋ฆฌ ๋ ์ด์์
๋ฉ๋ชจ๋ฆฌ๋ ๊ฒฐ๊ตญ ์์์ด ๋ค์ด์๋ ์์๋ผ๊ณ ๋ณผ ์ ์๊ณ , ๊ทธ ์์์๋ ์์์ ์ข
๋ฅ ๋ฐ ์ฉ๋์ ๋ฐ๋ผ ์๋์ผ๋ก ๋๋ ๋จ๋ค. ์๋ฅผ๋ค์ด ์ท์ฅ์ ๋ฐ์ง ๋ฃ๋ ์๋, ์์ ๋ฃ๋ ์๋์ผ๋ก ๋๋ ๋ ๊ฒ์ฒ๋ผ !
์ฌ๊ธฐ์ ์ฐ๋ฆฌ๋ ์๋์ ‘์ธ๊ทธ๋จผํธ’๋ผ๊ณ ๋ถ๋ฅด๊ธฐ๋ก ํ๋ค. ์ด์ ๋ฐ์ง ์๋์ ๋ฐ์ง ์ธ๊ทธ๋จผํธ๋ผ๊ณ ๋ถ๋ฅด๋ ๊ฒ์ด๋ค. ์ธ๊ทธ๋จผํธ๋ค์๋ ์ด๋ฆ์ด ์๋ค. ์ด์ ๊ทธ๊ฑธ ์ดํด๋ณด์.
์ด๋ฐ ๋ฐฉ์์ผ๋ก ํ๋ก์ธ์ค๋ผ๋ ํฐ ์์ ์์ ์ฌ๋ฌ ์๋, ์ฆ ์ธ๊ทธ๋จผํธ๊ฐ ์กด์ฌํ๊ณ , ๊ทธ ์ธ๊ทธ๋จผํธ๋ ๋ค์ด๊ฐ์๋ ๋ฐ์ดํฐ์ ๊ทธ์ ์ฉ๋์ ๋ฐ๋ผ ๋๋์ด์ ธ์๋ค. ๋ง์น ๋ฐ์ง๋ฅผ ๋ฃ๋ ์๋๊ณผ ์์๋ฅผ ๋ฃ๋ ์๋์ด ๋ค๋ฅด๊ณ , ์๋ฐ์ง๋ฅผ ๋ฃ๋ ์๋๊ณผ ๊ทธ๋ฅ ๋ฐ์ง๋ฅผ ๋ฃ๋ ์๋์ด ๋ค๋ฅด๋ฏ์ด ๋ง์ด๋ค.
ํ์ง๋ง ์ด ์ธ๊ทธ๋จผํธ๋ค์ ๊ทธ์ ์๋๊ณผ๋ ๋ค๋ฅธ ๋ถ๋ถ์ด ์๋ค. ์ธ๊ทธ๋จผํธ๋ ์ธ๊ทธ๋จผํธ์ ๋ฐ๋ผ ํ ์ ์๋ ์์
์ด ๋ค ๋ค๋ฅด๋ค. ์๋ฅผ ๋ค๋ฉด, ์ฝ๋๊ฐ ์ ์ฅ๋๋ ์ฝ๋ ์ธ๊ทธ๋จผํธ์ ๊ฒฝ์ฐ ์ฝ๊ธฐ(r), ์คํ(x)์ ๊ฐ๋ฅํ์ง๋ง ์ฐ๊ธฐ(w)๋ ๋ถ๊ฐ๋ฅํ๋ค. ์ฐ๊ธฐ ๊ถํ์ ์ค ๊ฒฝ์ฐ ์ด๋ฏธ ์คํ๊ถํ๋ ์๋๋ฐ ์ด์ํ ๊ฑธ ์์ฑํด์ ์คํ์ํฌ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค.
์ด์ฒ๋ผ ๊ฐ ์ธ๊ทธ๋จผํธ์๋ ๋ค์ด๊ฐ๋ ๋ฐ์ดํฐ๋ฟ๋ง ์๋๋ผ ๊ถํ(r,w,x)์ด๋ผ๋ ํน์ฑ๋ ๋ถ์ฌ๋์ด์๋ค๋ ์ ๋ ๊ธฐ์ตํ์.
์ธ๊ทธ๋จผํธ ์ข
๋ฅ
๋ฉ๋ชจ๋ฆฌ์๋ ์๋์ ๊ฐ์ ์ธ๊ทธ๋จผํธ๋ค์ด ์กด์ฌํ๋ค.
- ๐ฉ๐ป ์ฝ๋ ์ธ๊ทธ๋จผํธ (ํ ์คํธ ์ธ๊ทธ๋จผํธ)
- ๐ ๋ฐ์ดํฐ ์ธ๊ทธ๋จผํธ (data, rodata)
- 0๏ธโฃ BSS ์ธ๊ทธ๋จผํธ
- ํ ์ธ๊ทธ๋จผํธ
- ๐ ์คํ ์ธ๊ทธ๋จผํธ
๊ทธ๋ผ ์ด์ ๋ณธ๊ฒฉ์ ์ผ๋ก ๊ฐ๊ฐ์ ์ธ๊ทธ๋จผํธ(์๋)์ ์ด๋ค ๋ฐ์ดํฐ(์ท)์ด ๋ค์ด๊ฐ๊ณ , ๊ทธ ์ธ๊ทธ๋จผํธ์ ํน์ง์ ๋ฌด์์ธ์ง ์์๋ณด๋๋ก ํ์! ์ฌ๊ธฐ์๋ ์น๊ทผํ๊ฒ ์น๊ตฌ ๋ฐฉ์์ผ๋ก ์ฐ๊ฒ ๋ค ๐
๐ฉ๐ป ์ฝ๋ ์ธ๊ทธ๋จผํธ
- ์คํํ ์ ์๋ ์ฝ๋(ex: ํจ์ ๋ฑ)์ด ์ ์ฅ๋ผ!
- ์ฌ์ค ์ฝ๋๋ค์ ์ปดํ์ผ ๋๋ฉด 5ab20ff ์ด๋ฐ์์ผ๋ก ์ด์ํ ๊ธฐ๊ณ์ด๋ก ๋ณํ๋๊ฑฐ๋ ~ ๊ทธ๋ ์ด๋ฌํ ๊ธฐ๊ณ์ด๋ค์ ์ฝ๋ ์ธ๊ทธ๋จผํธ์ ์ ์ฅํ๊ฒ๋๋ ๋ฐฉ์์ด์ผ!
- ์ฝ๊ธฐ/์คํ ๊ถํ์ ์์ง๋ง ์ฐ๊ธฐ ๊ถํ์ ์์ด! ์๋ํ๋ฉด ์ฐ๊ธฐ ๊ถํ์ด ๋ถ์ฌ๋ ๊ฒฝ์ฐ ์ ์์ ์ธ ๊ณต๊ฒฉ์๊ฐ ์ด์ํ ์ฝ๋๋ฅผ ์์ฑํ ์๋ ์๊ฑฐ๋ (๊ทธ๋ฐ๋ฐ ๋ฐ์ดํฐ ์ธ๊ทธ๋จผํธ์์๋ ์ฐ๊ธฐ ๊ฐ๋ฅํ๋๋ฐ.. ์๋ ์ ๋์ง? ๊ฐ์๊ธฐ ๊ณต๋ถ ํ์)
- ์ฝ๋๋ ํ ์คํธ์ด๋ฏ๋ก ํ ์คํธ ์ธ๊ทธ๋จผํธ๋ผ๊ณ ๋ถ๋ฆฌ๊ธฐ๋ ํด~
int main(void) {
printf("hi");
return 0;
}
์ด๋ฐ ์ฝ๋๊ฐ ์ ์ฅ๋๋ ๊ณณ์ด ์ฝ๋ ์ธ๊ทธ๋จผํธ๊ฐ ๋๋ ๊ฑฐ์ง!
๐ ๋ฐ์ดํฐ ์ธ๊ทธ๋จผํธ
์ฐ๋ฆฌ์ ๋๋ฒ์งธ ์๋, ๋ฐ์ดํฐ ์ธ๊ทธ๋จผํธ์ผ!
- ์ฌ๊ธฐ์๋ ์ด๋ฏธ ์ด๊ธฐํ๋ ์ ์ญ๋ณ์ ํน์ ์์๋ฑ์ด ์ ์ฅ๋ผ.
- ๋น์ฐํ ์ฝ๊ธฐ๊ถํ์ด ๋ถ์ฌ๋์ด์๊ฒ ์ง?
๋ฐ์ดํฐ ์ธ๊ทธ๋จผํธ๋ ๊ถํ ๋ฐ ์ฉ๋์ ๋ฐ๋ผ ๋ ๋ถ๋ถ์ผ๋ก ๋๋์ด์ ธ ์์ด!
rodata (๐)data (๐โ๏ธ)
- Read-Only data์ ์ฝ์์ฌ์ ์ฝ๊ธฐ๋ง ๊ฐ๋ฅํด!
- ์ ์ญ ์์ ๋ฑ์ด ์ฌ๊ธฐ์ ์ํ๊ฒ ์ง? ์์๋ ํ๋ฒ ์ ์ธํ๋ฉด ์์ ์ด ๋ถ๊ฐ๋ฅํ๋๊น ๋ง์ด์ผ~
data (๐โ๏ธ)
- ์ฝ๊ธฐ, ์ฐ๊ธฐ ๋ชจ๋ ๊ฐ๋ฅํด!
- ์ด๊ธฐํ๋ ์ ์ญ ๋ณ์ ๋ฑ์ด ๋ค์ด๊ฐ๊ฒ ๋๊ฒ ์ง?
0๏ธโฃ BSS ์ธ๊ทธ๋จผํธ
- Block Started By Symbol Segment ์ ์ฝ์
- ์ปดํ์ผ ์์ ์ ๊ฐ์ด ‘์ ํด์ง์ง ์์’ ์ ์ญ ๋ณ์ ๋ฑ์ ์ ์ฅํด!
- ์ด๋ฐ ๋ณ์๋ค์ ํ๋ก๊ทธ๋จ ์์ํ ๋ ์๋์ผ๋ก ๋ค 0์ผ๋ก ์ด๊ธฐํ ๋๋! ๐ฎ
- ์ฝ๊ธฐ์ ์ฐ๊ธฐ ๊ถํ์ด ์์ด!
int bss_data; //์ด๊ธฐํ ์ํด์คฌ์ผ๋ฏ๋ก bss ์ธ๊ทธ๋จผํธ์ ์ ์ฅ๋จ
int main()
{ printf("%d\n", bss_data); // 0 (0์ผ๋ก ์๋์ผ๋ก ์ด๊ธฐํ๋จ)
return 0;}
๐ ์คํ ์ธ๊ทธ๋จผํธ
์ด์ ์คํ ์ธ๊ทธ๋จผํธ์ผ! ๊ฑฐ์ ๋ค์์ผ๋ ์กฐ๊ธ๋ง ํ๋ด์! ์ฌ๊ธฐ์ ๋์ค๋ ์คํ ํ๋ ์์ ๋ํด์๋ ๋ค๋ฅธ ํฌ์คํธ๋ก ์ข ๋ ์์ธํ ๋ค๋ค๋ณผ ์์ ์ด๋ ๊ธฐ๋ํด์ค ๐
- ํ๋ก์ธ์ค์ ์คํ์ด ์์นํ๋ ์์ญ์ด์ผ!
- ์ฝ๊ธฐ์ ์ฐ๊ธฐ ๊ถํ์ด ๋ถ์ฌ๋์ด์์ด
- ํจ์์ ์ธ์ (๋งค๊ฐ๋ณ์)๋ ์ง์ญ ๋ณ์์ ๊ฐ์ ์์ ๋ณ์๊ฐ ์ ์ฅ๋ผ.
- ์คํ ์์ญ์ ์ ์ฅ๋๋ ํจ์์ ํธ์ถ ์ ๋ณด๋ฅผ ์คํ ํ๋ ์(stack frame)์ด๋ผ๊ณ ํด
- ์ฆ, ์คํ ํ๋ ์์ด๋ผ๋ ๋จ์๋ก ์คํ์ด ์ธ๊ทธ๋จผํธ๊ฐ ์คํ์ด๋๋๋ฐ, ์ด ์คํ ํ๋ ์์ ์ฌ์ฉ์์ ์ธํ ๋ฑ์ ๋ฐ๋ผ ํฌ๊ธฐ๊ฐ ๋ฌ๋ผ์ง ์๊ฐ ์์ด์ ํฌ๊ธฐ ์์ธก์ด ๋ถ๊ฐ๋ฅํด. ์๋ฅผ ๋ค์ด ์กฐ๊ฑด๋ฌธ์ ํตํด ๋ถ๊ธฐ๊ฐ ๋๋ ๊ฒฝ์ฐ๋ฅผ ๋ค ์ ์๊ฒ ์ง? -> ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ์คํ์์๋ ์ ๋์ ์ผ๋ก ๊ฐ์ ํ ๋นํด์ฃผ๊ฒ ๋ผ. ๊ทธ๋ฆฌ๊ณ ๋ถ์กฑํด์ง ๋๋ง๋ค ์ด๋ฅผ ํ์ฅํด์ฃผ๊ฒ๋์ง.
- ์ฃผ์๊ฐ ์ค์ด๋๋ ๋ฐฉํฅ์ผ๋ก ์๋ผ๋.(์๋ฐฉํฅ์ผ๋ก ์๋ผ!)
- ์คํ ์์ญ์ ํจ์์ ํธ์ถ๊ณผ ํจ๊ป ํ ๋น๋๊ณ , ํจ์์ ํธ์ถ์ด ์๋ฃ๋๋ฉด ์๋ฉธํ๊ฒ ๋ผ.
- ๋ ์ง์คํฐ๋ ํ๊ฒฝ๋ณ์ ์ ๋ณด๋ ์คํ์ ์ ์ฅ๋๋ ๊ฒ ๊ฐ์(ํ์คํ์ง ์์ผ๋ ๊ณต๋ถ ํ์)
- ๋ฐฐ์ด๋ ์คํ ์์ญ์ ์ ์ฅ๋๋ค๊ณ ํด(ํ์คํ์ง ์์ผ๋ ๊ณต๋ถ ํ์)
void func() { //ํจ์์คํ์ ์คํ ํ๋ ์ ์์ฑ
int choice = 0; //์ด๋ ๊ฒ ์ง์ญ๋ณ์๊ฐ์ ์ ๋ค์ด ์คํ์ ์ ์ฅ๋จ
scanf("%d", &choice);
if (choice) //choice์ ๋ฐ๋ผ์ ์ด๋ค ํจ์๊ฐ ์คํ๋ ์ง ๋ฌ๋ผ์ง -> stack frame์ ์์ธก ๋ถ๊ฐ๋ฅ !!
call_true();
else
call_false();
return 0;
} //ํจ์ ๋ฐํํ์ผ๋ฏ๋ก ์คํ ํ๋ ์ ํด์
๐ฅ ํ ์ธ๊ทธ๋จผํธ
- ํ ์ธ๊ทธ๋จผํธ์๋ ํฌ์ธํฐ๋ค์ด ๋์ ์ผ๋ก ํ ๋น๋ฐ์ ๋ฉ๋ชจ๋ฆฌ๋ค์ด ์ ์ฅ๋ผ!
- Java ๋ C++ ๋ฑ์์๋ 'new' ๋ฅผ ํตํด, C์์ 'malloc', 'calloc' ๋ฑ์ ํตํด ๊ฐ์ ธ์ค๋ ๋ฉ๋ชจ๋ฆฌ๋ค์ด ํ์ ์๋ ๋ฉ๋ชจ๋ฆฌ์ผ!
- ์คํ๊ณผ ๋ฐ๋ ๋ฐฉํฅ์ผ๋ก ์๋ผ! (์๋๋ฐฉํฅ์ด์ง๋ง ์ฃผ์๊ฐ ๋์ด๋๋ ๋ฐฉํฅ์ด์ผ)
- calloc(), malloc() ๋ฑ์ ์ํด ํ ๋น๋ฐ์ ๋ฉ๋ชจ๋ฆฌ๋ค์ด ์ฌ๊ธฐ ์์ด! ํฌ์ธํฐ๋ ์คํ์ ์์ผ๋ ํท๊ฐ๋ฆฌ์ง๋ง๊ตฌ!
- ํ๋ก๊ทธ๋จ ์คํ ์ค(Runtime)์ ๊ฒฐ์ ๋ผ!
- ์ฝ๊ธฐ์ ์ฐ๊ธฐ ๊ถํ์ด ์์ด!
๊ทธ๋ ๋ค๋ฉด ํ๊ณผ ์คํ์ ์ ๋ฐ๋ ๋ฐฉํฅ์ผ๋ก ์๋ผ๋ ๊ฑธ๊น?
ํ๊ณผ ์ธ๊ทธ๋จผํธ๊ฐ ๋์ผํ ๋ฐฉํฅ์ผ๋ก ์๋๋ค๊ณ ์๊ฐํด๋ณด์. ๊ทธ๋ฌ๋ฉด ๋ง์ฝ ํ ๋น๋ ํ ์ธ๊ทธ๋จผํธ์ ์์ ๋ค ์ผ๋ค๋ฉด ์ด๋ฅผ ํ์ฅํ๋ ๊ณผ์ ์์ ์คํ ์ธ๊ทธ๋จผํธ ๋ถ๋ถ์ ์นจ๋ฒํ๊ฒ ๋๊ฒ ์ง?
ํ์ง๋ง ๋ฐ๋ ๋ฐฉํฅ์ผ๋ก ์๋ก ์๋ผ๊ฒํ๋ฉด ์ด๋ฐ ์ถฉ๋๋ฌธ์ ์ ๋ํด ์ข ๋ ์์ ๋ก์์ง ์ ์๊ฒ ์ง~
์๋ ์์ ์ฝ๋๋ heap_data_ptr์ malloc()์ผ๋ก ๋์ ํ ๋นํ ์์ญ์ ์ฃผ์๋ฅผ ๋์ ํ๊ณ , ์ด ์์ญ(heap)์ ๊ฐ์ ์ฐ๊ฒ๋ผ.
int main() {
int *heap_data_ptr = //ํฌ์ธํฐ ๋ณ์๋ ์คํ์ ์ ์ฅ
malloc(sizeof(*heap_data_ptr)); // ๋์ ํ ๋นํ ํ ์์ญ์ ์ฃผ์๋ฅผ ๊ฐ๋ฆฌํด
*heap_data_ptr = 31337; // ํ ์์ญ์ ๊ฐ์ ์
printf("%d\n", *heap_data_ptr); // ํ ์์ญ์ ๊ฐ์ ์ฌ์ฉํจ
return 0;
}
์ ๋ฆฌ
์ธ๊ทธ๋จผํธ | ์ญํ | ๊ถํ | ์์ |
์ฝ๋ ์ธ๊ทธ๋จผํธ | ์คํ ๊ฐ๋ฅํ ์ฝ๋๊ฐ ์ ์ฅ๋์ด์๋ ์์ญ | r,x | int main(){...} |
๋ฐ์ดํฐ ์ธ๊ทธ๋จผํธ | ์ด๊ธฐํ๋ ์ ์ญ ๋ณ์ ๋ฐ ์์๊ฐ ์ ์ฅ๋์ด์๋ ์์ญ | r,w/r | int a=0; int NUM 10; |
BSS ์ธ๊ทธ๋จผํธ | ์ด๊ธฐํ๋์ง ์์ ๋ฐ์ดํฐ๊ฐ ์ ์ฅ๋์ด์๋ ์์ญ | r,w | int a; |
ํ ์ธ๊ทธ๋จผํธ | ๋์ ํ ๋น์ ํตํด ํ ๋น๋ฐ์ ๋ฉ๋ชจ๋ฆฌ๊ฐ ์๋ ์์ญ | r,w | malloc(), calloc(), new()๋ฑ์ผ๋ก ํ ๋น๋ฐ์ ๋ฉ๋ชจ๋ฆฌ |
์คํ ์ธ๊ทธ๋จผํธ | ์์๋ณ์ (ํจ์์ ๋งค๊ฐ๋ณ์, ์ง์ญ๋ณ์ ๋ฑ) | r,w | int fnc(int i){};์์ i์ ๊ฐ ๋ฑ |
์์
#include <stdlib.h>
int a = 0xa; //a๋ ์ด๊ธฐํ๋ ์ ์ญ๋ณ์์ด๋ฏ๋ก data ์ธ๊ทธ๋จผํธ์ ์ ์ฅ
const char b[] = "d_str"; //"d_str"๋ ์ด๊ธฐํ๋ ์์์ด๋ฏ๋ก rodata ์ธ๊ทธ๋จผํธ์ ์ ์ฅ
int c; //์ด๊ธฐํ๋์ง ์์์ผ๋ฏ๋ก BSS ์ธ๊ทธ๋จผํธ์ ์ ์ฅ
int foo(int arg) { //foo()ํจ์๋ ์ฝ๋ ์ธ๊ทธ๋จผํธ์ ์ ์ฅ
int d = 0xd; //d๋ ์ง์ญ ๋ณ์์ด๋ฏ๋ก ์คํ์ ์ ์ฅ
return 0;
}
int main() //main()ํจ์๋ ์ฝ๋ ์ธ๊ทธ๋จผํธ์ ์ ์ฅ
{
int *e = malloc(sizeof(*e)); //e๋ ์คํ์, e๊ฐ ์ฐธ์กฐํ๋ ๋ฉ๋ชจ๋ฆฌ๋ ํ์ ๋ฉ๋ชจ๋ฆฌ
return 0;
}
์ค๋์ ์ปดํจํฐ ๊ตฌ์กฐ์์ ์ค์ํ ๋ฉ๋ชจ๋ฆฌ ๊ตฌ์กฐ์ ๋ํด ์์๋ณด์๋ค. ๋ค์ ํฌ์คํธ๋ ์ด์ ๋ธ๋ฆฌ์ด ๊ด๋ จ ํฌ์คํ ์ด ๋ ์์ ์ด๋ค.
Reference
https://dreamhack.io/
์์คํ
ํดํน stage 2 ๊ณต๋ถ ๋ด์ฉ ์ ๋ฆฌ
'๐ฅ๏ธ Computer Science > System' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[System] ๋ฉ๋ชจ๋ฆฌ ์ฃผ์ (x64, x32, 64bit, 32bit) (0) | 2023.03.29 |
---|---|
[Pwnable] ์์คํ ์ฝ(syscall), ์ ธ, ์ปค๋๋ชจ๋ vs ์ ์ ๋ชจ๋ (0) | 2023.03.26 |
[Assembly] ์ด์ ๋ธ๋ฆฌ์ด ํ์ ๋ช ๋ น์ด ์ ๋ฆฌ๋ณธ (์คํ ๊ด๋ จ) (0) | 2023.03.26 |
[Assembly] x86 ์ด์ ๋ธ๋ฆฌ ํท๊ฐ๋ฆฌ๋ mov, PTR ์ ๋ฆฌ (0) | 2023.03.19 |
[System] ์ปดํจํฐ ๊ตฌ์กฐ, ํฐ ๋ ธ์ด๋ง ๊ตฌ์กฐ, x86-64, ๋ ์ง์คํฐ (0) | 2023.03.17 |