过游戏保护驱动

最新推荐文章于 2023-06-05 17:13:28 发布
最新推荐文章于 2023-06-05 17:13:28 发布
阅读量4.7k 收藏 9
点赞数 2
分类专栏： 驱动

整理自CrazyWolf的博客

学习下过游戏驱动保护的方法。

篇一：

//
//define
#define SsdtTbaleSize 0x11C //
//全局

ULONG ZwHookOpenProcess = 0;
ULONG ZwHookWriteVirtualMemory = 0;
ULONG ZwHookQuerySystemInformation = 0;


DWORD oldssdt[SsdtTbaleSize] = {0};


VOID SaveOldSSdt()
{
//保存没有被HOOK前的SSDT表
PVOID pssdttableaddr = (PVOID)KeServiceDescriptorTable->ServiceTableBase;
RtlCopyMemory( oldssdt , pssdttableaddr , SsdtTbaleSize*sizeof(DWORD) );

KdPrint( ("SaveOldSSdt OK") );
}


ULONG GetFunctionId( char* FunctionName )
{
NTSTATUS ntstatus;
HANDLE hFile = NULL; 
HANDLE hSection = NULL ;
OBJECT_ATTRIBUTES object_attributes;
IO_STATUS_BLOCK io_status = {0};
PVOID baseaddress = NULL;
SIZE_T size = 0;
//模块基址
PVOID ModuleAddress = NULL;
//偏移量
ULONG dwOffset = 0;

PIMAGE_DOS_HEADER dos = NULL;
PIMAGE_NT_HEADERS nt = NULL; 
PIMAGE_DATA_DIRECTORY expdir = NULL;
PIMAGE_EXPORT_DIRECTORY exports = NULL;

ULONG addr;
ULONG Size;

PULONG functions;
PSHORT ordinals;
PULONG names;

ULONG max_name;
ULONG max_func;
ULONG i;

ULONG pFunctionAddress;

ULONG ServiceId;

UNICODE_STRING DllName;
RtlInitUnicodeString( &DllName, L"\\SystemRoot\\system32\\ntdll.dll");
//初始化OBJECT_ATTRIBUTES结构
InitializeObjectAttributes( 
   &object_attributes,
   &DllName,
    OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
   NULL,
   NULL);
//打开文件
ntstatus = ZwCreateFile(
   &hFile,
    FILE_EXECUTE | SYNCHRONIZE,
   &object_attributes,
   &io_status,
   NULL,
    FILE_ATTRIBUTE_NORMAL,
    FILE_SHARE_READ,
    FILE_OPEN,
    FILE_NON_DIRECTORY_FILE |
    FILE_RANDOM_ACCESS |
    FILE_SYNCHRONOUS_IO_NONALERT,
   NULL,
   0);
if( !NT_SUCCESS( ntstatus ))
{
    KdPrint(("[GetFunctionAddress] error0\n"));
    KdPrint(("[GetFunctionAddress] ntstatus = 0x%x\n", ntstatus));
   return 0;
}
//创建区段
InitializeObjectAttributes(
   &object_attributes,
   NULL,
    OBJ_CASE_INSENSITIVE|OBJ_KERNEL_HANDLE,
   NULL,
   NULL);

ntstatus = ZwCreateSection(
   &hSection,
    SECTION_ALL_ACCESS,
   &object_attributes,
   0,
    PAGE_EXECUTE,
    SEC_IMAGE,
    hFile);
if( !NT_SUCCESS( ntstatus ))
{
    KdPrint(("[GetFunctionAddress] error1\n"));
    KdPrint(("[GetFunctionAddress] ntstatus = 0x%x\n", ntstatus));
   return 0;
}
//映射区段到进程虚拟空间
ntstatus = ZwMapViewOfSection(
    hSection,
    NtCurrentProcess(), //ntddk.h定义的宏用来获取当前进程句柄
   &baseaddress,
   0,
   1000,
   0,
   &size,
   (SECTION_INHERIT)1,
    MEM_TOP_DOWN,
    PAGE_READWRITE);
if( !NT_SUCCESS( ntstatus ))
{
    KdPrint(("[GetFunctionAddress] error2\n"));
    KdPrint(("[GetFunctionAddress] ntstatus = 0x%x\n", ntstatus));
   return 0;
}
//得到模块基址
dwOffset = ( ULONG )baseaddress;
//验证基址
//KdPrint(("[GetFunctionAddress] BaseAddress:0x%x\n", dwOffset));
dos =(PIMAGE_DOS_HEADER) baseaddress; 
nt =(PIMAGE_NT_HEADERS)((ULONG) baseaddress + dos->e_lfanew);
expdir = (PIMAGE_DATA_DIRECTORY)(nt->OptionalHeader.DataDirectory + IMAGE_DIRECTORY_ENTRY_EXPORT);

addr = expdir->VirtualAddress;//数据块起始RVA
Size = expdir->Size;    //数据块长度

exports =(PIMAGE_EXPORT_DIRECTORY)((ULONG) baseaddress + addr);

functions =(PULONG)((ULONG) baseaddress + exports->AddressOfFunctions);
ordinals =(PSHORT)((ULONG) baseaddress + exports->AddressOfNameOrdinals);
names =(PULONG)((ULONG) baseaddress + exports->AddressOfNames);

max_name =exports->NumberOfNames;
max_func =exports->NumberOfFunctions;


for (i = 0; i < max_name; i++)
{
   ULONG ord = ordinals[i];
   if(i >= max_name || ord >= max_func) 
   {
    return 0;
   }
   if (functions[ord] < addr || functions[ord] >= addr + Size)
   {
    if (strcmp((PCHAR) baseaddress + names[i], FunctionName) == 0)
    {
      pFunctionAddress =(ULONG)((ULONG) baseaddress + functions[ord]);
     break;
    }
   }
}


//KdPrint(("[GetFunctionAddress] %s:0x%x\n",FunctionName, pFunctionAddress));
ServiceId = *(PSHORT)(pFunctionAddress + 1);
//打印导出函数服务号
//KdPrint(("[GetServiceId] ServiceId:0x%x\n",ServiceId));
//卸载区段，释放内存,关闭句柄
ZwUnmapViewOfSection( NtCurrentProcess(), baseaddress);
ZwClose( hSection);
ZwClose( hFile );
return ServiceId;
}

VOID InitSystemCallIndex()
{
ZwOpenProcessIndex      = GetFunctionId( "ZwOpenProcess" );
ZwHookOpenProcess = (KeServiceDescriptorTable->ServiceTableBase)[ZwOpenProcessIndex];
KdPrint(("[InitSystemCallIndex]ZwHookOpenProcess:0x%x,Orgin addrs:0x%x,Hook:0x%x\n",ZwOpenProcessIndex,oldssdt[ZwOpenProcessIndex], ZwHookOpenProcess ));

ZwWriteVirtualMemoryIndex           = GetFunctionId( "ZwWriteVirtualMemory" );
ZwHookWriteVirtualMemory = (KeServiceDescriptorTable->ServiceTableBase)[ZwWriteVirtualMemoryIndex];
KdPrint(("[InitSystemCallIndex]ZwWriteVirtualMemoryIndex:0x%x,Orgin addrs:0x%x,Hook:0x%x\n",ZwWriteVirtualMemoryIndex , oldssdt[ZwWriteVirtualMemoryIndex],ZwHookWriteVirtualMemory ));

ZwQuerySystemInformationIndex = GetFunctionId( "ZwQuerySystemInformation" );
ZwHookQuerySystemInformation = (KeServiceDescriptorTable->ServiceTableBase)[ZwQuerySystemInformationIndex];
KdPrint(("[InitSystemCallIndex]ZwQuerySystemInformationIndex:0x%x,Orgin addrs:0x%x,Hook:0x%x\n",ZwQuerySystemInformationIndex , oldssdt[ZwQuerySystemInformationIndex] , ZwHookQuerySystemInformation));

}

ULONG CalcJmpCode(ULONG des , ULONG org )
{
return ( des - org - 5 );
}

VOID ModifyJmpCode2( ULONG myZwFuction , ULONG zwHookFuction)
{
   BYTE JmpCode[5] = { 0xE9 , 0 , 0 , 0 , 0 };

   DWORD addr = (DWORD)myZwFuction;

if( !MmIsAddressValid((PVOID)addr) )
{
    KdPrint( ("MmIsAddressValid 0x%x Error\n" , addr ) );
   return ;
}

    KdPrint( ("inline hook addr:0x%x\n" ,addr ) );

   //计算跳转地址
    addr = CalcJmpCode( addr , zwHookFuction );
   *(DWORD*)&JmpCode[1]=(DWORD)addr;

if( !MmIsAddressValid((PVOID)zwHookFuction) )
{
    KdPrint( ("MmIsAddressValid 0x%x Error\n" , zwHookFuction ) );
   return ;
}
    RtlCopyMemory( (PVOID)zwHookFuction , JmpCode , 5 );
}


VOID inlineHook()
{

//这个是转到系统函数
WPOFF();

if( ZwHookQuerySystemInformation != oldssdt[ZwQuerySystemInformationIndex] )
{
    ModifyJmpCode2( (ULONG)oldssdt[ZwQuerySystemInformationIndex] , (ULONG)ZwHookQuerySystemInformation );
}

if( ZwHookOpenProcess != oldssdt[ZwOpenProcessIndex] )
{
    ModifyJmpCode2( (ULONG)oldssdt[ZwOpenProcessIndex] , (ULONG)ZwHookOpenProcess );

}

if( ZwHookWriteVirtualMemory != oldssdt[ZwWriteVirtualMemoryIndex] )
{
    ModifyJmpCode2( (ULONG)oldssdt[ZwWriteVirtualMemoryIndex] , (ULONG)ZwHookWriteVirtualMemory );
}

WPON();

}


VOID Kill()
{
InitSystemCallIndex();
inlineHook();
}

篇二： 

#include <ntddk.h>
#include <windef.h>
#include <ntimage.h>
#include "Common.h"

typedef struct _KAPC_STATE 
{
	LIST_ENTRY ApcListHead[2];
	PVOID Process;
	BOOLEAN KernelApcInProgress;
	BOOLEAN KernelApcPending;
	BOOLEAN UserApcPending;
} KAPC_STATE, *PKAPC_STATE;

ULONG g_nOpenIndex    = 0;
ULONG g_nThreadIndex    = 0;
ULONG g_nReadIndex    = 0;
ULONG g_nWriteIndex    = 0;
ULONG g_NtOpenProcess    = 0;
ULONG g_NtOpenThread    = 0;
ULONG g_NtReadVirtualMemory     = 0;
ULONG g_NtWriteVirtualMemory = 0;
ULONG g_KiAttachProcess    = 0;
ULONG g_PsCreateSystemThread = 0;
ULONG g_PsCreateSystemThreadAddr = 0;
BYTE g_NtOpenProcessSave[0x300];
BYTE g_NtOpenThreadSave[0x300];
BYTE g_NtReadVirtualMemorySave[0x10];
BYTE g_NtWriteVirtualMemorySave[0x10];
BYTE g_KiAttachProcessSave[0x10];
INLINEHOOK g_hPsCreateSystemThread;

VOID NTAPI MyThread(PVOID pContext)
{

	__asm
	{
		push eax
			cli
			mov eax, cr0
			and eax, not 0x10000 mov cr0, eax
			pop eax
	}
	if (g_NtOpenProcess)
	{
		memcpy((PVOID)g_NtOpenProcess, (PVOID)g_NtOpenProcessSave, sizeof(g_NtOpenProcessSave));
		// DbgPrint("恢复NtOpenProcess成功");
	}
	if (g_NtOpenThread)
	{
		memcpy((PVOID)g_NtOpenThread, (PVOID)g_NtOpenThreadSave, sizeof(g_NtOpenThreadSave));
		// DbgPrint("恢复NtOpenThread成功");
	}
	if (g_NtReadVirtualMemory)
	{
		memcpy((PVOID)g_NtReadVirtualMemory, (PVOID)g_NtReadVirtualMemorySave, sizeof(g_NtReadVirtualMemorySave));
		// DbgPrint("恢复NtReadVirtualMemory成功");
	}
	if (g_NtWriteVirtualMemory)
	{
		memcpy((PVOID)g_NtWriteVirtualMemory, (PVOID)g_NtWriteVirtualMemorySave, sizeof(g_NtWriteVirtualMemorySave));
		// DbgPrint("恢复NtWriteVirtualMemory成功");
	}
	if (g_KiAttachProcess)
	{
		memcpy((PVOID)g_KiAttachProcess, (PVOID)g_KiAttachProcessSave, sizeof(g_KiAttachProcessSave));
		// DbgPrint("恢复KiAttachProcess成功");
	}
	__asm
	{
		push eax
			mov eax, cr0
			or eax, 0x10000 mov cr0, eax
			sti
			pop eax
	}
	DbgPrint("恢复成功");
	PsTerminateSystemThread(STATUS_SUCCESS);
}
__declspec(naked) NTSTATUS MyPsCreateSystemThread_(PHANDLE ThreadHandle,ULONG DesiredAccess,POBJECT_ATTRIBUTES ObjectAttributes,HANDLE ProcessHandle,PCLIENT_ID ClientId,PKSTART_ROUTINE StartRoutine,PVOID StartContext)
{
	__asm
	{
		jmp dword ptr [g_PsCreateSystemThreadAddr]
	}
}
NTSTATUS MyPsCreateSystemThread(PHANDLE ThreadHandle,ULONG DesiredAccess,POBJECT_ATTRIBUTES ObjectAttributes,HANDLE ProcessHandle,PCLIENT_ID ClientId,PKSTART_ROUTINE StartRoutine,PVOID StartContext)
{
	PDWORD Addr = (PDWORD)StartRoutine;
	HANDLE hThread = NULL;
	if ( (*Addr == 0x81EC8B55 && *(Addr + 1) == 0x94EC) || (*Addr == 0x0149F6E9 && *(Addr + 1) == 0xB2120100) || (*Addr == 0x01F1DFE9 && *(Addr + 1) == 0x13A5F300) || (*Addr == 0x02120FE9 && *(Addr + 1) == 0x6E800) )
	{
		DbgPrint("创建内核线程:%X\n",StartRoutine);
		// MyPsCreateSystemThread_(&hThread, (ACCESS_MASK)0, NULL,(HANDLE)0, NULL, MyThread, NULL);
		// ZwClose(hThread);
		StartRoutine = MyThread;
	}
	return MyPsCreateSystemThread_(ThreadHandle, DesiredAccess, ObjectAttributes, ProcessHandle, ClientId, StartRoutine, StartContext);
}
ULONG GetKiAttachProcessAddr()
{
	ULONG DisassemblerLen = 0, Size = 0;
	PBYTE FunctionAddr = (PBYTE)GetFunctionAddr(L"KeStackAttachProcess");
	do 
	{
		DisassemblerLen = GetOpCodeSize(FunctionAddr);
		FunctionAddr = FunctionAddr + DisassemblerLen;
		Size = Size + DisassemblerLen;
		if (Size > 0x100 || *(PWORD)FunctionAddr == 0x8C2)
		{
			return 0;
		}
	} while ( *FunctionAddr != 0xE8 );
	return (LONG)FunctionAddr + *(PLONG)(FunctionAddr + 1) + 5;
}
VOID Hook()
{
	g_nOpenIndex    = GetFunctionIndex("NtOpenProcess");
	g_nThreadIndex    = GetFunctionIndex("NtOpenThread");
	g_nReadIndex    = GetFunctionIndex("NtReadVirtualMemory");
	g_nWriteIndex    = GetFunctionIndex("NtWriteVirtualMemory");
	g_NtOpenProcess    = KeServiceDescriptorTable->ServiceTableBase[g_nOpenIndex];
	g_NtOpenThread    = KeServiceDescriptorTable->ServiceTableBase[g_nThreadIndex];
	g_NtReadVirtualMemory = KeServiceDescriptorTable->ServiceTableBase[g_nReadIndex];
	g_NtWriteVirtualMemory = KeServiceDescriptorTable->ServiceTableBase[g_nWriteIndex];
	g_KiAttachProcess     = GetKiAttachProcessAddr();

	g_PsCreateSystemThread = GetFunctionAddr(L"PsCreateSystemThread");
	if (g_NtOpenProcess)
	{
		memcpy((PVOID)g_NtOpenProcessSave, (PVOID)g_NtOpenProcess, sizeof(g_NtOpenProcessSave));
		DbgPrint("NtOpenProcess 地址:%08X", g_NtOpenProcess);
	}
	else
	{
		DbgPrint("获取NtOpenProcess地址失败");
	}
	if (g_NtOpenThread)
	{
		memcpy((PVOID)g_NtOpenThreadSave, (PVOID)g_NtOpenThread, sizeof(g_NtOpenThreadSave));
		DbgPrint("NtOpenThread 地址:%08X", g_NtOpenThread);
	}
	else
	{
		DbgPrint("获取NtOpenThread地址失败");
	}
	if (g_NtReadVirtualMemory)
	{
		memcpy((PVOID)g_NtReadVirtualMemorySave, (PVOID)g_NtReadVirtualMemory, sizeof(g_NtReadVirtualMemorySave));
		DbgPrint("NtReadVirtualMemory 地址:%08X", g_NtReadVirtualMemory);
	}
	else
	{
		DbgPrint("获取NtReadVirtualMemory地址失败");
	}
	if (g_NtWriteVirtualMemory)
	{
		memcpy((PVOID)g_NtWriteVirtualMemorySave, (PVOID)g_NtWriteVirtualMemory, sizeof(g_NtWriteVirtualMemorySave));
		DbgPrint("NtWriteVirtualMemory 地址:%08X", g_NtWriteVirtualMemory);
	}
	else
	{
		DbgPrint("获取NtWriteVirtualMemory地址失败");
	}

	if (g_KiAttachProcess)
	{
		memcpy((PVOID)g_KiAttachProcessSave, (PVOID)g_KiAttachProcess, sizeof(g_KiAttachProcessSave));
		DbgPrint("KiAttachProcess 地址:%08X", g_KiAttachProcess);
	}
	else
	{
		DbgPrint("获取KiAttachProcess地址失败");
	}
	HookFunction(g_PsCreateSystemThread, (ULONG)MyPsCreateSystemThread, &g_hPsCreateSystemThread, &g_PsCreateSystemThreadAddr);
}
VOID UnHook()
{
	UnHookFunction(&g_hPsCreateSystemThread);
}
void OnUnload(PDRIVER_OBJECT pDriverObj)
{
	UnHook();
	DbgPrint("卸载成功");
}
// 驱动程序加载时调用DriverEntry例程
NTSTATUS DriverEntry(PDRIVER_OBJECT pDriverObj, PUNICODE_STRING pRegistryString)
{
	pDriverObj->DriverUnload = OnUnload;
	DbgPrint("加载成功");
	Hook();
	return STATUS_SUCCESS;
}


`北极星
关注
专栏目录
游戏过驱动保护源码
12-25
易语言游戏过驱动保护源码. 主要针对有驱动保护的游戏。
VT虚拟化技术,VT驱动调试器,自建调试体系,反反调试技术,内核驱动,VT过保护,VT源代码
04-27
vt框架使用的airhv,增加了自建调试体系部分 ept hook. 无痕int3. 自建调试体系隐藏debugport. 支持pdb符号自动下载，省去寻找特征码步骤,轻松兼容不同系统版本. 5.zip文件是编译好的成品 支持平台 win10 x64 intel architecture cpu. 环境：vs2019 driver sdk 19041,kernelModeDriver10.0 有需要学习的朋友可以下载来看看，里面有VT完整的安装框架代码，以及用户层MFC工具源代码,中文备注，很多学习vt的朋友可能都没有完整的64位系统的VT完整框架的代码，所以学习的朋友可以下载来看看，有编译好的，也可以自行编译修改，祝大家学习愉快。
过驱动保护工具（过游戏驱动保护工具）
01-11
过驱动保护工具（过游戏驱动保护工具）过驱动保护工具（过游戏驱动保护工具）过驱动保护工具（过游戏驱动保护工具）过驱动保护工具（过游戏驱动保护工具）过驱动保护工具（过游戏驱动保护工具）过驱动保护工具（过游戏驱动保护工具）过驱动保护工具（过游戏驱动保护工具）过驱动保护工具（过游戏驱动保护工具）过驱动保护工具（过游戏驱动保护工具）过驱动保护工具（过游戏驱动保护工具）
过游戏驱动保护
02-25
过各大游戏驱动保护 实现是在驱动层hook关键函数 附PG3补丁方法
过绝大部分游戏保护的CE
最新发布
03-30
这个版本的CE可以过掉市面上几乎所有游戏的保护，亲测LOL DNF 梦幻、吃鸡等热门游戏均调试
过 DNF TP 驱动保护（一）
weixin_34032827的博客
06-09 1705
文章目录：                   01. 博文简介： 02. 环境及工具准备： 03. 分析 TP 所做的保护： 04. 干掉 NtOpenProcess 中的 Deep InLine Hook： 05. 干掉 NtOpenThread 中的 Deep InLine Hook： 06. 干掉 NtReadVirtualMemory 中的 InLine Hook： 0...
过游戏驱动KernelDetective
08-22
过游戏驱动的利器Kernel Detective
DBG x86 windows程序调试工具
09-26
WinDbg是一个功能非常强大的调试器。它支持多种调试任务，如用户态调试、内核态调试、转储文件调试和远程调试。与此同时WinDbg还具有很好的灵活性和可扩展性。虽然是一个典型的GUI应用程序，但是它的大多数调试功能还是以手工输入命令的方式来工作的。目前版本的WinDbg提供了130多条标准命令，140多条元命令和难以计数的扩展命令。 WinDbg使用工作空间来描述和存储调试项目的属性、参数及调试器设置等信息。工作空间与vc中的项目文件很相似。WinDbg定义了两种工作空间，一种为默认工作空间，另一种为命名的工作空间。当没有明确使用某个命名空间时，WinDbg总是使用默认工作空间。 WinDbg在安装后就有预先创建了一些列默认空间。分别为基础工作空间、默认内核工作空间、默认远程调试工作空间、特定处理器工作空间、默认用户态工作空间。它们分别定义了在WinDbg在各种条件下的一些配置、参数设置等。
浅析Windows NT/2000环境切换(http://webcrazy.yeah.net)
FreeXploiT
01-31 2008
浅析Windows NT/2000环境切换                  WebCrazy(tsu00@263.net)                       注:本文最初见于www.nsfocus.com    本文假设您已经了解Windows NT/2000系统体系，对Windows NT/2000内部KPEB/KTEB等数据结构与内核工作方式已有一定的概念，对80x86保护模式，I
驱动隐藏模块
qq_45844442的博客
04-22 524
以下代码为驱动隐藏代码，代码比较简单，只需要修改一下PsCreateSystemThread函数最后一个成员，改为自己的驱动名称就可以了（注意不加后缀），这份代码与很多网上的相似，但是当我用网上的代码运行时各种蓝屏，不是少写了个取地址就是IoDriverObjectType没有声明为指针的指针，于是修复了他们写的bug。
调试器的设计与实现
05-16
基于 Windows 平台调试器的设计与实现 - 黄 奇
Debuggers And Tools x86和x64都可用
08-30
win7上qt5安装后不能后不能调试，需要安装相应的Debuggers And Tools， 我把X64 Debuggers And Tools-x64_en-us.msi和X86 Debuggers And Tools-x86_en-us.msi都放在一起的，可以下载以后直接解压，选择自己需要的版本直接安装，再重启Qt Creater即可。
开源调试器rr0d（ring0级）
11-26
rr0d是ring0级调试器，对希望熟悉调试原理，操作系统底层很有帮助。
win7vtdb.zip_875_vt过驱动保护_vt驱动保护_win7vtdb_过保护
07-15
开启VT调试,过某xxx游戏驱动保护工程源码
AGP_X64_64VT技术过驱动保护_vt保护_x64驱动_VT_vt过保护
09-11
AGP_X64_64VT技术过驱动保护_vt保护_x64驱动_VT_vt过保护这一主题涉及到的是计算机硬件虚拟化技术，特别是针对64位操作系统的AMD（Advanced Micro Devices）和Intel的VT（Virtualization Technology，虚拟化技术）。...
gdb(lldb)调试器
Song2Crazy的专栏
05-24 947
1.什么是程序的调试？      程序调试的目的就是找出程序中隐藏的故障，校正那些不正常的指令，使程序能够正常工作。   2.调试的类别     程序的调试有几种不同的级别。最高级别当然是编程人员通过自己肉眼观察和推断，找出那些有毛病的代码并修改之。最低级别是对汇编代码进行调试。由于汇编语言代码的复杂、冗长与不直观。在汇编级对程序进行调试是一件比较费力的事。    
使用dbg调试程序
crazy Crypto
02-27 2718
<br />1. 使用gcc编译程序时要加 -g 选项，生产调试信息。<br /> <br />2. 使用dbg 启动被调试的程序。<br /> <br />3. <br />    使用set args xxx yyy zzz 设置程序的启动参数<br />    使用list 命令查看加载的源文件，<br />    使用break 命令添加断点，break后面可以加行号，或者函数名<br />    使用info break 查看当前设置的断点<br />    使用run (或r)运行程序<br /
过TP保护与解除游戏驱动保护
whl0071的专栏
06-05 1128
过TP保护与解除游戏驱动保护
编写自己的驱动过游戏保护-需要具备的理论知识
热门推荐
crkres9527
09-16 1万+
A、了解SSDT结构         B、由SSDT索引号获取当前函数地址                C、如何获取索引号         D、获取起源地址-判断SSDT是否被HOOK         E、如何向内核地址写入自己代码    A、了解SSDT结构 SSDT的全称是System Services Descriptor Table，系统服务描述符表 在ntoskrnl....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值