1.内核重载：

  • image.png

    2.内核重载的步骤

    1. 将内核文件加载到内存中
    2. 将文件展开到内存中的状态
    3. 通过LDR链获取ntkrnlpa.exe的基址
    4. 修复新内核的重定位
    5. 修复新的SSDT表
    6. 拦截系统调用，HOOK KiFastCallEntry，让自己的HOOK函数判断是走新内核还是老内核

image.png

注意：

image.png

  1. #include <ntifs.h>
  2. #include <ntimage.h>
  4. PDRIVER_OBJECT g_pDriver = NULL;
  7. #pragma pack(1)
  8. typedef struct _ServiceDesriptorEntry
  9. {
  10.     ULONG *ServiceTableBase;        // 服务表基址
  11.     ULONG *ServiceCounterTableBase; // 计数表基址
  12.     ULONG NumberOfServices;         // 表中项的个数
  13.     UCHAR *ParamTableBase;          // 参数表基址
  14. }SSDTEntry, *PSSDTEntry;
  15. #pragma pack()
  17. // 导入SSDT
  18. NTSYSAPI SSDTEntry KeServiceDescriptorTable;
  20. PSSDTEntry g_pNewSSDT;//新的SSDT
  21. ULONG g_JmpPoint;
  22. PUCHAR pHookPoint;
  24. HANDLE KernelCreateFile(
  25.     IN PUNICODE_STRING pstrFile, // 文件路径符号链接
  26.     IN BOOLEAN         bIsDir)   // 是否为文件夹
  27. {
  28.     HANDLE          hFile = NULL;
  29.     NTSTATUS        Status = STATUS_UNSUCCESSFUL;
  30.     IO_STATUS_BLOCK StatusBlock = { 0 };
  31.     ULONG           ulShareAccess =
  32.         FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
  33.     ULONG           ulCreateOpt =
  34.         FILE_SYNCHRONOUS_IO_NONALERT;
  35.     // 1. 初始化OBJECT_ATTRIBUTES的内容
  36.     OBJECT_ATTRIBUTES objAttrib = { 0 };
  37.     ULONG             ulAttributes =
  38.         OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE;
  39.     InitializeObjectAttributes(
  40.         &objAttrib,    // 返回初始化完毕的结构体
  41.         pstrFile,      // 文件对象名称
  42.         ulAttributes,  // 对象属性
  43.         NULL, NULL);   // 一般为NULL
  44.     // 2. 创建文件对象
  45.     ulCreateOpt |= bIsDir ?
  46.         FILE_DIRECTORY_FILE : FILE_NON_DIRECTORY_FILE;
  47.     Status = ZwCreateFile(
  48.         &hFile,                // 返回文件句柄
  49.         GENERIC_ALL,           // 文件操作描述
  50.         &objAttrib,            // OBJECT_ATTRIBUTES
  51.         &StatusBlock,          // 接受函数的操作结果
  52.         0,                     // 初始文件大小
  53.         FILE_ATTRIBUTE_NORMAL, // 新建文件的属性
  54.         ulShareAccess,         // 文件共享方式
  55.         FILE_OPEN_IF,          // 文件存在则打开不存在则创建
  56.         ulCreateOpt,           // 打开操作的附加标志位
  57.         NULL,                  // 扩展属性区
  58.         0);                   // 扩展属性区长度
  59.     if (!NT_SUCCESS(Status))
  60.         return (HANDLE)-1;
  61.     return hFile;
  62. }
  64. ULONG64 KernelGetFileSize(IN HANDLE hfile)
  65. {
  66.     // 查询文件状态
  67.     IO_STATUS_BLOCK           StatusBlock = { 0 };
  68.     FILE_STANDARD_INFORMATION fsi = { 0 };
  69.     NTSTATUS Status = STATUS_UNSUCCESSFUL;
  70.     Status = ZwQueryInformationFile(
  71.         hfile,        // 文件句柄
  72.         &StatusBlock, // 接受函数的操作结果
  73.         &fsi,         // 根据最后一个参数的类型输出相关信息
  74.         sizeof(FILE_STANDARD_INFORMATION),
  75.         FileStandardInformation);
  76.     if (!NT_SUCCESS(Status))
  77.         return 0;
  78.     return fsi.EndOfFile.QuadPart;
  79. }
  81. ULONG64 KernelReadFile(
  82.     IN  HANDLE         hfile,    // 文件句柄
  83.     IN  PLARGE_INTEGER Offset,   // 从哪里开始读取
  84.     IN  ULONG          ulLength, // 读取多少字节
  85.     OUT PVOID          pBuffer)  // 保存数据的缓存
  86. {
  87.     // 1. 读取文件
  88.     IO_STATUS_BLOCK StatusBlock = { 0 };
  89.     NTSTATUS        Status = STATUS_UNSUCCESSFUL;
  90.     Status = ZwReadFile(
  91.         hfile,        // 文件句柄
  92.         NULL,         // 信号状态(一般为NULL)
  93.         NULL, NULL,   // 保留
  94.         &StatusBlock, // 接受函数的操作结果
  95.         pBuffer,      // 保存读取数据的缓存
  96.         ulLength,     // 想要读取的长度
  97.         Offset,       // 读取的起始偏移
  98.         NULL);        // 一般为NULL
  99.     if (!NT_SUCCESS(Status))  return 0;
  100.     // 2. 返回实际读取的长度
  101.     return StatusBlock.Information;
  102. }
  103. typedef struct _LDR_DATA_TABLE_ENTRY {
  104.     LIST_ENTRY InLoadOrderLinks;    //双向链表
  105.     LIST_ENTRY InMemoryOrderLinks;
  106.     LIST_ENTRY InInitializationOrderLinks;
  107.     PVOID DllBase;
  108.     PVOID EntryPoint;
  109.     ULONG SizeOfImage;
  110.     UNICODE_STRING FullDllName;
  111.     UNICODE_STRING BaseDllName;
  112.     ULONG Flags;
  113.     USHORT LoadCount;
  114.     USHORT TlsIndex;
  115.     union {
  116.         LIST_ENTRY HashLinks;
  117.         struct {
  118.             PVOID SectionPointer;
  119.             ULONG CheckSum;
  120.         };
  121.     };
  122.     union {
  123.         struct {
  124.             ULONG TimeDateStamp;
  125.         };
  126.         struct {
  127.             PVOID LoadedImports;
  128.         };
  129.     };
  130. } LDR_DATA_TABLE_ENTRY, *PLDR_DATA_TABLE_ENTRY;
  132. void * SearchMemory(char * buf, int BufLenth, char * Mem, int MaxLenth)
  133. {
  134.     int MemIndex = 0;
  135.     int BufIndex = 0;
  136.     for (MemIndex = 0; MemIndex < MaxLenth; MemIndex++)
  137.     {
  138.         BufIndex = 0;
  139.         if (Mem[MemIndex] == buf[BufIndex] || buf[BufIndex] == '?')
  140.         {
  141.             int MemIndexTemp = MemIndex;
  142.             do
  143.             {
  144.                 MemIndexTemp++;
  145.                 BufIndex++;
  146.             } while ((Mem[MemIndexTemp] == buf[BufIndex] || buf[BufIndex] == '?') && BufIndex < BufLenth);
  147.             if (BufIndex == BufLenth)
  148.             {
  149.                 return Mem + MemIndex;
  150.             }
  152.         }
  153.     }
  154.     return 0;
  155. }
  157. void OffProtected()
  158. {
  159.     __asm { //关闭内存保护
  160.         cli;
  161.         push eax;
  162.         mov eax, cr0;
  163.         and eax, ~0x10000;
  164.         mov cr0, eax;
  165.         pop eax;
  166.     }
  168. }
  169. void OnProtected()
  170. {
  171.     __asm { //恢复内存保护
  172.         push eax;
  173.         mov eax, cr0;
  174.         or eax, 0x10000;
  175.         mov cr0, eax;
  176.         pop eax;
  177.         sti;
  178.     }
  180. }
  185. ULONG32 MyGetModuleHandle(PUNICODE_STRING pModuleName)
  186. {
  187.     PLDR_DATA_TABLE_ENTRY pLdr =
  188.         (PLDR_DATA_TABLE_ENTRY)g_pDriver->DriverSection;
  189.     LIST_ENTRY *pTemp = &pLdr->InLoadOrderLinks;
  190.     do
  191.     {
  192.         PLDR_DATA_TABLE_ENTRY pDriverInfo =
  193.             (PLDR_DATA_TABLE_ENTRY)pTemp;
  194.         if (RtlCompareUnicodeString(pModuleName, &pDriverInfo->BaseDllName, FALSE) == 0)
  195.         {
  196.             return pDriverInfo->DllBase;
  197.         }
  198.         pTemp = pTemp->Blink;
  199.     } while (pTemp != &pLdr->InLoadOrderLinks);
  200.     return 0;
  201. }
  203. //windows根据不同的环境，会加载不同的内核文件
  204. //单核，开了PAE  
  205. //单核，没开PAE
  206. //多核，开了PAE
  207. //多核，没开PAE
  210. void ReadKernelToBuf(PWCHAR pPath, PUCHAR* pBuf)
  211. {
  212.     //-----------------------------------------
  213.     UNICODE_STRING pKernelPath;  //内核文件路径
  214.     HANDLE hFile = 0;            //内核文件句柄
  215.     LARGE_INTEGER Offset = { 0 };//读取的偏移值
  216.     //-----------------------------------------
  217.     //1 打开文件
  218.     RtlInitUnicodeString(
  219.         &pKernelPath,
  220.         pPath);
  221.     hFile = KernelCreateFile(&pKernelPath, FALSE);
  222.     //2 获取文件大小
  223.     ULONG64 ulFileSize = KernelGetFileSize(hFile);
  224.     *pBuf = ExAllocatePool(NonPagedPool, ulFileSize);
  225.     RtlZeroMemory(*pBuf, ulFileSize);
  226.     //3 读取文件到内存
  227.     KernelReadFile(hFile, &Offset, ulFileSize, *pBuf);
  228. }
  231. void ZKKernel(PUCHAR * pZkBUf, PUCHAR buf)
  232. {
  233.     _asm int 
  234.     //1 获得DOS头，继而获得NT头，再获得扩展头
  235.     PIMAGE_DOS_HEADER pDos = (PIMAGE_DOS_HEADER)buf;
  236.     PIMAGE_NT_HEADERS pNt = (PIMAGE_NT_HEADERS)(pDos->e_lfanew + buf);
  237.     ULONG uZkSize = pNt->OptionalHeader.SizeOfImage;
  239.     //2 申请空间
  240.     *pZkBUf = ExAllocatePool(NonPagedPool, uZkSize);
  241.     RtlZeroMemory(*pZkBUf, uZkSize);
  242.     //3 开始展开
  243.     //3.1 先拷贝头部
  244.     memcpy(*pZkBUf, buf, pNt->OptionalHeader.SizeOfHeaders);
  245.     //3.2再拷贝区段
  246.     PIMAGE_SECTION_HEADER pSection = IMAGE_FIRST_SECTION(pNt);
  247.     for (int i = 0; i < pNt->FileHeader.NumberOfSections; i++)
  248.     {
  249.         memcpy(
  250.             *pZkBUf + pSection[i].VirtualAddress,//本区段内存中的起始位置
  251.             buf + pSection[i].PointerToRawData,  //本区段在文件中的位置
  252.             pSection[i].Misc.VirtualSize         //本区段的大小
  253.         );
  254.     }
  255. }
  256. typedef struct _TYPE {
  258.     USHORT Offset : 12;
  259.     USHORT Type : 4;
  260. }TYPE, *PTYPE;
  261. void FixReloc(PUCHAR ZkBuf, PUCHAR OldBase)
  262. {
  265.     //1 获得DOS头，继而获得NT头，再获得扩展头
  266.     PIMAGE_DOS_HEADER pDos = (PIMAGE_DOS_HEADER)ZkBuf;
  267.     PIMAGE_NT_HEADERS pNt = (PIMAGE_NT_HEADERS)(pDos->e_lfanew + ZkBuf);
  272.     //2 获得重定位表
  274.     PIMAGE_DATA_DIRECTORY pRelocDir = (pNt->OptionalHeader.DataDirectory + 5);
  275.     PIMAGE_BASE_RELOCATION pReloc = (PIMAGE_BASE_RELOCATION)
  276.         (pRelocDir->VirtualAddress + ZkBuf);
  278.     //2.5 得到一个老内核与默认基址间的一个差值
  279.     ULONG uOffset = (ULONG)OldBase - pNt->OptionalHeader.ImageBase;
  281.     //3 开始修复重定位
  282.     while (pReloc->SizeOfBlock != 0)
  283.     {
  284.         ULONG uCount = (pReloc->SizeOfBlock - 8) / 2;//本0x1000内，有多少需要重定位的地方
  285.         ULONG uBaseRva = pReloc->VirtualAddress;     //本0x1000的起始位置
  286.         PTYPE pType = (PTYPE)(pReloc + 1);
  287.         for (int i = 0; i < uCount; i++)
  288.         {
  289.             if (pType->Type == 3)
  290.             {
  291.                 PULONG pRelocPoint = (uBaseRva + pType->Offset + ZkBuf);
  292.                 //重定位后的地址 - 新基址 = 没重定位的地址 - 默认基址
  293.                 //所以：重定位后的地址 = 新基址 - 默认基址 + 没重定位的地址
  294.                 *pRelocPoint = uOffset + *pRelocPoint;
  295.             }
  296.             pType++;
  297.         }
  298.         pReloc = (PIMAGE_BASE_RELOCATION)((ULONG)pReloc + pReloc->SizeOfBlock);
  299.     }
  301. }
  303. void FixSSDT(PUCHAR pZKBuf, PUCHAR OldBase)
  304. {
  306.     //新内核某位置1 - 新内核基址 = 老内核某位置1 - 老内核基址；
  307.     //新内核某位置1 = 新内核基址 - 老内核基址 + 老内核某位置1;
  309.     LONG Offset = (ULONG)pZKBuf - (ULONG)OldBase;
  310.     //1 得到新内核中的SSDT
  311.     g_pNewSSDT = (PSSDTEntry)((LONG)&KeServiceDescriptorTable + Offset);
  313.     //2 填充系统服务个数
  314.     g_pNewSSDT->NumberOfServices = KeServiceDescriptorTable.NumberOfServices;
  316.     //3 填充SSDT表
  317.     g_pNewSSDT->ServiceTableBase = (ULONG *)((PUCHAR)KeServiceDescriptorTable.ServiceTableBase + Offset);
  318.     //让所有的SSDT中保存的函数地址，都指向新内核
  319.     for (int i = 0; i < g_pNewSSDT->NumberOfServices; i++)
  320.     {
  321.         g_pNewSSDT->ServiceTableBase[i] = g_pNewSSDT->ServiceTableBase[i] + Offset;
  322.     }
  323.     //4 填充参数表
  324.     g_pNewSSDT->ParamTableBase = (PULONG)((PUCHAR)KeServiceDescriptorTable.ParamTableBase + Offset);
  325.     memcpy(g_pNewSSDT->ParamTableBase,
  326.         KeServiceDescriptorTable.ParamTableBase,
  327.         g_pNewSSDT->NumberOfServices
  328.     );
  329. }
  331. ULONG GetKiFastCallEntry()
  332. {
  333.     ULONG uAddress = 0;
  334.     _asm
  335.     {
  336.         push eax;
  337.         push ecx;
  338.         mov ecx, 0x176;
  339.         rdmsr;
  340.         mov uAddress, eax;
  341.         pop ecx;
  342.         pop eax;
  343.     }
  344.     return uAddress;
  345. }
  348. ULONG   FilterFun(ULONG SSdtBase, PULONG OldFun, ULONG Id)
  349. {
  350.     //如果相等，说明调用的是SSDT中的函数
  351.     if (SSdtBase == (ULONG)KeServiceDescriptorTable.ServiceTableBase)
  352.     {
  353.         //使用思路：
  354.         //假如进程是OD，并且函数调用是190号，就走新内核中的函数，这样通过hookOpenProcess就无法拦住OD了。
  355.         return g_pNewSSDT->ServiceTableBase[Id];
  356.     }
  357.     return OldFun;
  359. }
  361. _declspec(naked)void MyHookFun()
  362. {
  363.     //eax 里面是调用号，edx里面是老函数地址，edi里面是SSDT基址
  364.     _asm {
  365.         pushad;
  366.         pushfd;
  367.         push eax;
  368.         push edx;
  369.         push edi;
  371.         call FilterFun;
  372.         mov dword ptr ds : [esp + 0x18], eax;
  373.         popfd;
  374.         popad;
  375.         sub     esp, ecx
  376.             shr     ecx, 2
  377.             jmp     g_JmpPoint
  378.     }
  379. }
  382. UCHAR Old_Code[5] = { 0 };
  388. void OnHookKiFastCallEntry()
  389. {
  390.     char buf[] = { 0x2b, 0xe1, 0xc1, 0xe9, 0x02 };
  391.     ULONG KiFastCallEntryAdd = GetKiFastCallEntry();
  392.     pHookPoint = SearchMemory(buf, 5, (char*)KiFastCallEntryAdd, 0x200);
  393.     g_JmpPoint = (ULONG)(pHookPoint + 5);
  394.     memcpy(Old_Code, pHookPoint, 5);
  395.     OffProtected();
  396.     pHookPoint[0] = 0xE9;
  397.     *(ULONG*)(&pHookPoint[1]) = (ULONG)MyHookFun - (ULONG)pHookPoint - 5;
  398.     OnProtected();
  399. }
  403. void KernelReload()
  404. {
  406.     PUCHAR pBuf = NULL;
  407.     PUCHAR pZKBuf = NULL;
  408.     UNICODE_STRING KernelName;
  410.     //1 首先把内核文件读取到内存里
  411.     //ReadKernelToBuf(L"\\??\\C:\\Windows\\System32\\ntoskrnl.exe", &pBuf);
  412.     ReadKernelToBuf(L"\\??\\C:\\Windows\\System32\\ntoskrnl.exe", &pBuf);
  413.     //2 把读到内存中的内核给展开成0x1000对齐
  414.     ZKKernel(&pZKBuf, pBuf);
  415.     ExFreePool(pBuf);
  416.     //3 修复新内核的重定位
  417.     RtlInitUnicodeString(&KernelName, L"ntoskrnl.exe");
  418.     ULONG32 uBase = MyGetModuleHandle(&KernelName);
  419.     FixReloc(pZKBuf, (PUCHAR)uBase);
  420.     //4 修复新的SSDT表
  421.     FixSSDT(pZKBuf, (PUCHAR)uBase);
  422.     //5 Hook掉KiFastCallEntry，在自己的Hook函数中判断应该走新内核还是老内核
  423.     OnHookKiFastCallEntry();
  427. }
  429. void EnumDirver1(PDRIVER_OBJECT pDriver)
  430. {
  431.     PLDR_DATA_TABLE_ENTRY pLdr =
  432.         (PLDR_DATA_TABLE_ENTRY)pDriver->DriverSection;
  433.     LIST_ENTRY *pTemp = &pLdr->InLoadOrderLinks;
  434.     do
  435.     {
  436.         PLDR_DATA_TABLE_ENTRY pDriverInfo =
  437.             (PLDR_DATA_TABLE_ENTRY)pTemp;
  438.         KdPrint(("%wZ\n", &pDriverInfo->BaseDllName));
  439.         pTemp = pTemp->Blink;
  440.     } while (pTemp != &pLdr->InLoadOrderLinks);
  441. }
  443. void UnHook()
  444. {
  445.     OffProtected();
  446.     memcpy(pHookPoint, Old_Code, 5);
  447.     OnProtected();
  448. }
  450. VOID DriverUnload(PDRIVER_OBJECT pDriver)
  451. {
  452.     pDriver;
  453.     UnHook();
  454.     KdPrint(("Leave"));
  455. }
  456. NTSTATUS DriverEntry(PDRIVER_OBJECT pDriver, PUNICODE_STRING pPath)
  457. {
  458.     UNREFERENCED_PARAMETER(pPath);
  459.     DbgBreakPoint();
  460.     g_pDriver = pDriver;
  461.     //EnumDirver1(pDriver);
  462.     KernelReload();
  465.     pDriver->DriverUnload = DriverUnload;
  466.     return STATUS_SUCCESS;
  467. }