C++逆向学习(二) vector

现在的逆向C++题越来越多，经常上来就是一堆容器、标准模板库，这个系列主要记录这些方面的逆向学习心得

本文主要介绍 std::vector ，因为逆向题中的C++代码可能会故意写的很绕，比如输入一个数组，直接给 vector 赋值即可，但是也可以用稍微费解的方法 连续push_back() ，也算是一种混淆的手段，文章中的示例会逆向一些故意写的繁琐的程序

vector

内存布局

仍然用vs调试，观察内存布局

vector a 的第一个字段是 size 大小 第二个字段是 capacity 容量

和 std::string 差不多

当 size>capacity 也就是空间不够用时

首先配置一块新空间，然后将元素从旧空间一一搬往新空间，再把旧空间归还给操作系统

内存增长机制

测试代码：

#include<iostream>
#include<vector>
using namespace std;

int main(int argc, char** argv) {
    std::vector<int> a;
    int num[16];
    for (int i = 0; i < 100; i++) {
        a.push_back(i);
        std::cout << "size : " << i+1 << "\t" << "capacity : " << a.capacity() << std::endl;
    }
    system("pause");
    return 0;
}
//visual studio 2019 x64

运行结果：

可以看到，后面的增长速度和 std::string 一样是1.5倍扩容，一开始有点差别，分析一下源码

else if (max_size() - size() < _Count)
    //可以申请的最大容量也不够用，抛出异常_THROW(length_error, "vector<T> too long");
    _Xlen();
else if (_Capacity < size() + _Count){//空间不足，需要扩容   
    _Capacity = max_size() - _Capacity / 2 < _Capacity
        ? 0 : _Capacity + _Capacity / 2;    // 尝试扩容1.5倍
    if (_Capacity < size() + _Count)//扩容1.5倍后依然不够用，则容量等于当前数据个数加上新增数据个数
        _Capacity = size() + _Count;
    pointer _Newvec = this->_Alval.allocate(_Capacity);//申请新空间
    pointer _Ptr = _Newvec;
    _TRY_BEGIN
        _Ptr = _Umove(_Myfirst, _VEC_ITER_BASE(_Where),
            _Newvec);   //move原先的数据
    _Ptr = _Ucopy(_First, _Last, _Ptr); //copy新增的数据到新内存之后
    _Umove(_VEC_ITER_BASE(_Where), _Mylast, _Ptr);  
    _CATCH_ALL
        _Destroy(_Newvec, _Ptr);
    this->_Alval.deallocate(_Newvec, _Capacity);//释放原来申请的内存
    _RERAISE;
    _CATCH_END
...

详见注释，注意这句 扩容1.5倍后依然不够用，则容量等于当前数据个数加上新增数据个数 ，也就解释了一开始的增长是 1 2 3 4 的原因

调试

具体调试一下，当 push_back (0)和(1)时：

注意一开始的内存窗口，每次动态扩容时确实已经改变了存储空间的地址

再F5执行到断点，内存窗口的 红色 说明这块内存刚动过，已经被操作系统回收了， vector 中的元素也已经改变了存放地址

accumulate

上次写西湖论剑 easyCpp 的探究时有朋友说再举一些 std::accumulate 的例子...

关于用 std::accumulate + lambda 反转 vector ，在上一篇文章已经写过了

西湖论剑初赛easyCpp探究

在这边就算是补个例子

#include<iostream>
#include<vector>
#include<algorithm>
#include<numeric>

using namespace std;

int main(int argc, char** argv) {
    std::vector<int> v(5);
    for (int i = 0; i < 5; i++) {
        std::cin >> v[i];
    }
    int sum = std::accumulate(v.begin(), v.end(), 0,
        [](int acc, int _) {return acc + _; });
    std::cout << sum;
    return 0;
}
//visual studio 2019 x64

std::accumulate 对一个容器进行 折叠 ，并且是 左折叠 ，对其进行 一元操作 ，实例中为 lambda +

因为 迭代器 可以看作是 容器 与 算法 的中间层，这也是STL的设计哲学，因此传入的是 vector 的 begin() 和 end()

在"循环"的内部，通过判断 当前迭代器是否到达末尾 得到是否结束循环的信息，形如：

for(vector<int>::const_iterator iter=ivec.begin();iter!=ivec.end();++iter){
    /*...*/ 
}

IDA视角

IDA中打开，因为是windows下vs编译的，看不出 vector 和 accumulate 和 lambda 的特征了

分析一下，开了一块内存0x14字节，也就是对应我们的5个int

依次输入赋值，最后用一个指针++遍历这个地址

获得累加和并输出

transform

换个稍复杂的 std::transform 的例子，保留特征，用g++编译

#include<iostream>
#include<vector>
#include<algorithm>
#include<numeric>

using namespace std;

int main(int argc, char** argv) {
    std::vector<int> a = { 1,2,3,4,5};
    std::vector<int> b(5);
    std::vector<int> result;
    for (int i = 0; i < 5; i++) { std::cin >> b[i]; }
    std::transform(a.begin(), a.end(), b.begin(), std::back_inserter(result),
        [](int _1, int _2) { return _1 * _2; });

    for (int i = 0; i < 5; i++) {
        if (result[i] != 2 * (i + 1)) {
            std::cout << "You failed!" << std::endl;
            exit(0);
        }
    }
    std::cout << "You win!" << std::endl;
    return 0;
}
//g++ main.cpp -o test -std=c++14

用 std::transform 同时对两个列表进行操作，输入5个数存入 vector b 中，然后 vector result 分别是 a[i]*b[i] ，最后判断 result 中的每个数是否符合要求

注意， vector b 大小一定要超过 vector a ，从参数中也可以看出来， b 只传入了 begin()

如果 vector b 较小，后面的内存存放的是未知的数据

会造成未定义行为 UB

IDA视角

IDA打开可以看到 vector 相关代码，但是命名很乱，根据 std::transform 二元操作符 的特征我们可以更改一下变量名

我们定义的 vector{1,2,3,4,5} 在内存中如下