======================================================== "바이너리 파일을 분석하여 소스로 만들기" 2002/ 07/ 05 NaNu9 in Null@Root NaNuIX@null2root.org ======================================================== o. 무한한 삽질 흔히 실전에서 바이너리만 있는 취약프로그램이 주어집니다. 갑갑하죠.. 한번 부딪혀 보겠습니다. 바이너리 프로그램을 분석해서 소스를 만드는 방법(?이라기 보다 과정)과 분석하는 방법을 찾아보겠습니다. 이렇게 무식하게 덤빌수 있는것은 C 언어의 예약어(Reserved Word)가 몇개 않되고 대부분이 함수로 이루어져 있기 때문에 함수의 구성으로 소스를 만들어 가는 방법입니다. 이번에 선택한 프로그램은 길이도 만만치 않은 레벨7->8 프로그램입니다. -r-sr-xr-x 1 level8 level7 15878 Jun 25 00:12 yupgigirl 이렇게 되어 있네요 1. 먼저 실행을 해서 어떻게 돌아가는지 간단하게 살펴보겠습니다. 실행에 앞서 길게 입력하기 번거로우니 ln -s /home/level7/yupgigirl lvl08 이렇게 간단하게 링크를 해두겠습니다. ./lvl08 200 안녕하세요. (null)님! 이름 : qazwsxedcrfv <-- 아무꺼나 입력해봄. 당신이 입력할 수 있는 문자 수는 20개 입니다. Input char : asdfghjkl Input char : Input char : Input char : 123 Input char : 12 Input char : 12 당신이 입력한 단어는 afj <-- 입력에 대하여 출력이...건너뜀(?) dhlwtsgxbdfsg 32입니다. 흠... 이렇게 돌아가는 프로그램 이라는것 밖에... 뭐가 뭔지 모르겠네요. 자.. 이제부터 본격적으로 분석을 하여 소스프로그램으로 만들어 보겠습니다. 2. 이제 바이너리 프로그램을 분석해 보겠습니다. 여기서 사용하는 프로그램은 일반적으로 제공되어 있는 objdump와 gdb를 사용합니다. 먼저 objdump -S lvl08을 하여 프로그램을 역어셈블 시켜 봅니다. 여기에서 사용자 함수가 어떤것이 있는지 분석합니다. Message, print_total, main 이 있네요. 좀더 세부적으로 들어가 보겠습니다. 3. objdump에서는 출력 되지 않던 함수의 이름까지 출력해주는 gdb를 돌려 보겠습니다. shell> $ gdb ./lvl08 gdb에서 역어셈블을 시켜 보겠습니다. disas Message 를 해보니 다음과 같이 나오네요... 0x8048730 : push %ebp 0x8048731 : mov %esp,%ebp 0x8048733 : sub $0x8,%esp 0x8048736 : sub $0x4,%esp <-- 여기까지는 C 함수의 원형입니다. 0x8048739 : sub $0x8,%esp 0x804873c : pushl 0x8(%ebp) 0x804873f : call 0x80485c8 0x8048744 : add $0xc,%esp 0x8048747 : mov %eax,%eax 0x8048749 : push %eax 0x804874a : pushl 0x8(%ebp) 0x804874d : push $0x1 0x804874f : call 0x8048568 0x8048754 : add $0x10,%esp 0x8048757 : sub $0xc,%esp 0x804875a : pushl 0x8049c44 0x8048760 : call 0x8048578 0x8048765 : add $0x10,%esp 0x8048768 : leave <-- 함수를 끝내는 부분 입니다. 0x8048769 : ret 음.. Message라는 함수에는 strlen, write, fflush 이렇게 3가지의 함수가 사용되었네요. 각각의 함수에 대한 기본적인 구성이 어떻게 되는지 알아 보겠습니다. 다 아는 방법으로 리눅스의 man 명령을 사용하면 됩니다. man strlen을 해보니 size_t strlen(const char *s); 문자열 길이를 계산하는 함수로써 끝이 `\0'인 문자를 빼고 문자열 s의 길이를 계산해서 돌려주는 함수네요. 다음은 man write를 해보겠습니다. 이 write는 명령도 있고 함수도 있습니다. 그러므로 man -a write를 하여 Q를 누르면 함수에 대한 부분을 볼수 있습니다. ssize_t write(int fd, const void *buf, size_t count); 마찮가지로 man fflush를 하면 int fflush(FILE *stream); 라는 것을 알수 있습니다. 다음은 역어셈블 리스트와 함수의 원형을 어떻게 연결할까요? 이것은 C 컴파일러가 규칙을 가지고 있습니다. C 에는 2가지의 변수전달 방법이 있습니다. 하나는 직접 값을 전달하는 방법과, 포인트를 전달하는 방법입니다. 즉 size_t strlen(const char *s); 이 함수의 s 변수를 전달을 하는 방법으로 변수의 번지를 스택에 저장하여 실행함수를 call 하여 실행하는 것 입니다. 변수의 번지를 전달하여, 이 번지에 그런 데이타가 있다.. 이런식이죠. 자.. 그럼 분석된 역어셈블 리스트를 보겠습니다. 바로 이부분이죠. 0x8048739 : sub $0x8,%esp <-- dummy 0x804873c : pushl 0x8(%ebp) <-- parameter 0x804873f : call 0x80485c8 0x8048744 : add $0xc,%esp size_t strlen(const char *s); 에는 전달변수가 하나 밖에 없는데 스택을 빼주는 군요.. 이부분이 gcc의 버젼에 따라서 추가되는 dummy 부분입니다. 0x804873c : pushl 0x8(%ebp) <-- 이부분이 *s 의 번지입니다. 이 표현은 ebp 레지스터 + 8 번지의 내용을 스택에 저장하라는 의미 입니다. 엥.. 그런데 0x8(%ebp) 가 어디쯤 일까요? 자.. 이 Message 함수가 실행되는 메모리의 구조를 분석해보겠습니다. 0x0000 +---------------------+ <-- 메모리의 낮은 번지 | | ~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~ | dummy | 4 Byte [ebp] +---------------------+ <-- 프로그램 시작시 [esp] 레지스터 | ebp | 4 Byte +---------------------+ | RET Address | <-- Message() 함수가 실행될때 [RET] [ebp]+8 +---------------------+ | str | <-- Message(*str) +---------------------+ 여기서 str 은 임의로 붙인 변수명 입니다. | | ~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~ | | <-- Stack의 하위 0xFFFF +---------------------+ <-- 메모리의 높은 번지 str을 바로 스택에 저장하네요. 그래서 size_t strlen(const char *s); 함수는 strlen(*str); 으로 됩니다. 그리고 strlen()를 실행한 결과는 eax 레지스터로 돌려 줍니다. 이것을 보니 Message(*str)으로 구성이 된다는 것을 알수가 있습니다. 다음은 ssize_t write(int fd, const void *buf, size_t count); 가 어떻게 컴파일 되어 있는지 보겠습니다. 0x8048747 : mov %eax,%eax <-- strlen을 실행한 결과 0x8048749 : push %eax <-- count 0x804874a : pushl 0x8(%ebp) <-- *buf = str 0x804874d : push $0x1 <-- fd = 1 0x804874f : call 0x8048568 0x8048754 : add $0x10,%esp 따라서 ssize_t write(int fd, const void *buf, size_t count); 함수는 write(1, str, strlen(str)); 이렇게 됩니다. 다음은 int fflush(FILE *stream); 부분을 살펴보겠습니다. 0x8048757 : sub $0xc,%esp <-- dummy 0x804875a : pushl 0x8049c44 <-- stdout (왜 stdout이냐구요? 설명은 아래에...) 0x8048760 : call 0x8048578 0x8048765 : add $0x10,%esp 여기에서 pushl 0x8049c44 이 있군요. 이것은 objdump -x lvl08 을 하여 해당번지가 일치하는 부분을 찾습니다. 08049c44 g O .bss 00000004 stdout@@GLIBC_2.0 stdout이라는 번지와 일치하는 군요.. 따라서 fflush(stdout); 으로 됩니다. 전체적으로 정리를 해보면 다음의 함수가 만들어 집니다. void Message(char *str) { write(1, str, strlen(str)); fflush(stdout); } 다음은 print_total 함수를 분석해 보겠습니다. gdb에서 disas print_total 으로 역어셈블을 합니다. 그리고 각 해당 프로그램에서 분석을 해보겠습니다. (gdb) disas print_total 0x804876c : push %ebp 0x804876d : mov %esp,%ebp 0x804876f : sub $0x78,%esp 0x8048772 : pushl 0xc(%ebp) 0x8048775 : push $0x8048a60 0x804877a : push $0x100 0x804877f : push $0x8049c80 0x8048784 : call 0x80485f8 0x8048789 : add $0x10,%esp 0x804878c : sub $0xc,%esp 0x804878f : push $0x8049c80 0x8048794 : call 0x8048730 0x8048799 : add $0x10,%esp 중간 생략 0x80487c8 : sub $0xc,%esp 0x80487cb : pushl 0x8049c48 0x80487d1 : call 0x8048548 0x80487d6 : add $0x10,%esp 0x80487d9 : mov %eax,%eax 0x80487db : mov %al,0xffffff97(%ebp) 중간 생략 0x8048851 : leave 0x8048852 : ret 다음.. print_total라는 함수에는 snprintf, Message, fgetc 이렇게 3가지의 함수가 사용되었네요. 중복되는 함수들이 나오는데 개별적으로 함수를 분석해보겠습니다. 먼저 print_total 함수가 실행될때 대략적인 메모리의 구조를 분석해 보겠습니다. 0x0000 +---------------------+ <-- 메모리의 낮은 번지 | | ~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~ | | ff8c +---------------------+ | int | ff90 +---------------------+ | char * | ff97 +---------------------+ | char | 4byte ff98 +---------------------+ | char | 90 byte +---------------------+ | dummy | 8 Byte [ebp] +---------------------+ <-- 프로그램 시작시 [ebp] 레지스터 | ebp | 4 Byte +---------------------+ | RET Address | <-- print_total(par1, par2) 함수가 실행될때 [RET] [ebp]+8 +---------------------+ | par1 | <-- parameter 1 [ebp]+c +---------------------+ 여기서 par1,2 는 임의로 붙인 변수명 입니다. | par2 | <-- parameter 2 +---------------------+ | | ~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~ | | <-- Stack의 하위 0xFFFF +---------------------+ <-- 메모리의 높은 번지 그러면 snprintf를 분석해보겠습니다. 함수의 원형은 다음과 같습니다. int snprintf(char *str, size_t size, const char *format, ...); 역어셈블된 상태를 보겠습니다. 0x8048772 : pushl 0xc(%ebp) <-- par2 0x8048775 : push $0x8048a60 <-- format = print할 포멧 0x804877a : push $0x100 <-- size = 0x100 0x804877f : push $0x8049c80 <-- pointer = tmp_buf 0x8048784 : call 0x80485f8 0x8048789 : add $0x10,%esp 여기에서 pushl 0x8048a60 이 있군요. 이것은 objdump -s lvl08 을 하여 해당번지가 일치하는 부분을 찾습니다. Contents of section .rodata: 8048a60 b4e7bdc5 c0cc20c0 d4b7c2c7 d220bcf6 ...... ...... .. 8048a70 20c0d6b4 c220b9ae c0da20bc f6b4c220 .... .... .... 8048a80 2564b0b3 20c0d4b4 cfb4d92e 0d0a0a00 %d.. ........... 뭔가를 출력하는 포멧인데 저 상태로는 뭔지 모르겠네요. 프로그램을 간단히 테스트 할때 출력한 상태를 기준으로 만들어 보면 "당신이 입력할 수 있는 문자 수는 %d개 입니다.\n" 인듯 합니다. 다음은 pushl $0x8049c80 이 있군요. 이것은 objdump -x lvl08 을 하여 해당번지가 일치하는 부분을 찾습니다. 08049c80 g O .bss 00000100 tmp_buf 따라서 int snprintf(char *str, size_t size, const char *format, ...); 함수는 snprintf(tmp_buf, sizeof(tmp_buf), "당신이 입력할 수 있는 문자 수는 %d개 입니다.\n", par2); 이렇게 만들어 집니다. 다음은 Message를 분석해 보겠습니다. 그런데 이 함수는 저위에서 분석을 했었죠. 함수의 원형이 void Message(char *str); 이렇게 되었었죠. 역어셈블된 상태를 보겠습니다. 0x804878c : sub $0xc,%esp <-- Dummy 0x804878f : push $0x8049c80 <-- 뭔가를 출력할 메시지의 주소이겠죠. 0x8048794 : call 0x8048730 0x8048799 : add $0x10,%esp 여기에서도 pushl $0x8049c80 이 있군요. 이것은 objdump -x lvl08 을 하여 해당번지가 일치하는 부분을 찾습니다. 08049c80 g O .bss 00000100 tmp_buf tmp_buf를 출력하는것을 알수가 있네요. 그러니까 snprintf()에서 조합해놓은 버퍼의 데이타를 출력하는 부분이군요. Message(tmp_buf); 이렇게 프로그램 되어있었겠네요. 다음은 fgetc 함수가 뭔지 알아보겠습니다. 먼저 이 함수의 원형이 어떻게 되어있는지 알아봐야죠. man fgetc를 해보겠습니다. int fgetc(FILE *stream); 이렇게 구성되어 있네요. 마찬가지로 역어셈블된 상태를 보겠습니다. 0x80487c8 : sub $0xc,%esp <-- Dummy 0x80487cb : pushl 0x8049c48 <-- stdin 0x80487d1 : call 0x8048548 0x80487d6 : add $0x10,%esp 여기에서 pushl 0x8049c48 이 있군요. 이것은 objdump -x lvl08 을 하여 해당번지가 일치하는 부분을 찾습니다. 08049c48 g O .bss 00000004 stdin@@GLIBC_2.0 stdin이라는 번지와 일치하는 군요.. 따라서 fgetc(stdin); 으로 됩니다. 이상 분석한 3가지 함수를 기준으로 print_total() 함수를 분석해 보겠습니다. (gdb) disas print_total 0x804876c : push %ebp 0x804876d : mov %esp,%ebp 0x804876f : sub $0x78,%esp <-- 여기까지는 C 함수의 원형입니다. +-> 내부 변수를 사용하는것을 알수가 있습니다. char ff98[90]; char ff97; char *ff90; int ff8c; snprintf(tmp_buf, sizeof(tmp_buf), "당신이 입력할 수 있는 문자 수는 %d개 입니다.\n", par2); 0x8048772 : pushl 0xc(%ebp) 0x8048775 : push $0x8048a60 0x804877a : push $0x100 0x804877f : push $0x8049c80 0x8048784 : call 0x80485f8 0x8048789 : add $0x10,%esp Message(tmp_buf); 0x804878c : sub $0xc,%esp 0x804878f : push $0x8049c80 0x8048794 : call 0x8048730 0x8048799 : add $0x10,%esp ff90 = ff98; 0x804879c : lea 0xffffff98(%ebp),%eax <-- (ebp-0x68)번지를 eax로 가져옴 0x804879f : mov %eax,0xffffff90(%ebp) <-- eax 내용을 (ebp-0x70)번지에 저장함 for(ff8c=0; ff8c < par2; ff8c++) { 0x80487a2 : movl $0x0,0xffffff8c(%ebp) <-- ff8c = 0 0x80487a9 : lea 0x0(%esi),%esi 0x80487ac : mov 0xffffff8c(%ebp),%eax 0x80487af : cmp 0xc(%ebp),%eax <-- ff8c 와 par2 를 비교 0x80487b2 : jl 0x80487b8 0x80487b4 : jmp 0x8048820 0x80487b6 : mov %esi,%esi Message("Input char : "); 0x80487b8 : sub $0xc,%esp 0x80487bb : push $0x8048a90 0x80487c0 : call 0x8048730 0x80487c5 : add $0x10,%esp ff97 = fgetc(stdin); 0x80487c8 : sub $0xc,%esp 0x80487cb : pushl 0x8049c48 0x80487d1 : call 0x8048548 0x80487d6 : add $0x10,%esp 0x80487d9 : mov %eax,%eax 0x80487db : mov %al,0xffffff97(%ebp) *(ff90++) = ff97; 0x80487de : mov 0xffffff90(%ebp),%edx 0x80487e1 : mov 0xffffff97(%ebp),%al 0x80487e4 : mov %al,(%edx) 0x80487e6 : lea 0xffffff90(%ebp),%eax 0x80487e9 : incl (%eax) ff97 = fgetc(stdin); 0x80487eb : sub $0xc,%esp 0x80487ee : pushl 0x8049c48 0x80487f4 : call 0x8048548 0x80487f9 : add $0x10,%esp 0x80487fc : mov %eax,%eax 0x80487fe : mov %al,0xffffff97(%ebp) ff97 = fgetc(stdin); 0x8048801 : sub $0xc,%esp 0x8048804 : pushl 0x8049c48 0x804880a : call 0x8048548 0x804880f : add $0x10,%esp 0x8048812 : mov %eax,%eax 0x8048814 : mov %al,0xffffff97(%ebp) 0x8048817 : lea 0xffffff8c(%ebp),%eax 0x804881a : incl (%eax) <-- ff8c++; 0x804881c : jmp 0x80487ac 0x804881e : mov %esi,%esi } *ff90 = 0x00; 0x8048820 : mov 0xffffff90(%ebp),%eax 0x8048823 : movb $0x0,(%eax) snprintf(tmp_buf, sizeof(tmp_buf), "당신이 입력한 단어는 %s입니다.\n", ff98); 0x8048826 : lea 0xffffff98(%ebp),%eax 0x8048829 : push %eax 0x804882a : push $0x8048aa0 0x804882f : push $0x100 0x8048834 : push $0x8049c80 0x8048839 : call 0x80485f8 0x804883e : add $0x10,%esp Message(tmp_buf); 0x8048841 : sub $0xc,%esp 0x8048844 : push $0x8049c80 0x8048849 : call 0x8048730 0x804884e : add $0x10,%esp 0x8048851 : leave <-- 함수를 끝내는 부분 입니다. 0x8048852 : ret C 로 번역된 부분을 하나씩 모아서 소스로 만들어 보겠습니다. void print_total(char *par1, int par2) { char ff98[90]; char ff97; char *ff90; int ff8c; snprintf(tmp_buf, sizeof(tmp_buf), "당신이 입력할 수 있는 문자 수는 %d개 입니다.\n", par2); Message(tmp_buf); ff90 = ff98; for(ff8c=0; ff8c: push %ebp 0x8048855 : mov %esp,%ebp 0x8048857 : sub $0x48,%esp int fff4 = 0x14; char ffd8[10]; <-- buff[10] int ffd4; int ffd0; int ffcc; int ffc8; int ffc4 = 0x10; int ffc0; 0x804885a : movl $0x14,0xfffffff4(%ebp) <-- fff4 = 0x14 0x8048861 : movl $0x10,0xffffffc4(%ebp) <-- ffc4 = 0x10 for( ffc0 = 0x00; ffc0 < argc; ffc0++) { 0x8048868 : movl $0x0,0xffffffc0(%ebp) <-- ffc0 = 0x00 0x804886f : nop 0x8048870 : mov 0xffffffc0(%ebp),%eax 0x8048873 : cmp 0x8(%ebp),%eax <-- ffc0 와 argc 의 비교. 0x8048876 : jl 0x804887c 0x8048878 : jmp 0x80488b8 memset(argv[ffc0], 0, strlen(argv[ffc0])); 0x804887a : mov %esi,%esi 0x804887c : sub $0x4,%esp 0x804887f : sub $0x8,%esp 0x8048882 : mov 0xffffffc0(%ebp),%eax 0x8048885 : imul $0x4,%eax,%edx 0x8048888 : mov 0xc(%ebp),%eax 0x804888b : pushl (%eax,%edx,1) 0x804888e : call 0x80485c8 0x8048893 : add $0xc,%esp 0x8048896 : mov %eax,%eax 0x8048898 : push %eax 0x8048899 : push $0x0 0x804889b : mov 0xffffffc0(%ebp),%eax 0x804889e : imul $0x4,%eax,%edx 0x80488a1 : mov 0xc(%ebp),%eax 0x80488a4 : pushl (%eax,%edx,1) 0x80488a7 : call 0x8048608 0x80488ac : add $0x10,%esp 0x80488af : lea 0xffffffc0(%ebp),%eax 0x80488b2 : incl (%eax) 0x80488b4 : jmp 0x8048870 } 0x80488b6 : mov %esi,%esi <-- 메모리의 주소를 4의 배수로 만들기 0x80488b8 : nop 위해서 삽입한 dummy code for(ffc0=0; environ[ffc0]; ffc0++) 0x80488b9 : movl $0x0,0xffffffc0(%ebp) <-- ffc0 = 0x00 0x80488c0 : mov 0xffffffc0(%ebp),%eax 0x80488c3 : imul $0x4,%eax,%ecx 0x80488c6 : mov 0x8049c40,%edx 0x80488cc : mov 0xffffffc0(%ebp),%eax 0x80488cf : cmp (%edx,%ecx,1),%eax 0x80488d2 : jb 0x80488d8 0x80488d4 : jmp 0x8048918 memset(environ[ffc0], 0, strlen(environ[ffc0])); 0x80488d6 : mov %esi,%esi 0x80488d8 : sub $0x4,%esp 0x80488db : sub $0x8,%esp 0x80488de : mov 0xffffffc0(%ebp),%eax 0x80488e1 : imul $0x4,%eax,%edx 0x80488e4 : mov 0x8049c40,%eax 0x80488e9 : pushl (%eax,%edx,1) 0x80488ec : call 0x80485c8 0x80488f1 : add $0xc,%esp 0x80488f4 : mov %eax,%eax 0x80488f6 : push %eax 0x80488f7 : push $0x0 0x80488f9 : mov 0xffffffc0(%ebp),%eax 0x80488fc : imul $0x4,%eax,%edx 0x80488ff : mov 0x8049c40,%eax 0x8048904 : pushl (%eax,%edx,1) 0x8048907 : call 0x8048608 0x804890c : add $0x10,%esp 0x804890f : lea 0xffffffc0(%ebp),%eax 0x8048912 : incl (%eax) <-- ffc0++ 0x8048914 : jmp 0x80488c0 0x8048916 : mov %esi,%esi } // int getpeername(int s, struct sockaddr *name, socklen_t *namelen); if (getpeername(0, ffc8, ffc4)== -1) 0x8048918 : sub $0x4,%esp 0x804891b : lea 0xffffffc4(%ebp),%eax 0x804891e : push %eax 0x804891f : lea 0xffffffc8(%ebp),%eax 0x8048922 : push %eax 0x8048923 : push $0x0 0x8048925 : call 0x80485a8 0x804892a : add $0x10,%esp 0x804892d : mov %eax,%eax 0x804892f : cmp $0xffffffff,%eax 0x8048932 : jne 0x8048968 snprintf(tmp_buf, sizeof(tmp_buf), "%d 안녕하세요. (null)님!\n", getlogin()); 0x8048934 : call 0x8048618 0x8048939 : mov %eax,%eax 0x804893b : push %eax 0x804893c : push $0x8048ac1 0x8048941 : push $0x100 0x8048946 : push $0x8049c80 0x804894b : call 0x80485f8 0x8048950 : add $0x10,%esp Message(tmp_buf); 0x8048953 : sub $0xc,%esp 0x8048956 : push $0x8049c80 0x804895b : call 0x8048730 0x8048960 : add $0x10,%esp 0x8048963 : jmp 0x80489a0 0x8048965 : lea 0x0(%esi),%esi } else { // char *inet_ntoa(struct in_addr in); snprintf(tmp_buf, sizeof(tmp_buf), "%d 안녕하세요. (null)님!\n", inet_ntoa(ffcc)); 0x8048968 : sub $0xc,%esp 0x804896b : pushl 0xffffffcc(%ebp) 0x804896e : call 0x8048588 0x8048973 : add $0x10,%esp 0x8048976 : mov %eax,%eax 0x8048978 : push %eax 0x8048979 : push $0x8048ae0 0x804897e : push $0x100 0x8048983 : push $0x8049c80 0x8048988 : call 0x80485f8 0x804898d : add $0x10,%esp Message(tmp_buf); 0x8048990 : sub $0xc,%esp 0x8048993 : push $0x8049c80 0x8048998 : call 0x8048730 200 안녕하세요. (null)님! 0x804899d : add $0x10,%esp } Message("이름 : "); 0x80489a0 : sub $0xc,%esp 0x80489a3 : push $0x8048b0a 0x80489a8 : call 0x8048730 이름: 0x80489ad : add $0x10,%esp fgets(ffd8, sizeof(ffd8), stdin); // 30 byte 0x80489b0 : sub $0x4,%esp 0x80489b3 : pushl 0x8049c48 <-- stdin 0x80489b9 : push $0x1e <-- 30 byte 0x80489bb : lea 0xffffffd8(%ebp),%eax 0x80489be : push %eax 0x80489bf : call 0x80485b8 이름 입력을 받는곳. 0x80489c4 : add $0x10,%esp print_total(ffd8, fff4); 0x80489c7 : sub $0x8,%esp 0x80489ca : pushl 0xfffffff4(%ebp) 0x80489cd : lea 0xffffffd8(%ebp),%eax 0x80489d0 : push %eax 0x80489d1 : call 0x804876c 0x80489d6 : add $0x10,%esp 0x80489d9 : leave 0x80489da : ret } 이렇게 C 로 번역된 main 부분을 하나씩 모아서 소스로 만들어 보겠습니다. int main(int argc, char **argv) { int fff4 = 0x14; char ffd8[10]; int ffd4; int ffd0; int ffcc; int ffc8; int ffc4 = 0x10; int ffc0; for( ffc0 = 0x00; ffc0 < argc; ffc0++) memset(argv[ffc0], 0, strlen(argv[ffc0])); for(ffc0=0; environ[ffc0]; ffc0++) memset(environ[ffc0], 0, strlen(environ[ffc0])); /* // int getpeername(int s, struct sockaddr *name, socklen_t *namelen); if (getpeername(0, ffc8, ffc4)== -1) snprintf(tmp_buf, sizeof(tmp_buf), "%d 안녕하세요. (null)님!\n", getlogin()); Message(tmp_buf); } else { // char *inet_ntoa(struct in_addr in); snprintf(tmp_buf, sizeof(tmp_buf), "%d 안녕하세요. (null)님!\n", inet_ntoa(ffcc)); Message(tmp_buf); } */ Message("이름 : "); fgets(ffd8, 30, stdin); // fgets(ffd8, sizeof(ffd8)+2, stdin); // 30 byte print_total(ffd8, fff4); } 이파일을 컴파일하여 본래의 역어셈블 파일과 같은 상태로 만들어 줍니다. 이것을 모두 조합하면 다음의 소스가 만들어 집니다. #include #include extern char **environ; char tmp_buf[256]; void Message(char *str) { write(1, str, strlen(str)); fflush(stdout); } void print_total(char *par1, int par2) { char ff98[90]; char ff97; char *ff90; int ff8c; snprintf(tmp_buf, sizeof(tmp_buf), "당신이 입력할 수 있는 문자 수는 %d개 입니다.\n", par2); Message(tmp_buf); ff90 = ff98; for(ff8c=0; ff8c #include #include "dumpcode.h" extern char **environ; char tmp_buf[256]; unsigned long get_ret(void) { __asm__("movl %ebx,%eax"); } void Message(char *str) { write(1, str, strlen(str)); fflush(stdout); } void print_total(char *par1, int par2) { char buff[90]; // ff98 char ch; // ff97 char *ptr; // ff90 int i; // ff8c __asm__("push %ebx"); // Save [ebx] register __asm__("movl %ebp,%ebx"); // [ebx] <- [ebp] printf("P Return Address = %x\n", get_ret()+0x04); // Return Address 찿기 __asm__("pop %ebx"); // Restore [ebx] snprintf(tmp_buf, sizeof(tmp_buf), "당신이 입력할 수 있는 문자 수는 %d개 입니다.\n", par2); Message(tmp_buf); ptr = buff; for(i=0; i #include #include #include #include #define MAX_NAME_LEN 12 #define DEF_COUNT 20 #define DEF_BUF_LEN 256 extern char **environ; char tmp_buf[DEF_BUF_LEN]; void Message(char *buf) { write(STDOUT_FILENO, buf, strlen(buf)); fflush(stdout); } void print_total(char *name, int count) { char padding[50]; char buf[DEF_COUNT+1], ch, *ptr; int i; snprintf(tmp_buf, DEF_BUF_LEN, "당신이 입력할 수 있는 문자 수는 %d개 입니다.\r\n", count); Message(tmp_buf); ptr = buf; for (i=0; i