鑫郁飞网络技术-郁金香灬老师

 找回密码
 立即注册

QQ登录

只需一步,快速开始

郁金香 外挂开发(实战)郁金香 终身VIP 尊贵特权郁金香 VIP学员办理任鸟飞2015外挂教程
◆招传奇霸业辅助作者◆论坛VIP会员账号郁金香游戏外挂制作 终极教程   ◆招传奇霸业辅助作者◆
查看: 156|回复: 0

win7/win8/win10 64 过保护 驱动教程

[复制链接]
发表于 2018-4-8 11:46:58 | 显示全部楼层 |阅读模式
QQ 群 87530438 欢迎交流

1、保护自己的进程
2、过tp保护
3、过gpk保护
4、过np保护
5、过XIgnCode3保护
6、过HS保护
7、过PP保护

另发一点 过TP保护 资料
[XueTr][Kernel Hook]: 55
挂钩对象                挂钩位置                钩子类型                挂钩处当前值                挂钩处原始值
[*]KDCOM.dll:KdSendPacket[ntoskrnl.exe]                [0xF7B551B2]->[0xA9D28FE2][C:\WINDOWS\system32\TesSafe.sys]               
KDCOM.dll:KdReceivePacket[ntoskrnl.exe]                [0xF7B54F4C]->[0xA9D28FF2][C:\WINDOWS\system32\TesSafe.sys]                               
[*]len(4) NtOpenProcess[ntoskrnl.exe]                [0x80582846]->[0xA9D3245E][C:\WINDOWS\system32\TesSafe.sys]       
[*]len(4) NtOpenThread[ntoskrnl.exe]                [0x805E2A8B]->[0xA9D29E98][C:\WINDOWS\system32\TesSafe.sys]       
[*]len(7) NtReadVirtualMemory[ntoskrnl.exe]                [0x805894CA]->[0xA9D29AE6][C:\WINDOWS\system32\TesSafe.sys]               
[*]len(7) NtReadVirtualMemory[ntoskrnl.exe]                [0x805894CA]->[0xA9D29AE6][C:\WINDOWS\system32\TesSafe.sys]       
[*]len(7) NtWriteVirtualMemory[ntoskrnl.exe]                [0x805895C2]->[0xA9D29BC2][C:\WINDOWS\system32\TesSafe.sys]
[*]len(7) KiAttachProcess                [0x804F24C1]->[0xA9D29C9E][C:\WINDOWS\system32\TesSafe.sys]       
[*]len(7) DbgkpQueueMessage                [0x80662525]->[0xA9D2CC3E][C:\WINDOWS\system32\TesSafe.sys]       
[*]len(7) DbgkpSetProcessDebugObject                [0x806632E3]->[0xA9D2CBBC][C:\WINDOWS\system32\TesSafe.sys]       

///////////////////////////////////////////////////////////////////
//PassTP.c
//////////////////////////////////////////////////////////////////////////

//NtOpenThread    //防止调试器在它体内创建线程
//NtOpenProcess   //防止OD等在进程列表看到它
//KiAttachProcess   //防止其他软件附加它
//NtReadVirtualMemory  //防止别人读取它的内存
//NtWriteVirtualMemory  //防止别人在它的内存里面乱写乱画
//KDCOM.dll:KdReceivePacket  //这两个是COM串口的接受和发送数据
//KDCOM.dll:KdSendPacket      //主要用来方式别人双机调试
//下面简单看下他关键的几个HOOK:
//1KiAttachProcess   
//2NtReadVirtualMemory  
//3NtWriteVirtualMemory  
//4 NtOpenThread
//5 NtOpenProcess
//其中,前3个直接恢复即可。
//第4个有监视,直接恢复即刻重启
//第5个和ring3有通信,直接恢复1分钟内SX非法模块
//
//根据上面的分析,下面给出相应的解决方案
//1.直接恢复 第1、2、3处HOOK
//2.绕过4、5处HOOK
//3.将debugport清零的内核线程干掉,清2个DPCTIMER和IOTIMER,自较验
//4.恢复硬件断点
//5清回调

//但是要有一个先后的逻辑顺序
//因为内核有一个线程负责监视几个地方,必须要先干掉它。
//但是这个内容我写在了处理debugport清零的一起,也就是第3步。所以大家在照搬源码的时候
//注意代码执行次序
//////////////////////////////////////////////////////////////////////////
#include <ntddk.h>
#include "Fun.h"
#include "RestoreSSDT.h"
#include "passtp.h"

#include "DpcIoTimer.h"
//////////////////////////////////////////////////////////////////////////
//全局变量
ULONG   ObOpenObjectByPointerAddress  = 0; //ObOpenObjectByPointer的地址
ULONG   p_TpHookNtOpenPrcessAddress = 0;        //TP的HOOK函数地址
ULONG   uRetNtOpenPrcess_0x141 = 0;        //返回到的地址
ULONG   uRetNtOpenThread_0x14e=0;
BYTE    *g_pTesSafeAddress = NULL;
ULONG    g_TesSafeSize = 0;
ULONG    p_OpenThread_TpHookAddress=0;
////////
//处理硬件断点时
ULONG                   TenNtGetContextThread=0,TenNtSetContextThread=0;
ULONG                   NtSetContextThreadAddrValue=0,NtGetContextThreadAddrValue=0;
ULONG          KiAttachProcessAddress=0;
////
SaveCodeBuf    NtReadMem={0},NtWirteMem={0},KiAttPro={0};
SaveCodeBuf    DbgkpQueueMessage_save={0},DbgkpSetProcessDebugObject_save={0};
//SaveCodeBuf    HardBreakPointGet={0},HardBreakPointSet={0};
////
InlineHook     MyNtOpenProcessHook={0},MyNtOpenThreadHook={0};
//////////////////////////////////////////////////////////////////////////

VOID  PassTP()
{
        char buf[40]="\\??\\c:\\windows\\system32\\tessafe.sys\0";
    My_Recovery_Debugport1();
       
        //My_Recovery_Debugport();
        //return;
        DeleteDpcTimerInSpecialModule((PWCHAR)&buf);
        DeleteIoTimerInSpecialModule((PWCHAR)&buf);
    RestoreSSDT();
        ResetCode(&DbgkpSetProcessDebugObject_save);
        ResetCode(&DbgkpQueueMessage_save);
        My_RecoveryHook_BackCall();
    My_RecoveryHook_NtReadAndWriteMemory();       
        My_RecoveryHook_KiAttachProcess();
        My_Recovery_HardwareBreakpoint();
    My_RecoveryHook_NtOpenProcess();
        My_RecoveryHook_NtOpenThread();
}
void  SaveAll()
{
    //保存代码等以后过TP时恢复
        //硬断点
        BYTE buf[7]={0x8b,0xff,0x55,0x8b,0xec,0x81,0xec};
        BYTE buf1[7]={0x8b,0xff,0x55,0x8b,0xec,0x83,0xec};
    NtSetContextThreadAddrValue=GetSSDTCurrentAddress(0xd5);
    NtGetContextThreadAddrValue=GetSSDTCurrentAddress(0x55);

        NtReadMem.CodeAddres=GetSSDTCurrentAddress(0xba);;
    NtWirteMem.CodeAddres=GetSSDTCurrentAddress(0x115);;
        SaveCode(&NtReadMem);//保存代码
        SaveCode(&NtWirteMem);//保存代码
       
        KiAttachProcessAddress=GetKiAttachProcessAddr();
        KiAttPro.CodeAddres=KiAttachProcessAddress;
        SaveCode(&KiAttPro);//保存代码

        DbgkpQueueMessage_save.CodeAddres=FindDbgkpQueueMessage();
        DbgkpQueueMessage_save.CodeCount=7;
        memcpy((void*)&DbgkpQueueMessage_save.CodeBuf,(void*)&buf,7);

        DbgkpSetProcessDebugObject_save.CodeAddres=FindDbgkpSetProcessDebugObject();
        DbgkpSetProcessDebugObject_save.CodeCount=7;
        memcpy((void*)&DbgkpSetProcessDebugObject_save.CodeBuf,(void*)&buf1,7);

        //SaveCode(&DbgkpSetProcessDebugObject_save);
        //SaveCode(&DbgkpQueueMessage_save);
       
        //        HardBreakPointGet.CodeAddres=(ULONG)KeServiceDescriptorTable->ServiceTableBase+0x55 * 4;
        //        HardBreakPointSet.CodeAddres=(ULONG)KeServiceDescriptorTable->ServiceTableBase+0xD5 * 4;
        //        HardBreakPointGet.CodeCount=4;
        //        HardBreakPointSet.CodeCount=4;
        //        SaveCode(&HardBreakPointGet);
        //        SaveCode(&HardBreakPointSet);
        //获取ObOpenObjectByPointer的地址
    ObOpenObjectByPointerAddress = GetFunAddress(L"ObOpenObjectByPointer");
       
}
//////////////////////////////////////////////////////////////////////////
void MyUnHook()
{
        ULONG addres,size;
        ULONG    uNtGetContextThreadAddress=0;
    ULONG    uNtSetContextThreadAddress=0;
        UnInlineHook(&MyNtOpenThreadHook);
        UnInlineHook(&MyNtOpenProcessHook);
        ResetCode(&NtReadMem);
        ResetCode(&NtWirteMem);
        ResetCode(&KiAttPro);
        //////////////////////////////////////////////////////////////////////////
        uNtSetContextThreadAddress = (ULONG)KeServiceDescriptorTable->ServiceTableBase+0xD5 * 4;
        uNtGetContextThreadAddress = (ULONG)KeServiceDescriptorTable->ServiceTableBase+0x55 * 4;
        if(GetTesSafeAddress((BYTE**)&addres,&size)==STATUS_SUCCESS)
        {
                //获取地址
               
                if (TenNtGetContextThread && TenNtSetContextThread)
                {
                        WPOFF();  
                        *(ULONG*)uNtGetContextThreadAddress = TenNtGetContextThread;
                        *(ULONG*)uNtSetContextThreadAddress = TenNtSetContextThread;
                        WPON();
                }
        }
        else
        {
                //ResetCode(&HardBreakPointGet);
                //ResetCode(&HardBreakPointSet);
                WPOFF();  
                *(ULONG*)uNtGetContextThreadAddress = NtGetContextThreadAddrValue;
                *(ULONG*)uNtSetContextThreadAddress = NtSetContextThreadAddrValue;
                WPON();
        }
        ExitFun();
}
void Test()
{
        //AddMyServiceTable();
        PassTP();
}
//////////////////////////////////////////////////////////////////////
//  名称:  RecoveryHook_KiAttachProcess
//  功能:  解除游戏保护对_KiAttachProcess函数的HOOK(DNF)
//  参数:  
//  返回:  状态
//////////////////////////////////////////////////////////////////////
NTSTATUS My_RecoveryHook_KiAttachProcess()
{
        ULONG KiAddres;
        BYTE* lpKiAddres;
        KiAddres=GetKiAttachProcessAddr();
        if (KiAddres)
        {
                lpKiAddres=(BYTE*)KiAddres;
                if (*lpKiAddres!=0x8b||
                        *(lpKiAddres+2)!=0xff||
                        *(lpKiAddres+3)!=0x55||
                        *(lpKiAddres+4)!=0x8b||
                        *(lpKiAddres+5)!=0xec||
                        *(lpKiAddres+6)!=0x53||
                        *(lpKiAddres+7)!=0x8b)
                {
                        ResetCode(&KiAttPro);
                }
        }
        return  STATUS_SUCCESS;
}
//NTSTATUS My_RecoveryHook_KiAttachProcess()
//{
//  BYTE    *KeAttachProcessAddress = NULL;  //KeAttachProcess函数地址
//  BYTE    *p;
//  BYTE    MovEaxAddress[5]  = {0xB8,0,0,0,0};  //
//  BYTE    JmpEax[2]      = {0xff,0xe0};
//  KIRQL    Irql;
//  
//
//  //计算中继函数地址
//  *(ULONG *)(MovEaxAddress+1)=(ULONG)Nakd_KiAttachProcess;
//
//  WPOFF();  //清除CR0
//  //提升IRQL中断级
//  Irql=KeRaiseIrqlToDpcLevel();
//  //写入
//  RtlCopyMemory(KiAttachProcessAddress,MovEaxAddress,5);
//  RtlCopyMemory(KiAttachProcessAddress+5,JmpEax,2);
//  //恢复Irql
//  KeLowerIrql(Irql);
//  WPON();    //恢复CR0
//
//  return  STATUS_SUCCESS;
//}

//////////////////////////////////////////////////////////////////////
//  名称:  My_RecoveryHook_NtReadAndWriteMemory
//  功能:  解除游戏保护对NtReadVirtualMemory和
//      NtWriteVirtualMemory的HOOK
//  参数:  
//  返回:  
//////////////////////////////////////////////////////////////////////
NTSTATUS My_RecoveryHook_NtReadAndWriteMemory()
{
    WPOFF();
        if (NtReadMem.CodeAddres)
                *(PULONG)GetSSDTIndexAddres(0xba)=NtReadMem.CodeAddres;
        if (NtWirteMem.CodeAddres)
                *(PULONG)GetSSDTIndexAddres(0x115)=NtWirteMem.CodeAddres;
        WPON();   
    ResetCode(&NtReadMem);
        ResetCode(&NtWirteMem);
        return  STATUS_SUCCESS;
       
}

ULONG  FindDbgkpQueueMessage()
{
        ULONG uRet=0,i=0;
        BYTE* p=(BYTE*)GetSSDTCurrentAddress(33);
        if (p)
        {
                for(i=0;i<0x2000;i++)
                {
                        if((*(p)==0x56)&&
                                (*(p+1)==0x8b)&&
                                (*(p+4)==0x89)&&
                                (*(p+7)==0x83)&&
                                (*(p+11)==0x74))
                        {
                                uRet=(ULONG)p-12;
                                DbgPrint("DbgkpQueueMessage=%x ",uRet);
                                break;
                        }
                        p++;
                }
        }
        return uRet;
}
ULONG  FindDbgkpSetProcessDebugObject()
{
        ULONG uRet=0,i=0;
        BYTE* p=(BYTE*)FindDbgkpQueueMessage();
        if (p)
        {
                for(;i<4000;i++)
                {
                        if((*(p-3)==0x89)&&
                                (*(p)==0x8d)&&
                                (*(p+3)==0x89)&&
                                (*(p+6)==0x89)&&
                                (*(p+9)==0x8b)&&
                                (*(p+12)==0x33)&&
                                (*(p+13)==0xdb))
                        {
                                uRet=(ULONG)p-20;
                                DbgPrint("DbgkpSetProcessDebugObject=%x ",uRet);
                                break;
                        }
                        p++;
                }
        }
        return uRet;
}
//////////////////////////////////////////////////////////////////////
//  名称:  Nakd_KiAttachProcess
//  功能:  My_RecoveryHook_KiAttachProcess的中继函数
//  参数:  
//  返回:  
//////////////////////////////////////////////////////////////////////
NAKED VOID  Nakd_KiAttachProcess()
{
        ASM
        {
                mov     edi,edi;
                push    ebp;
                mov     ebp,esp;
                push    ebx;
                push    esi;
                mov     eax,KiAttachProcessAddress;
                test    eax,eax;
                jz      getki;
                add    eax,7;
                jmp    eax;
getki:
                call   GetKiAttachProcessAddr;
                add    eax,7;
                jmp    eax;
        }
}
//////////////////////////////////////////////////////////////////////
//  名称:  Nakd_NtOpenProcess
//  功能:  My_RecoveryHook_NtOpenProcess的中继函数
//  参数:  
//  返回:  
//////////////////////////////////////////////////////////////////////
NAKED VOID  Nakd_NtOpenProcess()
{
        ASM
        {
                pushad;
        }
        if ((IsGameProectProcess()&& p_TpHookNtOpenPrcessAddress))
        {
                //说明是DNF进程访问了这里
                ASM
                {
                        popad;
                        push    dword ptr [ebp-38h];
                        push    dword ptr [ebp-24h];
                        push    uRetNtOpenPrcess_0x141;
                        mov     eax,p_TpHookNtOpenPrcessAddress;
                        jmp     eax;
                }
        }
        else
        {
                ASM
                {
                        popad;
                        push    dword ptr [ebp-38h];
                        push    dword ptr [ebp-24h];
                        push    uRetNtOpenPrcess_0x141;
                        mov     eax,ObOpenObjectByPointerAddress;
                        jmp     eax;
                }
        }
}
///////ObReferenceObjectByPointer
///////////////////////////////////////////////////////////////////
//  名称:  Nakd_NtOpenThread
//  功能:  My_RecoveryHook_NtOpenThread的中继函数
//  参数:   
//  返回:   
//////////////////////////////////////////////////////////////////////
NAKED VOID  Nakd_NtOpenThread()
{
        ASM
        {
                pushad;
        }
        if (IsGameProectProcess())
        {
                //说明是DNF进程访问了这里
                ASM
                {
                        popad;
                        push    dword ptr [ebp-34h];
                        push    dword ptr [ebp-20h];
                        push    uRetNtOpenThread_0x14e;
                        //jmp     dword ptr [p_OpenThread_TpHookAddress];
                        mov     eax,p_OpenThread_TpHookAddress;
                        jmp eax;
                }
        }
        else
        {
                ASM
                {
                        popad;
                        push    dword ptr [ebp-34h];
                        push    dword ptr [ebp-20h];
                        push    uRetNtOpenThread_0x14e;
                        //jmp     dword ptr [ObOpenObjectByPointerAddress];
                        mov     eax,ObOpenObjectByPointerAddress;
                        jmp eax;
                             
                }
        }
}



//////////////////////////////////////////////////////////////////////
//  名称:  My_RecoveryHook_NtOpenProcess
//  功能:  解除游戏保护对NtOpenProcess的HOOK
//  参数:   
//  返回:  状态
//////////////////////////////////////////////////////////////////////

NTSTATUS My_RecoveryHook_NtOpenThread()
{
        BYTE    *NtOpenThreadHookAddress= NULL;  //NtOpenProcess的地址
        BYTE    *p = NULL;      //临时
        int i = 0;
    //获取NtOpenThread的地址
    p = (BYTE*)GetFunAddress(L"NtOpenThread");
    if (p == NULL)
    {
        KdPrint(("NtOpenThread地址获取失败\n"));
        return   STATUS_UNSUCCESSFUL;
    }
       
    //获取ObOpenObjectByPointer的地址
        if (ObOpenObjectByPointerAddress==0)
        {
                ObOpenObjectByPointerAddress = GetFunAddress(L"ObOpenObjectByPointer");
                if (ObOpenObjectByPointerAddress == 0)
                {
                        KdPrint(("ObOpenObjectByPointer地址获取失败\n"));
                        return   STATUS_UNSUCCESSFUL;
                }
        }

       
     for(i=0;i<=0x290;i++)
    {
                if ((*(p-6)    == 0xff) &&
                        (*(p-3)  == 0xff) &&
                        (*p      == 0xE8) &&
                        (*(p+5)    == 0x8b) &&
                        (*(p+6)    == 0xf8))
                {
                        KdPrint(("%0X \n",(ULONG)p));
            NtOpenThreadHookAddress=p;
                        break;
                }
                //推动指针向前走
                p++;
    }
        if (NtOpenThreadHookAddress==NULL)
        {
                return  STATUS_UNSUCCESSFUL;
        }

        //保存调用ObOpenObjectByPointer函数以后的返回地址
    uRetNtOpenThread_0x14e = (ULONG)NtOpenThreadHookAddress+5;
        //计算跳到TP在的位置
    p_OpenThread_TpHookAddress = *(PULONG)(NtOpenThreadHookAddress+0x01)+(ULONG)NtOpenThreadHookAddress+5;

        MyNtOpenThreadHook.OldAddres=(ULONG)NtOpenThreadHookAddress-6;//找到我们写入自定义函数的地址
        MyNtOpenThreadHook.NewAddres=(ULONG)Nakd_NtOpenThread;
        MyNtOpenThreadHook.HookCodeLen=6;
         //DbgPrint("uRetNtOpenThread_0x14e=%x,p_OpenThread_TpHookAddress=%x",uRetNtOpenThread_0x14e,p_OpenThread_TpHookAddress);
         SetInlineHook(&MyNtOpenThreadHook,FALSE);
    return  STATUS_SUCCESS;
}

//////////////////////////////////////////////////////////////////////
//  名称:  My_RecoveryHook_NtOpenProcess
//  功能:  解除游戏保护对NtOpenProcess的HOOK
//  参数:  
//  返回:  状态
//////////////////////////////////////////////////////////////////////


NTSTATUS My_RecoveryHook_NtOpenProcess()
{
        BYTE    *pTpHookOpenPrcessAddres  = NULL;  
        BYTE    *p = NULL; //NtOpenProcess的地址
        KIRQL    Irql;
        int i;
    //获取NtOpenProcess的地址
    p = (BYTE*)GetFunAddress(L"NtOpenProcess");
    if (p == NULL)
    {
                KdPrint(("NtOpenProcess地址获取失败\n"));
                return  FAILED_TO_OBTAIN_FUNCTION_ADDRESSES;
    }
        //        else
        //        {
        //                WPOFF();  //清除CR0
        //                //提升IRQL中断级
        //                Irql=KeRaiseIrqlToDpcLevel();
        //                //写入
        //                *(PULONG)GetSSDTIndexAddres(122)=(ULONG)NtOpenProcessAddress;
        //                //恢复Irql
        //                KeLowerIrql(Irql);
        //                WPON();    //恢复CR       
        //        }
    //获取ObOpenObjectByPointer的地址
    ObOpenObjectByPointerAddress = GetFunAddress(L"ObOpenObjectByPointer");
    if (ObOpenObjectByPointerAddress == 0)
    {
                KdPrint(("ObOpenObjectByPointer地址获取失败\n"));
                return  FAILED_TO_OBTAIN_FUNCTION_ADDRESSES;
    }
       

    //用一个给定的特征码来确定被HOOK位置
    for(i=0;i<=0x290;i++)
    {
                if ((*(p-6)    == 0xff) &&
                        (*(p-3)  == 0xff) &&
                        (*p      == 0xE8) &&
                        (*(p+5)    == 0x8b) &&
                        (*(p+6)    == 0xf8))
                {
                        KdPrint(("%0X \n",(ULONG)p));
            pTpHookOpenPrcessAddres=p;
                        break;
                }
                //推动指针向前走
                p++;
    }
        if (pTpHookOpenPrcessAddres==NULL)
               
          return FAILED_TO_OBTAIN_FUNCTION_ADDRESSES;
       
        //计算跳到TP在的位置
    p_TpHookNtOpenPrcessAddress = *(PULONG)(pTpHookOpenPrcessAddres+0x01)+(ULONG)pTpHookOpenPrcessAddres+5;
    uRetNtOpenPrcess_0x141 = (ULONG)pTpHookOpenPrcessAddres+5;//保存调用ObOpenObjectByPointer函数以后的返回地址
    //DbgPrint("uRetNtOpenPrcess_0x141=%x,p_TpHookNtOpenPrcessAddress=%x",uRetNtOpenPrcess_0x141,p_TpHookNtOpenPrcessAddress);       

        MyNtOpenProcessHook.OldAddres=(ULONG)pTpHookOpenPrcessAddres-6;//找到我们写入自定义函数的地址
        MyNtOpenProcessHook.NewAddres=(ULONG)Nakd_NtOpenProcess;//就是在TP钩OPENPROCESS前面挂入我们的Nakd_NtOpenProcess
    MyNtOpenProcessHook.HookCodeLen=6;
        SetInlineHook(&MyNtOpenProcessHook,FALSE);

        return  STATUS_SUCCESS;
}
NTSTATUS My_Recovery_Debugport1()
{
        NTSTATUS stats;
        BYTE  *sd1 = NULL,*sd2 = NULL,*pd = NULL;
        ULONG  ModuleSize=0,ModuleAddress=0,i,number = 0;
        BYTE  *p;
        KIRQL  Irql;
        BYTE  C390[2] = {0xc3,0x90};
       
        //获取指定的内核模块地址和字节数
        DbgPrint("sd........");
        stats = MyEnumKernelModule("\\??\\c:\\windows\\system32\\tessafe.sys",&ModuleAddress,&ModuleSize);
        if (ModuleAddress==0||ModuleSize==0 )
        {
                return STATUS_UNSUCCESSFUL;
        }
        KdPrint(("Address:%0X Sie:%d \n",ModuleAddress,ModuleSize));
       
        //将P指向内核模块开始处
        p = (BYTE*)ModuleAddress + 20;
        for (i = 0; i < ModuleSize - 20; i++,p++)
        {
                //sd1
       
                if ((*p==0xf0)&&
                        (*(p+1)==0x0f)&&
                        (*(p+2)==0xc1)&&
                        (*(p+3)==0x08)&&
                        (*(p+4)==0x9d)&&
                        (*(p+5)==0x61)&&
                        (*(p+6)==0x8b)&&
                        (*(p+7)==0xe5)&&
                        (*(p+29)==0x9d)&&
                        (*(p+30)==0x61)&&
                        (*(p+34)==0xff)&&
                        (*(p+36)==0x80))
                {
                       
                        sd1 = p;
                        DbgPrint("sd1=%x \r",(ULONG)sd1);
                        number+=1;  //记录已经获取一个特征
                }
                //sd2
                if((*p==0x87)&&
                        (*(p+1)==0x08)&&
                        (*(p+2)==0x8b)&&
                        (*(p+3)==0x46)&&
                        (*(p-1)==0xC9)&&
                        (*(p-2)==0x33))
                {
                        DbgPrint("sd2=%x \r",(ULONG)p);
                        sd2 = p;
                        number+=1;  //记录已经获取一个特征
                }
                //pd
                if((*p==0x87)&&
                        (*(p+1)==0x07)&&
                        (*(p+2)==0x8b)&&
                        (*(p+3)==0x09)&&
                        (*(p-1)==0xc0)&&
                        (*(p-2)==0x33))
                {
                        DbgPrint("sd3=%x \r",(ULONG)p);
                        pd = p;
                        number+=1;  //记录已经获取一个特征
                }
                if (number >= 3)
                {
                        KdPrint(("特征 %d ---退出\n",number));
                        break;
                }
        }
        if (sd1!=NULL)
        {
                KillTpThread((ULONG)sd1);
        }
        if (pd!=NULL)
        {
                KillTpThread((ULONG)pd);
        }

        if (sd2!=NULL)
        {
                KillTpThread((ULONG)sd2);
        }
        return stats;
}
//////////////////////////////////////////////////////////////////////
//  名称:  My_Recovery_Debugport
//  功能:  恢复游戏对debugport的清零操作
//  参数:  
//  返回:  
//////////////////////////////////////////////////////////////////////

NTSTATUS My_Recovery_Debugport()
{
        NTSTATUS stats;
        BYTE  *sd1 = NULL,*sd2 = NULL,*sd3=NULL,*pd = NULL;
        ULONG  ModuleSize,ModuleAddress,i,number = 0;
        BYTE  *p;
       
        //获取指定的内核模块地址和字节数
        stats = MyEnumKernelModule("\\??\\c:\\windows\\system32\\tessafe.sys",&ModuleAddress,&ModuleSize);
        if (stats == FAILED_TO_OBTAIN_FUNCTION_ADDRESSES)
        {
                return  FAILED_TO_OBTAIN_FUNCTION_ADDRESSES;
        }
        DbgPrint("tessafe.sys Address:%0X Sie:%d \n",ModuleAddress,ModuleSize);
        //特征码
        /*  sd1特征
        p-1:18 p-2:87 p-3B p-4:33 p-5:07
        p-6:03 p  :33 p+1:C0 p+7:3B p+88
    sd2特征
        p-1:07 p-2:87 p-3:c0 p-4:33 p+14:89
        p+15:1c p+16:38
       
          sd3特征
          //f0 0f c1 08 9d 61 8b e5 +29=9d +30=61 +34=ff +36=80
        */
       
        //将P指向内核模块开始处
        p = (BYTE*)ModuleAddress + 20;
        for (i = 0; i < ModuleSize - 20; i++,p++)
        {
                //sd1
                if ((*(p-11) == 0x89) &&
                        (*(p-8) == 0x89) &&
                        (*(p-5) == 0xb9) &&
                        (*p    == 0x33) &&
                        (*(p+1) == 0xC0) &&
                        (*(p+2) == 0x0f) &&
                        (*(p+6) == 0x6b) &&
                        (*(p+9) == 0x03) )
                {
                        DbgPrint("sd1 %x",(ULONG)p);
                        sd1 = p;
                        number+=1;  //记录已经获取一个特征
                }
                //sd2
                if ((*(p-13) == 0xab) &&
                        (*(p-12) == 0x8b) &&
                        (*(p-6) == 0x8b) &&
                        (*(p-3) == 0x03) &&
                        (*p    == 0x33)        &&
                        (*(p+1)== 0xc0) &&
                        (*(p+2)== 0x87) &&
                        (*(p+4)== 0x8b))
                {
                        DbgPrint("sd2 %x",(ULONG)p);
                        sd2 = p;
                        number+=1;  //记录已经获取一个特征
                }
                //pd
                if ((*(p-7) == 0x8b) &&
                        (*(p-5)== 0x8b) &&
                        (*(p-2)== 0x8b) &&
                        (*p    == 0xc1)&&
                        (*(p+3) == 0xF3) &&
                        (*(p+5) == 0x8b) &&
                        (*(p+10) == 0xf3) &&
                        (*(p+12) == 0xeb))
                {
                        DbgPrint("pd %x ",(ULONG)p);
                        pd = p;
                        number+=1;  //记录已经获取一个特征
                }
                if (number >= 3)
                {
                        KdPrint(("特征 %d ---退出\n",number));
                        break;
                }
        }
        if (pd!=NULL)
        {
                KillTpThread((ULONG)pd);
        }
        if (sd1!=NULL)
        {
                KillTpThread((ULONG)sd1);
        }
        if (sd2!=NULL)
        {
                KillTpThread((ULONG)sd2);
        }
        return  STATUS_SUCCESS;
}
//////////////////////////////////////////////////////////////////////
//  名称:  MyNtGetThreadContext && MyNtSetThreadContext
//  功能:  NtGetThreadContext与NtSetThreadContext函数被SSDT HOOK的伪造函数
//  参数:  
//  返回:  
//////////////////////////////////////////////////////////////////////
NTSTATUS MyNtGetThreadContext(HANDLE hThread, PCONTEXT pContext)
{
        if (!IsGameProectProcess())
        {
                ASM
                {
                        push pContext;
                        push hThread;
                        call    dword ptr[NtGetContextThreadAddrValue];
                }
          return STATUS_SUCCESS;
        }
return STATUS_UNSUCCESSFUL;
}
NTSTATUS MyNtSetThreadContext(HANDLE hThread, PCONTEXT pContext)
{

        if (!IsGameProectProcess()||pContext->Dr7 == 0x101)
        {
                ASM
                {
                        push pContext;
                        push hThread;
                        call    dword ptr[NtSetContextThreadAddrValue];
                }
                return STATUS_SUCCESS;
        }
return STATUS_UNSUCCESSFUL;
}

//////////////////////////////////////////////////////////////////////
//  名称:  My_Recovery_HardwareBreakpoint
//  功能:  通过对set与get进行SSDT HOOK来恢复硬件断点
//  参数:  
//  返回:  
//////////////////////////////////////////////////////////////////////
NTSTATUS My_Recovery_HardwareBreakpoint()
{
        KIRQL    Irql;
        ULONG    uNtGetContextThreadAddress=0;
   ULONG    uNtSetContextThreadAddress=0;
        //获取地址
        uNtSetContextThreadAddress = GetSSDTIndexAddres(0xD5);
        uNtGetContextThreadAddress = GetSSDTIndexAddres(0x55);
        WPOFF();  //清除CR0
    TenNtGetContextThread=*(ULONG*)uNtGetContextThreadAddress;
        TenNtSetContextThread=*(ULONG*)uNtSetContextThreadAddress;


        //完成SSDT HOOK
        *(ULONG*)uNtGetContextThreadAddress = (ULONG)MyNtGetThreadContext;
        *(ULONG*)uNtSetContextThreadAddress = (ULONG)MyNtSetThreadContext;
        WPON();    //恢复CR0
        return STATUS_SUCCESS;
}


//////////////////////////////////////////////////////////////////////////
NTSTATUS GetTesSafeAddress(BYTE **ppAddress, ULONG *pSize)
{
        NTSTATUS status = STATUS_UNSUCCESSFUL;
        if ( g_pTesSafeAddress == NULL )
        {
                status = MyEnumKernelModule("\\??\\c:\\windows\\system32\\tessafe.sys", &(ULONG)g_pTesSafeAddress, &g_TesSafeSize);
                if (!NT_SUCCESS(status))
                {
                        DbgPrint("TesSafe is not loaded yet\n");
                        return status;
                }
        }
        else
        {
                *ppAddress = g_pTesSafeAddress;
                *pSize = g_TesSafeSize;
        }
       
        return STATUS_SUCCESS;
}
//////////////////////////////////////////////////////////////////////////
NAKED void MyKe386IoSetAccessProcess(IN PEPROCESS pProcess,IN ULONG dwFlag)
{
        _asm
        {
                mov     edi,edi;
                push    ebp;
                mov     ebp,esp;
                push    esi;
                mov     esi,dword ptr [ebp+0Ch];
                mov eax,Ke386IoSetAccessProcess;
                add eax,0x09;
                jmp eax;       
        }
}
//////////////////////////////////////////////////////////////////////////
NAKED NTSTATUS MyObOpenObjectByPointer(  IN PVOID Object,                                            
                                                                 IN ULONG HandleAttributes,                                 
                                                                 IN PACCESS_STATE PassedAccessStateOPTIONAL,               
                                                                 IN ACCESS_MASK DesiredAccess OPTIONAL,                     
                                                                 IN POBJECT_TYPE ObjectType OPTIONAL,                        
                                                                 IN KPROCESSOR_MODE AccessMode,                              
                                                                 OUT PHANDLE Handle)
{
        _asm
        {
                mov     edi,edi;
                push    ebp;
                mov     ebp,esp;
                sub     esp,94h;
                push    ebx;
                mov eax,ObOpenObjectByPointer;
                add eax,0x0c;
                jmp eax;
               
        }
}












lkd> U DbgkpSetProcessDebugObject
nt!DbgkpSetProcessDebugObject:
806632e3 b8bccbd2a9      mov     eax,0A9D2CBBCh
806632e8 ffe0            jmp     eax
806632ea 185356          sbb     byte ptr [ebx+56h],dl
806632ed 57              push    edi
806632ee 64a124010000    mov     eax,dword ptr fs:[00000124h]
806632f4 8945f8          mov     dword ptr [ebp-8],eax
806632f7 8d45e8          lea     eax,[ebp-18h]
806632fa 8945ec          mov     dword ptr [ebp-14h],eax
lkd> U
nt!DbgkpSetProcessDebugObject+0x1a:
806632fd 8945e8          mov     dword ptr [ebp-18h],eax
80663300 8b4510          mov     eax,dword ptr [ebp+10h]
80663303 33db            xor     ebx,ebx
80663305 3bc3            cmp     eax,ebx
80663307 c645fe01        mov     byte ptr [ebp-2],1
8066330b c645ff00        mov     byte ptr [ebp-1],0
8066330f 7d08            jge     nt!DbgkpSetProcessDebugObject+0x36 (80663319)
80663311 895d14          mov     dword ptr [ebp+14h],ebx
lkd> U
nt!DbgkpSetProcessDebugObject+0x31:
80663314 894510          mov     dword ptr [ebp+10h],eax
80663317 eb03            jmp     nt!DbgkpSetProcessDebugObject+0x39 (8066331c)
80663319 895d10          mov     dword ptr [ebp+10h],ebx
8066331c 395d10          cmp     dword ptr [ebp+10h],ebx
8066331f 8b7d08          mov     edi,dword ptr [ebp+8]
80663322 8b3518914d80    mov     esi,dword ptr [nt!_imp_ExAcquireFastMutex (804d9118)]
80663328 0f8c93000000    jl      nt!DbgkpSetProcessDebugObject+0xde (806633c1)
8066332e b940155680      mov     ecx,offset nt!DbgkpProcessDebugPortMutex (80561540)
lkd> U
nt!DbgkpSetProcessDebugObject+0x50:
80663333 c645ff01        mov     byte ptr [ebp-1],1
80663337 ffd6            call    esi
80663339 399fbc000000    cmp     dword ptr [edi+0BCh],ebx
8066333f 7573            jne     nt!DbgkpSetProcessDebugObject+0xd1 (806633b4)
80663341 8b450c          mov     eax,dword ptr [ebp+0Ch]
80663344 8b4d14          mov     ecx,dword ptr [ebp+14h]
80663347 8987bc000000    mov     dword ptr [edi+0BCh],eax
8066334d e8117de7ff      call    nt!ObfReferenceObject (804db063)
lkd> U
nt!DbgkpSetProcessDebugObject+0x6f:
80663352 ff7514          push    dword ptr [ebp+14h]
80663355 57              push    edi
80663356 e8fa5ff2ff      call    nt!PsGetNextProcessThread (80589355)
8066335b 8bd8            mov     ebx,eax
8066335d 85db            test    ebx,ebx
8066335f 7460            je      nt!DbgkpSetProcessDebugObject+0xde (806633c1)
80663361 83a7bc00000000  and     dword ptr [edi+0BCh],0
80663368 b940155680      mov     ecx,offset nt!DbgkpProcessDebugPortMutex (80561540)
///////////////////////////////////////////////////////////////////////

lkd> U DbgkpQueueMessage
nt!DbgkpQueueMessage:
80662525 b83eccd2a9      mov     eax,0A9D2CC3Eh
8066252a ffe0            jmp     eax
8066252c b800000053      mov     eax,53000000h
80662531 56              push    esi
80662532 8b7514          mov     esi,dword ptr [ebp+14h]
80662535 8975fc          mov     dword ptr [ebp-4],esi
80662538 8365fc02        and     dword ptr [ebp-4],2
8066253c 7448            je      nt!DbgkpQueueMessage+0x61 (80662586)
lkd> U
nt!DbgkpQueueMessage+0x19:
8066253e 6844626745      push    45676244h
80662543 68b0000000      push    0B0h
80662548 6a08            push    8
8066254a e80372e8ff      call    nt!ExAllocatePoolWithQuotaTag (804e9752)
8066254f 8bd8            mov     ebx,eax
80662551 85db            test    ebx,ebx
80662553 750a            jne     nt!DbgkpQueueMessage+0x3a (8066255f)
80662555 b89a0000c0      mov     eax,0C000009Ah
lkd> U
nt!DbgkpQueueMessage+0x35:
8066255a e974010000      jmp     nt!DbgkpQueueMessage+0x1ae (806626d3)
8066255f 8b4d08          mov     ecx,dword ptr [ebp+8]
80662562 83ce04          or      esi,4
80662565 89732c          mov     dword ptr [ebx+2Ch],esi
80662568 e8f68ae7ff      call    nt!ObfReferenceObject (804db063)
8066256d 8b4d0c          mov     ecx,dword ptr [ebp+0Ch]
80662570 e8ee8ae7ff      call    nt!ObfReferenceObject (804db063)
80662575 64a124010000    mov     eax,dword ptr fs:[00000124h]
lkd> U
nt!DbgkpQueueMessage+0x56:
8066257b 894330          mov     dword ptr [ebx+30h],eax
8066257e 8b4518          mov     eax,dword ptr [ebp+18h]
80662581 894514          mov     dword ptr [ebp+14h],eax
80662584 eb5d            jmp     nt!DbgkpQueueMessage+0xbe (806625e3)
80662586 b940155680      mov     ecx,offset nt!DbgkpProcessDebugPortMutex (80561540)
8066258b 8d9d48ffffff    lea     ebx,[ebp-0B8h]
80662591 89b574ffffff    mov     dword ptr [ebp-8Ch],esi
80662597 ff1518914d80    call    dword ptr [nt!_imp_ExAcquireFastMutex (804d9118)]

//白名单资源
mov edi, edi
push ebp
mov ebp, esp
mov ecx, dword ptr [F30691A8]
mov edx, F30691A8
xor al, al
cmp ecx, edx
je short F305F0A7
push esi
mov esi, dword ptr [ebp+8]
cmp esi, dword ptr [ecx-24]
je short F305F099
mov ecx, dword ptr [ecx]
cmp ecx, edx
jne short F305F089
jmp short F305F0A6
mov edx, dword ptr [ebp+C]
inc dword ptr [ecx-4]
test dword ptr [ecx-1C], edx
je short F305F0A6
mov al, 1

F305F0A7:

  pop esi
pop ebp
retn 8





//
//
#include <ntddk.h>
#include "DebugPort.h"

//////////////////////////////////////////////////////////////////////////
//全局变量
DEBUGPORT_INDEX DebugPort_index={0};
BYTE debugport_in[2]={0xBC,0x00};   //还原修改的函数
BYTE debugPort_out[2]={0x5C,0x02};  //将DebugPort+bc移至DebugPort+25C
//////////////////////////////////////////////////////////////////////////
VOID MyRtlCopyMemory(void* dresAddress,void* SrcAddress,ULONG len)
{
        if (dresAddress!=NULL&&SrcAddress!=NULL)
        {
                RtlCopyMemory(dresAddress,SrcAddress,len);
        }
}
VOID Hook_DebugPort()
{
/*
1.枚举模块获取首地址
2.定位函数地址
3.修改函数
        */
        NTSTATUS status;
        PCHAR GamePath;
        ULONG KerBase=0;
        ULONG KerSize=0;
        ULONG i,KerCount,tmp;
        BYTE* P=NULL;
        KIRQL  Irql;
    GetKernelBaseAndSize(&KerBase,&KerSize);
    if (KerBase==0||KerSize==0)
    {
                DbgPrint("Get kerBase err");
                return ;
    }
        DbgPrint("kerBase=%x,kerSize=%x",KerBase,KerSize);
        KerBase=KerBase+0x7Fb0;
        //KerCount=0x805cf000-20;
        KerCount=KerBase+KerSize-0x7Fb0-40;
        if (!MmIsAddressValid((void*)KerBase)||!MmIsAddressValid((void*)KerCount))
        {
                DbgPrint("kerBaseRead err",KerBase);
                for (tmp=KerBase;tmp<(KerBase+KerSize);tmp++)
                {
                        if (!MmIsAddressValid((void*)tmp))
                        {
                                DbgPrint("read size=%x",tmp);
                                KerCount=tmp;
                                break;
                        }
                }
               
        }
//////////////////////////////////////////////////////////////////////////
//81c3bc000000
        P=(BYTE*)KerBase;
        DbgPrint("Find 81c3bc000000 Addres");
   for (i=KerBase;i<KerCount;i++)
        {
                if(        (GetMemValue(P)==0x81)&&
                        (GetMemValue(P+1)==0xc6)&&
                        (GetMemValue(P+2)==0xbc)&&
                        (GetMemValue(P+3)==0x00)&&
                        (GetMemValue(P+4)==0x00)&&
                        (GetMemValue(P+5)==0x00))
                {
                        DbgPrint("Find 81c3bc000000 Addres=0X%X",(ULONG)P);
                }
                P++;
   }

        //////////////////////////////////////////////////////////////////////////
        P=(BYTE*)KerBase;       
        for (i=KerBase;i<KerCount;i++)
        {
                if((GetMemValue(P-9)==0x64)&&
                        (GetMemValue(P-3)==0x8B)&&
                        (GetMemValue(P)==0x39)&&
                        (GetMemValue(P+6)==0x74)&&
                        (GetMemValue(P+8)==0x6A)&&
                        (GetMemValue(P+10)==0x8D))
                {
                        DebugPort_index.KiDispatchException=(ULONG)P+2;
               
                }
               
                if((GetMemValue(P-19)==0xE8)&&
                        (GetMemValue(P-14)==0x85)&&
                        (GetMemValue(P-12)==0x0F)&&
                        (GetMemValue(P-6)==0x8B)&&
                        (GetMemValue(P)==0x8B)&&
                        (GetMemValue(P+6)==0xF7))
                {
                        DebugPort_index.NtQueryInformationProcess=(ULONG)P+2;
                }
               
               
       
                if((GetMemValue(P-13)==0x8B)&&
                        (GetMemValue(P-11)==0x3B)&&
                        (GetMemValue(P-9)==0x0F)&&
                        (GetMemValue(P-3)==0x8B)&&
                        (GetMemValue(P)==0x89)&&
                        (GetMemValue(P+6)==0xF6)&&
                        (GetMemValue(P+10)==0x74))
                {
                        DebugPort_index.PspCreateProcess=(ULONG)P+2;
                       
                }
               
                if((GetMemValue(P-5)==0x8B)&&
                        (GetMemValue(P-3)==0x8B)&&
                        (GetMemValue(P)==0x8B)&&
                        (GetMemValue(P+6)==0x5D)&&
                        (GetMemValue(P+7)==0xC2)&&
                        (GetMemValue(P+10)==0x83))
                {
                        DebugPort_index.PsGetProcessDebugPort=(ULONG)P-2;
                       
                }
               
                if((GetMemValue(P-5)==0x8B)&&
                        (GetMemValue(P-3)==0x8B)&&
                        (GetMemValue(P)==0x83)&&
                        (GetMemValue(P+1)==0xB8)&&
                        (GetMemValue(P+7)==0x0F)&&
                        (GetMemValue(P+10)==0x5D)&&
                        (GetMemValue(P+11)==0xC2))
                {
                        DebugPort_index.PsIsProcessBeingDebugged=(ULONG)P+2;
                }
               
                if((GetMemValue(P-13)==0x81)&&
                        (GetMemValue(P-6)==0x0f)&&
                        (GetMemValue(P)==0x83)&&
                        (GetMemValue(P+13)==0x8b)&&
                        (GetMemValue(P+7)==0x0f))
                {
                        DebugPort_index.NtTerminateProcess=(ULONG)P+2;
                }
               
               
                if((GetMemValue(P-6)==0x8B)&&
                        (GetMemValue(P-4)==0x85)&&
                        (GetMemValue(P-2)==0x75)&&
                        (GetMemValue(P)==0x39)&&
                        (GetMemValue(P+1)==0x86)&&
                        (GetMemValue(P+2)==0xBC)&&
                        (GetMemValue(P+6)==0x74)&&
                        (GetMemValue(P+8)==0x56))
                {
                        DebugPort_index.PspTerminateProcess=(ULONG)P+2;
               
                }
                if((GetMemValue(P-5)==0xE8)&&
                        (GetMemValue(P)==0x83)&&
                        (GetMemValue(P+1)==0xBF)&&
                        (GetMemValue(P+2)==0xBC)&&
                        (GetMemValue(P+7)==0x74)&&
                        (GetMemValue(P+9)==0xF6))
                {
                        DebugPort_index.PspExitThread=(ULONG)P+2;
       
                }
               
                if((GetMemValue(P-9)==0x64)&&
                        (GetMemValue(P-3)==0x8b)&&
                        (GetMemValue(P)==0x83)&&
                        (GetMemValue(P+7)==0x74)&&
                        (GetMemValue(P+9)==0x68))
                {
                        DebugPort_index.PspProcessDelete[0]=(ULONG)P+2;
               
                }
                if((GetMemValue(P-13)==0x80)&&
                        (GetMemValue(P-9)==0x64)&&
                        (GetMemValue(P-3)==0x8b)&&
                        (GetMemValue(P)==0x83)&&       
                        (GetMemValue(P+8)==0x74))
                {
                        DebugPort_index.PspProcessDelete[1]=(ULONG)P+2;
               
                }
               
               
                if((GetMemValue(P-9)==0x81)&&
                        (GetMemValue(P-2)==0x74)&&
                        (GetMemValue(P)==0x83)&&
                        (GetMemValue(P+1)==0xBB)&&
                        (GetMemValue(P+2)==0xBC)&&
                        (GetMemValue(P+7)==0x74))
                {
                        DebugPort_index.PspProcessDelete[2]=(ULONG)P+2;
                       
                }
               
               
                if((GetMemValue(P-9)==0x64)&&(GetMemValue(P-3)==0x8B)&&(GetMemValue(P)==0x83)&&(GetMemValue(P+1)==0xB8)&&(GetMemValue(P+2)==0xBC)&&(GetMemValue(P+7)==0x74))
                {
                        DebugPort_index.ObpCloseHandleTableEntry=(ULONG)P+2;
               
                }
               
               
                if((GetMemValue(P-9)==0xF6)&&(GetMemValue(P-2)==0x75)&&(GetMemValue(P)==0x39)&&(GetMemValue(P+1)==0x8B)&&(GetMemValue(P+2)==0xBC)&&(GetMemValue(P+6)==0x74))
                {
                        DebugPort_index.ObpCloseHandle=(ULONG)P+2;
               
                }
               
               
                if((GetMemValue(P-8)==0x8B)&&(GetMemValue(P-5)==0x89)&&(GetMemValue(P-2)==0x33)&&(GetMemValue(P)==0x39)&&(GetMemValue(P+1)==0x9E)&&(GetMemValue(P+6)==0x0F))
                {
                        DebugPort_index.MmCreatePeb=(ULONG)P+2;
               
                }
               
               
                if((GetMemValue(P-6)==0x50)&&(GetMemValue(P-5)==0xE8)&&(GetMemValue(P)==0x39)&&(GetMemValue(P+1)==0x9E)&&(GetMemValue(P+2)==0xBC)&&(GetMemValue(P+6)==0x0F)&&(GetMemValue(P+12)==0x39))
                {
                        DebugPort_index.DbgkCreateThread=(ULONG)P+2;
                       
                }
               
               
                if((GetMemValue(P-9)==0xF6)&&(GetMemValue(P-2)==0x75)&&(GetMemValue(P)==0x8B)&&(GetMemValue(P+1)==0x89)&&(GetMemValue(P+2)==0xBC)&&(GetMemValue(P+6)==0x85))
                {
                        DebugPort_index.DbgkExitThread=(ULONG)P+2;
               
                }
               
                if((GetMemValue(P-9)==0xF6)&&(GetMemValue(P-2)==0x75)&&(GetMemValue(P)==0x8B)&&(GetMemValue(P+1)==0x89)&&(GetMemValue(P+2)==0xBC)&&(GetMemValue(P+6)==0x85))
                {
                        DebugPort_index.DbgkExitProcess=(ULONG)P+2;
               
                }
               
               
                if((GetMemValue(P-6)==0x74)&&(GetMemValue(P-4)==0x33)&&(GetMemValue(P-2)==0xEB)&&(GetMemValue(P)==0x8B)&&(GetMemValue(P+1)==0x89)&&(GetMemValue(P+6)==0x3B))
                {
                        DebugPort_index.DbgkMapViewOfSection=(ULONG)P+2;
               
                }
               
                if((GetMemValue(P-9)==0xF6)&&(GetMemValue(P-2)==0x75)&&(GetMemValue(P)==0x83)&&(GetMemValue(P+1)==0xB9)&&(GetMemValue(P+2)==0xBC)&&(GetMemValue(P+7)==0x74))
                {
                        DebugPort_index.DbgkUnMapViewOfSection=(ULONG)P+2;
               
                }
               
                if((GetMemValue(P-11)==0xFF)&&(GetMemValue(P-5)==0x89)&&(GetMemValue(P-2)==0x33)&&(GetMemValue(P)==0x39)&&(GetMemValue(P+1)==0xBE)&&(GetMemValue(P+6)==0x0F)&&(GetMemValue(P+9)==0x8B))
                {
                        DebugPort_index.DbgkpMarkProcessPeb=(ULONG)P+2;
               
                }
               
                if((GetMemValue(P-5)==0xEB)&&(GetMemValue(P-3)==0x8B)&&(GetMemValue(P)==0x81)&&(GetMemValue(P+1)==0xC3)&&(GetMemValue(P+2)==0xBC)&&(GetMemValue(P+6)==0x39)&&(GetMemValue(P+8)==0x75))
                {
                        DebugPort_index.DbgkpCloseObject[0]=(ULONG)P+2;
               
                }
               
                if((GetMemValue(P-5)==0xFF)&&(GetMemValue(P-3)==0x8B)&&(GetMemValue(P)==0x05)&&(GetMemValue(P+1)==0xBC)&&(GetMemValue(P+5)==0x8B)&&(GetMemValue(P+7)==0x33))
                {
                        DebugPort_index.DbgkpCloseObject[1]=(ULONG)P+1;
               
                }
               
               
                if((GetMemValue(P-6)==0xC6)&&(GetMemValue(P-2)==0xFF)&&(GetMemValue(P)==0x39)&&(GetMemValue(P+1)==0x9F)&&(GetMemValue(P+6)==0x75)&&(GetMemValue(P+8)==0x8B))
                {
                        DebugPort_index.DbgkpCloseObject[2]=(ULONG)P+2;
               
                }
               
                if((GetMemValue(P-6)==0x55)&&
                        (GetMemValue(P-5)==0x8B)&&
                        (GetMemValue(P-3)==0x8B)&&
                        (GetMemValue(P)==0x83)&&
                        (GetMemValue(P+1)==0xA0)&&
                        (GetMemValue(P+2)==0xBC)&&
                        (GetMemValue(P+7)==0x56))
                {
                        DebugPort_index.DbgkCopyProcessDebugPort[0]=(ULONG)P+2;
                }
               
                if((GetMemValue(P-4)==0x85)&&
                        (GetMemValue(P-2)==0x74)&&
                        (GetMemValue(P)==0x83)&&
                        (GetMemValue(P+2)==0xBC)&&
                        (GetMemValue(P+3)==0x00)&&
                        (GetMemValue(P+7)==0xb9))
                {
                        DebugPort_index.DbgkCopyProcessDebugPort[1]=(ULONG)P+2;
               
                }
               
                if((GetMemValue(P-8)==0xE8)&&(GetMemValue(P-3)==0x8B)&&(GetMemValue(P)==0x89)&&(GetMemValue(P+1)==0xB0)&&(GetMemValue(P+2)==0xBC)&&(GetMemValue(P+6)==0x8B))
                {
                        DebugPort_index.DbgkCopyProcessDebugPort[2]=(ULONG)P+2;
               
                }
               
               
                if((GetMemValue(P-5)==0x51)&&(GetMemValue(P-4)==0x56)&&(GetMemValue(P-3)==0x8B)&&(GetMemValue(P)==0x81)&&(GetMemValue(P+1)==0xC6)&&(GetMemValue(P+6)==0x83)&&(GetMemValue(P+9)==0xC7))
                {
                        DebugPort_index.DbgkCopyProcessDebugPort[3]=(ULONG)P+2;
               
                }
               
                if((GetMemValue(P-5)==0x51)&&(GetMemValue(P-4)==0x56)&&(GetMemValue(P-3)==0x8B)&&(GetMemValue(P)==0x81)&&(GetMemValue(P+1)==0xC6)&&(GetMemValue(P+6)==0x83)&&(GetMemValue(P+9)==0xC7))
                {
                        DebugPort_index.DbgkOpenProcessDebugPort[0]=(ULONG)P+2;
               
                }
               
                if((GetMemValue(P-9)==0xFF)&&(GetMemValue(P-3)==0x8B)&&(GetMemValue(P)==0x8B)&&(GetMemValue(P+1)==0x80)&&(GetMemValue(P+6)==0x89)&&(GetMemValue(P+9)==0x8B))
                {
                        DebugPort_index.DbgkOpenProcessDebugPort[1]=(ULONG)P+2;
               
                }
               
                if((GetMemValue(P-9)==0xFF)&&(GetMemValue(P-3)==0x8B)&&(GetMemValue(P)==0x8B)&&(GetMemValue(P+1)==0x80)&&(GetMemValue(P+6)==0x89)&&(GetMemValue(P+9)==0x8B))
                {
                        DebugPort_index.DbgkpQueueMessage=(ULONG)P+2;
               
                }
               
                if((GetMemValue(P-5)==0xFF)&&(GetMemValue(P-3)==0x8B)&&(GetMemValue(P)==0x05)&&(GetMemValue(P+1)==0xBC)&&(GetMemValue(P+5)==0x8B)&&(GetMemValue(P+7)==0x33))
                {
                        DebugPort_index.DbgkClearProcessDebugObject[0]=(ULONG)P+1;
               
                }
               
                if((GetMemValue(P-6)==0xC6)&&(GetMemValue(P-2)==0xFF)&&(GetMemValue(P)==0x39)&&(GetMemValue(P+1)==0x9F)&&(GetMemValue(P+6)==0x75)&&(GetMemValue(P+8)==0x8B))
                {
                        DebugPort_index.DbgkClearProcessDebugObject[1]=(ULONG)P+2;
               
                }
               
                if((GetMemValue(P-6)==0xC6)&&(GetMemValue(P-2)==0xFF)&&(GetMemValue(P)==0x39)&&(GetMemValue(P+1)==0x9F)&&(GetMemValue(P+6)==0x75)&&(GetMemValue(P+8)==0x8B))
                {
                        DebugPort_index.DbgkpSetProcessDebugObject[0]=(ULONG)P+2;
               
                }
               
                if((GetMemValue(P-6)==0x8B)&&(GetMemValue(P-3)==0x8B)&&(GetMemValue(P)==0x89)&&(GetMemValue(P+1)==0x87)&&(GetMemValue(P+6)==0xE8)&&(GetMemValue(P+11)==0xFF))
                {
                        DebugPort_index.DbgkpSetProcessDebugObject[1]=(ULONG)P+2;
               
                }
               
               
                if((GetMemValue(P-6)==0x8B)&&(GetMemValue(P-4)==0x85)&&(GetMemValue(P-2)==0x74)&&(GetMemValue(P)==0x83)&&(GetMemValue(P+1)==0xA7)&&(GetMemValue(P+7)==0xB9))
                {
                        DebugPort_index.DbgkpSetProcessDebugObject[2]=(ULONG)P+2;
                       
                }
               
                if((GetMemValue(P-6)==0xC6)&&(GetMemValue(P-2)==0xFF)&&(GetMemValue(P)==0x83)&&(GetMemValue(P+1)==0xBF)&&(GetMemValue(P+7)==0x74)&&(GetMemValue(P+9)==0xC7))
                {
                        DebugPort_index.DbgkpSetProcessDebugObject[3]=(ULONG)P+2;
                       
                }
               
                if((GetMemValue(P-7)==0xE8)&&(GetMemValue(P-2)==0xEB)&&(GetMemValue(P)==0x83)&&(GetMemValue(P+1)==0xA7)&&(GetMemValue(P+7)==0xC7))
                {
                        DebugPort_index.DbgkpSetProcessDebugObject[4]=(ULONG)P+2;
                }
               
                if((GetMemValue(P-6)==0x74)&&(GetMemValue(P-4)==0x33)&&(GetMemValue(P-2)==0xEB)&&(GetMemValue(P)==0x8B)&&(GetMemValue(P+1)==0x81)&&(GetMemValue(P+6)==0x32)&&(GetMemValue(P+8)==0xEB))
                {
                        DebugPort_index.DbgkForwardException=(ULONG)P+2;
                }
                P++;
        }
        //////////////////////////////////////////////////////////////////////////
        KdPrint(("NtQueryInformationProecss访问DebugPort的地址为:%x\n",DebugPort_index.NtQueryInformationProcess));
        DbgPrint("KiDispatchException访问DebugPort的地址为:%x\n",DebugPort_index.KiDispatchException);
        KdPrint(("spCreateProess访问DebugPort的地址为:%x\n",DebugPort_index.PspCreateProcess));
        KdPrint(("sGetProcessDeubugPort访问DebugPort的地址为:%x\n",DebugPort_index.PsGetProcessDebugPort));
        KdPrint(("sIsProcessBeingDebugged访问DebugPort的地址为:%x\n",DebugPort_index.PsIsProcessBeingDebugged));
        KdPrint(("NtTerminateProecss访问DebugPort的地址为:%x\n",DebugPort_index.NtTerminateProcess));
        KdPrint(("spTerminateProecss访问DebugPort的地址为:%x\n",DebugPort_index.PspTerminateProcess));
        KdPrint(("spExitThread访问DebugPort的地址为:%x\n",DebugPort_index.PspExitThread));
                                KdPrint(("第一处PspProcessDelete访问DebugPotr的地址为:%x\n",DebugPort_index.PspProcessDelete[0]));
                                KdPrint(("第二处PspProcessDelete访问DebugPotr的地址为:%x\n",DebugPort_index.PspProcessDelete[1]));
                                KdPrint(("第三处PspProcessDelete访问DebugPotr的地址为:%x\n",DebugPort_index.PspProcessDelete[2]));
                                KdPrint(("ObpCloseHandleTableEntry访问DebugPort的地址为:%x\n",DebugPort_index.ObpCloseHandleTableEntry));
                                KdPrint(("ObpCloseHandle访问DebugPort的地址为:%x\n",DebugPort_index.ObpCloseHandle));
                                KdPrint(("MmCreatePeb访问DebugPort的地址为:%x\n",DebugPort_index.MmCreatePeb));
                                KdPrint(("DbgkCreateThread访问DebugPort的地址为:%x\n",DebugPort_index.DbgkCreateThread));
                                KdPrint(("DbgkExitThread访问DebugPort的地址为:%x\n",DebugPort_index.DbgkExitThread));
                                KdPrint(("DbgkExitProcess访问DebugProt的地址为:%x\n",DebugPort_index.DbgkExitProcess));
                                KdPrint(("DbgkMapViewOfSection访问DebugPort的地址为:%x\n",DebugPort_index.DbgkMapViewOfSection));
                                KdPrint(("DbgkUnMapViewOfSection访问DebugPort的地址为:%x\n",DebugPort_index.DbgkUnMapViewOfSection));
                                KdPrint(("DbgkpMarkProcessPeb访问DebugPort的地址为:%x\n",DebugPort_index.DbgkpMarkProcessPeb));
                                KdPrint(("第一个DbgkpCloseObject访问DeBugPort的地址为:%x\n",DebugPort_index.DbgkpCloseObject[0]));
                                KdPrint(("第二个DbgkpCloseObject访问DebugPort的地址为:%x\n",DebugPort_index.DbgkpCloseObject[1]));
                                KdPrint(("第三个DbgkpCloseObject访问DebugPort的地址为:%x\n",DebugPort_index.DbgkpCloseObject[2]));
                                KdPrint(("第一个DbgkCopyProcessDebugPort访问DebugPort的地址为:%x\n",DebugPort_index.DbgkCopyProcessDebugPort[0]));
                                KdPrint(("第二个DbgkCopyProcessDebugPort访问DebugPort的地址为:%x\n",DebugPort_index.DbgkCopyProcessDebugPort[1]));
                                KdPrint(("第三个DbgkCopyProcessDebugPort访问DebugPort的地址为:%x\n",DebugPort_index.DbgkCopyProcessDebugPort[2]));
                                KdPrint(("第四个DbgkCopyProcessDebugPort访问DebugPort的地址为:%x\n",DebugPort_index.DbgkCopyProcessDebugPort[3]));
                                KdPrint(("第一个DbgkOpenProcessDebugPort的访问地址为:%x\n",DebugPort_index.DbgkOpenProcessDebugPort[0]));
                                KdPrint(("第二个DbgkOpenProcessDebugPort访问DebugPort的地址为:%x\n",DebugPort_index.DbgkOpenProcessDebugPort[1]));
                                KdPrint(("DbgkpQueueMessage访问DebugPort的地址为:%x\n",DebugPort_index.DbgkpQueueMessage));
                                KdPrint(("DbgkClearProcessDebugObject访问DebugPort的地址为:%x\n",DebugPort_index.DbgkClearProcessDebugObject[0]));
                                KdPrint(("DbgkClearProcessDebugObject访问DebugPort的地址为:%x\n",DebugPort_index.DbgkClearProcessDebugObject[1]));
                                KdPrint(("第一个DbgkpSetProcessDebugObject访问DebugPort的地址为:%x\n",DebugPort_index.DbgkpSetProcessDebugObject[0]));
                                KdPrint(("第二个DbgkpSetProcessDebugObject访问DebugPort的地址为:%x\n",DebugPort_index.DbgkpSetProcessDebugObject[1]));
                                KdPrint(("第三个DbgkpSetProcessDebugObject访问DebugPort的地址为:%x\n",DebugPort_index.DbgkpSetProcessDebugObject[2]));
                                KdPrint(("第四个DbgkpSetProcessDebugObject访问DebugPort的地址为:%x\n",DebugPort_index.DbgkpSetProcessDebugObject[3]));
                                KdPrint(("第四个DbgkpSetProcessDebugObject访问DebugPort的地址为:%x\n",DebugPort_index.DbgkpSetProcessDebugObject[3]));
                                KdPrint(("第五个DbgkpSetProcessDebugObject访问DebugPort的地址为:%x\n",DebugPort_index.DbgkpSetProcessDebugObject[4]));
                                KdPrint(("DbgkForwardException访问DeubugPort的地址为:%x\n",DebugPort_index.DbgkForwardException));       
                               
                               
                                //////////////////////////////////////////////////////////////////////////
                               
                                return;
        WPOFF();  //清除CR0
        //提升IRQL中断级
        Irql=KeRaiseIrqlToDpcLevel();
        MyRtlCopyMemory((PVOID)DebugPort_index.KiDispatchException,(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.NtQueryInformationProcess,(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.PspCreateProcess,(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.PsGetProcessDebugPort,(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.PsIsProcessBeingDebugged,(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.NtTerminateProcess,(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.PspTerminateProcess,(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.PspExitThread,(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.PspProcessDelete[0],(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.PspProcessDelete[1],(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.PspProcessDelete[2],(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.ObpCloseHandleTableEntry,(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.ObpCloseHandle,(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.MmCreatePeb,(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkCreateThread,(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkExitThread,(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkExitProcess,(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkMapViewOfSection,(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkUnMapViewOfSection,(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkpMarkProcessPeb,(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkpCloseObject[0],(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkpCloseObject[1],(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkpCloseObject[2],(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkCopyProcessDebugPort[0],(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkCopyProcessDebugPort[1],(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkCopyProcessDebugPort[2],(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkCopyProcessDebugPort[3],(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkOpenProcessDebugPort[0],(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkOpenProcessDebugPort[1],(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkpQueueMessage,(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkClearProcessDebugObject[0],(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkClearProcessDebugObject[1],(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkpSetProcessDebugObject[0],(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkpSetProcessDebugObject[1],(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkpSetProcessDebugObject[2],(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkpSetProcessDebugObject[3],(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkpSetProcessDebugObject[4],(void*)&debugPort_out,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkForwardException,(void*)&debugPort_out,2);
        //恢复Irql
        KeLowerIrql(Irql);
        WPON();    //恢复CR0
}
VOID Un_DebugPort()
{
        KIRQL  Irql;
        WPOFF();  //清除CR0
        //提升IRQL中断级
        Irql=KeRaiseIrqlToDpcLevel();
        MyRtlCopyMemory((PVOID)DebugPort_index.KiDispatchException,(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.NtQueryInformationProcess,(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.PspCreateProcess,(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.PsGetProcessDebugPort,(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.PsIsProcessBeingDebugged,(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.NtTerminateProcess,(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.PspTerminateProcess,(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.PspExitThread,(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.PspProcessDelete[0],(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.PspProcessDelete[1],(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.PspProcessDelete[2],(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.ObpCloseHandleTableEntry,(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.ObpCloseHandle,(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.MmCreatePeb,(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkCreateThread,(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkExitThread,(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkExitProcess,(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkMapViewOfSection,(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkUnMapViewOfSection,(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkpMarkProcessPeb,(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkpCloseObject[0],(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkpCloseObject[1],(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkpCloseObject[2],(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkCopyProcessDebugPort[0],(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkCopyProcessDebugPort[1],(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkCopyProcessDebugPort[2],(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkCopyProcessDebugPort[3],(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkOpenProcessDebugPort[0],(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkOpenProcessDebugPort[1],(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkpQueueMessage,(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkClearProcessDebugObject[0],(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkClearProcessDebugObject[1],(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkpSetProcessDebugObject[0],(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkpSetProcessDebugObject[1],(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkpSetProcessDebugObject[2],(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkpSetProcessDebugObject[3],(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkpSetProcessDebugObject[4],(void*)&debugport_in,2);
        MyRtlCopyMemory((PVOID)DebugPort_index.DbgkForwardException,(void*)&debugport_in,2);
        //恢复Irql
        KeLowerIrql(Irql);
        WPON();    //恢复CR0
}


//////////////////////////////////////////////////////////////////////////


郁金香外挂教程,学习中...
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则


QQ|小黑屋|手机版|鑫郁飞网络技术-郁金香灬老师 ( 苏ICP备10059359号 )

GMT+8, 2018-4-20 20:39 , Processed in 0.088588 second(s), 18 queries .

Powered by Discuz! X3.4

© 2001-2017 Comsenz Inc.

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