堆溢出 对HeapFree函数的详细调试

最新推荐文章于 2025-10-04 09:39:32 发布
原创 最新推荐文章于 2025-10-04 09:39:32 发布 · 1.7k 阅读 · 2 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#堆栈 #安全
本文通过详细的代码示例和步骤解析，深入探讨了Windows环境下内存分配与释放的过程，特别是使用HeapAlloc函数时堆内存的分配、合并等操作细节。

代码

#include <windows.h>
int main()
{
	HLOCAL h1,h2,h3,h4,h5,h6;
	HANDLE hp;
	hp = HeapCreate(0,0x1000,0x10000);

	
	h1 = HeapAlloc(hp,HEAP_ZERO_MEMORY,3);
	h2 = HeapAlloc(hp,HEAP_ZERO_MEMORY,5);
	h3 = HeapAlloc(hp,HEAP_ZERO_MEMORY,6);
	h4 = HeapAlloc(hp,HEAP_ZERO_MEMORY,8);
	h5 = HeapAlloc(hp,HEAP_ZERO_MEMORY,19);
	h6 = HeapAlloc(hp,HEAP_ZERO_MEMORY,24);
	
	_asm int 3
	HeapFree(hp,0,h1);
	HeapFree(hp,0,h3);
	HeapFree(hp,0,h5);
	_asm int 3

	HeapFree(hp,0,h4);


	return 0;
}

实验目的

了解HeapAlloc函数的操作过程

实验准备

环境：windows 2k professional
编译器：vc++
调试器：OD

实验过程

1.首先观察链表是怎么装载进去的

CPU Disasm
Address   Hex dump          Command                                  Comments
77FCC8E6  |.  8066 05 10    AND BYTE PTR DS:[ESI+5],10 //对堆块中Flag位进行更改，使其为占用态

2.然后修改被装载进去堆块的地址，先改被占用堆块的第一项，第二项，再去修改Freelist[1]中的第一项第二项，然后再把可用的总空间加起来放进堆块一开始偏移0x28的地方。

77FCC909  |.  8D46 08       LEA EAX,[ESI+8]
77FCC90C  |.  8918          MOV DWORD PTR DS:[EAX],EBX
77FCC90E  |.  894E 0C       MOV DWORD PTR DS:[ESI+0C],ECX
77FCC911  |.  8901          MOV DWORD PTR DS:[ECX],EAX
77FCC913  |.  8943 04       MOV DWORD PTR DS:[EBX+4],EAX             //把地址进行替换
77FCC916  |.  8B45 D0       MOV EAX,DWORD PTR SS:[EBP-30]    
77FCC919  |.  0147 28       ADD DWORD PTR DS:[EDI+28],EAX              //add last part
77FCC91C  |>  834D FC FF    OR DWORD PTR SS:[EBP-4],FFFFFFFF

3.然后再把int 3断点往下再移一位，观察堆的拆卸，装载这一系列的操作。先开头还是一些准备的传参的工作，上线程锁啊这些的。然后就进入了关键的函数。这是函数的一波传参。

77FCC8CA  |.  6A 00         PUSH 0                                   //Arg4 = 0
77FCC8CC  |.  8D45 D0       LEA EAX,[LOCAL.12]                       
77FCC8CF  |.  50            PUSH EAX                                 //Arg3 = 指向堆栈中存放数组的指针
77FCC8D0  |.  56            PUSH ESI                                 //Arg2 = 指向Free的那个堆块的堆块头部
77FCC8D1  |.  57            PUSH EDI                                 //Arg1 = 指向整个堆块的最前面
77FCC8D2  |.  E8 EA000000   CALL 77FCC9C1                             //ntdll.77FCC9C1

4.然后的代码就是判断上一个堆块的一些数据，来判断要不要合并

77FCC9C1  /$  55            PUSH EBP                                 // ntdll.77FCC9C1(guessed Arg1,Arg2,Arg3,Arg4)
77FCC9C2  |.  8BEC          MOV EBP,ESP
77FCC9C4  |.  53            PUSH EBX
77FCC9C5  |.  56            PUSH ESI
77FCC9C6  |.  8B75 0C       MOV ESI,DWORD PTR SS:[ARG.2]             //指向Free的那个堆块的堆块头部
77FCC9C9  |.  8B5D 08       MOV EBX,DWORD PTR SS:[ARG.1]             //指向HeapCreate堆块的头
77FCC9CC  |.  57            PUSH EDI
77FCC9CD  |.  8BFE          MOV EDI,ESI
77FCC9CF  |.  0FB746 02     MOVZX EAX,WORD PTR DS:[ESI+2]            //读取上一节的长度
77FCC9D3  |.  C1E0 03       SHL EAX,3
77FCC9D6  |.  2BF8          SUB EDI,EAX
77FCC9D8  |.  3BFE          CMP EDI,ESI                              //判断前面的那个堆块是不是只和一块空表连着的，如果连着的判断是不是尾块
77FCC9DA  |.  74 0A         JE SHORT 77FCC9E6
77FCC9DC  |.  F647 05 01    TEST BYTE PTR DS:[EDI+5],01              //观察前一块的是否是占用态
77FCC9E0  |.^ 0F84 98E9FFFF JZ 77FCB37E

5.然后就进行了相加的操作，那个Call 778953A的作用应该是检测那个堆块所对应的链表。

77FCB37E  |> /8B4D 10       MOV ECX,DWORD PTR SS:[EBP+10]
77FCB381  |. |0FB707        MOVZX EAX,WORD PTR DS:[EDI]
77FCB384  |. |8B09          MOV ECX,DWORD PTR DS:[ECX]
77FCB386  |. |03C8          ADD ECX,EAX                              //上一节堆块的大小再加上这一节的进行合并
77FCB388  |. |81F9 00FE0000 CMP ECX,0FE00
77FCB38E  |. |0F87 52160000 JA 77FCC9E6
77FCB394  |. |807D 14 00    CMP BYTE PTR SS:[EBP+14],0
77FCB398  |. |0F85 6A370000 JNE 77FCEB08
77FCB39E  |> |57            PUSH EDI                                 //指向Free的那个堆块的前一个堆块
77FCB39F  |. |53            PUSH EBX                                 //指向整个堆块的最前面
77FCB3A0  |. |E8 95E1FBFF   CALL 77F8953A                            // ntdll.77F8953A

6.先把之前的那个表从链表中拿出来，同时还检测了这块上再上面一块，如果这再上面一块不是占用态的话还要继续进行合并。再把堆块最前面对大小的说明的那一部分进行改动。

77FCB3A5  |.  8B4F 0C       MOV ECX,DWORD PTR DS:[EDI+0C]
77FCB3A8  |.  8B47 08       MOV EAX,DWORD PTR DS:[EDI+8]
77FCB3AB  |.  3BC1          CMP EAX,ECX                              //看看前面的再前面的那个堆块是不是只和一块空表连着的
77FCB3AD  |.  8901          MOV DWORD PTR DS:[ECX],EAX
77FCB3AF  |.  8948 04       MOV DWORD PTR DS:[EAX+4],ECX             //把和Free合并的那个堆块从链表中取出来
77FCB3B2  |.  74 4D         JE SHORT 77FCB401
77FCB3B4  |>  8A47 05       MOV AL,BYTE PTR DS:[EDI+5]
77FCB3B7  |.  A8 04         TEST AL,04                               //检测标志位。（不是很懂
77FCB3B9  |.^ 0F85 21FDFFFF JNZ 77FCB0E0
77FCB3BF  |>  8A46 05       MOV AL,BYTE PTR DS:[ESI+5]
77FCB3C2  |.  24 10         AND AL,10
77FCB3C4  |.  A8 10         TEST AL,10
77FCB3C6  |.  8847 05       MOV BYTE PTR DS:[EDI+5],AL               //把合并进来的堆块调成空闲态
77FCB3C9  |.  0F85 CB170000 JNZ 77FCCB9A
77FCB3CF  |>  0FB70F        MOVZX ECX,WORD PTR DS:[EDI]
77FCB3D2  |.  8B45 10       MOV EAX,DWORD PTR SS:[EBP+10]
77FCB3D5  |.  8BF7          MOV ESI,EDI                              //再往上看一个堆块
77FCB3D7  |.  0108          ADD DWORD PTR DS:[EAX],ECX               //加起来
77FCB3D9  |.  0FB70F        MOVZX ECX,WORD PTR DS:[EDI]
77FCB3DC  |.  294B 28       SUB DWORD PTR DS:[EBX+28],ECX            //从总的里面减
77FCB3DF  |.  66:8B00       MOV AX,WORD PTR DS:[EAX]
77FCB3E2  |.  F647 05 10    TEST BYTE PTR DS:[EDI+5],10              //又判断是不是尾块
77FCB3E6  |.  66:8907       MOV WORD PTR DS:[EDI],AX                 //堆块头部的大小进行了替换 合并
77FCB3E9  |.  0F85 F7150000 JNZ 77FCC9E6
77FCB3EF  |.  8B45 10       MOV EAX,DWORD PTR SS:[EBP+10]
77FCB3F2  |.  8B08          MOV ECX,DWORD PTR DS:[EAX]
77FCB3F4  |.  66:8B00       MOV AX,WORD PTR DS:[EAX]
77FCB3F7  |.  66:8944CF 02  MOV WORD PTR DS:[ECX*8+EDI+2],AX         //把下一节中描述上一节大小的量进行变化
77FCB3FC  |.  E9 E5150000   JMP 77FCC9E6

6.然后又看下一节是不是占用态，不是占用态的话继续合并。

77FCC9E0  |.^\0F84 98E9FFFF JZ 77FCB37E
77FCC9E6  |>  F646 05 10    TEST BYTE PTR DS:[ESI+5],10
77FCC9EA  |.  75 0F         JNZ SHORT 77FCC9FB
77FCC9EC  |.  8B45 10       MOV EAX,DWORD PTR SS:[EBP+10]
77FCC9EF  |.  8B00          MOV EAX,DWORD PTR DS:[EAX]
77FCC9F1  |.  F644C6 05 01  TEST BYTE PTR DS:[EAX*8+ESI+5],01        //看下一节是不是占用态
77FCC9F6  |.  8D3CC6        LEA EDI,[EAX*8+ESI]
77FCC9F9  |.  74 09         JZ SHORT 77FCCA04

7.看下一节是不是尾块，不是的话继续合并、

77FCCA04  |> \0FB70F        MOVZX ECX,WORD PTR DS:[EDI]
77FCCA07  |.  03C8          ADD ECX,EAX
77FCCA09  |.  81F9 00FE0000 CMP ECX,0FE00
77FCCA0F  |.^ 77 EA         JA SHORT 77FCC9FB
77FCCA11  |.  807D 14 00    CMP BYTE PTR SS:[EBP+14],0
77FCCA15  |.  0F85 FB210000 JNE 77FCEC16
77FCCA1B  |>  8A47 05       MOV AL,BYTE PTR DS:[EDI+5]
77FCCA1E  |.  24 10         AND AL,10
77FCCA20  |.  A8 10         TEST AL,10                               //看是不是尾块
77FCCA22  |.  8846 05       MOV BYTE PTR DS:[ESI+5],AL
77FCCA25  |.  75 4B         JNZ SHORT 77FCCA72
77FCCA27  |>  57            PUSH EDI                                 //下一节的地址
77FCCA28  |.  53            PUSH EBX                                 //堆块的地址
77FCCA29  |.  E8 0CCBFBFF   CALL 77F8953A                            //\ntdll.77F8953A
77FCCA2E  |.  8B4F 0C       MOV ECX,DWORD PTR DS:[EDI+0C]
77FCCA31  |.  8B47 08       MOV EAX,DWORD PTR DS:[EDI+8]
77FCCA34  |.  3BC1          CMP EAX,ECX                              //看看是不是表里只有一个
77FCCA36  |.  8901          MOV DWORD PTR DS:[ECX],EAX
77FCCA38  |.  8948 04       MOV DWORD PTR DS:[EAX+4],ECX             //把表改成指向自己，清空    
77FCCA3B  |.^ 0F84 12E9FFFF JE 77FCB353

8.然后修改堆块头，改下一节对上一节大小的说明

77FCCA41  |> \8A47 05       MOV AL,BYTE PTR DS:[EDI+5]
77FCCA44  |.  A8 04         TEST AL,04
77FCCA46  |.^ 0F85 CBE6FFFF JNZ 77FCB117
77FCCA4C  |>  0FB70F        MOVZX ECX,WORD PTR DS:[EDI]
77FCCA4F  |.  8B45 10       MOV EAX,DWORD PTR SS:[EBP+10]
77FCCA52  |.  0108          ADD DWORD PTR DS:[EAX],ECX               //上面加的又加上下一节
77FCCA54  |.  0FB70F        MOVZX ECX,WORD PTR DS:[EDI]
77FCCA57  |.  294B 28       SUB DWORD PTR DS:[EBX+28],ECX            //从总的里面减
77FCCA5A  |.  66:8B08       MOV CX,WORD PTR DS:[EAX]
77FCCA5D  |.  F646 05 10    TEST BYTE PTR DS:[ESI+5],10              //确认不是尾块
77FCCA61  |.  66:890E       MOV WORD PTR DS:[ESI],CX                 //又一次修改堆块头的大小
77FCCA64  |.^ 75 95         JNZ SHORT 77FCC9FB
77FCCA66  |.  8B08          MOV ECX,DWORD PTR DS:[EAX]
77FCCA68  |.  66:8B00       MOV AX,WORD PTR DS:[EAX]
77FCCA6B  |.  66:8944CE 02  MOV WORD PTR DS:[ECX*8+ESI+2],AX         //修改下一节中对上一节的大小的描述
77FCCA70  |.^ EB 89         JMP SHORT 77FCC9FB

9.找一个空闲的空表放进去

77FCC8E6  |.  8066 05 10    AND BYTE PTR DS:[ESI+5],10               //确认堆块的Flag位
77FCC8EA  |.  0FB745 D0     MOVZX EAX,WORD PTR SS:[LOCAL.12]
77FCC8EE  |.  8D9CC7 780100 LEA EBX,[EAX*8+EDI+178]                  //找一个Freelist
77FCC8F5  |.  895D C4       MOV DWORD PTR SS:[LOCAL.15],EBX
77FCC8F8  |.  391B          CMP DWORD PTR DS:[EBX],EBX               //看这个表是不是空闲的空表
77FCC8FA  |.^ 0F84 CBF5FFFF JE 77FCBECB

77FCC90C  |.  8918          MOV DWORD PTR DS:[EAX],EBX
77FCC90E  |.  894E 0C       MOV DWORD PTR DS:[ESI+0C],ECX
77FCC911  |.  8901          MOV DWORD PTR DS:[ECX],EAX
77FCC913  |.  8943 04       MOV DWORD PTR DS:[EBX+4],EAX             //按照顺序改堆块里面的地址
77FCC916  |.  8B45 D0       MOV EAX,DWORD PTR SS:[EBP-30]            //堆溢出就在这一个点，就把那个指针替换掉
77FCC919  |.  0147 28       ADD DWORD PTR DS:[EDI+28],EAX            //改空表里面的地址
详细介绍HeapFree()
felicity_one的博客
04-02 1033
书籍：《Visual C++ 2017从入门到精通》的2.9 内存管理环境：visual studio 2022内容：[例 2.51] 分配内存堆并释放HeapFree()是 Windows API 中用于释放由或分配的内存块的核心函数。
HEAP: Free Heap block 39rt98 modified at 39rtc0 after it was freed
Acheld的博客
01-16 2221
 HEAP: Free Heap block 39rt98 modified at 39rtc0 after it was freed 一. 介绍这个问题之前，先来简要对一些概念进行梳理。 Heap,堆，一种由程序员根据实际需求人为分配、释放的数据存储单元。 通常情况下，通过调用malloc函数，或者 new特殊字符来创建出来。 相对应的是通过调用free函数，或者del
HeapFree
hyczwl的专栏
10-04 2758
HeapFree 释放由HeapAlloc 或 HeapReAlloc 函数从堆分配的内存块。 BOOL HeapFree(   HANDLE hHeap,   DWORD dwFlags,   LPVOID lpMem ); Parameters hHeap [in] 将要被释放的内存块的堆的句柄。该句柄由HeapCreate 或 GetProcessHea
详细介绍HeapFree() 函数
felicity_one的博客
05-23 723
书籍：《Visual C++ 2017从入门到精通》的2.3.8 Win32控件编程环境：visual studio 2022 是 Windows API 中 ​​堆内存管理​​ 的核心函数，用于释放由 或 分配的内存块。其设计目标是为开发者提供安全、可控的内存释放机制，避免内存泄漏和堆损坏。以下是其功能、参数、使用场景及注意事项的全面解析： ​​头文件​​：（通常通过 间接包含）。 ​​链接库​​：需链接 。 ​​2. 参数解析​​ ​​参数​​ ​​类型​
堆溢出 对HeapAlloc函数的详细调试
Misaka10046的博客
09-23 951
代码 #include <windows.h> int main() { HLOCAL h1,h2,h3,h4,h5,h6; HANDLE hp; hp = HeapCreate(0,0x1000,0x10000); _asm int 3 h1 = HeapAlloc(hp,HEAP_ZERO_MEMORY,3); h2 = HeapAlloc(hp,HEAP_ZERO_MEMORY,5); h3 = HeapAlloc(hp,HEAP_ZERO_MEMORY,6); h4
漏洞学习笔记——堆溢出原理
谈成(C/C++)
04-14 4102
最近在学习堆的溢出原理，但是查了网上和书上的一些讲解，总是感觉缺少一些关键点。所以理解起来总是有点晕，经过努力的调试分析后，总结了下面的更为详细的堆溢出原理。如果不准确的地方，希望大佬可以提醒一哈~ 1.堆的结构： struct _LIST_ENTRY{ DWORD Flink; DWORD Blink; } //空闲堆头结构 struct _HEAP_FREE_ENTRY{ union{ struct{ union{ struct { WORD Size;
《0day安全》中的堆溢出利用调试
Lethe's Blog
06-26 1155
0x01 堆的工作原理 实验环境: 推荐使用环境 备注 操作系统 Windows20000虚拟机 分配策略对操作系统非常敏感 编译器 Visual C++ 6.0 默认编译选项 编译选项 默认编译选项 VS2003/VS2005的GS选项将导致实验失败 build 版本 release VS2003/VS2005的GS选项将导致实验失败 调试器 Ollydbg 需要配置Make OllyDbg just-in-time debugger选项 调试代码如下： #inclu
Windows下堆溢出三种利用方式深度解析与实战
最新发布
weixin_29009401的博客
10-04 1171
Start[开始运行程序] --> Alloc[堆上分配TestClass对象]Alloc --> Read[读取payload.bin]Read --> Copy[strcpy触发溢出]Copy --> Overwrite[覆盖vptr为0x00405000]Overwrite --> Call[t->trigger()调用]Call --> Jump[CPU跳转至0x00405000]Jump --> Exec[执行shellcode]
windows 堆：入门学习
qq_39267690的博客
01-09 1347
堆是Windows操作系统在运行时对系统资源的管理方式，是一种动态内存分配系统，可以在程序运行时动态地分配和释放内存。Windows提供了各种堆操作函数，如HeapCreate、HeapDestroy、HeapAlloc、HeapReAlloc、HeapFree等。然而，在一般的程序开发过程中，我们往往不会直接使用这些底层的堆操作函数，因为这些函数的使用往往需要对Windows内存管理的深入理解和小心翼翼的错误处理。
[笔记]Windows核心编程《十八》堆栈
二次元怪兽的博客
02-22 1345
文章目录前言一、进程的默认堆栈二、为什么要创建辅助堆栈2.1 保护组件2.2 更有效的内存管理2.3 进行本地访问2.4 减少线程同步的开销2.5 迅速释放堆栈三、如何创建辅助堆栈3.1 从堆栈中分配内存块3.2 改变内存块的大小3.3 了解内存块的大小3.4 释放内存块3.5 撤消堆栈3.6 用C + +程序来使用堆栈四、其他堆栈函数总结 前言 windows 对内存进行操作的机制： 虚拟内存 文件映射 堆栈 使用堆栈场景： 堆栈可以用来分配许多较小的数据块。 例如，若要对链接表和链接树进行管理，最
2014-03-16周日：内存释放函数HeapFree（）
勿忘初心,安得始终
03-16 919
1、输入： BOOL WINAPI HeapFree(   _In_  HANDLE hHeap,   _In_  DWORD dwFlags,   _In_  LPVOID lpMem ); hHeap要释放内存的句柄，dwFlags堆的选择，一般是0，lpMem是指向将要释放内存的空间的指针。 2、返回值： 　如果函数成功,返回值是非零。 　如果函数失败,返回值是零。应用
GlobalFree HeapFree LocalFree与C函数free的区别与联系
weixin_30824479的博客
05-24 261
GlobalFree HeapFree LocalFree与C函数free的区别与联系 GlobalFree是释放空间并且使得句柄无效 对应的申请函数是GlobalAlloc和GlobalRelloc HeapFree是释放HeapAlloc和HeapRelloc申请的空间 LocalFree是释放LocalAlloc和Localrelloc申请的空间 free对应的是malloc 和...
windbg调试HEAP
flyingleo1981的专栏
09-26 4799
HEAP的概念 堆栈堆栈，在操作系统内存中有两种存储空间，一个是堆，一个是栈。堆主要用于存储用户动态分配的变量，而栈呢，则是存储我们程序过程中的临时变量。当然栈的作用远不止用作存储变量，但这不是我们这篇文章的讨论内容。 堆（HEAP）的分配，使用，回收都是通过微软的API来管理的，最常见的API是malloc和new。在往底层走一点呢，这两个函数都会调用HeapAlloc（RtlAllocat
win32api函数中heapalloc和heapfree使用导致内存没正常释放
fuck487的博客
04-12 4993
1、因为本人使用heapalloc分配内存的对象是结构体 //HTTP消息数据结构体 typedef struct _HttpMsgData { string httpMethod;//请求方法（GET/POST） string url;//url string postContent;//消息体 string contentLength;//post时，消息体长度 }HttpMsgDa
动态内存分配
予衡飞翔
12-22 744
动态内存分配指的是在堆上进行分配内存，根据申请分配的层次可以分成两大类： 1、底层：堆内存管理函数HeapCreate、HeapAlloc、HeapFree、HeapDestroy函数   HeapCreate函数功能：创建自定义堆，这不同与默认堆由进程创建时系统自动创建。 HeapAlloc函数功能：从自定义堆中分配内存。HeapFree函数功能：释放内存。但并不能保证所有的物理内
Windows API一日一练(78)HeapAlloc函数
anjichan4261的博客
11-26 606
前面已经介绍两个分配内存的函数，一个全局的内存分配，一个是私有的内存分配。在进程私有的内存里分配里，又有两种分配情况，一种上基于栈式的内存分配，另一种是基于堆内存的分配。在c++里使用堆内存分配是使用HeapAlloc函数来实现的，也就是实现new操作符分配内存时会调这个函数。 函数HeapAlloc声明如下： WINBASEAPI __bcount(dwBytes) LP...
c语言各种内存申请与内存的操作
frhdd的博客
11-21 2663
在 C 语言中，内存的分配主要包括和两种方式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值