加载中…
个人资料
微博
  • 博客等级：
  • 博客积分：
  • 博客访问：
  • 关注人气：
  • 获赠金笔：0支
  • 赠出金笔：0支
  • 荣誉徽章：
正文 字体大小：大 中 小

（转）拦截系统调用 (Linux 3.2.0)

(2014-04-22 05:54:11)
分类： 内核开发
转自： http://blog.csdn.net/u011923747/article/details/11650445

今天在ubuntu中玩了下“拦截系统调用”，记录下自己对整个实现的理解。

原理

在linux kernel中，系统调用都放在一个叫做“sys_call_table”的分配表里面，在进入一个系统调用的最后一步，会调用与eax中包含的系统调用号对应的特定服务例程：

  1. call *sys_call_table(,�x,4)  

因为分派表中的每个表项占4个字节，因此首先把系统调用号乘以4，再加上sys_call_table分配表的起始地址，然后从从这个地址单元获取指向服务例程的指针，内核就找到了要调用的服务例程。我们只要修改对应的分配表项，即可实现系统调用的拦截。

获取sys_call_table的地址

网上介绍了很多种方法得到sys_call_table的地址，我使用了相对简单的一种方法——从内核导出的符号表中获取。

http://img.blog.csdn.net/20130913165306375?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvdTAxMTkyMzc0Nw==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast(Linux 3.2.0)" />

图中，十六进制数c15b3000即为sys_call_table的地址。同时，我们也得到了一个重要的信息，该符号对应的内存区域是只读的!

清除写保护

因为sys_call_table分配表的内存属性为只读，因此，我们要先清除对应地址的写保护。暂时使用了两种方法实现该目的：

第一种方法，修改cr0读写保护位：

  1.   
  2. unsigned int clear_and_return_cr0(void)  
  3. {  
  4.         unsigned int cr0 = 0;  
  5.         unsigned int ret;  
  6.   
  7.         asm volatile ("movl %%cr0, %�x"  
  8.                         : "=a"(cr0)  
  9.                      );  
  10.         ret = cr0;  
  11.   
  12.           
  13.         cr0 &= 0xfffeffff;  
  14.   
  15.         asm volatile ("movl %�x, %%cr0"  
  16.                         :  
  17.                         : "a"(cr0)  
  18.                      );  
  19.   
  20.         return ret;  
  21. }  
  22.   
  23.   
  24. void setback_cr0(unsigned int val)  
  25. {  
  26.         asm volatile ("movl %�x, %%cr0"  
  27.                         :  
  28.                         : "a"(val)  
  29.                      );  
  30. }  

第二种方法，设置虚拟地址对应页表项的读写属性：
  1.   
  2. int make_rw(unsigned long address)  
  3. {  
  4.         unsigned int level;  
  5.         pte_t *pte = lookup_address(address, &level);  
  6.         if (pte->pte & ~_PAGE_RW)  
  7.                 pte->pte |=  _PAGE_RW;  
  8.           
  9.         return 0;  
  10. }  
  11.   
  12.   
  13.   
  14. int make_ro(unsigned long address)  
  15. {  
  16.         unsigned int level;  
  17.         pte_t *pte = lookup_address(address, &level);  
  18.         pte->pte &= ~_PAGE_RW;  
  19.   
  20.         return 0;  
  21. }  

附：完整代码
  1. #include   
  2. #include   
  3. #include   
  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. #include   
  17. #include   
  18. #include   
  19. #include   
  20. #include   
  21. #include   
  22. #include   
  23. #include   
  24.   
  25.   
  26.   
  27.   
  28. unsigned long **sys_call_table = (unsigned long **)0xc15b3000;  
  29. unsigned long *orig_mkdir = NULL;  
  30.   
  31.   
  32.   
  33. int make_rw(unsigned long address)  
  34. {  
  35.         unsigned int level;  
  36.         pte_t *pte = lookup_address(address, &level);  
  37.         if (pte->pte & ~_PAGE_RW)  
  38.                 pte->pte |=  _PAGE_RW;  
  39.           
  40.         return 0;  
  41. }  
  42.   
  43.   
  44.   
  45. int make_ro(unsigned long address)  
  46. {  
  47.         unsigned int level;  
  48.         pte_t *pte = lookup_address(address, &level);  
  49.         pte->pte &= ~_PAGE_RW;  
  50.   
  51.         return 0;  
  52. }  
  53.   
  54.   
  55.   
  56. asmlinkage long hacked_mkdir(const char __user *pathname, int mode)  
  57. {  
  58.         printk("mkdir pathname: %s\n", pathname);  
  59.         printk(KERN_ALERT "mkdir do nothing!\n");  
  60.   
  61.         return 0;   
  62. }  
  63.   
  64.   
  65. static int syscall_init_module(void)  
  66. {  
  67.         printk(KERN_ALERT "sys_call_table: 0x%lx\n", sys_call_table);  
  68.         orig_mkdir = (unsigned long *)(sys_call_table[__NR_mkdir]);  
  69.         printk(KERN_ALERT "orig_mkdir: 0x%lx\n", orig_mkdir);  
  70.   
  71.         make_rw((unsigned long)sys_call_table);  
  72.         sys_call_table[__NR_mkdir] = (unsigned long *)hacked_mkdir;  
  73.         make_ro((unsigned long)sys_call_table);  
  74.   
  75.         return 0;  
  76. }  
  77.   
  78. static void syscall_cleanup_module(void)  
  79. {  
  80.         printk(KERN_ALERT "Module syscall unloaded.\n");  
  81.   
  82.         make_rw((unsigned long)sys_call_table);  
  83.         sys_call_table[__NR_mkdir] = (unsigned long *)orig_mkdir;   
  84.         make_ro((unsigned long)sys_call_table);  
  85. }  
  86.   
  87.   
  88. module_init(syscall_init_module);  
  89. module_exit(syscall_cleanup_module);  
  90.   
  91. MODULE_LICENSE("GPL");  
  92. MODULE_DESCRIPTION("hack syscall");  


参考：

1、《深入理解linux内核（第三版）》

2、Hijack Linux System Calls: Part III. System Call Table

喜欢

0

阅读┊ 收藏 ┊ 喜欢▼ ┊打印┊举报/Report
  

新浪BLOG意见反馈留言板　欢迎批评指正

新浪简介 | About Sina | 广告服务 | 联系我们 | 招聘信息 | 网站律师 | SINA English | 产品答疑

Copyright © 1996 - 2022 SINA Corporation, All Rights Reserved

新浪公司 版权所有