设为首页收藏本站
开启辅助访问 切换到宽版

看流星社区

 找回密码
 注册账号
看流星社区»看流星社区 › » 【编程技术】 › 驱动开发技术 › 游戏保护大放送之HP驱动，新版。
返回列表 发新帖
查看: 4463|回复: 3

游戏保护大放送之HP驱动，新版。

[复制链接]
八月的樱花

该用户从未签到
发表于 2012-10-18 20:34:03 | 显示全部楼层 |阅读模式


  3. #include "struct.h"
  4. #include "FGPK.h"

  6. //////////////////////////////////////////////////////////////////////////

  8. char g_pFindOrigCode[8];
  9. ULONG KiSystemService_hack_address=0;
  10. PULONG  pSSDTKernel,pSSWDTKernel;
  11. PSERVICE_DESCRIPTOR_TABLE_SHADOW _KeServiceDescriptorTable;
  12. PSERVICE_DESCRIPTOR_TABLE_SHADOW  ShadowTable;
  13. unsigned long SSDT_reentry_address,SSDTDW_reentry_address;


  16. ULONG g_Dra_count=0;
  17. ULONG g_Sem_count=0;

  19. //////////////////////////////////////////////////////////////////////////
  20. void RePlaceSSDT();
  21. void RestoreSSDT();

  23. ULONG Pass_NtCreateMutant();
  24. VOID UnDetour_NtCreateMutant();

  26. ULONG Pass_NtQuerySystemInformation();
  27. VOID UnDetour_NtQuerySystemInformation();

  29. ULONG Pass_NtOpenProcess();
  30. VOID UnDetour_NtOpenProcess();

  32. NTSTATUS HookFindWindow();
  33. NTSTATUS UnHookFindWindow();

  35. ULONG Pass_NtReadVirtualMemory();
  36. VOID UnDetour_NtReadVirtualMemory();

  38. ULONG Pass_NtWriteVirtualMemory();
  39. VOID UnDetour_NtWriteVirtualMemory();

  41. ULONG Pass_NtCreateSemaphore();
  42. VOID UnDetour_NtCreateSemaphore();


  45. ULONG Pass_NtReleaseSemaphore();
  46. VOID UnDetour_NtReleaseSemaphore();

  48. ULONG Pass_NtOpenSemaphore();
  49. VOID UnDetour_NtOpenSemaphore();

  51. ULONG Pass_NtQueryObject();
  52. VOID UnDetour_NtQueryObject();


  55. ULONG Pass_NtWaitForSingleObject();
  56. VOID UnDetour_NtWaitForSingleObject();

  58. NTSTATUS HookNtUserPostMessage();
  59. NTSTATUS UnHookNtUserPostMessage();

  61. NTSTATUS HookNtUserSendInput();
  62. NTSTATUS UnHookNtUserSendInput();

  64. NTSTATUS HookNtUserMessageCall();
  65. NTSTATUS UnHookNtUserMessageCall();



  69. NTSTATUS InitSWSSDT();

  71. ULONG IsHooked=0;

  73. ULONG HookSysCall();
  74. NTSTATUS GetHookedFunAdd();



  78. //////////////////////////////////////////////////////////////////////////


  81. PEPROCESS crsEProc;

  83. PSERVICE_DESCRIPTOR_TABLE KeServiceDescriptorTableShadow;

  85. __declspec(dllimport) _stdcall KeAddSystemServiceTable(PVOID, PVOID, PVOID, PVOID, PVOID);


  88. #define ObjectNameInformation  1

  90. #define SystemHandleInformation 0x10

  92. typedef struct _SYSTEM_HANDLE_INFORMATION {
  93.   ULONG ProcessId;
  94.   UCHAR ObjectTypeNumber;
  95.   UCHAR Flags;
  96.   USHORT Handle;
  97.   PVOID Object;
  98.   ACCESS_MASK GrantedAccess;
  99. } _SYSTEM_HANDLE_INFORMATION, *P_SYSTEM_HANDLE_INFORMATION;


  102. typedef struct _SYSTEM_HANDLE_INformATION_EX {
  103.   ULONG NumberOfHandles;
  104.   _SYSTEM_HANDLE_INFORMATION Information[1];
  105. } _SYSTEM_HANDLE_INFORMATION_EX, *PSYSTEM_HANDLE_INFORMATION_EX;

  107. //////////////////////////////////////////////////////////////////////////

  109. NTSTATUS
  110. DriverEntry(
  111.   PDRIVER_OBJECT pDriverObj,
  112.   PUNICODE_STRING pRegistryString
  113.   )
  114. {
  115.   NTSTATUS status = STATUS_SUCCESS;
  116.   UNICODE_STRING ustrLinkName;
  117.   UNICODE_STRING ustrDevName;   
  118.   PDEVICE_OBJECT pDevObj;

  120.   dprintf("[FGPK] DriverEntry\n");
  121.   
  122.   pDriverObj->MajorFunction[IRP_MJ_CREATE] = DispatchCreate;
  123.   pDriverObj->MajorFunction[IRP_MJ_CLOSE] = DispatchClose;
  124.   pDriverObj->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DispatchIoctl;
  125.   pDriverObj->DriverUnload = DriverUnload;


  128.   RtlInitUnicodeString(&ustrDevName, DEVICE_NAME);
  129.   status = IoCreateDevice(pDriverObj,
  130.         0,
  131.         &ustrDevName,
  132.         FILE_DEVICE_UNKNOWN,
  133.         0,
  134.         FALSE,
  135.         &pDevObj);

  137.   if(!NT_SUCCESS(status))  {
  138.     dprintf("[FGPK] IoCreateDevice = 0x%x\n", status);
  139.     return status;
  140.   }

  142.   RtlInitUnicodeString(&ustrLinkName, LINK_NAME);
  143.   status = IoCreateSymbolicLink(&ustrLinkName, &ustrDevName);  
  144.   if(!NT_SUCCESS(status)) {
  145.     dprintf("[FGPK] IoCreateSymbolicLink = 0x%x\n", status);
  146.     IoDeleteDevice(pDevObj);  
  147.     return status;
  148.   }
  149.   

  151.   //
  152.   // 添加执行代码
  153.   //

  155.   RePlaceSSDT();

  157.   InitSWSSDT();

  159. //  Pass_NtQueryObject();

  161. //  Pass_NtCreateMutant();

  163. //  Pass_NtCreateSemaphore();

  165. //  Pass_NtReleaseSemaphore();

  167. //  Pass_NtOpenSemaphore();

  169. //  Pass_NtWaitForSingleObject();

  171. //  Pass_NtQuerySystemInformation();

  173.   Pass_NtOpenProcess();

  175. //  Pass_NtReadVirtualMemory();

  177. //  Pass_NtWriteVirtualMemory();

  179. //  HookFindWindow();

  181. //  HookNtUserMessageCall();

  183. //  HookNtUserSendInput();

  185. //  HookNtUserPostMessage();

  187.   return STATUS_SUCCESS;
  188. }


  191. VOID
  192. DriverUnload(
  193.   PDRIVER_OBJECT pDriverObj
  194.   )
  195. {  
  196.   UNICODE_STRING strLink;
  197.   RtlInitUnicodeString(&strLink, LINK_NAME);

  199.   //
  200.   // 添加卸载代码
  201.   //

  203.   
  204.   
  205. //  UnDetour_NtOpenSemaphore();

  207. //  UnDetour_NtWaitForSingleObject();

  209. //  UnDetour_NtCreateSemaphore();

  211. //  UnDetour_NtReleaseSemaphore();

  213. //  UnDetour_NtCreateMutant();

  215. //  UnDetour_NtQueryObject();

  217. //  UnDetour_NtQuerySystemInformation();

  219.   UnDetour_NtOpenProcess();

  221. //  UnDetour_NtReadVirtualMemory();

  223. //  UnDetour_NtWriteVirtualMemory();

  225. //  UnHookFindWindow();

  227. //  UnHookNtUserPostMessage();

  229. //  UnHookNtUserSendInput();

  231. //  UnHookNtUserMessageCall();

  233.   
  234.   RestoreSSDT();


  237. //  Sleep(5000);
  238.   
  239.   IoDeleteSymbolicLink(&strLink);
  240.   IoDeleteDevice(pDriverObj->DeviceObject);
  241.   dprintf("[FGPK] Unloaded\n");
  242. }


  245. NTSTATUS
  246. DispatchCreate(
  247.   PDEVICE_OBJECT pDevObj,
  248.   PIRP pIrp
  249.   )
  250. {
  251.   pIrp->IoStatus.Status = STATUS_SUCCESS;
  252.   pIrp->IoStatus.Information = 0;

  254.   dprintf("[FGPK] IRP_MJ_CREATE\n");

  256.   IoCompleteRequest(pIrp, IO_NO_INCREMENT);
  257.   return STATUS_SUCCESS;
  258. }


  261. NTSTATUS
  262. DispatchClose(
  263.   PDEVICE_OBJECT pDevObj,
  264.   PIRP pIrp
  265.   )
  266. {
  267.   pIrp->IoStatus.Status = STATUS_SUCCESS;
  268.   pIrp->IoStatus.Information = 0;

  270.   dprintf("[FGPK] IRP_MJ_CLOSE\n");

  272.   IoCompleteRequest(pIrp, IO_NO_INCREMENT);
  273.   return STATUS_SUCCESS;
  274. }


  277. NTSTATUS
  278. DispatchIoctl(
  279.   PDEVICE_OBJECT pDevObj,
  280.   PIRP pIrp
  281.   )
  282. {
  283.   NTSTATUS status = STATUS_INVALID_DEVICE_REQUEST;
  284.   PIO_STACK_LOCATION pIrpStack;
  285.   ULONG uIoControlCode;
  286.   PVOID pIoBuffer;
  287.   ULONG uInSize;
  288.   ULONG uOutSize;

  290.   pIrpStack = IoGetCurrentIrpStackLocation(pIrp);
  291.   uIoControlCode = pIrpStack->Parameters.DeviceIoControl.IoControlCode;
  292.   pIoBuffer = pIrp->AssociatedIrp.SystemBuffer;
  293.   uInSize = pIrpStack->Parameters.DeviceIoControl.InputBufferLength;
  294.   uOutSize = pIrpStack->Parameters.DeviceIoControl.OutputBufferLength;

  296.   switch(uIoControlCode) {

  298.     case IOCTL_HELLO: {
  299.       
  300.       dprintf("[FGPK] Hello\n");

  302.       GetHookedFunAdd();

  304.       HookSysCall();

  306.       IsHooked=1;
  307.       status = STATUS_SUCCESS;
  308.     }
  309.     break;

  311.     //
  312.     // 添加执行代码
  313.     //

  315.   }

  317.   if(status == STATUS_SUCCESS)
  318.     pIrp->IoStatus.Information = uOutSize;
  319.   else
  320.     pIrp->IoStatus.Information = 0;
  321.   
  322.   /////////////////////////////////////
  323.   pIrp->IoStatus.Status = status;
  324.   IoCompleteRequest(pIrp, IO_NO_INCREMENT);

  326.   return status;
  327. }
  328. //////////////////////////////////////////////////////////////////////////

  330. NTSTATUS IsGame()
  331. {
  332.   if (!strcmp("HProtect.exe",GetProcessNameFromEProc(0)) || !strcmp("zhengtu2.dat",GetProcessNameFromEProc(0)))
  333.   {
  334.     return 1;
  335.   }
  336.   return 0;
  337. }

  339. //////////////////////////////////////////////////////////////////////////



  343. void __declspec(naked) my_function_detour_KiFastCallEntry()
  344. {
  345.   __asm
  346.   {
  347.     cmp     ecx,10h
  348.     jne    SSDT

  350.     pushad
  351.     call    IsGame
  352.     cmp    eax,1
  353.     popad
  354.     je      ZTGAME1

  356.     mov    edi,KeServiceDescriptorTable
  357.     sub    edi,0x10

  359. ZTGAME1:
  360.     jmp    [SSDTDW_reentry_address]

  362. SSDT:

  364.     pushad
  365.     call    IsGame
  366.     cmp    eax,1
  367.     popad
  368.     je      ZTGAME2

  370.     mov    edi,KeServiceDescriptorTable
  371.     add    edi,0x20

  373. ZTGAME2:
  374.     jmp    [SSDT_reentry_address]


  377.   }

  379. }

  381. UCHAR findcode[]={0x83,0xf9,0x10,0x75};

  383. VOID FindHackAddr()
  384. {
  385.     ULONG  uSysenter;
  386.     ULONG i=0;
  387.     PUCHAR strSysenter;

  389.   __asm{
  390.         mov ecx,0x176
  391.         rdmsr
  392.         mov uSysenter,eax  //得到KiFastCallEntry地址
  393.       }
  394.   strSysenter=(PUCHAR)uSysenter;
  395.   for (i=0;i<0x100;i++)
  396.   {
  397.     if (
  398.       findcode[0]==strSysenter[i] &&
  399.       findcode[1]==strSysenter[i+1] &&
  400.       findcode[2]==strSysenter[i+2] &&
  401.       findcode[3]==strSysenter[i+3] )
  402.     {
  403.       break;
  404.     }

  406.   }

  408.   KiSystemService_hack_address=uSysenter+i;

  410. }
  411. ULONG HookSysCall()
  412. {
  413.   KIRQL  oldIrql;


  416.   unsigned char newcode[] = { 0xE9, 0x44, 0x33, 0x22, 0x11};

  418.   char *actual_function;

  420.   int i = 0;

  422.   FindHackAddr();

  424.   if (KiSystemService_hack_address==0)
  425.   {
  426.     dprintf("find hack address error!\n");
  427.     return 0;
  428.   }

  430.   actual_function =(char*) KiSystemService_hack_address;

  432.   SSDT_reentry_address = KiSystemService_hack_address+0x20;
  433.   SSDTDW_reentry_address = KiSystemService_hack_address+0x5;

  435.   *( (unsigned long *)(&newcode[1]) ) = (ULONG)my_function_detour_KiFastCallEntry-KiSystemService_hack_address-5;


  438.   WPOFF();
  439.   oldIrql = KeRaiseIrqlToDpcLevel();
  440.   for(i=0;i < 5;i++)
  441.   {
  442.     g_pFindOrigCode[i] = actual_function[i];
  443.     actual_function[i] = newcode[i];
  444.   }
  445.   KeLowerIrql(oldIrql);
  446.   WPON();

  448.   return 1;
  449. }


  452. PVOID GetInfoTable(ULONG ATableType)
  453. {
  454.   ULONG mSize = 0x4000;
  455.   PVOID mPtr = NULL;
  456.   NTSTATUS St;
  457.   do
  458.   {
  459.     mPtr = ExAllocatePool(PagedPool, mSize);
  460.     memset(mPtr, 0, mSize);
  461.     if (mPtr)
  462.     {
  463.       St = ZwQuerySystemInformation(ATableType, mPtr, mSize, NULL);
  464.     } else return NULL;
  465.     if (St == STATUS_INFO_LENGTH_MISMATCH)
  466.     {
  467.       ExFreePool(mPtr);
  468.       mSize = mSize * 2;
  469.     }
  470.   } while (St == STATUS_INFO_LENGTH_MISMATCH);
  471.   if (St == STATUS_SUCCESS) return mPtr;
  472.   ExFreePool(mPtr);
  473.   return NULL;
  474. }

  476. HANDLE GetCsrPid()
  477. {
  478.   HANDLE Process, hObject;
  479.   HANDLE CsrId = (HANDLE)0;
  480.   OBJECT_ATTRIBUTES obj;
  481.   CLIENT_ID cid;
  482.   UCHAR Buff[0x100];
  483.   POBJECT_NAME_INFORMATION ObjName = (PVOID)&Buff;
  484.   PSYSTEM_HANDLE_INFORMATION_EX Handles;
  485.   ULONG r;

  487.   Handles = GetInfoTable(SystemHandleInformation);

  489.   if (!Handles) return CsrId;

  491.   for (r = 0; r < Handles->NumberOfHandles; r++)
  492.   {
  493.     if (Handles->Information[r].ObjectTypeNumber == 21) //Port object
  494.     {
  495.       InitializeObjectAttributes(&obj, NULL, OBJ_KERNEL_HANDLE, NULL, NULL);

  497.       cid.UniqueProcess = (HANDLE)Handles->Information[r].ProcessId;
  498.       cid.UniqueThread = 0;

  500.       if (NT_SUCCESS(NtOpenProcess(&Process, PROCESS_DUP_HANDLE, &obj, &cid)))
  501.       {
  502.         if (NT_SUCCESS(ZwDuplicateObject(Process, (HANDLE)Handles->Information[r].Handle,NtCurrentProcess(), &hObject, 0, 0, DUPLICATE_SAME_ACCESS)))
  503.         {
  504.           if (NT_SUCCESS(ZwQueryObject(hObject, ObjectNameInformation, ObjName, 0x100, NULL)))
  505.           {
  506.             if (ObjName->Name.Buffer && !wcsncmp(L"\\Windows\\ApiPort", ObjName->Name.Buffer, 20))
  507.             {
  508.               CsrId = (HANDLE)Handles->Information[r].ProcessId;
  509.             }
  510.           }

  512.           ZwClose(hObject);
  513.         }

  515.         ZwClose(Process);
  516.       }
  517.     }
  518.   }

  520.   ExFreePool(Handles);
  521.   return CsrId;
  522. }

  524. unsigned long AddMyServiceTable()
  525. {
  526.   ULONG  nSDTKerCallLen,nSWDTKerCallLen;
  527.   NTSTATUS status;
  528.   PEPROCESS crsEProc;


  531.   __asm
  532.   {
  533.     pushad
  534.       mov   eax,KeServiceDescriptorTable
  535.       mov   _KeServiceDescriptorTable,eax
  536.       sub   eax,0x40
  537.       mov   ShadowTable,eax
  538.       popad
  539.   }
  540.   nSDTKerCallLen  =  _KeServiceDescriptorTable->ntoskrnl.NumberOfServices;
  541.   nSWDTKerCallLen  =  ShadowTable->win32k.NumberOfServices;


  544.   pSSDTKernel =  (PULONG)ExAllocatePool( NonPagedPool, nSDTKerCallLen*sizeof(ULONG));
  545.   pSSWDTKernel=   (PULONG)ExAllocatePool( NonPagedPool, nSWDTKerCallLen*sizeof(ULONG));


  548.   if(!pSSDTKernel || !pSSWDTKernel)
  549.   {
  550.     DbgPrint("AddMyServiceTable  alloc fail\n");
  551.     return 0;
  552.   }
  553.   memset( (PVOID)pSSDTKernel, 0, nSDTKerCallLen*sizeof(ULONG));
  554.   memset( (PVOID)pSSWDTKernel, 0, nSWDTKerCallLen*sizeof(ULONG));


  557.   //填充新的SSDT表
  558.   //
  559.   RtlCopyMemory( (PVOID)pSSDTKernel,(PVOID)_KeServiceDescriptorTable->ntoskrnl.ServiceTableBase,nSDTKerCallLen*sizeof(ULONG) );


  562.   RtlCopyMemory( (PVOID)&_KeServiceDescriptorTable->NotUse1,(PVOID)&_KeServiceDescriptorTable->ntoskrnl,sizeof(SERVICE_DESCRIPTOR_TABLE) );
  563.   //sswdt

  565.   status = PsLookupProcessByProcessId((HANDLE)GetCsrPid(), &crsEProc);
  566.   if (!NT_SUCCESS( status ))
  567.   {
  568.     DbgPrint("PsLookupProcessByProcessId() error\n");
  569.     return status;
  570.   }
  571.   KeAttachProcess(crsEProc);

  573.   __try
  574.   {
  575.     RtlCopyMemory( (PVOID)pSSWDTKernel,(PVOID)ShadowTable->win32k.ServiceTableBase,nSWDTKerCallLen*sizeof(ULONG) );

  577.   }
  578.   __finally
  579.   {
  580.     KeDetachProcess();
  581.   }

  583.   RtlCopyMemory( (PVOID)&ShadowTable->NotUse1,(PVOID)&ShadowTable->ntoskrnl,sizeof(SERVICE_DESCRIPTOR_TABLE));
  584.   RtlCopyMemory( (PVOID)&ShadowTable->NotUse2,(PVOID)&ShadowTable->win32k,sizeof(SERVICE_DESCRIPTOR_TABLE));

  586.   WPOFF();
  587.   RtlCopyMemory((PVOID)&_KeServiceDescriptorTable->NotUse1.ServiceTableBase, &pSSDTKernel, sizeof(ULONG));

  589.   RtlCopyMemory((PVOID)&ShadowTable->NotUse1.ServiceTableBase, &pSSDTKernel, sizeof(ULONG));
  590.   RtlCopyMemory((PVOID)&ShadowTable->NotUse2.ServiceTableBase, &pSSWDTKernel, sizeof(ULONG));

  592.   WPON();

  594.   return 1;
  595. }

  597. void RePlaceSSDT()
  598. {
  599.   if (AddMyServiceTable())
  600.   {
  601.     HookSysCall();
  602.   }

  604. }

  606. void RestoreSSDT()
  607. {
  608.   int i;
  609.   char *actual_function = (char *)(KiSystemService_hack_address);
  610.   KIRQL  oldIrql;
  611.   WPOFF();

  613.   KeRaiseIrql( DISPATCH_LEVEL,&oldIrql );

  615.   for(i=0;i < 5;i++)
  616.   {
  617.     actual_function[i] = g_pFindOrigCode[i];
  618.   }

  620.   KeLowerIrql( oldIrql );
  621.   ExFreePool(pSSDTKernel);
  622.   ExFreePool(pSSWDTKernel);


  625.   WPON();

  627. }

  629. //////////////////////////////////////////////////////////////////////////


  632. //////////////////////////////////////////////////////////////////////////
  633. typedef NTSTATUS (*NTQUERYOBJECT)
  634. (
  635. IN HANDLE ObjectHandle,
  636. IN OBJECT_INFORMATION_CLASS ObjectInformationClass,
  637. OUT PVOID ObjectInformation,
  638. IN ULONG ObjectInformationLength,
  639. OUT PULONG ReturnLength OPTIONAL
  640. );
  641. NTQUERYOBJECT OrgNtQueryObject;

  643. //*****************************************************************************************************************
  644. NTSYSAPI
  645. NTSTATUS
  646. NTAPI
  647. ObQueryNameString(
  648.                __in       PVOID Object,
  649.                __out_opt  POBJECT_NAME_INFORMATION ObjectNameInfo,
  650.                __in       ULONG Length,
  651.                __out      PULONG ReturnLength
  652.                );


  655. NTSTATUS GetObjectNameFromHandle(HANDLE Objecthandle,PUNICODE_STRING filename)
  656. {
  657. //   PFILE_OBJECT      pFileObject;
  658. //   OBJECT_HANDLE_INFORMATION HandleInformationObject;
  659.   NTSTATUS nTstatus;
  660.   POBJECT_NAME_INFORMATION pObjectInformation;
  661.   PVOID Object;
  662.   OBJECT_HANDLE_INFORMATION HandleInformation = {0};
  663.   ULONG TempReturnLength;


  666.   pObjectInformation=ExAllocatePool(PagedPool,0x100);
  667.   RtlZeroMemory(pObjectInformation,0x100);

  669.   __try
  670.   {
  671.     nTstatus = ObReferenceObjectByHandle( Objecthandle,
  672.       0,
  673.       NULL,
  674.       0,
  675.       &Object,
  676.       &HandleInformation );

  678.     if (NT_SUCCESS( nTstatus ))
  679.     {
  680.       nTstatus = ObQueryNameString( Object,
  681.         (POBJECT_NAME_INFORMATION)pObjectInformation,
  682.         0x100,
  683.         &TempReturnLength
  684.          );

  686.       RtlCopyUnicodeString(filename,(PUNICODE_STRING)&(pObjectInformation->Name));
  687.       return 0;
  688.     }
  689.    
  690.       
  691.    
  692.    
  693.   }
  694.   __except(1)
  695.   {
  696.     dprintf("GetObjectNameFromHandle error!\n");
  697.   }

  699.   return -1;

  701. }
  702. //********************************************************************************************************************

  704. NTSTATUS __stdcall MyNtQueryObject(
  705.                    HANDLE ObjectHandle,
  706.                    OBJECT_INFORMATION_CLASS ObjectInformationClass,
  707.                    PVOID ObjectInformation,
  708.                    ULONG ObjectInformationLength,
  709.                    PULONG ReturnLength)
  710. {
  711.   NTSTATUS nTstatus;

  713.   UNICODE_STRING Objectname;
  714.   UNICODE_STRING oldname;

  716.   __try
  717.   {
  718.     if(strcmp(GetProcessNameFromEProc(0),"DragonNest.exe")==0)
  719.     {
  720.       //DragonNest pid 3548 ObjectNameInformation MyNtQueryObject name \BaseNamedObjects\dnx_579876753682410 handle 00000614

  722.       nTstatus=OrgNtQueryObject(ObjectHandle,ObjectInformationClass,ObjectInformation,ObjectInformationLength,ReturnLength);
  723.       switch (ObjectInformationClass)
  724.       {
  725.       case ObjectNameInformation:
  726.         if(ObjectInformation!=NULL)
  727.         {

  729.           POBJECT_NAME_INFORMATION  pobj_name=(POBJECT_NAME_INFORMATION)ObjectInformation;
  730.          
  731.           if (pobj_name->Name.Buffer)
  732.           {
  733.             if (wcsstr(pobj_name->Name.Buffer,L"dnx_57987675368241"))
  734.             {
  735.               dprintf("DragonNest pid %d ObjectNameInformation MyNtQueryObject name %wZ handle %08x\n",PsGetCurrentProcessId(),&(pobj_name->Name),(ULONG)ObjectHandle);
  736.               RtlInitUnicodeString(&oldname,L"\\BaseNamedObjects\\dnx_57987675368241");
  737.               RtlCopyUnicodeString(&(pobj_name->Name),&oldname);
  738.               dprintf("DragonNest pid %d ObjectNameInformation MyNtQueryObject name %wZ handle %08x\n",PsGetCurrentProcessId(),&(pobj_name->Name),(ULONG)ObjectHandle);
  739.             }
  740.             
  741.             else if (wcsstr(pobj_name->Name.Buffer,L"MutexDragonNest"))
  742.             {
  743.               dprintf("DragonNest pid %d ObjectNameInformation MyNtQueryObject name %wZ handle %08x\n",PsGetCurrentProcessId(),&(pobj_name->Name),(ULONG)ObjectHandle);
  744.             //  RtlInitUnicodeString(&oldname,L"\\BaseNamedObjects\\MutexDragonNest");
  745.             //  RtlCopyUnicodeString(&(pobj_name->Name),&oldname);
  746.               dprintf("DragonNest pid %d ObjectNameInformation MyNtQueryObject name %wZ handle %08x\n",PsGetCurrentProcessId(),&(pobj_name->Name),(ULONG)ObjectHandle);

  748.             }
  749.             
  750.           }
  751.         }
  752.         break;
  753.       case ObjectBasicInformation:
  754.         if(ObjectInformation!=NULL)
  755.         {
  756.           POBJECT_BASIC_INFORMATION  pobj_basic=(POBJECT_BASIC_INFORMATION)ObjectInformation;
  757.           dprintf("DragonNest pid %d ObjectBasicInformation HandleCount %d handle %08x\n",PsGetCurrentProcessId(),pobj_basic->HandleCount,(ULONG)ObjectHandle);
  758.         }
  759.         break;

  761.       }

  763.     }

  765.   }
  766.   __except(1)
  767.   {
  768.     dprintf("MyNtQueryObject error!\n");
  769.   }


  772.   return nTstatus;
  773. }

  775. ULONG Pass_NtQueryObject()
  776. {
  777.   KIRQL oldIrql;
  778.   ULONG  Address=0;

  780.   Address = (ULONG)_KeServiceDescriptorTable->NotUse1.ServiceTableBase + 163 * 4;   

  782.   (ULONG)OrgNtQueryObject = *(ULONG*)Address;    //保存此地址

  784.   WPOFF();
  785.   oldIrql = KeRaiseIrqlToDpcLevel();
  786.   *((ULONG*)Address) = (ULONG)MyNtQueryObject;      //HOOK SSDT
  787.   KeLowerIrql(oldIrql);
  788.   WPON();
  789.   return 1;
  790. }

  792. //反补丁，用于最后恢复用
  793. VOID UnDetour_NtQueryObject()
  794. {
  795.   KIRQL oldIrql;
  796.   ULONG  Address=0;

  798.   Address = (ULONG)_KeServiceDescriptorTable->NotUse1.ServiceTableBase + 163 * 4;

  800.   WPOFF();
  801.   oldIrql = KeRaiseIrqlToDpcLevel();

  803.   *((ULONG*)Address) = (ULONG)OrgNtQueryObject;  //HOOK SSDT
  804.   KeLowerIrql(oldIrql);
  805.   WPON();
  806. }

复制代码
回复

举报

八月的樱花

该用户从未签到
 楼主| 发表于 2012-10-18 20:35:33 | 显示全部楼层


  3. //////////////////////////////////////////////////////////////////////////
  4. typedef NTSYSAPI NTSTATUS (__stdcall *ZWCREATEMUTANT)(
  5.   OUT PHANDLE             MutantHandle,
  6.   IN ACCESS_MASK          DesiredAccess,
  7.   IN POBJECT_ATTRIBUTES   ObjectAttributes OPTIONAL,
  8.   IN BOOLEAN              InitialOwner );

  10. ZWCREATEMUTANT OrgZwCreateMutant;

  12. ULONG g_mutex_count=0;
  13. NTSTATUS __stdcall MyZwCreateMutant(
  14.                   OUT PHANDLE             MutantHandle,
  15.                   IN ACCESS_MASK          DesiredAccess,
  16.                   IN POBJECT_ATTRIBUTES   ObjectAttributes OPTIONAL,
  17.                   IN BOOLEAN              InitialOwner )
  18. {
  19.   PUNICODE_STRING p_mutex_name;
  20.   UNICODE_STRING uni_count;
  21.   WCHAR wzCount[3];
  22.   UNICODE_STRING tmpunicodestring,tmpunicodestring1;
  23.   OBJECT_ATTRIBUTES tmpobjatus;

  25.   NTSTATUS nTstatus;
  26.   __try
  27.   {
  28.     if (!strcmp(GetProcessNameFromEProc(0),"DragonNest.exe"))
  29.     {
  30.       if(ObjectAttributes==NULL)
  31.         return OrgZwCreateMutant(MutantHandle,DesiredAccess,ObjectAttributes,InitialOwner);

  33.       p_mutex_name=ObjectAttributes->ObjectName;

  35.       if(p_mutex_name  )
  36.       {
  37.         if (p_mutex_name->Buffer)
  38.         {
  39.           //    dprintf("mutex %S\n",p_mutex_name->Buffer);

  41.           if (!wcscmp(p_mutex_name->Buffer,L"Global\\MutexDragonNest"))
  42.           {
  43.         //    return OrgZwCreateMutant(MutantHandle,DesiredAccess,ObjectAttributes,InitialOwner);
  44.             dprintf("fack mutex!\n");
  45.             return STATUS_SUCCESS;
  46.         //    DbgBreakPoint();
  47.             
  48.             nTstatus=OrgZwCreateMutant(MutantHandle,DesiredAccess,ObjectAttributes,InitialOwner);

  50.             
  51.             while(1)
  52.             {
  53.               
  54.               if (nTstatus==STATUS_OBJECT_NAME_EXISTS)
  55.               {
  56.                 dprintf("STATUS_OBJECT_NAME_EXISTS\n");

  58.                 g_mutex_count++;
  59.                 if(g_mutex_count==20)  g_mutex_count=0;
  60.                 dprintf("g_mutex_count %d\n",g_mutex_count);
  61.                 uni_count.Buffer=(PWSTR)ExAllocatePool(PagedPool,BUFFER_SIZE);
  62.                 uni_count.MaximumLength=BUFFER_SIZE;
  63.                 nTstatus=RtlIntegerToUnicodeString(g_mutex_count,10,&uni_count);

  65.                 if (NT_SUCCESS(nTstatus))
  66.                 {
  67.                   dprintf("uni_count %wZ\n",uni_count);

  69.                   RtlInitUnicodeString(&tmpunicodestring1,L"Global\\MutexDragonNest");
  70.                   tmpunicodestring.Buffer=(PWSTR)ExAllocatePool(PagedPool,BUFFER_SIZE);
  71.                   tmpunicodestring.MaximumLength=BUFFER_SIZE;
  72.                   //wcscpy(tmpunicodestring.Buffer,L"Global\\MutexDragonNest");
  73.                   RtlCopyUnicodeString(&tmpunicodestring,&tmpunicodestring1);
  74.                   RtlAppendUnicodeStringToString(&tmpunicodestring,&uni_count);
  75.                   DbgPrint("tmpunicodestring %wZ\n",&tmpunicodestring);
  76.                   InitializeObjectAttributes(&tmpobjatus,&tmpunicodestring,ObjectAttributes->Attributes,
  77.                     ObjectAttributes->RootDirectory,ObjectAttributes->SecurityDescriptor);
  78.                   nTstatus=OrgZwCreateMutant(MutantHandle,DesiredAccess,&tmpobjatus,InitialOwner);
  79.                   dprintf("name %wZ\n",tmpobjatus.ObjectName);
  80.                   RtlFreeUnicodeString(&tmpunicodestring);

  82.                 }
  83.                 else
  84.                 {
  85.                   dprintf("RtlIntegerToUnicodeString error!\n");
  86.                 }
  87.                 RtlFreeUnicodeString(&uni_count);

  89.                 //  RtlInitUnicodeString(&uni_count,wzCount);
  90.               }
  91.               else
  92.               {
  93.                 dprintf("CreateMutex sucess! Mutex name %S\n",p_mutex_name->Buffer);
  94.                 return nTstatus;
  95.               }

  97.             }
  98.   
  99.           }
  100.         }

  102.       }
  103.     }
  104.   }
  105.   __except(1)
  106.   {
  107.     dprintf("MyZwCreateMutant error\n");
  108.   }
  109.   return OrgZwCreateMutant(MutantHandle,DesiredAccess,ObjectAttributes,InitialOwner);
  110. }

  112. ULONG Pass_NtCreateMutant()
  113. {
  114.   KIRQL oldIrql;
  115.   ULONG  Address=0;

  117.   Address = (ULONG)_KeServiceDescriptorTable->NotUse1.ServiceTableBase + 43 * 4;   

  119.   (ULONG)OrgZwCreateMutant = *(ULONG*)Address;    //保存此地址

  121.   WPOFF();
  122.   oldIrql = KeRaiseIrqlToDpcLevel();
  123.   *((ULONG*)Address) = (ULONG)MyZwCreateMutant;      //HOOK SSDT
  124.   KeLowerIrql(oldIrql);
  125.   WPON();
  126.   return 1;
  127. }

  129. //反补丁，用于最后恢复用
  130. VOID UnDetour_NtCreateMutant()
  131. {
  132.   KIRQL oldIrql;
  133.   ULONG  Address=0;

  135.   Address = (ULONG)_KeServiceDescriptorTable->NotUse1.ServiceTableBase + 43 * 4;

  137.   WPOFF();
  138.   oldIrql = KeRaiseIrqlToDpcLevel();

  140.   *((ULONG*)Address) = (ULONG)OrgZwCreateMutant;  //HOOK SSDT
  141.   KeLowerIrql(oldIrql);
  142.   WPON();
  143. }



  147. //////////////////////////////////////////////////////////////////////////


  150. typedef NTSTATUS (*NTQUERYSYSTEMINFORMATION)
  151. (
  152. ULONG SystemInformationCLass,
  153. PVOID SystemInformation,
  154. ULONG SystemInformationLength,
  155. PULONG ReturnLength
  156. );

  158. NTQUERYSYSTEMINFORMATION OldNtQuerySystemInformation;


  161. typedef struct _SYSTEM_BASIC_INFORMATION {
  162.   BYTE Reserved1[24];
  163.   PVOID Reserved2[4];
  164.   CCHAR NumberOfProcessors;
  165. } SYSTEM_BASIC_INFORMATION;



  169. NTSTATUS NewNtQuerySystemInformation(
  170.                    IN ULONG SystemInformationClass,
  171.                    IN PVOID SystemInformation,
  172.                    IN ULONG SystemInformationLength,
  173.                    OUT PULONG ReturnLength)
  174. {

  176.   NTSTATUS ntStatus;
  177.   UNICODE_STRING gamename;
  178.   UNICODE_STRING launchername;


  181.   ntStatus = OldNtQuerySystemInformation(
  182.     SystemInformationClass,
  183.     SystemInformation,
  184.     SystemInformationLength,
  185.     ReturnLength );


  188.   if (!_stricmp(GetProcessNameFromEProc(0),"DragonNest.exe") || !_stricmp(GetProcessNameFromEProc(0),"dnlauncher.exe"))
  189.   {

  191.     if( NT_SUCCESS(ntStatus))
  192.     {


  195.       if(SystemInformationClass == 5)
  196.       {

  198.         struct _SYSTEM_PROCESSES *curr = (struct _SYSTEM_PROCESSES *)SystemInformation;
  199.         struct _SYSTEM_PROCESSES *prev = NULL;

  201.         while(curr)
  202.         {

  204.           if (curr->ProcessName.Buffer != NULL)
  205.           {
  206.             //  dprintf("processid %d\n",curr->ProcessId);

  208.             RtlInitUnicodeString(&gamename,L"DragonNest.exe");
  209.             RtlInitUnicodeString(&launchername,L"dnlauncher.exe");
  210.             

  212.             if((!RtlCompareUnicodeString(&(curr->ProcessName),&gamename,FALSE) && (ULONG)PsGetCurrentProcessId()!=curr->ProcessId) ||
  213.               !RtlCompareUnicodeString(&(curr->ProcessName),&launchername,FALSE))
  214.             {
  215.               //  dprintf("FIND DNF PDI %d\n",curr->ProcessId);

  217.               if(prev)
  218.               {
  219.                 if(curr->NextEntryDelta)
  220.                 {
  221.                   prev->NextEntryDelta += curr->NextEntryDelta;
  222.                 }

  224.                 else
  225.                 {
  226.                   prev->NextEntryDelta = 0;
  227.                 }
  228.               }
  229.               else
  230.               {
  231.                 if(curr->NextEntryDelta)
  232.                 {

  234.                   (char *)SystemInformation += curr->NextEntryDelta;
  235.                 }
  236.                 else
  237.                 {
  238.                   SystemInformation = NULL;
  239.                 }

  241.               }


  244.             }
  245.             else
  246.             {
  247.               prev = curr;
  248.             }
  249.           }

  251.           if(curr->NextEntryDelta)
  252.           {
  253.             ((char *)curr += curr->NextEntryDelta);
  254.           }
  255.           else
  256.           {
  257.             curr = NULL;
  258.           }


  261.         }
  262.       }


  265.     }

  267.   }

  269.   return ntStatus;
  270. }

  272. ULONG Pass_NtQuerySystemInformation()
  273. {
  274.   KIRQL oldIrql;
  275.   ULONG  Address=0;

  277.   Address = (ULONG)_KeServiceDescriptorTable->NotUse1.ServiceTableBase + 173 * 4;   

  279.   (ULONG)OldNtQuerySystemInformation = *(ULONG*)Address;    //保存此地址

  281.   WPOFF();
  282.   oldIrql = KeRaiseIrqlToDpcLevel();
  283.   *((ULONG*)Address) = (ULONG)NewNtQuerySystemInformation;      //HOOK SSDT
  284.   KeLowerIrql(oldIrql);
  285.   WPON();
  286.   return 1;
  287. }

  289. //反补丁，用于最后恢复用
  290. VOID UnDetour_NtQuerySystemInformation()
  291. {
  292.   KIRQL oldIrql;
  293.   ULONG  Address=0;

  295.   Address = (ULONG)_KeServiceDescriptorTable->NotUse1.ServiceTableBase + 173 * 4;

  297.   WPOFF();
  298.   oldIrql = KeRaiseIrqlToDpcLevel();

  300.   *((ULONG*)Address) = (ULONG)OldNtQuerySystemInformation;  //HOOK SSDT
  301.   KeLowerIrql(oldIrql);
  302.   WPON();
  303. }

  305. //////////////////////////////////////////////////////////////////////////
  306. /*
  307. 805c1148 8bff            mov     edi,edi
  308. 805c114a 55              push    ebp
  309. 805c114b 8bec            mov     ebp,esp
  310. 805c114d 83ec10          sub     esp,10h
  311. */


  314. VOID UnHook()
  315. {
  316.   KIRQL oldIrql;

  318.   unsigned char  oldcode[]={0x8b,0xff,0x55,0x8b,0xec,0x83,0xec,0x10};
  319.   unsigned char* obcheckobjectaccessptr=(unsigned char*)GetFunctionAddr(L"ObCheckObjectAccess");
  320.   
  321.   ULONG  Address=(ULONG)_KeServiceDescriptorTable->NotUse1.ServiceTableBase + 257 * 4;
  322.   unsigned char* ntterminateprocessptr=(unsigned char*)(*(ULONG*)Address);  
  323.   

  325.   if (obcheckobjectaccessptr[0]==0x68)
  326.   {
  327.    
  328.     WPOFF();
  329.     oldIrql = KeRaiseIrqlToDpcLevel();
  330.     RtlCopyMemory(obcheckobjectaccessptr,oldcode,8);
  331.     KeLowerIrql(oldIrql);
  332.     WPON();

  334.   }
  335.   if (ntterminateprocessptr[0]==0x68)
  336.   {
  337.    

  339.     WPOFF();
  340.     oldIrql = KeRaiseIrqlToDpcLevel();
  341.     RtlCopyMemory(ntterminateprocessptr,oldcode,8);
  342.     KeLowerIrql(oldIrql);
  343.     WPON();

  345.   }

  347. }

  349. //////////////////////////////////////////////////////////////////////////NtOpenProcess
  350. typedef NTSTATUS (*NTOPENPROCESS) (
  351.           __out PHANDLE ProcessHandle,
  352.           __in ACCESS_MASK DesiredAccess,
  353.           __in POBJECT_ATTRIBUTES ObjectAttributes,
  354.           __in_opt PCLIENT_ID ClientId
  355.           );

  357. NTOPENPROCESS OldNtProcessAdd;
  358. NTOPENPROCESS HookedNtOpenProcess;

  360. extern POBJECT_TYPE PsProcessType;

  362. NTSTATUS
  363. NewNtOpenProcess (
  364.         __out PHANDLE ProcessHandle,
  365.         __in ACCESS_MASK DesiredAccess,
  366.         __in POBJECT_ATTRIBUTES ObjectAttributes,
  367.         __in_opt PCLIENT_ID ClientId
  368.         )
  369. {

  371.   HANDLE Handle;
  372.   KPROCESSOR_MODE PreviousMode;
  373.   NTSTATUS Status;
  374.   PEPROCESS Process;
  375.   PETHREAD Thread;
  376.   CLIENT_ID CapturedCid={0};
  377.   BOOLEAN ObjectNamePresent;
  378.   BOOLEAN ClientIdPresent;
  379.   ACCESS_STATE AccessState;
  380.   AUX_ACCESS_DATA AuxData;
  381.   ULONG Attributes;
  382.   LUID SeDebugPrivilege = {0};

  384.   POBJECT_TYPE _PsProcessType;

  386.   PEPROCESS tempeprocess;

  388.   if (!strcmp("Open.exe",GetProcessNameFromEProc(0)))
  389.   {
  390.     DbgPrint("open.exe openprocess!\n");
  391.   }

  393.   if (!strcmp("HProtect.exe",GetProcessNameFromEProc(0)) || !strcmp("zhengtu2.dat",GetProcessNameFromEProc(0)))
  394.   {
  395.   //  return HookedNtOpenProcess(ProcessHandle,DesiredAccess,ObjectAttributes,ClientId);

  397.     PsLookupProcessByProcessId(ClientId->UniqueProcess,&tempeprocess);
  398.     __try
  399.     {
  400.       if (
  401.         !strcmp("DML.exe",GetProcessNameFromEProc(tempeprocess)) ||
  402.         (!strcmp("DragonNest.exe",GetProcessNameFromEProc(tempeprocess)) && PsGetCurrentProcessId()!=ClientId->UniqueProcess)
  403.         /*!strcmp("DeRoX.exe",GetProcessNameFromEProc(tempeprocess))*/
  404.         )
  405.       {
  406.         return STATUS_ACCESS_DENIED;
  407.       }

  409.     }
  410.     __except (EXCEPTION_EXECUTE_HANDLER)
  411.     {
  412.       dprintf("GetExceptionCode %08x\n",GetExceptionCode());
  413.       return GetExceptionCode();
  414.     }

  416.    
  417.   }


  420. //  UnHook();

  422.   (ULONG)_PsProcessType=*(ULONG*)PsProcessType;
  423.   PreviousMode = KeGetPreviousMode();
  424.   SeDebugPrivilege =RtlConvertLongToLuid(SE_DEBUG_PRIVILEGE);
  425.   if (PreviousMode != KernelMode) {
  426.     __try {
  427.       ProbeForWriteHandle (ProcessHandle);

  429.       ProbeForReadSmallStructure (ObjectAttributes,
  430.         sizeof(OBJECT_ATTRIBUTES),
  431.         sizeof(ULONG));
  432.       ObjectNamePresent = (BOOLEAN)ARGUMENT_PRESENT (ObjectAttributes->ObjectName);
  433.       Attributes = ObSanitizeHandleAttributes (ObjectAttributes->Attributes, UserMode);

  435.       if (ARGUMENT_PRESENT (ClientId)) {
  436.         ProbeForReadSmallStructure (ClientId, sizeof (CLIENT_ID), sizeof (ULONG));
  437.         CapturedCid = *ClientId;
  438.         ClientIdPresent = TRUE;
  439.       } else {
  440.         ClientIdPresent = FALSE;
  441.       }
  442.     }
  443.     __except (EXCEPTION_EXECUTE_HANDLER) {
  444.       return GetExceptionCode();
  445.     }
  446.   } else {
  447.     ObjectNamePresent = (BOOLEAN)ARGUMENT_PRESENT (ObjectAttributes->ObjectName);
  448.     Attributes = ObSanitizeHandleAttributes (ObjectAttributes->Attributes, KernelMode);
  449.     if (ARGUMENT_PRESENT (ClientId)) {
  450.       CapturedCid = *ClientId;
  451.       ClientIdPresent = TRUE;
  452.     } else {
  453.       ClientIdPresent = FALSE;
  454.     }
  455.   }

  457.   if (ObjectNamePresent && ClientIdPresent) {
  458.     return STATUS_INVALID_PARAMETER_MIX;
  459.   }

  461.   Status = SeCreateAccessState(
  462.     &AccessState,
  463.     &AuxData,
  464.     DesiredAccess,
  465.     &_PsProcessType->TypeInfo.GenericMapping
  466.     );

  468.   if ( !NT_SUCCESS(Status) ) {

  470.     return Status;
  471.   }

  473.   if (SeSinglePrivilegeCheck( SeDebugPrivilege, PreviousMode )) {

  475.     if ( AccessState.RemainingDesiredAccess & MAXIMUM_ALLOWED ) {
  476.       AccessState.PreviouslyGrantedAccess |= PROCESS_ALL_ACCESS;

  478.     } else {

  480.       AccessState.PreviouslyGrantedAccess |= ( AccessState.RemainingDesiredAccess );
  481.     }

  483.     AccessState.RemainingDesiredAccess = 0;

  485.   }
  486.   if (ObjectNamePresent) {


  489.     Status = ObOpenObjectByName(
  490.       ObjectAttributes,
  491.       _PsProcessType,
  492.       PreviousMode,
  493.       &AccessState,
  494.       0,
  495.       NULL,
  496.       &Handle
  497.       );

  499.     SeDeleteAccessState( &AccessState );

  501.     if ( NT_SUCCESS(Status) ) {
  502.       __try {
  503.         *ProcessHandle = Handle;
  504.       }
  505.       __except (EXCEPTION_EXECUTE_HANDLER) {
  506.         return GetExceptionCode ();
  507.       }
  508.     }
  509.     return Status;
  510.   }

  512.   if ( ClientIdPresent ) {

  514.     Thread = NULL;
  515.     if (CapturedCid.UniqueThread) {
  516.       Status = PsLookupProcessThreadByCid(
  517.         &CapturedCid,
  518.         &Process,
  519.         &Thread
  520.         );

  522.       if (!NT_SUCCESS(Status)) {
  523.         SeDeleteAccessState( &AccessState );
  524.         return Status;
  525.       }
  526.     } else {
  527.       Status = PsLookupProcessByProcessId(
  528.         CapturedCid.UniqueProcess,
  529.         &Process
  530.         );

  532.       if ( !NT_SUCCESS(Status) ) {
  533.         SeDeleteAccessState( &AccessState );
  534.         return Status;
  535.       }
  536.     }

  538.     //
  539.     // OpenObjectByAddress
  540.     //
  541.     Status = ObOpenObjectByPointer(
  542.       Process,
  543.       Attributes,
  544.       &AccessState,
  545.       0,
  546.       _PsProcessType,
  547.       PreviousMode,
  548.       &Handle
  549.       );

  551.     SeDeleteAccessState( &AccessState );

  553.     if (Thread) {
  554.       ObDereferenceObject(Thread);
  555.     }

  557.     ObDereferenceObject(Process);

  559.     if (NT_SUCCESS (Status)) {

  561.       __try {
  562.         *ProcessHandle = Handle;
  563.       }
  564.       __except (EXCEPTION_EXECUTE_HANDLER) {
  565.         return GetExceptionCode ();
  566.       }
  567.     }
  568.     return Status;
  569.   }
  570.   return STATUS_INVALID_PARAMETER_MIX;
  571. }


  574. ULONG Pass_NtOpenProcess()
  575. {

  577.   KIRQL oldIrql;
  578.   ULONG  Address=0;

  580.   Address = (ULONG)_KeServiceDescriptorTable->NotUse1.ServiceTableBase +  0x7A * 4;

  582.   (ULONG)OldNtProcessAdd = *(ULONG*)Address;

  584.   WPOFF();
  585.   oldIrql = KeRaiseIrqlToDpcLevel();

  587.   *((ULONG*)Address) = (ULONG)NewNtOpenProcess;  //HOOK SSDT
  588.   KeLowerIrql(oldIrql);
  589.   WPON();

  591.   return 1;
  592. }

  594. VOID UnDetour_NtOpenProcess()
  595. {
  596.   KIRQL oldIrql;
  597.   ULONG  Address=0;

  599.   Address = (ULONG)_KeServiceDescriptorTable->NotUse1.ServiceTableBase +  0x7A * 4;

  601.   WPOFF();
  602.   oldIrql = KeRaiseIrqlToDpcLevel();

  604.   *((ULONG*)Address) =(ULONG) OldNtProcessAdd;  //HOOK SSDT
  605.   KeLowerIrql(oldIrql);
  606.   WPON();

  608. }

  610. //////////////////////////////////////////////////////////////////////////
  611. typedef
  612. NTSTATUS
  613. (*NTREADVIRTUALMEMORY)(
  614.           IN HANDLE ProcessHandle,
  615.           IN PVOID BaseAddress,
  616.           OUT PVOID Buffer,
  617.           IN ULONG NumberOfBytesToRead,
  618.           OUT PULONG NumberOfBytesReaded OPTIONAL );

  620. NTREADVIRTUALMEMORY OldNtReadVirtualMemoryAdd;
  621. NTREADVIRTUALMEMORY HookedNtReadVirtualMemoryAdd;

  623. NTSTATUS NewNtReadVirtualMemory(
  624.                 IN HANDLE               ProcessHandle,
  625.                 IN PVOID                BaseAddress,
  626.                 OUT PVOID               Buffer,
  627.                 IN ULONG                NumberOfBytesToRead,
  628.                 OUT PULONG              NumberOfBytesReaded OPTIONAL
  629.                 )
  630. {

  632.   NTSTATUS    status;
  633.   PEPROCESS   pEProcess=0;
  634.   char*       proname=0;

  636.   


  639.   if (!strcmp("HProtect.exe",GetProcessNameFromEProc(0)) || !strcmp("zhengtu2.dat",GetProcessNameFromEProc(0)))
  640.   {
  641.     return HookedNtReadVirtualMemoryAdd(ProcessHandle,BaseAddress,Buffer,NumberOfBytesToRead,NumberOfBytesReaded);

  643.     if (!ProcessHandle)
  644.     {
  645.       return 0;

  647.     }

  649.     status = ObReferenceObjectByHandle(ProcessHandle,PROCESS_ALL_ACCESS,NULL,0,&pEProcess,NULL);

  651.     if(!NT_SUCCESS(status))
  652.     {
  653.       dprintf("ObReferenceObjectByHandle fail! %08x \n",status);
  654.       return 0;

  656.     }
  657.     ObDereferenceObject(pEProcess);
  658.     proname=GetProcessNameFromEProc(pEProcess);
  659.     if (PsGetCurrentProcessId()!=PsGetProcessId(pEProcess))
  660.     {
  661.       if (!strcmp("DragonNest.exe",proname) || !strcmp("MDL.exe",proname))
  662.       {
  663.         return STATUS_ACCESS_DENIED;
  664.       }
  665.     }

  667.   }
  668.   return OldNtReadVirtualMemoryAdd(ProcessHandle,BaseAddress,Buffer,NumberOfBytesToRead,NumberOfBytesReaded);

  670. }



  674. //////////////////////////////////////////////////////////////////////////NtReadVirtualMemory



  678. ULONG Pass_NtReadVirtualMemory()
  679. {
  680.   KIRQL oldIrql;
  681.   ULONG  Address=0;

  683.   Address = (ULONG)_KeServiceDescriptorTable->NotUse1.ServiceTableBase + 0xBA * 4;    //得到NtReadVirtualMemory的服务地址

  685.   (ULONG)OldNtReadVirtualMemoryAdd = *(ULONG*)Address;    //保存此地址


  688.   WPOFF();
  689.   oldIrql = KeRaiseIrqlToDpcLevel();
  690.   *((ULONG*)Address) = (ULONG)NewNtReadVirtualMemory;  //HOOK SSDT

  692.   KeLowerIrql(oldIrql);
  693.   WPON();
  694.   return 1;
  695. }

  697. //反补丁，用于最后恢复用
  698. VOID UnDetour_NtReadVirtualMemory()
  699. {
  700.   KIRQL oldIrql;
  701.   ULONG  Address=0;

  703.   Address = (ULONG)_KeServiceDescriptorTable->NotUse1.ServiceTableBase + 0xBA * 4;

  705.   WPOFF();
  706.   oldIrql = KeRaiseIrqlToDpcLevel();

  708.   *((ULONG*)Address) = (ULONG)OldNtReadVirtualMemoryAdd;  //HOOK SSDT
  709.   KeLowerIrql(oldIrql);
  710.   WPON();
  711. }
  712. //////////////////////////////////////////////////////////////////////////

  714. typedef NTSTATUS (*NTWRITEVIRTUALMEMORY)(

  716.            IN HANDLE               ProcessHandle,
  717.            IN PVOID                BaseAddress,
  718.            IN PVOID                Buffer,
  719.            IN ULONG                NumberOfBytesToWrite,
  720.            OUT PULONG              NumberOfBytesWritten OPTIONAL );

  722. NTWRITEVIRTUALMEMORY OldNtWriteVirtualMemoryAdd;
  723. NTWRITEVIRTUALMEMORY HookedNtWriteVirtualMemoryAdd;


  726. NTSTATUS
  727. NTAPI
  728. NewNtWriteVirtualMemory(

  730.            IN HANDLE               ProcessHandle,
  731.            IN PVOID                BaseAddress,
  732.            IN PVOID                Buffer,
  733.            IN ULONG                NumberOfBytesToWrite,
  734.            OUT PULONG              NumberOfBytesWritten OPTIONAL )
  735. {

  737.   if (!strcmp("HProtect.exe",GetProcessNameFromEProc(0)) || !strcmp("zhengtu2.dat",GetProcessNameFromEProc(0)))
  738.   {
  739.     return HookedNtWriteVirtualMemoryAdd(ProcessHandle,BaseAddress,Buffer,NumberOfBytesToWrite,NumberOfBytesWritten);
  740.   }

  742.   return OldNtWriteVirtualMemoryAdd(ProcessHandle,BaseAddress,Buffer,NumberOfBytesToWrite,NumberOfBytesWritten);

  744. }

  746. ULONG Pass_NtWriteVirtualMemory()
  747. {
  748.   KIRQL oldIrql;
  749.   ULONG  Address=0;

  751.   Address = (ULONG)_KeServiceDescriptorTable->NotUse1.ServiceTableBase + 277 * 4;   

  753.   (ULONG)OldNtWriteVirtualMemoryAdd = *(ULONG*)Address;    //保存此地址


  756.   WPOFF();
  757.   oldIrql = KeRaiseIrqlToDpcLevel();
  758.   *((ULONG*)Address) = (ULONG)NewNtWriteVirtualMemory;  //HOOK SSDT

  760.   KeLowerIrql(oldIrql);
  761.   WPON();
  762.   return 1;
  763. }

  765. //反补丁，用于最后恢复用
  766. VOID UnDetour_NtWriteVirtualMemory()
  767. {
  768.   KIRQL oldIrql;
  769.   ULONG  Address=0;

  771.   Address = (ULONG)_KeServiceDescriptorTable->NotUse1.ServiceTableBase + 277 * 4;

  773.   WPOFF();
  774.   oldIrql = KeRaiseIrqlToDpcLevel();

  776.   *((ULONG*)Address) = (ULONG)OldNtWriteVirtualMemoryAdd;  //HOOK SSDT
  777.   KeLowerIrql(oldIrql);
  778.   WPON();
  779. }

  781. //////////////////////////////////////////////////////////////////////////

  783. typedef NTSTATUS (*NTCREATESEMAPHORE)(
  784.           OUT PHANDLE             SemaphoreHandle,
  785.           IN ACCESS_MASK          DesiredAccess,
  786.           IN POBJECT_ATTRIBUTES   ObjectAttributes OPTIONAL,
  787.           IN ULONG                InitialCount,
  788.           IN ULONG                MaximumCount );

  790. NTCREATESEMAPHORE OrgNtCreateSemaphore;

  792. ULONG semhandle=0;

  794. NTSTATUS __stdcall MyNtCreateSemaphore(
  795.                      OUT PHANDLE             SemaphoreHandle,
  796.                      IN ACCESS_MASK          DesiredAccess,
  797.                      IN POBJECT_ATTRIBUTES   ObjectAttributes OPTIONAL,
  798.                      IN ULONG                InitialCount,
  799.                      IN ULONG                MaximumCount
  800.                      )
  801. {
  802.   PUNICODE_STRING p_mutex_name;
  803.   UNICODE_STRING uni_count={0};


  806.   HANDLE tmphand;
  807.   NTSTATUS nTstatus;
  808.   __try
  809.   {
  810.     if (!strcmp(GetProcessNameFromEProc(0),"DragonNest.exe"))
  811.     {
  812.       if(ObjectAttributes==NULL)
  813.         return OrgNtCreateSemaphore(SemaphoreHandle,DesiredAccess,ObjectAttributes,InitialCount,MaximumCount);

  815.       p_mutex_name=ObjectAttributes->ObjectName;

  817.       if(p_mutex_name  )
  818.       {
  819.         if (p_mutex_name->Buffer)
  820.         {
  821.           //dprintf("Semaphore %S\n",p_mutex_name->Buffer);
  822.           //dnx_57987675368241

  824.           if (wcsstr(p_mutex_name->Buffer,L"dnx_57987675368241"))
  825.           {      
  826.             /*         
  827.             nTstatus=OrgNtCreateSemaphore(SemaphoreHandle,DesiredAccess,ObjectAttributes,InitialCount,MaximumCount);
  828.             dprintf("Semaphore %S\n",p_mutex_name->Buffer);
  829.             dprintf("OrgNtCreateSemaphore nTstatus %08x\n",nTstatus);
  830.             //    semhandle=(ULONG)*SemaphoreHandle;
  831.             //    dprintf("DragonNest pid %d MyNtCreateSemaphore dnx_57987675368241 handle %08x\n",PsGetCurrentProcessId(),semhandle);
  832.             return nTstatus;
  833.             */      

  835.             
  836.             while(1)
  837.             {
  838.               nTstatus=OrgNtCreateSemaphore(SemaphoreHandle,DesiredAccess,ObjectAttributes,InitialCount,MaximumCount);
  839.               if (nTstatus==STATUS_OBJECT_NAME_EXISTS)
  840.               {
  841.                 dprintf("STATUS_OBJECT_NAME_EXISTS\n");
  842.                 if (SemaphoreHandle)
  843.                 {
  844.                   dprintf("SemaphoreHandle %08x\n",*(ULONG*)SemaphoreHandle);
  845.                   tmphand=*(HANDLE*)SemaphoreHandle;
  846.                   if (tmphand)
  847.                   {
  848.                     ZwClose(tmphand);
  849.                   }
  850.                 }
  851.                
  852.                 g_Sem_count++;
  853.                 if(g_Sem_count==20)  g_Sem_count=0;
  854.                 uni_count.Buffer=(PWSTR)ExAllocatePool(PagedPool,BUFFER_SIZE);
  855.                 uni_count.MaximumLength=BUFFER_SIZE;
  856.                 nTstatus=RtlIntegerToUnicodeString(g_Sem_count,10,&uni_count);
  857.                   if (NT_SUCCESS(nTstatus))
  858.                   {
  859.                     p_mutex_name->MaximumLength=0x100;
  860.                     RtlAppendUnicodeStringToString(p_mutex_name,&uni_count);
  861.                   }
  862.                   else
  863.                   {
  864.                     dprintf("RtlIntegerToUnicodeString error!\n");
  865.                   }
  866.                   RtlFreeUnicodeString(&uni_count);

  868.               //  RtlInitUnicodeString(&uni_count,wzCount);
  869.               }
  870.               else
  871.               {
  872.                 dprintf("CreateSemaphore sucess! Semaphore name %S\n",p_mutex_name->Buffer);
  873.                 return nTstatus;
  874.               }

  876.             }
  877.             //  MaximumCount=10;
  878.             //  dprintf("DragonNest CreateSemaphore MaximumCount :%d InitialCount :%d\n",MaximumCount,InitialCount);
  879.             //  dprintf("fack mutex!\n");
  880.             //  return STATUS_SUCCESS;
  881.           }
  882.         }

  884.       }
  885.     }
  886.   }
  887.   __except(1)
  888.   {
  889.     dprintf("MyNtCreateSemaphore error\n");
  890.   }
  891.   return OrgNtCreateSemaphore(SemaphoreHandle,DesiredAccess,ObjectAttributes,InitialCount,MaximumCount);
  892. }

  894. ULONG Pass_NtCreateSemaphore()
  895. {
  896.   KIRQL oldIrql;
  897.   ULONG  Address=0;

  899.   Address = (ULONG)_KeServiceDescriptorTable->NotUse1.ServiceTableBase + 51 * 4;   

  901.   (ULONG)OrgNtCreateSemaphore = *(ULONG*)Address;    //保存此地址

  903.   WPOFF();
  904.   oldIrql = KeRaiseIrqlToDpcLevel();
  905.   *((ULONG*)Address) = (ULONG)MyNtCreateSemaphore;      //HOOK SSDT
  906.   KeLowerIrql(oldIrql);
  907.   WPON();
  908.   return 1;
  909. }

  911. //反补丁，用于最后恢复用
  912. VOID UnDetour_NtCreateSemaphore()
  913. {
  914.   KIRQL oldIrql;
  915.   ULONG  Address=0;

  917.   Address = (ULONG)_KeServiceDescriptorTable->NotUse1.ServiceTableBase + 51 * 4;

  919.   WPOFF();
  920.   oldIrql = KeRaiseIrqlToDpcLevel();

  922.   *((ULONG*)Address) = (ULONG)OrgNtCreateSemaphore;  //HOOK SSDT
  923.   KeLowerIrql(oldIrql);
  924.   WPON();
  925. }
  926. //////////////////////////////////////////////////////////////////////////

  928. typedef NTSTATUS (*NTRELEASESEMAPHORE)(

  930.            IN HANDLE               SemaphoreHandle,
  931.            IN ULONG                ReleaseCount,
  932.            OUT PULONG              PreviousCount OPTIONAL );

  934. NTRELEASESEMAPHORE OrgNtReleaseSemaphore;

  936. NTSTATUS __stdcall MyNtReleaseSemaphore(
  937.                     IN HANDLE               SemaphoreHandle,
  938.                     IN ULONG                ReleaseCount,
  939.                     OUT PULONG              PreviousCount OPTIONAL
  940.                     )
  941. {
  942.   UNICODE_STRING semaphorename;
  943.   __try
  944.   {
  945.     if (!strcmp(GetProcessNameFromEProc(0),"DragonNest.exe"))
  946.     {

  948.       if (semhandle==(ULONG)SemaphoreHandle)
  949.       {
  950.         dprintf("DragonNest pid %d ReleaseSemaphore handle %08x\n",PsGetCurrentProcessId(),SemaphoreHandle);
  951.       }
  952.       
  953. /*
  954.       if (!GetObjectNameFromHandle(SemaphoreHandle,&semaphorename))
  955.       {
  956.         if (!wcscmp(semaphorename.Buffer,L"dnx_57987675368241"))
  957.         {
  958.           dprintf("DragonNest pid %d ReleaseSemaphore name %wZ\n",PsGetCurrentProcessId(),&semaphorename);
  959.         }
  960.         
  961.       }
  962.       */
  963.     }
  964.   }
  965.   __except(1)
  966.   {
  967.     dprintf("MyNtReleaseSemaphore error!\n");
  968.   }
  969.   return OrgNtReleaseSemaphore(SemaphoreHandle,ReleaseCount,PreviousCount);
  970. }

  972. ULONG Pass_NtReleaseSemaphore()
  973. {
  974.   KIRQL oldIrql;
  975.   ULONG  Address=0;

  977.   Address = (ULONG)_KeServiceDescriptorTable->NotUse1.ServiceTableBase + 189 * 4;   

  979.   (ULONG)OrgNtReleaseSemaphore = *(ULONG*)Address;    //保存此地址

  981.   WPOFF();
  982.   oldIrql = KeRaiseIrqlToDpcLevel();
  983.   *((ULONG*)Address) = (ULONG)MyNtReleaseSemaphore;      //HOOK SSDT
  984.   KeLowerIrql(oldIrql);
  985.   WPON();
  986.   return 1;
  987. }

  989. //反补丁，用于最后恢复用
  990. VOID UnDetour_NtReleaseSemaphore()
  991. {
  992.   KIRQL oldIrql;
  993.   ULONG  Address=0;

  995.   Address = (ULONG)_KeServiceDescriptorTable->NotUse1.ServiceTableBase + 189 * 4;

  997.   WPOFF();
  998.   oldIrql = KeRaiseIrqlToDpcLevel();

  1000.   *((ULONG*)Address) = (ULONG)OrgNtReleaseSemaphore;  //HOOK SSDT
  1001.   KeLowerIrql(oldIrql);
  1002.   WPON();
  1003. }
  1004. //////////////////////////////////////////////////////////////////////////


  1007. typedef  NTSTATUS (*NTOPENSEMAPHORE)(

  1009.         OUT PHANDLE             SemaphoreHandle,
  1010.         IN ACCESS_MASK          DesiredAccess,
  1011.         IN POBJECT_ATTRIBUTES   ObjectAttributes );

  1013. NTOPENSEMAPHORE OrgNtOpenSemaphore;

  1015. NTSTATUS __stdcall MyNtOpenSemaphore(
  1016.                    OUT PHANDLE             SemaphoreHandle,
  1017.                    IN ACCESS_MASK          DesiredAccess,
  1018.                    IN POBJECT_ATTRIBUTES   ObjectAttributes )
  1019. {
  1020.   PUNICODE_STRING p_mutex_name;
  1021.   __try
  1022.   {
  1023.     if (!strcmp(GetProcessNameFromEProc(0),"DragonNest.exe"))
  1024.     {
  1025.   //    dprintf("DragonNest pid %d OpenSemaphore\n",PsGetCurrentProcessId());

  1027.       p_mutex_name=ObjectAttributes->ObjectName;

  1029.       if(p_mutex_name  )
  1030.       {
  1031.         if (p_mutex_name->Buffer)
  1032.         {
  1033.           if (wcsstr(p_mutex_name->Buffer,L"dnx_57987675368241"))
  1034.           {
  1035.             dprintf("DragonNest PID %d NtOpenSemaphore name %S\n",PsGetCurrentProcessId(),p_mutex_name->Buffer);
  1036.           }  
  1037.         }
  1038.       }

  1040.       
  1041.     }
  1042.   }
  1043.   __except(1)
  1044.   {
  1045.     dprintf("MyNtOpenSemaphore error!\n");
  1046.   }
  1047.   return OrgNtOpenSemaphore(SemaphoreHandle,DesiredAccess,ObjectAttributes);
  1048. }

  1050. ULONG Pass_NtOpenSemaphore()
  1051. {
  1052.   KIRQL oldIrql;
  1053.   ULONG  Address=0;

  1055.   Address = (ULONG)_KeServiceDescriptorTable->NotUse1.ServiceTableBase + 126 * 4;   

  1057.   (ULONG)OrgNtOpenSemaphore = *(ULONG*)Address;    //保存此地址

  1059.   WPOFF();
  1060.   oldIrql = KeRaiseIrqlToDpcLevel();
  1061.   *((ULONG*)Address) = (ULONG)MyNtOpenSemaphore;      //HOOK SSDT
  1062.   KeLowerIrql(oldIrql);
  1063.   WPON();
  1064.   return 1;
  1065. }

  1067. //反补丁，用于最后恢复用
  1068. VOID UnDetour_NtOpenSemaphore()
  1069. {
  1070.   KIRQL oldIrql;
  1071.   ULONG  Address=0;

  1073.   Address = (ULONG)_KeServiceDescriptorTable->NotUse1.ServiceTableBase + 126 * 4;

  1075.   WPOFF();
  1076.   oldIrql = KeRaiseIrqlToDpcLevel();

  1078.   *((ULONG*)Address) = (ULONG)OrgNtOpenSemaphore;  //HOOK SSDT
  1079.   KeLowerIrql(oldIrql);
  1080.   WPON();
  1081. }
  1082. //////////////////////////////////////////////////////////////////////////



  1086. typedef NTSTATUS (*NTWAITFORSINGLEOBJECT)(

  1088.             IN HANDLE               ObjectHandle,
  1089.             IN BOOLEAN              Alertable,
  1090.             IN PLARGE_INTEGER       TimeOut );

  1092. NTWAITFORSINGLEOBJECT OrgNtWaitForSingleObject;

  1094. NTSTATUS __stdcall MyNtWaitForSingleObject(
  1095.   IN HANDLE               ObjectHandle,
  1096.   IN BOOLEAN              Alertable,
  1097.   IN PLARGE_INTEGER       TimeOut )
  1098. {
  1099.   UNICODE_STRING Objectname;
  1100.   __try
  1101.   {
  1102.     if (!strcmp(GetProcessNameFromEProc(0),"DragonNest.exe"))
  1103.     {
  1104.       if (semhandle==(ULONG)ObjectHandle)
  1105.       {
  1106.         dprintf("DragonNest pid %d MyNtWaitForSingleObject name %wZ TimeOut %d\n",PsGetCurrentProcessId(),&Objectname,TimeOut);
  1107.       }
  1108.       /*
  1109.       if (!GetObjectNameFromHandle(ObjectHandle,&Objectname))
  1110.       {
  1111.         if (!wcscmp(Objectname.Buffer,L"dnx_57987675368241"))
  1112.         {
  1113.           dprintf("DragonNest pid %d MyNtWaitForSingleObject name %wZ TimeOut %d\n",PsGetCurrentProcessId(),&Objectname,TimeOut);
  1114.         }
  1115.         
  1116.       }
  1117.       */
  1118.     }
  1119.   }
  1120.   __except(1)
  1121.   {
  1122.     dprintf("MyNtOpenSemaphore error!\n");
  1123.   }
  1124.   return OrgNtWaitForSingleObject(ObjectHandle,Alertable,TimeOut);
  1125. }

  1127. ULONG Pass_NtWaitForSingleObject()
  1128. {
  1129.   KIRQL oldIrql;
  1130.   ULONG  Address=0;

  1132.   Address = (ULONG)_KeServiceDescriptorTable->NotUse1.ServiceTableBase + 271 * 4;   

  1134.   (ULONG)OrgNtWaitForSingleObject = *(ULONG*)Address;    //保存此地址

  1136.   WPOFF();
  1137.   oldIrql = KeRaiseIrqlToDpcLevel();
  1138.   *((ULONG*)Address) = (ULONG)MyNtWaitForSingleObject;      //HOOK SSDT
  1139.   KeLowerIrql(oldIrql);
  1140.   WPON();
  1141.   return 1;
  1142. }

  1144. //反补丁，用于最后恢复用
  1145. VOID UnDetour_NtWaitForSingleObject()
  1146. {
  1147.   KIRQL oldIrql;
  1148.   ULONG  Address=0;

  1150.   Address = (ULONG)_KeServiceDescriptorTable->NotUse1.ServiceTableBase + 271 * 4;

  1152.   WPOFF();
  1153.   oldIrql = KeRaiseIrqlToDpcLevel();

  1155.   *((ULONG*)Address) = (ULONG)OrgNtWaitForSingleObject;  //HOOK SSDT
  1156.   KeLowerIrql(oldIrql);
  1157.   WPON();
  1158. }


  1161. //////////////////////////////////////////////////////////////////////////



  1165. //////////////////////////////////////////////////////////////////////////


  1168. typedef UINT_PTR (*NTUSERQUERYWINDOW)(
  1169.                     IN ULONG WindowHandle,
  1170.                     IN ULONG TypeInformation);

  1172. NTUSERQUERYWINDOW OldNtUserQueryWindow;


  1175. NTSTATUS FindNtUserQueryWindow()
  1176. {
  1177.   NTSTATUS status=0;

  1179.   KeAttachProcess(crsEProc);

  1181.   __try
  1182.   {
  1183.     if (KeServiceDescriptorTableShadow!=NULL)
  1184.     {
  1185.       OldNtUserQueryWindow = (NTUSERQUERYWINDOW)KeServiceDescriptorTableShadow[1].ServiceTableBase[0x1E3];

  1187.     }
  1188.   }
  1189.   __finally
  1190.   {
  1191.     KeDetachProcess();
  1192.   }


  1195.   return status ;


  1198. }


  1201. //////////////////////////////////////////////////////////////////////////

  1203. unsigned int getAddressOfShadowTable()
  1204. {
  1205.   unsigned int i;
  1206.   unsigned char *p;
  1207.   unsigned int dwordatbyte;

  1209.   p = (unsigned char*) KeAddSystemServiceTable;

  1211.   for(i = 0; i < 4096; i++, p++)
  1212.   {
  1213.     __try
  1214.     {
  1215.       dwordatbyte = *(unsigned int*)p;
  1216.     }
  1217.     __except(EXCEPTION_EXECUTE_HANDLER)
  1218.     {
  1219.       return 0;
  1220.     }

  1222.     if(MmIsAddressValid((PVOID)dwordatbyte))
  1223.     {
  1224.       if(memcmp((PVOID)dwordatbyte, &KeServiceDescriptorTable, 16) == 0)
  1225.       {
  1226.         if((PVOID)dwordatbyte == &KeServiceDescriptorTable)
  1227.         {
  1228.           continue;
  1229.         }

  1231.         return dwordatbyte;
  1232.       }
  1233.     }
  1234.   }

  1236.   return 0;
  1237. }

  1239. ULONG getShadowTable()
  1240. {
  1241.   KeServiceDescriptorTableShadow = (PSERVICE_DESCRIPTOR_TABLE) getAddressOfShadowTable();

  1243.   if(KeServiceDescriptorTableShadow == NULL)
  1244.   {
  1245.     dprintf("hooker.sys: Couldnt find shadowtable!\n");

  1247.     return FALSE;
  1248.   }
  1249.   else
  1250.   {
  1251.     dprintf("hooker.sys: Shadowtable has been found!\n");

  1253.     dprintf("hooker.sys: Shadowtable entries: %d\n", KeServiceDescriptorTableShadow[1].NumberOfServices);
  1254.     return TRUE;
  1255.   }
  1256. }





  1262. //6A 30       PUSH 0x30
  1263. //68 70D898BF    PUSH 0xBF98D870

  1265. unsigned long reentry_ntuserfinwind;
  1266. UCHAR g_oldcode_ntuserfindwind[8];

  1268. __declspec(naked) NTSTATUS _NtUserFindWindowEx(
  1269.   HANDLE hwndParent,
  1270.   HANDLE hwndChild,
  1271.   PUNICODE_STRING pstrClassName ,
  1272.   PUNICODE_STRING pstrWindowName ,
  1273.   DWORD dwType)

  1275. {

  1277.   __asm
  1278.   {
  1279.     push 0x30
  1280.     push 0xBF98D870
  1281.     jmp  [reentry_ntuserfinwind]
  1282.   }

  1284. }

  1286. NTSTATUS InitSWSSDT()
  1287. {
  1288.   NTSTATUS status;
  1289.   getShadowTable();

  1291.   


  1294.   status = PsLookupProcessByProcessId((HANDLE)GetCsrPid(), &crsEProc);
  1295.   if (!NT_SUCCESS( status ))
  1296.   {
  1297.     dprintf("PsLookupProcessByProcessId() error\n");

  1299.   }
  1300.   FindNtUserQueryWindow();
  1301.   return status;
  1302. }
  1303. char* GetProcessName( ULONG nProcessId)
  1304. {
  1305.   NTSTATUS rStutus;

  1307.   PEPROCESS       curproc;

  1309.   rStutus=PsLookupProcessByProcessId((HANDLE)nProcessId,&curproc);
  1310.   if (!rStutus)
  1311.   {
  1312.     ObDereferenceObject(curproc);
  1313.     return GetProcessNameFromEProc(curproc);
  1314.   }
  1315.   return 0;

  1317. }

  1319. NTSTATUS MyNtUserFindWindowEx(
  1320.                 IN HANDLE hwndParent,
  1321.                 IN HANDLE hwndChild,
  1322.                 IN PUNICODE_STRING pstrClassName OPTIONAL,
  1323.                 IN PUNICODE_STRING pstrWindowName OPTIONAL,
  1324.                 IN DWORD dwType)
  1325. {
  1326.   ULONG result;
  1327.   UNICODE_STRING CLASSNAME;
  1328.   //UNICODE_STRING FIXCLASSNAME;
  1329.   ULONG FindProcessID;
  1330.   char* szFindProcessName;
  1331.   ULONG ProcessID;  

  1333.   result = _NtUserFindWindowEx(hwndParent, hwndChild, pstrClassName, pstrWindowName, dwType);

  1335.   if (!_stricmp("DragonNest.exe",GetProcessNameFromEProc(0)))
  1336.   {
  1337.      
  1338.     ProcessID = OldNtUserQueryWindow(result, 0);
  1339.    
  1340.     if (ProcessID!=(ULONG)PsGetCurrentProcessId())   
  1341.     {

  1343.       if (pstrClassName!=0)
  1344.       {
  1345.         RtlInitUnicodeString(&CLASSNAME,L"DRAGONNEST");
  1346.         if (!RtlCompareUnicodeString(pstrClassName,&CLASSNAME,FALSE))
  1347.         {

  1349.           return 0;  

  1351.         }
  1352.       }
  1353.       if (pstrWindowName!=0)
  1354.       {
  1355.         RtlInitUnicodeString(&CLASSNAME,L"龙之谷");
  1356.         if (!RtlCompareUnicodeString(pstrWindowName,&CLASSNAME,FALSE))
  1357.         {

  1359.           return 0;

  1361.         }
  1362.         RtlInitUnicodeString(&CLASSNAME,L"DML");
  1363.         if (!RtlCompareUnicodeString(pstrWindowName,&CLASSNAME,FALSE))
  1364.         {

  1366.           return 0;

  1368.         }
  1369.       }

  1371.     }
  1372.    
  1373.   }


  1376.   return result;
  1377. }





  1383. typedef NTSTATUS (*NTUSERFINDWINDOWEX)(
  1384.                      HANDLE hwndParent,
  1385.                      HANDLE hwndChild,
  1386.                      PUNICODE_STRING pstrClassName ,
  1387.                      PUNICODE_STRING pstrWindowName ,
  1388.                      DWORD dwType);


  1391. NTUSERFINDWINDOWEX          g_OriginalNtUserFindWindowEx;




  1396. NTSTATUS HookFindWindow()
  1397. {
  1398.   NTSTATUS status=0;

  1400.   unsigned char newcode[] = { 0xE9, 0x44, 0x33, 0x22, 0x11,0x90,0x90};


  1403.   KeAttachProcess(crsEProc);

  1405.   __try
  1406.   {
  1407.     if (KeServiceDescriptorTableShadow!=NULL)
  1408.     {
  1409.       g_OriginalNtUserFindWindowEx     = (NTUSERFINDWINDOWEX)KeServiceDescriptorTableShadow[1].ServiceTableBase[0x17A];
  1410.       memcpy(g_oldcode_ntuserfindwind,(UCHAR*)g_OriginalNtUserFindWindowEx,7);
  1411.       reentry_ntuserfinwind=(unsigned long)g_OriginalNtUserFindWindowEx+7;
  1412.       *( (unsigned long *)(&newcode[1]) ) = (unsigned long)MyNtUserFindWindowEx-(unsigned long)g_OriginalNtUserFindWindowEx-5;

  1414.     }
  1415.     else
  1416.       KeServiceDescriptorTableShadow=NULL;


  1419.     WPOFF();
  1420.     if (KeServiceDescriptorTableShadow!=NULL )
  1421.     {

  1423.       memcpy((UCHAR*)g_OriginalNtUserFindWindowEx,newcode,7);
  1424.     }

  1426.     WPON();
  1427.   }
  1428.   __finally
  1429.   {
  1430.     KeDetachProcess();
  1431.   }



  1435.   return status ;
  1436. }

  1438. NTSTATUS UnHookFindWindow()
  1439. {
  1440.   NTSTATUS status;

  1442.   KeAttachProcess(crsEProc);

  1444.   __try
  1445.   {
  1446.     WPOFF();

  1448.     if (KeServiceDescriptorTableShadow!=NULL)
  1449.     {
  1450.       memcpy((UCHAR*)g_OriginalNtUserFindWindowEx,g_oldcode_ntuserfindwind,7);

  1452.     }

  1454.     WPON();
  1455.   }
  1456.   __finally
  1457.   {
  1458.     KeDetachProcess();
  1459.     Sleep(50);
  1460.   }
  1461.   return 0;
  1462. }



  1466. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


  1469. //////////////////////////////////////////////////////////////////////////



  1473. ULONG          OldNtUserPostMessage;


  1476. NTSTATUS __declspec(naked) MyNtUserPostMessage()
  1477. {
  1478.   __asm
  1479.   {
  1480.     push ebp
  1481.     mov  ebp,esp
  1482.     push  esi
  1483.     mov   eax,OldNtUserPostMessage
  1484.     add   eax,6
  1485.     jmp   eax
  1486.   }
  1487.   
  1488. }

  1490. NTSTATUS HookNtUserPostMessage()
  1491. {

  1493.   KIRQL oldIrql;
  1494.   ULONG  Address=0;

  1496.   __try
  1497.   {
  1498.     KeAttachProcess(crsEProc);

  1500.     Address = (ULONG)ShadowTable->NotUse2.ServiceTableBase + 475 * 4;   
  1501.     (ULONG)OldNtUserPostMessage = *(ULONG*)Address;   

  1503.     WPOFF();
  1504.     oldIrql = KeRaiseIrqlToDpcLevel();
  1505.     *((ULONG*)Address) = (ULONG)MyNtUserPostMessage;  //HOOK SSDT
  1506.     KeLowerIrql(oldIrql);
  1507.     WPON();
  1508.    
  1509.   }
  1510.   __finally
  1511.   {
  1512.     KeDetachProcess();
  1513.   }
  1514.   return 0 ;
  1515. }

  1517. NTSTATUS UnHookNtUserPostMessage()
  1518. {
  1519.   KIRQL oldIrql;
  1520.   ULONG  Address=0;

  1522.   __try
  1523.   {
  1524.     KeAttachProcess(crsEProc);

  1526.     Address = (ULONG)ShadowTable->NotUse2.ServiceTableBase +475 * 4;
  1527.     WPOFF();
  1528.     oldIrql = KeRaiseIrqlToDpcLevel();

  1530.     *((ULONG*)Address) = (ULONG)OldNtUserPostMessage;  //HOOK SSDT
  1531.     KeLowerIrql(oldIrql);
  1532.     WPON();

  1534.   }
  1535.   __finally
  1536.   {
  1537.     KeDetachProcess();
  1538.   }

  1540.   return 0;
  1541. }


  1544. //////////////////////////////////////////////////////////////////////////




  1549. ULONG          OldNtUserMessageCall;


  1552. NTSTATUS __declspec(naked) MyNtUserMessageCall()
  1553. {
  1554.   __asm
  1555.   {
  1556.     push ebp
  1557.     mov  ebp,esp
  1558.     sub  esp,0xc
  1559.     mov   eax,OldNtUserMessageCall
  1560.     add   eax,8
  1561.     jmp   eax
  1562.   }

  1564. }

  1566. NTSTATUS HookNtUserMessageCall()
  1567. {

  1569.   KIRQL oldIrql;
  1570.   ULONG  Address=0;
  1571.   
  1572.   __try
  1573.   {
  1574.     KeAttachProcess(crsEProc);

  1576.     Address = (ULONG)ShadowTable->NotUse2.ServiceTableBase + 460 * 4;   
  1577.     (ULONG)OldNtUserMessageCall = *(ULONG*)Address;   

  1579.     WPOFF();
  1580.     oldIrql = KeRaiseIrqlToDpcLevel();
  1581.     *((ULONG*)Address) = (ULONG)MyNtUserMessageCall;  //HOOK SSDT
  1582.     KeLowerIrql(oldIrql);
  1583.     WPON();

  1585.   }
  1586.   __finally
  1587.   {
  1588.     KeDetachProcess();
  1589.   }


  1592.   return 0 ;
  1593. }

  1595. NTSTATUS UnHookNtUserMessageCall()
  1596. {
  1597.   KIRQL oldIrql;
  1598.   ULONG  Address=0;
  1599.   
  1600.   __try
  1601.   {
  1602.     KeAttachProcess(crsEProc);

  1604.     Address = (ULONG)ShadowTable->NotUse2.ServiceTableBase +460 * 4;
  1605.     WPOFF();
  1606.     oldIrql = KeRaiseIrqlToDpcLevel();

  1608.     *((ULONG*)Address) = (ULONG)OldNtUserMessageCall;  //HOOK SSDT
  1609.     KeLowerIrql(oldIrql);
  1610.     WPON();

  1612.   }
  1613.   __finally
  1614.   {
  1615.     KeDetachProcess();
  1616.   }


  1619.   return 0;
  1620. }

  1622. //////////////////////////////////////////////////////////////////////////

  1624. typedef struct tagKEYBDINPUT {
  1625.   SHORT wVk;
  1626.   SHORT wScan;
  1627.   ULONG dwFlags;
  1628.   ULONG time;
  1629.   ULONG_PTR dwExtraInfo;
  1630. } KEYBDINPUT, *PKEYBDINPUT;

  1632. typedef struct tagMOUSEINPUT {
  1633.   LONG dx;
  1634.   LONG dy;
  1635.   ULONG mouseData;
  1636.   ULONG dwFlags;
  1637.   ULONG time;
  1638.   ULONG_PTR dwExtraInfo;
  1639. } MOUSEINPUT, *PMOUSEINPUT;

  1641. typedef struct tagHARDWAREINPUT {
  1642.   ULONG uMsg;
  1643.   SHORT wParamL;
  1644.   SHORT wParamH;
  1645. } HARDWAREINPUT, *PHARDWAREINPUT;

  1647. typedef struct tagINPUT {  
  1648.   ULONG type;  
  1649.   union {MOUSEINPUT mi;  
  1650.   KEYBDINPUT ki;
  1651.   HARDWAREINPUT hi;
  1652.   };
  1653. }INPUT, *PINPUT;

  1655. typedef ULONG (NTAPI*NTUSERSENDINPUT)(ULONG,PINPUT,int);




  1660. NTUSERSENDINPUT          OldNtUserSendInput;
  1661. //ULONG OldNtUserSendInputree;


  1664. NTSTATUS __declspec(naked) _NtUserSendInput(IN ULONG nInputs,IN PINPUT pInputs,IN int cbSize)
  1665. {
  1666.   __asm
  1667.   {
  1668.     push 0x18
  1669.     push 0xbf98f050
  1670.     mov  eax,OldNtUserSendInput
  1671.     add  eax,7
  1672.     jmp   eax
  1673.   }

  1675. }

  1677. ULONG NTAPI MyNtUserSendInput(IN ULONG nInputs,IN PINPUT pInputs,IN int cbSize)
  1678. {
  1679.   if (!strcmp(GetProcessNameFromEProc(0),"DragonNest.exe"))
  1680.   {
  1681.     dprintf("DragonNest NtUserSendInput\n");
  1682.    
  1683.   }

  1685.   return OldNtUserSendInput(nInputs,pInputs,cbSize);

  1687. //  return _NtUserSendInput(nInputs,pInputs,cbSize);

  1689. }


  1692. NTSTATUS HookNtUserSendInput()
  1693. {

  1695.   KIRQL oldIrql;
  1696.   ULONG  Address=0;
  1697.   
  1698.   __try
  1699.   {
  1700.     KeAttachProcess(crsEProc);

  1702.     Address = (ULONG)ShadowTable->NotUse2.ServiceTableBase + 502 * 4;   
  1703.     (ULONG)OldNtUserSendInput = *(ULONG*)Address;   

  1705. //    OldNtUserSendInputree=OldNtUserSendInput+7;

  1707.     WPOFF();
  1708.     oldIrql = KeRaiseIrqlToDpcLevel();
  1709.     *((ULONG*)Address) = (ULONG)_NtUserSendInput;  //HOOK SSDT
  1710.     KeLowerIrql(oldIrql);
  1711.     WPON();

  1713.   }
  1714.   __finally
  1715.   {
  1716.     KeDetachProcess();
  1717.   }

  1719.   return 0 ;
  1720. }

  1722. NTSTATUS UnHookNtUserSendInput()
  1723. {
  1724.   KIRQL oldIrql;
  1725.   ULONG  Address=0;
  1726.   
  1727.   __try
  1728.   {
  1729.     KeAttachProcess(crsEProc);

  1731.     Address = (ULONG)ShadowTable->NotUse2.ServiceTableBase +502 * 4;
  1732.     WPOFF();
  1733.     oldIrql = KeRaiseIrqlToDpcLevel();

  1735.     *((ULONG*)Address) = (ULONG)OldNtUserSendInput;  //HOOK SSDT
  1736.     KeLowerIrql(oldIrql);
  1737.     WPON();

  1739.   }
  1740.   __finally
  1741.   {
  1742.     KeDetachProcess();
  1743.   }

  1745.   return 0;
  1746. }

  1748. //////////////////////////////////////////////////////////////////////////

  1750. NTSTATUS GetHookedFunAdd()
  1751. {
  1752.   ULONG  Address=0;

  1754.   Address = (ULONG)_KeServiceDescriptorTable->NotUse1.ServiceTableBase +  0x7A * 4;
  1755.   
  1756.   (ULONG)HookedNtOpenProcess = *(ULONG*)Address;

  1758.   Address = (ULONG)_KeServiceDescriptorTable->NotUse1.ServiceTableBase +  0xBA * 4;

  1760.   (ULONG)HookedNtReadVirtualMemoryAdd = *(ULONG*)Address;

  1762.   Address = (ULONG)_KeServiceDescriptorTable->NotUse1.ServiceTableBase +  277 * 4;

  1764.   (ULONG)HookedNtWriteVirtualMemoryAdd = *(ULONG*)Address;
  1765.   
  1766.   return 0;
  1767. }

复制代码
回复 支持 反对

举报

网瘾犯了

该用户从未签到
发表于 2012-10-19 22:03:29 | 显示全部楼层
先收藏先谢谢LZ
回复 支持 反对

举报

xiaozu

该用户从未签到
发表于 2012-10-19 23:10:58 | 显示全部楼层
求成品 不会C++
回复 支持 反对

举报

返回列表 发新帖
点击按钮快速添加回复内容: 支持 高兴 激动 给力 加油 苦寻 生气 回帖 路过 感恩
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册账号

本版积分规则

小黑屋|手机版|Archiver|看流星社区 |网站地图

GMT+8, 2024-5-1 00:55

Powered by Kanliuxing X3.4

© 2010-2019 kanliuxing.com

快速回复 返回顶部 返回列表