用户空间与内核空间

这样做到底有什么意义呢？好, 我们假设当一个硬件驱动试图去写数据到一个用户内存空间的程序里的时候, 它是不可以直接去完成的, 但是它可以利用一些特殊的核心函数来间接完成。同样, 当参数需要传递地址到核心函数中时,核心函数也不能直接的来读取该参数。同样的，它可以利用一些特殊的核心函数来传递参数。

这里有一些比较有用的核心函数用来作为内核区与用户区相互传递参数用。

#include<asm/segment.h>

get_user(ptr)

从用户内存获取给定的字节, 字,或者长整形。这只是一个宏（在核心代码里面有此宏的详细定义）,并且它依据参数类型来确定传输数量。所以你必须巧妙地利用它。

put_user(ptr)和get_user()非常相似, 但，它不是从用户内存读取数据，而是想用户内存写数据。

memcpy_fromfs(void *to, const void *from,unsigned long n)

从用户内存中的*from拷贝n个字节到指向核心内存的指针*to。

memcpy_tofs(void *to,const *from,unsigned long n)

从核心内存中的*from拷贝n个字节数据到用户内存中的*to。

/*译者注：这四个函数足以在2.0.x中解决内核和用户区的参数传递问题，在2.0.x以上

的版本有新的实现，即copy_user_to(...)以及copy_user_from(...)根据内核版本这些

特殊函数会有不同，请关注核心代码的实现方法。*/

系统调用

大部分的c函数库的调用都依赖于系统调用, 就是一些使用户程序可以调用的简单核心包装函数。 这些系统调用运行在内核本身或者在可加载内核模块中, 就是一些可动态的加载卸载的核心代码。

就象MS-DOS和其他许多系统一样, linux中的系统调用依赖一个给定的中断来调用多个系统调用。linux系统中,这个中断就是int 0x80。当调用'int 0x80'中断的时候,控制权就转交给了内核(或者，我们确切点地说, 交给_system_call()这个函数), 并且实际上是一个正在进行的单处理过程。

* _system_call()是如何工作的 ?

首先, 所有的寄存器被保存并且%eax寄存器全面检查系统调用表, 这张表列举了所有的系统调用和他们的地址信息。它可以通过extern void *sys_call_table[]来被访问到。 该表中的每个定义的数值和内存地址都对应每个系统调用。大家可以在/usr/include/sys/syscall.h这个头中找到系统调用的标示数。他们对应相应的SYS_systemcall名。假如一个系统调用不存在, 那么它在sys_call_table中相应的标示就为0, 并且返回一个出错信息。否则,系统调用存在并在表里相应的入口为系统调用代码的内存地址。

这儿是一个有问题的系统调用例程:

[root@plaguez kernel]# cat no1.c

#include <linux/errno.h>

#include <sys/syscall.h>

#include <errno.h>

extern void *sys_call_table[];

sc()

{ // 165这个系统调用号是不存在的。

__asm__(

"movl $165,%eax

int $0x80");

}

main()

{

errno = -sc();

perror("test of invalid syscall");

}

[root@plaguez kernel]# gcc no1.c

[root@plaguez kernel]# ./a.out

test of invalid syscall: Function not implemented

[root@plaguez kernel]# exit

系统控制权就会转向真正的系统调用, 用来完成你的请求并返回。 然后_system_call()调用_ret_from_sys_call()来检查不同的返回值, 并且最后返回到用户内存。

* libc

这int $0x80 并不是直接被用作系统调用; 更确切地是, libc函数,经常用来包装0x80中断,这样使用的。

libc通常利用_syscallX()宏来描述系统调用, X是系统调用的总参数个数。

举个例子吧, libc中的write(2)就是利用_syscall3这个系统调用宏来实现的, 因为实际的write(2)原型需要3个参数。在调用0x80中断之前，这个_syscallX宏假定系统调用的堆栈结构和要求的参数列表，最后，当_system_call()(通过int &0x80来引发)返回的时候，_syscallX()宏将会查出错误的返回值（在%eax）并且为其设置errno。

让我们看一下另一个write(2)例程并看看它是如何进行预处理的。

[root@plaguez kernel]# cat no2.c

#include <linux/types.h>

#include <linux/fs.h>

#include <sys/syscall.h>

#include <asm/unistd.h>

#include <sys/types.h>

#include <stdio.h>

#include <errno.h>

#include <fcntl.h>

#include <ctype.h>

_syscall3(ssize_t,write,int,fd,const void *,buf,size_t,count);/*构建一个write调用*/

main()

{

char *t = "this is a test.\n";

write(0, t, strlen(t));

}

[root@plaguez kernel]# gcc -E no2.c > no2.C

[root@plaguez kernel]# indent no2.C -kr

indent:no2.C:3304: Warning: old style assignment ambiguity in "=-".Assuming "= -"

[root@plaguez kernel]# tail -n 50 no2.C

#9 "no2.c" 2

ssize_t write(int fd, const void *buf, size_t count)

{

long __res;

__asm__ __volatile("int $0x80":"=a"(__res):"0"(4), "b"((long) (fd)), "c"((long) (buf)), "d"((long) (count)));

if (__res >= 0)

return (ssize_t) __res;

errno = -__res;

return -1;

};

main()

{

char *t = "this is a test.\n";

write(0, t, strlen(t));

}

[root@plaguez kernel]# exit

注意那个write()里的"0"这个参数匹配SYS_write，在/usr/include/sys/syscall.h中定义。

* 构建你自己的系统调用。

这里给出了几个构建你自己的系统调用的方法。举个例子, 你可以修改内核代码并且加入你自己的代码。一个比较简单可行的方法, 不过, 一定要被写成可加载内核模块。

没有一个代码可以象可加载内核模块那样可以当内核需要的时候被随时加载的。

我们的主要意图是需要一个很小的内核,当我们需要的时候运行insmod命令，给定的驱动就可以被自动加载。这样卸除来的lkm程序一定比在内核代码树里写代码要简单易行多了。

* 写lkm程序

一个lkm程序可以用c来很容易编写出来。它包含了大量的 #defines, 一些函数, 一个初始化模块的函数，叫做init_module()，和一个卸载函数：cleanup_module()。

这里有一个经典的lkm代码结构:

#define MODULE

#define __KERNEL__

#define __KERNE_SYSCALLS__

#include <linux/config.h>

#ifdef MODULE

#include <linux/module.h>

#include <linux/version.h>

#else

#define MOD_INC_USE_COUNT

#define MOD_DEC_USE_COUNT

#endif

#include <linux/types.h>

#include <linux/fs.h>

#include <linux/mm.h>

#include <linux/errno.h>

#include <asm/segment.h>

#include <sys/syscall.h>

#include <linux/dirent.h>

#include <asm/unistd.h>

#include <sys/types.h>

#include <stdio.h>

#include <errno.h>

#include <fcntl.h>

#include <ctype.h>

int errno;

char tmp[64];

/* 假如，我们要用到ioctl调用 */

_syscall3(int, ioctl, int, d, int, request, unsigned long, arg);

int myfunction(int parm1,char *parm2)

{

int i,j,k;

/* ... */

}

int init_module(void)

{

/* ... */

printk("\nModule loaded.\n");

return 0;

}

void cleanup_module(void)

{

/* ... */

}

检查代码中的 #defines (#define MODULE, #define __KERNEL__)和

#includes (#include <linux/config.h> ...)

一定要注意的是我们的lkm讲要被运行在内核状态,我们就不能用libc包装的函数了, 但是我们可以通过前面所讨论的_syscallX()宏来构建系统调用。

你可以这样编译你的模块'gcc -c -O3 module.c' 并且利用'insmod module.o'来加载。

提一个建议, lkm也可以用来在不完全重建核心代码的情况下来修改内核代码。举个例子, 你可以修改write系统调用让它隐藏一部分给定的文件，就象我们把我们的backdoors放到一个非常好的地方：当你无法再信任你的系统内核的时候会怎么样呢？

* 内核和系统调用后门

在简单介绍了上述理论，我们主要可以用来做什么呢。我们可以利于lkm截获一些对我们有影响的系统调用, 这样可以强制内核按照我们的方式运行。例如：我们可以利用ioctl系统调用来隐藏sniffer所造成的网卡PROMISC模式的显示。非常有效。

去改变一个给定的系统调用,只需要在你的lkm程序中增加一个定义extern void *sys_call_table[],并且利用init_module()函数来改变sys_call_table里的入口来指向我们自己的代码。改变后的调用可以做我们希望它做的一切事情, 利用改变sys_call_table来导出更多的原系统调用，并且。。。。

译者后话：这篇文章相对比较浅显易懂，所以可以作为大家入门lkm编程来用，它着重讲述了linux系统调用system call的原理，以及我们如何通过lkm来截获它并换成我们想要的代码来建立后门程序。再次强调本文的依据是linux内核版本2.0.x，大家在自己系统实现时请对比内核代码来做改变。