重载内核

forwe

DriverEntry.c

1. #include "ntddk.h"
   
2. #include "ntimage.h"
   
3. #include <WINDEF.H>
   
4. 
   
5. #define PAGEDCODE code_seg("PAGE")
   
6. #define LOCKEDCODE code_seg()
   
7. #define INITCODE code_seg("INIT")
   
8. 
   
9. #define PAGEDDATA data_seg("PAGE")
   
10. #define LOCKEDDATA data_seg()
    
11. #define INITDATA data_seg("INIT")
    
12. 
    
13. 
    
14. typedef struct _LDR_DATA_TABLE_ENTRY {
    
15.         LIST_ENTRY InLoadOrderLinks;
    
16.         LIST_ENTRY InMemoryOrderLinks;
    
17.         LIST_ENTRY InInitializationOrderLinks;
    
18.         PVOID DllBase;
    
19.         PVOID EntryPoint;
    
20.         ULONG SizeOfImage;
    
21.         UNICODE_STRING FullDllName;
    
22.         UNICODE_STRING BaseDllName;
    
23.         ULONG Flags;
    
24.         USHORT LoadCount;
    
25.         USHORT TlsIndex;
    
26.         union {
    
27.                 LIST_ENTRY HashLinks;
    
28.                 struct {
    
29.                         PVOID SectionPointer;
    
30.                         ULONG CheckSum;
    
31.                 };
    
32.         };
    
33.         union {
    
34.                 struct {
    
35.                         ULONG TimeDateStamp;
    
36.                 };
    
37.                 struct {
    
38.                         PVOID LoadedImports;
    
39.                 };
    
40.         };
    
41. } LDR_DATA_TABLE_ENTRY, *PLDR_DATA_TABLE_ENTRY;
    
42. 
    
43. 
    
44. #pragma pack(1)
    
45. typedef struct ServiceDescriptorEntry {
    
46.         unsigned int *ServiceTableBase;
    
47.         unsigned int *ServiceCounterTableBase; //仅适用于checked build版本
    
48.         unsigned int NumberOfServices;
    
49.         unsigned char *ParamTableBase;
    
50. } ServiceDescriptorTableEntry_t, *PServiceDescriptorTableEntry_t;
    
51. #pragma pack()
    
52. 
    
53. __declspec (dllimport) ServiceDescriptorTableEntry_t KeServiceDescriptorTable;
    
54. 
    
55. typedef NTSTATUS  (*pNtCreateFile)(
    
56.     OUT PHANDLE  FileHandle,
    
57.     IN ACCESS_MASK  DesiredAccess,
    
58.     IN POBJECT_ATTRIBUTES  ObjectAttributes,
    
59.     OUT PIO_STATUS_BLOCK  IoStatusBlock,
    
60.     IN PLARGE_INTEGER  AllocationSize,
    
61.     IN ULONG  FileAttributes,
    
62.     IN ULONG  ShareAccess,
    
63.     IN ULONG  CreateDisposition,
    
64.     IN ULONG  CreateOptions,
    
65.     IN PVOID  EaBuffer,
    
66.     IN ULONG  EaLength
    
67.     );
    
68. 
    
69. 
    
70. 
    
71. 
    
72. //global
    
73. PVOID g_lpVitrualPointer;
    
74. ULONG g_ntCreateFile;
    
75. ULONG g_kifastcall_hookpoint;
    
76. ULONG g_goto_OrigFunc;
    
77. ULONG g_NewKernelInc;
    
78. PServiceDescriptorTableEntry_t g_pNewServiceTable;
    
79. 
    
80. 
    
81. void PageProtectOn()
    
82. {
    
83.         //恢复内存保护
    
84.         __asm
    
85.         {
    
86.                 mov eax, cr0
    
87.                         or eax, 10000h
    
88.                         mov cr0, eax
    
89.                         sti
    
90.         }
    
91. }
    
92. 
    
93. void PageProtectOff()
    
94. {
    
95.         //去掉内存保护
    
96.         __asm
    
97.         {
    
98.                 cli
    
99.                         mov eax, cr0
    
100.                         and eax, not 10000h
     
101.                         mov cr0, eax
     
102.         }
     
103. }
     
104. 
     
105. #pragma PAGEDCODE
     
106. void SetNewSSDT(PVOID pNewImage, PVOID pOrigImage, PServiceDescriptorTableEntry_t *pNewServiceTable)
     
107. {
     
108.         ULONG uIndex, uOffset;
     
109.         ULONG uNewKernelInc;
     
110.         PServiceDescriptorTableEntry_t pNewSSDT;
     
111. 
     
112.         uNewKernelInc = (ULONG) pNewImage - (ULONG) pOrigImage;
     
113.         pNewSSDT = (PServiceDescriptorTableEntry_t) ((ULONG)&KeServiceDescriptorTable + uNewKernelInc);
     
114. 
     
115.         if (!MmIsAddressValid(pNewSSDT))
     
116.         {
     
117.                 return;
     
118.         }
     
119. 
     
120.         pNewSSDT->NumberOfServices = KeServiceDescriptorTable.NumberOfServices;
     
121.         uOffset = (ULONG)KeServiceDescriptorTable.ServiceTableBase - (ULONG)pOrigImage;
     
122.         pNewSSDT->ServiceTableBase = (unsigned int *)((ULONG)pNewImage + uOffset);
     
123.         if (!MmIsAddressValid(pNewSSDT->ServiceTableBase))
     
124.         {
     
125.                 return;
     
126.         }
     
127.        
     
128.         for (uIndex = 0; uIndex < pNewSSDT->NumberOfServices; uIndex++)
     
129.         {
     
130.                 //KdPrint(("pNewSSDT->ServiceTableBase[%d]:%X\n", uIndex, pNewSSDT->ServiceTableBase[uIndex]));
     
131. 
     
132.                 pNewSSDT->ServiceTableBase[uIndex] += uNewKernelInc;
     
133.                 //KdPrint(("pNewSSDT->ServiceTableBase[%d]:%X\n", uIndex, pNewSSDT->ServiceTableBase[uIndex]));
     
134.         }
     
135.        
     
136.        
     
137.         uOffset = (ULONG)KeServiceDescriptorTable.ParamTableBase - (ULONG)pOrigImage;
     
138.         pNewSSDT->ParamTableBase = (unsigned char *)((ULONG)pNewImage + uOffset);
     
139. 
     
140.         if (!MmIsAddressValid(pNewSSDT->ParamTableBase))
     
141.         {
     
142.                 return;
     
143.         }
     
144.         RtlCopyMemory(pNewSSDT->ParamTableBase, KeServiceDescriptorTable.ParamTableBase, pNewSSDT->NumberOfServices * sizeof(CHAR));
     
145.        
     
146.         *pNewServiceTable = pNewSSDT;
     
147.         KdPrint(("set new ssdt success!\n"));
     
148. }
     
149. 
     
150. #pragma PAGEDCODE
     
151. void RelocModule(PVOID pNewImage, PVOID pOrigImage)
     
152. {
     
153.         ULONG uIndex;
     
154.         ULONG uRelocTableSize;
     
155.         USHORT TypeValue;
     
156.         USHORT *pwTypeOffsetArrayAddress;
     
157.         ULONG uTypeOffsetArraySize;
     
158.         ULONG uRelocAddress;
     
159.         ULONG uRelocOffset;
     
160. 
     
161.         PIMAGE_DOS_HEADER pImageDosHeader;
     
162.         PIMAGE_NT_HEADERS pImageNtHeader;
     
163.         IMAGE_DATA_DIRECTORY ImageDataDirectory;
     
164.         IMAGE_BASE_RELOCATION *pImageBaseRelocation;
     
165. 
     
166.         pImageDosHeader = (PIMAGE_DOS_HEADER)pNewImage;
     
167.         pImageNtHeader = (PIMAGE_NT_HEADERS)((ULONG)pNewImage + pImageDosHeader->e_lfanew);
     
168. 
     
169.         uRelocOffset = (ULONG)pOrigImage - pImageNtHeader->OptionalHeader.ImageBase;
     
170. 
     
171.         ImageDataDirectory = pImageNtHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC];
     
172.        
     
173.         pImageBaseRelocation = (IMAGE_BASE_RELOCATION *)(ImageDataDirectory.VirtualAddress + (ULONG)pNewImage);
     
174.         uRelocTableSize = ImageDataDirectory.Size;
     
175. 
     
176.         while(uRelocTableSize)
     
177.         {
     
178.                 //uTypeOffsetArraySize = (pImageBaseRelocation->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION) + sizeof(pImageBaseRelocation->TypeOffset)) / sizeof(USHORT);
     
179.                 uTypeOffsetArraySize = (pImageBaseRelocation->SizeOfBlock - sizeof(ULONG) * 2) / sizeof(USHORT);
     
180.                 pwTypeOffsetArrayAddress = pImageBaseRelocation->TypeOffset;
     
181.                 for (uIndex = 0; uIndex < uTypeOffsetArraySize; uIndex++)
     
182.                 {
     
183.                         TypeValue = pwTypeOffsetArrayAddress[uIndex];
     
184.                         if (TypeValue >> 12 == IMAGE_REL_BASED_HIGHLOW)
     
185.                         {
     
186.                                 uRelocAddress = (TypeValue & 0x0fff) + pImageBaseRelocation->VirtualAddress  + (ULONG)pNewImage;
     
187.                                 if (!MmIsAddressValid((PVOID)uRelocAddress))
     
188.                                 {
     
189.                                         continue;
     
190.                                 }
     
191.                                 *(ULONG *)uRelocAddress += uRelocOffset;
     
192.                         }
     
193.                 }
     
194. 
     
195.                 uRelocTableSize -= pImageBaseRelocation->SizeOfBlock;
     
196.                 pImageBaseRelocation = (IMAGE_BASE_RELOCATION *) ((ULONG)pImageBaseRelocation + pImageBaseRelocation->SizeOfBlock);
     
197.         }
     
198.         return;
     
199. }
     
200. 
     
201. 
     
202. #pragma PAGEDCODE
     
203. NTSTATUS ReadFileToMemory(WCHAR *strFileName, PVOID *lpVitrualAddress, PVOID pOrigImage)
     
204. {
     
205.         NTSTATUS Status;
     
206.         HANDLE hFile;
     
207.         LARGE_INTEGER FileOffset;
     
208.         OBJECT_ATTRIBUTES        ObjAttr;
     
209.         UNICODE_STRING FileName;
     
210.         IO_STATUS_BLOCK IoStatusBlock;
     
211. 
     
212.         IMAGE_DOS_HEADER ImageDosHeader;
     
213.         IMAGE_NT_HEADERS ImageNtHeader;
     
214.         IMAGE_SECTION_HEADER *pImageSectionHeader;
     
215.        
     
216.        
     
217.         PVOID lpVirtualPointer;
     
218.         ULONG SectionVirtualAddress, SizeOfSection;
     
219.         ULONG PointerToRawData;
     
220.         ULONG uIndex;
     
221. 
     
222.         RtlInitUnicodeString(&FileName, strFileName);
     
223. 
     
224.         InitializeObjectAttributes(&ObjAttr, &FileName, OBJ_CASE_INSENSITIVE, NULL, NULL);
     
225. 
     
226.         if (!MmIsAddressValid(strFileName))
     
227.         {
     
228.                 return STATUS_UNSUCCESSFUL;
     
229.         }
     
230. 
     
231.         Status = ZwCreateFile(&hFile, GENERIC_ALL, &ObjAttr, &IoStatusBlock, NULL, FILE_ATTRIBUTE_NORMAL,
     
232.                 FILE_SHARE_READ, FILE_OPEN,  FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0);
     
233. 
     
234.         if (!NT_SUCCESS(Status))
     
235.         {
     
236.                 KdPrint(("ZwCreateFile Failed:%X\n",Status));
     
237.                 return Status;
     
238.         }
     
239.        
     
240. 
     
241.         FileOffset.QuadPart = 0;
     
242.         Status = ZwReadFile(hFile, NULL, NULL, NULL, &IoStatusBlock, &ImageDosHeader, sizeof(IMAGE_DOS_HEADER),
     
243.                 &FileOffset, NULL);
     
244.         if (!NT_SUCCESS(Status))
     
245.         {
     
246.                 KdPrint(("read IMAGE_DOS_HEADER Failed:%X\n",Status));
     
247.                 ZwClose(hFile);
     
248.                 return Status;
     
249.         }
     
250. 
     
251.         FileOffset.QuadPart = ImageDosHeader.e_lfanew;
     
252.         Status = ZwReadFile(hFile, NULL, NULL, NULL, &IoStatusBlock, &ImageNtHeader, sizeof(IMAGE_NT_HEADERS),
     
253.                 &FileOffset, NULL);
     
254.         if (!NT_SUCCESS(Status))
     
255.         {
     
256.                 KdPrint(("read IMAGE_NT_HEADERS Failed:%X\n",Status));
     
257.                 ZwClose(hFile);
     
258.                 return Status;
     
259.         }
     
260. 
     
261.         pImageSectionHeader = (IMAGE_SECTION_HEADER *)ExAllocatePool(PagedPool,
     
262.                 sizeof(IMAGE_SECTION_HEADER) * ImageNtHeader.FileHeader.NumberOfSections);
     
263. 
     
264.         if (pImageSectionHeader == 0)
     
265.         {
     
266.                 KdPrint(("pImageSectionHeader is null!\n"));
     
267.                 ZwClose(hFile);
     
268.                 return STATUS_UNSUCCESSFUL;
     
269.         }
     
270.         FileOffset.QuadPart += sizeof(IMAGE_NT_HEADERS);
     
271.         Status = ZwReadFile(hFile, NULL, NULL, NULL, &IoStatusBlock, pImageSectionHeader,
     
272.                 sizeof(IMAGE_SECTION_HEADER) * ImageNtHeader.FileHeader.NumberOfSections, &FileOffset, NULL);
     
273.         if (!NT_SUCCESS(Status))
     
274.         {
     
275.                 KdPrint(("read IMAGE_SECTION_HEADER Failed:%X\n",Status));
     
276.                 ZwClose(hFile);
     
277.                 ExFreePool(pImageSectionHeader);
     
278.                 return Status;
     
279.         }
     
280. 
     
281. 
     
282.         lpVirtualPointer = ExAllocatePool(PagedPool, ImageNtHeader.OptionalHeader.SizeOfImage);
     
283.         if (lpVirtualPointer == 0)
     
284.         {
     
285.                 KdPrint(("lpVirtualPointer is null!\n"));
     
286.                 ZwClose(hFile);
     
287.                 ExFreePool(pImageSectionHeader);
     
288.                 return STATUS_UNSUCCESSFUL;
     
289.         }
     
290. 
     
291.         memset(lpVirtualPointer, 0, ImageNtHeader.OptionalHeader.SizeOfImage);
     
292.         RtlCopyMemory(lpVirtualPointer, &ImageDosHeader, sizeof(IMAGE_DOS_HEADER));
     
293.         RtlCopyMemory((PVOID)((ULONG)lpVirtualPointer + ImageDosHeader.e_lfanew), &ImageNtHeader, sizeof(IMAGE_NT_HEADERS));
     
294.         RtlCopyMemory((PVOID)((ULONG)lpVirtualPointer + ImageDosHeader.e_lfanew + sizeof(IMAGE_NT_HEADERS)),
     
295.                 pImageSectionHeader, sizeof(IMAGE_SECTION_HEADER) * ImageNtHeader.FileHeader.NumberOfSections);
     
296. 
     
297. 
     
298.         for (uIndex = 0; uIndex < ImageNtHeader.FileHeader.NumberOfSections; uIndex++)
     
299.         {
     
300.                 SectionVirtualAddress = pImageSectionHeader[uIndex].VirtualAddress;
     
301.                 SizeOfSection = pImageSectionHeader[uIndex].SizeOfRawData;
     
302.                 PointerToRawData = pImageSectionHeader[uIndex].PointerToRawData;
     
303. 
     
304.                 FileOffset.QuadPart = PointerToRawData;
     
305.                 Status = ZwReadFile(hFile, NULL, NULL, NULL, &IoStatusBlock, (PVOID)((ULONG)lpVirtualPointer + SectionVirtualAddress),
     
306.                         SizeOfSection, &FileOffset, NULL);
     
307.                 if (!NT_SUCCESS(Status))
     
308.                 {
     
309.                         KdPrint(("read failed is pImageSectionHeader[%d]:%X\n",uIndex, Status));
     
310.                         ZwClose(hFile);
     
311.                         ExFreePool(pImageSectionHeader);
     
312.                         ExFreePool(lpVirtualPointer);
     
313.                         return Status;
     
314.                 }
     
315.         }
     
316. 
     
317.         RelocModule(lpVirtualPointer, pOrigImage);
     
318.         SetNewSSDT(lpVirtualPointer, pOrigImage, &g_pNewServiceTable);
     
319.        
     
320.         KdPrint(("ok..."));
     
321. 
     
322.         *lpVitrualAddress = lpVirtualPointer;
     
323.         ZwClose(hFile);
     
324.         ExFreePool(pImageSectionHeader);
     
325.         return Status;
     
326. }
     
327. 
     
328. 
     
329. #pragma PAGEDCODE
     
330. PLDR_DATA_TABLE_ENTRY EnumDriver(PDRIVER_OBJECT pDriverObject, WCHAR *strDriverName)
     
331. {
     
332.         PLDR_DATA_TABLE_ENTRY pDataTableEntry, pTempDataTableEntry;
     
333.         PLIST_ENTRY pList;
     
334.         UNICODE_STRING usDriverName;
     
335. 
     
336.         RtlInitUnicodeString(&usDriverName, strDriverName);
     
337. 
     
338.         pDataTableEntry = (PLDR_DATA_TABLE_ENTRY)pDriverObject->DriverSection;
     
339. 
     
340.         if (!pDataTableEntry)
     
341.         {
     
342.                 return 0;
     
343.         }
     
344. 
     
345.         pList = pDataTableEntry->InLoadOrderLinks.Flink;
     
346. 
     
347.         while(pList != &pDataTableEntry->InLoadOrderLinks)
     
348.         {
     
349.                 pTempDataTableEntry = (PLDR_DATA_TABLE_ENTRY)pList;
     
350. 
     
351.                 //KdPrint(("\n%wZ\n", &pTempDataTableEntry->BaseDllName));
     
352. 
     
353.                 if (0 == RtlCompareUnicodeString(&pTempDataTableEntry->BaseDllName, &usDriverName, FALSE))
     
354.                 {
     
355.                         return pTempDataTableEntry;
     
356.                 }
     
357. 
     
358.                 pList = pList->Flink;
     
359.         }
     
360. 
     
361.         return 0;
     
362. }
     
363. 
     
364. 
     
365. #pragma PAGEDCODE
     
366. ULONG SearchHookPointer(ULONG StartAddress)
     
367. {
     
368.         ULONG u_index;
     
369.         UCHAR *p = (UCHAR*)StartAddress;
     
370. 
     
371.         for (u_index = 0; u_index < 200; u_index++)
     
372.         {
     
373.                 if (*p == 0x2b &&
     
374.                         *(p+1) == 0xe1 &&
     
375.                         *(p+2) == 0xc1 &&
     
376.                         *(p+3) == 0xe9 &&
     
377.                         *(p+4) == 0x02)
     
378.                 {
     
379.                         return (ULONG)p;
     
380.                 }
     
381.                 p--;
     
382.         }
     
383. 
     
384.         return 0;
     
385. }
     
386. 
     
387. #pragma PAGEDCODE
     
388. ULONG __stdcall FilterKiFastCallEntry(ULONG ServiceTableBase, ULONG FuncIndex, ULONG OrigFuncAddress)
     
389. {
     
390.         if (ServiceTableBase == (ULONG)KeServiceDescriptorTable.ServiceTableBase)
     
391.         {
     
392.                 if (strstr((char*)PsGetCurrentProcess() + 0x174, "Ollydbg") != 0)
     
393.                 {
     
394.                         return g_pNewServiceTable->ServiceTableBase[FuncIndex];
     
395.                 }
     
396.         }
     
397. 
     
398.         return OrigFuncAddress;
     
399. }
     
400. 
     
401. __declspec(naked) void NewKiFastCallEntry()
     
402. {
     
403.         __asm
     
404.         {
     
405.                 pushad
     
406.                         pushfd
     
407. 
     
408.                         push ebx
     
409.                         push eax
     
410.                         push edi
     
411.                         call FilterKiFastCallEntry
     
412. 
     
413.                         mov [esp + 0x14], eax
     
414. 
     
415.                         popfd
     
416.                         popad
     
417. 
     
418.                         sub esp,ecx
     
419.                         shr ecx,2
     
420.                         jmp g_goto_OrigFunc
     
421.         }
     
422. }
     
423. 
     
424. void UnHookKiFastCallEntry()
     
425. {
     
426.         UCHAR str_origfuncode[5] = {0x2b, 0xe1, 0xc1, 0xe9, 0x02};
     
427.         if (g_kifastcall_hookpoint == 0)
     
428.         {
     
429.                 return;
     
430.         }
     
431. 
     
432.         PageProtectOff();
     
433.         RtlCopyMemory((PVOID)g_kifastcall_hookpoint, str_origfuncode, 5);
     
434.         PageProtectOn();
     
435. }
     
436. 
     
437. void HookKiFastCallEntry(ULONG HookPointer)
     
438. {
     
439.         ULONG u_temp;
     
440.         UCHAR u_jmp_code[5];
     
441. 
     
442.         u_jmp_code[0] = 0xe9;
     
443. 
     
444.         u_temp = (ULONG)NewKiFastCallEntry - HookPointer - 5;
     
445.         *(ULONG*)&u_jmp_code[1] = u_temp;
     
446. 
     
447.         PageProtectOff();
     
448. 
     
449.         RtlCopyMemory((PVOID)HookPointer, u_jmp_code, 5);
     
450. 
     
451.         PageProtectOn();
     
452. 
     
453. }
     
454. 
     
455. NTSTATUS  NewNtCreateFile(
     
456.                                                   OUT PHANDLE  FileHandle,
     
457.                                                   IN ACCESS_MASK  DesiredAccess,
     
458.                                                   IN POBJECT_ATTRIBUTES  ObjectAttributes,
     
459.                                                   OUT PIO_STATUS_BLOCK  IoStatusBlock,
     
460.                                                   IN PLARGE_INTEGER  AllocationSize,
     
461.                                                   IN ULONG  FileAttributes,
     
462.                                                   IN ULONG  ShareAccess,
     
463.                                                   IN ULONG  CreateDisposition,
     
464.                                                   IN ULONG  CreateOptions,
     
465.                                                   IN PVOID  EaBuffer,
     
466.                                                   IN ULONG  EaLength
     
467.                                                   )
     
468. {
     
469.         ULONG u_call_retAddr;
     
470.         __asm
     
471.         {
     
472.                 pushad
     
473.                         mov eax, [ebp + 0x4]
     
474.                 mov u_call_retAddr, eax
     
475.                         popad
     
476.         }
     
477. 
     
478.         KdPrint(("u_call_retAddr: %x\n", u_call_retAddr));
     
479.         g_kifastcall_hookpoint = SearchHookPointer(u_call_retAddr);
     
480. 
     
481.         if (g_kifastcall_hookpoint == 0)
     
482.         {
     
483.                 KdPrint(("search failed!\n"));
     
484.         }
     
485.         else
     
486.         {
     
487.                 KdPrint(("search success %x\n", g_kifastcall_hookpoint));
     
488.         }
     
489. 
     
490.         g_goto_OrigFunc = g_kifastcall_hookpoint + 5;
     
491.         HookKiFastCallEntry(g_kifastcall_hookpoint);
     
492. 
     
493.         PageProtectOff();
     
494. 
     
495.         KeServiceDescriptorTable.ServiceTableBase[37] = (unsigned int)g_ntCreateFile;
     
496. 
     
497.         PageProtectOn();
     
498. 
     
499.         return ((pNtCreateFile)g_ntCreateFile)(
     
500.                 FileHandle,
     
501.                 DesiredAccess,
     
502.                 ObjectAttributes,
     
503.                 IoStatusBlock,
     
504.                 AllocationSize,
     
505.                 FileAttributes,
     
506.                 ShareAccess,
     
507.                 CreateDisposition,
     
508.                 CreateOptions,
     
509.                 EaBuffer,
     
510.                 EaLength);
     
511. }
     
512. 
     
513. 
     
514. 
     
515. 
     
516. #pragma PAGEDCODE
     
517. void SearchKiFastCallEntry()
     
518. {
     
519.         NTSTATUS Status;
     
520.         HANDLE hFile;
     
521.         OBJECT_ATTRIBUTES        ObjAttr;
     
522.         UNICODE_STRING FileName;
     
523.         IO_STATUS_BLOCK IoStatusBlock;
     
524. 
     
525.         RtlInitUnicodeString(&FileName, L"\\??\\C:\\WINDOWS\\system32\\ntoskrnl.exe");
     
526. 
     
527.         InitializeObjectAttributes(&ObjAttr, &FileName, OBJ_CASE_INSENSITIVE, NULL, NULL);
     
528. 
     
529.         PageProtectOff();
     
530.         g_ntCreateFile = KeServiceDescriptorTable.ServiceTableBase[37];
     
531.         KeServiceDescriptorTable.ServiceTableBase[37] = (unsigned int)NewNtCreateFile;
     
532.         PageProtectOn();
     
533. 
     
534.         Status = ZwCreateFile(&hFile, GENERIC_ALL, &ObjAttr, &IoStatusBlock, NULL, FILE_ATTRIBUTE_NORMAL,
     
535.                 FILE_SHARE_READ, FILE_OPEN,  FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0);
     
536.         if (NT_SUCCESS(Status))
     
537.         {
     
538.                 ZwClose(hFile);
     
539.         }
     
540. 
     
541. }
     
542. 
     
543. 
     
544. #pragma PAGEDCODE
     
545. VOID MyDriverUnload(IN PDRIVER_OBJECT pDriverObject)
     
546. {
     
547. 
     
548.         if (g_lpVitrualPointer)
     
549.         {
     
550.                 ExFreePool(g_lpVitrualPointer);
     
551.         }
     
552. 
     
553.         UnHookKiFastCallEntry();
     
554. 
     
555.         KdPrint(("DriverEntry unLoading...\n"));
     
556. 
     
557. }
     
558. 
     
559. 
     
560. 
     
561. #pragma INITCODE
     
562. NTSTATUS DriverEntry(IN PDRIVER_OBJECT pDriverObject, IN PUNICODE_STRING RegistryPath)
     
563. {
     
564.         NTSTATUS status = STATUS_SUCCESS;
     
565.         PLDR_DATA_TABLE_ENTRY pLdrDataTableEntry;
     
566. 
     
567.         pLdrDataTableEntry = EnumDriver(pDriverObject, L"ntoskrnl.exe");
     
568.         if (pLdrDataTableEntry)
     
569.         {
     
570.                 ReadFileToMemory(L"\\??\\C:\\WINDOWS\\system32\\ntoskrnl.exe", &g_lpVitrualPointer, pLdrDataTableEntry->DllBase);
     
571.                 KdPrint(("g_lpVitrualPointer:%X\n", g_lpVitrualPointer));
     
572.                 g_NewKernelInc = (ULONG)g_lpVitrualPointer - (ULONG)pLdrDataTableEntry->DllBase;
     
573.                 SearchKiFastCallEntry();
     
574.         }
     
575. 
     
576.         pDriverObject->DriverUnload = MyDriverUnload;
     
577.         return status;
     
578. }

复制代码

ntimage.h

1. /*++ BUILD Version: 0004    // Increment this if a change has global effects
   
2. 
   
3. Copyright (c) Microsoft Corporation. All rights reserved.
   
4. 
   
5. You may only use this code if you agree to the terms of the Windows Research Kernel Source Code License agreement (see License.txt).
   
6. If you do not agree to the terms, do not use the code.
   
7. 
   
8. 
   
9. Module Name:
   
10. 
    
11.     ntimage.h
    
12. 
    
13. Abstract:
    
14. 
    
15.     This is the include file that describes all image structures.
    
16. 
    
17. --*/
    
18. 
    
19. #ifndef _NTIMAGE_
    
20. #define _NTIMAGE_
    
21. 
    
22. #if _MSC_VER > 1000
    
23. #pragma once
    
24. #endif
    
25. 
    
26. //
    
27. // Define the linker version number.  This is temporary to aid
    
28. // in debugging with people trying to load images built with
    
29. // an older linker.  This is not required in the final product.
    
30. //
    
31. 
    
32. #define IMAGE_MAJOR_LINKER_VERSION 2
    
33. 
    
34. // begin_winnt
    
35. 
    
36. 
    
37. //
    
38. // Image Format
    
39. //
    
40. 
    
41. #include "pshpack4.h"                   // 4 byte packing is the default
    
42. 
    
43. #define IMAGE_DOS_SIGNATURE                 0x5A4D      // MZ
    
44. #define IMAGE_OS2_SIGNATURE                 0x454E      // NE
    
45. #define IMAGE_OS2_SIGNATURE_LE              0x454C      // LE
    
46. #define IMAGE_VXD_SIGNATURE                 0x454C      // LE
    
47. #define IMAGE_NT_SIGNATURE                  0x00004550  // PE00
    
48. 
    
49. #include "pshpack2.h"                   // 16 bit headers are 2 byte packed
    
50. 
    
51. typedef struct _IMAGE_DOS_HEADER {      // DOS .EXE header
    
52.     USHORT e_magic;                     // Magic number
    
53.     USHORT e_cblp;                      // Bytes on last page of file
    
54.     USHORT e_cp;                        // Pages in file
    
55.     USHORT e_crlc;                      // Relocations
    
56.     USHORT e_cparhdr;                   // Size of header in paragraphs
    
57.     USHORT e_minalloc;                  // Minimum extra paragraphs needed
    
58.     USHORT e_maxalloc;                  // Maximum extra paragraphs needed
    
59.     USHORT e_ss;                        // Initial (relative) SS value
    
60.     USHORT e_sp;                        // Initial SP value
    
61.     USHORT e_csum;                      // Checksum
    
62.     USHORT e_ip;                        // Initial IP value
    
63.     USHORT e_cs;                        // Initial (relative) CS value
    
64.     USHORT e_lfarlc;                    // File address of relocation table
    
65.     USHORT e_ovno;                      // Overlay number
    
66.     USHORT e_res[4];                    // Reserved words
    
67.     USHORT e_oemid;                     // OEM identifier (for e_oeminfo)
    
68.     USHORT e_oeminfo;                   // OEM information; e_oemid specific
    
69.     USHORT e_res2[10];                  // Reserved words
    
70.     LONG   e_lfanew;                    // File address of new exe header
    
71.   } IMAGE_DOS_HEADER, *PIMAGE_DOS_HEADER;
    
72. 
    
73. typedef struct _IMAGE_OS2_HEADER {      // OS/2 .EXE header
    
74.     USHORT ne_magic;                    // Magic number
    
75.     CHAR   ne_ver;                      // Version number
    
76.     CHAR   ne_rev;                      // Revision number
    
77.     USHORT ne_enttab;                   // Offset of Entry Table
    
78.     USHORT ne_cbenttab;                 // Number of bytes in Entry Table
    
79.     LONG   ne_crc;                      // Checksum of whole file
    
80.     USHORT ne_flags;                    // Flag word
    
81.     USHORT ne_autodata;                 // Automatic data segment number
    
82.     USHORT ne_heap;                     // Initial heap allocation
    
83.     USHORT ne_stack;                    // Initial stack allocation
    
84.     LONG   ne_csip;                     // Initial CS:IP setting
    
85.     LONG   ne_sssp;                     // Initial SS:SP setting
    
86.     USHORT ne_cseg;                     // Count of file segments
    
87.     USHORT ne_cmod;                     // Entries in Module Reference Table
    
88.     USHORT ne_cbnrestab;                // Size of non-resident name table
    
89.     USHORT ne_segtab;                   // Offset of Segment Table
    
90.     USHORT ne_rsrctab;                  // Offset of Resource Table
    
91.     USHORT ne_restab;                   // Offset of resident name table
    
92.     USHORT ne_modtab;                   // Offset of Module Reference Table
    
93.     USHORT ne_imptab;                   // Offset of Imported Names Table
    
94.     LONG   ne_nrestab;                  // Offset of Non-resident Names Table
    
95.     USHORT ne_cmovent;                  // Count of movable entries
    
96.     USHORT ne_align;                    // Segment alignment shift count
    
97.     USHORT ne_cres;                     // Count of resource segments
    
98.     UCHAR  ne_exetyp;                   // Target Operating system
    
99.     UCHAR  ne_flagsothers;              // Other .EXE flags
    
100.     USHORT ne_pretthunks;               // offset to return thunks
     
101.     USHORT ne_psegrefbytes;             // offset to segment ref. bytes
     
102.     USHORT ne_swaparea;                 // Minimum code swap area size
     
103.     USHORT ne_expver;                   // Expected Windows version number
     
104.   } IMAGE_OS2_HEADER, *PIMAGE_OS2_HEADER;
     
105. 
     
106. typedef struct _IMAGE_VXD_HEADER {      // Windows VXD header
     
107.     USHORT e32_magic;                   // Magic number
     
108.     UCHAR  e32_border;                  // The byte ordering for the VXD
     
109.     UCHAR  e32_worder;                  // The word ordering for the VXD
     
110.     ULONG  e32_level;                   // The EXE format level for now = 0
     
111.     USHORT e32_cpu;                     // The CPU type
     
112.     USHORT e32_os;                      // The OS type
     
113.     ULONG  e32_ver;                     // Module version
     
114.     ULONG  e32_mflags;                  // Module flags
     
115.     ULONG  e32_mpages;                  // Module # pages
     
116.     ULONG  e32_startobj;                // Object # for instruction pointer
     
117.     ULONG  e32_eip;                     // Extended instruction pointer
     
118.     ULONG  e32_stackobj;                // Object # for stack pointer
     
119.     ULONG  e32_esp;                     // Extended stack pointer
     
120.     ULONG  e32_pagesize;                // VXD page size
     
121.     ULONG  e32_lastpagesize;            // Last page size in VXD
     
122.     ULONG  e32_fixupsize;               // Fixup section size
     
123.     ULONG  e32_fixupsum;                // Fixup section checksum
     
124.     ULONG  e32_ldrsize;                 // Loader section size
     
125.     ULONG  e32_ldrsum;                  // Loader section checksum
     
126.     ULONG  e32_objtab;                  // Object table offset
     
127.     ULONG  e32_objcnt;                  // Number of objects in module
     
128.     ULONG  e32_objmap;                  // Object page map offset
     
129.     ULONG  e32_itermap;                 // Object iterated data map offset
     
130.     ULONG  e32_rsrctab;                 // Offset of Resource Table
     
131.     ULONG  e32_rsrccnt;                 // Number of resource entries
     
132.     ULONG  e32_restab;                  // Offset of resident name table
     
133.     ULONG  e32_enttab;                  // Offset of Entry Table
     
134.     ULONG  e32_dirtab;                  // Offset of Module Directive Table
     
135.     ULONG  e32_dircnt;                  // Number of module directives
     
136.     ULONG  e32_fpagetab;                // Offset of Fixup Page Table
     
137.     ULONG  e32_frectab;                 // Offset of Fixup Record Table
     
138.     ULONG  e32_impmod;                  // Offset of Import Module Name Table
     
139.     ULONG  e32_impmodcnt;               // Number of entries in Import Module Name Table
     
140.     ULONG  e32_impproc;                 // Offset of Import Procedure Name Table
     
141.     ULONG  e32_pagesum;                 // Offset of Per-Page Checksum Table
     
142.     ULONG  e32_datapage;                // Offset of Enumerated Data Pages
     
143.     ULONG  e32_preload;                 // Number of preload pages
     
144.     ULONG  e32_nrestab;                 // Offset of Non-resident Names Table
     
145.     ULONG  e32_cbnrestab;               // Size of Non-resident Name Table
     
146.     ULONG  e32_nressum;                 // Non-resident Name Table Checksum
     
147.     ULONG  e32_autodata;                // Object # for automatic data object
     
148.     ULONG  e32_debuginfo;               // Offset of the debugging information
     
149.     ULONG  e32_debuglen;                // The length of the debugging info. in bytes
     
150.     ULONG  e32_instpreload;             // Number of instance pages in preload section of VXD file
     
151.     ULONG  e32_instdemand;              // Number of instance pages in demand load section of VXD file
     
152.     ULONG  e32_heapsize;                // Size of heap - for 16-bit apps
     
153.     UCHAR  e32_res3[12];                // Reserved words
     
154.     ULONG  e32_winresoff;
     
155.     ULONG  e32_winreslen;
     
156.     USHORT e32_devid;                   // Device ID for VxD
     
157.     USHORT e32_ddkver;                  // DDK version for VxD
     
158.   } IMAGE_VXD_HEADER, *PIMAGE_VXD_HEADER;
     
159. 
     
160. #include "poppack.h"                    // Back to 4 byte packing
     
161. 
     
162. //
     
163. // File header format.
     
164. //
     
165. 
     
166. typedef struct _IMAGE_FILE_HEADER {
     
167.     USHORT  Machine;
     
168.     USHORT  NumberOfSections;
     
169.     ULONG   TimeDateStamp;
     
170.     ULONG   PointerToSymbolTable;
     
171.     ULONG   NumberOfSymbols;
     
172.     USHORT  SizeOfOptionalHeader;
     
173.     USHORT  Characteristics;
     
174. } IMAGE_FILE_HEADER, *PIMAGE_FILE_HEADER;
     
175. 
     
176. #define IMAGE_SIZEOF_FILE_HEADER             20
     
177. 
     
178. 
     
179. #define IMAGE_FILE_RELOCS_STRIPPED           0x0001  // Relocation info stripped from file.
     
180. #define IMAGE_FILE_EXECUTABLE_IMAGE          0x0002  // File is executable  (i.e. no unresolved external references).
     
181. #define IMAGE_FILE_LINE_NUMS_STRIPPED        0x0004  // Line nunbers stripped from file.
     
182. #define IMAGE_FILE_LOCAL_SYMS_STRIPPED       0x0008  // Local symbols stripped from file.
     
183. #define IMAGE_FILE_AGGRESIVE_WS_TRIM         0x0010  // Agressively trim working set
     
184. #define IMAGE_FILE_LARGE_ADDRESS_AWARE       0x0020  // App can handle >2gb addresses
     
185. #define IMAGE_FILE_BYTES_REVERSED_LO         0x0080  // Bytes of machine word are reversed.
     
186. #define IMAGE_FILE_32BIT_MACHINE             0x0100  // 32 bit word machine.
     
187. #define IMAGE_FILE_DEBUG_STRIPPED            0x0200  // Debugging info stripped from file in .DBG file
     
188. #define IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP   0x0400  // If Image is on removable media, copy and run from the swap file.
     
189. #define IMAGE_FILE_NET_RUN_FROM_SWAP         0x0800  // If Image is on Net, copy and run from the swap file.
     
190. #define IMAGE_FILE_SYSTEM                    0x1000  // System File.
     
191. #define IMAGE_FILE_DLL                       0x2000  // File is a DLL.
     
192. #define IMAGE_FILE_UP_SYSTEM_ONLY            0x4000  // File should only be run on a UP machine
     
193. #define IMAGE_FILE_BYTES_REVERSED_HI         0x8000  // Bytes of machine word are reversed.
     
194. 
     
195. #define IMAGE_FILE_MACHINE_UNKNOWN           0
     
196. #define IMAGE_FILE_MACHINE_I386              0x014c  // Intel 386.
     
197. #define IMAGE_FILE_MACHINE_R3000             0x0162  // MIPS little-endian, 0x160 big-endian
     
198. #define IMAGE_FILE_MACHINE_R4000             0x0166  // MIPS little-endian
     
199. #define IMAGE_FILE_MACHINE_R10000            0x0168  // MIPS little-endian
     
200. #define IMAGE_FILE_MACHINE_WCEMIPSV2         0x0169  // MIPS little-endian WCE v2
     
201. #define IMAGE_FILE_MACHINE_ALPHA             0x0184  // Alpha_AXP
     
202. #define IMAGE_FILE_MACHINE_SH3               0x01a2  // SH3 little-endian
     
203. #define IMAGE_FILE_MACHINE_SH3DSP            0x01a3
     
204. #define IMAGE_FILE_MACHINE_SH3E              0x01a4  // SH3E little-endian
     
205. #define IMAGE_FILE_MACHINE_SH4               0x01a6  // SH4 little-endian
     
206. #define IMAGE_FILE_MACHINE_SH5               0x01a8  // SH5
     
207. #define IMAGE_FILE_MACHINE_ARM               0x01c0  // ARM Little-Endian
     
208. #define IMAGE_FILE_MACHINE_THUMB             0x01c2
     
209. #define IMAGE_FILE_MACHINE_AM33              0x01d3
     
210. #define IMAGE_FILE_MACHINE_POWERPC           0x01F0  // IBM PowerPC Little-Endian
     
211. #define IMAGE_FILE_MACHINE_POWERPCFP         0x01f1
     
212. #define IMAGE_FILE_MACHINE_IA64              0x0200  // Intel 64
     
213. #define IMAGE_FILE_MACHINE_MIPS16            0x0266  // MIPS
     
214. #define IMAGE_FILE_MACHINE_ALPHA64           0x0284  // ALPHA64
     
215. #define IMAGE_FILE_MACHINE_MIPSFPU           0x0366  // MIPS
     
216. #define IMAGE_FILE_MACHINE_MIPSFPU16         0x0466  // MIPS
     
217. #define IMAGE_FILE_MACHINE_AXP64             IMAGE_FILE_MACHINE_ALPHA64
     
218. #define IMAGE_FILE_MACHINE_TRICORE           0x0520  // Infineon
     
219. #define IMAGE_FILE_MACHINE_CEF               0x0CEF
     
220. #define IMAGE_FILE_MACHINE_EBC               0x0EBC  // EFI Byte Code
     
221. #define IMAGE_FILE_MACHINE_AMD64             0x8664  // AMD64 (K8)
     
222. #define IMAGE_FILE_MACHINE_M32R              0x9041  // M32R little-endian
     
223. #define IMAGE_FILE_MACHINE_CEE               0xC0EE
     
224. 
     
225. //
     
226. // Directory format.
     
227. //
     
228. 
     
229. typedef struct _IMAGE_DATA_DIRECTORY {
     
230.     ULONG   VirtualAddress;
     
231.     ULONG   Size;
     
232. } IMAGE_DATA_DIRECTORY, *PIMAGE_DATA_DIRECTORY;
     
233. 
     
234. #define IMAGE_NUMBEROF_DIRECTORY_ENTRIES    16
     
235. 
     
236. //
     
237. // Optional header format.
     
238. //
     
239. 
     
240. typedef struct _IMAGE_OPTIONAL_HEADER {
     
241.     //
     
242.     // Standard fields.
     
243.     //
     
244. 
     
245.     USHORT  Magic;
     
246.     UCHAR   MajorLinkerVersion;
     
247.     UCHAR   MinorLinkerVersion;
     
248.     ULONG   SizeOfCode;
     
249.     ULONG   SizeOfInitializedData;
     
250.     ULONG   SizeOfUninitializedData;
     
251.     ULONG   AddressOfEntryPoint;
     
252.     ULONG   BaseOfCode;
     
253.     ULONG   BaseOfData;
     
254. 
     
255.     //
     
256.     // NT additional fields.
     
257.     //
     
258. 
     
259.     ULONG   ImageBase;
     
260.     ULONG   SectionAlignment;
     
261.     ULONG   FileAlignment;
     
262.     USHORT  MajorOperatingSystemVersion;
     
263.     USHORT  MinorOperatingSystemVersion;
     
264.     USHORT  MajorImageVersion;
     
265.     USHORT  MinorImageVersion;
     
266.     USHORT  MajorSubsystemVersion;
     
267.     USHORT  MinorSubsystemVersion;
     
268.     ULONG   Win32VersionValue;
     
269.     ULONG   SizeOfImage;
     
270.     ULONG   SizeOfHeaders;
     
271.     ULONG   CheckSum;
     
272.     USHORT  Subsystem;
     
273.     USHORT  DllCharacteristics;
     
274.     ULONG   SizeOfStackReserve;
     
275.     ULONG   SizeOfStackCommit;
     
276.     ULONG   SizeOfHeapReserve;
     
277.     ULONG   SizeOfHeapCommit;
     
278.     ULONG   LoaderFlags;
     
279.     ULONG   NumberOfRvaAndSizes;
     
280.     IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES];
     
281. } IMAGE_OPTIONAL_HEADER32, *PIMAGE_OPTIONAL_HEADER32;
     
282. 
     
283. typedef struct _IMAGE_ROM_OPTIONAL_HEADER {
     
284.     USHORT Magic;
     
285.     UCHAR  MajorLinkerVersion;
     
286.     UCHAR  MinorLinkerVersion;
     
287.     ULONG  SizeOfCode;
     
288.     ULONG  SizeOfInitializedData;
     
289.     ULONG  SizeOfUninitializedData;
     
290.     ULONG  AddressOfEntryPoint;
     
291.     ULONG  BaseOfCode;
     
292.     ULONG  BaseOfData;
     
293.     ULONG  BaseOfBss;
     
294.     ULONG  GprMask;
     
295.     ULONG  CprMask[4];
     
296.     ULONG  GpValue;
     
297. } IMAGE_ROM_OPTIONAL_HEADER, *PIMAGE_ROM_OPTIONAL_HEADER;
     
298. 
     
299. typedef struct _IMAGE_OPTIONAL_HEADER64 {
     
300.     USHORT      Magic;
     
301.     UCHAR       MajorLinkerVersion;
     
302.     UCHAR       MinorLinkerVersion;
     
303.     ULONG       SizeOfCode;
     
304.     ULONG       SizeOfInitializedData;
     
305.     ULONG       SizeOfUninitializedData;
     
306.     ULONG       AddressOfEntryPoint;
     
307.     ULONG       BaseOfCode;
     
308.     ULONGLONG   ImageBase;
     
309.     ULONG       SectionAlignment;
     
310.     ULONG       FileAlignment;
     
311.     USHORT      MajorOperatingSystemVersion;
     
312.     USHORT      MinorOperatingSystemVersion;
     
313.     USHORT      MajorImageVersion;
     
314.     USHORT      MinorImageVersion;
     
315.     USHORT      MajorSubsystemVersion;
     
316.     USHORT      MinorSubsystemVersion;
     
317.     ULONG       Win32VersionValue;
     
318.     ULONG       SizeOfImage;
     
319.     ULONG       SizeOfHeaders;
     
320.     ULONG       CheckSum;
     
321.     USHORT      Subsystem;
     
322.     USHORT      DllCharacteristics;
     
323.     ULONGLONG   SizeOfStackReserve;
     
324.     ULONGLONG   SizeOfStackCommit;
     
325.     ULONGLONG   SizeOfHeapReserve;
     
326.     ULONGLONG   SizeOfHeapCommit;
     
327.     ULONG       LoaderFlags;
     
328.     ULONG       NumberOfRvaAndSizes;
     
329.     IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES];
     
330. } IMAGE_OPTIONAL_HEADER64, *PIMAGE_OPTIONAL_HEADER64;
     
331. 
     
332. #define IMAGE_SIZEOF_ROM_OPTIONAL_HEADER      56
     
333. #define IMAGE_SIZEOF_STD_OPTIONAL_HEADER      28
     
334. #define IMAGE_SIZEOF_NT_OPTIONAL32_HEADER    224
     
335. #define IMAGE_SIZEOF_NT_OPTIONAL64_HEADER    240
     
336. 
     
337. #define IMAGE_NT_OPTIONAL_HDR32_MAGIC      0x10b
     
338. #define IMAGE_NT_OPTIONAL_HDR64_MAGIC      0x20b
     
339. #define IMAGE_ROM_OPTIONAL_HDR_MAGIC       0x107
     
340. 
     
341. #ifdef _WIN64
     
342. typedef IMAGE_OPTIONAL_HEADER64             IMAGE_OPTIONAL_HEADER;
     
343. typedef PIMAGE_OPTIONAL_HEADER64            PIMAGE_OPTIONAL_HEADER;
     
344. #define IMAGE_SIZEOF_NT_OPTIONAL_HEADER     IMAGE_SIZEOF_NT_OPTIONAL64_HEADER
     
345. #define IMAGE_NT_OPTIONAL_HDR_MAGIC         IMAGE_NT_OPTIONAL_HDR64_MAGIC
     
346. #else
     
347. typedef IMAGE_OPTIONAL_HEADER32             IMAGE_OPTIONAL_HEADER;
     
348. typedef PIMAGE_OPTIONAL_HEADER32            PIMAGE_OPTIONAL_HEADER;
     
349. #define IMAGE_SIZEOF_NT_OPTIONAL_HEADER     IMAGE_SIZEOF_NT_OPTIONAL32_HEADER
     
350. #define IMAGE_NT_OPTIONAL_HDR_MAGIC         IMAGE_NT_OPTIONAL_HDR32_MAGIC
     
351. #endif
     
352. 
     
353. typedef struct _IMAGE_NT_HEADERS64 {
     
354.     ULONG Signature;
     
355.     IMAGE_FILE_HEADER FileHeader;
     
356.     IMAGE_OPTIONAL_HEADER64 OptionalHeader;
     
357. } IMAGE_NT_HEADERS64, *PIMAGE_NT_HEADERS64;
     
358. 
     
359. typedef struct _IMAGE_NT_HEADERS {
     
360.     ULONG Signature;
     
361.     IMAGE_FILE_HEADER FileHeader;
     
362.     IMAGE_OPTIONAL_HEADER32 OptionalHeader;
     
363. } IMAGE_NT_HEADERS32, *PIMAGE_NT_HEADERS32;
     
364. 
     
365. typedef struct _IMAGE_ROM_HEADERS {
     
366.     IMAGE_FILE_HEADER FileHeader;
     
367.     IMAGE_ROM_OPTIONAL_HEADER OptionalHeader;
     
368. } IMAGE_ROM_HEADERS, *PIMAGE_ROM_HEADERS;
     
369. 
     
370. #ifdef _WIN64
     
371. typedef IMAGE_NT_HEADERS64                  IMAGE_NT_HEADERS;
     
372. typedef PIMAGE_NT_HEADERS64                 PIMAGE_NT_HEADERS;
     
373. #else
     
374. typedef IMAGE_NT_HEADERS32                  IMAGE_NT_HEADERS;
     
375. typedef PIMAGE_NT_HEADERS32                 PIMAGE_NT_HEADERS;
     
376. #endif
     
377. 
     
378. // IMAGE_FIRST_SECTION doesn't need 32/64 versions since the file header is the same either way.
     
379. 
     
380. #define IMAGE_FIRST_SECTION( ntheader ) ((PIMAGE_SECTION_HEADER)        \
     
381.     ((ULONG_PTR)ntheader +                                              \
     
382.      FIELD_OFFSET( IMAGE_NT_HEADERS, OptionalHeader ) +                 \
     
383.      ((PIMAGE_NT_HEADERS)(ntheader))->FileHeader.SizeOfOptionalHeader   \
     
384.     ))
     
385. 
     
386. // Subsystem Values
     
387. 
     
388. #define IMAGE_SUBSYSTEM_UNKNOWN              0   // Unknown subsystem.
     
389. #define IMAGE_SUBSYSTEM_NATIVE               1   // Image doesn't require a subsystem.
     
390. #define IMAGE_SUBSYSTEM_WINDOWS_GUI          2   // Image runs in the Windows GUI subsystem.
     
391. #define IMAGE_SUBSYSTEM_WINDOWS_CUI          3   // Image runs in the Windows character subsystem.
     
392. // end_winnt
     
393. // reserved                                  4   // Old Windows CE subsystem.
     
394. // begin_winnt
     
395. #define IMAGE_SUBSYSTEM_OS2_CUI              5   // image runs in the OS/2 character subsystem.
     
396. #define IMAGE_SUBSYSTEM_POSIX_CUI            7   // image runs in the Posix character subsystem.
     
397. #define IMAGE_SUBSYSTEM_NATIVE_WINDOWS       8   // image is a native Win9x driver.
     
398. #define IMAGE_SUBSYSTEM_WINDOWS_CE_GUI       9   // Image runs in the Windows CE subsystem.
     
399. #define IMAGE_SUBSYSTEM_EFI_APPLICATION      10  //
     
400. #define IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER  11   //
     
401. #define IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER   12  //
     
402. #define IMAGE_SUBSYSTEM_EFI_ROM              13
     
403. #define IMAGE_SUBSYSTEM_XBOX                 14
     
404. 
     
405. // DllCharacteristics Entries
     
406. 
     
407. //      IMAGE_LIBRARY_PROCESS_INIT           0x0001     // Reserved.
     
408. //      IMAGE_LIBRARY_PROCESS_TERM           0x0002     // Reserved.
     
409. //      IMAGE_LIBRARY_THREAD_INIT            0x0004     // Reserved.
     
410. //      IMAGE_LIBRARY_THREAD_TERM            0x0008     // Reserved.
     
411. #define IMAGE_DLLCHARACTERISTICS_NO_ISOLATION 0x0200    // Image understands isolation and doesn't want it
     
412. #define IMAGE_DLLCHARACTERISTICS_NO_SEH      0x0400     // Image does not use SEH.  No SE handler may reside in this image
     
413. #define IMAGE_DLLCHARACTERISTICS_NO_BIND     0x0800     // Do not bind this image.
     
414. //                                           0x1000     // Reserved.
     
415. #define IMAGE_DLLCHARACTERISTICS_WDM_DRIVER  0x2000     // Driver uses WDM model
     
416. //                                           0x4000     // Reserved.
     
417. #define IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE     0x8000
     
418. // end_winnt
     
419. #define IMAGE_DLLCHARACTERISTICS_X86_THUNK   0x1000 // Image is a Wx86 Thunk DLL
     
420. // Note: The Borland linker sets IMAGE_LIBRARY_xxx flags in DllCharacteristics
     
421. 
     
422. // LoaderFlags Values
     
423. 
     
424. #define IMAGE_LOADER_FLAGS_COMPLUS             0x00000001   // COM+ image
     
425. #define IMAGE_LOADER_FLAGS_SYSTEM_GLOBAL       0x01000000   // Global subsections apply across TS sessions.
     
426. 
     
427. // begin_winnt
     
428. 
     
429. // Directory Entries
     
430. 
     
431. #define IMAGE_DIRECTORY_ENTRY_EXPORT          0   // Export Directory
     
432. #define IMAGE_DIRECTORY_ENTRY_IMPORT          1   // Import Directory
     
433. #define IMAGE_DIRECTORY_ENTRY_RESOURCE        2   // Resource Directory
     
434. #define IMAGE_DIRECTORY_ENTRY_EXCEPTION       3   // Exception Directory
     
435. #define IMAGE_DIRECTORY_ENTRY_SECURITY        4   // Security Directory
     
436. #define IMAGE_DIRECTORY_ENTRY_BASERELOC       5   // Base Relocation Table
     
437. #define IMAGE_DIRECTORY_ENTRY_DEBUG           6   // Debug Directory
     
438. //      IMAGE_DIRECTORY_ENTRY_COPYRIGHT       7   // (X86 usage)
     
439. #define IMAGE_DIRECTORY_ENTRY_ARCHITECTURE    7   // Architecture Specific Data
     
440. #define IMAGE_DIRECTORY_ENTRY_GLOBALPTR       8   // RVA of GP
     
441. #define IMAGE_DIRECTORY_ENTRY_TLS             9   // TLS Directory
     
442. #define IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG    10   // Load Configuration Directory
     
443. #define IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT   11   // Bound Import Directory in headers
     
444. #define IMAGE_DIRECTORY_ENTRY_IAT            12   // Import Address Table
     
445. #define IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT   13   // Delay Load Import Descriptors
     
446. #define IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR 14   // COM Runtime descriptor
     
447. 
     
448. //
     
449. // Non-COFF Object file header
     
450. //
     
451. 
     
452. typedef struct ANON_OBJECT_HEADER {
     
453.     USHORT  Sig1;            // Must be IMAGE_FILE_MACHINE_UNKNOWN
     
454.     USHORT  Sig2;            // Must be 0xffff
     
455.     USHORT  Version;         // >= 1 (implies the CLSID field is present)
     
456.     USHORT  Machine;
     
457.     ULONG   TimeDateStamp;
     
458.     CLSID   ClassID;         // Used to invoke CoCreateInstance
     
459.     ULONG   SizeOfData;      // Size of data that follows the header
     
460. } ANON_OBJECT_HEADER;
     
461. 
     
462. //
     
463. // Section header format.
     
464. //
     
465. 
     
466. #define IMAGE_SIZEOF_SHORT_NAME              8
     
467. 
     
468. typedef struct _IMAGE_SECTION_HEADER {
     
469.     UCHAR   Name[IMAGE_SIZEOF_SHORT_NAME];
     
470.     union {
     
471.             ULONG   PhysicalAddress;
     
472.             ULONG   VirtualSize;
     
473.     } Misc;
     
474.     ULONG   VirtualAddress;
     
475.     ULONG   SizeOfRawData;
     
476.     ULONG   PointerToRawData;
     
477.     ULONG   PointerToRelocations;
     
478.     ULONG   PointerToLinenumbers;
     
479.     USHORT  NumberOfRelocations;
     
480.     USHORT  NumberOfLinenumbers;
     
481.     ULONG   Characteristics;
     
482. } IMAGE_SECTION_HEADER, *PIMAGE_SECTION_HEADER;
     
483. 
     
484. #define IMAGE_SIZEOF_SECTION_HEADER          40
     
485. 
     
486. //
     
487. // Section characteristics.
     
488. //
     
489. //      IMAGE_SCN_TYPE_REG                   0x00000000  // Reserved.
     
490. //      IMAGE_SCN_TYPE_DSECT                 0x00000001  // Reserved.
     
491. //      IMAGE_SCN_TYPE_NOLOAD                0x00000002  // Reserved.
     
492. //      IMAGE_SCN_TYPE_GROUP                 0x00000004  // Reserved.
     
493. #define IMAGE_SCN_TYPE_NO_PAD                0x00000008  // Reserved.
     
494. //      IMAGE_SCN_TYPE_COPY                  0x00000010  // Reserved.
     
495. 
     
496. #define IMAGE_SCN_CNT_CODE                   0x00000020  // Section contains code.
     
497. #define IMAGE_SCN_CNT_INITIALIZED_DATA       0x00000040  // Section contains initialized data.
     
498. #define IMAGE_SCN_CNT_UNINITIALIZED_DATA     0x00000080  // Section contains uninitialized data.
     
499. 
     
500. #define IMAGE_SCN_LNK_OTHER                  0x00000100  // Reserved.
     
501. #define IMAGE_SCN_LNK_INFO                   0x00000200  // Section contains comments or some other type of information.
     
502. //      IMAGE_SCN_TYPE_OVER                  0x00000400  // Reserved.
     
503. #define IMAGE_SCN_LNK_REMOVE                 0x00000800  // Section contents will not become part of image.
     
504. #define IMAGE_SCN_LNK_COMDAT                 0x00001000  // Section contents comdat.
     
505. //                                           0x00002000  // Reserved.
     
506. //      IMAGE_SCN_MEM_PROTECTED - Obsolete   0x00004000
     
507. #define IMAGE_SCN_NO_DEFER_SPEC_EXC          0x00004000  // Reset speculative exceptions handling bits in the TLB entries for this section.
     
508. #define IMAGE_SCN_GPREL                      0x00008000  // Section content can be accessed relative to GP
     
509. #define IMAGE_SCN_MEM_FARDATA                0x00008000
     
510. //      IMAGE_SCN_MEM_SYSHEAP  - Obsolete    0x00010000
     
511. #define IMAGE_SCN_MEM_PURGEABLE              0x00020000
     
512. #define IMAGE_SCN_MEM_16BIT                  0x00020000
     
513. #define IMAGE_SCN_MEM_LOCKED                 0x00040000
     
514. #define IMAGE_SCN_MEM_PRELOAD                0x00080000
     
515. 
     
516. #define IMAGE_SCN_ALIGN_1BYTES               0x00100000  //
     
517. #define IMAGE_SCN_ALIGN_2BYTES               0x00200000  //
     
518. #define IMAGE_SCN_ALIGN_4BYTES               0x00300000  //
     
519. #define IMAGE_SCN_ALIGN_8BYTES               0x00400000  //
     
520. #define IMAGE_SCN_ALIGN_16BYTES              0x00500000  // Default alignment if no others are specified.
     
521. #define IMAGE_SCN_ALIGN_32BYTES              0x00600000  //
     
522. #define IMAGE_SCN_ALIGN_64BYTES              0x00700000  //
     
523. #define IMAGE_SCN_ALIGN_128BYTES             0x00800000  //
     
524. #define IMAGE_SCN_ALIGN_256BYTES             0x00900000  //
     
525. #define IMAGE_SCN_ALIGN_512BYTES             0x00A00000  //
     
526. #define IMAGE_SCN_ALIGN_1024BYTES            0x00B00000  //
     
527. #define IMAGE_SCN_ALIGN_2048BYTES            0x00C00000  //
     
528. #define IMAGE_SCN_ALIGN_4096BYTES            0x00D00000  //
     
529. #define IMAGE_SCN_ALIGN_8192BYTES            0x00E00000  //
     
530. // Unused                                    0x00F00000
     
531. #define IMAGE_SCN_ALIGN_MASK                 0x00F00000
     
532. 
     
533. #define IMAGE_SCN_LNK_NRELOC_OVFL            0x01000000  // Section contains extended relocations.
     
534. #define IMAGE_SCN_MEM_DISCARDABLE            0x02000000  // Section can be discarded.
     
535. #define IMAGE_SCN_MEM_NOT_CACHED             0x04000000  // Section is not cachable.
     
536. #define IMAGE_SCN_MEM_NOT_PAGED              0x08000000  // Section is not pageable.
     
537. #define IMAGE_SCN_MEM_SHARED                 0x10000000  // Section is shareable.
     
538. #define IMAGE_SCN_MEM_EXECUTE                0x20000000  // Section is executable.
     
539. #define IMAGE_SCN_MEM_READ                   0x40000000  // Section is readable.
     
540. #define IMAGE_SCN_MEM_WRITE                  0x80000000  // Section is writeable.
     
541. 
     
542. //
     
543. // TLS Characteristic Flags
     
544. //
     
545. #define IMAGE_SCN_SCALE_INDEX                0x00000001  // Tls index is scaled
     
546. 
     
547. #include "pshpack2.h"                       // Symbols, relocs, and linenumbers are 2 byte packed
     
548. 
     
549. //
     
550. // Symbol format.
     
551. //
     
552. 
     
553. typedef struct _IMAGE_SYMBOL {
     
554.     union {
     
555.         UCHAR   ShortName[8];
     
556.         struct {
     
557.             ULONG   Short;     // if 0, use LongName
     
558.             ULONG   Long;      // offset into string table
     
559.         } Name;
     
560.         ULONG   LongName[2];    // PUCHAR[2]
     
561.     } N;
     
562.     ULONG   Value;
     
563.     SHORT   SectionNumber;
     
564.     USHORT  Type;
     
565.     UCHAR   StorageClass;
     
566.     UCHAR   NumberOfAuxSymbols;
     
567. } IMAGE_SYMBOL;
     
568. typedef IMAGE_SYMBOL UNALIGNED *PIMAGE_SYMBOL;
     
569. 
     
570. 
     
571. #define IMAGE_SIZEOF_SYMBOL                  18
     
572. 
     
573. //
     
574. // Section values.
     
575. //
     
576. // Symbols have a section number of the section in which they are
     
577. // defined. Otherwise, section numbers have the following meanings:
     
578. //
     
579. 
     
580. #define IMAGE_SYM_UNDEFINED           (SHORT)0          // Symbol is undefined or is common.
     
581. #define IMAGE_SYM_ABSOLUTE            (SHORT)-1         // Symbol is an absolute value.
     
582. #define IMAGE_SYM_DEBUG               (SHORT)-2         // Symbol is a special debug item.
     
583. #define IMAGE_SYM_SECTION_MAX         0xFEFF            // Values 0xFF00-0xFFFF are special
     
584. 
     
585. //
     
586. // Type (fundamental) values.
     
587. //
     
588. 
     
589. #define IMAGE_SYM_TYPE_NULL                 0x0000  // no type.
     
590. #define IMAGE_SYM_TYPE_VOID                 0x0001  //
     
591. #define IMAGE_SYM_TYPE_CHAR                 0x0002  // type character.
     
592. #define IMAGE_SYM_TYPE_SHORT                0x0003  // type short integer.
     
593. #define IMAGE_SYM_TYPE_INT                  0x0004  //
     
594. #define IMAGE_SYM_TYPE_LONG                 0x0005  //
     
595. #define IMAGE_SYM_TYPE_FLOAT                0x0006  //
     
596. #define IMAGE_SYM_TYPE_DOUBLE               0x0007  //
     
597. #define IMAGE_SYM_TYPE_STRUCT               0x0008  //
     
598. #define IMAGE_SYM_TYPE_UNION                0x0009  //
     
599. #define IMAGE_SYM_TYPE_ENUM                 0x000A  // enumeration.
     
600. #define IMAGE_SYM_TYPE_MOE                  0x000B  // member of enumeration.
     
601. #define IMAGE_SYM_TYPE_UCHAR                0x000C  //
     
602. #define IMAGE_SYM_TYPE_USHORT               0x000D  //
     
603. #define IMAGE_SYM_TYPE_UINT                 0x000E  //
     
604. #define IMAGE_SYM_TYPE_ULONG                0x000F  //
     
605. #define IMAGE_SYM_TYPE_PCODE                0x8000  //
     
606. //
     
607. // Type (derived) values.
     
608. //
     
609. 
     
610. #define IMAGE_SYM_DTYPE_NULL                0       // no derived type.
     
611. #define IMAGE_SYM_DTYPE_POINTER             1       // pointer.
     
612. #define IMAGE_SYM_DTYPE_FUNCTION            2       // function.
     
613. #define IMAGE_SYM_DTYPE_ARRAY               3       // array.
     
614. 
     
615. //
     
616. // Storage classes.
     
617. //
     
618. #define IMAGE_SYM_CLASS_END_OF_FUNCTION     (UCHAR)-1
     
619. #define IMAGE_SYM_CLASS_NULL                0x0000
     
620. #define IMAGE_SYM_CLASS_AUTOMATIC           0x0001
     
621. #define IMAGE_SYM_CLASS_EXTERNAL            0x0002
     
622. #define IMAGE_SYM_CLASS_STATIC              0x0003
     
623. #define IMAGE_SYM_CLASS_REGISTER            0x0004
     
624. #define IMAGE_SYM_CLASS_EXTERNAL_DEF        0x0005
     
625. #define IMAGE_SYM_CLASS_LABEL               0x0006
     
626. #define IMAGE_SYM_CLASS_UNDEFINED_LABEL     0x0007
     
627. #define IMAGE_SYM_CLASS_MEMBER_OF_STRUCT    0x0008
     
628. #define IMAGE_SYM_CLASS_ARGUMENT            0x0009
     
629. #define IMAGE_SYM_CLASS_STRUCT_TAG          0x000A
     
630. #define IMAGE_SYM_CLASS_MEMBER_OF_UNION     0x000B
     
631. #define IMAGE_SYM_CLASS_UNION_TAG           0x000C
     
632. #define IMAGE_SYM_CLASS_TYPE_DEFINITION     0x000D
     
633. #define IMAGE_SYM_CLASS_UNDEFINED_STATIC    0x000E
     
634. #define IMAGE_SYM_CLASS_ENUM_TAG            0x000F
     
635. #define IMAGE_SYM_CLASS_MEMBER_OF_ENUM      0x0010
     
636. #define IMAGE_SYM_CLASS_REGISTER_PARAM      0x0011
     
637. #define IMAGE_SYM_CLASS_BIT_FIELD           0x0012
     
638. 
     
639. #define IMAGE_SYM_CLASS_FAR_EXTERNAL        0x0044  //
     
640. 
     
641. #define IMAGE_SYM_CLASS_BLOCK               0x0064
     
642. #define IMAGE_SYM_CLASS_FUNCTION            0x0065
     
643. #define IMAGE_SYM_CLASS_END_OF_STRUCT       0x0066
     
644. #define IMAGE_SYM_CLASS_FILE                0x0067
     
645. // new
     
646. #define IMAGE_SYM_CLASS_SECTION             0x0068
     
647. #define IMAGE_SYM_CLASS_WEAK_EXTERNAL       0x0069
     
648. 
     
649. #define IMAGE_SYM_CLASS_CLR_TOKEN           0x006B
     
650. 
     
651. // type packing constants
     
652. 
     
653. #define N_BTMASK                            0x000F
     
654. #define N_TMASK                             0x0030
     
655. #define N_TMASK1                            0x00C0
     
656. #define N_TMASK2                            0x00F0
     
657. #define N_BTSHFT                            4
     
658. #define N_TSHIFT                            2
     
659. // MACROS
     
660. 
     
661. // Basic Type of  x
     
662. #define BTYPE(x) ((x) & N_BTMASK)
     
663. 
     
664. // Is x a pointer?
     
665. #ifndef ISPTR
     
666. #define ISPTR(x) (((x) & N_TMASK) == (IMAGE_SYM_DTYPE_POINTER << N_BTSHFT))
     
667. #endif
     
668. 
     
669. // Is x a function?
     
670. #ifndef ISFCN
     
671. #define ISFCN(x) (((x) & N_TMASK) == (IMAGE_SYM_DTYPE_FUNCTION << N_BTSHFT))
     
672. #endif
     
673. 
     
674. // Is x an array?
     
675. 
     
676. #ifndef ISARY
     
677. #define ISARY(x) (((x) & N_TMASK) == (IMAGE_SYM_DTYPE_ARRAY << N_BTSHFT))
     
678. #endif
     
679. 
     
680. // Is x a structure, union, or enumeration TAG?
     
681. #ifndef ISTAG
     
682. #define ISTAG(x) ((x)==IMAGE_SYM_CLASS_STRUCT_TAG || (x)==IMAGE_SYM_CLASS_UNION_TAG || (x)==IMAGE_SYM_CLASS_ENUM_TAG)
     
683. #endif
     
684. 
     
685. #ifndef INCREF
     
686. #define INCREF(x) ((((x)&~N_BTMASK)<<N_TSHIFT)|(IMAGE_SYM_DTYPE_POINTER<<N_BTSHFT)|((x)&N_BTMASK))
     
687. #endif
     
688. #ifndef DECREF
     
689. #define DECREF(x) ((((x)>>N_TSHIFT)&~N_BTMASK)|((x)&N_BTMASK))
     
690. #endif
     
691. 
     
692. //
     
693. // Auxiliary entry format.
     
694. //
     
695. 
     
696. typedef union _IMAGE_AUX_SYMBOL {
     
697.     struct {
     
698.         ULONG    TagIndex;                      // struct, union, or enum tag index
     
699.         union {
     
700.             struct {
     
701.                 USHORT  Linenumber;             // declaration line number
     
702.                 USHORT  Size;                   // size of struct, union, or enum
     
703.             } LnSz;
     
704.            ULONG    TotalSize;
     
705.         } Misc;
     
706.         union {
     
707.             struct {                            // if ISFCN, tag, or .bb
     
708.                 ULONG    PointerToLinenumber;
     
709.                 ULONG    PointerToNextFunction;
     
710.             } Function;
     
711.             struct {                            // if ISARY, up to 4 dimen.
     
712.                 USHORT   Dimension[4];
     
713.             } Array;
     
714.         } FcnAry;
     
715.         USHORT  TvIndex;                        // tv index
     
716.     } Sym;
     
717.     struct {
     
718.         UCHAR   Name[IMAGE_SIZEOF_SYMBOL];
     
719.     } File;
     
720.     struct {
     
721.         ULONG   Length;                         // section length
     
722.         USHORT  NumberOfRelocations;            // number of relocation entries
     
723.         USHORT  NumberOfLinenumbers;            // number of line numbers
     
724.         ULONG   CheckSum;                       // checksum for communal
     
725.         SHORT   Number;                         // section number to associate with
     
726.         UCHAR   Selection;                      // communal selection type
     
727.     } Section;
     
728. } IMAGE_AUX_SYMBOL;
     
729. typedef IMAGE_AUX_SYMBOL UNALIGNED *PIMAGE_AUX_SYMBOL;
     
730. 
     
731. #define IMAGE_SIZEOF_AUX_SYMBOL             18
     
732. 
     
733. typedef enum IMAGE_AUX_SYMBOL_TYPE {
     
734.     IMAGE_AUX_SYMBOL_TYPE_TOKEN_DEF = 1,
     
735. } IMAGE_AUX_SYMBOL_TYPE;
     
736. 
     
737. #include <pshpack2.h>
     
738. 
     
739. typedef struct IMAGE_AUX_SYMBOL_TOKEN_DEF {
     
740.     UCHAR bAuxType;                  // IMAGE_AUX_SYMBOL_TYPE
     
741.     UCHAR bReserved;                 // Must be 0
     
742.     ULONG SymbolTableIndex;
     
743.     UCHAR rgbReserved[12];           // Must be 0
     
744. } IMAGE_AUX_SYMBOL_TOKEN_DEF;
     
745. 
     
746. typedef IMAGE_AUX_SYMBOL_TOKEN_DEF UNALIGNED *PIMAGE_AUX_SYMBOL_TOKEN_DEF;
     
747. 
     
748. #include <poppack.h>
     
749. 
     
750. //
     
751. // Communal selection types.
     
752. //
     
753. 
     
754. #define IMAGE_COMDAT_SELECT_NODUPLICATES    1
     
755. #define IMAGE_COMDAT_SELECT_ANY             2
     
756. #define IMAGE_COMDAT_SELECT_SAME_SIZE       3
     
757. #define IMAGE_COMDAT_SELECT_EXACT_MATCH     4
     
758. #define IMAGE_COMDAT_SELECT_ASSOCIATIVE     5
     
759. #define IMAGE_COMDAT_SELECT_LARGEST         6
     
760. #define IMAGE_COMDAT_SELECT_NEWEST          7
     
761. 
     
762. #define IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY  1
     
763. #define IMAGE_WEAK_EXTERN_SEARCH_LIBRARY    2
     
764. #define IMAGE_WEAK_EXTERN_SEARCH_ALIAS      3
     
765. 
     
766. //
     
767. // Relocation format.
     
768. //
     
769. 
     
770. typedef struct _IMAGE_RELOCATION {
     
771.     union {
     
772.         ULONG   VirtualAddress;
     
773.         ULONG   RelocCount;             // Set to the real count when IMAGE_SCN_LNK_NRELOC_OVFL is set
     
774.     };
     
775.     ULONG   SymbolTableIndex;
     
776.     USHORT  Type;
     
777. } IMAGE_RELOCATION;
     
778. typedef IMAGE_RELOCATION UNALIGNED *PIMAGE_RELOCATION;
     
779. 
     
780. #define IMAGE_SIZEOF_RELOCATION         10
     
781. 
     
782. //
     
783. // I386 relocation types.
     
784. //
     
785. #define IMAGE_REL_I386_ABSOLUTE         0x0000  // Reference is absolute, no relocation is necessary
     
786. #define IMAGE_REL_I386_DIR16            0x0001  // Direct 16-bit reference to the symbols virtual address
     
787. #define IMAGE_REL_I386_REL16            0x0002  // PC-relative 16-bit reference to the symbols virtual address
     
788. #define IMAGE_REL_I386_DIR32            0x0006  // Direct 32-bit reference to the symbols virtual address
     
789. #define IMAGE_REL_I386_DIR32NB          0x0007  // Direct 32-bit reference to the symbols virtual address, base not included
     
790. #define IMAGE_REL_I386_SEG12            0x0009  // Direct 16-bit reference to the segment-selector bits of a 32-bit virtual address
     
791. #define IMAGE_REL_I386_SECTION          0x000A
     
792. #define IMAGE_REL_I386_SECREL           0x000B
     
793. #define IMAGE_REL_I386_TOKEN            0x000C  // clr token
     
794. #define IMAGE_REL_I386_SECREL7          0x000D  // 7 bit offset from base of section containing target
     
795. #define IMAGE_REL_I386_REL32            0x0014  // PC-relative 32-bit reference to the symbols virtual address
     
796. 
     
797. //
     
798. // MIPS relocation types.
     
799. //
     
800. #define IMAGE_REL_MIPS_ABSOLUTE         0x0000  // Reference is absolute, no relocation is necessary
     
801. #define IMAGE_REL_MIPS_REFHALF          0x0001
     
802. #define IMAGE_REL_MIPS_REFWORD          0x0002
     
803. #define IMAGE_REL_MIPS_JMPADDR          0x0003
     
804. #define IMAGE_REL_MIPS_REFHI            0x0004
     
805. #define IMAGE_REL_MIPS_REFLO            0x0005
     
806. #define IMAGE_REL_MIPS_GPREL            0x0006
     
807. #define IMAGE_REL_MIPS_LITERAL          0x0007
     
808. #define IMAGE_REL_MIPS_SECTION          0x000A
     
809. #define IMAGE_REL_MIPS_SECREL           0x000B
     
810. #define IMAGE_REL_MIPS_SECRELLO         0x000C  // Low 16-bit section relative reference (used for >32k TLS)
     
811. #define IMAGE_REL_MIPS_SECRELHI         0x000D  // High 16-bit section relative reference (used for >32k TLS)
     
812. #define IMAGE_REL_MIPS_TOKEN            0x000E  // clr token
     
813. #define IMAGE_REL_MIPS_JMPADDR16        0x0010
     
814. #define IMAGE_REL_MIPS_REFWORDNB        0x0022
     
815. #define IMAGE_REL_MIPS_PAIR             0x0025
     
816. 
     
817. //
     
818. // Alpha Relocation types.
     
819. //
     
820. #define IMAGE_REL_ALPHA_ABSOLUTE        0x0000
     
821. #define IMAGE_REL_ALPHA_REFLONG         0x0001
     
822. #define IMAGE_REL_ALPHA_REFQUAD         0x0002
     
823. #define IMAGE_REL_ALPHA_GPREL32         0x0003
     
824. #define IMAGE_REL_ALPHA_LITERAL         0x0004
     
825. #define IMAGE_REL_ALPHA_LITUSE          0x0005
     
826. #define IMAGE_REL_ALPHA_GPDISP          0x0006
     
827. #define IMAGE_REL_ALPHA_BRADDR          0x0007
     
828. #define IMAGE_REL_ALPHA_HINT            0x0008
     
829. #define IMAGE_REL_ALPHA_INLINE_REFLONG  0x0009
     
830. #define IMAGE_REL_ALPHA_REFHI           0x000A
     
831. #define IMAGE_REL_ALPHA_REFLO           0x000B
     
832. #define IMAGE_REL_ALPHA_PAIR            0x000C
     
833. #define IMAGE_REL_ALPHA_MATCH           0x000D
     
834. #define IMAGE_REL_ALPHA_SECTION         0x000E
     
835. #define IMAGE_REL_ALPHA_SECREL          0x000F
     
836. #define IMAGE_REL_ALPHA_REFLONGNB       0x0010
     
837. #define IMAGE_REL_ALPHA_SECRELLO        0x0011  // Low 16-bit section relative reference
     
838. #define IMAGE_REL_ALPHA_SECRELHI        0x0012  // High 16-bit section relative reference
     
839. #define IMAGE_REL_ALPHA_REFQ3           0x0013  // High 16 bits of 48 bit reference
     
840. #define IMAGE_REL_ALPHA_REFQ2           0x0014  // Middle 16 bits of 48 bit reference
     
841. #define IMAGE_REL_ALPHA_REFQ1           0x0015  // Low 16 bits of 48 bit reference
     
842. #define IMAGE_REL_ALPHA_GPRELLO         0x0016  // Low 16-bit GP relative reference
     
843. #define IMAGE_REL_ALPHA_GPRELHI         0x0017  // High 16-bit GP relative reference
     
844. 
     
845. //
     
846. // IBM PowerPC relocation types.
     
847. //
     
848. #define IMAGE_REL_PPC_ABSOLUTE          0x0000  // NOP
     
849. #define IMAGE_REL_PPC_ADDR64            0x0001  // 64-bit address
     
850. #define IMAGE_REL_PPC_ADDR32            0x0002  // 32-bit address
     
851. #define IMAGE_REL_PPC_ADDR24            0x0003  // 26-bit address, shifted left 2 (branch absolute)
     
852. #define IMAGE_REL_PPC_ADDR16            0x0004  // 16-bit address
     
853. #define IMAGE_REL_PPC_ADDR14            0x0005  // 16-bit address, shifted left 2 (load doubleword)
     
854. #define IMAGE_REL_PPC_REL24             0x0006  // 26-bit PC-relative offset, shifted left 2 (branch relative)
     
855. #define IMAGE_REL_PPC_REL14             0x0007  // 16-bit PC-relative offset, shifted left 2 (br cond relative)
     
856. #define IMAGE_REL_PPC_TOCREL16          0x0008  // 16-bit offset from TOC base
     
857. #define IMAGE_REL_PPC_TOCREL14          0x0009  // 16-bit offset from TOC base, shifted left 2 (load doubleword)
     
858. 
     
859. #define IMAGE_REL_PPC_ADDR32NB          0x000A  // 32-bit addr w/o image base
     
860. #define IMAGE_REL_PPC_SECREL            0x000B  // va of containing section (as in an image sectionhdr)
     
861. #define IMAGE_REL_PPC_SECTION           0x000C  // sectionheader number
     
862. #define IMAGE_REL_PPC_IFGLUE            0x000D  // substitute TOC restore instruction iff symbol is glue code
     
863. #define IMAGE_REL_PPC_IMGLUE            0x000E  // symbol is glue code; virtual address is TOC restore instruction
     
864. #define IMAGE_REL_PPC_SECREL16          0x000F  // va of containing section (limited to 16 bits)
     
865. #define IMAGE_REL_PPC_REFHI             0x0010
     
866. #define IMAGE_REL_PPC_REFLO             0x0011
     
867. #define IMAGE_REL_PPC_PAIR              0x0012
     
868. #define IMAGE_REL_PPC_SECRELLO          0x0013  // Low 16-bit section relative reference (used for >32k TLS)
     
869. #define IMAGE_REL_PPC_SECRELHI          0x0014  // High 16-bit section relative reference (used for >32k TLS)
     
870. #define IMAGE_REL_PPC_GPREL             0x0015
     
871. #define IMAGE_REL_PPC_TOKEN             0x0016  // clr token
     
872. 
     
873. #define IMAGE_REL_PPC_TYPEMASK          0x00FF  // mask to isolate above values in IMAGE_RELOCATION.Type
     
874. 
     
875. // Flag bits in IMAGE_RELOCATION.TYPE
     
876. 
     
877. #define IMAGE_REL_PPC_NEG               0x0100  // subtract reloc value rather than adding it
     
878. #define IMAGE_REL_PPC_BRTAKEN           0x0200  // fix branch prediction bit to predict branch taken
     
879. #define IMAGE_REL_PPC_BRNTAKEN          0x0400  // fix branch prediction bit to predict branch not taken
     
880. #define IMAGE_REL_PPC_TOCDEFN           0x0800  // toc slot defined in file (or, data in toc)
     
881. 
     
882. //
     
883. // Hitachi SH3 relocation types.
     
884. //
     
885. #define IMAGE_REL_SH3_ABSOLUTE          0x0000  // No relocation
     
886. #define IMAGE_REL_SH3_DIRECT16          0x0001  // 16 bit direct
     
887. #define IMAGE_REL_SH3_DIRECT32          0x0002  // 32 bit direct
     
888. #define IMAGE_REL_SH3_DIRECT8           0x0003  // 8 bit direct, -128..255
     
889. #define IMAGE_REL_SH3_DIRECT8_WORD      0x0004  // 8 bit direct .W (0 ext.)
     
890. #define IMAGE_REL_SH3_DIRECT8_LONG      0x0005  // 8 bit direct .L (0 ext.)
     
891. #define IMAGE_REL_SH3_DIRECT4           0x0006  // 4 bit direct (0 ext.)
     
892. #define IMAGE_REL_SH3_DIRECT4_WORD      0x0007  // 4 bit direct .W (0 ext.)
     
893. #define IMAGE_REL_SH3_DIRECT4_LONG      0x0008  // 4 bit direct .L (0 ext.)
     
894. #define IMAGE_REL_SH3_PCREL8_WORD       0x0009  // 8 bit PC relative .W
     
895. #define IMAGE_REL_SH3_PCREL8_LONG       0x000A  // 8 bit PC relative .L
     
896. #define IMAGE_REL_SH3_PCREL12_WORD      0x000B  // 12 LSB PC relative .W
     
897. #define IMAGE_REL_SH3_STARTOF_SECTION   0x000C  // Start of EXE section
     
898. #define IMAGE_REL_SH3_SIZEOF_SECTION    0x000D  // Size of EXE section
     
899. #define IMAGE_REL_SH3_SECTION           0x000E  // Section table index
     
900. #define IMAGE_REL_SH3_SECREL            0x000F  // Offset within section
     
901. #define IMAGE_REL_SH3_DIRECT32_NB       0x0010  // 32 bit direct not based
     
902. #define IMAGE_REL_SH3_GPREL4_LONG       0x0011  // GP-relative addressing
     
903. #define IMAGE_REL_SH3_TOKEN             0x0012  // clr token
     
904. 
     
905. #define IMAGE_REL_ARM_ABSOLUTE          0x0000  // No relocation required
     
906. #define IMAGE_REL_ARM_ADDR32            0x0001  // 32 bit address
     
907. #define IMAGE_REL_ARM_ADDR32NB          0x0002  // 32 bit address w/o image base
     
908. #define IMAGE_REL_ARM_BRANCH24          0x0003  // 24 bit offset << 2 & sign ext.
     
909. #define IMAGE_REL_ARM_BRANCH11          0x0004  // Thumb: 2 11 bit offsets
     
910. #define IMAGE_REL_ARM_TOKEN             0x0005  // clr token
     
911. #define IMAGE_REL_ARM_GPREL12           0x0006  // GP-relative addressing (ARM)
     
912. #define IMAGE_REL_ARM_GPREL7            0x0007  // GP-relative addressing (Thumb)
     
913. #define IMAGE_REL_ARM_BLX24             0x0008
     
914. #define IMAGE_REL_ARM_BLX11             0x0009
     
915. #define IMAGE_REL_ARM_SECTION           0x000E  // Section table index
     
916. #define IMAGE_REL_ARM_SECREL            0x000F  // Offset within section
     
917. 
     
918. #define IMAGE_REL_AM_ABSOLUTE           0x0000
     
919. #define IMAGE_REL_AM_ADDR32             0x0001
     
920. #define IMAGE_REL_AM_ADDR32NB           0x0002
     
921. #define IMAGE_REL_AM_CALL32             0x0003
     
922. #define IMAGE_REL_AM_FUNCINFO           0x0004
     
923. #define IMAGE_REL_AM_REL32_1            0x0005
     
924. #define IMAGE_REL_AM_REL32_2            0x0006
     
925. #define IMAGE_REL_AM_SECREL             0x0007
     
926. #define IMAGE_REL_AM_SECTION            0x0008
     
927. #define IMAGE_REL_AM_TOKEN              0x0009
     
928. 
     
929. //
     
930. // x64 relocations
     
931. //
     
932. #define IMAGE_REL_AMD64_ABSOLUTE        0x0000  // Reference is absolute, no relocation is necessary
     
933. #define IMAGE_REL_AMD64_ADDR64          0x0001  // 64-bit address (VA).
     
934. #define IMAGE_REL_AMD64_ADDR32          0x0002  // 32-bit address (VA).
     
935. #define IMAGE_REL_AMD64_ADDR32NB        0x0003  // 32-bit address w/o image base (RVA).
     
936. #define IMAGE_REL_AMD64_REL32           0x0004  // 32-bit relative address from byte following reloc
     
937. #define IMAGE_REL_AMD64_REL32_1         0x0005  // 32-bit relative address from byte distance 1 from reloc
     
938. #define IMAGE_REL_AMD64_REL32_2         0x0006  // 32-bit relative address from byte distance 2 from reloc
     
939. #define IMAGE_REL_AMD64_REL32_3         0x0007  // 32-bit relative address from byte distance 3 from reloc
     
940. #define IMAGE_REL_AMD64_REL32_4         0x0008  // 32-bit relative address from byte distance 4 from reloc
     
941. #define IMAGE_REL_AMD64_REL32_5         0x0009  // 32-bit relative address from byte distance 5 from reloc
     
942. #define IMAGE_REL_AMD64_SECTION         0x000A  // Section index
     
943. #define IMAGE_REL_AMD64_SECREL          0x000B  // 32 bit offset from base of section containing target
     
944. #define IMAGE_REL_AMD64_SECREL7         0x000C  // 7 bit unsigned offset from base of section containing target
     
945. #define IMAGE_REL_AMD64_TOKEN           0x000D  // 32 bit metadata token
     
946. #define IMAGE_REL_AMD64_SREL32          0x000E  // 32 bit signed span-dependent value emitted into object
     
947. #define IMAGE_REL_AMD64_PAIR            0x000F
     
948. #define IMAGE_REL_AMD64_SSPAN32         0x0010  // 32 bit signed span-dependent value applied at link time
     
949. 
     
950. //
     
951. // IA64 relocation types.
     
952. //
     
953. #define IMAGE_REL_IA64_ABSOLUTE         0x0000
     
954. #define IMAGE_REL_IA64_IMM14            0x0001
     
955. #define IMAGE_REL_IA64_IMM22            0x0002
     
956. #define IMAGE_REL_IA64_IMM64            0x0003
     
957. #define IMAGE_REL_IA64_DIR32            0x0004
     
958. #define IMAGE_REL_IA64_DIR64            0x0005
     
959. #define IMAGE_REL_IA64_PCREL21B         0x0006
     
960. #define IMAGE_REL_IA64_PCREL21M         0x0007
     
961. #define IMAGE_REL_IA64_PCREL21F         0x0008
     
962. #define IMAGE_REL_IA64_GPREL22          0x0009
     
963. #define IMAGE_REL_IA64_LTOFF22          0x000A
     
964. #define IMAGE_REL_IA64_SECTION          0x000B
     
965. #define IMAGE_REL_IA64_SECREL22         0x000C
     
966. #define IMAGE_REL_IA64_SECREL64I        0x000D
     
967. #define IMAGE_REL_IA64_SECREL32         0x000E
     
968. //
     
969. #define IMAGE_REL_IA64_DIR32NB          0x0010
     
970. #define IMAGE_REL_IA64_SREL14           0x0011
     
971. #define IMAGE_REL_IA64_SREL22           0x0012
     
972. #define IMAGE_REL_IA64_SREL32           0x0013
     
973. #define IMAGE_REL_IA64_UREL32           0x0014
     
974. #define IMAGE_REL_IA64_PCREL60X         0x0015  // This is always a BRL and never converted
     
975. #define IMAGE_REL_IA64_PCREL60B         0x0016  // If possible, convert to MBB bundle with NOP.B in slot 1
     
976. #define IMAGE_REL_IA64_PCREL60F         0x0017  // If possible, convert to MFB bundle with NOP.F in slot 1
     
977. #define IMAGE_REL_IA64_PCREL60I         0x0018  // If possible, convert to MIB bundle with NOP.I in slot 1
     
978. #define IMAGE_REL_IA64_PCREL60M         0x0019  // If possible, convert to MMB bundle with NOP.M in slot 1
     
979. #define IMAGE_REL_IA64_IMMGPREL64       0x001A
     
980. #define IMAGE_REL_IA64_TOKEN            0x001B  // clr token
     
981. #define IMAGE_REL_IA64_GPREL32          0x001C
     
982. #define IMAGE_REL_IA64_ADDEND           0x001F
     
983. 
     
984. //
     
985. // CEF relocation types.
     
986. //
     
987. #define IMAGE_REL_CEF_ABSOLUTE          0x0000  // Reference is absolute, no relocation is necessary
     
988. #define IMAGE_REL_CEF_ADDR32            0x0001  // 32-bit address (VA).
     
989. #define IMAGE_REL_CEF_ADDR64            0x0002  // 64-bit address (VA).
     
990. #define IMAGE_REL_CEF_ADDR32NB          0x0003  // 32-bit address w/o image base (RVA).
     
991. #define IMAGE_REL_CEF_SECTION           0x0004  // Section index
     
992. #define IMAGE_REL_CEF_SECREL            0x0005  // 32 bit offset from base of section containing target
     
993. #define IMAGE_REL_CEF_TOKEN             0x0006  // 32 bit metadata token
     
994. 
     
995. //
     
996. // clr relocation types.
     
997. //
     
998. #define IMAGE_REL_CEE_ABSOLUTE          0x0000  // Reference is absolute, no relocation is necessary
     
999. #define IMAGE_REL_CEE_ADDR32            0x0001  // 32-bit address (VA).
     
1000. #define IMAGE_REL_CEE_ADDR64            0x0002  // 64-bit address (VA).
      
1001. #define IMAGE_REL_CEE_ADDR32NB          0x0003  // 32-bit address w/o image base (RVA).
      
1002. #define IMAGE_REL_CEE_SECTION           0x0004  // Section index
      
1003. #define IMAGE_REL_CEE_SECREL            0x0005  // 32 bit offset from base of section containing target
      
1004. #define IMAGE_REL_CEE_TOKEN             0x0006  // 32 bit metadata token
      
1005. 
      
1006. 
      
1007. #define IMAGE_REL_M32R_ABSOLUTE       0x0000   // No relocation required
      
1008. #define IMAGE_REL_M32R_ADDR32         0x0001   // 32 bit address
      
1009. #define IMAGE_REL_M32R_ADDR32NB       0x0002   // 32 bit address w/o image base
      
1010. #define IMAGE_REL_M32R_ADDR24         0x0003   // 24 bit address
      
1011. #define IMAGE_REL_M32R_GPREL16        0x0004   // GP relative addressing
      
1012. #define IMAGE_REL_M32R_PCREL24        0x0005   // 24 bit offset << 2 & sign ext.
      
1013. #define IMAGE_REL_M32R_PCREL16        0x0006   // 16 bit offset << 2 & sign ext.
      
1014. #define IMAGE_REL_M32R_PCREL8         0x0007   // 8 bit offset << 2 & sign ext.
      
1015. #define IMAGE_REL_M32R_REFHALF        0x0008   // 16 MSBs
      
1016. #define IMAGE_REL_M32R_REFHI          0x0009   // 16 MSBs; adj for LSB sign ext.
      
1017. #define IMAGE_REL_M32R_REFLO          0x000A   // 16 LSBs
      
1018. #define IMAGE_REL_M32R_PAIR           0x000B   // Link HI and LO
      
1019. #define IMAGE_REL_M32R_SECTION        0x000C   // Section table index
      
1020. #define IMAGE_REL_M32R_SECREL32       0x000D   // 32 bit section relative reference
      
1021. #define IMAGE_REL_M32R_TOKEN          0x000E   // clr token
      
1022. 
      
1023. 
      
1024. #define EXT_IMM64(Value, Address, Size, InstPos, ValPos)  /* Intel-IA64-Filler */           \
      
1025.     Value |= (((ULONGLONG)((*(Address) >> InstPos) & (((ULONGLONG)1 << Size) - 1))) << ValPos)  // Intel-IA64-Filler
      
1026. 
      
1027. #define INS_IMM64(Value, Address, Size, InstPos, ValPos)  /* Intel-IA64-Filler */\
      
1028.     *(PULONG)Address = (*(PULONG)Address & ~(((1 << Size) - 1) << InstPos)) | /* Intel-IA64-Filler */\
      
1029.           ((ULONG)((((ULONGLONG)Value >> ValPos) & (((ULONGLONG)1 << Size) - 1))) << InstPos)  // Intel-IA64-Filler
      
1030. 
      
1031. #define EMARCH_ENC_I17_IMM7B_INST_WORD_X         3  // Intel-IA64-Filler
      
1032. #define EMARCH_ENC_I17_IMM7B_SIZE_X              7  // Intel-IA64-Filler
      
1033. #define EMARCH_ENC_I17_IMM7B_INST_WORD_POS_X     4  // Intel-IA64-Filler
      
1034. #define EMARCH_ENC_I17_IMM7B_VAL_POS_X           0  // Intel-IA64-Filler
      
1035. 
      
1036. #define EMARCH_ENC_I17_IMM9D_INST_WORD_X         3  // Intel-IA64-Filler
      
1037. #define EMARCH_ENC_I17_IMM9D_SIZE_X              9  // Intel-IA64-Filler
      
1038. #define EMARCH_ENC_I17_IMM9D_INST_WORD_POS_X     18 // Intel-IA64-Filler
      
1039. #define EMARCH_ENC_I17_IMM9D_VAL_POS_X           7  // Intel-IA64-Filler
      
1040. 
      
1041. #define EMARCH_ENC_I17_IMM5C_INST_WORD_X         3  // Intel-IA64-Filler
      
1042. #define EMARCH_ENC_I17_IMM5C_SIZE_X              5  // Intel-IA64-Filler
      
1043. #define EMARCH_ENC_I17_IMM5C_INST_WORD_POS_X     13 // Intel-IA64-Filler
      
1044. #define EMARCH_ENC_I17_IMM5C_VAL_POS_X           16 // Intel-IA64-Filler
      
1045. 
      
1046. #define EMARCH_ENC_I17_IC_INST_WORD_X            3  // Intel-IA64-Filler
      
1047. #define EMARCH_ENC_I17_IC_SIZE_X                 1  // Intel-IA64-Filler
      
1048. #define EMARCH_ENC_I17_IC_INST_WORD_POS_X        12 // Intel-IA64-Filler
      
1049. #define EMARCH_ENC_I17_IC_VAL_POS_X              21 // Intel-IA64-Filler
      
1050. 
      
1051. #define EMARCH_ENC_I17_IMM41a_INST_WORD_X        1  // Intel-IA64-Filler
      
1052. #define EMARCH_ENC_I17_IMM41a_SIZE_X             10 // Intel-IA64-Filler
      
1053. #define EMARCH_ENC_I17_IMM41a_INST_WORD_POS_X    14 // Intel-IA64-Filler
      
1054. #define EMARCH_ENC_I17_IMM41a_VAL_POS_X          22 // Intel-IA64-Filler
      
1055. 
      
1056. #define EMARCH_ENC_I17_IMM41b_INST_WORD_X        1  // Intel-IA64-Filler
      
1057. #define EMARCH_ENC_I17_IMM41b_SIZE_X             8  // Intel-IA64-Filler
      
1058. #define EMARCH_ENC_I17_IMM41b_INST_WORD_POS_X    24 // Intel-IA64-Filler
      
1059. #define EMARCH_ENC_I17_IMM41b_VAL_POS_X          32 // Intel-IA64-Filler
      
1060. 
      
1061. #define EMARCH_ENC_I17_IMM41c_INST_WORD_X        2  // Intel-IA64-Filler
      
1062. #define EMARCH_ENC_I17_IMM41c_SIZE_X             23 // Intel-IA64-Filler
      
1063. #define EMARCH_ENC_I17_IMM41c_INST_WORD_POS_X    0  // Intel-IA64-Filler
      
1064. #define EMARCH_ENC_I17_IMM41c_VAL_POS_X          40 // Intel-IA64-Filler
      
1065. 
      
1066. #define EMARCH_ENC_I17_SIGN_INST_WORD_X          3  // Intel-IA64-Filler
      
1067. #define EMARCH_ENC_I17_SIGN_SIZE_X               1  // Intel-IA64-Filler
      
1068. #define EMARCH_ENC_I17_SIGN_INST_WORD_POS_X      27 // Intel-IA64-Filler
      
1069. #define EMARCH_ENC_I17_SIGN_VAL_POS_X            63 // Intel-IA64-Filler
      
1070. 
      
1071. #define X3_OPCODE_INST_WORD_X                    3  // Intel-IA64-Filler
      
1072. #define X3_OPCODE_SIZE_X                         4  // Intel-IA64-Filler
      
1073. #define X3_OPCODE_INST_WORD_POS_X                28 // Intel-IA64-Filler
      
1074. #define X3_OPCODE_SIGN_VAL_POS_X                 0  // Intel-IA64-Filler
      
1075. 
      
1076. #define X3_I_INST_WORD_X                         3  // Intel-IA64-Filler
      
1077. #define X3_I_SIZE_X                              1  // Intel-IA64-Filler
      
1078. #define X3_I_INST_WORD_POS_X                     27 // Intel-IA64-Filler
      
1079. #define X3_I_SIGN_VAL_POS_X                      59 // Intel-IA64-Filler
      
1080. 
      
1081. #define X3_D_WH_INST_WORD_X                      3  // Intel-IA64-Filler
      
1082. #define X3_D_WH_SIZE_X                           3  // Intel-IA64-Filler
      
1083. #define X3_D_WH_INST_WORD_POS_X                  24 // Intel-IA64-Filler
      
1084. #define X3_D_WH_SIGN_VAL_POS_X                   0  // Intel-IA64-Filler
      
1085. 
      
1086. #define X3_IMM20_INST_WORD_X                     3  // Intel-IA64-Filler
      
1087. #define X3_IMM20_SIZE_X                          20 // Intel-IA64-Filler
      
1088. #define X3_IMM20_INST_WORD_POS_X                 4  // Intel-IA64-Filler
      
1089. #define X3_IMM20_SIGN_VAL_POS_X                  0  // Intel-IA64-Filler
      
1090. 
      
1091. #define X3_IMM39_1_INST_WORD_X                   2  // Intel-IA64-Filler
      
1092. #define X3_IMM39_1_SIZE_X                        23 // Intel-IA64-Filler
      
1093. #define X3_IMM39_1_INST_WORD_POS_X               0  // Intel-IA64-Filler
      
1094. #define X3_IMM39_1_SIGN_VAL_POS_X                36 // Intel-IA64-Filler
      
1095. 
      
1096. #define X3_IMM39_2_INST_WORD_X                   1  // Intel-IA64-Filler
      
1097. #define X3_IMM39_2_SIZE_X                        16 // Intel-IA64-Filler
      
1098. #define X3_IMM39_2_INST_WORD_POS_X               16 // Intel-IA64-Filler
      
1099. #define X3_IMM39_2_SIGN_VAL_POS_X                20 // Intel-IA64-Filler
      
1100. 
      
1101. #define X3_P_INST_WORD_X                         3  // Intel-IA64-Filler
      
1102. #define X3_P_SIZE_X                              4  // Intel-IA64-Filler
      
1103. #define X3_P_INST_WORD_POS_X                     0  // Intel-IA64-Filler
      
1104. #define X3_P_SIGN_VAL_POS_X                      0  // Intel-IA64-Filler
      
1105. 
      
1106. #define X3_TMPLT_INST_WORD_X                     0  // Intel-IA64-Filler
      
1107. #define X3_TMPLT_SIZE_X                          4  // Intel-IA64-Filler
      
1108. #define X3_TMPLT_INST_WORD_POS_X                 0  // Intel-IA64-Filler
      
1109. #define X3_TMPLT_SIGN_VAL_POS_X                  0  // Intel-IA64-Filler
      
1110. 
      
1111. #define X3_BTYPE_QP_INST_WORD_X                  2  // Intel-IA64-Filler
      
1112. #define X3_BTYPE_QP_SIZE_X                       9  // Intel-IA64-Filler
      
1113. #define X3_BTYPE_QP_INST_WORD_POS_X              23 // Intel-IA64-Filler
      
1114. #define X3_BTYPE_QP_INST_VAL_POS_X               0  // Intel-IA64-Filler
      
1115. 
      
1116. #define X3_EMPTY_INST_WORD_X                     1  // Intel-IA64-Filler
      
1117. #define X3_EMPTY_SIZE_X                          2  // Intel-IA64-Filler
      
1118. #define X3_EMPTY_INST_WORD_POS_X                 14 // Intel-IA64-Filler
      
1119. #define X3_EMPTY_INST_VAL_POS_X                  0  // Intel-IA64-Filler
      
1120. 
      
1121. //
      
1122. // Line number format.
      
1123. //
      
1124. 
      
1125. typedef struct _IMAGE_LINENUMBER {
      
1126.     union {
      
1127.         ULONG   SymbolTableIndex;               // Symbol table index of function name if Linenumber is 0.
      
1128.         ULONG   VirtualAddress;                 // Virtual address of line number.
      
1129.     } Type;
      
1130.     USHORT  Linenumber;                         // Line number.
      
1131. } IMAGE_LINENUMBER;
      
1132. typedef IMAGE_LINENUMBER UNALIGNED *PIMAGE_LINENUMBER;
      
1133. 
      
1134. #define IMAGE_SIZEOF_LINENUMBER              6
      
1135. 
      
1136. #include "poppack.h"                        // Back to 4 byte packing
      
1137. 
      
1138. //
      
1139. // Based relocation format.
      
1140. //
      
1141. 
      
1142. typedef struct _IMAGE_BASE_RELOCATION {
      
1143.     ULONG   VirtualAddress;
      
1144.     ULONG   SizeOfBlock;
      
1145.         USHORT  TypeOffset[1];
      
1146. } IMAGE_BASE_RELOCATION;
      
1147. typedef IMAGE_BASE_RELOCATION UNALIGNED * PIMAGE_BASE_RELOCATION;
      
1148. 
      
1149. #define IMAGE_SIZEOF_BASE_RELOCATION         8
      
1150. 
      
1151. //
      
1152. // Based relocation types.
      
1153. //
      
1154. 
      
1155. #define IMAGE_REL_BASED_ABSOLUTE              0
      
1156. #define IMAGE_REL_BASED_HIGH                  1
      
1157. #define IMAGE_REL_BASED_LOW                   2
      
1158. #define IMAGE_REL_BASED_HIGHLOW               3
      
1159. #define IMAGE_REL_BASED_HIGHADJ               4
      
1160. #define IMAGE_REL_BASED_MIPS_JMPADDR          5
      
1161. // end_winnt
      
1162. #define IMAGE_REL_BASED_SECTION               6
      
1163. #define IMAGE_REL_BASED_REL32                 7
      
1164. //      IMAGE_REL_BASED_VXD_RELATIVE          8
      
1165. // begin_winnt
      
1166. #define IMAGE_REL_BASED_MIPS_JMPADDR16        9
      
1167. #define IMAGE_REL_BASED_IA64_IMM64            9
      
1168. #define IMAGE_REL_BASED_DIR64                 10
      
1169. 
      
1170. 
      
1171. //
      
1172. // Archive format.
      
1173. //
      
1174. 
      
1175. #define IMAGE_ARCHIVE_START_SIZE             8
      
1176. #define IMAGE_ARCHIVE_START                  "!<arch>\n"
      
1177. #define IMAGE_ARCHIVE_END                    "`\n"
      
1178. #define IMAGE_ARCHIVE_PAD                    "\n"
      
1179. #define IMAGE_ARCHIVE_LINKER_MEMBER          "/               "
      
1180. #define IMAGE_ARCHIVE_LONGNAMES_MEMBER       "//              "
      
1181. 
      
1182. typedef struct _IMAGE_ARCHIVE_MEMBER_HEADER {
      
1183.     UCHAR    Name[16];                          // File member name - `/' terminated.
      
1184.     UCHAR    Date[12];                          // File member date - decimal.
      
1185.     UCHAR    UserID[6];                         // File member user id - decimal.
      
1186.     UCHAR    GroupID[6];                        // File member group id - decimal.
      
1187.     UCHAR    Mode[8];                           // File member mode - octal.
      
1188.     UCHAR    Size[10];                          // File member size - decimal.
      
1189.     UCHAR    EndHeader[2];                      // String to end header.
      
1190. } IMAGE_ARCHIVE_MEMBER_HEADER, *PIMAGE_ARCHIVE_MEMBER_HEADER;
      
1191. 
      
1192. #define IMAGE_SIZEOF_ARCHIVE_MEMBER_HDR      60
      
1193. 
      
1194. //
      
1195. // DLL support.
      
1196. //
      
1197. 
      
1198. //
      
1199. // Export Format
      
1200. //
      
1201. 
      
1202. typedef struct _IMAGE_EXPORT_DIRECTORY {
      
1203.     ULONG   Characteristics;
      
1204.     ULONG   TimeDateStamp;
      
1205.     USHORT  MajorVersion;
      
1206.     USHORT  MinorVersion;
      
1207.     ULONG   Name;
      
1208.     ULONG   Base;
      
1209.     ULONG   NumberOfFunctions;
      
1210.     ULONG   NumberOfNames;
      
1211.     ULONG   AddressOfFunctions;     // RVA from base of image
      
1212.     ULONG   AddressOfNames;         // RVA from base of image
      
1213.     ULONG   AddressOfNameOrdinals;  // RVA from base of image
      
1214. } IMAGE_EXPORT_DIRECTORY, *PIMAGE_EXPORT_DIRECTORY;
      
1215. 
      
1216. //
      
1217. // Import Format
      
1218. //
      
1219. 
      
1220. typedef struct _IMAGE_IMPORT_BY_NAME {
      
1221.     USHORT  Hint;
      
1222.     UCHAR   Name[1];
      
1223. } IMAGE_IMPORT_BY_NAME, *PIMAGE_IMPORT_BY_NAME;
      
1224. 
      
1225. #include "pshpack8.h"                       // Use align 8 for the 64-bit IAT.
      
1226. 
      
1227. typedef struct _IMAGE_THUNK_DATA64 {
      
1228.     union {
      
1229.         ULONGLONG ForwarderString;  // PUCHAR
      
1230.         ULONGLONG Function;         // PULONG
      
1231.         ULONGLONG Ordinal;
      
1232.         ULONGLONG AddressOfData;    // PIMAGE_IMPORT_BY_NAME
      
1233.     } u1;
      
1234. } IMAGE_THUNK_DATA64;
      
1235. typedef IMAGE_THUNK_DATA64 * PIMAGE_THUNK_DATA64;
      
1236. 
      
1237. #include "poppack.h"                        // Back to 4 byte packing
      
1238. 
      
1239. typedef struct _IMAGE_THUNK_DATA32 {
      
1240.     union {
      
1241.         ULONG ForwarderString;      // PUCHAR
      
1242.         ULONG Function;             // PULONG
      
1243.         ULONG Ordinal;
      
1244.         ULONG AddressOfData;        // PIMAGE_IMPORT_BY_NAME
      
1245.     } u1;
      
1246. } IMAGE_THUNK_DATA32;
      
1247. typedef IMAGE_THUNK_DATA32 * PIMAGE_THUNK_DATA32;
      
1248. 
      
1249. #define IMAGE_ORDINAL_FLAG64 0x8000000000000000
      
1250. #define IMAGE_ORDINAL_FLAG32 0x80000000
      
1251. #define IMAGE_ORDINAL64(Ordinal) (Ordinal & 0xffff)
      
1252. #define IMAGE_ORDINAL32(Ordinal) (Ordinal & 0xffff)
      
1253. #define IMAGE_SNAP_BY_ORDINAL64(Ordinal) ((Ordinal & IMAGE_ORDINAL_FLAG64) != 0)
      
1254. #define IMAGE_SNAP_BY_ORDINAL32(Ordinal) ((Ordinal & IMAGE_ORDINAL_FLAG32) != 0)
      
1255. 
      
1256. //
      
1257. // Thread Local Storage
      
1258. //
      
1259. 
      
1260. typedef VOID
      
1261. (NTAPI *PIMAGE_TLS_CALLBACK) (
      
1262.     PVOID DllHandle,
      
1263.     ULONG Reason,
      
1264.     PVOID Reserved
      
1265.     );
      
1266. 
      
1267. typedef struct _IMAGE_TLS_DIRECTORY64 {
      
1268.     ULONGLONG   StartAddressOfRawData;
      
1269.     ULONGLONG   EndAddressOfRawData;
      
1270.     ULONGLONG   AddressOfIndex;         // PULONG
      
1271.     ULONGLONG   AddressOfCallBacks;     // PIMAGE_TLS_CALLBACK *;
      
1272.     ULONG   SizeOfZeroFill;
      
1273.     ULONG   Characteristics;
      
1274. } IMAGE_TLS_DIRECTORY64;
      
1275. typedef IMAGE_TLS_DIRECTORY64 * PIMAGE_TLS_DIRECTORY64;
      
1276. 
      
1277. typedef struct _IMAGE_TLS_DIRECTORY32 {
      
1278.     ULONG   StartAddressOfRawData;
      
1279.     ULONG   EndAddressOfRawData;
      
1280.     ULONG   AddressOfIndex;             // PULONG
      
1281.     ULONG   AddressOfCallBacks;         // PIMAGE_TLS_CALLBACK *
      
1282.     ULONG   SizeOfZeroFill;
      
1283.     ULONG   Characteristics;
      
1284. } IMAGE_TLS_DIRECTORY32;
      
1285. typedef IMAGE_TLS_DIRECTORY32 * PIMAGE_TLS_DIRECTORY32;
      
1286. 
      
1287. #ifdef _WIN64
      
1288. #define IMAGE_ORDINAL_FLAG              IMAGE_ORDINAL_FLAG64
      
1289. #define IMAGE_ORDINAL(Ordinal)          IMAGE_ORDINAL64(Ordinal)
      
1290. typedef IMAGE_THUNK_DATA64              IMAGE_THUNK_DATA;
      
1291. typedef PIMAGE_THUNK_DATA64             PIMAGE_THUNK_DATA;
      
1292. #define IMAGE_SNAP_BY_ORDINAL(Ordinal)  IMAGE_SNAP_BY_ORDINAL64(Ordinal)
      
1293. typedef IMAGE_TLS_DIRECTORY64           IMAGE_TLS_DIRECTORY;
      
1294. typedef PIMAGE_TLS_DIRECTORY64          PIMAGE_TLS_DIRECTORY;
      
1295. #else
      
1296. #define IMAGE_ORDINAL_FLAG              IMAGE_ORDINAL_FLAG32
      
1297. #define IMAGE_ORDINAL(Ordinal)          IMAGE_ORDINAL32(Ordinal)
      
1298. typedef IMAGE_THUNK_DATA32              IMAGE_THUNK_DATA;
      
1299. typedef PIMAGE_THUNK_DATA32             PIMAGE_THUNK_DATA;
      
1300. #define IMAGE_SNAP_BY_ORDINAL(Ordinal)  IMAGE_SNAP_BY_ORDINAL32(Ordinal)
      
1301. typedef IMAGE_TLS_DIRECTORY32           IMAGE_TLS_DIRECTORY;
      
1302. typedef PIMAGE_TLS_DIRECTORY32          PIMAGE_TLS_DIRECTORY;
      
1303. #endif
      
1304. 
      
1305. typedef struct _IMAGE_IMPORT_DESCRIPTOR {
      
1306.     union {
      
1307.         ULONG   Characteristics;            // 0 for terminating null import descriptor
      
1308.         ULONG   OriginalFirstThunk;         // RVA to original unbound IAT (PIMAGE_THUNK_DATA)
      
1309.     };
      
1310.     ULONG   TimeDateStamp;                  // 0 if not bound,
      
1311.                                             // -1 if bound, and real date\time stamp
      
1312.                                             //     in IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT (new BIND)
      
1313.                                             // O.W. date/time stamp of DLL bound to (Old BIND)
      
1314. 
      
1315.     ULONG   ForwarderChain;                 // -1 if no forwarders
      
1316.     ULONG   Name;
      
1317.     ULONG   FirstThunk;                     // RVA to IAT (if bound this IAT has actual addresses)
      
1318. } IMAGE_IMPORT_DESCRIPTOR;
      
1319. typedef IMAGE_IMPORT_DESCRIPTOR UNALIGNED *PIMAGE_IMPORT_DESCRIPTOR;
      
1320. 
      
1321. //
      
1322. // New format import descriptors pointed to by DataDirectory[ IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT ]
      
1323. //
      
1324. 
      
1325. typedef struct _IMAGE_BOUND_IMPORT_DESCRIPTOR {
      
1326.     ULONG   TimeDateStamp;
      
1327.     USHORT  OffsetModuleName;
      
1328.     USHORT  NumberOfModuleForwarderRefs;
      
1329. // Array of zero or more IMAGE_BOUND_FORWARDER_REF follows
      
1330. } IMAGE_BOUND_IMPORT_DESCRIPTOR,  *PIMAGE_BOUND_IMPORT_DESCRIPTOR;
      
1331. 
      
1332. typedef struct _IMAGE_BOUND_FORWARDER_REF {
      
1333.     ULONG   TimeDateStamp;
      
1334.     USHORT  OffsetModuleName;
      
1335.     USHORT  Reserved;
      
1336. } IMAGE_BOUND_FORWARDER_REF, *PIMAGE_BOUND_FORWARDER_REF;
      
1337. 
      
1338. //
      
1339. // Resource Format.
      
1340. //
      
1341. 
      
1342. //
      
1343. // Resource directory consists of two counts, following by a variable length
      
1344. // array of directory entries.  The first count is the number of entries at
      
1345. // beginning of the array that have actual names associated with each entry.
      
1346. // The entries are in ascending order, case insensitive strings.  The second
      
1347. // count is the number of entries that immediately follow the named entries.
      
1348. // This second count identifies the number of entries that have 16-bit integer
      
1349. // Ids as their name.  These entries are also sorted in ascending order.
      
1350. //
      
1351. // This structure allows fast lookup by either name or number, but for any
      
1352. // given resource entry only one form of lookup is supported, not both.
      
1353. // This is consistant with the syntax of the .RC file and the .RES file.
      
1354. //
      
1355. 
      
1356. typedef struct _IMAGE_RESOURCE_DIRECTORY {
      
1357.     ULONG   Characteristics;
      
1358.     ULONG   TimeDateStamp;
      
1359.     USHORT  MajorVersion;
      
1360.     USHORT  MinorVersion;
      
1361.     USHORT  NumberOfNamedEntries;
      
1362.     USHORT  NumberOfIdEntries;
      
1363. //  IMAGE_RESOURCE_DIRECTORY_ENTRY DirectoryEntries[];
      
1364. } IMAGE_RESOURCE_DIRECTORY, *PIMAGE_RESOURCE_DIRECTORY;
      
1365. 
      
1366. #define IMAGE_RESOURCE_NAME_IS_STRING        0x80000000
      
1367. #define IMAGE_RESOURCE_DATA_IS_DIRECTORY     0x80000000
      
1368. //
      
1369. // Each directory contains the 32-bit Name of the entry and an offset,
      
1370. // relative to the beginning of the resource directory of the data associated
      
1371. // with this directory entry.  If the name of the entry is an actual text
      
1372. // string instead of an integer Id, then the high order bit of the name field
      
1373. // is set to one and the low order 31-bits are an offset, relative to the
      
1374. // beginning of the resource directory of the string, which is of type
      
1375. // IMAGE_RESOURCE_DIRECTORY_STRING.  Otherwise the high bit is clear and the
      
1376. // low-order 16-bits are the integer Id that identify this resource directory
      
1377. // entry. If the directory entry is yet another resource directory (i.e. a
      
1378. // subdirectory), then the high order bit of the offset field will be
      
1379. // set to indicate this.  Otherwise the high bit is clear and the offset
      
1380. // field points to a resource data entry.
      
1381. //
      
1382. 
      
1383. typedef struct _IMAGE_RESOURCE_DIRECTORY_ENTRY {
      
1384.     union {
      
1385.         struct {
      
1386.             ULONG NameOffset:31;
      
1387.             ULONG NameIsString:1;
      
1388.         };
      
1389.         ULONG   Name;
      
1390.         USHORT  Id;
      
1391.     };
      
1392.     union {
      
1393.         ULONG   OffsetToData;
      
1394.         struct {
      
1395.             ULONG   OffsetToDirectory:31;
      
1396.             ULONG   DataIsDirectory:1;
      
1397.         };
      
1398.     };
      
1399. } IMAGE_RESOURCE_DIRECTORY_ENTRY, *PIMAGE_RESOURCE_DIRECTORY_ENTRY;
      
1400. 
      
1401. //
      
1402. // For resource directory entries that have actual string names, the Name
      
1403. // field of the directory entry points to an object of the following type.
      
1404. // All of these string objects are stored together after the last resource
      
1405. // directory entry and before the first resource data object.  This minimizes
      
1406. // the impact of these variable length objects on the alignment of the fixed
      
1407. // size directory entry objects.
      
1408. //
      
1409. 
      
1410. typedef struct _IMAGE_RESOURCE_DIRECTORY_STRING {
      
1411.     USHORT  Length;
      
1412.     CHAR    NameString[ 1 ];
      
1413. } IMAGE_RESOURCE_DIRECTORY_STRING, *PIMAGE_RESOURCE_DIRECTORY_STRING;
      
1414. 
      
1415. 
      
1416. typedef struct _IMAGE_RESOURCE_DIR_STRING_U {
      
1417.     USHORT  Length;
      
1418.     WCHAR   NameString[ 1 ];
      
1419. } IMAGE_RESOURCE_DIR_STRING_U, *PIMAGE_RESOURCE_DIR_STRING_U;
      
1420. 
      
1421. 
      
1422. //
      
1423. // Each resource data entry describes a leaf node in the resource directory
      
1424. // tree.  It contains an offset, relative to the beginning of the resource
      
1425. // directory of the data for the resource, a size field that gives the number
      
1426. // of bytes of data at that offset, a CodePage that should be used when
      
1427. // decoding code point values within the resource data.  Typically for new
      
1428. // applications the code page would be the unicode code page.
      
1429. //
      
1430. 
      
1431. typedef struct _IMAGE_RESOURCE_DATA_ENTRY {
      
1432.     ULONG   OffsetToData;
      
1433.     ULONG   Size;
      
1434.     ULONG   CodePage;
      
1435.     ULONG   Reserved;
      
1436. } IMAGE_RESOURCE_DATA_ENTRY, *PIMAGE_RESOURCE_DATA_ENTRY;
      
1437. 
      
1438. //
      
1439. // Load Configuration Directory Entry
      
1440. //
      
1441. 
      
1442. typedef struct {
      
1443.     ULONG   Size;
      
1444.     ULONG   TimeDateStamp;
      
1445.     USHORT  MajorVersion;
      
1446.     USHORT  MinorVersion;
      
1447.     ULONG   GlobalFlagsClear;
      
1448.     ULONG   GlobalFlagsSet;
      
1449.     ULONG   CriticalSectionDefaultTimeout;
      
1450.     ULONG   DeCommitFreeBlockThreshold;
      
1451.     ULONG   DeCommitTotalFreeThreshold;
      
1452.     ULONG   LockPrefixTable;            // VA
      
1453.     ULONG   MaximumAllocationSize;
      
1454.     ULONG   VirtualMemoryThreshold;
      
1455.     ULONG   ProcessHeapFlags;
      
1456.     ULONG   ProcessAffinityMask;
      
1457.     USHORT  CSDVersion;
      
1458.     USHORT  Reserved1;
      
1459.     ULONG   EditList;                   // VA
      
1460.     ULONG   SecurityCookie;             // VA
      
1461.     ULONG   SEHandlerTable;             // VA
      
1462.     ULONG   SEHandlerCount;
      
1463. } IMAGE_LOAD_CONFIG_DIRECTORY32, *PIMAGE_LOAD_CONFIG_DIRECTORY32;
      
1464. 
      
1465. typedef struct {
      
1466.     ULONG      Size;
      
1467.     ULONG      TimeDateStamp;
      
1468.     USHORT     MajorVersion;
      
1469.     USHORT     MinorVersion;
      
1470.     ULONG      GlobalFlagsClear;
      
1471.     ULONG      GlobalFlagsSet;
      
1472.     ULONG      CriticalSectionDefaultTimeout;
      
1473.     ULONGLONG  DeCommitFreeBlockThreshold;
      
1474.     ULONGLONG  DeCommitTotalFreeThreshold;
      
1475.     ULONGLONG  LockPrefixTable;         // VA
      
1476.     ULONGLONG  MaximumAllocationSize;
      
1477.     ULONGLONG  VirtualMemoryThreshold;
      
1478.     ULONGLONG  ProcessAffinityMask;
      
1479.     ULONG      ProcessHeapFlags;
      
1480.     USHORT     CSDVersion;
      
1481.     USHORT     Reserved1;
      
1482.     ULONGLONG  EditList;                // VA
      
1483.     ULONGLONG  SecurityCookie;          // VA
      
1484.     ULONGLONG  SEHandlerTable;          // VA
      
1485.     ULONGLONG  SEHandlerCount;
      
1486. } IMAGE_LOAD_CONFIG_DIRECTORY64, *PIMAGE_LOAD_CONFIG_DIRECTORY64;
      
1487. 
      
1488. #ifdef _WIN64
      
1489. typedef IMAGE_LOAD_CONFIG_DIRECTORY64     IMAGE_LOAD_CONFIG_DIRECTORY;
      
1490. typedef PIMAGE_LOAD_CONFIG_DIRECTORY64    PIMAGE_LOAD_CONFIG_DIRECTORY;
      
1491. #else
      
1492. typedef IMAGE_LOAD_CONFIG_DIRECTORY32     IMAGE_LOAD_CONFIG_DIRECTORY;
      
1493. typedef PIMAGE_LOAD_CONFIG_DIRECTORY32    PIMAGE_LOAD_CONFIG_DIRECTORY;
      
1494. #endif
      
1495. 
      
1496. //
      
1497. // WIN CE Exception table format
      
1498. //
      
1499. 
      
1500. //
      
1501. // Function table entry format.  Function table is pointed to by the
      
1502. // IMAGE_DIRECTORY_ENTRY_EXCEPTION directory entry.
      
1503. //
      
1504. 
      
1505. typedef struct _IMAGE_CE_RUNTIME_FUNCTION_ENTRY {
      
1506.     ULONG FuncStart;
      
1507.     ULONG PrologLen : 8;
      
1508.     ULONG FuncLen : 22;
      
1509.     ULONG ThirtyTwoBit : 1;
      
1510.     ULONG ExceptionFlag : 1;
      
1511. } IMAGE_CE_RUNTIME_FUNCTION_ENTRY, * PIMAGE_CE_RUNTIME_FUNCTION_ENTRY;
      
1512. 
      
1513. typedef struct _IMAGE_ALPHA64_RUNTIME_FUNCTION_ENTRY {
      
1514.     ULONGLONG BeginAddress;
      
1515.     ULONGLONG EndAddress;
      
1516.     ULONGLONG ExceptionHandler;
      
1517.     ULONGLONG HandlerData;
      
1518.     ULONGLONG PrologEndAddress;
      
1519. } IMAGE_ALPHA64_RUNTIME_FUNCTION_ENTRY, *PIMAGE_ALPHA64_RUNTIME_FUNCTION_ENTRY;
      
1520. 
      
1521. typedef struct _IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY {
      
1522.     ULONG BeginAddress;
      
1523.     ULONG EndAddress;
      
1524.     ULONG ExceptionHandler;
      
1525.     ULONG HandlerData;
      
1526.     ULONG PrologEndAddress;
      
1527. } IMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY, *PIMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY;
      
1528. 
      
1529. typedef struct _IMAGE_RUNTIME_FUNCTION_ENTRY {
      
1530.     ULONG BeginAddress;
      
1531.     ULONG EndAddress;
      
1532.     ULONG UnwindInfoAddress;
      
1533. } _IMAGE_RUNTIME_FUNCTION_ENTRY, *_PIMAGE_RUNTIME_FUNCTION_ENTRY;
      
1534. 
      
1535. typedef  _IMAGE_RUNTIME_FUNCTION_ENTRY  IMAGE_IA64_RUNTIME_FUNCTION_ENTRY;
      
1536. typedef _PIMAGE_RUNTIME_FUNCTION_ENTRY PIMAGE_IA64_RUNTIME_FUNCTION_ENTRY;
      
1537. 
      
1538. typedef  _IMAGE_RUNTIME_FUNCTION_ENTRY  IMAGE_RUNTIME_FUNCTION_ENTRY;
      
1539. typedef _PIMAGE_RUNTIME_FUNCTION_ENTRY PIMAGE_RUNTIME_FUNCTION_ENTRY;
      
1540. 
      
1541. //
      
1542. // Debug Format
      
1543. //
      
1544. 
      
1545. typedef struct _IMAGE_DEBUG_DIRECTORY {
      
1546.     ULONG   Characteristics;
      
1547.     ULONG   TimeDateStamp;
      
1548.     USHORT  MajorVersion;
      
1549.     USHORT  MinorVersion;
      
1550.     ULONG   Type;
      
1551.     ULONG   SizeOfData;
      
1552.     ULONG   AddressOfRawData;
      
1553.     ULONG   PointerToRawData;
      
1554. } IMAGE_DEBUG_DIRECTORY, *PIMAGE_DEBUG_DIRECTORY;
      
1555. 
      
1556. #define IMAGE_DEBUG_TYPE_UNKNOWN          0
      
1557. #define IMAGE_DEBUG_TYPE_COFF             1
      
1558. #define IMAGE_DEBUG_TYPE_CODEVIEW         2
      
1559. #define IMAGE_DEBUG_TYPE_FPO              3
      
1560. #define IMAGE_DEBUG_TYPE_MISC             4
      
1561. #define IMAGE_DEBUG_TYPE_EXCEPTION        5
      
1562. #define IMAGE_DEBUG_TYPE_FIXUP            6
      
1563. #define IMAGE_DEBUG_TYPE_OMAP_TO_SRC      7
      
1564. #define IMAGE_DEBUG_TYPE_OMAP_FROM_SRC    8
      
1565. #define IMAGE_DEBUG_TYPE_BORLAND          9
      
1566. #define IMAGE_DEBUG_TYPE_RESERVED10       10
      
1567. #define IMAGE_DEBUG_TYPE_CLSID            11
      
1568. 
      
1569. // end_winnt
      
1570. 
      
1571. // IMAGE_DEBUG_TYPE values > 0x7FFFFFFF are reserved for BBT
      
1572. 
      
1573. // begin_winnt
      
1574. 
      
1575. typedef struct _IMAGE_COFF_SYMBOLS_HEADER {
      
1576.     ULONG   NumberOfSymbols;
      
1577.     ULONG   LvaToFirstSymbol;
      
1578.     ULONG   NumberOfLinenumbers;
      
1579.     ULONG   LvaToFirstLinenumber;
      
1580.     ULONG   RvaToFirstByteOfCode;
      
1581.     ULONG   RvaToLastByteOfCode;
      
1582.     ULONG   RvaToFirstByteOfData;
      
1583.     ULONG   RvaToLastByteOfData;
      
1584. } IMAGE_COFF_SYMBOLS_HEADER, *PIMAGE_COFF_SYMBOLS_HEADER;
      
1585. 
      
1586. #define FRAME_FPO       0
      
1587. #define FRAME_TRAP      1
      
1588. #define FRAME_TSS       2
      
1589. #define FRAME_NONFPO    3
      
1590. 
      
1591. typedef struct _FPO_DATA {
      
1592.     ULONG       ulOffStart;             // offset 1st byte of function code
      
1593.     ULONG       cbProcSize;             // # bytes in function
      
1594.     ULONG       cdwLocals;              // # bytes in locals/4
      
1595.     USHORT      cdwParams;              // # bytes in params/4
      
1596.     USHORT      cbProlog : 8;           // # bytes in prolog
      
1597.     USHORT      cbRegs   : 3;           // # regs saved
      
1598.     USHORT      fHasSEH  : 1;           // TRUE if SEH in func
      
1599.     USHORT      fUseBP   : 1;           // TRUE if EBP has been allocated
      
1600.     USHORT      reserved : 1;           // reserved for future use
      
1601.     USHORT      cbFrame  : 2;           // frame type
      
1602. } FPO_DATA, *PFPO_DATA;
      
1603. #define SIZEOF_RFPO_DATA 16
      
1604. 
      
1605. 
      
1606. #define IMAGE_DEBUG_MISC_EXENAME    1
      
1607. 
      
1608. typedef struct _IMAGE_DEBUG_MISC {
      
1609.     ULONG       DataType;               // type of misc data, see defines
      
1610.     ULONG       Length;                 // total length of record, rounded to four
      
1611.                                         // byte multiple.
      
1612.     BOOLEAN     Unicode;                // TRUE if data is unicode string
      
1613.     UCHAR       Reserved[ 3 ];
      
1614.     UCHAR       Data[ 1 ];              // Actual data
      
1615. } IMAGE_DEBUG_MISC, *PIMAGE_DEBUG_MISC;
      
1616. 
      
1617. 
      
1618. //
      
1619. // Function table extracted from MIPS/ALPHA/IA64 images.  Does not contain
      
1620. // information needed only for runtime support.  Just those fields for
      
1621. // each entry needed by a debugger.
      
1622. //
      
1623. 
      
1624. typedef struct _IMAGE_FUNCTION_ENTRY {
      
1625.     ULONG   StartingAddress;
      
1626.     ULONG   EndingAddress;
      
1627.     ULONG   EndOfPrologue;
      
1628. } IMAGE_FUNCTION_ENTRY, *PIMAGE_FUNCTION_ENTRY;
      
1629. 
      
1630. typedef struct _IMAGE_FUNCTION_ENTRY64 {
      
1631.     ULONGLONG   StartingAddress;
      
1632.     ULONGLONG   EndingAddress;
      
1633.     union {
      
1634.         ULONGLONG   EndOfPrologue;
      
1635.         ULONGLONG   UnwindInfoAddress;
      
1636.     };
      
1637. } IMAGE_FUNCTION_ENTRY64, *PIMAGE_FUNCTION_ENTRY64;
      
1638. 
      
1639. //
      
1640. // Debugging information can be stripped from an image file and placed
      
1641. // in a separate .DBG file, whose file name part is the same as the
      
1642. // image file name part (e.g. symbols for CMD.EXE could be stripped
      
1643. // and placed in CMD.DBG).  This is indicated by the IMAGE_FILE_DEBUG_STRIPPED
      
1644. // flag in the Characteristics field of the file header.  The beginning of
      
1645. // the .DBG file contains the following structure which captures certain
      
1646. // information from the image file.  This allows a debug to proceed even if
      
1647. // the original image file is not accessable.  This header is followed by
      
1648. // zero of more IMAGE_SECTION_HEADER structures, followed by zero or more
      
1649. // IMAGE_DEBUG_DIRECTORY structures.  The latter structures and those in
      
1650. // the image file contain file offsets relative to the beginning of the
      
1651. // .DBG file.
      
1652. //
      
1653. // If symbols have been stripped from an image, the IMAGE_DEBUG_MISC structure
      
1654. // is left in the image file, but not mapped.  This allows a debugger to
      
1655. // compute the name of the .DBG file, from the name of the image in the
      
1656. // IMAGE_DEBUG_MISC structure.
      
1657. //
      
1658. 
      
1659. typedef struct _IMAGE_SEPARATE_DEBUG_HEADER {
      
1660.     USHORT      Signature;
      
1661.     USHORT      Flags;
      
1662.     USHORT      Machine;
      
1663.     USHORT      Characteristics;
      
1664.     ULONG       TimeDateStamp;
      
1665.     ULONG       CheckSum;
      
1666.     ULONG       ImageBase;
      
1667.     ULONG       SizeOfImage;
      
1668.     ULONG       NumberOfSections;
      
1669.     ULONG       ExportedNamesSize;
      
1670.     ULONG       DebugDirectorySize;
      
1671.     ULONG       SectionAlignment;
      
1672.     ULONG       Reserved[2];
      
1673. } IMAGE_SEPARATE_DEBUG_HEADER, *PIMAGE_SEPARATE_DEBUG_HEADER;
      
1674. 
      
1675. typedef struct _NON_PAGED_DEBUG_INFO {
      
1676.     USHORT      Signature;
      
1677.     USHORT      Flags;
      
1678.     ULONG       Size;
      
1679.     USHORT      Machine;
      
1680.     USHORT      Characteristics;
      
1681.     ULONG       TimeDateStamp;
      
1682.     ULONG       CheckSum;
      
1683.     ULONG       SizeOfImage;
      
1684.     ULONGLONG   ImageBase;
      
1685. } NON_PAGED_DEBUG_INFO, *PNON_PAGED_DEBUG_INFO;
      
1686. 
      
1687. #define IMAGE_SEPARATE_DEBUG_SIGNATURE 0x4944
      
1688. #define NON_PAGED_DEBUG_SIGNATURE      0x494E
      
1689. 
      
1690. #define IMAGE_SEPARATE_DEBUG_FLAGS_MASK 0x8000
      
1691. #define IMAGE_SEPARATE_DEBUG_MISMATCH   0x8000  // when DBG was updated, the
      
1692.                                                 // old checksum didn't match.
      
1693. 
      
1694. //
      
1695. //  The .arch section is made up of headers, each describing an amask position/value
      
1696. //  pointing to an array of IMAGE_ARCHITECTURE_ENTRY's.  Each "array" (both the header
      
1697. //  and entry arrays) are terminated by a quadword of 0xffffffffL.
      
1698. //
      
1699. //  NOTE: There may be quadwords of 0 sprinkled around and must be skipped.
      
1700. //
      
1701. 
      
1702. typedef struct _ImageArchitectureHeader {
      
1703.     unsigned int AmaskValue: 1;                 // 1 -> code section depends on mask bit
      
1704.                                                 // 0 -> new instruction depends on mask bit
      
1705.     int :7;                                     // MBZ
      
1706.     unsigned int AmaskShift: 8;                 // Amask bit in question for this fixup
      
1707.     int :16;                                    // MBZ
      
1708.     ULONG FirstEntryRVA;                        // RVA into .arch section to array of ARCHITECTURE_ENTRY's
      
1709. } IMAGE_ARCHITECTURE_HEADER, *PIMAGE_ARCHITECTURE_HEADER;
      
1710. 
      
1711. typedef struct _ImageArchitectureEntry {
      
1712.     ULONG FixupInstRVA;                         // RVA of instruction to fixup
      
1713.     ULONG NewInst;                              // fixup instruction (see alphaops.h)
      
1714. } IMAGE_ARCHITECTURE_ENTRY, *PIMAGE_ARCHITECTURE_ENTRY;
      
1715. 
      
1716. #include "poppack.h"                // Back to the initial value
      
1717. 
      
1718. // The following structure defines the new import object.  Note the values of the first two fields,
      
1719. // which must be set as stated in order to differentiate old and new import members.
      
1720. // Following this structure, the linker emits two null-terminated strings used to recreate the
      
1721. // import at the time of use.  The first string is the import's name, the second is the dll's name.
      
1722. 
      
1723. #define IMPORT_OBJECT_HDR_SIG2  0xffff
      
1724. 
      
1725. typedef struct IMPORT_OBJECT_HEADER {
      
1726.     USHORT  Sig1;                       // Must be IMAGE_FILE_MACHINE_UNKNOWN
      
1727.     USHORT  Sig2;                       // Must be IMPORT_OBJECT_HDR_SIG2.
      
1728.     USHORT  Version;
      
1729.     USHORT  Machine;
      
1730.     ULONG   TimeDateStamp;              // Time/date stamp
      
1731.     ULONG   SizeOfData;                 // particularly useful for incremental links
      
1732. 
      
1733.     union {
      
1734.         USHORT  Ordinal;                // if grf & IMPORT_OBJECT_ORDINAL
      
1735.         USHORT  Hint;
      
1736.     };
      
1737. 
      
1738.     USHORT  Type : 2;                   // IMPORT_TYPE
      
1739.     USHORT  NameType : 3;               // IMPORT_NAME_TYPE
      
1740.     USHORT  Reserved : 11;              // Reserved. Must be zero.
      
1741. } IMPORT_OBJECT_HEADER;
      
1742. 
      
1743. typedef enum IMPORT_OBJECT_TYPE
      
1744. {
      
1745.     IMPORT_OBJECT_CODE = 0,
      
1746.     IMPORT_OBJECT_DATA = 1,
      
1747.     IMPORT_OBJECT_CONST = 2,
      
1748. } IMPORT_OBJECT_TYPE;
      
1749. 
      
1750. typedef enum IMPORT_OBJECT_NAME_TYPE
      
1751. {
      
1752.     IMPORT_OBJECT_ORDINAL = 0,          // Import by ordinal
      
1753.     IMPORT_OBJECT_NAME = 1,             // Import name == public symbol name.
      
1754.     IMPORT_OBJECT_NAME_NO_PREFIX = 2,   // Import name == public symbol name skipping leading ?, @, or optionally _.
      
1755.     IMPORT_OBJECT_NAME_UNDECORATE = 3,  // Import name == public symbol name skipping leading ?, @, or optionally _
      
1756.                                         // and truncating at first @
      
1757. } IMPORT_OBJECT_NAME_TYPE;
      
1758. 
      
1759. // end_winnt
      
1760. 
      
1761. // The structure is used by the NT loader for clr URT support.  It
      
1762. // is a duplicate of the definition in corhdr.h.
      
1763. 
      
1764. // begin_winnt
      
1765. 
      
1766. #ifndef __IMAGE_COR20_HEADER_DEFINED__
      
1767. #define __IMAGE_COR20_HEADER_DEFINED__
      
1768. 
      
1769. typedef enum ReplacesCorHdrNumericDefines
      
1770. {
      
1771. // COM+ Header entry point flags.
      
1772.     COMIMAGE_FLAGS_ILONLY               =0x00000001,
      
1773.     COMIMAGE_FLAGS_32BITREQUIRED        =0x00000002,
      
1774.     COMIMAGE_FLAGS_IL_LIBRARY           =0x00000004,
      
1775.     COMIMAGE_FLAGS_STRONGNAMESIGNED     =0x00000008,
      
1776.     COMIMAGE_FLAGS_TRACKDEBUGDATA       =0x00010000,
      
1777. 
      
1778. // Version flags for image.
      
1779.     COR_VERSION_MAJOR_V2                =2,
      
1780.     COR_VERSION_MAJOR                   =COR_VERSION_MAJOR_V2,
      
1781.     COR_VERSION_MINOR                   =0,
      
1782.     COR_DELETED_NAME_LENGTH             =8,
      
1783.     COR_VTABLEGAP_NAME_LENGTH           =8,
      
1784. 
      
1785. // Maximum size of a NativeType descriptor.
      
1786.     NATIVE_TYPE_MAX_CB                  =1,   
      
1787.     COR_ILMETHOD_SECT_SMALL_MAX_DATASIZE=0xFF,
      
1788. 
      
1789. // #defines for the MIH FLAGS
      
1790.     IMAGE_COR_MIH_METHODRVA             =0x01,
      
1791.     IMAGE_COR_MIH_EHRVA                 =0x02,   
      
1792.     IMAGE_COR_MIH_BASICBLOCK            =0x08,
      
1793. 
      
1794. // V-table constants
      
1795.     COR_VTABLE_32BIT                    =0x01,          // V-table slots are 32-bits in size.   
      
1796.     COR_VTABLE_64BIT                    =0x02,          // V-table slots are 64-bits in size.   
      
1797.     COR_VTABLE_FROM_UNMANAGED           =0x04,          // If set, transition from unmanaged.
      
1798.     COR_VTABLE_CALL_MOST_DERIVED        =0x10,          // Call most derived method described by
      
1799. 
      
1800. // EATJ constants
      
1801.     IMAGE_COR_EATJ_THUNK_SIZE           =32,            // Size of a jump thunk reserved range.
      
1802. 
      
1803. // Max name lengths   
      
1804.     MAX_CLASS_NAME                      =1024,
      
1805.     MAX_PACKAGE_NAME                    =1024,
      
1806. } ReplacesCorHdrNumericDefines;
      
1807. 
      
1808. // COM+ 2.0 header structure.
      
1809. typedef struct IMAGE_COR20_HEADER
      
1810. {
      
1811.     // Header versioning
      
1812.     ULONG                   cb;              
      
1813.     USHORT                  MajorRuntimeVersion;
      
1814.     USHORT                  MinorRuntimeVersion;
      
1815.    
      
1816.     // Symbol table and startup information
      
1817.     IMAGE_DATA_DIRECTORY    MetaData;        
      
1818.     ULONG                   Flags;           
      
1819.     ULONG                   EntryPointToken;
      
1820.    
      
1821.     // Binding information
      
1822.     IMAGE_DATA_DIRECTORY    Resources;
      
1823.     IMAGE_DATA_DIRECTORY    StrongNameSignature;
      
1824. 
      
1825.     // Regular fixup and binding information
      
1826.     IMAGE_DATA_DIRECTORY    CodeManagerTable;
      
1827.     IMAGE_DATA_DIRECTORY    VTableFixups;
      
1828.     IMAGE_DATA_DIRECTORY    ExportAddressTableJumps;
      
1829. 
      
1830.     // Precompiled image info (internal use only - set to zero)
      
1831.     IMAGE_DATA_DIRECTORY    ManagedNativeHeader;
      
1832.    
      
1833. } IMAGE_COR20_HEADER, *PIMAGE_COR20_HEADER;
      
1834. 
      
1835. #endif // __IMAGE_COR20_HEADER_DEFINED__
      
1836. 
      
1837. //
      
1838. // End Image Format
      
1839. //
      
1840. 
      
1841. // end_winnt
      
1842. 
      
1843. typedef IMAGE_OS2_HEADER UNALIGNED * PUIMAGE_OS2_HEADER;
      
1844. typedef IMAGE_IMPORT_DESCRIPTOR UNALIGNED CONST *PCIMAGE_IMPORT_DESCRIPTOR;
      
1845. typedef CONST IMAGE_BOUND_IMPORT_DESCRIPTOR *PCIMAGE_BOUND_IMPORT_DESCRIPTOR;
      
1846. typedef CONST IMAGE_BOUND_FORWARDER_REF     *PCIMAGE_BOUND_FORWARDER_REF;
      
1847. typedef CONST IMAGE_IMPORT_BY_NAME          *PCIMAGE_IMPORT_BY_NAME;
      
1848. typedef CONST IMAGE_THUNK_DATA              *PCIMAGE_THUNK_DATA;
      
1849. typedef CONST IMAGE_THUNK_DATA32            *PCIMAGE_THUNK_DATA32;
      
1850. typedef CONST IMAGE_THUNK_DATA64            *PCIMAGE_THUNK_DATA64;
      
1851. typedef CONST IMAGE_TLS_DIRECTORY           *PCIMAGE_TLS_DIRECTORY;
      
1852. typedef CONST IMAGE_TLS_DIRECTORY32         *PCIMAGE_TLS_DIRECTORY32;
      
1853. typedef CONST IMAGE_TLS_DIRECTORY64         *PCIMAGE_TLS_DIRECTORY64;
      
1854. typedef CONST IMAGE_EXPORT_DIRECTORY        *PCIMAGE_EXPORT_DIRECTORY;
      
1855. typedef CONST IMAGE_SECTION_HEADER          *PCIMAGE_SECTION_HEADER;
      
1856. 
      
1857. #endif // _NTIMAGE_

复制代码