[MS08-067] 공격 코드

[MS08-067] Server Service 취약점으로 인한 원격코드실행 문제

□ 영향
  o 공격자가 영향 받는 시스템에 대해 완전한 권한 획득
 
□ 설명
  o Server Service에 원격코드실행이 가능한 취약점이 존재
    ※ Server Service :Windows 운영체제에서 파일, 폴더 및 주변장치 등을 공유하기 위해
       지원하는 기능으로 네트워크의 다른 사용자들이 해당 리소스를 액세스할 수 있음
  o 공격자는 Server Service에 조작된 RPC 요청을 전달하여 공격함. 공격이 성공하면
    공격자는 영향 받는 시스템에 대해 완전한 권한 획득 가능
    ※ RPC(Remote Procedure Call) : 분산 환경에 컴퓨터간 서비스 요청에 사용되는 프로토콜
  o 관련취약점 : Server Service Vulnerability - CVE-2008-4250
  o 영향 : 원격 코드 실행
  o 중요도 : 긴급

□ 해당시스템 
  o 영향 받는 소프트웨어
    - Microsoft Windows 2000 SP4
    - Microsoft Windows XP SP2, SP3
    - Microsoft Windows XP Professional x64 Edition, SP2
    - Microsoft Windows Server 2003 SP1, SP2
    - Microsoft Windows Server 2003 SP1, SP2 for Itanium-based Systems
    - Microsoft Windows Server 2003 x64 Edition, SP2
    - Windows Vista, SP1
    - Windows Vista x64 Edition
    - Windows Server 2008, x64 Edition, Itanium-based Systems
 
□ 해결책 
  o 해당 시스템에 대한 마이크로소프트사의 취약점 패치 적용
  o TCP 139, 445 통신 포트가 반드시 필요한 경우가 아니면 방화벽에서 차단

□ 참조사이트
  o 영문 : http://www.microsoft.com/technet/security/bulletin/MS08-067.mspx

#include <wchar.h>

// This is the decompiled function sub_5B86A51B in netapi32.dll on XP SP3

int ms08_067(wchar_t* path)
{
  wchar_t* p;
  wchar_t* q;
  wchar_t* previous_slash = NULL;
  wchar_t* current_slash  = NULL;
  wchar_t  ch;

  // If the path starts with a server name, skip it

  if ((path[0] == L'\\' || path[0] == L'/') &&
      (path[1] == L'\\' || path[1] == L'/'))
  {
      p = path+2;

      while (*p != L'\\' || *p != L'/') {
          if (*p == L'\0')
              return 0;
          p++;
      }

      p++;

      // make path point after the server name

      path = p;

      // make sure the server name is followed by a single slash

      if (path[0] == L'\\' || path[0] == L'/')
          return 0;
  }

  if (path[0] == L'\0')   // return if the path is empty
      return 1;

  // Iterate through the path and canonicalize ..\ and .\

  p = path;

  while (1) {
      if (*p == L'\\') {
          // we have a slash

          if (current_slash == p-1)   // don't allow consequtive slashes
              return 0;

          // store the Locations of the current and previous slashes

          previous_slash = current_slash;
          current_slash = p;
      }
      else if (*p == L'.' && (current_slash == p-1 || p == path)) {
          // we have \. or ^.

          if (p[1] == L'.' && (p[2] == L'\\' || p[2] == L'\0')) {
              // we have a \..\, \..$, ^..\ or ^..$ sequence

              if (previous_slash == NULL)
                  return 0;

              // example: aaa\bbb\..\ccc
              //             ^   ^  ^
              //             |   |  &p[2]
              //             |   |
              //             |   current_slash
              //             |
              //             previous_slash

              ch = p[2];

              wcscpy(previous_slash, &p[2]);

              if (ch == L'\0')
                  return 1;

              current_slash = previous_slash;
              p = previous_slash;

              // find the slash before p

              // BUG: if previous_slash points to the beginning of the
              // string, we'll go beyond the start of the buffer
              //
              // example string: \a\..\

              q = p-1;

              while (*q != L'\\' && q != path)
                  q--;

              if (*p == L'\\')
                  previous_slash = q;
              else
                  previous_slash = NULL;
          }
          else if (p[1] == L'\\') {
              // we have \.\ or ^.\

              if (current_slash != NULL) {
                  wcscpy(current_slash, &p[1]);
                  goto end_of_loop;
              }
              else { // current_slash == NULL
                  wcscpy(p, p+2);
                  goto end_of_loop;
              }
          }
          else if (p[1] != L'\0') {
              // we have \. or ^. followed by some other char

              if (current_slash != NULL) {
                  p = current_slash;
              }
              *p = L'\0';
              return 1;
          }
      }

      p++;

end_of_loop:
      if (*p == L'\0')
          return 1;
  }
}

// Run this program to simulate the MS08-067 vulnerability

int main()
{
  return ms08_067(L"\\a\\..\\");
}