内核里操作进程

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 在内核里操作进程

在内核里操作进程，相信是很多对 WINDOWS 内核编程感兴趣的朋友第一个学习的知识点。但在这里，我要让大家失望了，在内核里操作进程没什么特别的，就标准方法而言，还是调用那几个和进程相关的 NATIVE API 而已（当然了，本文所说的进程操作，还包括对线程和 DLL 模块的操作）。本文包括 10 个部分：分别是：枚举进程、暂停进程、恢复进程、结束进程、枚举线程、暂停线程、恢复线程、结束线程、枚举 DLL 模块、卸载 DLL 模块。

1.枚举进程。进程就是活动起来的程序。每一个进程在内核里，都有一个名为 EPROCESS 的巨大结构体记录它的详细信息，包括它的名字，编号（PID），出生地点（进程路径），老爹是谁（PPID 或父进程 ID）等。在 RING3 枚举进程，通常只要列出所有进程的编号即可。不过在 RING0 里，我们还要把它的身份证（EPROCESS）地址给列举出来。顺带说一句， 现实中男人最怕的事情 就是“ 喜当爹” ， 这种事情在内核里更加容易发生。因为 EPROCESS  里 有 且只有 一个 成员 是记录父进程 ID  的，稍微改一下，就可以认任意进程为爹了。枚举进程的方法很多，标准方法是使用 ZwQuerySystemInformation 的 SystemProcessInformation 功能号，不过如果在内核里也这么用的话，那就真是脱了裤子放屁——多此一举。因为在内核里使用这个函数照样是得不到进程的 EPROCESS 地址，而且一旦内存出错，还会蓝屏，更加逃不过任何隐藏进程的手法。 所以在 内核里 稳定 又不失 强度 的 枚举 进程方法举 是枚举 PspCidTable ， 它能最大的好处是能得到进程的 EPROCESS  地址 ， 而且 能 检查出 使用“ 断链 ” 这种低级 手法 的隐藏进程。不过话也说回来，枚举 PspCidTable 并不是一件很爽的事情，因为 PspCidTable  是一个 不公开的变量，要 获得它地址 的话，必然 要 使用硬编码或者符号。所以 我的 方法是：变相枚举 PspCidTable。内核里有个函数叫做 PsLookupProcessByProcessId，它能通过进程 PID 查到进程的 EPROCESS，它的内部实现正是枚举了 PspCidTable。PID 的范围是从 4 开始，到MAX_INT（2^31-1）结束，步进为 4。但实际上，大家见到的 PID 基本都是小于 10000 的，而上 10000 的 PID 相信很多人都没有见过。所以我们实际的枚举范围是 4～2^18，如果PsLookupProcessByProcessId 返回失败，则证明此进程不存在，如果返回成功，则把 EPROCESS、PID、PPID、进程名打印出来。

1.枚举进程
//声明 API
NTKERNELAPI UCHAR* PsGetProcessImageFileName(IN PEPROCESS Process);
NTKERNELAPI HANDLE PsGetProcessInheritedFromUniqueProcessId(IN PEPROCESS Process);
//根据进程 ID 返回进程 EPROCESS，失败返回 NULL
PEPROCESS LookupProcess(HANDLE Pid)
{
PEPROCESS eprocess = NULL;
if (NT_SUCCESS(PsLookupProcessByProcessId(Pid, &eprocess)))
return eprocess;
else
return NULL;
}
//枚举进程
VOID EnumProcess()
{
ULONG i = 0;
PEPROCESS eproc = NULL;
for (i = 4; i<262144; i = i + 4)
{
eproc = LookupProcess((HANDLE)i);
if (eproc != NULL)
{
DbgPrint("EPROCESS = %p, PID = %ld, PPID = %ld, Name = %s\n",
eproc,
(DWORD)PsGetProcessId(eproc),
(DWORD)PsGetProcessInheritedFromUniqueProcessId(eproc),
PsGetProcessImageFileName(eproc));
ObDereferenceObject(eproc);
}
}
}

2.暂停进程。暂停进程就是暂停进程的活动，但是不将其杀死。暂停进程在 VISTA 之后有导
出的函数：PsSuspendProcess。它的函数原型很简单：
NTKERNELAPI //声明要使用此函数
NTSTATUS //返回类型
PsSuspendProcess(PEPROCESS Process); //唯一的参数是 EPROCESS

3.恢复进程。恢复进程就是让被暂停进程的恢复活动，是上一个操作的反操作。恢复进程在
VISTA 之后有导出的函数：PsResumeProcess。它的函数原型很简单：
NTKERNELAPI //声明要使用此函数
NTSTATUS //返回类型
PsResumeProcess(PEPROCESS Process); //唯一的参数是 EPROCESS

4.结束进程。结束进程的标准方法就是使用 ZwOpenProcess 打开进程获得句柄，然后使用
ZwTerminateProcess 结束，最后使用 ZwClose 关闭句柄。除了这种方法之外，还能用使用内
存清零的方式结束进程，后者使用有一定的危险性，可能在特殊情况下发生蓝屏，但强度比
前者大得多。在 WIN64 不可以搞内核 HOOK 的大前提下，后者可以结束任何被保护的进程。

//正规方法结束进程
void ZwKillProcess()
{
HANDLE hProcess = NULL;
CLIENT_ID ClientId;
OBJECT_ATTRIBUTES oa;
//填充 CID
ClientId.UniqueProcess = (HANDLE)2908; //这里修改为你要的 PID
ClientId.UniqueThread = 0;
//填充 OA
oa.Length = sizeof(oa);
oa.RootDirectory = 0;
oa.ObjectName = 0;
oa.Attributes = 0;
oa.SecurityDescriptor = 0;
oa.SecurityQualityOfService = 0;
//打开进程，如果句柄有效，则结束进程
ZwOpenProcess(&hProcess, 1, &oa, &ClientId);
if (hProcess)
{
ZwTerminateProcess(hProcess, 0);
ZwClose(hProcess);
};
}

内存清0方式结束进程
NTKERNELAPI VOID NTAPI KeAttachProcess(PEPROCESS Process);
NTKERNELAPI VOID NTAPI KeDetachProcess();
//内存清零法结束进程
void PVASE()
{
SIZE_T i = 0;
//依附进程
KeAttachProcess((PEPROCESS)0xFFFFFA8003ABDB30); //这里改为指定进程的 EPROCESS
for (i = 0x10000; i<0x20000000; i += PAGE_SIZE)
{
__try
{
memset((PVOID)i, 0, PAGE_SIZE); //把进程内存全部置零
}
_except(1)
{
;
}
}
//退出依附进程
KeDetachProcess();
}
5.枚举线程。线程跟进程类似，也有一个身份证一样的结构体 ETHREAD 存放在内核里，而它
所有的 ETHREAD 也是放在 PspCidTable 里的。于是有了类似枚举进程的代码：
//根据线程 ID 返回线程 ETHREAD，失败返回 NULL
PETHREAD LookupThread(HANDLE Tid)
{
PETHREAD ethread;
if (NT_SUCCESS(PsLookupThreadByThreadId(Tid, ðread)))
return ethread;
else
return NULL;
}

//枚举指定进程的线程
VOID EnumThread(PEPROCESS Process)
{
ULONG i = 0, c = 0;
PETHREAD ethrd = NULL;
PEPROCESS eproc = NULL;
for (i = 4; i<262144; i = i + 4)
{
ethrd = LookupThread((HANDLE)i);
if (ethrd != NULL)
{
//获得线程所属进程
eproc = IoThreadToProcess(ethrd);
if (eproc == Process)
{
//打印出 ETHREAD 和 TID
DbgPrint("ETHREAD=%p, TID=%ld\n",
ethrd,
(ULONG)PsGetThreadId(ethrd));
}
ObDereferenceObject(ethrd);
}
}
}
6.挂起线程。类似于“挂起进程”，唯一的差别是没有导出函数可用了。可以自行定位
PsSuspendThread，它的原型如下：

NTSTATUS PsSuspendThread
(IN PETHREAD Thread, //线程 ETHREAD
OUT PULONG PreviousSuspendCount OPTIONAL) //挂起的次数，每挂起一次此值增 1

7.恢复线程。类似于“恢复进程”， 唯一的差别是没有导出函数可用了。可以自行定位
PsResumeThread，它的原型如下：

NTSTATUS PsResumeThread
(PETHREAD Thread, //线程 ETHREAD
OUT PULONG PreviousCount); //恢复的次数，每恢复一次此值减 1，为 0 时线程才正常

8.结束线程。结束线程的标准方法是 ZwOpenThread+ZwTerminateThread+ZwClose，暴力方法
是直接调用 PspTerminateThreadByPointer。暴力方法在后面的课程里讲，这里先讲标准方法。
由于 ZwTerminateThread 没有导出，所以只能先硬编码了（在 WINDBG 里使用 x 命令获得地
址：x nt!ZwTerminateThread）：

typedef NTSTATUS(__fastcall *ZWTERMINATETHREAD)(HANDLE hThread, ULONG uExitCode);
ZWTERMINATETHREAD ZwTerminateThread = 0Xfffff80012345678; //要修改这个值
//正规方法结束线程
void ZwKillThread()
{
HANDLE hThread = NULL;
CLIENT_ID ClientId;
OBJECT_ATTRIBUTES oa;
//填充 CID
ClientId.UniqueProcess = 0;
ClientId.UniqueThread = (HANDLE)1234; //这里修改为你要的 TID
  //填充 OA
oa.Length = sizeof(oa);
oa.RootDirectory = 0;
oa.ObjectName = 0;
oa.Attributes = 0;
oa.SecurityDescriptor = 0;
oa.SecurityQualityOfService = 0;
//打开进程，如果句柄有效，则结束进程
ZwOpenProcess(&hThread, 1, &oa, &ClientId);
if (hThread)
{
ZwTerminateThread(hThread, 0);
ZwClose(hThread);
};}
9.枚举 DLL 模块。DLL 模块记录在 PEB 的 LDR 链表里，LDR 是一个双向链表，枚举它即可。
另外，DLL 模块列表包含 EXE 的相关信息。换句话说， 枚举 DLL  模块 即可 实现 枚举 进程 路径。

// 声明偏移
ULONG64 LdrInPebOffset = 0x018; //peb.ldr
ULONG64 ModListInPebOffset = 0x010; //peb.ldr.InLoadOrderModuleList
//声明 API
NTKERNELAPI PPEB PsGetProcessPeb(PEPROCESS Process);
//声明结构体
typedef struct _LDR_DATA_TABLE_ENTRY
{
LIST_ENTRY64 InLoadOrderLinks;
LIST_ENTRY64 InMemoryOrderLinks;
LIST_ENTRY64 InInitializationOrderLinks;
PVOID  DllBase;
PVOID  EntryPoint;
ULONG SizeOfImage;
UNICODE_STRING FullDllName;
UNICODE_STRING BaseDllName;
ULONG Flags;
USHORT LoadCount;
USHORT TlsIndex;
PVOID  SectionPointer;
ULONG CheckSum;
PVOID  LoadedImports;
PVOID  EntryPointActivationContext;
PVOID  PatchInformation;
LIST_ENTRY64 ForwarderLinks;
LIST_ENTRY64 ServiceTagLinks;
LIST_ENTRY64 StaticLinks;
PVOID  ContextInformation;
ULONG64 OriginalBase;
LARGE_INTEGER  LoadTime;
} LDR_DATA_TABLE_ENTRY, *PLDR_DATA_TABLE_ENTRY;
//根据进程枚举模块
VOID EnumModule(PEPROCESS Process)
{
ULONG64 Peb = 0;
ULONG64 Ldr = 0;
PLIST_ENTRY ModListHead = 0;
PLIST_ENTRY Module = 0;
ANSI_STRING AnsiString;
KAPC_STATE ks;
//EPROCESS 地址无效则退出
if (!MmIsAddressValid(Process))
return;
//获取 PEB 地址
Peb = PsGetProcessPeb(Process);
//PEB 地址无效则退出
if (!Peb)
return;
//依附进程
KeStackAttachProcess(Process, &ks);
__try
{
//获得 LDR 地址
Ldr = Peb + (ULONG64)LdrInPebOffset;
//测试是否可读，不可读则抛出异常退出
ProbeForRead((CONST PVOID)Ldr, 8, 8);
//获得链表头
ModListHead = (PLIST_ENTRY)(*(PULONG64)Ldr + ModListInPebOffset);
//再次测试可读性
ProbeForRead((CONST PVOID)ModListHead, 8, 8);
//获得第一个模块的信息
Module = ModListHead->Flink;
while (ModListHead != Module)
{
//打印信息：基址、大小、DLL 路径
DbgPrint("Base=%p, Size=%ld, Path=%wZ",
(PVOID)(((PLDR_DATA_TABLE_ENTRY)Module)->DllBase),
(ULONG)(((PLDR_DATA_TABLE_ENTRY)Module)->SizeOfImage),
&(((PLDR_DATA_TABLE_ENTRY)Module)->FullDllName));
Module = Module->Flink;
//测试下一个模块信息的可读性
ProbeForRead((CONST PVOID)Module, 80, 8);
}
}
__except (EXCEPTION_EXECUTE_HANDLER)
{
DbgPrint("[EnumModule]__except (EXCEPTION_EXECUTE_HANDLER)");
}
//取消依附进程
KeUnstackDetachProcess(&ks);
}

10.卸载 DLL 模块。使用 MmUnmapViewOfSection 即可。MmUnmapViewOfSection 的原型如
下。填写正确的 EPROCESS 和 DLL 模块基址就能把 DLL 卸载掉。如果卸载 NTDLL 等重要 DLL
将会导致进程崩溃
NTSTATUS MmUnmapViewOfSection
(IN PEPROCESS Process, //进程的 EPROCESS
IN PVOID BaseAddress) //DLL 模块基址

时间： 2024-10-10 02:29:07

内核里操作进程的相关文章

X64驱动：内核里操作进程

注意:下面的所有案例必须使用.C结尾的文件,且必须在链接选项中加入 /INTEGRITYCHECK 选项,否则编译根本无法通过(整理修正,整合,Win10可编译并运行),内核代码相对固定,如果对内核编程不太熟的话,请不要随意修改代码,否则很容易蓝屏,大佬绕过 内核枚举进线程/模块 内核枚举进程: 进程就是活动起来的程序,每一个进程在内核里,都有一个名为 EPROCESS 的结构记录它的详细信息,其中就包括进程名,PID,PPID,进程路径等,通常在应用层枚举进程只列出所有进程的编号即可,不过在内

windows内核代码之进程操作

［toc] 一丶简介 整理一下windows内核中.常用的代码.这里只整理下进程的相关代码. 二丶 windows内核之遍历进程 内核中记录进程的结构体是EPROCESS结构.所以只需要遍历这个结构即可.标准方法可以使用ZwQuerySystemInformation函数.使用SystemProcessInformation功能号. 另外也有很多种枚举进程的方法比如找到EPROCESS结构进行枚举的.(CPU结构体 KPCR)等等.不过兼容性都是不太好.另一种方法是枚举句柄表 PspCidTab

Linux内核剖析 之 进程简介

1.概念 1.1  什么是进程? 进程是程序执行的一个实例,可以看作充分描述程序已经执行到何种程度的数据结构的汇集. 从内核观点看,进程的目的就是担当分配系统资源(CPU时间,内存等)的实体. 我们熟悉的fork()库函数,它有两种用法: (1).一个父进程希望复制自己,使父子进程执行不同的代码段,常用于网络服务程序. (2).一个进程要执行一个不同的程序,fork()后立即exec(),如shell. 1.2  什么是线程? 有时候,一个进程希望有多个执行流,如一款麻将游戏,三个由电脑控制的人

Linux内核剖析 之 进程简单介绍

1.概念 1.1  什么是进程? 进程是程序运行的一个实例.能够看作充分描写叙述程序已经运行到何种程度的数据结构的汇集. 从内核观点看.进程的目的就是担当分配系统资源(CPU时间,内存等)的实体. 我们熟悉的fork()库函数,它有两种使用方法: (1).一个父进程希望复制自己,使父子进程运行不同的代码段.经常使用于网络服务程序. (2).一个进程要运行一个不同的程序,fork()后马上exec(),如shell. 1.2  什么是线程? 有时候,一个进程希望有多个运行流,如一款麻将游戏,三个由

linux内核分析之进程地址空间【转】

转自:http://blog.csdn.net/bullbat/article/details/7106094 版权声明:本文为博主原创文章,未经博主允许不得转载. 本文主要介绍linux内核中进程地址空间的数据结构描述,包括mm_struct/vm_area_struct.进程线性地址区间的分配流程,并对相应的源代码做了注释. 内核中的函数以相当直接了当的方式获得动态内存.当给用户态进程分配内存时,情况完全不同了.进程对动态内存的请求被认为是不紧迫的,一般来说,内核总是尽量推迟给用户态进程分配

Windows内核原理研究——进程创建

进程可能是用户接触的Windows系统中最多的部分了,对于Windows系统而言,进程是一个独立的地址空间可以为线程提供一个独立的执行环境, 也就是说 进程= 独立的地址空间 一个进程内核对象 线程= 一个线程自己的栈 一个线程内核对象 当然这个栈是在进程的地址空间中.那么,也就是说线程才是真正“干活”的东西,进程只不过是一些资源的集合而已.只能说是“原材料”. 在我学习Windows内核以前一直觉得进程的种种特性很神奇,比如说地址空间独立是怎么实现的呢?我们的电脑使用的都是同一块内存怎么能实现

【转载】linux内核笔记之进程地址空间

原文:linux内核笔记之进程地址空间 进程的地址空间由允许进程使用的全部线性地址组成,在32位系统中为0~3GB,每个进程看到的线性地址集合是不同的. 内核通过线性区的资源(数据结构)来表示线性地址区间,线性区是由起始线性地址,长度和一些访问权限来描述的.线性区的大小为页框的整数倍,起始地址为4096的整数倍. 下图展示了x86 Linux 进程的地址空间组织结构: 正文段 .text ,这是CPU执行的机器指令部分.通常正文段是共享的,而且是只读的,以防止程序修改其自身的指令. 数据段 .d

用户空间与内核空间，进程上下文与中断上下文[总结]

用户空间与内核空间,进程上下文与中断上下文[总结] 最近有研究到zabbix监控,就得清楚cpu各个指标的含义, 1,简单回顾下cpu及计算机组成: 计算机五大部件: 运算器 控制器 存储器 输入/输出设备. 2,cpu 进程的内核态和用户态 我们知道现在操作系统都是采用虚拟存储器,那么对32位操作系统而言,它的寻址空间(虚拟存储空间)为4G(2的32次方).操心系统的核心是内核,独立于普通的应用程序,可以访问受保护的内存空间,也有访问底层硬件设备的所有权限.为 了保证用户进程不能直接操作内核,

RHCA学习笔记:RH442-Unit9内核定时与进程延时

Unit 9 Kernel Timing and Process Latency 内核定时与进程延时 学习目标: A.了解CPU 是怎样追踪时间的 B.调整CPU的访问次数 C.调整调度延时 D.虚拟机上的CPU任务调整 9.1How Linux tracks time Linux下的时间追踪 A. 硬件定时器是靠使用时钟来完成计时的. 包括以下时间资源: a. Real time clock(RTC):实时时钟是用来持久存放系统时间的设备,即便系统关闭后,它也可以靠主板上的微电池提供的电力保持