【安全】linux audit审计使用入门

auditctl -a always,exit -S execve -F key=123456
1

ausearch -k 123456
1

auditctl -w /usr/bin/tail -p x -k 123456
1

time->Sun Apr 23 15:47:36 2023
type=PROCTITLE msg=audit(1682236056.128:4318964): proctitle=7461696C002D6E0032006C756F2E7368
type=PATH msg=audit(1682236056.128:4318964): item=1 name="/lib64/ld-linux-x86-64.so.2" inode=36969 dev=08:03 mode=0100755 ouid=0 ogid=0 rdev=00:00 obj=system_u:object_r:ld_so_t:s0 objtype=NORMAL cap_fp=0000000000000000 cap_fi=0000000000000000 cap_fe=0 cap_fver=0
type=PATH msg=audit(1682236056.128:4318964): item=0 name="/usr/bin/tail" inode=100666597 dev=08:03 mode=0100755 ouid=0 ogid=0 rdev=00:00 obj=system_u:object_r:bin_t:s0 objtype=NORMAL cap_fp=0000000000000000 cap_fi=0000000000000000 cap_fe=0 cap_fver=0
type=CWD msg=audit(1682236056.128:4318964):  cwd="/root"
type=EXECVE msg=audit(1682236056.128:4318964): argc=4 a0="tail" a1="-n" a2="2" a3="luo.sh"
type=SYSCALL msg=audit(1682236056.128:4318964): arch=c000003e syscall=59 success=yes exit=0 a0=20749e0 a1=218ecd0 a2=2179ee0 a3=7fffa4a99460 items=2 ppid=58219 pid=59519 auid=0 uid=0 gid=0 euid=0 suid=0 fsuid=0 egid=0 sgid=0 fsgid=0 tty=pts1 ses=956 comm="tail" exe="/usr/bin/tail" subj=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023 key="123456"
1
2
3
4
5
6
7

#include 
#include 

using namespace std;

int main() {

    int fd = audit_open();

    audit_request_status(fd);

    struct audit_reply reply;
    audit_get_reply(fd, &reply, GET_REPLY_BLOCKING, 0);
    struct audit_status *status;
    status = reply.status;

    cout <<"auditctl -s return:" <

// /usr/src/libaudit.h
struct audit_reply {
        int                      type;
        int                      len;
        struct nlmsghdr         *nlh;
        struct audit_message     msg;

        /* Using a union to compress this structure since only one of
         * the following should be valid for any packet. */
        union {
        struct audit_status     *status;
        struct audit_rule_data  *ruledata;
        struct audit_login      *login;
        char                    *message;
        struct nlmsgerr         *error;
        struct audit_sig_info   *signal_info;
        struct daemon_conf      *conf;
#ifdef AUDIT_FEATURE_BITMAP_ALL
        struct audit_features   *features;
#endif
        };
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// include/uapi/linux/audit.h
struct audit_status {
        __u32           mask;           /* Bit mask for valid entries */
        __u32           enabled;        /* 1 = enabled, 0 = disabled */
        __u32           failure;        /* Failure-to-log action */
        __u32           pid;            /* pid of auditd process */
        __u32           rate_limit;     /* messages rate limit (per second) */
        __u32           backlog_limit;  /* waiting messages limit */
        __u32           lost;           /* messages lost */
        __u32           backlog;        /* messages waiting in queue */
        union {
                __u32   version;        /* deprecated: audit api version num */
                __u32   feature_bitmap; /* bitmap of kernel audit features */
        };
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#include 
#include 

using namespace std;

int main() {

    struct timeval t = {
        .tv_sec = 0, .tv_usec = 500000
    };

    int fd = audit_open();

    audit_request_status(fd);

    fd_set read_mask;
    FD_ZERO(&read_mask);
    FD_SET(fd, &read_mask);
    select(fd+1, &read_mask, NULL, NULL, &t);

    struct audit_reply reply;
    audit_get_reply(fd, &reply, GET_REPLY_NONBLOCKING, 0);
    struct audit_status *status;
    status = reply.status;

    cout <<"auditctl -s return:" <

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36

对于修改配置的操作，libaudit直接提供了对应的api函数，例如，设置backlog_limit，可以直接调用audit_set_backlog_limit()。

4.2 获取和修改规则

#include 
#include 

using namespace std;

int main() {

    struct timeval t = {
        .tv_sec = 0, .tv_usec = 500000
    };

    int fd = audit_open();

    do {
        audit_request_rules_list_data(fd);

        fd_set read_mask;
        FD_ZERO(&read_mask);
        FD_SET(fd, &read_mask);
        select(fd+1, &read_mask, NULL, NULL, &t);
    
        struct audit_reply reply;
        audit_get_reply(fd, &reply, GET_REPLY_NONBLOCKING, 0);
        if(reply.type == NLMSG_DONE) {
            break;
        }
        struct audit_rule_data *rules;
        rules = reply.ruledata;
    
        cout <<"auditctl -l return:" <flags) << endl;
        cout << audit_action_to_name(rules->action) << endl;
    } while(true);

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

获取规则跟获取配置的区别只是发起操作的函数和数据解析不同，获取规则使用audit_request_rules_list_data()发起操作，解析数据时则需要解析struct audit_rule_data的数组。

#include 
#include 
#include 

using namespace std;

int main() {

    int fd = audit_open();

    struct audit_rule_data *rule = new(struct audit_rule_data);

    audit_rule_syscall_data(rule, 57);

    audit_add_rule_data(fd, rule, AUDIT_FILTER_EXIT, AUDIT_NEVER);

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

上面的代码相当于auditctl -a exit,never -S execve。

#include 
#include 
#include 

using namespace std;

int main() {

    int fd = audit_open();

    struct audit_rule_data *rule = new(struct audit_rule_data);

    audit_add_watch(&rule, "/etc/passwd");

    audit_add_rule_data(fd, rule, AUDIT_FILTER_EXIT, AUDIT_ALWAYS);

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

上面的代码相当于auditctl -w /etc/passwd -p rwxa。

4.3 获取审计日志

获取升级日志还是使用netlink的方式读取：

#include 
#include 
#include 
#include 

using namespace std;

int main() {
    int audit_fd = audit_open();
    if (audit_fd < 0) {
	cout << "open audit fail:" << strerror(errno) << endl;
        return -1;
    }

    audit_set_enabled(audit_fd, 1);
    struct audit_reply audit_rep;
    int ret;
    struct timeval t = {
            .tv_sec = 5, .tv_usec = 0
        };
    pid_t cur_pid = getpid();
    ret = audit_set_pid(audit_fd, static_cast(cur_pid),
                               WAIT_NO);
    if (ret <= 0) {
        cout << "audit_set_pid fail:" << strerror(errno) << endl;
        return -1;
    }
    do {
        fd_set read_mask;
        FD_ZERO(&read_mask);
        FD_SET(audit_fd, &read_mask);
        ret = select(audit_fd + 1, &read_mask, nullptr, nullptr, &t);
        if (ret <= 0) {
            cout << "select fail:" << strerror(errno) << endl;
            continue;
        }
        ret = audit_get_reply(audit_fd, &audit_rep,
                          GET_REPLY_NONBLOCKING, 0);
        if (ret <= 0) {
            cout << "open audit fail:" << strerror(errno) << endl;
        }

        printf("%s %s", __FUNCTION__, audit_rep.msg.data);
        cout << audit_rep.msg.data << endl;
    } while(true);

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

5 audit存在的问题

如果只是正常使用audit：配置audit规则，查看审计日志，也没啥问题，但是，实际使用过程中，还是存在一些问题。

5.1 内核版本

不同版本的内核在实现机制上有所不同，因此，运行表现和参数控制上也有所不同：

• 小于3.14的内核没有提供设置backlog_wait_time的接口

5.2 审计日志过多造成的缓存队列和磁盘问题

audit_log_end将审计日志放到audit_queue的队尾，如果审计日志较多，可能会导致队列很长，占用的资源增多，因此，内核也提供了一些参数进行控制：

• backlog_limit：缓存队列长度限制
• backlog_wait_time：缓存队列满的等待时间

// audit_log_start(linux-4.19.281)
    // auditd_test_task：检查当前进程是否是audit daemon进程
    // audit_ctl_owner_current：检查当前进程是否持有audit_cmd_mutex锁
    // 因此，这里进入if的条件是：当前进程不是audit daemon进程，并且没有持有锁
	if (!(auditd_test_task(current) || audit_ctl_owner_current())) {

		// 获取audit_backlog_wait_time，就是auditctl -s中的backlog_wait_time
		long stime = audit_backlog_wait_time;

		// audit_backlog_limit就是auditctl -s中的backlog_limit，默认值是64
		// 因此，这里进入while的条件是：设置了backlog_limit，并且当前缓存队列的长度大于backlog_limit
		while (audit_backlog_limit &&
		       (skb_queue_len(&audit_queue) > audit_backlog_limit)) {
			// 唤醒kauditd处理队列中的日志
			wake_up_interruptible(&kauditd_wait);

			/* sleep if we are allowed and we haven't exhausted our
			 * backlog wait limit */
		    // 如果当前进程允许休眠，并且backlog_wait_time大于0，则进入if，backlog_wait_time默认是60s
			if (gfpflags_allow_blocking(gfp_mask) && (stime > 0)) {
				// 创建等待队列的节点
				DECLARE_WAITQUEUE(wait, current);

				// 将刚才创建的等待队列的节点wait加入到队列audit_backlog_wait中
				add_wait_queue_exclusive(&audit_backlog_wait,
							 &wait);
				set_current_state(TASK_UNINTERRUPTIBLE);

				// 让当前进程休眠一段时间
				stime = schedule_timeout(stime);

				// 将wait从audit_backlog_wait队列中移除
				remove_wait_queue(&audit_backlog_wait, &wait);
			} else {
				// 如果当前进程没有休眠，则先检查审计日志的生成速度是否超过rate_limit
				if (audit_rate_check() && printk_ratelimit())
					pr_warn("audit_backlog=%d > audit_backlog_limit=%d\n",
						skb_queue_len(&audit_queue),
						audit_backlog_limit);

				// lost自增1，并在审计日志中打印缓存队列超过限制
				audit_log_lost("backlog limit exceeded");
				return NULL;
			}
		}
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

从上面的代码可以看出，当队列长度超过backlog_limit时，内核会休眠一段时间backlog_wait_time(默认60秒)，如果backlog_limit为0，则不会休眠，而是会打印backlog limit exceeded日志。

因此，如果backlog_wait_time不为0，而日志太多时，可能导致内核频繁休眠，极端情况下，系统直接卡死。

如果要解决这个问题，可以从几个方面入手：

• 审计规则尽可能只配置必要的，防止生成大量无用的审计日志
• 根据机器配置增加backlog_limit，例如，将backlog_limit可以设置为8193或者更大
• backlog_wait_time设置为0，当日志过多时直接丢弃，防止影响日常的使用
• 审计日志的消费者尽可能快速消费日志，可能的情况下，可以增加丢弃策略，防止审计日志堆积

当审计日志过多，还会造成磁盘占用率的问题：当审计日志太多，可能会占用大量磁盘空间。

需要注意的是，即使没有配置审计规则，日志中也可能有审计日志，pam认证、服务启动等，在没有规则的情况下内核也会生成审计日志。

同时，从3.16.0开始，内核增加了多消费者，允许多个进程同时读取审计日志，那么，如果存在其他进程也读取审计然后写到日志文件的话，磁盘占用的问题又会放大，因此，对于磁盘占用的问题，可以从以下几个方面入手：

• 是否有其他进程也读取了审计日志
• 在没有配置审计规则的情况下是否也会产生大量日志

5.2 容器环境下同一个命令的日志存在差异

在容器环境下，同一个命令的日志可能存在差异，因为命令的实现有所不同，比较典型的是，有些镜像的vi是重定向到busybox，有些则是跟主机一样的二进制文件，那么他们产生的日志就不同，就会造成分析上的困难。

6 参考文档

• RHEL Audit System Reference
• 读懂audit日志
• Audit framework