Linux内核编程——进程内存窥探修改器（全网最详）

最新推荐文章于 2024-04-08 23:40:30 发布
最新推荐文章于 2024-04-08 23:40:30 发布
阅读量2.2k 收藏 24
点赞数 8
文章标签： linux c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/life_forwin/article/details/123330794
版权

Linux内核编程——进程内存窥探修改器

文章目录

关键词

内核模块法；带参数的系统调用；虚拟内存管理；虚拟地址映射为物理地址；私有内存的入侵读写；

主要功能

  • 使用内核模块法向Linux内核增加两个系统调用，系统调用号分别为335和336 。
  • 335号系统调用：使用此系统调用能够读取任意进程的任意虚拟地址范围内的内容。
  • 336号系统调用：使用此系统调用能够修改任意进程的任意虚拟地址范围内的内容。
  • 两者都能获取进程的私有内存空间结构。

设计思路

  1. Linux虚拟内存管理实现了进程之间的地址访问隔离，因此要想让一个进程访问另一个进程的私有内存（非共享）地址中的内容，就需要从用户态转变为内核态，让内核去完成此项任务，这一过程本质上就是使用系统调用，因此需要理解系统调用的基本原理[1]，然后向内核增加系统调用。

  2. 增加系统调用的常见的两种方法：

    • 修改内核源码[4]，配置内核，然后编译，最后安装新内核，此方法耗时费力。
    • 内核模块法[5,6,7]，编写内核模块动态加载到内核中，即插即用，实现热插拔。

  3. 由于我们的目标是任意进程，因此对进程管理[2]，如进程控制块进程描述符要有一定的了解。

  4. 另外对于我们想要完成的功能，Linux虚拟内存管理[3]带来的另一个问题是进程所使用的都是虚拟地址（Linux中由于没有段的概念，虚拟地址等同于线性地址），CPU对内存的访问需要经过MUM（Memory Management Unit）和Linux内核共同来完成虚拟地址到物理地址的转换，MMU是一种硬件实现，操作系统用于管理填充页表，MMU则利用页表进行地址转换。因此要完成此项人物还需要理解Linux内核关于虚拟内存管理的源码，并对自己的计算机的体系架构和页表机制了如指掌。

  5. 综上所述，总的设计思路为：

    1. 理解系统调用、进程管理、虚拟内存管理三大知识点
    2. 学会怎么用内核模块法增加带参数传递的系统调用**（搭好框架）**
    3. 设计实现系统调用的逻辑内容**（填充框架）**——即读取（修改）任意进程任意虚拟地址空间的思路逻辑是什么。
      • 首先根据pid进程号获取进程描述符
      • 根据用户空间的虚拟地址寻找其所在页的物理页框的物理地址
      • 利用page_address( )函数将物理页转变为内核空间的页虚拟地址[8]
      • 再加上页偏移值便可得到用户空间虚拟地址对应的内核空间的虚拟地址[9]
      • 然后就可以在内核态下对该地址的内容进行读取或者修改

  6. 本文模拟黑客入侵，设计了四个模块：

    • **hacker模块：**该模块对应 invade_process.c源文件，该程序主要执行进程内存窥探修改的整体控制逻辑。
    • **335号系统调用模块：**该模块对应my_syscall335.c 源文件，该模块会被hacker模块所调用，在调用前需要将其sudo insmod my_syscall335.ko加载到内核中，使用结束后sudo rmmod my_syscall335将模块卸载防止污染内核。
    • **336号系统调用模块：**该模块对应my_syscall336.c 源文件，该模块会被hacker模块所调用，在调用前需要将其sudo insmod my_syscall336.ko加载到内核中，使用结束后sudo rmmod my_syscall336将模块卸载防止污染内核。
    • **defender模块：**该模块对应 target_process.c 源文件，该程序向外暴露虚拟地址 printf("%ld",vaddr)，然后将自己阻塞getchar()，这样保证该进程一直存在，以供hacker模块入侵（读取 or 修改）。

代码解读

my_syscall335.c源代码

/*
my_syscall335.c
此模块主要功能：提供一个系统调用，其他进程可利用此系统调用（读取）任意进程任意虚拟地址空间的内容。
需要注意以下几点：
	系统调用号335，使用前需确认335是否被占用，若占用则修改下面的__NR_syscall宏即可；
	Linux 内核自5.7后为了安全起见 unexport kallsyms_lookup_name() and kallsyms_on_each_symbol() 因此为了获得sys_call_table的地址需用以下方法：
		sudo cat /proc/kallsyms | grep sys_call_table 然后将其硬编码为源文件中的宏，每次开机地址发生变化，需要修改源文件，重新编译后再insmod入内核；
		或者重新编译内核，在配置内核时修改sys_call_table地址为固定值，这样就不会变化了；
	
																					Author: Pcyslist
*/
#include <linux/kernel.h>	//包含内和打印函数或其他重要宏定义
#include <linux/init.h>		//模块初始化宏定义在此
#include <linux/module.h>	//内核模块
#include <linux/unistd.h>	//系统调用
#include <linux/sched.h>	//进程管理，调度程序头文件，定义了任务结构task_struct
#include<linux/mm.h>		//内存管理
#include<linux/mm_types.h>
#include<linux/export.h>
#include <linux/kallsyms.h>	//曾包含了kallsyms_lookup_name(const char *)
#include <linux/time.h>		//时间头文件
#include <linux/uaccess.h>	//核访问用户进程内存地址的函数定义


#define __NR_syscall 335//系统调用号为335
#define SYS_CALL_TABLE_ADDRESS   0xffffffffa1000300 //sys_call_table对应的地址 0xffffffffa1000300 sudo cat /proc/kallsyms | grep sys_call_table

int orig_cr0;  //用来存储cr0寄存器原来的值
unsigned long *sys_call_table=0;	//保存系统调用表指针
 
static int(*anything_saved)(void);  //定义一个函数指针，用来保存一个系统调用
 typedef asmlinkage long (*sys_call_ptr_t)(const struct pt_regs *);		//结构体指针类型用于传参
static int clear_cr0(void) //使cr0寄存器的第17位设置为0（内核空间可写）
{
    unsigned int cr0=0;
    unsigned int ret;
    asm volatile("movq %%cr0,%%rax":"=a"(cr0));//将cr0寄存器的值移动到eax寄存器中，同时d输出到cr0变量中
    ret=cr0;
    cr0&=0xfffffffffffeffff;//将cr0变量值中的第17位清0,将修改后的值写入cr0寄存器
    asm volatile("movq %%rax,%%cr0"::"a"(cr0));//将cr0变量的值作为输入，输入到寄存器eax中，同时移动到寄存器cr0中
    return ret;
}
 
static void setback_cr0(int val) //使cr0寄存器设置为内核不可写
{
    asm volatile("movq %%rax,%%cr0"::"a"(val));
}
 
// 根据一个进程的进程描述符和虚拟地址找到虚拟地址所在页的页表项
static pte_t* get_pte(struct task_struct *task, unsigned long vaddr)
{
	pgd_t* pgd;		//PGD: Page Global Directory
    p4d_t* p4d;		//P4D: 第四级页表
	pud_t* pud;		//PUD: Page Upper Directory
	pmd_t* pmd;		//PMD: Page Middle Directory
	pte_t* pte;		//PTE: Page Table Entry
	struct mm_struct *mm = task->mm;
	//五级页表层层索引
	pgd = pgd_offset(mm, vaddr); //获得pgd的地址 
	if(pgd_none(*pgd) || pgd_bad(*pgd))
		return NULL;

    p4d = p4d_offset(pgd, vaddr); //获得p4d的地址 
	if(p4d_none(*p4d) || p4d_bad(*p4d))
		return NULL;

	pud = pud_offset(p4d, vaddr); //获得pud的地址 
	if(pud_none(*pud) || pud_bad(*pud))
		return NULL;

	pmd = pmd_offset(pud, vaddr); //获得pmd的地址 
	if(pmd_none(*pmd) || pmd_bad(*pmd))
		return NULL;

	pte = pte_offset_kernel(pmd, vaddr); //获得pte的地址 
	if(pte_none(*pte))
		return NULL;
	return pte;
}

static int sys_mycall(const struct pt_regs * regs) //定义自己的系统调用 参数为一个结构体指针regs，详情请看参考文献[6]
{   
    /*regs结构体指针内的四个成员，本质上是四个寄存器，分别存着 pid vaddr buffer bytes*/
	unsigned long obj_pid=(unsigned long )regs->di;		//待入侵的进程pid
	unsigned long obj_vaddr=(unsigned long )regs->si;	//待入侵的进程的虚拟地址，此处的虚拟地址vaddr是用户态下的
	unsigned long crrt_buffer=(unsigned long )regs->dx;	//将[obj_vaddr,obj_vaddr+obj_bytes]地址区间的内容拷贝到crrt_buffer中实现读取
	unsigned long obj_bytes=(unsigned long )regs->r10;	//读取的字节数
	
	int crrt_pid=current->pid;	//调用本服务例程的进程pid

	struct task_struct  *obj_task;	//目标进程描述符
	struct task_struct  *crrt_task;	//当前进程描述符

	pte_t* obj_pte;					//目标进程页表项
	pte_t* crrt_pte;				//当前进程页表项

	struct page* obj_page;			//页
	struct page* crrt_page;

	// int i;

	unsigned long obj_pgvaddr=0;	//虚拟地址vaddr所在页的虚拟地址		
	unsigned long crrt_pgvaddr=0;

	unsigned long obj_page_offset = 0; //虚拟地址vaddr的页偏移值
	unsigned long crrt_page_offset = 0;

	unsigned long obj_vaddr_kernel=0;  //vaddr的内核态的虚拟地址
	unsigned long crrt_vaddr_kernel=0;
	
	printk("module my_syscall335 is calling by process %d...\npid=%ld   vaddr=0x%lx  %lu	bufferaddr=0x%lx  %lu \n",
												current->pid,obj_pid,obj_vaddr,obj_vaddr,crrt_buffer,crrt_buffer);
	// 根据pid找到进程描述符
	obj_task = pid_task(find_pid_ns(obj_pid, &init_pid_ns), PIDTYPE_PID);
	// 根据进程描述符和虚拟地址找到虚拟地址vaddr所在页的页表项
	if(!(obj_pte = get_pte(obj_task, obj_vaddr)))
		return -2;		//入侵的地址所在的页暂时不在内存中 此处返回-2是因为系统调用失败会返回-1，依据返回值告诉调用进程失败的原因
	//由页表项找到所在页page
	obj_page = pte_page(*obj_pte);	
	//由页返回页的虚拟地址
	obj_pgvaddr = (unsigned long)page_address(obj_page);
	printk("page virtual address=0x%lx  %lu\n",obj_pgvaddr,obj_pgvaddr);
	obj_page_offset = obj_vaddr & ~PAGE_MASK;//获得页偏移地址 
	obj_vaddr_kernel=obj_pgvaddr+obj_page_offset;	//内核态的虚拟地址
	printk("kernel virtual address=0x%lx  %lu\n",obj_vaddr_kernel,obj_vaddr_kernel);

	crrt_task=pid_task(find_pid_ns(crrt_pid, &init_pid_ns), PIDTYPE_PID);
	if(!(crrt_pte = get_pte(crrt_task, crrt_buffer)))
		return -3;		//buffer分配失败时buffer所在页就不会在内存中，此处返回-3，一般来说传入的buffer是否是空要做检查，此处为了防止不做检查就传入的情况
	crrt_page = pte_page(*crrt_pte);	
	crrt_pgvaddr = (unsigned long)page_address(crrt_page);
	printk("buffer page virtual address=0x%lx  %lu\n",crrt_pgvaddr,crrt_pgvaddr);
	crrt_page_offset = crrt_buffer & ~PAGE_MASK;
	crrt_vaddr_kernel=crrt_pgvaddr+crrt_page_offset;
	printk("kernel virtual BUFFER address=0x%lx  %lu\n",crrt_vaddr_kernel,crrt_vaddr_kernel);
	//进行读取
	memcpy((void *)crrt_vaddr_kernel,(void *)obj_vaddr_kernel,obj_bytes);
	return 0;    //调用成功
}
/*初始化*/
static int __init init_mycall(void)
{
	printk("module my_syscall335 is initializing......\n");
    sys_call_table=(unsigned long*)(SYS_CALL_TABLE_ADDRESS); 
	printk("sys_call_table: 0x%p\n", sys_call_table);			//会发现输出值不等于SYS_CALL_TABLE_ADDRESS
    anything_saved=(int(*)(void))(sys_call_table[__NR_syscall]);//保存系统调用表中的NUM位置上的系统调用
    orig_cr0=clear_cr0();//使内核地址空间可写
    sys_call_table[__NR_syscall]=(unsigned long) &sys_mycall;//用自己的系统调用替换NUM位置上的系统调用
    setback_cr0(orig_cr0);//使内核地址空间不可写
    return 0;
}
/*卸载*/
static void __exit exit_mycall(void)
{
    printk("module my_syscall335 is exiting......\n");
    orig_cr0=clear_cr0();
    sys_call_table[__NR_syscall]=(unsigned long)anything_saved;//将系统调用恢复
    setback_cr0(orig_cr0);
}


MODULE_LICENSE("GPL");
module_init(init_mycall);
module_exit(exit_mycall);

my_syscall336.c 源代码和上面的代码很相似，不同在于memcpy(dest,src,size)这一行代码。

/*
my_syscall336.c
此模块主要功能：提供一个系统调用，其他进程可利用此系统调用（读取）任意进程任意虚拟地址空间的内容。
需要注意以下几点：
	系统调用号336，使用前需确认336是否被占用，若占用则修改下面的__NR_syscall宏即可；
	Linux 内核自5.7后为了安全起见 unexport kallsyms_lookup_name() and kallsyms_on_each_symbol() 因此为了获得sys_call_table的地址需用以下方法：
		sudo cat /proc/kallsyms | grep sys_call_table 然后将其硬编码为源文件中的宏，每次开机地址发生变化，需要修改源文件，重新编译后再insmod入内核；
		或者重新编译内核，在配置内核时修改sys_call_table地址为固定值，这样就不会变化了；
	
																					Author: Pcyslist
*/
#include <linux/kernel.h>	//包含内和打印函数或其他重要宏定义
#include <linux/init.h>		//模块初始化宏定义在此
#include <linux/module.h>	//内核模块
#include <linux/unistd.h>	//系统调用
#include <linux/sched.h>	//进程管理，调度程序头文件，定义了任务结构task_struct
#include<linux/mm.h>		//内存管理
#include<linux/mm_types.h>
#include<linux/export.h>
#include <linux/kallsyms.h>	//曾包含了kallsyms_lookup_name(const char *)
#include <linux/time.h>		//时间头文件
#include <linux/uaccess.h>	//核访问用户进程内存地址的函数定义

#define __NR_syscall 336//系统调用号为336   
#define SYS_CALL_TABLE_ADDRESS   0xffffffffa1000300 //sys_call_table对应的地址 0xffffffffa1000300 sudo cat /proc/kallsyms | grep sys_call_table

int orig_cr0;  //用来存储cr0寄存器原来的值
unsigned long *sys_call_table=0;
 
static int(*anything_saved)(void);  //定义一个函数指针，用来保存一个系统调用
 typedef asmlinkage long (*sys_call_ptr_t)(const struct pt_regs *);		//结构体指针类型用于传参
static int clear_cr0(void) //使cr0寄存器的第17位设置为0（内核空间可写）
{
    unsigned int cr0=0;
    unsigned int ret;
    asm volatile("movq %%cr0,%%rax":"=a"(cr0));//将cr0寄存器的值移动到eax寄存器中，同时d输出到cr0变量中
    ret=cr0;
    cr0&=0xfffffffffffeffff;//将cr0变量值中的第17位清0,将修改后的值写入cr0寄存器
    asm volatile("movq %%rax,%%cr0"::"a"(cr0));//将cr0变量的值作为输入，输入到寄存器eax中，同时移动到寄存器cr0中
    return ret;
}
 
static void setback_cr0(int val) //使cr0寄存器设置为内核不可写
{
    asm volatile("movq %%rax,%%cr0"::"a"(val));
}
 
// 根据一个进程的进程描述符和虚拟地址找到虚拟地址所在页的页表项
static pte_t* get_pte(struct task_struct *task, unsigned long vaddr)
{
	pgd_t* pgd;		//PGD: Page Global Directory
    p4d_t* p4d;		//P4D: 第四级页表
	pud_t* pud;		//PUD: Page Upper Directory
	pmd_t* pmd;		//PMD: Page Middle Directory
	pte_t* pte;		//PTE: Page Table Entry
	struct mm_struct *mm = task->mm;
	//五级页表层层索引
	pgd = pgd_offset(mm, vaddr); //获得pgd的地址 
	if(pgd_none(*pgd) || pgd_bad(*pgd))
		return NULL;

    p4d = p4d_offset(pgd, vaddr); //获得p4d的地址 
	if(p4d_none(*p4d) || p4d_bad(*p4d))
		return NULL;

	pud = pud_offset(p4d, vaddr); //获得pud的地址 
	if(pud_none(*pud) || pud_bad(*pud))
		return NULL;

	pmd = pmd_offset(pud, vaddr); //获得pmd的地址 
	if(pmd_none(*pmd) || pmd_bad(*pmd))
		return NULL;

	pte = pte_offset_kernel(pmd, vaddr); //获得pte的地址 
	if(pte_none(*pte))
		return NULL;
	return pte;
}

static int sys_mycall(const struct pt_regs * regs) //定义自己的系统调用 参数为一个结构体指针regs，详情请看参考文献[6]
{   
    /*regs结构体指针内的四个成员，本质上是四个寄存器，分别存着 pid vaddr buffer bytes*/
	unsigned long obj_pid=(unsigned long )regs->di;		//待入侵的进程pid
	unsigned long obj_vaddr=(unsigned long )regs->si;	//带入侵进程的虚拟地址，此处的虚拟地址vaddr是用户态下的
	unsigned long crrt_buffer=(unsigned long )regs->dx;	//将[crrt_buffer,crrt_buffer+obj_bytes]地址区间的内容拷贝到obj_vaddr中实现修改
	unsigned long obj_bytes=(unsigned long )regs->r10;	//修改的字节数

	int crrt_pid=current->pid;	//调用本服务例程的进程pid

	struct task_struct  *obj_task;
	struct task_struct  *crrt_task;

	pte_t* obj_pte;
	pte_t* crrt_pte;

	struct page* obj_page;
	struct page* crrt_page;

	// int i;

	unsigned long obj_pgvaddr=0;	//虚拟地址vaddr所在页的虚拟地址		
	unsigned long crrt_pgvaddr=0;

	unsigned long obj_page_offset = 0; //虚拟地址vaddr的页偏移值
	unsigned long crrt_page_offset = 0;

	unsigned long obj_vaddr_kernel=0;  //vaddr的内核态的虚拟地址
	unsigned long crrt_vaddr_kernel=0;
	
	printk("module my_syscall336 is calling by process %d...\npid=%ld   vaddr=0x%lx  %lu	bufferaddr=0x%lx  %lu \n",
												current->pid,obj_pid,obj_vaddr,obj_vaddr,crrt_buffer,crrt_buffer);
	// 根据pid找到进程描述符
	obj_task = pid_task(find_pid_ns(obj_pid, &init_pid_ns), PIDTYPE_PID);
	// 根据进程描述符和虚拟地址找到虚拟地址vaddr所在页的页表项
	if(!(obj_pte = get_pte(obj_task, obj_vaddr)))
		return -2;		//入侵的地址所在的页暂时不在内存中 此处返回-2是因为系统调用失败会返回-1，依据返回值告诉调用进程失败的原因
	//由页表项找到所在页page
	obj_page = pte_page(*obj_pte);	
	//由页返回页的虚拟地址
	obj_pgvaddr = (unsigned long)page_address(obj_page);
	printk("page virtual address=0x%lx  %lu\n",obj_pgvaddr,obj_pgvaddr);
	obj_page_offset = obj_vaddr & ~PAGE_MASK;//获得页偏移地址 
	obj_vaddr_kernel=obj_pgvaddr+obj_page_offset;	//内核态的虚拟地址
	printk("kernel virtual address=0x%lx  %lu\n",obj_vaddr_kernel,obj_vaddr_kernel);

	crrt_task=pid_task(find_pid_ns(crrt_pid, &init_pid_ns), PIDTYPE_PID);
	if(!(crrt_pte = get_pte(crrt_task, crrt_buffer)))
		return -3;		//buffer分配失败时buffer所在页就不会在内存中，此处返回-3，一般来说传入的buffer是否是空要做检查，此处为了防止不做检查就传入的情况
	crrt_page = pte_page(*crrt_pte);	
	crrt_pgvaddr = (unsigned long)page_address(crrt_page);
	printk("buffer page virtual address=0x%lx  %lu\n",crrt_pgvaddr,crrt_pgvaddr);
	crrt_page_offset = crrt_buffer & ~PAGE_MASK;
	crrt_vaddr_kernel=crrt_pgvaddr+crrt_page_offset;
	printk("kernel virtual BUFFER address=0x%lx  %lu\n",crrt_vaddr_kernel,crrt_vaddr_kernel);
	//执行修改
	memcpy((void *)obj_vaddr_kernel,(void *)crrt_vaddr_kernel,obj_bytes);
	return 0;    //调用成功
}
static int __init init_mycall(void)
{
	printk("module my_syscall336 is initializing......\n");
    sys_call_table=(unsigned long*)(SYS_CALL_TABLE_ADDRESS); 
	printk("sys_call_table: 0x%p\n", sys_call_table);
    anything_saved=(int(*)(void))(sys_call_table[__NR_syscall]);//保存系统调用表中的NUM位置上的系统调用
    orig_cr0=clear_cr0();//使内核地址空间可写
    sys_call_table[__NR_syscall]=(unsigned long) &sys_mycall;//用自己的系统调用替换NUM位置上的系统调用
    setback_cr0(orig_cr0);//使内核地址空间不可写
    return 0;
}
 
static void __exit exit_mycall(void)
{
    printk("module my_syscall336 is exiting......\n");
    orig_cr0=clear_cr0();
    sys_call_table[__NR_syscall]=(unsigned long)anything_saved;//将系统调用恢复
    setback_cr0(orig_cr0);
}


MODULE_LICENSE("GPL");
module_init(init_mycall);
module_exit(exit_mycall);

为了编译以上两个.c源文件，需要写Makefile文件，这里文件名必须为"Makefile"注意大小写，文件中的内容如下：（注意第一行obj-m:=****.o要与****.c名字对应）,编译后会生成两个对应的.ko文件，命令行终端执行sudo insmod ***.ko将模块插入内核。

#Makefile
obj-m:=my_syscall335.o # Pay attention here 'obj-m:=my_syscall336.o'
PWD:= $(shell pwd)
KERNELDIR:= /lib/modules/$(shell uname -r)/build

all:
	make -C $(KERNELDIR) M=$(PWD) modules
clean:
	make -C $(KERNELDIR) M=$(PWD) clean

invade_process.c源代码，实现展示进程私有内存整体布局，并通过调用以上两个系统调用完成进程内存窥探和修改的整体逻辑。

/*
invade_process.c
*/
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
int disp_mem(int pid);  //展示任意进程内存空间结构
int main(){
    unsigned long pid,vaddr,bytes;  //读取（并修改）任意进程pid的虚拟地址vaddr的bytes个字节
    char *buffer=0;                 //读取时用于存放读取到的内容，修改时用于存放要修改的内容
    int i=0;                        //用于迭代buffer
    printf("Current pid=%d\n",getpid());    //输出当前进程pid
    printf("Input the infomation of process you want invade : pid vaddr bytes\n");
    scanf("%lu%lu%lu",&pid,&vaddr,&bytes);  //输入要入侵（读取或修改）的进程的pid、虚拟地址vaddr、读取（修改）的字节数bytes
    printf("Info of invaded process: pid=%lu	vaddr=%lu	bytes=%lu\n",pid,vaddr,bytes);
    if(disp_mem(pid)==-1)           //展示任意进程pid的内存映射布局，返回-1代表该pid进程不存在
        return -1;
    /*调用335系统调用（读取）指定进程指定虚拟地址空间的内容*/
    if(buffer=(char *)malloc(bytes)){   
    int sign=syscall(335,pid,vaddr,buffer,bytes);   //调用335号系统调用，335系统调用实现了对任意进程任意虚拟地址空间内容的读取
        if(sign==0){                            //调用成功
            printf("Intercepted content: \n0x");
            //逐字节以16进制输出读取到的bytes个字节
            for(i=0;i<bytes;i++)    
                printf("%02x ",*(buffer+i));
            printf("\n");
            printf("%s\n",buffer);
        }  
        else if(sign==-2){                      //调用失败，原因：当前要读取的虚拟地址所在页不在内存中（即缺页）
            printf("Failed: The page where the virtual address is located is not in memory \n");
            free(buffer);                       //中途结束程序前，释放buffer内存
            return 0;	
        }
        else if(sign==-1){                      //系统调用335内核模块未加载，或者其他系统故障
            printf("syscall 335 failed !\n");
            free(buffer);                       //中途结束程序前，释放buffer内存
            return 0;
        }
        //正常释放buffer内存
        free(buffer);
    }else
        printf("Buffer allocation failed !");
    /*调用336系统调用（修改）指定进程指定虚拟地址空间的内容*/
    printf("Do you want something more exciting ? y/n\n");
    getchar();      //接受前面格式输入scanf的回车键，因为下面的choice读取只读一个字符
    char choice='n';
    scanf("%c",&choice);
    if(choice=='n'|| choice=='N'){
        printf("So boring you are , bye !\n");
    }else if(choice=='y'||choice=='Y'){
        printf("Let's modify the contents of the specified memory address of the process： vaddr bytes\n");
        scanf("%lu%lu",&vaddr,&bytes);      //此处只需输入要修改的内存虚拟地址和字节数，而不用输入pid
        if(buffer=(char *)malloc(bytes)){   
            printf("input the modifed content < %ld bytes:\n",bytes);
            getchar();
            fgets(buffer,bytes,stdin);          //此处以修改的内容是字符串为例，当然也可以是任意类型比如整形int，则申请4字节的buffer 然后 scanf("%d",(int*)buffer); 
            //以下调用336系统调用来修改指定虚拟地址空间的内容为buffer的内容
            int sign=syscall(336,pid,vaddr,buffer,bytes);
            if(sign==0)
                printf("Modify successfully !\n");
            else if(sign==-2)
                printf("Failed: The page where the virtual address is located is not in memory \n");
            else if(sign==-1)
                printf("syscall 336 failed !");
                free(buffer);
        }
    }
    return 0;
}
/*展示任意进程的内存布局*/
int disp_mem(int pid){
    char file_name[50]={0};
    sprintf(file_name,"/proc/%d/maps",pid); //读取任意进程的/proc/$pid/maps
    FILE * f=fopen(file_name,"r");
    if(f==NULL){
        printf("process %d doesn't exist !\n",pid);
        return -1;
    }else{
        char c;
        while((c = fgetc(f)) != EOF)
        {
            printf("%c", c);
        }
        printf("\n");
        fclose(f);
    }
    return 0;
}

target_process.c源代码，被入侵的进程，主要任务为暴露自己的相关信息出去，并阻塞自己让其他进程入侵。

/*
target_process.c
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/mman.h>

int main()
{
    char* vaddr = (char*)malloc(100);       //待其它进程入侵读取的内容，将其地址暴露出去
    char* buffer=(char *)malloc(100);       //待其他进程入侵修改的内容，将其地址也暴露出去,此时的buffer没有任何内容
    strcpy(vaddr, "Who are you ?");

    printf("pid:%d  vaddr: %lu   buufer: %lu\n", getpid(),(unsigned long)vaddr, (unsigned long)buffer); //暴露进程pid和两个待入侵的地址
    printf("host:%s  \n", vaddr);

    getchar();		//阻塞自身

    printf("hacker:%s\n", buffer);  //黑客入侵成功后，将会在此留下他想对主人说的话：I am your father hahaha...
    								//入侵失败则输出为空
    free(vaddr);
    free(buffer);
    return 0;
}

运行结果

运行平台：Ubuntu20.04 (kernel 5.13.0-27-generic)

在这里插入图片描述

首先查看当前系统调用表sys_call_table在内存中的地址，可以看到第一行R是只读的：

执行命令行 sudo cat /proc/kallsyms | grep sys_call_table

在这里插入图片描述

修改两个系统调用内核模块源文件中的宏定义：

#define SYS_CALL_TABLE_ADDRESS   0xffffffff82c00300

命令行终端执行sudo make编译两个系统调用源文件（执行两次，第一次执行完需要修改Makefile文件的第一行）

在这里插入图片描述

加载两个内核模块到内核中sudo insmod ***.ko

在这里插入图片描述

命令行终端输入lsmod | grrep my_syscall可以看到模块成功插入到Linux内核中。

在这里插入图片描述

编译invade_process.c和target_process.c

在这里插入图片描述

启动defender进程，准备迎接入侵，可以看到第一次./defender直接按回车停止阻塞，hacker没有入侵，输出为空，第二次./defender后保持阻塞，接下来我们将进行入侵。

在这里插入图片描述

启动hacker进程入侵defender进程，输入要入侵的进程pid 12395、虚拟地址、读取字节数20，输出如下，中间的密密麻麻的为内存布局，Intercepted content就是我们读取到的20字节内容（16进制一行，字符形式一行），“ Who are you ? "说明我们确实读取到defender进程该虚拟地址的内容了。

在这里插入图片描述

继续输入 y 干点大事，我们要告诉他我是谁，于是就有了下面的输出，修改字节数小于25字节，输入要修改的内容 “i am a hacker named Pcyslist…”。

在这里插入图片描述

打开defender进程，输入回车让它停止阻塞，看看我们是否真的入侵成功！

在这里插入图片描述

emm…这…输入的25字节太少了，我们输入的内容多余25个字节了，有一部分没有修改进去，不过程序逻辑是没问题的，下次输入字节选项时输大点即可随心所欲的修改了。

在target_process.c源文件中，待修改的地址的内容是一个通过malloc()函数申请的buffer内存，经测试，这个地址可以是任意的，比如一个整形变量int a，结构体中的某个成员变量，只要将其虚拟地址暴露出去，就能够成功读取和修改。

遇到的问题

  • 系统调用的问题：

    • **sys_call_table的内存地址的获取：**该地址是动态的，每次系统启动其地址都是不一样的，本来计划用kallsyms_lookup_name函数来获取，Linux 内核自5.7后为了安全起见取消了该函数，因此只能通过sudo cat /proc/kallsyms | grep sys_call_table来获取然后硬编码到代码中。这种方法很机械，也很无奈，若有更好的解决办法，欢迎大家评论区指正。
    • **对于sys_call_table的写入：**系统对sys_call_table进行了写保护，对CR0寄存器进行修改，以改变它的只读状态，经查资料修改CR0寄存器的第17位为0即可，修改完后即可将自己的系统调用函数sys_mycall这个函数指针挂在相应的系统调用号的位置上。
    • **含有参数传递的系统调用的设计：**从 内核4.17 版本开始，64 位（x86-64）的内核会采用包装的方式来调用系统调用实际的函数，如果直接简单粗暴地像编写普通函数那样的话，在后面调用自定义系统调用时，并不能正确地返回结果——实际上如果有输出调试的话，会发现根本不会触发我们增加的系统调用。[6] 为此需要传入一个结构体指针，这一点在下面的参考文献[6]中有详细介绍，是一篇很不错的文章。

  • 虚拟内存管理的问题：

    • **从虚拟地址到物理地址的转换：**因为我们要访问任意进程的虚拟地址空间的内容，因此就需要找到存放其内容的具体物理地址在那，为实现这一点需要理解Linux内存管理的基本原理以及mm.h头文件中的各种函数，还有自己的计算机的分页机制是几级页表。

    • **用户空间的虚拟地址VS内核空间的虚拟地址：**在实验过程中发现，同一个物理地址在用户态下的虚拟地址和内核态下的虚拟地址是不一样的，可以对比以下两对地址：obj_vaddr 和 obj_vaddr_kernel 或者crrt_buffer 和 crrt_vaddr_kernel 第一对儿地址均指向的是defender进程的vaddr(读取时) buffer(修改时)；第二对二地址均指向hacker进程的buffer(无论读取还是修改)，可以发现每一对地址都是不一样的，这一点很让人迷惑不解。在运行完hacker进程后，我们执行命令dmesg可以看到hacker进程执行系统调用时留下的内核输出记录：可以看到pid为12600的进程（hacker进程）分别调用335号系统调用和336号系统调用各一次，对pid为12395的进程（defender进程）进行入侵。在进行读取时，obj_vaddr=vaddr=0x55ced8d8a2a0 obj_vaddr_kernel=kernel virtual address=0xffff9e31694432a0是不相等的，他们均指向的是defender进程的vaddr内存空间；crrt_buffer=bufferaddr=0x5603c4ac80b0 crrt_vaddr_kernel=kernel virtual BUFFER address=0xffff9e3186fce0b0同样也是不相同的。在进行修改时，调用336系统调用中也是不同的。

      在这里插入图片描述

    • 对于暂时还没有加入到内存的页，当我们用其他进程入侵访问该虚拟地址时会发生缺页（不会产生缺页中断），此时系统调用会失败，因为缺页中断是进程自己正常执行时才会触发的。当然我们或许可以设计一种方法让它加载到内存？这是一个不错的想法。

内容总结

本文设计了一个小工具——“进程内存窥探修改器”：通过内核模块法向Linux内核增加了两个带参数传递的系统调用，借用此系统调用**能够完成对任意进程任意虚拟地址空间内容的读取和修改。**并通过hacker 入侵 defender的情景模式进行演示，实验结果证明该算法程序的真实有效性。若要访问的虚拟地址所在的页未在内存中，则无法对其进行读取和修改，这种情况可能是这个程序可以改进的地方。

参考文献

特别感谢以下文献作者对本文的帮助！

[1] 系统调用原理 https://linux.fasionchan.com/zh_CN/latest/system-programming/syscall/principle.html

[2] Linux 进程管理 https://www.starky.ltd/2018/08/17/Linux-Process-Management/

[3] Linux虚拟内存管理 https://blog.csdn.net/u010150046/article/details/72630262

[4] Ubuntu20.04编译内核并添加一个系统调用 https://blog.csdn.net/BAR_WORKSHOP/article/details/111647568

[5] 使用内核模块添加系统调用（无需编译内核）https://blog.csdn.net/qq_34258344/article/details/103228607

[6] 内核模块法增加带参数的系统调用 https://moefactory.com/3041.moe#header-id-8

[7] ERROR: modpost: “kallsyms_lookup_name” undefined https://github.com/anbox/anbox-modules/issues/49

[8] Linux内核私闯进程地址空间 https://blog.csdn.net/dog250/article/details/102292288

[9] 虚拟地址转换得到实际的物理地址 https://blog.csdn.net/hpu11/article/details/52600726

life_forwin
关注
  • 8
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
进程内存修改器
02-16
对系统进程进行修改
Linux内核私闯进程地址空间并修改进程内存
Netfilter
10-07 5312
进程地址空间的隔离 是现代操作系统的一个显著特征。这也是区别于 “古代”操作系统 的显著特征。 进程地址空间隔离意味着进程P1无法以随意的方式访问进程P2的内存，除非这块内存被声明是共享的。 这非常容易理解，我举个例子。 我们知道，在原始野人社会，是没有家庭的观念的，所有的资源都是部落内共享的，所有的野人都可以以任意的方式在任意时间和任何其他野人交互。类似Dos这样的操作系统就是这样的，内存地址空...
边缘计算+WEB端应用融合：AI行为识别智能监控系统搭建指南 -- 边缘设备图像识别及部署
最新发布
2401_84166147的博客
04-08 1114
origin = wrapbuffer_fd(fd, width, height, RK_FORMAT_YCbCr_420_SP, width_stride, height_stride); src = wrapbuffer_fd(mpp_frame_fd, width, height, RK_FORMAT_YCbCr_420_SP, width_stride, height_stride); cv::Mat origin_mat = cv::Mat::zeros(height, width, CV_8UC
内存修改器
crkres9527
08-11 1998
// SoCool.cpp: 定义控制台应用程序的入口点。 // #include "stdafx.h" #include &lt;Windows.h&gt; #include &lt;TlHelp32.h&gt;   // enum all process  HANDLE  g_hProcess = INVALID_HANDLE_VALUE; DWORD g_dwValueAddr[10...
Linux 内存调试工具
qgylygqi的专栏
02-18 279
嵌入式开发内存调试工具
Linux内核私闯进程地址空间并修改进程内存的方法
09-14
通过以上讲解，我们可以了解到在Linux内核中如何越过进程地址空间的隔离，以及如何安全地修改进程内存。然而，这样的操作应该谨慎进行，因为它涉及到系统的安全性、稳定性和正确性。在实际应用中，我们应该尽量避免...
Linux内核基础——Linux内核基础编程
01-09
子任务1、编写最简单的内核模块，并将其加载到内核中 hello.c #include #include #include static int init_hello(void) { printk(KERN_INFO Hello, World!\n); return 0; } static void cleanup_hello(void) { ...
深入Linux内核架构——简介与概述
02-24
内核负责将可用共享资源分配到各个系统进程，同时保证系统的完整性。将内核视为库，其提供了一组面向系统的命令。通常系统调用用于向计算机发送请求。在操作系统的实现方面，有两种主要的泛型：微内核和宏内核。微...
Linux调试器-gdb使用
Calm的博客
09-24 175
如何用gdb运行一个程序 格式：gdb ./程序名 例: gdb ./main 程序名后边不需要参加参数，因为参数的获取在这里无效，这里仅仅加载可执行程序信息 进入gdb调试之后的命令操作： 退出：ctrl + d 或 quit 1.r/run：运行程序 2.n/next：逐步调试，如果遇到函数，跳过函数，直接完成功能 3.s/step：逐条调试，如果遇到函数，进入函数，一步一步执行 4....
任务管理器修改器任务管理器修改器
05-04
任务管理器修改器任务管理器任务管理器修改器修改器
修改任何程序内存数据的工具CheatMaker游戏修改V1.61绿色版
08-01
CheatMaker是一个修改任何程序内存数据的工具.可以用以修改内存中的游戏数据并且可以修改任何进程数据.它最大的特点就是你可以使用它来制作基于任何程序的修改器 而且可以制作运行于模拟器上模拟游戏的专用修改器还可以用它来直接修改电脑游戏在内存中的数据. 　　当然你也可以将它视为普通的游戏修改器.CM(简称)支持普通游戏修改器的大部分功能:数据搜索 数据修改 内存管理地址管理...等等.而CM不仅
linux 进程修改器,Linux文件编辑器vim、输出输入重定向以及进程
weixin_39660931的博客
04-28 313
之前在上linux课的时候，老师说，vim使用的好的网络管理员比普通的效率快好多。合抱之木，生于毫末；九层之台，起于累土；千里之行，始于足下。撸基础吧。linux编辑工具VIVIMEMACSvim 是vi的升级版本，它不仅兼容vi的所有指令，而且还有一些新的特性在里面。vim的这些优势主要体现在以下几个方面：易用性 vi只能运行于unix中，而vim不仅可以运行于unix,windows ,mac...
linux 内存被修改,linux 查询内存(linux 修改 openfiles)
weixin_39657521的博客
04-30 262
linux 查询内存(linux 修改 openfiles)2020-07-24 11:09:44共10个回答下面是一个可供选择的,但并不全面的图形或命令行工具列表,这些工具用来检查Linux平台中已用和可用的内存.1./proc/meminfo一种最简单的方法是通过“/proc/可以使用“free”命令查看当前内存的使用情况,其中各项的含义如下,total:总计物理内存的大小;used:已使用的...
linux 进程修改器,关于Linux下的GUI代码编辑器？
weixin_39992417的博客
04-28 132
刚开始接触linux，打算渐渐学习Linux下的程序开发，先要选一款编辑器。我不打算钻研那些软件的奇特用法，仅仅只是想熟悉其操作环境。比如vi和emacs，它们的命令好多的，不过我不是系统管理员，只是需要开发程序的工具。假设在Gnome环境下开发，有gedit这样的文本编辑器，就像用记事本一样，可以复制粘贴选择，能用鼠标我还是愿意用鼠标，不想按一大堆的键盘来执行这些基本操作。不过我想还是vim或e...
Linux内核函数转换
YuZhuQue的博客
11-07 190
要求输入字符串 int str = "75,89,788,75514" 输出数组{75, 89, 788, 75514} 函数实现： #include <linux/init.h> ...
内存修改器原理
Ginvar的专栏
08-19 1441
BOOL WINAPI ReadProcessMemory(                   HANDLE hProcess,    //待读进程的句柄                   LPCVOID lpBaseAddress,    //目标进程中待读内存的起始地址                   LPVOID lpBuffer,    //用来读取数据的缓冲区          
linux动态替换内核函数,如何替换一个Linux内核函数的实现-热补丁原理
weixin_35710880的博客
04-29 308
看题目， 替换Linux内核函数的实现 ，what？这不就是kpatch嘛！也就是我们所谓的 热补丁 。我们为内核做热补丁的时候，没人用汇编写吧，没人用二进制指令码去拼逻辑吧，我们一般都是直接修改内核函数的C代码的，然后形成一个patch文件，然后…然后…去读kpatch的Documents吧。本文我将要描述的是热补丁的原理，而不是一个如何使用kpatch的Howto，更不是关于任何kpatch技...
Linux内核编程基础知识进程管理、内存管理、文件系统、网络协议栈
10-21
Linux内核编程是一项非常复杂的任务，需要掌握许多基础知识。以下是Linux内核编程中的一些基础知识： 1. 进程管理：Linux内核中的进程管理是非常重要的，它包括进程的创建、销毁、调度、同步和通信等。进程是操作系统中最基本的执行单元，Linux内核提供了一系列的系统调用和数据结构来管理进程。 2. 内存管理：Linux内核中的内存管理是非常重要的，它包括内存的分配、释放、映射和保护等。内存管理是操作系统中最基本的资源管理之一，Linux内核提供了一系列的系统调用和数据结构来管理内存。 3. 文件系统：Linux内核中的文件系统是非常重要的，它包括文件的创建、读取、写入、删除和权限控制等。文件系统是操作系统中最基本的数据管理之一，Linux内核提供了一系列的系统调用和数据结构来管理文件系统。 4. 网络协议栈：Linux内核中的网络协议栈是非常重要的，它包括网络协议的实现、套接字接口、网络设备驱动程序等。网络协议栈是操作系统中最基本的通信机制之一，Linux内核提供了一系列的系统调用和数据结构来管理网络协议栈。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值