Linux下实现劫持系统调用的总结 转载

原文链接：http://blog.chinaunix.net/u/33048/showart_2109264.html


目录
一、代码及实现
（一） 劫持open系统调用的代码
（二） 编译及实践
二、实现原理分析
（一）中断向量表地址的获取
（二）系统调用中断向量地址的获取
（三）系统调用处理例程地址的获取
（四）系统调用表地址的获取
（五）系统调用的替换
参考链接


Linux内核版本2.6中已经不再导出系统调用符号表了。因此，如果想实现劫持系统调用，就得想办法找到系统调用表的地址。网上应该可以搜到相关的实现。我这里找到了albcamus兄的精华文章，并在内核版本2.6.18.3上实践了其中的代码。这里总结一下。

本文欢迎自由转载，但请标明出处和本文链接，并保持本文的完整性。
CU： Godbach
Blog：http://blog.chinaunix.net/u/33048/index.html
Dec 2, 2009

一、代码及实现
（一） 劫持open系统调用的代码
内核态实现劫持系统调用的代码如下，来自参考链接1，即albcamus兄提供的代码。我这里屏蔽了一些代码，仅实现了劫持open系统调用。

1. #include <linux/kernel.h>
   
2. #include
   
3. #include module.h>
   
4. #include
   
5. #include
   
6. #include
   
7. #include
   
8. #include
   
9. #include
   
10. #include
    
11. #include
    
12. #include
    
13. #include
    
14. #include
    
15. #include
    
16. 
    
17. MODULE_DESCRIPTION("Intercept the system call table in Linux");
    
18. MODULE_AUTHOR("alert7 ([email][e-mail][/email]) \n\t\talbcamus <[email][e-mail][/email]>");
    
19. MODULE_LICENSE("GPL");
    
20. 
    
21. 
    
22. /* comment the following line to shut me up */
    
23. #define INTERCEPT_DEBUG
    
24. 
    
25. #ifdef INTERCEPT_DEBUG
    
26.     #define dbgprint(format,args...) \
    
27.         printk("intercept: function:%s-L%d: "format, __FUNCTION__, __LINE__, ##args);
    
28. #else
    
29.     #define dbgprint(format,args...)  do {} while(0);
    
30. #endif
    
31. 
    
32. 
    
33. /**
    
34. * the system call table
    
35. */
    
36. void **my_table;
    
37. 
    
38. unsigned int orig_cr0;
    
39. 
    
40. /**
    
41. * the original syscall functions
    
42. */
    
43. asmlinkage long (*old_open) (char __user *filename, int flags, int mode);
    
44. asmlinkage int  (*old_execve) (struct pt_regs regs);
    
45. 
    
46. 
    
47. 
    
48. /** do_execve and do_fork */
    
49. unsigned int can_exec_fork = 0;
    
50. int    (*new_do_execve) (char * filename,
    
51.             char __user *__user *argv,
    
52.             char __user *__user *envp,
    
53.             struct pt_regs * regs);
    
54. 
    
55. 
    
56. struct idtr {
    
57.     unsigned short limit;
    
58.     unsigned int base;
    
59. } __attribute__ ((packed));
    
60. 
    
61. 
    
62. struct idt {
    
63.     unsigned short off1;
    
64.     unsigned short sel;
    
65.     unsigned char none, flags;
    
66.     unsigned short off2;
    
67. } __attribute__ ((packed));
    
68. 
    
69. 
    
70. #if 0
    
71. /**
    
72. *  check if we can intercept fork/vfork/clone/execve or not
    
73. *
    
74. *  return : 0 for no, 1 for yes
    
75. */
    
76. struct kprobe kp_exec;
    
77. unsigned int can_intercept_fork_exec(void)
    
78. {
    
79.     int ret = 0;
    
80. 
    
81. #ifndef CONFIG_KPROBES
    
82.     return ret;
    
83. #endif
    
84. 
    
85.     kp_exec.symbol_name = "do_execve";
    
86. 
    
87.     ret = register_kprobe(&kp_exec);
    
88.     if (ret != 0 ) {
    
89.         dbgprint("cannot find do_execve by kprobe.\n");
    
90.         return 0;
    
91.     }
    
92.     new_do_execve = ( int (*)
    
93.              (char *,
    
94.               char __user * __user *,
    
95.               char __user * __user *,
    
96.               struct pt_regs *
    
97.              )
    
98.             ) kp_exec.addr;
    
99. 
    
100.     dbgprint("do_execve at %p\n", (void *)kp_exec.addr);
     
101.     unregister_kprobe(&kp_exec);
     
102. 
     
103. 
     
104.     return 1;
     
105. }
     
106. 
     
107. #endif
     
108. 
     
109. /**
     
110. * clear WP bit of CR0, and return the original value
     
111. */
     
112. unsigned int clear_and_return_cr0(void)
     
113. {
     
114.     unsigned int cr0 = 0;
     
115.     unsigned int ret;
     
116. 
     
117.     asm volatile ("movl %%cr0, %%eax"
     
118.               : "=a"(cr0)
     
119.               );
     
120.     ret = cr0;
     
121. 
     
122.     /* clear the 16 bit of CR0, a.k.a WP bit */
     
123.     cr0 &= 0xfffeffff;
     
124. 
     
125.     asm volatile ("movl %%eax, %%cr0"
     
126.               :
     
127.               : "a"(cr0)
     
128.               );
     
129.     return ret;
     
130. }
     
131. 
     
132. /** set CR0 with new value
     
133. *
     
134. * @val : new value to set in cr0
     
135. */
     
136. void setback_cr0(unsigned int val)
     
137. {
     
138.     asm volatile ("movl %%eax, %%cr0"
     
139.               :
     
140.               : "a"(val)
     
141.               );
     
142. }
     
143. 
     
144. 
     
145. /**
     
146. * Return the first appearence of NEEDLE in HAYSTACK.  
     
147. * */
     
148. static void *memmem(const void *haystack, size_t haystack_len,
     
149.             const void *needle, size_t needle_len)
     
150. {/*{{{*/
     
151.     const char *begin;
     
152.     const char *const last_possible
     
153.         = (const char *) haystack + haystack_len - needle_len;
     
154. 
     
155.     if (needle_len == 0)
     
156.         /* The first occurrence of the empty string is deemed to occur at
     
157.            the beginning of the string.  */
     
158.         return (void *) haystack;
     
159. 
     
160.     /* Sanity check, otherwise the loop might search through the whole
     
161.        memory.  */
     
162.     if (__builtin_expect(haystack_len < needle_len, 0))
     
163.         return NULL;
     
164. 
     
165.     for (begin = (const char *) haystack; begin <= last_possible;
     
166.          ++begin)
     
167.         if (begin[0] == ((const char *) needle)[0]
     
168.             && !memcmp((const void *) &begin[1],
     
169.                    (const void *) ((const char *) needle + 1),
     
170.                    needle_len - 1))
     
171.             return (void *) begin;
     
172. 
     
173.     return NULL;
     
174. }/*}}}*/
     
175. 
     
176. 
     
177. /**
     
178. * Find the location of sys_call_table
     
179. */
     
180. static unsigned long get_sys_call_table(void)
     
181. {/*{{{*/
     
182. /* we'll read first 100 bytes of int $0x80 */
     
183. #define OFFSET_SYSCALL 100        
     
184. 
     
185.     struct idtr idtr;
     
186.     struct idt idt;
     
187.     unsigned sys_call_off;
     
188.     unsigned retval;
     
189.     char sc_asm[OFFSET_SYSCALL], *p;
     
190. 
     
191.     /* well, let's read IDTR */
     
192.     asm("sidt %0":"=m"(idtr)
     
193.              :
     
194.              :"memory" );
     
195. 
     
196.     dbgprint("idtr base at 0x%X, limit at 0x%X\n", (unsigned int)idtr.base,(unsigned short)idtr.limit);
     
197. 
     
198.     /* Read in IDT for vector 0x80 (syscall) */
     
199.     memcpy(&idt, (char *) idtr.base + 8 * 0x80, sizeof(idt));
     
200. 
     
201.     sys_call_off = (idt.off2 << 16) | idt.off1;
     
202. 
     
203.     dbgprint("idt80: flags=%X sel=%X off=%X\n",
     
204.                  (unsigned) idt.flags, (unsigned) idt.sel, sys_call_off);
     
205. 
     
206.     /* we have syscall routine address now, look for syscall table
     
207.        dispatch (indirect call) */
     
208.     memcpy(sc_asm, (void *)sys_call_off, OFFSET_SYSCALL);
     
209. 
     
210.     /**
     
211.      * Search opcode of `call sys_call_table(,eax,4)'
     
212.      */
     
213.     p = (char *) memmem(sc_asm, OFFSET_SYSCALL, "\xff\x14\x85", 3);
     
214.     if (p == NULL)
     
215.         return 0;
     
216. 
     
217.     retval = *(unsigned *) (p + 3);
     
218.     if (p) {
     
219.         dbgprint("sys_call_table at 0x%x, call dispatch at 0x%x\n",
     
220.              retval, (unsigned int) p);
     
221.     }
     
222.     return retval;
     
223. #undef OFFSET_SYSCALL
     
224. }/*}}}*/
     
225. 
     
226. 
     
227. 
     
228. /**
     
229. * new_open - replace the original sys_open when initilazing,
     
230. *           as well as be got rid of when removed
     
231. */
     
232. asmlinkage long new_open(char *filename, int flags, int mode)
     
233. {
     
234.     dbgprint("call open()\n");
     
235.     return old_open (filename, flags, mode);
     
236. }
     
237. 
     
238. 
     
239. /**
     
240. * new_execve - you should change this function whenever the kernel's sys_execve()
     
241. * changes
     
242. */
     
243. asmlinkage int new_execve(struct pt_regs regs)
     
244. {
     
245.     int error;
     
246.     char *filename;
     
247. 
     
248.     dbgprint("Hello\n");
     
249. 
     
250.     filename = getname( (char __user *) regs.ebx );
     
251.     error = PTR_ERR(filename);
     
252.     if ( IS_ERR(filename) )
     
253.         goto out;
     
254.     dbgprint("file to execve: %s\n", filename);
     
255.     error = new_do_execve(filename,
     
256.                   (char __user * __user *) regs.ecx,
     
257.                   (char __user * __user *) regs.edx,
     
258.                   ®s);
     
259.     if (error == 0) {
     
260.         task_lock(current);
     
261.         current->ptrace &= ~PT_DTRACE;
     
262.         task_unlock(current);
     
263.         set_thread_flag(TIF_IRET);
     
264.     }
     
265.     putname (filename);
     
266. out:
     
267.     return error;
     
268. }
     
269. 
     
270. static int intercept_init(void)
     
271. {
     
272.     my_table = (void **)get_sys_call_table();
     
273.     if (my_table == NULL)
     
274.         return -1;
     
275. 
     
276.     dbgprint("sys call table address %p\n", (void *) my_table);
     
277. 
     
278. #define REPLACE(x) old_##x = my_table[__NR_##x];\
     
279.     my_table[__NR_##x] = new_##x
     
280. 
     
281.    
     
282.     REPLACE(open);
     
283. #if 0
     
284.     can_exec_fork = can_intercept_fork_exec();
     
285.     if(can_exec_fork == 1)
     
286.         REPLACE(execve);
     
287. #endif
     
288. 
     
289. #undef REPLACE
     
290.     return 0;
     
291. }
     
292. 
     
293. 
     
294. 
     
295. 
     
296. 
     
297. static int __init this_init(void)
     
298. {
     
299.     int ret;
     
300.     printk("syscall intercept: Hi, poor linux!\n");
     
301. 
     
302.     orig_cr0 = clear_and_return_cr0();   
     
303.     ret = intercept_init();
     
304.     setback_cr0(orig_cr0);
     
305. 
     
306.     return ret;
     
307. }
     
308. 
     
309. static void __exit this_fini(void)
     
310. {
     
311.     printk("syscall intercept: bye, poor linux!\n");
     
312. 
     
313. #define RESTORE(x) my_table[__NR_##x] = old_##x
     
314. 
     
315.     orig_cr0 = clear_and_return_cr0();   
     
316.     RESTORE(open);
     
317. #if 0
     
318.     if(can_exec_fork == 1)
     
319.         RESTORE(execve);
     
320. #endif
     
321.     setback_cr0(orig_cr0);
     
322. 
     
323. #undef RESTORE
     
324. }
     
325. 
     
326. module_init(this_init);
     
327. module_exit(this_fini);

复制代码

（二） 编译及实践
Makefile如下：

obj-m   :=hack_open.o
EXTRA_CFLAGS := -Dsymname=sys_call_table
KDIR   := /lib/modules/$(shell uname -r)/build
PWD   := $(shell pwd)
default:
    make -C $(KDIR) SUBDIRS=$(PWD) modules
clean:
    rm -rf .*.cmd *.mod.c *.o *.ko .tmp* *.symvers

编译之后，加载模块，然后查看日志信息：

Sep 24 19:06:49 localhost kernel: intercept: function:get_sys_call_table-L220: sys_call_table at 0xc11f14e0, call dispatch at 0xcebeceaa
Sep 24 19:06:49 localhost kernel: intercept: function:intercept_init-L276: sys call table address c11f14e0
Sep 24 19:06:50 localhost kernel: intercept: function:new_open-L234: hello
Sep 24 19:07:00 localhost last message repeated 460 times

可见open系统调用执行次数之频繁。

二、实现原理分析
        实现的方法就是通过中断向量表，找到系统调用的中断向量，再通过系统调用时执行的指令，最终找到系统调用表的地址， 进行系统调用的替换。。

（一）中断向量表地址的获取
        中断向量表（IDT）的入口地址是通过IDTR寄存器来确定的。IDTR寄存器的内容如下图所示。

(6.05 KB)

2009-12-02 13:22

这就是上面代码中定义结构体

1. struct idtr {
   
2.     unsigned short limit;
   
3.     unsigned int base;
   
4. } __attribute__ ((packed))

复制代码

的原因。
idtr寄存器的内容可以通过汇编指令sidt取出，然后就可以IDT的入口地址idtr.base，即高32bit。

（二）系统调用中断向量地址的获取
下一步就通过IDT找到系统调用中断即（0x80）的地址。下图即一个中断向量的组成。由此可以见，一个中断向量占用8个字节。因此，系统调用中断的地址可以表示为：
idt  = idtr.base + 8 * 0x80

(16.03 KB)

2009-12-02 13:41

（三）系统调用处理例程地址的获取
获取到系统调用中断的地址后，同样需要一个数据结构，将中断向量描述符的相关内容保存。数据结构的定义如下：

1. struct idt {
   
2.     unsigned short off1;
   
3.     unsigned short sel;
   
4.     unsigned char none, flags;
   
5.     unsigned short off2;
   
6. } __attribute__ ((packed));

复制代码

通过以上数据结构就可以得到系统调用中断发生时的中断处理例程的地址，即函数system_call()函数的地址：

1. sys_call_off = idt.off2 << 16 | idt.off1

复制代码

该函数是用汇编实现的，位于arch/i386/kernel/entry.S，下面截取该函数的部分实现：

QUOTE:

    # system call handler stub
ENTRY(system_call)
    RING0_INT_FRAME         # can't unwind into user space anyway
    pushl %eax          # save orig_eax
    CFI_ADJUST_CFA_OFFSET 4
    SAVE_ALL
    GET_THREAD_INFO(%ebp)
    testl $TF_MASK,EFLAGS(%esp)
    jz no_singlestep
    orl $_TIF_SINGLESTEP,TI_flags(%ebp)
no_singlestep:
                    # system call tracing in operation / emulation
    /* Note, _TIF_SECCOMP is bit number 8, and so it needs testw and not testb */
    testw $(_TIF_SYSCALL_EMU|_TIF_SYSCALL_TRACE|_TIF_SECCOMP|_TIF_SYSCALL_AUDIT),TI_flags(%ebp)
    jnz syscall_trace_entry
    cmpl $(nr_syscalls), %eax
    jae syscall_badsys
syscall_call:
    call *sys_call_table(,%eax,4)
movl %eax,EAX(%esp)     # store the return value

（四）系统调用表地址的获取
从上面代码中，我们可以看到，系统调用表的入口地址就是上面倒数第二行中sys_call_table。那么如果获取到sys_call_table的地 址呢。由于这行代码执行了函数调用的指令call，该指令对应的指令码为\xff\x14\x85。因此，我们只要在system_call函数体内搜索 的前三个字节为\xff\x14\x85的内存地址，然后将该地址加3，即可获取到sys_call_table的地址。同时，还有一个问题需要确定，就 是call *sys_call_table(,%eax,4)这条指令相对于system_call函数体的偏移是多少，这样我们可以确定内存搜索的范围。下面是 entry.o函数反汇编的部分代码：

QUOTE:

000000d0 :
  d0:   50                      push   %eax
  d1:   fc                      cld   
  d2:   06                      push   %es  
  d3:   1e                      push   %ds  
  d4:   50                      push   %eax
  d5:   55                      push   %ebp
  d6:   57                      push   %edi
  d7:   56                      push   %esi
  d8:   52                      push   %edx
  d9:   51                      push   %ecx
  da:   53                      push   %ebx
  db:   ba 7b 00 00 00          mov    $0x7b,%edx
  e0:   8e da                   movl   %edx,%ds
  e2:   8e c2                   movl   %edx,%es
  e4:   bd 00 f0 ff ff          mov    $0xfffff000,%ebp
  e9:   21 e5                   and    %esp,%ebp
  eb:   f7 44 24 30 00 01 00    testl  $0x100,0x30(%esp)
  f2:   00   
  f3:   74 04                   je     f9
  f5:   83 4d 08 10             orl    $0x10,0x8(%ebp)

000000f9 :
  f9:   66 f7 45 08 c1 01       testw  $0x1c1,0x8(%ebp)
  ff:   0f 85 bf 00 00 00       jne    1c4
105:   3d 3e 01 00 00          cmp    $0x13e,%eax
10a:   0f 83 27 01 00 00       jae    237

00000110 :
110:   ff 14 85 00 00 00 00    call   *0x0(,%eax,4)
117:   89 44 24 18             mov    %eax,0x18(%esp)

通过以上反汇编代码的倒数第二行可以看到，该行即执行call *sys_call_table(,%eax,4) 的代码。那么该执行相对于函数体的偏移为0x110-0xd0 = 0x40。我们实际的代码中使用偏移值100作为搜索的最大范围。
至于反汇编出来为什么只是call *0x0(,%eax,4)，个人理解应该是该模块尚未与其他模块进行链接的原因。当生成内核镜像vmlinux之后，反汇编vmlinux，然后找到 system_call函数，就可以看到指令call *0x0(,%eax,4)中0x0被替换为有效的地址。本人也已经在2.6.18.3的vmlinux上验证过了，实际的代码如下：

1. c1003d04 :
   
2. c1003d04:   ff 14 85 e0 14 1f c1    call   *0xc11f14e0(,%eax,4)
   
3. c1003d0b:   89 44 24 18             mov    %eax,0x18(%esp)

复制代码

因此可以看出，我当前系统的sys_call_table的地址为0xc11f14e0。

（五）系统调用的替换
一旦我们获取到了系统调用表的地址，需要需要替换那些系统调用，只需要将系统调用表的某个系统调用指向自己实现的系统调用即可。

1. #define REPLACE(x) old_##x = my_table[__NR_##x];\
   
2.     my_table[__NR_##x] = new_##x
   
3.     REPLACE(open);

复制代码

另外，需要注意的是，在替换系统调用的时候，要先清CR0的第20位并记录原始值，不然在替换sys_call_table的时候会报错。在替换完毕之后，再将CR0的原始值恢复，代码如下：

1. orig_cr0 = clear_and_return_cr0();   
   
2. setback_cr0(orig_cr0);

复制代码

以上为Linux劫持系统调用的总结。欢迎多多交流，如果不妥之处，请大家指正。


参考链接：
1.
3.