WIN64枚举GDT以及枚举并恢复IDT的代码

admin

GDT：

1. typedef union _KGDTENTRY64
   
2. {
   
3.         struct
   
4.         {
   
5.                 USHORT LimitLow;
   
6.                 USHORT BaseLow;                                //base:2B
   
7.                 union
   
8.                 {
   
9.                         struct
   
10.                         {
    
11.                                 UCHAR BaseMiddle;        //base:1B
    
12.                                 UCHAR Flags1;
    
13.                                 UCHAR Flags2;
    
14.                                 UCHAR BaseHigh;                //BASE:1B
    
15.                         } Bytes;
    
16.                         struct
    
17.                         {
    
18.                                 ULONG BaseMiddle:8;
    
19.                                 ULONG Type:4;
    
20.                                 ULONG S:1;
    
21.                                 ULONG Dpl:2;                //DPL
    
22.                                 ULONG Present:1;        //P
    
23.                                 ULONG LimitHigh:4;
    
24.                                 ULONG System:1;
    
25.                                 ULONG LongMode:1;
    
26.                                 ULONG DefaultBig:1;
    
27.                                 ULONG Granularity:1;//G
    
28.                                 ULONG BaseHigh:8;
    
29.                         } Bits;
    
30.                 };
    
31.                 ULONG BaseUpper;                        //base:4B
    
32.                 ULONG MustBeZero;
    
33.         };
    
34.         UINT64 Alignment;
    
35. } KGDTENTRY64, *PKGDTENTRY64;
    
36. 
    
37. ULONG64 MakeULONG64ForGDT(USHORT BaseLow, UCHAR BaseMiddle, UCHAR BaseHigh, ULONG BaseUpper)
    
38. {
    
39.         ULONG64 ul64=0;
    
40.         memcpy(((PUCHAR)(&ul64))+0,&BaseLow,2);
    
41.         memcpy(((PUCHAR)(&ul64))+2,&BaseMiddle,1);
    
42.         memcpy(((PUCHAR)(&ul64))+3,&BaseHigh,1);
    
43.         memcpy(((PUCHAR)(&ul64))+4,&BaseUpper,4);
    
44.         return ul64;
    
45. }
    
46. 
    
47. typedef struct _GDT_INFO
    
48. {
    
49.         UCHAR        CpuId;
    
50.         UCHAR        DPL;
    
51.         UCHAR        P;
    
52.         UCHAR        G;
    
53.         WORD        GdtLimit;
    
54.         WORD        ItemLimit;
    
55.         ULONG64        GdtBase;
    
56.         ULONG64 ItemBase;
    
57.         ULONG        Type;
    
58.         ULONG        Selector;
    
59. } GDT_INFO, *PGDT_INFO;
    
60. 
    
61. GDT_INFO GdtInfo[256]= {0}; //“默认”CPU最多有16个核心
    
62. 
    
63. void GetGDT(ULONG64 *Base, WORD *Limit)
    
64. {
    
65.         typedef void (__fastcall *SCFN)(void);
    
66.         UCHAR data[10]= {0};
    
67.         PVOID p=&data[0];
    
68.         SCFN scfn=NULL;
    
69.         UCHAR shellcode[15]=
    
70.             "\x48\xB8\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F" //9
    
71.             "\x0F\x01\x00"                             //12
    
72.             "\xC3";                                    //13
    
73.         /*
    
74.                 mov rax,xxxxxxxxxxxxxxxxh
    
75.                 sgdt [rax]
    
76.                 ret
    
77.         */
    
78.         memcpy(shellcode+2,&p,8);
    
79.         scfn=(SCFN)MALLOC_NPP(14);
    
80.         memcpy(scfn,shellcode,14);
    
81.         scfn();
    
82.         memcpy(Base,data+2,8);
    
83.         memcpy(Limit,data,2);
    
84.         FREE(scfn);
    
85. }
    
86. 
    
87. ULONG EnumGDT()
    
88. {
    
89.         ULONG c=0,j=0,k=0,gec=0;
    
90.         ULONG CpuNumber=KeNumberProcessors;
    
91.         ULONG64 GdtBase=0;
    
92.         WORD GdtLimit=0;
    
93.         KGDTENTRY64 GdtEntry[16]= {0};
    
94.         memset(GdtInfo,0,sizeof(GDT_INFO)*256);
    
95.         for(j=0; j<CpuNumber; j++)
    
96.         {
    
97.                 KeSetSystemAffinityThread(j+1);
    
98.                 GetGDT(&GdtBase,&GdtLimit);
    
99.                 KeRevertToUserAffinityThread();
    
100.                 if(GdtLimit>256){GdtLimit=256;}
     
101.                 memcpy(GdtEntry,(PVOID)GdtBase,GdtLimit);
     
102.                 gec=(GdtLimit+1)/16;
     
103.                 for(k=0; k<gec; k++)
     
104.                 {
     
105.                         GdtInfo[c].CpuId=(UCHAR)j;
     
106.                         GdtInfo[c].GdtBase=GdtBase;
     
107.                         GdtInfo[c].GdtLimit=GdtLimit;
     
108.                         GdtInfo[c].ItemBase=MakeULONG64ForGDT(GdtEntry[k].BaseLow,(UCHAR)(GdtEntry[k].Bits.BaseMiddle),(UCHAR)(GdtEntry[k].Bits.BaseHigh),GdtEntry[k].BaseUpper);
     
109.                         GdtInfo[c].ItemLimit=GdtEntry[k].LimitLow;
     
110.                         GdtInfo[c].DPL=(UCHAR)GdtEntry[k].Bits.Dpl;
     
111.                         GdtInfo[c].P=(UCHAR)GdtEntry[k].Bits.Present;
     
112.                         GdtInfo[c].G=(UCHAR)GdtEntry[k].Bits.Granularity;
     
113.                         GdtInfo[c].Type=GdtEntry[k].Bits.Type;
     
114.                         GdtInfo[c].Selector=k*16;
     
115.                         c++;
     
116.                 }
     
117.                 if(c>256){break;}
     
118.         }
     
119.         return c;
     
120. }

复制代码

IDT：

1. /*
   
2. nt!_KIDTENTRY64
   
3.    +0x000 OffsetLow        : Uint2B
   
4.    +0x002 Selector         : Uint2B
   
5.    +0x004 IstIndex         : Pos 0, 3 Bits
   
6.    +0x004 Reserved0        : Pos 3, 5 Bits
   
7.    +0x004 Type             : Pos 8, 5 Bits
   
8.    +0x004 Dpl              : Pos 13, 2 Bits
   
9.    +0x004 Present          : Pos 15, 1 Bit
   
10.    +0x006 OffsetMiddle     : Uint2B
    
11.    +0x008 OffsetHigh       : Uint4B
    
12.    +0x00c Reserved1        : Uint4B
    
13.    +0x000 Alignment        : Uint8B
    
14. */
    
15. typedef struct _IDTENTRY64
    
16. {
    
17.         USHORT OffsetLow;
    
18.         USHORT Selector;
    
19.         USHORT BitInfo;
    
20.         USHORT OffsetMiddle;
    
21.         ULONG  OffsetHigh;
    
22.         ULONG  Reserved1;
    
23. } IDTENTRY64, *PIDTENTRY64;
    
24. 
    
25. 
    
26. IDTENTRY64 IdtInfo[8192]= {0}; //“默认”CPU最多有32个核心
    
27. 
    
28. ULONG EnumIDT()
    
29. {
    
30.         PUCHAR CurrentIdtBaseAddressOffset,CurrentIdtBaseAddress;
    
31.         ULONG c=0,j=0;
    
32.         ULONG CpuNumber=KeNumberProcessors;
    
33.         memset(IdtInfo,0,sizeof(IDTENTRY64)*256);
    
34.         for(j=0; j<CpuNumber; j++)
    
35.         {
    
36.                 KeSetSystemAffinityThread(j+1);
    
37.                 CurrentIdtBaseAddressOffset=(PUCHAR)__readmsr(0xC0000101) + 0x38;
    
38.                 KeRevertToUserAffinityThread();
    
39.                 CurrentIdtBaseAddress=(PUCHAR)(*(ULONG64*)CurrentIdtBaseAddressOffset);
    
40.                 memcpy(&IdtInfo[j*256], CurrentIdtBaseAddress, 256*sizeof(IDTENTRY64));
    
41.                 c=c+256;
    
42.                 if(c > 256*32){break;}
    
43.         }
    
44.         return c;
    
45. }
    
46. 
    
47. void SplitQWORDforIDT(ULONG64 Number, ULONG *high, USHORT *middle, USHORT *low)
    
48. {
    
49.         memcpy(high,((PUCHAR)&Number)+4,4);
    
50.         memcpy(middle,((PUCHAR)&Number)+2,2);
    
51.         memcpy(low,((PUCHAR)&Number),2);
    
52. }
    
53. 
    
54. void ModifyIDT(UCHAR cpu, UCHAR id, ULONG64 Address)
    
55. {
    
56.         ULONG high_dword=0;
    
57.         USHORT mid_word=0,low_word=0;
    
58.         PIDTENTRY64 TargetAddress;
    
59.         PUCHAR CurrentIdtBaseAddressOffset,CurrentIdtBaseAddress;
    
60.         KeSetSystemAffinityThread(cpu+1);
    
61.         CurrentIdtBaseAddressOffset=(PUCHAR)__readmsr(0xC0000101) + 0x38;
    
62.         KeRevertToUserAffinityThread();
    
63.         CurrentIdtBaseAddress=(PUCHAR)(*(ULONG64*)CurrentIdtBaseAddressOffset);
    
64.         TargetAddress=(PIDTENTRY64)(CurrentIdtBaseAddress+id*16);
    
65.         SplitQWORDforIDT(Address,&high_dword,&mid_word,&low_word);
    
66.         _disable();
    
67.         TargetAddress->OffsetLow=low_word;
    
68.         TargetAddress->OffsetMiddle=mid_word;
    
69.         TargetAddress->OffsetHigh=high_dword;
    
70.         _enable();
    
71. }

复制代码