忘了操作pȝ会根据处理器型号加蝲不同版本内核?...
正好看到高端调试上有关于q个的讨? http://advdbg.org/forums/2142/ShowPost.aspx
但是我的分析是基于ntoskrnl的，没办法，只好强制指定pȝ加蝲ntosknrl?得做以下几个工作
1 把vm的processor调成单核单处理器
2 开windows虚拟? Z告诉pȝ现在是单核单处理器模?得跑一下这个命?nbsp;rundll32.exe setupapi,InstallHinfSection ACPIAPIC_UP_HAL 131 %windir%\inf\hal.inf
参? 如何修改Windows XPpȝ的内核类?nbsp; http://blog.sina.com.cn/s/blog_5918846401000bik.html
3 当然,q里q没l束,如果处理器支持PAE 那么pȝ会加载ntoskrnla 所以还得禁用PAE. ?span style="font-family: arial, 宋体, sans-serif; font-size: 14px; line-height: 24px; text-indent: 30px; background-color: #ffffff;">BOOT.INI里面, 启动讄中如果有/noexecute=optin替换改?execute,没有的话加?/span>/execute
完了后就会加载ntoskrnl?效果?
指定其它pȝҎcM,在此仅抛砖引?nbsp;
]]>
HEAP的概?/h1>
堆栈堆栈Q在操作pȝ内存中有两种存储I间Q一个是堆，一个是栈。堆主要用于存储用户动态分配的变量Q而栈呢，则是存储我们E序q程中的临时变量。当然栈的作用远不止用作存储变量Q但q不是我们这文章的讨论内容?/p>
堆（HEAPQ的分配Q用，回收都是通过微Y的API来管理的Q最常见的API是malloc和new。在往底层C点呢Q这两个函数都会调用HeapAllocQRtlAllocateHeapQ。同L相关函数q有HeapFree用来释放堆，HeapCreate用来创徏自己的私有堆。下面是q些函数的调用链Q?/p>
HeapCreate->RtlCreateHeap->ZwAllocateVirtualMemory (q里会直接申请一大片内存,至于甌多大内存,pEPEBl构中的字段觉得QHeapSegmentReserve字段指出要申请多大的虚拟内存QHeapSegmentCommit指明要提交多大内存，对虚拟内存的甌和提交概念不清楚的童鞋，请参见windows核心~程相关内容~)
HeapAlloc->RtlAllocateHeapQ至于这里申L内存Q由于HeapCreate已经甌了一大片内存Q堆理器这片内存中划分一块出来以满甌的需要。这一步申h作是堆管理器自己l护的，仅当甌内存不够的时候才会再ơ调用ZwAllocateVirtualMemory Q?/p>
HeapFree->RtlFreeHeap Q对于释攄内存Q堆理器只是简单的把这块内存标志位已释放让后加入到I闲列表中，仅当I闲的内存达C定阀值的时候会调用ZwFreeVirtualMeMory Q?/p>
HeapDestroy->RtlDestroyHeap->ZwFreeVirtualMeMory Q销毁我们申L堆）
如何扑ֈ我们的HEAP信息Q?/h1>
WINDBG观察?/p>
源码Q?/p>
#include "windows.h"
int main()
{
HANDLE heap_handle = HeapCreate( NULL , 0x1000 , 0x2000 ) ;
char *buffer = (char*)HeapAlloc(heap_handle , NULL , 128) ;
char *buffer1 = (char*)HeapAlloc(heap_handle , NULL , 121) ;
HeapFree(heap_handle, 0 , buffer ) ;
HeapFree(heap_handle, 0 , buffer1 ) ;
HeapDestroy( heap_handle) ;
return 0 ;
}
该源码生成编译生成heap.exeQ然后用windbg调试q个E序Q在main函数下断Q紧接着执行W五行语句，执行l果如下
0:000> p
eax=002e1ca0 ebx=00000000 ecx=6d29b6f0 edx=00000000 esi=00000001 edi=01033374
eip=01031012 esp=0022fe8c ebp=0022feac iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
heap!main+0x12:
01031012 ff150c200301 call dword ptr [heap!_imp__HeapCreate (0103200c)] ds:0023:0103200c={kernel32!HeapCreateStub (769a29d7)}
0:000> p
eax=002c0000 ebx=00000000 ecx=77429897 edx=77498500 esi=00000001 edi=01033374
eip=01031018 esp=0022fe98 ebp=0022feac iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
heap!main+0x18:
01031018 8945fc mov dword ptr [ebp-4],eax ss:0023:0022fea8=6d222201
0:000> !heap
Index Address Name Debugging options enabled
1: 00300000
2: 00010000
3: 00020000
4: 002e0000
5: 002c0000
HeapCreate执行的返回值存攑֜eax处，q个函数q回了一个堆句柄Q?x002c0000。用!heap命o查看可以看到W五个堆是我们创徏的堆句柄了?/p>
每个q程都存在多个堆Q我们也可以通过PEBl构来得到进E中存在的堆Q结果和!heap命o昄的内Ҏ一L?/p>
heap!_PEB
+0x018 ProcessHeap : 0x00300000 Void ; q程的默认堆
+0x068 NtGlobalFlag : 0 ; q个标志位记录了当前堆调试模?0为普通调试模?br /> +0x078 HeapSegmentReserve : 0x100000 ; q程在新建堆的时候默认申L虚拟内存大小
+0x07c HeapSegmentCommit : 0x2000 ; q程在每ơ申h交的虚拟内存大小Q在提交的内存用完后Q进E会又在一ơ提交HeapSegmentCommit中指定的内存大小
+0x080 HeapDeCommitTotalFreeThreshold : 0x10000 ; 当释攄内存大小大于q个阀|p行内存解除提交操?br /> +0x084 HeapDeCommitFreeBlockThreshold : 0x1000 ; 当一ơ性释攄块大超q这个阀|p行内存解除提交操作，只有当满两个条g时才会调用ZwFreeVirtualMeMory 释放物理内存
+0x088 NumberOfHeaps : 5 ; 当前q程的堆数目,q个数目对应着!heap命o的堆昄个数
+0x08c MaximumNumberOfHeaps : 0x10 ; q程所能运行的最大堆数目,若堆数目过q个g计HeapCreate失败了?br /> +0x090 ProcessHeaps : 0x77498500 -> 0x00300000 Void ;存储堆句柄的数组,q里我们可以得到q程的所有堆句柄
我们可以输入如下命o来查看现有的堆句?/p>
0:000> dd 0x77498500
77498500 00300000 00010000 00020000 002e0000
77498510 002c0000 00000000 00000000 00000000
77498520 00000000 00000000 00000000 00000000
77498530 00000000 00000000 00000000 00000000
77498540 00000000 77498340 7749bb08 77498220
77498550 00000000 00000000 00000000 00000000
77498560 77498220 00317bd0 00000000 00000000
77498570 00000000 00000000 00000000 00000000
可以看得到这里面的内容和!heap命o的输出结果是一L
而堆句柄的存放范?从MaximumNumberOfHeaps 上来?是77498500-77498540q?x40个字节，因ؓ每个堆句柄占4个字节，0x10个堆句柄的存攄间就?x40?/p>
HEAP的组l结?/h1>
堆的理Q我们可以理解ؓ一个内存池Q它甌一大块I间Q然后负责接应用程序的甌释放{请求。只有在创徏堆，释放堆（注意Q是释放堆，不是堆中的空_Q在q之前，我们需要对堆有关的数据l构做一些解?/p>
我这里观察到的HEAPl构QHEAP_SEGMENTl构和HEAP_ENTRYl构都和软g调试里面描述的不一P当年奎哥写Y件调试的时候估计还没用上WIN7吧。。。我的演C系l是WIN7
HeapCreate函数q回的堆句柄其实是一个指向堆理l构的指针，每个堆都会涉及到q样三个l构QHEAP,HEAP_SEGMENT,HEAP_ENTRY
HEAP_ENTRYl构Q?/p>
在堆理中，每一块申请下来的内存都会有下面所C的固定模式Q?/p>
|
HEAP_ENTRYQ? bytesQ?/p> |
|
我们new或malloc分配的空?/p> |
|
固定填充I间 |
q个l构用来记录所分配的空间的信息Q包括用LLI间Q填充的I间Q所在的D号{等信息。所以我们new或者malloc的地址减去8指向该l构。第三部分的固定填充I间是ؓ了内存对齐而生成的Q当然这部分I间q有一部分是用来额外记录这块内存的其它信息Q这里就不详l做介绍了?/p>
HEAP_SEGMENTl构Q?/p>
我们可以q么认ؓQ堆甌内存的大是以段为单位的Q当新徏一个堆的时候，pȝ会默认ؓq个堆分配一个段?hQ通过刚开始的new和malloc分配的空间都是在q个D上分配的，当这个段用完的时候，如果当初创徏堆的时候指明了HEAP_GROWABLEq个标志Q那么系l会个堆在再分配一个段Q这个时候新分配的段q?h了，以下以此cL。每个段的开始初便是HEAP_SEGMENTl构的首地址Q由于这个结构也是申L一块内存，所以它前面也会有个HEAP_ENTRYl构Q?/p>
|
HEAP_ENTRYQ? bytesQ?/p> |
|
HEAP_SEGMENT |
|
HEAP_ENTRYQ? bytesQ?/p> |
|
我们new或malloc分配的空?/p> |
|
固定填充I间 |
HEAP_SEGMENTl构会记录段的一些基本信息，该段甌的大，已经提交内存的大，W一个HEAP_ENTRYl构的入口点。（我观察看貌似D는L内存q不会一ơ性全部提交，而是每次提交一个页的大，比如一个段大小2个页Q那么它会先提交一个页内存Q若用完了再提交一个页的内存，若内存还用完了那新Z个段Q这个新建的D也会是先提交一个页内存。）但是0h很特别，q个D늚起始地址是堆句柄指针指向的|也就是说Q?/font>HeapCreateq回的堆句柄L指向0hQؓ什么呢Q因为HEAPl构是HEAP_ENTRY,HEAP_SEGMENT的合体加长版~
HEAPl构Q?/p>
HEAPl构则是记录了这个堆的信息，q个l构可以扑ֈHEAP_SEGMENT链表入口Q空闲内存链表的入口Q内存分配粒度等{信息。HEAP的首地址便是堆句柄的|但是堆句柄的值又?h的首地址也是堆句柄，何解Q其实很单，0h的HEAP_SEGMENT在HEAPl构里面QHEAPl构cd义如q样Q?/p>
struct _HEAP
{
_HEAP_ENTRY Entry ; //HEAP_ENTRYl构Q用来描q存储HEAP内存块大等信息?
_HEAP_SEGMENT Segment ; //0h的首地址
…? //对于该HEAP的描qC?
} ;
在我们看来，内存l织l构应该如下所C：
|
HEAP_ENTRYQ? bytesQ?/p> |
|
HEAP_SEGMENT |
|
HEAP |
更确切的_HEAPl构中本w就包含了HEAP_ENTRY和HEAP_SEGMENTQHEAP_ENTRYl构是HEAP的第一个数据成员，HEAP_SEGMENT是它W二个数据成员。而对于HEAP_SEGMENT,它的W一个数据成员便是HEAP_ENTRY。这里ؓ了方便理解，才在内存l织l构中把它们拆开展示。（注：q里是win7的情况，和Y件调试这本书中所描述的有一些差异，也属正常现象Q毕竟这部分l构微Yq未公开Q?/p>
用WINDBG观察HEAPl构
在之前已l演CZ如何从PEBl构中找到所有的堆句柄，可以看到002c0000便是我们创徏的句柄。然后我们执CZE序的第7行代码。执行完后结果如下：
0:000> p
eax=002c0000 ebx=00000000 ecx=77429897 edx=77498500 esi=00000001 edi=01033374
eip=01031026 esp=0022fe8c ebp=0022feac iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
heap!main+0x26:
01031026 ff1500200301 call dword ptr [heap!_imp__HeapAlloc (01032000)] ds:0023:01032000={ntdll!RtlAllocateHeap (774120b5)}
0:000> p
eax=002c0590 ebx=00000000 ecx=774134b4 edx=002c0180 esi=00000001 edi=01033374
eip=0103102c esp=0022fe98 ebp=0022feac iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
heap!main+0x2c:
0103102c 8945f0 mov dword ptr [ebp-10h],eax ss:0023:0022fe9c={heap!envp (0103301c)}
可以看到EAX保存的返回gؓ002c0590。我们通过两种途径来观察我们申L内存Q通过!heap命o观察和通过dt命o观察
通过!heap命o观察
输入命o!heap –a 2c0590得到的结果如下：
0:000> !heap -a 2c0000
Index Address Name Debugging options enabled
5: 002c0000
Segment at 002c0000 to 002c2000 (00001000 bytes committed)
Flags: 00001000
ForceFlags: 00000000
Granularity: 8 bytes
Segment Reserve: 00100000
Segment Commit: 00002000
DeCommit Block Thres: 00000200
DeCommit Total Thres: 00002000
Total Free Size: 0000013a
Max. Allocation Size: 7ffdefff
Lock Variable at: 002c0138
Next TagIndex: 0000
Maximum TagIndex: 0000
Tag Entries: 00000000
PsuedoTag Entries: 00000000
Virtual Alloc List: 002c00a0
Uncommitted ranges: 002c0090
002c1000: 00001000 (4096 bytes)
FreeList[ 00 ] at 002c00c4: 002c0618 . 002c0618
002c0610: 00088 . 009d0 [100] - free
Segment00 at 002c0000:
Flags: 00000000
Base: 002c0000
First Entry: 002c0588
Last Entry: 002c2000
Total Pages: 00000002
Total UnCommit: 00000001
Largest UnCommit:00000000
UnCommitted Ranges: (1)
Heap entries for Segment00 in Heap 002c0000
002c0000: 00000 . 00588 [101] - busy (587)
002c0588: 00588 . 00088 [101] - busy (80)
002c0610: 00088 . 009d0 [100]
002c0fe0: 009d0 . 00020 [111] - busy (1d)
002c1000: 00001000 - uncommitted bytes.
q个命o分别提炼ZHEAPQ绿色区域）,HEAP_SEGMENTQ红色区域）和HEAP_ENTRYQ灰色区域）l构中的信息。虽然在灰色区域中，我们找不?c0590Q但是找C一?c0588Q这个正?c0590-8的结果，也就是说最双的地址是每个HEAP_ENTRY的首地址Q接着00588q个字段表示了前面一个HEAP_ENTRY所占用的大，后面?088表示q个内存块的d，x们申L内存+HEAP_ENTRYQ?28+8=0x80+0x8=0x88Q，[101]是这块内存的标志位，最双一位ؓ1表示该内存块被占用。然后busyQ?0Q就是解释说q块内存是被占用的（非空闲的Q，它申L内存?x80Q{化成十进制正好就是我们申L128字节大小?/p>
但是q里用dt _HEAP_ENTRY 2c0588命o却没办法查看对应的结构信息，真是怪哉Q有博文也提到win2008中HEAP相关l构也有变，看来到NT6后，HEAPl构变得不小Qv码windbg中直接dt HEAP_ENTRY是无法原始数据的了，貌似对HEAP_ENTRY做了~码?/font>
通过dt命o观察
同样的，已知HEAP的首地址Q那么先从HEAP下手好了Qdt _HEAP 002c0000可以昄HEAP的数据结?/p>
ntdll!_HEAP
+0x000 Entry : _HEAP_ENTRY
+0x008 SegmentSignature : 0xffeeffee
+0x00c SegmentFlags : 0
+0x010 SegmentListEntry : _LIST_ENTRY [ 0x2c00a8 - 0x2c00a8 ]
+0x018 Heap : 0x002c0000 _HEAP
+0x01c BaseAddress : 0x002c0000 Void
+0x020 NumberOfPages : 2
+0x024 FirstEntry : 0x002c0588 _HEAP_ENTRY
+0x028 LastValidEntry : 0x002c2000 _HEAP_ENTRY
+0x02c NumberOfUnCommittedPages : 1
+0x030 NumberOfUnCommittedRanges : 1
+0x034 SegmentAllocatorBackTraceIndex : 0
+0x036 Reserved : 0
+0x038 UCRSegmentList : _LIST_ENTRY [ 0x2c0ff0 - 0x2c0ff0 ]
+0x040 Flags : 0x1000
+0x044 ForceFlags : 0
+0x048 CompatibilityFlags : 0
+0x04c EncodeFlagMask : 0x100000
+0x050 Encoding : _HEAP_ENTRY
+0x058 PointerKey : 0x17c06e63
+0x05c Interceptor : 0
+0x060 VirtualMemoryThreshold : 0xfe00
+0x064 Signature : 0xeeffeeff
+0x068 SegmentReserve : 0x100000
+0x06c SegmentCommit : 0x2000
+0x070 DeCommitFreeBlockThreshold : 0x200
+0x074 DeCommitTotalFreeThreshold : 0x2000
+0x078 TotalFreeSize : 0x13a
+0x07c MaximumAllocationSize : 0x7ffdefff
+0x080 ProcessHeapsListIndex : 5
+0x082 HeaderValidateLength : 0x138
+0x084 HeaderValidateCopy : (null)
+0x088 NextAvailableTagIndex : 0
+0x08a MaximumTagIndex : 0
+0x08c TagEntries : (null)
+0x090 UCRList : _LIST_ENTRY [ 0x2c0fe8 - 0x2c0fe8 ]
+0x098 AlignRound : 0xf
+0x09c AlignMask : 0xfffffff8
+0x0a0 VirtualAllocdBlocks : _LIST_ENTRY [ 0x2c00a0 - 0x2c00a0 ]
+0x0a8 SegmentList : _LIST_ENTRY [ 0x2c0010 - 0x2c0010 ]
+0x0b0 AllocatorBackTraceIndex : 0
+0x0b4 NonDedicatedListLength : 0
+0x0b8 BlocksIndex : 0x002c0150 Void
+0x0bc UCRIndex : (null)
+0x0c0 PseudoTagEntries : (null)
+0x0c4 FreeLists : _LIST_ENTRY [ 0x2c0618 - 0x2c0618 ]
+0x0cc LockVariable : 0x002c0138 _HEAP_LOCK
+0x0d0 CommitRoutine : 0x17c06e63 long +17c06e63
+0x0d4 FrontEndHeap : (null)
+0x0d8 FrontHeapLockCount : 0
+0x0da FrontEndHeapType : 0 ''
+0x0dc Counters : _HEAP_COUNTERS
+0x130 TuningParameters : _HEAP_TUNING_PARAMETERS
如本文前面所q的Q第一个字D|HEAP_ENTRYl构Q接着应该是HEAP_SEGMENTQ这里只不过把HEAP_SEGMENTl构的字D展开了，可以dt _HEAP_SEGMENT来观察下q个l构的字D?/p>
0:000> dt _heap_segment
ntdll!_HEAP_SEGMENT
+0x000 Entry : _HEAP_ENTRY
+0x008 SegmentSignature : Uint4B
+0x00c SegmentFlags : Uint4B
+0x010 SegmentListEntry : _LIST_ENTRY
+0x018 Heap : Ptr32 _HEAP
+0x01c BaseAddress : Ptr32 Void
+0x020 NumberOfPages : Uint4B
+0x024 FirstEntry : Ptr32 _HEAP_ENTRY
+0x028 LastValidEntry : Ptr32 _HEAP_ENTRY
+0x02c NumberOfUnCommittedPages : Uint4B
+0x030 NumberOfUnCommittedRanges : Uint4B
+0x034 SegmentAllocatorBackTraceIndex : Uint2B
+0x036 Reserved : Uint2B
+0x038 UCRSegmentList : _LIST_ENTRY
可以看到HEAPl构中灰色部分是和HEAP_SEGMENTl构中的字段是重复的Q也是说灰色部分字D便是HEAP_SEGMENTl构。在HEAP_SEGMENTl构中，我们可以扑ֈFirstEntry字段Q这里指的便是我们的分配的内存，不过HEAP_ENTRYl构无法观察Q这里便没办法枚丑և所有的HEAP_ENTRYl构了，但是说一下思\Q?/p>
每个HEAP_ENTRY和它对应的内存我们可以称Z个内存块Q计下一个内存块需要用到现有内存块中的2个字D，Size和UnsedBytesQSize的g上粒度（是0:000> !heap -a 2c0000命o昄的信息中的Granularity: 8 bytes字段Q这里是8字节Q，下一个内存块地址是 本内存块地址+Size*8+UnsedBytes。当然这里的_度可以通过HEAP字段中的AlignMask 字段出来?/p>
HEAP的分配粒?/h1>
在HEAPl构中指明了分配_度Q这个分配粒度是说每ơ堆分配的时候，都以q个_度为最单位，q里看到_度?字节。所以这里就有了W二ơ分配内存的实验Q我们让E序执行W?行，然后?heap -a 002c0000观察分配情况
Heap entries for Segment00 in Heap 002c0000
002c0000: 00000 . 00588 [101] - busy (587)
002c0588: 00588 . 00088 [101] - busy (80)
002c0610: 00088 . 00088 [101] - busy (79)
002c0698: 00088 . 00948 [100]
002c0fe0: 00948 . 00020 [111] - busy (1d)
002c1000: 00001000 - uncommitted bytes.
q里可以看出多出了一个占用块Q大是0x79Q?21Q?bytesQ但是实际分配的大小q是0x 88 Q?28QbytesQ这是因为系l是? bytes为粒度分配的Q所以ؓq块121 bytes的内存自动填充了7个字节，可见甌121 bytes和申?28 bytes所使用的空间是一L?/font>
HEAP的释攑֒销?/h1>
执行?1行和12行的代码后，堆中的内容分别如下：
执行11行代码的堆情?/strong>
FreeList[ 00 ] at 002c00c4: 002c06a0 . 002c0590
002c0588: 00588 . 00088 [100] ?free Q空闲列表中多出了一块内?/font>
002c0698: 00088 . 00948 [100] ?free Q空闲内存，I闲I间?48
002c0000: 00000 . 00588 [101] - busy (587)
002c0588: 00588 . 00088 [100] Q原先的q块内存释放掉了
002c0610: 00088 . 00088 [101] - busy (79)
002c0698: 00088 . 00948 [100] ; I闲内存
002c0fe0: 00948 . 00020 [111] - busy (1d)
002c1000: 00001000 - uncommitted bytes.
执行12行代码的堆情?/strong>
FreeList[ 00 ] at 005c00c4: 005c0590 . 005c0590
005c0588: 00588 . 00a58 [100] ?free Q回收了buffer1的内存后Q由于由于空闲内存是q箋的，所以直接合q成一块内存。可以看C前内存freeI间?48Q现在合q了以后便是948+88+88=a58,也就是当前内存大?/font>
Heap entries for Segment00 in Heap 005c0000
005c0000: 00000 . 00588 [101] - busy (587)
005c0588: 00588 . 00a58 [100]
005c0fe0: 00a58 . 00020 [111] - busy (1d)
005c1000: 00001000 - uncommitted bytes.
最后执?4行代?对堆q行释放,释放后我们通过!heap也可以看到只?个堆?我们甌的堆被释放了.
0:000> !heapIndex Address Name Debugging options enabled
1: 00300000
2: 00010000
3: 00020000
4: 002e0000
至于HEAP_ENTRYl构的问?有时间在调试看看是怎么回事吧~另外Q这里说明下Qnew和malloc内部都会调用HeapAlloc来申请内存，但是堆句柄从哪来呢？它会_crtheap变量是否为空Q若不ؓI则拿_crtheap变量来作q堆句柄去调用HeapAlloc
参考：
软g调试 张奎?/p>
MSDN
]]>