LIDS 工具及原理介绍

LIDS是Linux Intrusion Detection System的简写，意即Linux入侵侦察系统，是Linux内核补丁和系统管理员工具(lidsadm)，它加强了Linus内核。 它在内核中实现了一种安全模式 -- 参考模式以及内核中的强制存取控制模式(Mandatory Access Control)。

 

LIDS主要功能

* 保护：保护硬盘上任何类型的重要文件和目录，如/bin、/sbin、/usr/bin、/usr/sbin、/etc/rc.d等目录和其下的文件，以及系统中的敏感文件，如passwd和shadow文件，防止未被授权者(包括ROOT)和未被授权的程序进入，任何人包括ROOT都无法改变，文件可以隐藏。保护重要进程不被终止，任何人包括root也不能杀死进程，而且可以隐藏特定的进程。防止非法程序的RAW IO 操作，保护硬盘，包括MBR保护等等。

* 检测：集成在内核中的端口扫描器，LIDS能检测到扫描并报告系统管理员。 LIDS还可以检测到系统上任何违反规则的进程。

* 响应：来自内核的安全警告，当有人违反规则时， LIDS会在控制台显示警告信息，将非法的活动细节记录到受LIDS保护的系统log文件中。 LIDS还可以将log信息发到你的信箱中。LIDS还可以马上关闭与用户的会话。

 

Linux入侵监测系统LIDS原理

一、入侵
随着Internet上的Linux主机的增加，越来越多的安全漏洞在当前的GNU/Linux系统上发现。你也许在Internet上听说过 在Linux下发现bug，它会导致系统很容易的被黑客攻击。
因为Linux是一个开放代码的系统，漏洞很容易发现

看图之王ACDSee 6.0应用大全
数码人像照片矢量化及艺术处理

六天学会Visual Basic数据库编程
解析“震荡波”恶性蠕虫病毒

，并且也会很快的有补丁出来。但是当漏洞没有公布的时候，并且管理员很懒，没有去打补丁。黑客就会很容易的攻击这个系统，取得root权限，在现有的GNU/Linux下，他就可以做任何他想做的事情。现在你可以问，我们现在到底可以做些什么呢？
1.1 现在的GNU/Linux错误在哪里？
超级用户会滥用职权，他能够做所有他要做的事情。作为root。他会改变所有的东西。
许多系统文件很容易被更改。这些文件可能是很重要的文件，如/bin/login，如果一个黑客进入，他可以上传一个login程序来覆盖/bin/login，这样他就可以不用登陆名和密码来登陆系统。但是这些文件不需要经常改动，除非你要升级系统。
模块modules很容易用来中断内核。模块是为了让Linux内核更模块话和更高效而设计的。但是当模块加入到内核，它就会成为内核的一部分并且能做原始内核能做的工作。因此，一些不友好的代码可以写成模块来加入到内核里，这些代码就会重定向系统调用并且作为一个病毒来运行。
进程是不受保护的，一些进程，如后台的web服务器，一直都认为是没有严格保护的程序。因此，他们就会很容易被黑客攻击。
1.2 LIDS的设想是什么。
保护重要文件。因为文件很容易被root更改，为什么不严格文件操作呢？因此，LIDS改变了文件系统在内核里的安全系统调用。如果某个时候一些人访问一个文件，他就会进入系统调用然后我们就可以检查文件名并且看她们是否被保护。如果它已经被保护，我们就可以拒绝这个访问者的要求。
保护重要的进程。这个和上面的保护进程的想法不是一样的。当一个系统里运行一个进程，它会在/proc 文件系统里有一个用pid作为路径名的入口。所以，如果你用“ps –axf”你就可以显示出当前运行的进程。你可以问如果保护这些进程。如果你要杀死一个进程的话，首先，你键入“ps”来得到进程的PID，然后，你键入“kill 〈pid〉”来杀死它。但是，如果我不让你看到进程，你怎么来杀死这个进程呢？因此，LIDS是用隐藏进程来保护它的。
另外一个重要的方法就是不让任何人可以杀死进程，包括root用户。LIDS能够保护父进程是init（pid=1）的所有进程 。
封装内核。有时候我们需要要把一些必要的模块加入到内核里来使用，另外，我们也要拒绝任何人包括root用户向内核插入模块。那么如何来平衡这个矛盾的问题呢？我们可以只允许在系统启动的时候插入模块，然后我们封装模块，在封装后，内核不允许任何人插入模块到内核里。通过这种封装功能，我们能用它来保护重要的文件，进程，我们可以在系统启动的时候只允许必要的进程，只改变必要的文件。在封装内核后，我们就不能在对文件有任何的修改。

二、保护文件系统
2.1 保护文件系统是LIDS的重要功能之一。这个功能是在内核的VFS（虚拟文件系统）层实现的，我们可以保护任何种类的文件系统，如EXT2，FAT。
在LIDS，保护的文件按种类分为以下几种：
只读的文件或目录。只读文件意味着它们不被允许改写，如，在目录/usr/bin，/sbin。这些类型的文件大多数都是二进制系统程序或是系统配置文件，除了在升级系统的时候，我们不需要改变它们。
只可增加文件或目录。这些文件是那些只可以增加大小的文件。大多数是系统的日值文件，如在/var/log里的只可增加文件。
额外的文件或目录，这些文件没有被保护。一般来说，你想要保护目录下的所有文件，但是，还需要有一些特殊的文件不要被保护。所以我们可以定义这些文件作为额外的其他的只读文件。
保护挂载或卸载文件系统。当你在启动的时候挂载文件系统的时候，你可以禁止所有人，甚至是root，去卸载文件系统。你也可以禁止任何人在当前文件系统下挂载文件系统来覆盖它。
2.2 LIDS如何在内核保护文件
在这部分，我们会看到一些内核的代码来理解LIDS是如何保护文件的。
Linux文件系统数据结构程序
首先，我们必须了解Linux的虚拟文件系统。
在Linux里的每一个文件，不管是什么样子的，都有一个结点inode数，文件系统提供了以下数据结构。

在/usr/src/Linux/include/Linux/fs.h
struct inode {
struct list_head i_hash;
struct list_head i_list;
struct list_head i_dentry;
unsigned long i_ino; ----> inode number.
unsigned int i_count;
kdev_t i_dev; ----> device number.
umode_t i_mode;
nlink_t i_nlink;
uid_t i_uid;
......
}

注意：用来鉴定一个结点inode。这个意思是你可以用一对来得到一个系统里独一无二的inode。

在/ur/src/Linux/cinclude/Linux/dcache.h里
struct dentry {
int d_count;
unsigned int d_flags;
struct inode * d_inode; /* Where the name belongs to - NULL is negative */
struct dentry * d_parent; /* parent directory */
struct dentry * d_mounts; /* mount information */
struct dentry * d_covers;
struct list_head d_hash; /* lookup hash list */
struct list_head d_lru; /* d_count = 0 LRU list */
struct list_head d_child; /* child of parent list */
struct list_head d_subdirs; /* our
......
}

dentry是一个目录文件的入口。通过这个入口，我们可以很容易的在文件的父目录下移动。
例如，如果你一文件的inode是(struct inode*)file_inode，如果你可以用file_inode->d_entry来得到它的目录入口并且用file_inode->d_entry->d_parent来得到父目录的目录入口。

LIDS保护数据结构
在分析完Linux文件系统后，让我们来看看LIDS是如何容VFS来保护文件和目录的。

在/usr/src/Linux/fs/lids.c
struct secure_ino {
unsigned long int ino; /* the inode number */
kdev_t dev; /* the dev number */
int type; /* the file type */
};

上面的结构用一对来存储保护文件或目录的结点。“type”是用来标明保护结点文件类型的。
LIDS有4种类型
在/usr/src/Linux/include/Linux/fs.h
#define LIDS_APPEND 1 /* APPEND ONLY FILE */
#define LIDS_READONLY 2 /* Read Only File */
#define LIDS_DEVICE 3 /* Protect MBR Writing to device */
#define LIDS_IGNORE 4 /* Ignore the protection */
通过secure_ino结构，我们能很容易的初使化保护的文件或是在内核里执行以下函数。

在/usr/src/Linux/fs/lids.c
int lids_add_inode(unsigned long int inode ,kdev_t dev , int type)
{
if ( last_secure == (LIDS_MAX_INODE-1))
return 0;
secure[last_secure].ino = inode;
secure[last_secure].dev = dev;
secure[last_secure].type = type;
secure[++last_secure].ino = 0;
#ifdef VFS_SECURITY_DEBUG
printk("lids_add_inode : return %d
",last_secure);
#endif
return last_secure;
}

就象你在上面代码上可以看到的，给secure_ino加到一个结点上是非常容易的。被保护的结点会在系统启动的时候初使化。初使化程序在/usr/src/Linux/fs/lids.c的init_vfs_security()里。
现在，让我们看看LIDS是如何来检查是否一个结点已经受到保护。

在/usr/src/Linux/fs/open.c
int do_truncate(struct dentry *dentry, unsigned long length)
{
struct inode *inode = dentry->d_inode;
int error;
struct iattr newattrs;
/* Not pretty: "inode->i_size" shouldnt really be "off_t". But it is. */
if ((off_t) length < 0)
return -EINVAL;
#ifdef CONFIG_LIDS
if (lids_load && lids_local_load) {
error = lids_check_base(dentry,LIDS_READONLY);
if (error) {
lids_security_alert("Try to truncate a protected file (dev %d %d,inode %ld)",
MAJOR(dentry->d_inode-&gt;i_dev),
MINOR(dentry-&gt;d_inode-&gt;i_dev),
dentry-&gt;d_inode-&gt;i_ino);
.....................

这个是LIDS加到内核里做检测的一个例子。你会看到lids_check_base()是LIDS保护方法的一个核心函数。
你可以在LIDS要保护的地方看到很多LIDS保护方法用到lids_check_base()函数，特别是在Linux内核的子目录下。

在/usr/src/Linux/fs/lids.c
int lids_check_base(struct dentry *base, int flag)
{
..................
inode = base-&gt;d_inode; /* get the inode number */
parent = base-&gt;d_parent; /* get the parent diretory */
.................
----&gt; do {
if ( inode == parent-&gt;d_inode)
break;
if ((retval = lids_search_inode(inode))) {
if ( retval == LIDS_IGNORE ||
(retval == LIDS_DEVICE && flag != LIDS_DEVICE))
break;
if ( flag == LIDS_READONLY ||
( flag == LIDS_APPEND && retval &gt;flag ) ||
( flag == LIDS_DEVICE && flag == retval )) {
return -EROFS;
}
break;
}
inode = parent-&gt;d_inode;
} while( ((parent = parent-&gt;d_parent ) != NULL) );
return 0;
}
lids_check_base()会检查一个给定文件的dentry和它的父目录是否被保护。

注意：如果它的父目录被保护，它下面的文件也会被保护。
例如，如果“/etc/”被保护，“/etc/passwd”也一样被保护。

在内核保护系统调用
为了保护系统，LIDS会在一些检查临界的系统调用的时候做检查。因此，我们可以保护系统调用和限制文件系统的用户调用。
这些是一些例子，
open(),open是通过禁止一些权利来保护文件的打开。 你可以在打开调用open_namei()调用的时候LIDS在检测它。
mknod(),mknod是用来在指定目录下保护mknod。
unlink(), 在内核代码检查do_unlink()。
三、保护设备
Linux的设备会在/dev/目录下以文件的形式列出，我们可以用上面保护文件的方法来保护设备。但是在一些情况下，用户也可以用IO操作来旁路文件系统来读写设备，我们必须注意这个问题。
3.1 设备，内核I/O
在GNU/Linux系统下的设备会以文件的形式表达，所以我们可以用保护文件系统那样来保护设备。
用户的I/O访问是通过系统调用sys_operm和sys_iopl来实现的。你可以看看/usr/src/Linux/arch/i386/kernel/ioport.。这个是要基于系统结构的，要是到其他平台，就需要注意它们的变化。
3.2 如何用LIDS来保护
大多数情况下，程序不需要通过在/dev的设备文件名称来访问设备。但是，一些特殊的程序需要直接访问，如X Server,这个会写到/dev/mem和甚至是I/O设备。我们需要一些额外的东西来保护设备。LIDS会在配置内核的时候来定义这个功能。
CONFIG_LIDS_ALLOW_DEV_MEM,如果你选择了开启这个功能，你就可以允许一些特殊程序来访问/dev/men和/dev/kmen这些内核临界的设备。如果你想要用内核的X Server，选择这个功能就会在配置内核的时候提供整个路径和文件名。
CONFIG_LIDS_ALLOW_RAW_DISKS，如果选择这个开启，你就可以允许一些特殊的程序来访问物理磁盘。
CONFIG_LIDS_ALLOW_IO_PORTS，如果你选择了开启这个功能，你就可以允许一些特殊的程序来访I/O端口。
当系统运行fs/lids.c里的init_vfs_security()的时候初使化就被调用。

#ifdef CONFIG_LIDS_ALLOW_DEV_MEM
lids_fill_table(allow_dev_mem,&last_dev_mem,LIDS_MAX_ALLOWED,CONFIG_LIDS_DEV_MEM_PROGS);
#endif
#ifdef CONFIG_LIDS_ALLOW_RAW_DISKS
lids_fill_table(allow_raw_disks,&last_raw_disks,LIDS_MAX_ALLOWED,CONFIG_LIDS_RAW_DISKS_PROGS);
#endif
#ifdef CONFIG_LIDS_ALLOW_IO_PORTS
lids_fill_table(allow_io_ports,&last_io_ports,LIDS_MAX_ALLOWED,CONFIG_LIDS_IO_PORTS_PROGS);
#endif

如果一个进程或是程序要直接访问ip端口或是磁盘设备，LIDS就会检查它在数组 allow_raw_disk,last_io_ports,等）。这个检查是通过调用lids_check_base()里的lids_search_inode(inode)来实现的。
如，让我们看看CONFIG_LIDS_ALLOW_DEV_MEM

/* in lids_search_inode() */
#ifdef CONFIG_LIDS_ALLOW_DEV_MEM
for( i = 0 ; i < last_dev_mem ;i++ ) {
if ( allow_dev_mem[i].ino == ino && allow_dev_mem[i].dev == dev) {
return LIDS_READONLY;
}
}
#endif
#ifdef CONFIG_LIDS_ALLOW_RAW_DISKS

在allow_dev_mem包括了哪一个程序结点在系统启动的时候在init_vfs_security()里初使化。用同样的方法，除了一些特殊程序，我们可以保护设备，I/O访问等等。
四、保护重要进程
进程是操作系统的动态入口。内核里有两个特殊进程，进程ID 0 （swapd） 和进程ID 1（init）。Init进程是在系统启动的时候所有进程的父进程。
4.1 不可杀死的进程。
就象你可以看到是否有人要夺得root特权一样，我们可以很容易的杀死那些该内核发送特别信号的进程。为了杀死一个进程，你必须得到进程的ID，然后用kill命令来杀死它。
系统杀死进程的调用是kill，是在内核里的sys_kill()命令里的调用。
让我们看看LIDS的保护代码

在/usr/src/Linux/kernel/signal.c里
asmlinkage int
sys_kill(int pid, int sig)
{
struct siginfo info;
#ifdef CONFIG_LIDS_INIT_CHILDREN_LOCK pid_t this_pid;
int i;
#ifdef CONFIG_LIDS_ALLOW_KILL_INIT_CHILDREN
if (!(current->flags & PF_KILLINITC))
#endif
if (lids_load && lids_local_load && LIDS_FISSET(lids_flags,LIDS_FLAGS_LOCK_INIT_CHILDREN)) {
this_pid = pid&gt;0?pid:-pid;
for(i=0;i if( this_pid == lids_protected_pid[i]) {
lids_security_alert("Try to kill pid=%d,sig=%d
",pid,sig);
return -EPERM;
}
}
}
#endif
...
}
你可以在内核里看到两个标签，,CONFIG_LIDS_INIT_CHILDREN_LOCK 和CONFIG_LIDS_ALLOW_KILL_INIT_CHILDREN.

在CONFIG_LIDS_INIT_CHILDREN_LOCK的开启状态，LIDS能保护初使的运行程序。如，如果你在系统里运行inetd程序，你可以在隐藏内核前运行它，然后，你还可以杀死它。但是一些人如果telnet到你的机器，inetd就会创造子进程来为用户服务，这个子进程不会被LIDS保护，因为用户在任何时候退出和杀死程序。

4.2 隐藏进程
另外一个保护进程的方法就是隐藏进程。当一个黑客危机你的系统。他会登陆，然后会看看有没有一些已知的进程在监视它。然后他就杀死它。如果你隐藏了这个功能的进程，黑客就不会知道进程的所有情况并且你可以记录他在你系统上做的任何事情。
如何隐藏进程
为了隐藏进程，你必须在配置内核的时候提供一个完全的路径名。
当内核启动的时候，LIDS会访问文件结点到一个叫proc_to_hide[]的结构里。

在include/Linux/sched.h里
#ifdef CONFIG_LIDS_HIDE_PROC
#define PF_HIDDEN 0x04000000 /* Hidden process */
#endif
/* in fs/lids.c */
#ifdef CONFIG_LIDS_HIDE_PROC
struct allowed_ino proc_to_hide[LIDS_MAX_ALLOWED];
int last_hide=0;
#endif
....
/* in fs/lids.c , init_vfs_security(),
fill up the hidden process in proc_to_hide[]
*/
#ifdef CONFIG_LIDS_HIDE_PROC
lids_fill_table(proc_to_hide,&last_hide,LIDS_MAX_ALLOWED,CONFIG_LIDS_HIDDEN_PROC_PATH);
#endif

PF_HIDDEN是否用户可以用显示进程的命令（如“ps –a”）来显示和检查进程，如果一个进程被LIDS隐藏，当他执行的时候，进程就会得到一个PF_HIDDEN的属性。然后，当系统输出系统进程信息到用户的时候，它就会可以检查当前输出进程是否有PF_HIDDEN标志。如果发现了，它就不会输出这个进程的信息。

在in fs/exec.c
int do_execve(char * filename, char ** argv, char ** envp, struct pt_regs * regs)
{
...
if (retval &gt;= 0) {
#ifdef CONFIG_LIDS_HIDE_PROC
if (lids_search_proc_to_hide(dentry-&gt;d_inode))
current-&gt;flags |= PF_HIDDEN;
...

因为每一个Linux的进程都有一个在/proc文件系统的入口，我们为了隐藏进程也需要修改proc的文件入口。

在fs/proc/root.c
static struct dentry *proc_root_lookup(struct inode * dir, struct dentry * dentry)
{
...
inode = NULL;
#ifdef CONFIG_LIDS_HIDE_PROC
if ( pid && p && (! ((p-&gt;flags & PF_HIDDEN) && lids_load && lids_local_load)) ) {
#else
if (pid && p) {
#endif
unsigned long ino = (pid &gt;&gt; 16) + PROC_PID_INO;
inode = proc_get_inode(dir-&gt;i_sb, ino, &proc_pid);
if (!inode)
return ERR_PTR(-EINVAL);
inode-&gt;i_flags|=S_IMMUTABLE;
}
...
}

然后如果进程被PF_HIDDEN标记，它就不会在proc文件系统里显示。

五．密封内核

看图之王ACDSee 6.0应用大全
数码人像照片矢量化及艺术处理

六天学会Visual Basic数据库编程
解析“震荡波”恶性蠕虫病毒

我们需要在系统启动的时候做一些必要的操作，但是我们也需要在系统运行的时候保护它们。

例如，我们需要象内核里插入一些需要的模块，但是我们不希望在系统运行的时候插入任何模块，因为那样会十分危险。如何解决这个问题呢？这里就有一些密封的方法。我们可以在系统启动的时候做我们任何想做的事情，然后我们就密封内核。然后，我们就不能做那些以前在没有密封的时候可以做的事情。用密封的方法，我们可以用模块来解决问题，我们可以在密封前向内核里插入我们想要的模块，在密封后我们就不可以在内核里插入或是删除任何模块。

5.1 用LIDS密封内核

为了密封内核，我们可以用下面的LIDS命令

#lidsadm –I -- -CAP_xxx….

它们可以放到脚本里让系统启动的时候就执行它。具体你们可以看我以前在linuxbyte和chinabyte发表的文章。LIDS是通过/proc/sys/lids/locks和内核通讯的。

当你密封了内核，lidsadm是调用lidsadm.c的lids_init()的调用。

#define LIDS_LOCKS "/proc/sys/lids/locks"
......
void lids_init(int optind, int argc, char *argv[])
{
......
if ((fd=open(LIDS_LOCKS,O_RDWR)) == -1) {
perror("open");
exit_error (2, "cant open " LIDS_LOCKS);
}
if (read(fd,&locks,sizeof(lids_locks_t))==-1) {
perror("read");
exit_error (2, "cant read " LIDS_LOCKS);
}

lids_set_caps(optind,argc,argv,&locks);

locks.magic1=LIDS_MAGIC_1;
.........

if (write(fd,&locks,sizeof(lids_locks_t))==-1) {
perror("write");
exit_error (2, "cant write " LIDS_LOCKS);
}
.....
}

这个系统调用在LIDS_LOCKS生成新的变量loks，内核会通过lids_proc_locks_sysctl()命令来读取它。Lids_proc_locks_sysctl也会从用户区完全检查并读取它，然后改变密封的变量lids_first_time为0。

 

让我们看看lids_proc_locks_sysctl().这个函数会在用户读写/proc/sys/lids/locks的时候调用。

int lids_proc_locks_sysctl(ctl_table *table, int write, struct file *filp,
void *buffer, size_t *lenp, int conv, int op)
{
...........

/* first: check the terminal and the program which access the sysctl */

#ifndef CONFIG_LIDS_REMOTE_SWITCH
if (current-&gt;tty && (current-&gt;tty-&gt;driver.type != 2) ) {
lids_security_alert("Try to %s locks sysctl (unauthorized terminal)",
write ? "write" : "read");
return -EPERM;
}
#endif
........
/* second: check wether it is not a timeout period after two many failed attempts */

.......
if (write) {
/* Third : check what is submitted (size, magics, passwd) */
if (*lenp != sizeof(lids_locks_t)) {
lids_security_alert("Try to feed locks sysctl with garbage");
return -EINVAL;
}
if (copy_from_user(&locks,buffer,sizeof(lids_locks_t)))
return -EFAULT;
.......
if ((lids_first_time) && (!locks.passwd[0])) {
.........
number_failed=0;
if (lids_process_flags(locks.flags)) {
cap_bset=locks.cap_bset;
lids_security_alert("Changed: cap_bset=0x%x lids_flags=0x%x",cap_t(cap_bset),lids_flags);
}
Change flag here ..--&gt; lids_first_time=0;
.....
}

上面的函数会在密封内核或是改变内核安全级别的时候工作。变量lids_first_time是一个表明当前密封状态的的一个标志。当改变了需要的使能位，这个标志就会置1表明当前的状态是“密封后“。

密封内核有两个任务，首先，改变使能位，然后，改变lids_first_time标志为1。在密封后，系统就不允许改变它们了，除非你用lidsadm和密码。

在密封前保护程序

因为在密封前的状态是危险的，我们必须知道在密封前那些运行的程序是LIDS来保护的。为什么呢？因为密封后我们就不能改变它们了。如果文件没有被保护，一些人就可以改变他们然后重新启动，这些程序可能对系统非常危险。让我们来看看在没有密封前一个运行的非保护程序的代码。

int do_execve(char * filename, char ** argv, char ** envp, struct pt_regs * regs)
{
..........

#ifdef CONFIG_LIDS_SA_EXEC_UP
if (lids_first_time && lids_load) {
if (!lids_check_base(dentry,LIDS_READONLY))
#ifdef CONFIG_LIDS_NO_EXEC_UP
lids_security_alert("Try to exec unprotected program %s before sealing LIDS",filename);
if (dentry)
dput(dentry);
return -EPERM;
#else
lids_security_alert("Execed unprotected program %s before sealing LIDS",filename);
#endif
}
}
#endif
......
}

你会看到当LIDS保护系统开启（lids_load==1）和当前系统没有密封（lids_firest_time 为1）的时候，内核就会检查当前程序是否在LIDS的lids_check_base()保护下。如果没有被保护，它就会启动报警信息。

六．LIDS与Capability

Capability是一套来表明一个进程可以做为什么的位标志。在LIDS，我们可以用capability的限制来限制所有的进程。

在/include/linux/capability.h

typedef struct __user_cap_header_struct {
__u32 version;
int pid;
} *cap_user_header_t;

typedef struct __user_cap_data_struct {
__u32 effective;
__u32 permitted;
__u32 inheritable;
} *cap_user_data_t;

#ifdef __KERNEL__

/* #define STRICT_CAP_T_TYPECHE

#ifdef STRICT_CAP_T_TYPECHECKS

typedef struct kernel_cap_struct {
__u32 cap;
} kernel_cap_t;

#else

typedef __u32 kernel_cap_t;

#endif

kernel_cap_t cap_bset = CAP_FULL_SET;

在kernel_ap_t的每一位都代表一个许可。Cap_bset是capability集的主要部分。它们的值可以通过改变/proc/sys/kernel/cap-bound来改变。

看看上面的文件，你就会发现一些问题。

/* in include/linux/capability.h */

/* In a system with the [_POSIX_CHOWN_RESTRICTED] option defined, this
overrides the restriction of changing file ownership and group
ownership. */

#define CAP_CHOWN 0

/* Override all DAC access, including ACL execute access if
[_POSIX_ACL] is defined. Excluding DAC access covered by
CAP_LINUX_IMMUTABLE. */

#define CAP_DAC_OVERRIDE 1

/* Overrides all DAC restrictions regarding read and search on files
and directories, including ACL restrictions if [_POSIX_ACL] is
defined. Excluding DAC access covered by CAP_LINUX_IMMUTABLE. */

#define CAP_DAC_READ_SEARCH 2
.........

每一个任务（进程）在结构task_struct定义了三个成员：cap_effective,cap_inheritable,cap_permitted.我们已经有了一个用来表明基本capability的变量cap_bset。它们会检测这个系统并确定那种capability用来控制系统。

在内核实现的大部分系统调用会调用函数capable() (在kernel/sched.c)。然后会调用cap_raised() (在/include/linux/capability.h)。如下：

#ifdef CONFIG_LIDS_ALLOW_SWITCH
#define cap_raised(c, flag) ((cap_t(c) & CAP_TO_MASK(flag)) && ((CAP_TO_MASK(flag) & cap_bset) || (!lids_load) || (!lids_local_load)))
#else
#define cap_raised(c, flag) (cap_t(c) & CAP_TO_MASK(flag) & cap_bset)
#endif

你会看到这里的cap_bset(一般默认都是1)是很重要的。如果有人在那里把一些位置0，capability就可以会禁止整个系统。如，18 位的CAP_SYS_CHROOT, 如果我们把他置0，表明我们就不能用chroot（）了。

如果你看到sys_chroot的源代码，你就发现很多问题了：

if (!capable(CAP_SYS_CHROOT)) {
goto dput_and_out;
}
capable()会返回0，在位18为0，这样chroot就会给用户返回一个错误信息。

6.2．在LIDS里的capability

LIDS用capability来限制整个动作进程。LIDS用的函数是capable（）。在内核代码中已经存在的许多capable（）里。我们可以禁止一些当前系统默认的capability并且在用户违反LIDS定义的规则的时候报警。

至于管理员，他们也可以用lidsadm和密码来改变capability。当内核授权用户的时候，capability变量cap_bset 就会改变。

作为管理员一个需要理解的重要东西是每一个capability的意思。然后，在密封内核的时候禁止capability，并用密码来改变它们。

七．LIDS在内核中的安全级别

一些时候，我们需要改变保护系统的配置。那样我们该怎么做呢？LIDS给我们提供了两种方法。

我们可以重新启动系统，在LILO：里键入security=0.
我们可以在用lidsadm –S中用密码来转换安全级别。

7.1 在内核中的两个安全级别

LIDS在内核中定义了两个安全级别，安全的security和无安全的none_security.默认情况下，是设置成安全的级别。如果你需要改变它。就在启动的时候键入security=0.

在内核中有一个全局变量lids_load。它表明是否lids的安全变量security被开启。它默认是1。如果在系统启动的时候在LILO：键入security=0 ，所有的LIDS的保护都会失效，就象那些没有LIDS保护的系统一样。

/* variant defined in fs/lids.c */
int lids_reload_conf=0;
int lids_load=0; /* it is raised to 1 when kernel boot */
int lids_local_on=1;
int lids_local_pid=0;

/* in init/main.c */
#ifdef CONFIG_LIDS
/*
* lids_setup , read lids info from the kernel.
*/
static void __init lids_setup(char *str, int *ints)
{
if (ints[0] &gt; 0 && ints[1] &gt;= 0)
====&gt; _lids_load= ints[1];
}
#endif
....
/* init the LIDS when the system bootup up */

static void __init do_basic_setup(void)
{
......
/* Mount the root filesystem.. */
mount_root();

#ifdef CONFIG_LIDS
/* init the ids file system */
---&gt; lids_load=_lids_load;
lids_local_on=_lids_load;
lids_flags=lids_load * (LIDS_FLAGS_LIDS_ON | LIDS_FLAGS_LIDS_LOCAL_ON);
===&gt; printk("Linux Intrusion Detection System %s \n",lids_load==1?"starts":"stops");
init_vfs_security();
#endif
......
}

在系统启动的时候，你可以看到”Linux Intrusion Detection System 0.9 starts”,表明LIDS的保护开启了。当保护停止的时候，你可以看到”Linux Intrusion Detection System 0.9 stops”。这里的0.9是当前的LIDS版本号。

7.2 用lidsadm来改变系统安全级别

一些时候，有也可以在线的时候改变你的安全级别，你必须把CONFIG_LIDS_ALLOW_SWITCH功能开启。并且在编译前配置内核的时候提供一个RipeMD-160 encrypted password 。

这个密码可以用lidsadm –p 命令来获得

用内核鉴定

用提供的密码，LIDS可以鉴定用户来区分哪个用户可以转换内核的安全级别。

这个功能也要用到lidsadm的-S参数。如。
# /sbin/lidsadm -S -- -LIDS
SWITCH
Password:xxxxxx
#

在输入密码后，我们就可以转换LIDS的安全关闭。

让我们看看内部的编码来了解它是如何工作的，
/* in the fs/lids.c lids_proc_locks_sysctl() */
int lids_proc_locks_sysctl(ctl_table *table, int write, struct file *filp,
void *buffer, size_t *lenp, int conv, int op)
{
lids_locks_t locks;
byte hashcode[RMDsize/8];
char rmd160sig[170];
.......
locks.passwd[sizeof(passwd_t)-1]=0; /* We dont take the risk */
rmd160sig[0]=0;

#ifdef CONFIG_LIDS_ALLOW_SWITCH
if ((!lids_first_time) || (locks.passwd[0])) {
RMD((byte *)locks.passwd,hashcode);
memset((char *)locks.passwd,\,sizeof(passwd_t));
for (i=0; i sprintf(rmd160sig+2*i,"%02x", hashcode[i]);
}
if ( ((lids_first_time) && (!locks.passwd[0])) ||
----------&gt; (!strncmp(rmd160sig,CONFIG_LIDS_RMD160_PASSWD,160)) ) {
#else
if ((lids_first_time) && (!locks.passwd[0])) {
#endif
/* access granted ! */
number_failed=0;
if (lids_process_flags(locks.flags)) {
cap_bset=locks.cap_bset;
lids_security_alert("Changed: cap_bset=0x%x lids_flags=0x%x",cap_t(cap_bset),lids_flags);
}
lids_first_time=0;
}
........
}

在密码检查正确后。Lids_process_flag()就会改变当前的lids标记为关闭状态，然后你就可以在不受保护的系统做你想要做的事情了。你可以看看fs/lids.c的lids_process_flag的代码来了解它。

转换LIDS和LIDA_GLOBAL

如果你把LIDS的保护关闭，你会有两个结果，一，关闭后其它没有被LIDS保护的控制台一样不受保护，二，可以本地的关闭它们，在其它的控制台，所有的系统依然被LIDS保护。它们一样很安全。

这些细节是fs/lids的lids_process_flag()来实现。

八．内核的网络安全

用LIDS，你可以用下面的功能来保护你的网络。

8.1 保护防火墙和路由的规则
如果你的主机包含一些防火墙规则。你可以用LIDS来保护它们。你可以开启
CONFIG_LIDS_ALLOW_CHANGE_ROUTESLAI 实现这个功能。你也必须在密封内核的时候关闭CAP_NET_ADMIN。

然后，你也可以允许程序更改路由规则。

让我们来看看保护防火墙规则的代码吧。每一个改变防火墙的请求都会调用内核的ip_setsockopt()函数。

int ip_setsockopt(struct sock *sk, int level, int optname, char *optval, int optlen)
{
........
switch(optname)
{
.......
case IP_FW_DELETE_NUM:
case IP_FW_INSERT:
case IP_FW_FLUSH:
case IP_FW_ZERO:
case IP_FW_CHECK:
case IP_FW_CREATECHAIN:
case IP_FW_DELETECHAIN:
case IP_FW_POLICY:
#ifdef CONFIG_LIDS_ALLOW_CHANGE_ROUTES
if (!(capable(CAP_NET_ADMIN) || (current-&gt;flags & PF_CHROUTES))) {
#else
if (!capable(CAP_NET_ADMIN)) {
#endif
#ifdef CONFIG_LIDS
lids_security_alert("CAP_NET_ADMIN violation: try to change IP firewall rules with option %d",optname);
#endif
return -EACCES;
}
........

从上面的代码，我们可以看到如果有人要改变防火墙的规则，你必须把CAP_NET_ADMIN开启，并且你要修改规则的程序必须用routing_changeable来标记。

8.2 禁止嗅探

这个功能也是在上面的changing_route来实现的。让我们来看看net/core/dev.c的代码。

int dev_ioctl(unsigned int cmd, void *arg)
{
........
switch(cmd)
{
........
case SIOCSIFMETRIC:
case SIOCSIFMTU:
case SIOCSIFMAP:
case SIOCSIFHWADDR:
case SIOCSIFSLAVE:
case SIOCADDMULTI:
case SIOCDELMULTI:
case SIOCSIFHWBROADCAST:
case SIOCSIFTXQLEN:
case SIOCSIFNAME:
#ifdef CONFIG_LIDS_ALLOW_CHANGE_ROUTES
if (!(capable(CAP_NET_ADMIN) || (current-&gt;flags & PF_CHROUTES))) {
#else
if (!capable(CAP_NET_ADMIN)) {
#endif
#ifdef CONFIG_LIDS
lids_security_alert("CAP_NET_ADMIN violation: ioctl SIOC #%i",cmd);
#endif
return -EPERM;
.........

你能发现，如果你要为嗅探改变状态的话， 你必须让CAP_NET_ADMIN开启来实现这个功能。你可以在内核密封前启动CAP_NET_ADMIN，然后在内核密封后禁止它。

8.3 内核的检测端口扫描的功能

为什么要在内核里需要一个端口扫描的检测？

因为一个端口扫描的时候能检测到半连接的扫描。所以，端口扫描检测需要作为一个嗅探的程序来运行。如果我们需要检测端口扫描。我们又要开启允许嗅探程序的运行，在内核中的端口扫描检测很有用处。

端口扫描的主要思想是在一段短的时间内扫描一个范围的端口，然后，它们会在扫描后记录那些端口是开放的。用这个方法，扫描器就可以检测到远端的机器开放了什么端口。在内核里，我们能发现下面的代码。

内核中的端口扫描检测

让我们看看tcp的端口扫描

/* in net/ipv4/tcp_ipv4.c */

int tcp_v4_rcv(struct sk_buff *skb, unsigned short len)
{
........
__skb_queue_tail(&sk-&gt;back_log, skb);
return 0;

no_tcp_socket:

#ifdef CONFIG_LIDS
lids_check_scan(skb-&gt;nh.iph-&gt;saddr,ntohs(th-&gt;dest));
#endif
tcp_v4_send_reset(skb);

discard_it:

.........
}

lids_check_scan()有两个参数，一个是影响no_sock_srror的源地址，另外一个是你要通讯的机器上的端口。

Lids_check_scan()主要的任务是统计由同一个资源发出的错误信息。但是lids_check_scan()在源地址是一个端口扫描器的时候不会做检查，它会要timer来做。现在，让我们看看lids_check_scan()的代码。

/* in net/ipv4/lids_check_scan.c */
int lids_check_scan(__u32 addr,__u16 port)
{
...........
if((p = lids_find_scan(addr)) == NULL) {

p1 = &lids_scan_head;
p = (struct lids_scan*)kmalloc(sizeof(struct lids_scan),GFP_ATOMIC);
if(p == NULL ) {
return -1;
}
while((p1-&gt;next)!=NULL)p1=p1-&gt;next;

/* init the structure. */
p1-&gt;next = p;
spin_unlock(p-&gt;lock);
p-&gt;next = NULL;
p-&gt;addr = addr;
p-&gt;counter = 0;
p-&gt;lower_counter = 0;
p-&gt;create_time = current_time;
/* init a timer to do the detect thing */
init_timer(&(p-&gt;timer));
p-&gt;timer.expires = LIDS_SCAN_TIMEOUT + current_time;
p-&gt;timer.data = (unsigned long) p;
p-&gt;timer.function = lids_proceed_scan ;
add_timer(&(p-&gt;timer));
}
/* add the counter when hit */
spin_lock(p-&gt;lock);
(p-&gt;counter)++;
/* we here defined the port < 1024 and > 1024 */
if(port < 1024)
(p->lower_counter)++;
spin_unlock(p-&gt;lock);
return 0;
}

从上面的代码，我们能看到这个函数的主要是一个列表，所以它很快。为了防止在kmalloc()的DoS的攻击，我们也需要来限制检测的列表。在这个代码里可能是错误的，但是因为记时的函数timer lids_proceed_scan能非常快的更新这个列表（每3秒一次）。所以DoS攻击很难让内核迷惑扫描源的真实性。

九．入侵响应系统

当我们检测到了一些程序违反了我们定的规则，我们必须要对它做出响应。在当前的LIDS系统，我们可以用记录的功能来记录下所有的信息。我们也可以挂起这个用户用到的控制台。然后，我们就会给LIDS加上更多的响应系统，不但是在内核里，还是在用户区。
9.1 允许用安全的方法登陆
在传统的内核登陆模式，我们每次都是用printk在控制台打印信息。但是这样很容易会被DoS攻击内核。他会让系统频繁的运行printk命令，我们可以在内核用security_alert()来实现报警响应功能。
你可以看看/include/linux/kernel.h的代码。
9.2 控制台挂起
这个功能是用安全日志来挂起那些违反LIDS定义的安全规则的人的控制台。他们要继续必须重新登陆系统。但是他们所做的一切都已经被系统日志记录下来或是用e-mail的方法发送给了管理员。
9.3 用e-mail或是传呼来报告管理员
这个功能是boidi开发的。用这个工具，我们可以很容易的知道系统什么地方出错，我们可以及时的响应入侵。