[杂七杂八] rootkit技术

端口反弹：主要是为了更好的突破防火墙的限制，可以在客户端上监听80端口，而在服务器端通过对客户端的80端口进行回连，伪装成一个访问web服务的正常进程从而突破防火墙的限制。

附：Rootkit on Linux x86 v2.6.pdf： http://download.csdn.net/detail/lucien_cc/4284660

熬夜写llroot,写的头有些晕了,代码也有点乱,所以停下来歇歇;就又去逆向昨天下的那个rootkit,搞了1个多小时,头又晕了,才搞了不到一半,夜深人静的时候,孤孤单单,没有美女陪,不爽啊.想想好长时间没有在这个blog上写技术文章了,于是就转来下面一篇文章,文章比较老了,针对linux2.2内核的,但是基本的思路是没有失效的.正好这学期的操作系统课程考试也打算让研究生写一些类似的程序,所以贴在这里,也可以给他们参考下.等我今年把现在的事情忙完,把计划中的那几个开发板做出来后,明年要回头认真写个linux下的rootkit玩玩.

}

个人工作之余的实践总结，简单地把RootKit分为用户态rootkit和内核级rootkit。内核级rootkit可分基于LKM 的rootkit（又细分为系统调用表修改类以及VFS层rootkit等）和非LKM的rootkit（如系统调用表重定向等）。Linux下还有BIOS、PCI、Boot（NTLDR、BCD,Grub）等更新颖技术的rootkit暂时不提供样本，同时如前面所说的，完全是个人的分析总结，不足之处欢迎指导交流！

下面用图表格来分析对比。

通过hook Linux内核函数，监控进程/线程创建与销毁

还是实验室蛋疼项目的需求催出来的东西，蛋疼要死，CS专业读研难道就等于干2-3年义工？？本人对Linux内核无爱，好吗！！！

Linux实际上木有线程这玩意，具体到内核里面就是个进程组头+一堆轻量级进程

太感谢Linus了，工作量瞬间下来了，在内核线程/进程无差别的，写一套东西就忽悠交差说是两套都做了，反正那帮子人也不懂。。。。

所有的进程创建都是通过do_fork()内核函数来做的，所有进程销毁都是走do_exit()，系统调用什么的都是这两个函数的封装而已

比如下面，和创建进程/线程相关的系统调用的处理函数。。。

[cpp] view plain copy

 

1. asmlinkage int sys_fork(struct pt_regs regs)  
2. {  
3.     return do_fork(SIGCHLD, regs.esp, ®s, 0, NULL, NULL);  
4. }  
5.   
6. asmlinkage int sys_clone(struct pt_regs regs)  
7. {  
8.     unsigned long clone_flags;  
9.     unsigned long newsp;  
10.     int __user *parent_tidptr, *child_tidptr;  
11.   
12.     clone_flags = regs.ebx;  
13.     newsp = regs.ecx;  
14.     parent_tidptr = (int __user *)regs.edx;  
15.     child_tidptr = (int __user *)regs.edi;  
16.     if (!newsp)  
17.         newsp = regs.esp;  
18.     return do_fork(clone_flags, newsp, ®s, 0, parent_tidptr, child_tidptr);  
19. }  
20.   
21. /* 
22.  * This is trivial, and on the face of it looks like it 
23.  * could equally well be done in user mode. 
24.  * 
25.  * Not so, for quite unobvious reasons - register pressure. 
26.  * In user mode vfork() cannot have a stack frame, and if 
27.  * done by calling the "clone()" system call directly, you 
28.  * do not have enough call-clobbered registers to hold all 
29.  * the information you need. 
30.  */  
31. asmlinkage int sys_vfork(struct pt_regs regs)  
32. {  
33.     return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs.esp, ®s, 0, NULL, NULL);  
34. }  

关于怎么hook，在飞客杂志上找到几篇inline hook，都是修改被hook函数入口处的汇编，插入JMP到自己代码再跑完再手动平衡堆栈JMP回去，累不累额，，，

然后看到这个Ph4nt0m Security Team小组的文章http://blog.csdn.net/lucien_cc/article/details/7544834

真可惜，这个小组现在的主站已经不能访问了，还好在Google Sites里面还能找到小组以前的文章

http://www.80vul.com/ 貌似是新站

OK，回来，文章提到不改动入口，而是修改被hook函数的里面调用下层函数的call，貌似实现简单的多啦。。。

看看do_fork 和 do_exit 的代码

[cpp] view plain copy

 

1. fastcall NORET_TYPE void do_exit(long code)  
2. {  
3.     struct task_struct *tsk = current;  
4.     struct taskstats *tidstats;  
5.     int group_dead;  
6.     unsigned int mycpu;  
7.   
8.     profile_task_exit(tsk);  
9.   
10.     WARN_ON(atomic_read(&tsk->fs_excl));  
11.   
12.     ...  
13. }//任何进程进入这个函数就是死定了，上下文到这里就没有了  
14.   
15. long do_fork(unsigned long clone_flags,  
16.     ...  
17. {  
18.     struct task_struct *p;  
19.     int trace = 0;  
20.     struct pid *pid = alloc_pid();  
21.   
22.     ...  
23.   
24.     p = copy_process(clone_flags, stack_start, regs, stack_size, parent_tidptr, child_tidptr, nr);  
25.   
26.     if (!IS_ERR(p)) {  
27.   
28.         ...  
29.   
30.     } else {  
31.         free_pid(pid);  
32.         nr = PTR_ERR(p);  
33.     }  
34.     return nr;  
35. }  

do_fork会调用copy_process复制进程，如果copy_process成功，进程就创建成功了，最后把PID值返回回去

SO，只需要把这两次函数调用的call语句修改了就能监控全部的创建与销毁了。

最后实现代码如下：

[cpp] view plain copy

 

1. #include <linux/kernel.h>  
2. #include <linux/module.h>  
3. #include <linux/err.h>  
4. #include <linux/smp_lock.h>  
5.   
6. MODULE_LICENSE("GPL");  
7.   
8. #define _FORK_copy_process 0xc04234f9  
9. #define _EXIT_profile_task_exit 0xc04268cf  
10. #define _DO_EXIT_ 0xc0427ec1  
11. #define _DO_FORK_ 0xc0424944 //从 /boot/System.map-$(uname -r) 能找到这些地址  
12.   
13. //CR0的宏，网上扒的  
14. #define CLEAR_CR0    asm ("pushl %eax\n\t"             \  
15. "movl %cr0, %eax\n\t"        \  
16. "andl $0xfffeffff, %eax\n\t"     \  
17. "movl %eax, %cr0\n\t"        \  
18. "popl %eax");  
19.   
20. #define SET_CR0        asm ("pushl %eax\n\t"             \  
21. "movl %cr0, %eax\n\t"         \  
22. "orl $0x00010000, %eax\n\t"     \  
23. "movl %eax, %cr0\n\t"        \  
24. "popl %eax");  
25.   
26. struct task_struct *(*orig_copy_process)(unsigned long clone_flags,  
27.                     unsigned long stack_start,  
28.                     struct pt_regs *regs,  
29.                     unsigned long stack_size,  
30.                     int __user *parent_tidptr,  
31.                     int __user *child_tidptr,  
32.                     int pid); //从内核源代码复制过来的函数声明  
33.   
34. static struct task_struct *my_copy_process(unsigned long clone_flags,  
35.                     unsigned long stack_start,  
36.                     struct pt_regs *regs,  
37.                     unsigned long stack_size,  
38.                     int __user *parent_tidptr,  
39.                     int __user *child_tidptr,  
40.                     int pid)  
41. {  
42.     struct task_struct * ret;  
43.     ret = (*orig_copy_process)(clone_flags,stack_start,regs,stack_size,parent_tidptr,child_tidptr,pid);  
44.     if(!IS_ERR(ret))  
45.         printk("---z---\tPID:%d fork %d successed!\n",current->pid,pid);  
46.     else  
47.         printk("---z---\tPID:%d fork %d failed!\n",current->pid,pid);  
48.     return ret;  
49.   
50. }  
51.   
52. void (*orig_profile_task_exit)(struct task_struct * task);  
53.   
54. void my_profile_task_exit(struct task_struct * task)  
55. {//这个函数不是每个内核都有的，在CONFIG_PROFILING=n的情况下编译的内核，profile_task_exit不存在的，但是呢，在centos 5.5的内核里面是有的，管其他呢。。。。  
56.     printk("---z---\tPID:%d exited!\n",current->pid);  
57. }  
58.   
59. static int replace_fun(unsigned long handle, unsigned long old_fun, unsigned long new_fun)  
60. {  
61.     unsigned char *p = (unsigned char *)handle;  
62.     int i = 0;  
63.     while(1)  
64.     {  
65.         if(i++ > 128)  
66.             return 0;  
67.         if(*p == 0xe8)  
68.         {//e8是GCC编译出来的普通函数调用的call，当然也可能是某个立即数里面的一个字节  
69.             if((*(int *)(p+1) + (unsigned long)p + 5) == old_fun)  
70.             {//so需要看下看e8后面是不是老地址的偏移值，是的话替换掉  
71.                 *(int *)(p+1) = new_fun - (unsigned long)p - 5;  
72.                 return 1;  
73.             }  
74.         }  
75.         p++;  
76.     }  
77. }  
78.   
79. static int _init_module(void ) {  
80.     printk("---z---\t+++++++++++\n");  
81.     orig_copy_process = _FORK_copy_process;  
82.     orig_profile_task_exit = _EXIT_profile_task_exit;  
83.     lock_kernel();  
84.     CLEAR_CR0  
85.     replace_fun(_DO_FORK_, _FORK_copy_process, (unsigned long)my_copy_process);  
86.     replace_fun(_DO_EXIT_, _EXIT_profile_task_exit, (unsigned long)my_profile_task_exit);  
87.     SET_CR0  
88.     unlock_kernel();  
89.     return 0;  
90. }  
91.   
92.   
93. static void _cleanup_module(void) {  
94.     printk("---z---\t---------\n");  
95.     lock_kernel();  
96.     CLEAR_CR0  
97.     replace_fun(_DO_FORK_, (unsigned long)my_copy_process, _FORK_copy_process);  
98.     replace_fun(_DO_EXIT_, (unsigned long)my_profile_task_exit, _EXIT_profile_task_exit);  
99.     SET_CR0  
100.     unlock_kernel();  
101. }  
102.   
103. module_init(_init_module);  
104. module_exit(_cleanup_module);  

装载卸载内核，dmesg看输出

[plain] view plain copy

 

1. ---z--- +++++++++++  
2. ---z--- PID:12668 exited!  
3. ---z--- PID:642 fork 12671 successed!  
4. ---z--- PID:12671 exited!  
5. ---z--- PID:4422 fork 12672 successed!  
6. ---z--- PID:12672 exited!  
7. ---z--- PID:6992 fork 12673 successed!  
8. ---z--- PID:11 fork 12674 successed!  
9. ---z--- PID:12674 fork 12675 successed!  
10. ---z--- PID:12675 exited!  
11. ---z--- PID:12674 exited!  
12. ---z--- ---------  

OK ，很好，，，，，，