Linux下實現(xiàn)劫持系統(tǒng)調用的總結

Godbach

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


目錄
一、代碼及實現(xiàn)
（一） 劫持open系統(tǒng)調用的代碼
（二） 編譯及實踐
二、實現(xiàn)原理分析
（一）中斷向量表地址的獲取
（二）系統(tǒng)調用中斷向量地址的獲取
（三）系統(tǒng)調用處理例程地址的獲取
（四）系統(tǒng)調用表地址的獲取
（五）系統(tǒng)調用的替換
參考鏈接


Linux內核版本2.6中已經(jīng)不再導出系統(tǒng)調用符號表了。因此，如果想實現(xiàn)劫持系統(tǒng)調用，就得想辦法找到系統(tǒng)調用表的地址。網(wǎng)上應該可以搜到相關的實現(xiàn)。我這里找到了albcamus兄的精華文章，并在內核版本2.6.18.3上實踐了其中的代碼。這里總結一下。

本文歡迎自由轉載，但請標明出處和本文鏈接，并保持本文的完整性。
CU： Godbach
Blog：http://blog.chinaunix.net/u/33048/index.html
Dec 2, 2009

一、代碼及實現(xiàn)
（一） 劫持open系統(tǒng)調用的代碼
內核態(tài)實現(xiàn)劫持系統(tǒng)調用的代碼如下，來自參考鏈接1，即albcamus兄提供的代碼。我這里屏蔽了一些代碼，僅實現(xiàn)了劫持open系統(tǒng)調用。

1. #include <linux/kernel.h>
   
2. #include <linux/init.h>
   
3. #include <linux/module.h>
   
4. #include <linux/kprobes.h>
   
5. #include <linux/kallsyms.h>
   
6. #include <linux/sched.h>
   
7. #include <linux/ptrace.h>
   
8. #include <linux/mm.h>
   
9. #include <linux/smp.h>
   
10. #include <linux/user.h>
    
11. #include <linux/errno.h>
    
12. #include <linux/cpu.h>
    
13. #include <asm/uaccess.h>
    
14. #include <asm/fcntl.h>
    
15. #include <asm/unistd.h>
    
16. 
    
17. MODULE_DESCRIPTION("Intercept the system call table in Linux");
    
18. MODULE_AUTHOR("alert7 ([email]alert7@xfocus.org[/email]) \n\t\talbcamus <[email]albcamus@gmail.com[/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.                   &regs);
     
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系統(tǒng)調用執(zhí)行次數(shù)之頻繁。

[ 本帖最后由 Godbach 于 2010-1-19 11:24 編輯 ]

Godbach

二、實現(xiàn)原理分析
        實現(xiàn)的方法就是通過中斷向量表，找到系統(tǒng)調用的中斷向量，再通過系統(tǒng)調用時執(zhí)行的指令，最終找到系統(tǒng)調用表的地址， 進行系統(tǒng)調用的替換。。

（一）中斷向量表地址的獲取
        中斷向量表（IDT）的入口地址是通過IDTR寄存器來確定的。IDTR寄存器的內容如下圖所示。

這就是上面代碼中定義結構體

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

復制代碼

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

（二）系統(tǒng)調用中斷向量地址的獲取
下一步就通過IDT找到系統(tǒng)調用中斷即（0x80）的地址。下圖即一個中斷向量的組成。由此可以見，一個中斷向量占用8個字節(jié)。因此，系統(tǒng)調用中斷的地址可以表示為：
idt  = idtr.base + 8 * 0x80



（三）系統(tǒng)調用處理例程地址的獲取
獲取到系統(tǒng)調用中斷的地址后，同樣需要一個數(shù)據(jù)結構，將中斷向量描述符的相關內容保存。數(shù)據(jù)結構的定義如下：

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

復制代碼

通過以上數(shù)據(jù)結構就可以得到系統(tǒng)調用中斷發(fā)生時的中斷處理例程的地址，即函數(shù)system_call()函數(shù)的地址：

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

復制代碼

該函數(shù)是用匯編實現(xiàn)的，位于arch/i386/kernel/entry.S，下面截取該函數(shù)的部分實現(xiàn)：

    # 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

（四）系統(tǒng)調用表地址的獲取
從上面代碼中，我們可以看到，系統(tǒng)調用表的入口地址就是上面倒數(shù)第二行中sys_call_table。那么如果獲取到sys_call_table的地址呢。由于這行代碼執(zhí)行了函數(shù)調用的指令call，該指令對應的指令碼為\xff\x14\x85。因此，我們只要在system_call函數(shù)體內搜索的前三個字節(jié)為\xff\x14\x85的內存地址，然后將該地址加3，即可獲取到sys_call_table的地址。同時，還有一個問題需要確定，就是call *sys_call_table(,%eax,4)這條指令相對于system_call函數(shù)體的偏移是多少，這樣我們可以確定內存搜索的范圍。下面是entry.o函數(shù)反匯編的部分代碼：

000000d0 <system_call>:
  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 <no_singlestep>
  f5:   83 4d 08 10             orl    $0x10,0x8(%ebp)

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

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

通過以上反匯編代碼的倒數(shù)第二行可以看到，該行即執(zhí)行call *sys_call_table(,%eax,4) 的代碼。那么該執(zhí)行相對于函數(shù)體的偏移為0x110-0xd0 = 0x40。我們實際的代碼中使用偏移值100作為搜索的最大范圍。
至于反匯編出來為什么只是call *0x0(,%eax,4)，個人理解應該是該模塊尚未與其他模塊進行鏈接的原因。當生成內核鏡像vmlinux之后，反匯編vmlinux，然后找到system_call函數(shù)，就可以看到指令call *0x0(,%eax,4)中0x0被替換為有效的地址。本人也已經(jīng)在2.6.18.3的vmlinux上驗證過了，實際的代碼如下：

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

復制代碼

因此可以看出，我當前系統(tǒng)的sys_call_table的地址為0xc11f14e0。

（五）系統(tǒng)調用的替換
一旦我們獲取到了系統(tǒng)調用表的地址，需要需要替換那些系統(tǒng)調用，只需要將系統(tǒng)調用表的某個系統(tǒng)調用指向自己實現(xiàn)的系統(tǒng)調用即可。

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

復制代碼

另外，需要注意的是，在替換系統(tǒng)調用的時候，要先清CR0的第20位并記錄原始值，不然在替換sys_call_table的時候會報錯。在替換完畢之后，再將CR0的原始值恢復，代碼如下：

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

復制代碼

以上為Linux劫持系統(tǒng)調用的總結。歡迎多多交流，如果不妥之處，請大家指正。


參考鏈接：
1. http://linux.chinaunix.net/bbs/viewthread.php?tid=909712
3. http://linux.chinaunix.net/bbs/thread-1135859-1-2.html

[ 本帖最后由 Godbach 于 2009-12-2 13:43 編輯 ]

Godbach

scutan兄，你回復的真快啊。

scutan

呵呵，為了不影響文章的連貫性，所以我將之前那個回貼刪了。
學習學習。

Godbach

呵呵，我應該在1樓注上未完待續(xù):wink:

Godbach

1樓中添加了全文的目錄結構。
其實第一部分就是使用albcamus兄的代碼。
重點內容在于第二部分，分析了劫持系統(tǒng)調用的整個過程。

GoldenSoldier

代碼沒有改動吧？

學習了，分析的很好啊，贊一下！
很好，很強大

godbach

代碼沒有改變。

我就是拿了ablcamus兄的代碼，只保留的open系統(tǒng)調用的劫持。

如果想看完成的代碼，可以打開參考連接1.

mik

好文，棒下場。godbach 繼續(xù)發(fā)表些有益的文章

Godbach

呵呵，慚愧。還請mik兄多多指教。這樣的文章在mik面前，有點班門弄斧了。