1. ๋ฆฌํ์๋์ธ ํ๊ธฐ๋ฒ
(1) ๋ฐ์ดํธ ์ค๋๋ง
- ์ปดํจํฐ์์ ๋ฉ๋ชจ๋ฆฌ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ๋ฐฉ์
- ๋น ์๋์ธ(Big Endian)๊ณผ ๋ฆฌํ ์๋์ธ(Little Endian) ๋ ๊ฐ์ง ๋ฐฉ์์ด ์กด์ฌ
- ๋น ์๋์ธ - ์์๋๋ก ํ๊ธฐ
- ๋ฆฌํ ์๋์ธ - ์ญ์์ผ๋ก ํ๊ธฐ
- intel x86 CPU(Windows ๊ณ์ด)์ด ์ฌ์ฉ
BYTE b = 0x12; //0x.. -> 16์ง์
WORD w = 0x1234;
DWORD dw = 0x12345678;
char str[] = "abcde";
Type | Name | Size | ๋น ์๋์ธ | ๋ฆฌํ ์๋์ธ |
BYTE | b | 1 | [12] | [12] |
WORD | w | 2 | [12][34] | [34][12] |
DWORD | dw | 4 | [12][34][56][78] | [78][56][34][12] |
char [] | str | 6 | [61][62][63][64][65][00] | [61][62][63][64][65][00] |
์์คํค ๋ฌธ์์์ 'a'๋ 0x61๊ณผ ๊ฐ๊ณ , ๋ฌธ์์ด์ ๋ง์ง๋ง์ null๋ก ๋๋๋ค.
(2) ๋๋ฒ๊น ํ์ฌ ํ์ธํ๊ธฐ
#include "windows.h"
BYTE b = 0x12;
WORD w = 0x1234;
DWORD dw = 0x12345678;
char str[] = "abcde";
int main(int argc, char *argv[]) {
BYTE Ib = b;
WORD Iw = w;
DWORD Idw = dw;
char *Istr = str;
return 0;
}
- main() ํ์ธ
exit ์ง์ ์ call์ด main์ธ ํ๋ฅ ์ด ๋์
main()ํจ์๋ฅผ ์ฐพ๊ธฐ ์ฝ๊ฒ ์ฝ๋ฉํ๋ ค๋ฉด printf ๋ฑ์ ๋ฃ์ผ๋ฉด ์ข์
- ์คํํด๋ณด์์ ๋ exit ๋จ๊ธฐ ์ ์ call์ ๋ค์ด๊ฐ๋ณด๋ฉด, ์ฝ๋๋ก ์์ฑํ ๋ด์ฉ์ด ๋ณด์ธ๋ค.
- ๋ฐ์ดํธ์ค๋๋ง ํ์ธ
- 403018 ํ์ธ (BYTE)
- ๋ฐ์ดํธ ํ์ ์ b ๋ณ์๋ฅผ ์ ์ฅํ ๋์๋ ์ ๋ ฅํ ๊ทธ๋๋ก ์ ์ฅ์ด ๋จ
- 403020 ํ์ธ (WORD)
- 2๋ฐ์ดํธ ์ด์์ ํฌ๊ธฐ๋ฅผ ๊ฐ์ง ์๋ฃํ์ ์ ์ฅํ ๋๋ถํฐ ๋ฆฌํ ์๋์ ํ์ธ ๊ฐ๋ฅ
- 12 34๊ฐ ์๋ ๋ฆฌํ ์๋์ ๋ฐฉ์์ด๊ธฐ ๋๋ฌธ์ ์ญ์์ผ๋ก 34 12๋ก ๋ฐ์ดํฐ๊ฐ ์ ์ฅ์ด ๋์ด์๋ค.
- ๋ฆฌํ ์๋์ธ์ด๋ผ๋ ๋ฐ์ดํธ ์์ฒด๋ ์ ์์ ์ธ ์์๋ก ์ ์ฅ๋๋ค. ์ค๋ก์ง ๋ฉํฐ ๋ฐ์ดํธ ๊ฐ์ ๊ฒฝ์ฐ ๊ฐ ๋ฐ์ดํธ๊ฐ ์ญ์์ผ๋ก ์ ์ฅ๋๋ ๊ฒ์ด๋ค.
- 40301c ํ์ธ (DWORD)
- DWORD ๋ํ ๋ฆฌํ ์๋์ ๋ฐฉ์์ผ๋ก 78 56 34 12๋ก ์ ์ฅ๋์ด ์๋ค.
- 403024 ํ์ธ (char)
- abcde๋ char์ด๊ธฐ ๋๋ฌธ์ ๋ฆฌํ์๋์๊ณผ ๋น ์๋์ ๋ฐฉ์์ ์์๊ฐ ๋๊ฐ๋ค.
- ๋ฌธ์์ด์ ๊ฒฐ๊ตญ ์บ๋ฆญํฐ(char)์ ๋ฐฐ์ด์ด๊ธฐ ๋๋ฌธ์ ๊ฐ ๋ฐ์ดํธ๋ฅผ ํ๋์ฉ ์ฐ์ํด์ ์ ์ฅํ๋ ๊ฐ๋
2. ๋ ์ง์คํฐ
- CPU ๋ ์ง์คํฐ: CPU ๋ด๋ถ์ ์กด์ฌํ๋ ๋ค๋ชฉ์ ์ ์ฅ ๊ณต๊ฐ
- CPU๊ฐ RAM์ ์๋ ๋ฐ์ดํฐ์ ์์ธ์คํ๊ธฐ ์ํด์๋ ๋ฌผ๋ฆฌ์ ์ธ ๊ฑฐ๋ฆฌ๊ฐ ๋ฉ๊ธฐ ๋๋ฌธ์ ์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆผ
- ๋ฐ๋ผ์, CPU์ ์๋ ๋ ์ง์คํฐ๋ฅผ ํตํด ๋น ๋ฅด๊ฒ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌ
- ๋ ์ง์คํฐ 'CPU๊ฐ ์ฌ์ฉํ๋ ๋ณ์' ๋ผ๊ณ ์๊ฐํ๋ฉด ํธํ๋ค.
IA-32์ ๋ ์ง์คํฐ
๊ฐ ๋ ์ง์คํฐ๋ค์ 32๋นํธ์ด์ง๋ง ์ํฉ์ ๋ฐ๋ผ ํจ์จ์ ์ผ๋ก ์ฌ์ฉํ๊ธฐ ์ํด ๋ช ๊ฐ์ ๊ตฌํ์ผ๋ก ๋๋์ด์ง๋ค.
์๋ฅผ ๋ค์ด 32๋นํธ์ธ EAX๋ ์ค 16๋นํธ๋ง ํ์ํ ๋ ํ์ 16๋นํธ์ธ AX๋ฅผ ์ฌ์ฉํ ์ ์๋ค.
AX๋ ๋ ์์ 8๋นํธ AH์ ํ์ 8๋นํธ AL๋ก ๋๋์ด์ง๋ค. ๋ง์ฐฌ๊ฐ์ง๋ก 8๋นํธ๋ง ์ฌ์ฉํ๊ณ ์ถ๋ค๋ฉด ์ด๋ค์ ์ฌ์ฉํ ์ ์๋ค.
- Basic program execution registers
- ๋ฒ์ฉ ๋ ์ง์คํฐ(General Purpose) : ๋ฒ์ฉ์ ์ผ๋ก ์ฌ์ฉ๋จ
- ํฌ๊ธฐ: 32๋นํธ (4๋ฐ์ดํธ)
- ์ฃผ๋ก ์ฐ์ ์ฐ์ฐ ๋ฑ์ ๋ช ๋ น์ด์์ ์์/๋ณ์ ๊ฐ์ ์ ์ฅ์ฉ๋๋ก ์ฌ์ฉ
- ์ด๋ค ๋ช
๋ น์ด๋ค์ ํน์ ๋ ์ง์คํฐ๋ฅผ ์ง์ ์กฐ์ํ๊ธฐ๋ ํจ (MUL, DIV ๋ฑ)
- EAX (Extended Accumlator Regiser): ์ฃผ๋ก ์ฐ์ ์ฐ์ฐ์ ์ฌ์ฉ๋จ(ํจ์ ๊ฒฐ๊ณผ๊ฐ์ ์ ์ฅํ๊ณ ๋ฆฌํด๊ฐ์ ์ ๋ฌํด์ค)
- ๋ฐ๋ณต๋ฌธ ๋ช ๋ น์ด(๋ฃจํ)์์ ๋ฐ๋ณต ์นด์ดํธ๋ก ์ฌ์ฉ๋จ //๋ฐ๋ณต์ ๋ ๋๋ง๋ค ECX๋ฅผ 1์ฉ ๊ฐ์์ํด
- ์ฝ๊ฒ ์๊ฐํ๋ฉด ํํ ์ฐ๋ ๋ณ์๋ฅผ ์๊ฐํ๋ฉด ์ฝ๊ณ , ์ฌ์น์ฐ์ฐ ๋ฑ์ ์์ฃผ ๋ฑ์ฅํ๋ค
- ํจ์์ ๋ฆฌํด๊ฐ์ด๋ return100, return Fa-lse ๋ฑ์ ์ฝ๋๋ฅผ ์ฌ์ฉํ ๋ return ๋ค์ ๊ฐ์ด EAX์ ๊ธฐ๋ก๋๋ค๊ณ ์๊ฐํ๋ฉด ๋๋ค.
- ECX (Extended Count Register): ๋ฃจํ๋ฌธ์ ์ํํ ๋ ์นด์ดํ
ํ๋ ์ญํ ์ ํ๋ค
- for (int i; i < 10; i++) { .. } ์ i ์ญํ ์ด๋ผ๊ณ ์๊ฐํ์
- C/C++์์๋ ๋ณดํต 0๋ถํฐ ํน์ ์กฐ๊ฑด์ผ๋ก ๋ฃจํ๋ฅผ ๋๋ฆฌ์ง๋ง, ECX๋ ๋ฐ๋๋ก ๋ฏธ๋ฆฌ ๋ฃจํ๋ฅผ ๋ ๊ฐ์ ์ ํด๋๊ณ 0๊น์ง i-- ์ฒ๋ผ ์ฐ์ฐํ๋ ๊ฒ์ด ํน์ง์ด๋ค.
- ์นด์ดํ ํ ํ์๊ฐ ์์ ๋๋ ์ผ๋ฐ ๋ณ์์ฒ๋ผ ์ฌ์ฉํด๋ ๋ฌด๋ฐฉํ๋ค
- EDX (Extended Data Register): ์ผ๋ฐ ์๋ฃ ์ ์ฅ (์
์ถ๋ ฅ ๋์์ ์ฌ์ฉ)
- ์๋ EAX์ฒ๋ผ ๋ณ์๋ผ๊ณ ์๊ฐํ๋ฉด ์ฌ์
- EAX์ ์ญํ ๊ฑฐ์ ๊ฐ์ง๋ง, ๋ฆฌํด๊ฐ์ ์ฉ๋๋ก ์ฌ์ฉX
- ๊ณฑํ๊ฑฐ๋ ๋ํ ๋ ๋ฑ ๋ณต์กํ ์ฐ์ฐ์ด ํ์ํ ๋ ๋ค์ผ๋ก ์ฐ์ด๊ธฐ๋ ํ๋ค
- EBX (Extended Base Register): ๋ฒ ์ด์ค ๋ ์ง์คํฐ, ํน์ ์ฃผ์ ์ ์ฅ
- ๋ณ๊ฑฐ ์๋ค๊ณ ์๊ฐํ๋ฉด ๋จ
- ์ด๋ค ๋ชฉ์ ์ ๊ฐ์ง๊ณ ๋ง๋ค์ด์ง ๋ ์ง์คํฐ๊ฐ ์๋
- ๋ ์ง์คํฐ๊ฐ ํ๋ ๋ ํ์ํ๊ฑฐ๋ ๊ณต๊ฐ์ด ํ์ํ ๋ ์ ๋นํ ์ฉ๋๋ฅผ ์์์ ๋ง๋ค์ด ์ฌ์ฉํ๋ค
- EAX, EDX, ECX๊ฐ ๋ถ์กฑํ ๋ ์ฌ์ฉํ๊ธฐ๋ ํจ
- EAX (Extended Accumlator Regiser): ์ฃผ๋ก ์ฐ์ ์ฐ์ฐ์ ์ฌ์ฉ๋จ(ํจ์ ๊ฒฐ๊ณผ๊ฐ์ ์ ์ฅํ๊ณ ๋ฆฌํด๊ฐ์ ์ ๋ฌํด์ค)
- ํฌ๊ธฐ: 32๋นํธ (4๋ฐ์ดํธ)
- ์ธ๋ฑ์ค ๋ ์ง์คํฐ
- ํฌ๊ธฐ: 32๋นํธ(4๋ฐ์ดํธ)
- ESI (Extended Source Index): ์ถ๋ฐ์ง ์ธ๋ฑ์ค (์ถ๋ฐ์ง ์ฃผ์์ ๋ํ ๊ฐ ์ ์ฅ)
- EDI (Extended Destination Index): ๋ชฉ์ ์ง ์ธ๋ฑ์ค (๋ชฉ์ ์ง ์ฃผ์์ ๋ํ ๊ฐ ์ ์ฅ)
- ๋ฌธ์์ด์ด๋ ๊ฐ์ข ๋ฐ๋ณต ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌ ๋๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฎ๊ธฐ๋๋ฐ ์ฌ์ฉ๋๋ค
- ํฌ์ธํฐ ๋ ์ง์คํฐ(Pointer Register)
- ํฌ๊ธฐ: 32๋นํธ(4๋ฐ์ดํธ)
- ์คํ์ ๋์ ์ฃผ์ ๋ถํฐ ๋ฎ์ ์ฃผ์๋ก ์ฐ์ฌ์ง๋ ํน์ง์ ๊ฐ์ง๋ค. (์ฆ ๋์ ์ฃผ์์ ๋จผ์ ๋ฐ์ดํฐ๊ฐ ๋ค์ด๊ฐ๋ค.)
- EBP (Extended Base Pointer): ํ์ฌ ์คํ์ ๊ฐ์ฅ ๋ฎ์ ์์น์ ์๋ ๋ฐ์ดํฐ๋ฅผ ๊ฐ๋ฅดํค๋ ํฌ์ธํฐ
- ESP (Extended Stack Pointer): ํ์ฌ ์คํ์ ๊ฐ์ฅ ๋์ ์์น์ ์๋ ๋ฐ์ดํฐ๋ฅผ ๊ฐ๋ฅดํค๋ ํฌ์ธํฐ
- ์ด๋ค ๋ช ๋ น์ด๋ค์ ESP๋ฅผ ์ง์ ์กฐ์ํ๊ธฐ๋ ํจ
- ESP๋ ๋งค์ฐ ์ค์ํ๋ฏ๋ก, ๋ค๋ฅธ ์ฉ๋๋ก ์ฌ์ฉํ๋ฉด ์๋จ
- ์ฌ๊ธฐ์ ๋งํ๋ ๊ฐ์ฅ ๋์ ์์น๊ฐ ํฐ ์ฃผ์๋ฅผ ์๋ฏธํ๋ ๊ฒ์ด ์๋ (๊ฐ์ฅ ๋์ ์์น๋ ์คํ๋ ค ์์ ์ฃผ์ ์ผ ๊ฒ)
- EIP (Extended Instructure Pointer): ๋ค์์ ์ํํ ๋ช
๋ น์ ์ฃผ์ ์ ์ฅ
- CPU๋ EIP์ ์ ์ฅ๋ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์์ ๋ช ๋ น์ด๋ฅผ ํ๋ ์ฒ๋ฆฌํ๊ณ ๋ ํ ์๋์ผ๋ก ๊ทธ ๋ช ๋ น์ด ๊ธธ์ด๋งํผ EIP๋ฅผ ์ฆ๊ฐ์ํจ๋ค.
- ๋ฒ์ฉ ๋ ์ง์คํฐ์๋ ๋ค๋ฅด๊ฒ EIP๋ ๊ทธ ๊ฐ์ ์ง์ ๋ณ๊ฒฝํ ์ ์๋๋ก ๋์ด์์ด์ ๋ค๋ฅธ ๋ช
๋ น์ด๋ฅผ ํตํด์ ๊ฐ์ ์ ์ผ๋ก ๋ณ๊ฒฝํด์ผ ํจ
- ๋ณ๊ฒฝํ๋ ค๋ฉด JMP, CALL ๋ฑ์ ์ฌ์ฉํ๊ฑฐ๋ ์ธํฐ๋ฝํธ, ์์ธ๋ฅผ ๋ฐ์ํด์ผ ํจ
- ์ธ๊ทธ๋จผํธ ๋ ์ง์คํฐ
- 16๋นํธ (2๋ฐ์ดํธ)
- ์ธ๊ทธ๋จผํธ: IA-32์ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ ๋ชจ๋ธ์์ ๋์ค๋ ์ฉ์ด
- IA-32 ๋ณดํธ ๋ชจ๋์์ ์ธ๊ทธ๋จผํธ๋, ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์กฐ๊ฐ๋ด์ด ๊ฐ ์กฐ๊ฐ๋ง๋ค ์์ ์ฃผ์, ๋ฒ์, ์ ๊ทผ ์ ํ ๋ฑ์ ๋ถ์ฌํด์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ณดํธํ๋ ๊ธฐ๋ฒ์ ์๋ฏธํจ
- ์ธ๊ทธ๋จผํธ๋ ํ์ด์ง ๊ธฐ๋ฒ๊ณผ ํจ๊ป ๊ฐ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ค์ ๋ฌผ๋ฆฌ ๋ฉ๋ชจ๋ฆฌ๋ก ๋ณ๊ฒฝํ ๋ ์ฌ์ฉ๋จ
- ์ธ๊ทธ๋จผํธ ๋ฉ๋ชจ๋ฆฌ๋ SDT๋ผ๊ณ ํ๋ ๊ณณ์ ๊ธฐ์ ๋์ด์๋๋ฐ, ์ธ๊ทธ๋จผํธ ๋ ์ง์คํฐ๋ ๋ฐ๋ก ์ด SDT์ index๋ฅผ ๊ฐ์ง๊ณ ์๋ค
- CS, SS. DS, ES, FS, GS
- ์ธ๊ทธ๋จผํธ: IA-32์ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ ๋ชจ๋ธ์์ ๋์ค๋ ์ฉ์ด
- 16๋นํธ (2๋ฐ์ดํธ)
- EFLAGS: ํ๋๊ทธ ๋ ์ง์คํฐ
- ํฌ๊ธฐ: 32๋นํธ(4๋ฐ์ดํธ)
- ๊ฐ ๋นํธ๋ 1 ๋๋ 0์ ๊ฐ์ ๊ฐ์ง๊ณ ์์ผ๋ฉฐ, ์ด๋ On/Off ๋๋ True/False ๋ฅผ ์๋ฏธํจ
- Zero Flag(ZF): ์ฐ์ฐ ๋ช ๋ น ํ์ ๊ฒฐ๊ณผ๊ฐ์ด 0์ด ๋๋ฉด, ZF๊ฐ 1(True)๋ก ์ธํ ๋จ
- Overflow FLag(OF): ๋ณดํธ ์๋ ์์ ์ค๋ฒํ๋ก์ฐ๊ฐ ๋ฐ์ํ์ ๊ฒฝ์ฐ 1๋ก ์ธํ ๋จ. ๊ทธ๋ฆฌ๊ณ MSB(Most Significant Bit)๊ฐ ๋ณ๊ฒฝ๋์์ ๋ 1๋ก ์ธํ ๋จ
- Carry Flag(CF): Unsigned integer ์ ์ค๋ฒํ๋ก์ฐ๊ฐ ๋ฐ์ํ์ ๋ 1๋ก ์ธํ
3. ์ด์ ๋ธ๋ฆฌ ๋ช ๋ น์ด
(1) ๊ตฌ๋ฌธ
intel | AT&T | |
๋ ์ง์คํฐ ํํ | EAX | %eax |
๊ฐ์ ํํ | AABBCCDDh ๋๋ 0xAABBCCDD |
%0xAABBCCDD |
๋ช ๋ น์ด ํฌ๊ธฐ ํํ | MOV | movl (longํ) movb (byteํ) |
๋ฉ๋ชจ๋ฆฌ ์ฃผ์ | [์ฃผ์] | (์ฃผ์) |
์คํผ๋๋ ๋ฐฉํฅ | ๋ชฉ์ ์ง(dst) <- ์์ค(src) | ์์ค(src) -> ๋ชฉ์ ์ง(dst) |
(2) ๋ฐ์ดํฐ ์ด๋ ๋ช ๋ น์ด
- MOV dst, src : ๋ชฉ์ ์ง๋ก ๊ฐ์ ์ ์ฅ //๋ค์ ๊ฐ(src)์ dst์ ์ ์ฅ
- MOV eax, ebx : EBX์ ๊ฐ์ EAX์ ๋ณต์ฌํ์ฌ ์ ์ฅ
- MOV eax, 0x42 : 0x42(16์ง์)๋ฅผ EAX์ ์ ์ฅ
- MOV eax, [ebx] : ์ฃผ์[ebx]์ ์๋ ๊ฐ์ eax์ ์ ์ฅ
- LEA dst, src : ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ๋ชฉ์ ์ง์ ์ ์ฅ
- LEA EAX, [EBX+8] : EBX์ 8์ ๋ํ ์ฃผ์๊ฐ์ EAX์ ์ ์ฅ
- PUSH/POP : ์คํ์ ๋ฐ์ดํฐ๋ฅผ ๋ฃ์ / ๊บผ๋,
- EBP ๊ฐ์ / ์ฆ๊ฐ (EBP: ์คํ์ ์ ์ผ ๋ฎ์ ์ฃผ์๋ฅผ ๊ฐ๋ฅดํด)
- PUSH EBP
- POP EAX
(3) ์ฐ์ ์ฐ์ฐ ๋ช ๋ น์ด
- ADD dst, src : ๋์
(dst = dst + src)
- dst์ src ๊ฐ์ ๋ํ๋ค.
- ADD eax, 3 : eax = eax + 3
- SUB dst, src : ๋บ์
(dst = dst - src)
- dst์์ src์ ๊ฐ์ ๋บ๋ค.
- SUB EAX, 3 : EAX = EAX - 3
- INC op : ์คํผ๋๋์ ๊ฐ์ 1 ์ฆ๊ฐ (op = op + 1)
- INC EAX : EAX = EAX + 1
- DEC op : ์คํผ๋๋์ ๊ฐ์ 1 ๊ฐ์ (op = op - 1)
- DEC EAX : eax = eax - 1
- MUL(๋ถํธ)/IMUG(๋ฌด๋ถํธ) op : EAX์ ์คํผ๋๋๋ฅผ ๊ณฑ์
ํ์ฌ EAX์ ์ ์ฅ (EAX = EAX * op)
- MUL ECX: EAX = EAX * ECX
- DIV(๋ถํธ)/IDIV(๋ฌด๋ถํธ) op : EAX์ ์คํผ๋๋๋ฅผ ๋๋์ด ๋ชซ์ EAX์ ์ ์ฅ (๋๋จธ์ง๋ EDX์ ์ ์ฅ)
- DIV EDX: EAX = EAX / EDX
- NEG : ์์๋ฅผ ์์๋ก, ์์๋ฅผ ์์
(4) ๋นํธ ์ฐ์ฐ ๋ช ๋ น์ด
- AND dst, src
- dst์ src์ ๋นํธ๊ฐ ๋ชจ๋ 1์ด๋ฉด 1, ์๋๋ฉด 0์ ํ์ฌ dst์ ๊ฐ์ ์ด๋ค.
- OR dst, src
- dst์ src์ ๋นํธ ์ค ํ๋๋ผ๋ 1์ด๋ฉด 1, ์๋๋ฉด 0์ ํ์ฌ dst์ ๊ฐ์ ์ด๋ค.
- XOR dst, src
- dst์ src์ ๋นํธ๊ฐ ์๋ก ๋ค๋ฅด๋ฉด 1, ๊ฐ์ผ๋ฉด 0 ํ์ฌ dst์ ๊ฐ์ ์ด๋ค.
- NOT op
- op์ ๋นํธ ์ ๋ถ ๋ฐ์
- SHL
- ์ผ์ชฝ์ผ๋ก ์ฌํํธ ์ฐ์ฐ
- ์ต์์ ๋นํธ๋ 0์ผ๋ก ์ฑ์์ง๊ณ ๊ธฐ์กด๊ฐ์ CF ํ๋๊ทธ ๋ ์ง์คํฐ์ ์ ์ฅ
- SHR
- ์ค๋ฅธ์ชฝ์ผ๋ก ์ฌํํธ ์ฐ์ฐ
- ์ต์์ ๋นํธ๋ ๋ถํธ๋นํธ๋ก ์ฑ์์ง๊ณ CF ํ๋๊ทธ ๋ ์ง์คํฐ์ ์ ์ฅ
- ROL/RCL
- ์ผ์ชฝ์ผ๋ก ์ฌํํธ ์ฐ์ฐ, ์ตํ์ ๋นํธ๋ ์ต์์ ๋นํธ๋ก ์ฑ์์ง
- ROR/RCR
- ์ค๋ฅธ์ชฝ์ผ๋ก ์ฌํํธ ์ฐ์ฐ, ์ต์์ ๋นํธ๋ ์ตํ์ ๋นํธ๋ก ์ฑ์์ง
(5) ์ ์ด ๋ช ๋ น
- CMP : ๋ ๊ฐ์ ์คํผ๋๋ ๋น๊ต (๋บ์
์ฐ์ฐ ํ ํ๋๊ทธ ์ค์ )
- CMP EAX, 0 : EAX์ ๋นํธ๊ฐ 0์ธ์ง ๊ฒ์ฌ
- Zero Flag (ZF): ์ฐ์ฐ ๊ฒฐ๊ณผ๊ฐ 0์ด๋ฉด ์ด ํ๋๊ทธ๊ฐ ์ค์ ๋๋ค. (0์ผ ๋, 1) ์ฆ, ๊ฐ์ด ๊ฐ์ผ๋ฉด ZF๊ฐ 1์ด ๋จ
- CMP EAX, 0์์ EAX๊ฐ 0์ด๋ฉด ZF๋ 1์ด ๋๋ค.
- Sign Flag (SF): ์ฐ์ฐ ๊ฒฐ๊ณผ์ ์ต์์ ๋นํธ(๋ถํธ ๋นํธ)์ ๋ฐ๋ผ ์ค์ ๋๋ค. ๊ฒฐ๊ณผ๊ฐ ์์๋ฉด SF๋ 1์ด ๋๋ค.
- Overflow Flag (OF): ์ฐ์ฐ์์ ๋ถํธ ์๋ ์ค๋ฒํ๋ก๊ฐ ๋ฐ์ํ์ ๊ฒฝ์ฐ ์ด ํ๋๊ทธ๊ฐ ์ค์ ๋๋ค.
- Carry Flag (CF): ๋ฌด๋ถํธ ์๋ก ๊ณ์ฐํ์ ๋ ์ค๋ฒํ๋ก๊ฐ ๋ฐ์ํ๋ฉด CF๊ฐ ์ค์ ๋๋ค.
- TEST : ๋ ๊ฐ์ ์คํผ๋๋ ๋น๊ต (AND ์ฐ์ฐ ์ํ ํ ํ๋๊ทธ๋ฅผ ์ค์ )
- TEST EAX, 0 : EAX์ ๋นํธ๊ฐ 0์ธ์ง ๊ฒ์ฌ
- CALL : ํด๋น๋๋ ์ฃผ์์ ํจ์๋ฅผ ํธ์ถํ์ฌ ์ํ ์ฝ๋ ์์น๋ก ์ฎ๊น
- CALL 00401990
- INT : ์คํผ๋๋๋ก ์ง์ ๋ ์์ธ ์ฒ๋ฆฌ ์ํ
- INT 3 : ๋๋ฒ๊ฑฐ๋ฅผ ํ์ฑํํ๋ ๋ฐ ์ฌ์ฉ๋๋ ์ธํฐ๋ฝํธ. ์ฃผ๋ก ๋๋ฒ๊น ์ค์ ํ๋ก๊ทธ๋จ ์คํ์ ์ค์งํ๊ธฐ ์ํด ์ฌ์ฉ๋๋ค.
- LEAVE : ํจ์์์ ์ฌ์ฉ๋ ์ง์ญ๋ณ์ ์คํ์ ๋น์
- ์ฃผ๋ก ์คํ ํ๋ ์ ์ ๋ฆฌํ ๋ ์ฌ์ฉ
- ํจ์์ ๋ง์ง๋ง ๋ถ๋ถ์์ ์ฌ์ฉ๋์ด ํจ์์ ๋ก์ปฌ ๋ณ์ ๊ณต๊ฐ์ ์ ๋ฆฌํ๊ณ ์ด์ ์คํ ํ๋ ์์ผ๋ก ๋ณต๊ทํ๋ค.
- RET : ์คํ์ ์ ์ฅ๋ ์ฃผ์๋ก ๋ณต๊ท
-
- RET: ๋จ์ํ ํจ์์์ ๋ฐํ.
- RET 4: ํจ์์์ ๋ฐํํ๊ณ ์คํ ํฌ์ธํฐ๋ฅผ 4๋ฐ์ดํธ๋งํผ ์ถ๊ฐ ์กฐ์ (์: 4๋ฐ์ดํธ ์ธ์๋ฅผ ์ ๋ฌ๋ฐ์ ๊ฒฝ์ฐ).
-
- NOP : ์๋ฌด๋์๋ ์ํํ์ง ์์ (๊ธฐ๊ณ์ด ์ฝ๋: 0x90)
(6) ๋ถ๊ธฐ ๋ช ๋ น
- JMP (Jump): ๋ฌด์กฐ๊ฑด EIP ๊ฐ์ผ๋ก ์ ํ
- ์กฐ๊ฑด๋ถ ์ ํ: ์ด๋ฌํ ๋ช
๋ น์ด๋ค์ CPU์ ํ๋๊ทธ ์ํ(Zero Flag, Carry Flag ๋ฑ)์ ๋ฐ๋ผ EIP ์ฃผ์๊ฐ์ผ๋ก ์
- JE (Jump if Equal): Zero Flag๊ฐ ์ค์ ๋์ด ์์ผ๋ฉด ์ ํ (ZF = 1)
- JNE (Jump if Not Equal): Zero Flag๊ฐ ํด๋ฆฌ์ด๋์ด ์์ผ๋ฉด ์ ํ (ZF = 0)
- JG (Jump if Greater): Signed ๋น๊ต์์ ํฌ๋ฉด ์ ํ
- JGE (Jump if Greater or Equal): Signed ๋น๊ต์์ ํฌ๊ฑฐ๋ ๊ฐ์ผ๋ฉด ์ ํ
- JL (Jump if Less): Signed ๋น๊ต์์ ์์ผ๋ฉด ์ ํ
- JLE (Jump if Less or Equal): Signed ๋น๊ต์์ ์๊ฑฐ๋ ๊ฐ์ผ๋ฉด ์ ํ
- JC (Jump if Carry): Carry Flag๊ฐ ์ค์ ๋์ด ์์ผ๋ฉด ์ ํ
- JNC (Jump if No Carry): Carry Flag๊ฐ ํด๋ฆฌ์ด๋์ด ์์ผ๋ฉด ์ ํ
- JECXZ : ECX๊ฐ 0์ด๋ฉด ์ ํ
MOV EAX, value1
CMP EAX, value2 ; EAX์ value2๋ฅผ ๋น๊ต
JE equal_label ; EAX์ value2๊ฐ ๊ฐ์ผ๋ฉด equal_label๋ก ์ ํ
; ์ฌ๊ธฐ๋ EAX์ value2๊ฐ ๋ค๋ฅผ ๋ ์คํ๋ ์ฝ๋
...
equal_label:
; EAX์ value2๊ฐ ๊ฐ์ ๋ ์คํ๋ ์ฝ๋
...
(7) ๋ฐ๋ณต ๋ช ๋ น
- REP : ECX ๋ ์ง์คํฐ ์ง์ ํ์ ๋๋ ZF ํ๋๊ทธ ์กฐ๊ฑด์ ๋ง์ ๋์ ๋ฐ๋ณต
- REP : ECX๊ฐ 0์ด ๋ ๋๊น์ง ๋ฐ๋ณต
- REPE, REPZ : ECX๊ฐ 0์ด๊ฑฐ๋ ZF๊ฐ 0์ผ ๋๊น์ง ๋ฐ๋ณต
- REPNE, REPNZ : ECX๊ฐ 0์ด ์๋๊ฑฐ๋ ZF๊ฐ 1์ผ ๋๊น์ง ๋ฐ๋ณต
- LOOP [์ฃผ์] : ECX ๋ ์ง์คํฐ(์นด์ดํฐ)๋ฅผ 1 ๊ฐ์์ํค๊ณ , ECX๊ฐ 0์ด ์๋๋ฉด ์ฃผ์ด์ง ์ฃผ์๋ ๋ ์ด๋ธ๋ก ์ ํํฉ๋๋ค.
- LOOPE/LOOPZ (Loop while Equal/Loop while Zero) [์ฃผ์] : ECX๋ฅผ ๊ฐ์์ํค๊ณ , Zero Flag๊ฐ ์ค์ ๋์ด ์์ผ๋ฉฐ ECX๊ฐ 0์ด ์๋ ๋ ์ฃผ์ด์ง ์ฃผ์๋ ๋ ์ด๋ธ๋ก ์ ํํฉ๋๋ค.
- LOOPNE/LOOPNZ (Loop while Not Equal/Loop while Not Zero) [์ฃผ์]: ECX๋ฅผ ๊ฐ์์ํค๊ณ , Zero Flag๊ฐ ํด๋ฆฌ์ด๋์ด ์์ผ๋ฉฐ ECX๊ฐ 0์ด ์๋ ๋ ์ฃผ์ด์ง ์ฃผ์๋ ๋ ์ด๋ธ๋ก ์ ํํฉ๋๋ค.
4. ์คํ
(1) ์คํ ๋ฉ๋ชจ๋ฆฌ์ ์ญํ
- ํจ์ ๋ด์ ๋ก์ปฌ ๋ณ์ ์์ ์ ์ฅ
- ํจ์ ํธ์ถ ์ ํ๋ผ๋ฏธํฐ ์ ๋ฌ
- ๋ณต๊ท ์ฃผ์(return address) ์ ์ฅ
(2) ์คํ์ ํน์ง
- FILO (First In Last Out)
- PUSH ๋ฐฉํฅ: ์คํ์ ๋ฐ๋ฅ์์ ์๋ก
- POP ๋ฐฉํฅ: ์คํ์ ์์์ ๋ฐ๋ฅ์ผ๋ก
์คํ์ ๋ฐ๋ฅ์ ์ฃผ์๊ฐ์ด ๊ฐ์ฅ ํฌ๋ค
(3) ์คํ ๋์ ์์
- ์ด๊ธฐ ์ํ์ ์คํ
- ESP(์คํ ํฌ์ธํฐ): 19FF74
//๊ถ๊ธํ ์ : ESP์ EBP์ ์์๊ฐ์ด ์ ๋ค๋ฅด์ง??
= ์คํ์ ๋ค๋ฅธ ๊ฒ ๋ค์ด์์ ์ ์์(๋ฆฌํด์ด๋ ์ด๋ฐ๊ฒ ๋ณดํต ๋ค์ด์์ ์ผ๋ฐ์ ์ผ๋ก ์คํ์ด ๋น์ด์๋ ๊ฒฝ์ฐ๋ ๊ฑฐ์ ์๋ค)
- F8: Push 100 ๋ช ๋ น ์คํ
- ์คํ์ ์ ์ 100์ pushํด์ค (๊ฐ์ ๋ฃ์ด์ค)
- ESP: 19FF70 (4๋ฐ์ดํธ ๊ฐ์)
- 4๋ฐ์ดํธ: ๋ฐ์ดํฐ์ ํฌ๊ธฐ (์ ์์ ํฌ๊ธฐ = 4๋ฐ์ดํธ)
- ์คํ ํฌ์ธํฐ๊ฐ ๊ฐ๋ฅดํค๋ ์ฃผ์(19FF70)์๋ PUSH๋ช
๋ น์ ์ํด 100์ด ์ ์ฅ๋์ด์์
- ์คํ์ ๊ฐ์ ์ ์ฅํ๊ณ ESP๋ ์คํ์ ๊ฐ์ฅ ์์ชฝ์ ๊ฐ๋ฅดํค๊ธฐ ๋๋ฌธ
- ์ฆ, ๊ฐ์ ์ง์ด ๋ฃ์ = ESP ๊ฐ ๊ฐ์ฅ ์ต์๋จ์ผ๋ก ์ด๋ํจ
- ESP๊ฐ 4๋งํผ ์ค์ด๋ฆ
- ์คํ์ ์๋ก๊ฐ์๋ก ์ฃผ์๊ฐ์ด ์์์ง (ํฐ -> ์)
- F8: POP EAX
- ์คํ์์ ๋ฐ์ดํฐ๋ฅผ ์ ๊ฑฐํ๊ณ , ๊ทธ ๊ฐ์ eax ๋ ์ง์คํฐ๋ก ์ฎ๊น
- ESP: 19FF74 (4 ๋ฐ์ดํธ ์ฆ๊ฐ)
- ์คํ์์ ๊ฐ์ ๊บผ๋
- ESP๋ ์๋ ๋ฐฉํฅ์ผ๋ก ์ด๋ => ESP 4๋ฐ์ดํธ ์ฆ๊ฐ
- eax ๋ ์ง์คํฐ์๋ 100์ด ์ ์ฅ๋จ
์คํ์ ๊ฐ์ ์ ๋ ฅํ๋ฉด ์คํ ํฌ์ธํฐ(ESP)๋ ๊ฐ์ํ๊ณ , ์คํ์์ ๊ฐ์ ๊บผ๋ด๋ฉด ์คํ ํฌ์ธํฐ๋ ์ฆ๊ฐํ๋ค.
์คํ ํฌ์ธํฐ์ ์ด๊ธฐ๊ฐ์ ์คํ ๋ฉ๋ชจ๋ฆฌ์ ์๋์ชฝ์ ์๋ค.
5. ์คํ ํ๋ ์
(1) ์คํ ํ๋ ์
- ์คํ ํฌ์ธํฐ(ESP)๊ฐ ์๋ ๋ฒ ์ด์ค ํฌ์ธํฐ(EBP) ๋ ์ง์คํฐ๋ฅผ ์ฌ์ฉํ์ฌ ์คํ ๋ด์ ๋ก์ปฌ ๋ณ์, ํ๋ผ๋ฏธํฐ, ๋ณต๊ท ์ฃผ์์ ์ ๊ทผํ๋ ๊ธฐ๋ฒ
- ESP ๋ ์ง์คํฐ์ ๊ฐ์ ์์๋ก ๋ณ๊ฒฝ๋๊ธฐ ๋๋ฌธ์ ์คํ์์ ์ ์ฅ๋ ๋ณ์, ํ๋ผ๋ฏธํฐ์ ์ ๊ทผํ๊ณ ์ ํ ๋ ESP๊ฐ์ ๊ธฐ์ค์ผ๋ก ํ๋ฉด ํ๋ก๊ทธ๋จ์ ๋ง๋ค๊ธฐ ํ๋ค๊ณ , CPU๊ฐ ์ ํํ ์์น๋ฅผ ์ฐธ๊ณ ํ ๋ ์ด๋ ค์์ด ์์
- ๋ฐ๋ผ์, ํจ์ ์์์ ESP ๊ฐ์ EBP์ ์ ์ฅํ๊ณ ์ ์งํด์ฃผ๋ฉด ESP ๊ฐ์ด ๋ณํ๋๋ผ๋ EBP๋ฅผ ๊ธฐ์ค(base)์ผ๋ก ์์ ํ๊ฒ ํจ์์ ๋ณ์, ํ๋ผ๋ฏธํฐ, ๋ณต๊ท ์ฃผ์์ ์ ๊ทผํ ์ ์๋ค.
โ
(2) ์คํ ํ๋ ์์ ๊ตฌ์กฐ
- PUSH EBP โ= ํจ์ ์์ (EBP๋ฅผ ์ฌ์ฉํ๊ธฐ ์ ์ ๊ธฐ์กด์ ๊ฐ์ ์คํ์ ์ ์ฅ)
- MOV EBP, ESP โ= ํ์ฌ์ ESP๋ฅผ EBP์ ์ ์ฅ
- . . . = ํจ์์ ๋ณธ์ฒด // ์ฌ๊ธฐ์ ESP๊ฐ ๋ณ๊ฒฝ๋๋๋ผ๋ EBP๊ฐ ๋ณ๊ฒฝ๋์ง ์์ผ๋ฏ๋ก ์์ ํ๊ฒ ๋ก์ปฌ๋ณ์์ ํ๋ผ๋ฏธํฐ๋ฅผ ์์ธ์คํ ์ ์์
- MOV ESP, EBP = ESP๋ฅผ ์ ๋ฆฌ (ํจ์ ์์ํ์ ๋์ ๊ฐ์ผ๋ก ๋ณต์)
- POP EBP โ= ๋ฆฌํด๋๊ธฐ ์ ์ ์ ์ฅํด ๋์๋ ์๋ EBP ๊ฐ์ผ๋ก ๋ณต์
- RETN = ํจ์ ์ข ๋ฃ
(3) ์ค์ต - stackframe.exe
#include "stdio.h"
long add(long a, long b)
{
long x = a, y = b;
return (x + y);
}
int main(int argc, char* argv[])
{
long a = 1, b = 2;
printf("%d\n", add(a, b));
return 0;
}
#1 main() ํจ์ ์์, ์คํ ํ๋ ์ ์์ฑ
int main(int argc, char* argv[])
{
- main() ํจ์์์ EBP๊ฐ ๋ฒ ์ด์ค ํฌ์ธํฐ ์ญํ ์ ํ๊ฒ ๋๋ฏ๋ก EBP๊ฐ ์ด์ ์ ๊ฐ๊ณ ์๋ ๊ฐ์ ์คํ์ ๋ฐฑ์ ํด๋๊ธฐ ์ํ ๊ฒ
- ์คํ์ ์ ์ฅ๋ ํจ์ ํ๋ผ๋ฏธํฐ์ ๋ก์ปฌ ๋ณ์๋ค์ EBP๋ฅผ ํตํด ์์ธ์คํ๊ฒ ๋ค๋ ๊ฒ์ด๋ค
-> ์ด ๋ ๋ช ๋ น์ด์ ์ํด main()ํจ์์ ๋ํ ์คํ ํ๋ ์์ด ์์ฑ๋ ๊ฒ์ด๋ค.
* ์คํ ์ฐฝ์ ์ ํ ํ address -> Relative to EBP ์ ํํ์ฌ EBP ์์น ํ์ธ ๊ฐ๋ฅ
- EBP ๊ฐ์ 0019FF28๋ก ESP์ ๋์ผํ๊ณ ,19FF28 ์ฃผ์์๋ 19FF70 ์ด๋ผ๋ ๊ฐ์ด ์ ์ฅ๋์ด ์๋ค.
(main()ํจ์ ์์ํ ๋ EBP๊ฐ ๊ฐ์ง๊ณ ์๋ ์ด๊ธฐ๊ฐ)
#2 ๋ก์ปฌ ๋ณ์ ์ธํ
long a = 1, b = 2;
- ํ์ฌ ESP: 0019FF28 -> 19FF20
- 8์ ๋นผ๋ ์ด์ : ํจ์์ ๋ก์ปฌ ๋ณ์๋ ์คํ์ ์ ์ฅ๋๋๋ฐ, main()ํจ์์ ๋ก์ปฌ ๋ณ์๋ ๊ฐ 'a'์ 'b'์ด๋ค. ๊ทธ๋ฌ๋ 'a'์
'b'๋ long ํ์ ์ด๋ฏ๋ก ๊ฐ ๊ฐ 4๋ฐ์ดํธ์ฉ ๊ฐ์ง๋ค. ์ฆ, ์ด ๋๋ณ์๋ฅผ ์คํ์ ์ ์ฅํ๊ธฐ ์ํด ์ด 8๋ฐ์ดํธ๊ฐ ํ์ํ๋ฏ๋ก ๋ ๋ณ์์๊ฒ ํ์ํ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ํ๋ณด(์์ฝ)ํ ๊ฒ์ด๋ค.
- DWORD PTR SS:[EBP-4]): EBP-4 ์ฃผ์์์ 4๋ฐ์ดํธ ํฌ๊ธฐ์ ๋ฉ๋ชจ๋ฆฌ ๋ด์ฉ //ํฌ์ธํฐ
=> '[EBP-4] ์๋ 1์ ๋ฃ๊ณ (a) , [EBP-8]์๋ 2๋ฅผ ๋ฃ์ด๋ผ' (b)
#3 add() ํจ์ ํ๋ผ๋ฏธํฐ ์ ๋ ฅ ๋ฐ add() ํจ์ ํธ์ถ
printf("%d\n", add(a, b));
- ์ ์ด์
๋ธ๋ฆฌ ์ฝ๋๋ ์ ํ์ ์ธ ํจ์ ํธ์ถ ๊ณผ์ ์ ๋ณด์ฌ์ค๋ค
- 40103C ์ฃผ์์ CALL 401000 ๋ช ๋ น์ด์์ 401000 ํจ์๊ฐ ๋ฐ๋ก add()ํจ์์ด๋ค
- add()ํจ์๋ํ๋ผ๋ฏธํฐ๋ก a์ b๋ฅผ ๋ฐ๋๋ค
- ์ 401034~40103B์ฃผ์์ ์ฝ๋์์ ๋ณ์ a,b๋ฅผ ์คํ์ ๋ฃ๊ณ ์๋ค
* ์ฃผ๋ชฉํ ๋ด์ฉ์ ํ๋ผ๋ฏธํฐ๊ฐ C ์ธ์ด์ ์ ๋ ฅ ์์์๋ ๋ฐ๋๋ก ์คํ์ ์ ์ฅ๋๋ค๋ ๊ฒ์ด๋ค. (์ด๋ฅผํจ์ํ๋ผ๋ฏธํฐ์ ์ญ์์ ์ฅ์ด๋ผ๊ณ ํจ)
์ฆ, ๋ณ์ b ([EBP-8])๊ฐ ์คํ์ ๋จผ์ ๋ค์ด๊ฐ๊ณ ๋ณ์ a ([EBP-4])๊ฐ ๋์ค์ ๋ค์ด๊ฐ๋ค.
#5 ๋ณต๊ท ์ฃผ์
- CALL ๋ช ๋ น์ด๊ฐ ์คํ๋์ด ํด๋น ํจ์๋ก ๋ค์ด๊ฐ๊ธฐ ์ ์ CPU๋ ๋ฌด์กฐ๊ฑด ํด๋น ํจ์๊ฐ ์ข ๋ฃ๋ ๋ ๋ณต๊ทํ ์ฃผ์๋ฅผ ์คํ์ ์ ์ฅํ๋ค
#6 add() ํจ์ ์์, ์คํ ํ๋ ์ ์์ฑ
long add(long a, long b)
// F7๋ก ํด๋น ํจ์ ๋ค์ด๊ฐ๊ธฐ
- main()๊ณผ ์์ ํ ๋์ผํจ
#7 add() ํจ์์ ๋ก์ปฌ ๋ณ์ x, y ์ธํ
long x = a, y = b;
- ๋ก์ปฌ ๋ณ์์ x, y์ ๋ํ ๋ฉ๋ชจ๋ฆฌ ์์ญ ํ๋ณด
- [EBP+8]: ํ๋ผ๋ฏธํฐ a
- [EBP+C]: ํ๋ผ๋ฏธํฐ b
- [EBP-8]: add() ํจ์์ ๋ก์ปฌ x
- [EBP-4]: add() ํจ์์ ๋ก์ปฌ y
#8 ADD
return (x + y);
- [EBP-8]์ ๋ณ์ x์ ๊ฐ 1์ MOV ๋ช ๋ น์ด๋ฅผ ์ฌ์ฉํด EAX๋ก ๋ฃ๋๋ค
- [EBP-4]์ ๋ณ์ y์ ๊ฐ 2์ ADD ๋ช ๋ น์ด๋ฅผ ์ฌ์ฉํด EAX์ ๊ฐ 1๊ณผ ๋ํด 3์ด ๋์๋ค
- EAX๋ '๋ฒ์ฉ ๋ ์ง์คํฐ'๋ก ์ฐ์ ์ฐ์ฐ์ ์ฌ์ฉ๋๋ฉฐ, ๋ฆฌํด ๊ฐ์ผ๋ก๋ ์ฌ์ฉ๋๋ค
#9 add() ํจ์์ ์คํ ํ๋ ์ ํด์ & ํจ์ ์ข ๋ฃ(๋ฆฌํด)
return (x + y);
}
- add() ํจ์๊ฐ ๋ฆฌํด๋๊ธฐ ์ ์ add()ํจ์์ ์คํ ํ๋ ์์ ํด์ ํด์ผ ํ๋ค
- ํ์ฌ EBP ๊ฐ์ ESP์ ๋์ ํ๋ค //์ด ๋ช ใ ๋ น์ด๋ ์์ MOV EBP, ESP ๋ช ๋ น์ด์ ๋์ํ๋ ๊ฒ์ด๋ค
- ์ฆ add() ํจ์ ์์ํ ๋์ ESP๊ฐ์ EBP์ ๋ฃ์ด๋์๋ค๊ฐ ํจ์๊ฐ ์ข ๋ฃ๋ ๋ ESP๋ฅผ ๋ณต์์ํค๋ ๋ชฉ์ ์ผ๋ก ์ฌ์ฉ๋๋ค
- add() ํจ์๊ฐ ์์๋๋ฉด์ ์คํ์ ๋ฐฑ์
ํ EBP๊ฐ์ ๋ณต์ํ๋ค //PUSH EBP์ ๋์
- ์ด์ add() ํจ์์ ์คํ ํ๋ ์์ ํด์ ๋์๋ค
- RETN ๋ช
๋ น์ด๋ฅผ ์คํ์์ผ์ฃผ๋ฉด ์คํ์ ์ ์ฅ๋ ๋ณต๊ท ์ฃผ์๋ก ๋ฆฌํดํ๋ค //RETN
#10 add() ํ๋ผ๋ฏธํฐ ์ ๊ฑฐ
#11 printf() ํจ์ ํธ์ถ
printf("%d\n", add(a, b));
- ADD ESP, 8
- ADD ๋ช ๋ น์ผ๋ก ESP์ 8์ ๋ํ๊ณ ์๋ค
- add() ํจ์๊ฐ ์ข ๋ฃ๋์๊ธฐ ๋๋ฌธ์ ํ๋ผ๋ฏธํฐ a, b ๊ฐ ํ์๊ฐ ์๋ค
- ๋ฐ๋ผ์ 8์ ๋ํด ์คํ์ ์ ๋ฆฌํ๋ ๊ฒ์ด๋ค
- EAX ๋ ์ง์คํฐ์๋ add() ํจ์์์ ์ ์ฅ๋ ๋ฆฌํด ๊ฐ(3)์ด ๋ค์ด์๋ค
- printf() ํจ์์ ํ๋ผ๋ฏธํฐ ๊ฐ์๋ 2๊ฐ์ด๊ณ ํฌ๊ธฐ ์ญ์ 8๋ฐ์ดํธ์ด๋ค
- ๋ฐ๋ผ์ ADD ESP, 8 ๋ช ๋ น์ผ๋ก ์คํ์์ ํจ์ ํ๋ผ๋ฏธํฐ ์ ๋ฆฌํ๊ณ ์๋ค
#12 ๋ฆฌํด ๊ฐ ์ธํ
#13 ์คํ ํ๋ ์ ํด์ & main() ํจ์ ์ข ๋ฃ
return 0;
}
- XOR ๋ช ๋ น์ด๋ Exclusive OR bit ์ฐ์ฐ์ผ๋ก, ๊ฐ์ ๊ฐ๋ผ๋ฆฌ XORํ๋ฉด 0์ด ๋๋ ํน์ง์ด ์๋ค
- MOV EAX, 0 ๋ช ๋ น์ด๋ณด๋ค ์คํ ์๋๊ฐ ๋นจ๋ผ์ ๋ ์ง์คํฐ๋ฅผ ์ด๊ธฐํ์ํฌ ๋ ๋ง์ด ์ฌ์ฉ๋๋ค
#14 ์ฌ๋ฆฌ๋๋ฒ๊ฑฐ ์ต์ ๋ณ๊ฒฝ
** ์ด๋ฎค๋ํฐ ๋๋ฒ๊ฑฐ์์๋ Disasm ์ต์ ์ด ์์
์ถ์ฒ: ๋ฆฌ๋ฒ์ฑ ํต์ฌ์๋ฆฌ