Canvas is not supported in your browser.
首页 课程 文章
无痕注入 APC注入 线程注入 读写驱动 注入技术 句柄表 进程线程 系统调用 保护模式 内存管理 远程CALL 软件调试 驱动封装 云下发 驱动开发 FPS数据 方框透视 FPS方框 FPS自瞄 CE D3DHOOK D3D绘制 Imgui绘制 DWM
内核课程 驱动出租 学习路线 聊天室 免责声明 提问技巧

Windows 之 CRT的检测内存泄露

推荐 原创

周杰伦

文章分类 编程技术 阅读数 : 458 阅读时长 : 9分钟

Windows 之 CRT的检测内存泄露

使用方法

使用方法非常简单，首先定义宏_CRTDBG_MAP_ALLOC，然后包含头文件crtdbg.h，最后在main函数结尾调用_CrtDumpMemoryLeaks统计内存申请和释放的情况。相关例子如下，编译的时候需要在Debug模式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>
#include <iostream>
 
int main()
{
     std::cout << "Hello World!\n" ;
     int * x = ( int *) malloc ( sizeof ( int ));
     *x = 7;
     printf ( "%d\n" , *x);
     x = ( int *) calloc (3, sizeof ( int ));
     x[0] = 7;
     x[1] = 77;
     x[2] = 777;
 
     printf ( "%d %d %d\n" , x[0], x[1], x[2]);
     _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_DEBUG);
     _CrtDumpMemoryLeaks();
}

运行结果如下:

1
2
3
4
5
6
7
8
Detected memory leaks!
Dumping objects ->
main.cpp(16) : {163} normal block at 0x000002882AE17740, 12 bytes long .
  Data: <    M       > 07 00 00 00 4D 00 00 00 09 03 00 00
main.cpp(10) : {162} normal block at 0x000002882AE148C0, 4 bytes long .
  Data: <    > 07 00 00 00
Object dump complete.
// main.cpp(x) 表示在main.cpp的x行申请的内存没有被释放

CRT 检测的原理

在安装Visual Studio之后，Windows CRT的源码已经被存放在C:\Program Files (x86)\Windows Kits\10\Source\，这个目录下面有多个sdk的版本，我选择的是19041。

内存的申请

在C++编程语言中，内存申请对应的关键字是new或malloc，其实new最后调用的也是malloc函数，对应源代码文件是debug_heap.cpp。在包含相关头文件之后，malloc函数的调用栈为：malloc -> _malloc_dbg -> heap_alloc_dbg -> heap_alloc_dbg_internal。heap_alloc_dbg_internal函数分析如下：

  1. 获取临界区，保证当前只有一个线程进入.
1
2
3
4
5
6
__acrt_lock(__acrt_heap_lock);
 
extern "C" void __cdecl __acrt_lock(_In_ __acrt_lock_id _Lock)
{
     EnterCriticalSection(&__acrt_lock_table[_Lock]);
}
  1. 执行自定义malloc的回调函数.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
if (_crtBreakAlloc != -1 && request_number == _crtBreakAlloc)
{
     _CrtDbgBreak();
}
 
if (_pfnAllocHook && !_pfnAllocHook(
     _HOOK_ALLOC,
     nullptr,
     size,
     block_use,
     request_number,
     reinterpret_cast <unsigned char const *>(file_name),
     line_number))
{
     if (file_name)
         _RPTN(_CRT_WARN, "Client hook allocation failure at file %hs line %d.\n" , file_name, line_number);
     else
         _RPT0(_CRT_WARN, "Client hook allocation failure.\n" );
 
     __leave;
}

_pfnAllocHook有一个默认的回调函数，也允许程序员自己定义，回调函数原型如下:

1
2
3
4
5
6
7
8
9
typedef int (__cdecl * _CRT_ALLOC_HOOK)(
     int  const allocation_type,
     void *                const data,
     size_t               const size,
     int                  const block_use,
     long                 const request,
     unsigned char const * const file_name,
     int                  const line_number
);

设置回调函数的接口为_CrtSetAllocHook.
3. 调用Windows API分配内存，不过需要多分配一些冗余内存，记录一些信息，用于管理malloc分配的内存。
管理的数据结构如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
struct _CrtMemBlockHeader
{
     _CrtMemBlockHeader* _block_header_next;     //
     _CrtMemBlockHeader* _block_header_prev;     // 双向链表，访问该双向链表的全局变量为__acrt_first_block
     char const *         _file_name;             // 调用malloc的文件名
     int                 _line_number;           // 调用malloc的行数
 
     int                 _block_use;             // 内存类型，所有内存类型如下
     /*
      #define _FREE_BLOCK      0     // 内存释放
      #define _NORMAL_BLOCK    1     // 内存申请
      #define _CRT_BLOCK       2     // 标注CRT库申请的内存
      #define _IGNORE_BLOCK    3     // 此类内存不进行管理
      #define _CLIENT_BLOCK    4     // 暂时没找到用法
      #define _MAX_BLOCKS      5     // 暂时没找到用法
      */
     size_t              _data_size;             // malloc分配的大小
     long                _request_number;        // 记录分配内存的序号，每次分配内存自增1
     unsigned char       _gap[no_mans_land_size]; // 标记
 
     // Followed by:
     // unsigned char    _data[_data_size];          // malloc返回的内存
     // unsigned char    _another_gap[no_mans_land_size];    // 标记
};

结构中成员_gap填充了no_mans_land_size(4)个0xFD，在释放内存时检测写内存时是否出现溢出(上溢)。该结构后续的内容是malloc返回的内存，内存中被填充了0xCD。最后内存_another_gap也是填充了no_mans_land_size(4)个0xFD，在释放内存时检测写内存时是否出现溢出(下溢)。

内存的扩容

在C++编程语言中，内存扩容的关键字为realloc，对应的源文件是realloc.cpp，realloc函数的调用栈为：realloc -> _realloc_dbg -> realloc_dbg_nolock。该函数的函数原型如下：

1
2
3
4
5
6
7
8
static void * __cdecl realloc_dbg_nolock(
     void *       const block,
     size_t *     const new_size,
     int         const block_use,
     char const * const file_name,
     int         const line_number,
     bool        const reallocation_is_allowed
     ) throw ()
  1. 检查block和new_size的情况.
1
2
3
4
5
6
7
8
9
if (!block)         // block为nullptr，蜕变为malloc(size)
{
     return _malloc_dbg(*new_size, block_use, file_name, line_number);
}
if (reallocation_is_allowed && *new_size == 0)  // *new_size为0，则蜕变为free(block)
{
     _free_dbg(block, block_use);
     return nullptr;
}
  1. 调用_pfnAllocHook回调函数，参数allocation_type为_HOOK_REALLOC。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
if (_pfnAllocHook && !_pfnAllocHook(
     _HOOK_REALLOC,
     block,
     *new_size,
     block_use,
     request_number,
     reinterpret_cast <unsigned char const *>(file_name),
     line_number))
{
     if (file_name)
         _RPTN(_CRT_WARN, "Client hook re-allocation failure at file %hs line %d.\n" , file_name, line_number);
     else
         _RPT0(_CRT_WARN, "Client hook re-allocation failure.\n" );
 
     return nullptr;
}
  1. 对block进行一系列检查
1
2
3
4
5
6
7
8
9
10
11
is_block_an_aligned_allocation(block)       // 检查block是否被_aligned_malloc分配的，若是，则返回nullptr.
_ASSERTE(_CrtIsValidHeapPointer(block));    // 保证block内存属于进程堆
检查 -> 堆的类型是否是_IGNORE_BLOCK
检查 -> block的header的_data_size是否被破坏
检查 -> *new_size 是否过大
// Ensure the new requested size is not too large:
if (*new_size > static_cast < size_t >(_HEAP_MAXREQ - no_mans_land_size - sizeof (_CrtMemBlockHeader)))
{
     errno = ENOMEM;
     return nullptr;
}
  1. 分配一个新的_CrtMemBlockHeader结构
1
2
3
4
size_t const new_internal_size{ sizeof (_CrtMemBlockHeader) + *new_size + no_mans_land_size};
_CrtMemBlockHeader* new_head{nullptr};
new_head = static_cast <_CrtMemBlockHeader*>(_realloc_base(old_head, new_internal_size));
// _realloc_base中调用HeapReAlloc函数重新分配
  1. 对新分配的内存初始化
1
2
3
4
5
6
7
// If the block grew, fill the "extension" with the land fill value:
if (*new_size > new_head->_data_size)       // *new_size 新的内存大于原来的
{
     memset (new_block + new_head->_data_size, clean_land_fill, *new_size - new_head->_data_size);
}
// Fill in the gap after the client block:
memset (new_block + *new_size, no_mans_land_fill, no_mans_land_size);    // 填充向下溢出的标记
  1. 将新的header链接到双向链表中
1
2
3
4
5
6
7
8
9
// 删除原来的元素
new_head->_block_header_prev->_block_header_next = new_head->_block_header_next;
new_head->_block_header_prev->_block_header_next = new_head->_block_header_next;
 
// 替换__acrt_first_block指向的元素
__acrt_first_block->_block_header_prev = new_head;
new_head->_block_header_next = __acrt_first_block;
new_head->_block_header_prev = nullptr;
__acrt_first_block = new_head;

内存的释放

在C++编程语言中，内存释放对应的关键字是delete或free，delete操作符最后调用到free函数，对应的源文件是debug_heap.cpp。
free函数的调用栈为：free -> _free_dbg -> free_dbg_nolock，_free_dbg函数会获取临界区然后调用free_dbg_nolock。free_dbg_nolock函数分析过程如下：

  1. 释放内存时block_use为_FREE_BLOCK，若此时block_use为_NORMAL_BLOCK，且block由_aligned_malloc分配，不进行内存释放。
1
2
3
4
5
6
7
8
// Check to ensure that the block was not allocated by _aligned routines
if (block_use == _NORMAL_BLOCK && is_block_an_aligned_allocation(block))
{
     // We don't know (yet) where (file, linenum) block was allocated
     _RPTN(_CRT_ERROR, "The Block at 0x%p was allocated by aligned routines, use _aligned_free()" , block);
     errno = EINVAL;
     return ;
}
  1. 调用_pfnAllocHook，只不过allocation_type换成了_HOOK_FREE。
1
2
3
4
5
6
// Forced failure handling
if (_pfnAllocHook && !_pfnAllocHook(_HOOK_FREE, block, 0, block_use, 0, nullptr, 0))
{
     _RPT0(_CRT_WARN, "Client hook free failure.\n" );
     return ;
}
  1. 进行一系列检查
1
2
3
4
5
6
_ASSERTE(_CrtIsValidHeapPointer(block));    // 保证block是从进程堆申请的
_ASSERTE(is_block_type_valid(header->_block_use)); // 保证block的堆类型是正常的
_ASSERTE(header->_block_use == block_use || header->_block_use == _CRT_BLOCK && block_use == _NORMAL_BLOCK);
// 检查之前的标记是否被破坏，被破坏意味着存在内存溢出
check_bytes(header->_gap, no_mans_land_fill, no_mans_land_size)
check_bytes(block_from_header(header) + header->_data_size, no_mans_land_fill, no_mans_land_size)
  1. 在双向链表中，删除block元素，并释放内存.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 删除双向链表中的元素
header->_block_header_next->_block_header_prev = header->_block_header_prev;
header->_block_header_prev->_block_header_next = header->_block_header_next;
// 调用Windows api释放内存
extern "C" void __declspec ( noinline ) __cdecl _free_base( void * const block)
{
     if (block == nullptr)
     {
         return ;
     }
 
     if (!HeapFree(select_heap(block), 0, block))
     {
         errno = __acrt_errno_from_os_error(GetLastError());
     }
}

内存统计

调用_CrtDumpMemoryLeaks进行内存统计，主要是两个函数：_CrtMemCheckpoint(统计)和_CrtMemDumpAllObjectsSince(显示)

  • _CrtMemCheckpoint主要统计除了_FREE_BLOCK类型之外的其他内存，结果的数据结构如下：
1
2
3
4
5
6
7
8
typedef struct _CrtMemState
{
     struct _CrtMemBlockHeader * pBlockHeader;   // __acrt_first_block
     size_t lCounts[_MAX_BLOCKS];    // 统计各类型的数据
     size_t lSizes[_MAX_BLOCKS];     // 统计各类型内存的大小
     size_t lHighWaterCount;         //
     size_t lTotalCount;             // 所有的内存
} _CrtMemState;
  • _CrtMemDumpAllObjectsSince主要显示_NORMAL_BLOCK、_CRT_BLOCK和_CLIENT_BLOCK类型的内存，显示的回调函数可以自行设置，函数原型如下：
1
typedef void (__cdecl * _CRT_DUMP_CLIENT)( void *, size_t );

CRT库检测内存泄露的优缺点

优点

  • Windows SDK自带的内存泄露检测工具，使用简单方便。

缺点

  • 无法检测使用Windows APi来分配内存的情况，如: HeapAlloc或VirtualAlloc.
  • 仅使用源码模式下的检测，对于已编译成功的二进制文件无能为力.
  • 若程序依赖于其他的库文件，库文件出现的内存泄露无法被检测。


更多【Windows 之 CRT的检测内存泄露】相关视频教程：www.yxfzedu.com




相关文章推荐

记录自己的技术轨迹
文章规则：
1)：文章标题请尽量与文章内容相符
2)：严禁色情、血腥、暴力
3)：严禁发布任何形式的广告贴
4)：严禁发表关于中国的政治类话题
5)：严格遵守中国互联网法律法规
6)：有侵权,疑问可发邮件至service@yxfzedu.com
近期原创 更多
友情链接
内核结构 FAQ
免责声明
课程目录
Windows内核
游戏逆向(FPS)
技术交流QQ群
342478842 215039827 137189196
314055665 159620936
微信公众号
www.yxfzedu.com是一个分享游戏安全,游戏外挂与反外挂,游戏驱动保护的视频网站！
接各种驱动定制如：游戏读写驱动，软件内存保护，防止调试等功能定制。
出租读写驱动，调试驱动，无痕注入支持各种游戏。
邮箱：service@yxfzedu.com
QQ：851920120
特别说明：不接游戏数据分析，外挂编写，登陆协议等类似业务。