v0idnetwork/cve-2026-46331pedit COW
CVE-2026-46331 (также известна как «pedit COW») — это локальная ошибка повышения привилегий в подсистеме управления трафиком ядра Linux. Непривилегированный пользователь (в непривилегированном сетевом пространстве имён) может настроить фильтр act_pedit (редактор пакетов), чтобы вызвать частичную запись с копированием при записи (COW) в кэш страниц. В результате ядро записывает подконтрольные злоумышленнику данные в образ файла в памяти без пометки страницы как приватной, повреждая кэшированную копию этого файла. Важно отметить: для эксплуатации требуется только CAP_NET_ADMIN (получаемое в пользовательском пространстве имён) и не изменяет файл на диске. На практике 17 июня 2026 года было опубликовано рабочее доказательство концепции (PoC) под названием packet_edit_meme, демонстрирующее, как перезаписать образ setuid-бинарного файла (например, /bin/su) в кэше страниц для получения root-оболочки. Уязвимость связана с некорректным расчётом диапазона COW в tcf_pedit_act() и была исправлена в апстриме (4 июня 2026) путём переноса проверки области записи внутрь цикла по ключам.
act_pedit. Незапатченные стабильные релизы (включая многие дистрибутивные ядра) уязвимы.tc pedit и перезаписывает точку входа ELF setuid-бинарного файла в памяти шелл-кодом.skb_ensure_writable() внутрь цикла по ключам). В качестве временного решения заблокируйте или выгрузите модуль act_pedit или отключите непривилегированные пользовательские пространства имён (например, sysctl user.max_user_namespaces=0). После смягчения сбросьте кэши (echo 3 > /proc/sys/vm/drop_caches), чтобы удалить отравленные страницы.Этот отчёт содержит подробный технический анализ CVE-2026-46331: её причину, эксплуатацию, обнаружение и стратегии устранения, со ссылками на уведомления производителей, CVE и публичный эксплойт.
Определение: CVE-2026-46331 — это ошибка записи за пределами границ в подсистеме Traffic Control (net/sched) ядра Linux, а именно в действии act_pedit (редактор пакетов). Функция tcf_pedit_act() вычисляет диапазон «копирования при записи» для операций редактирования пакета до итерации по типизированным ключам, используя статическую подсказку tcfp_off_max_hint. Однако некоторые ключи (например, редактирование заголовков TCP/UDP) определяют свой окончательный байтовый сдвиг только во время выполнения. Код никогда не перепроверяет возможность записи для этих динамических смещений. В результате записи могут происходить за пределами предварительно скопированного региона: часть записи пакета никогда не делается приватной, что приводит к частичному COW. Эта ошибочная запись распространяется на разделяемую память кэша страниц файла (если буферы пакетов случайно ссылаются на страницы файла), повреждая кэшированный образ файла.
Предыстория: Действие редактора пакетов (pedit) в Linux позволяет администраторам перезаписывать произвольные байты в заголовках пакетов (канального, сетевого или транспортного уровней) при прохождении пакетов через настроенный фильтр tc. Оно работает путём указания смещения (возможно, привязанного к заголовку) и 32-битного значения/маски. Внутренне pedit работает с сокетными буферами (sk_buff) и должен сделать целевую память пакета доступной для записи перед её изменением (с помощью skb_ensure_writable() в стиле COW). В идеале ядро должно клонировать (приватно копировать) любые разделяемые страницы перед записью, чтобы избежать изменения памяти, используемой в других местах.
Основная причина: В tcf_pedit_act() код ошибочно рассчитывает доступную для записи область только один раз заранее, используя tcfp_off_max_hint (максимальное статическое смещение). Эта подсказка не включает смещение заголовка времени выполнения, которое добавляют типизированные ключи при обработке пакета. Ключи, такие как TCP или UDP, могут вычислять смещение на основе положения IP-заголовка во время выполнения (например, если предыдущий ключ сместил сетевой заголовок). Таким образом, во время цикла по ключам фактическое смещение для ключа может превышать диапазон, который был предварительно выделен как доступный для записи. Затем код записывает в память пакета через skb_store_bits(), но поскольку страница за пределами предварительно скопированного региона не была сделана приватной, запись повреждает страницу, которая всё ещё разделяется с кэшем страниц. Короче говоря, «слишком ранний расчёт доступного для записи диапазона пакета» приводит к записи за границы и пересечению страниц. Отрицательные смещения (например, редактирование Ethernet-заголовков на входящем трафике) также обрабатываются некорректно, и даже offset_valid() не имел защиты от INT_MIN, усугубляя ошибку.
Почему это происходит: Эта ошибка по сути является логической ошибкой в расчёте диапазона копирования при записи. Ядро предполагало, что статическое максимальное смещение (известное во время загрузки) достаточно для всех изменений. Оно не обновляло диапазон COW, когда ключи с динамическими смещениями фактически применялись. После серии поставленных в очередь изменений финальная запись могла оказаться за пределами предварительно проверенной области. Поскольку буферы пакетов могут ссылаться на страницы файлов, отображённых в память (например, через механизмы нулевого копирования), эта «частичная COW» запись может достичь кэша страниц файла на диске. На практике действие редактора пакетов может получать страницы от sendfile или splice; таким образом, одна операция фильтра пакетов может косвенно записать выбранные злоумышленником данные в образ файла в памяти, не изменяя диск.
Компоненты и поток данных: Уязвимый код находится в подсистеме Linux net/sched (act_pedit.c). Когда пакет соответствует настроенному правилу pedit, вызывается tcf_pedit_act(). Внутренне он вызывает skb_ensure_writable(skb, X) ровно один раз, где X = tcfp_off_max_hint. Это делает первые X байт пакета приватными (COW). Затем в цикле по каждому ключу (операции редактирования) вычисляется фактическое смещение записи для ключа путём добавления смещения заголовка времени выполнения к указанному смещению ключа и записывается 32-битное значение в пакет. В псевдокоде:```c
u32 off_max = action->tcfp_off_max_hint;
skb_ensure_writable(skb, off_max);
for (i = 0; i < num_keys; i++) {
u32 hdr_off = compute_header_offset(skb, key[i].hdr_type);
u32 write_off = hdr_off + key[i].offset;
skb_store_bits(skb, write_off, &key[i].value, 4);
}
Поскольку `hdr_off` вычисляется только при обработке каждого ключа, первоначальный вызов `skb_ensure_writable()` не учитывал его. Если `hdr_off + key[i].offset` превышает `off_max`, код переключается на `skb_store_bits()` на фрагментах, а не на основной линейной области, то есть он записывает в страницу, которая не была сделана приватной. Это и есть точка отказа.
**Поверхность атаки:** Единственный необходимый интерфейс — это **tc filter** с действием `pedit`, который обычно требует возможности **CAP_NET_ADMIN**. Однако обычные пользователи могут получить CAP_NET_ADMIN в частном сетевом пространстве имен (клонирование пространства имен пользователя) без реальных привилегий. Таким образом, непривилегированный пользователь может войти в пространство пользователя+сети и создать правило `tc pedit` на loopback. Запись происходит при обработке пакета (атакующий обычно генерирует трафик на loopback для его запуска). Граница доверия (пользователь против ядра) пересекается, потому что ядро доверяло своей настройке COW, но предоставленные пользователем смещения нарушили это предположение.
**Внутренний механизм:** На стороне ядра уязвимость проявляется как **запись за пределами границ** (CWE-787). Она повреждает память ядра, отображенную в пользовательское пространство (кэш страниц файла). В частности, она может перезаписать содержимое любой страницы файла, которая оказалась отображена в буфер сокета. В proof-of-concept `/bin/su` отображается в память (mmapped) путем отправки его в буфер сокета, поэтому эксплойт переключает байты точки входа в памяти. Это не изменяет файл на диске, но любое последующее выполнение этого двоичного файла считывает отравленный образ из кэша. Анализ в блоге отмечает:
> «Поскольку skb может ссылаться на страницы с нулевым копированием, полученные через sendfile, эта запись за пределами границ может попасть в общую память кэша страниц, обеспечивающую реальный файл. Ядро считает, что оно сделало память пакета безопасной для изменения; в реальности более поздняя запись выходит за пределы области, которую оно фактически приватизировало».
**Границы доверия:** Ядро ошибочно предполагало, что `skb_ensure_writable()` (быстрый путь COW) гарантирует безопасность всех последующих записей. Оно не выполняло повторную проверку для каждого ключа. Пользователь управляет только конфигурацией фильтра пакетов и содержимым пакета; ядро предоставило это (через сетевые пространства имен). Как только это доверие было нарушено, запись вырвалась в память, связанную с файлами, которая должна была быть защищена.
## Анализ первопричины
Основная причина — **неправильный расчет диапазона COW в действии pedit**. В терминах кода одиночный вызов `skb_ensure_writable()` был выполнен с длиной на основе `tcfp_off_max_hint`, а затем внутри цикла фактические смещения могли превышать это значение. Небольшой патч (май 2026 г.) исправляет это, перемещая `skb_ensure_writable()` *внутрь* цикла, после того как становится известно истинное смещение, и добавляя проверки и специальную обработку для отрицательных смещений. Другими словами:
- **Ошибочный код:** ```c
skb_ensure_writable(skb, action->tcfp_off_max_hint);
for each key:
// compute offset (hdr_off + key_offset)
skb_store_bits(skb, write_off, ...);
Кроме того, исправление гарантирует, что для отрицательных смещений (редактирование Ethernet-заголовка) оно использует skb_cow() для запаса перед заголовком и защищает от случаев INT_MIN. Сообщение коммита (краткое описание stack.watch) гласит: «Исправление путем перемещения skb_ensure_writable() внутрь цикла по ключам, где известно фактическое смещение записи, и добавление проверки переполнения при арифметике смещений».
Таким образом, почему он существует: в ходе проверки кода или проектирования пересчет для каждого ключа был упущен. Оптимизация статических подсказок обошла необходимость повторной оценки для каждого ключа. Похоже, что это честная ошибка, а не злонамеренный недосмотр, но ее влияние серьезно, поскольку нарушает предположение COW. Как отмечает TuxCare, эта ошибка была объединена под видом обычного исправления «повреждения данных», без немедленного контекста безопасности.
Уязвимость была внесена коммитом ядра 8b796475fd78 (май 2022 г.) и оставалась незамеченной до начала 2026 года. Согласно источникам, исправление (коммит 899ee91156e5 от 31 мая 2026 г.) было отправлено в список рассылки netdev в качестве обычного патча против повреждения данных. Мейнтейнеры ядра объединили исправление (net-7.1-rc7) 4 июня 2026 года. Только 16 июня 2026 года был официально присвоен CVE-2026-46331 (примерно через две недели после появления патча). Полностью функциональный публичный эксплойт появился 17 июня 2026 года (PoC packet_edit_meme).
На практике последовательность была такова:
Множество сторон заметили ошибку благодаря открытому патчу. Например, Massimiliano Oldani (исследователь кибербезопасности) вскоре опубликовал подробное описание и эксплойт, отметив, что «публичный, рабочий proof-of-concept эксплойт под названием packet_edit_meme появился на GitHub в течение 24 часов после назначения CVE». CloudLinux, TuxCare и SentinelOne опубликовали анализы, как только PoC стал публичным и были назначены CVE. Трекер безопасности Debian и PT DBugs также обобщили проблему и доступные рекомендации (см. Ссылки).
Реалистичная атака требует минимальных предварительных условий:
Возможности атакующего: Локальный непривилегированный пользователь на целевой машине. Пользователь должен иметь возможность создать новое пространство имен пользователя с сетевым пространством имен (через unshare(CLONE_NEWUSER|CLONE_NEWNET)), что предоставляет CAP_NET_ADMIN внутри этого пространства имен без реальных привилегий root. Непривилегированные пространства имен пользователя включены по умолчанию во многих ядрах (например, RHEL, Debian) и могут быть повторно включены в Ubuntu с помощью обходного пути aa-exec.
Условия цели: Цель должна работать на уязвимом ядре Linux (приблизительно 5.18–7.1-rc6) с доступным модулем act_pedit. Если act_pedit встроен или уже загружен, он сразу же эксплуатируем. Если это модуль, он автоматически загружается при настройке правила tc pedit. Цель не должна применять патч из upstream. Примечательно, что атакующему не требуется доступ на запись к какому-либо файлу; эксплойт работает путем записи через фильтры пакетов.
Цепочка атаки:
unshare --map-root-user --net --pid bash для создания нового пространства имен пользователя+сети. Это предоставляет CAP_NET_ADMIN в этом пространстве имен (пользователь отображается как root внутри).ifconfig lo up) и, опционально, запускает слушатель (например, nc -l 127.0.0.1 9999). Это обеспечивает поток пакетов для использования в действиях TC.Воздействие: В случае успеха атакующий получает полные привилегии root локально. Эксплойт можно выполнить одной командой, и он детерминирован. Кроме того, повреждение произвольных страниц, поддерживаемых файлами, может вызвать отказ в обслуживании (сбой системы) при другом использовании. Опубликованный PoC специально перезаписал точку входа /bin/su шелл-кодом, но может быть атакован любой файл, который атакующий может отобразить. Цепочка не требует специального времени или состояния гонки и была продемонстрирована на многих дистрибутивах (RHEL, Ubuntu, Debian и т.д.).
Публичный эксплойт packet_edit_meme доступен на GitHub (sgkdev/packet_edit_meme) и нацелен на /bin/su. Мы описываем его основную логику без деструктивных полезных нагрузок:```c
/* Pseudocode outline of the exploit (simplified) /
int main() {
/ 1. Identify a setuid binary (su) and its ELF entry offset */
int fd = open("/bin/su", O_RDONLY);
long entry = elf_entry_offset(fd);
if (entry < 0) abort();
printf("Target %s (UID=%d), entry offset 0x%lx\n", "/bin/su", getuid(), entry);
/* 2. Unshare user+net namespace to get CAP_NET_ADMIN locally */
if (unshare(CLONE_NEWUSER | CLONE_NEWNET) < 0) abort();
/* Map UID/GID to root (handled via /proc/self/uid_map, /gid_map) */
// (omit details: write "0 <uid> 1" to /proc/self/uid_map and gid_map, and deny setgroups)
/* 3. Setup environment: bring up loopback and listener */
if (system("ip link set lo up") < 0) abort();
if (system("nc -l 127.0.0.1 9999 &") < 0) abort();
/* 4. Configure a tc pedit action via netlink (simplified) */
// Assume 'pedit_write' sends a packet-edit command to the kernel.
// The key offsets below are chosen such that they exceed the initial COW range.
char shellcode[/*size=48*/] = {
// (assembly for setgid(0); setuid(0); execve("/bin/sh").., padded to 36 or 48 bytes)
};
size_t total = sizeof(shellcode), sent = 0;
while (sent < total) {
int chunk = min(PEDIT_MAX_WRITE, total - sent);
/* Issue TC pedit action to write next chunk */
if (pedit_write(fd, entry + sent, &shellcode[sent], chunk) != 0) {
fprintf(stderr, "pedit_write failed\n");
exit(1);
}
sent += chunk;
}
/* 5. Trigger execution of su (in original namespace) */
execl("/bin/su", "su", NULL); // This will run the poisoned binary as root
return 0;
}
Этот псевдокод иллюстрирует поток: открыть `/bin/su`, разделить пространства имён для получения CAP_NET_ADMIN, настроить loopback и правила TC pedit, затем вызвать функцию `pedit_write(fd, offset, data, len)` (в реальном PoC она использует вызовы netlink под капотом) для перезаписи page cache цели. Наконец, бинарник выполняется, порождая root-оболочку.
Реальный PoC более сложен (обработка карт UID/GID, прослушивание сети и байты shellcode на уровне системных вызовов), но основная концепция такова. Мы подчёркиваем **не запускать этот эксплойт** кроме как в безопасной тестовой среде и не направлять его на реальные системы. Вышесказанное приведено только для демонстрации.
**Примечание:** Если бы не существовало публичного безопасного PoC, мы бы явно это указали. В данном случае PoC является публичным, и мы описываем его концептуально. Мы опустили сырые байты shellcode и фактические детали netlink для краткости и безопасности.
## Схема эксплуатации
1. **Точка входа:** Атакующий должен сначала получить CAP_NET_ADMIN. Обычно это означает создание пространства имён пользователя+сети (`unshare`) из непривилегированного процесса, что даёт локальное в пространстве имён CAP_NET_ADMIN.
2. **Начальный доступ:** Внутри этого пространства имён атакующий может использовать обычные инструменты (`ip`, `tc`) для настройки контроля трафика. Теперь путь кода `act_pedit` ядра становится доступен для пакетов.
3. **Триггер:** Атакующий настраивает `tc filter ... action pedit` на интерфейсе loopback. Этот фильтр сопоставляет пакеты (например, 0-совпадение) и указывает один или несколько **typed keys** с типами заголовков (IP, TCP) и смещениями. Смещения выбраны так, что *после того, как ядро вычислит базовый адрес заголовка внутри цикла*, окончательное смещение записи выходит за пределы начального диапазона COW.
4. **Эксплуатация:** Когда пакет, соответствующий фильтру, обрабатывается, ядро вызывает `tcf_pedit_act()`. Оно выполняет *недостаточный* `skb_ensure_writable()`, а затем перебирает ключи. По крайней мере для одного ключа запись попадает на страницу, которая *не была* клонирована в приватную копию. Это вызывает **запись за границы** в общий page cache. Если сокетный буфер был подготовлен для ссылок на страницы файла (через sendfile/splice), эта запись повреждает страницы этого файла.
5. **Пост-эксплуатация:** Shellcode атакующего был записан в pagecache целевого бинарника (например, `/bin/su`). Атакующий (в исходном пространстве имён) затем выполняет `/bin/su`. Ядро считывает образ в памяти (с внедрённой полезной нагрузкой) и запускает shellcode, предоставляя атакующему root-оболочку. На этом этапе система полностью скомпрометирована.
6. **Воздействие:** Атакующий получает привилегии root. Конфиденциальные данные могут быть перезаписаны, но не раскрыты напрямую. Целостность полностью нарушена (атакующий может изменить образ памяти любого файла). Доступность также может пострадать (неправильная запись критических страниц может привести к сбою процессов или системы). Метрики CVSS: средний общий балл (CVSS 3.1=6.0), но фактическое воздействие — локальный root с серьёзными последствиями.
Этот поток схематично резюмируется:```mermaid
flowchart LR
A[Attacker (unprivileged user)] --> B[Unshare into user+net namespace<br>(gains CAP_NET_ADMIN)]
B --> C[Configure TC pedit filter on lo]
C --> D{Packet processing by kernel}
D --> E[act_pedit computes wrong COW range]
E --> F[skb_store_bits writes beyond COW'd region]
F --> G[Page cache of target file is corrupted]
G --> H[Attacker executes poisoned setuid binary]
H --> I[Root shell obtained]
act_pedit неожиданно появляется в выводе lsmod на системах, которые обычно не используют tc pedit. (Например, lsmod | grep act_pedit даёт непустой результат на веб-серверах.)tc: Необычные команды tc или сообщения netlink от непривилегированных процессов. В журналах аудита может появиться запись о предоставлении CAP_NET_ADMIN процессу, не являющемуся root.netstat -tulnp, показывающий nc или пользовательский слушатель на 127.0.0.1, может быть признаком.tcf_pedit_act, skb_ensure_writable или мягкие блокировки при интенсивном трафике на петлевом интерфейсе, или ошибки при обработке tc. (Это необычно и указывает на повреждение.)Например, одним из IOA является повреждённые файлы в page-cache: контрольный список для триажа может включать проверку содержимого файлов в памяти по сравнению с диском, особенно для setuid-бинарников после интенсивной активности tc. Другой — создание нового пространства имён: вызовы unshare(CLONE_NEWUSER|CLONE_NEWNET) могут быть помечены. Короче говоря, защитникам следует отслеживать любое из: использование act_pedit, использование userns и внезапные изменения исполняемых файлов в оперативной памяти.
Для обнаружения попыток эксплуатации:
tc или сообщения netlink, которые добавляют фильтр act_pedit. Например, Sigma-правила могут искать события, содержащие TCA_ACT_KIND: pedit или подобное. Мониторинг журналов аудита на capset CAP_NET_ADMIN от процессов, не являющихся root, или записи в /proc/*/uid_map./bin/su (или другие чувствительные бинарники), и внезапно выполняющих их в тандеме с вызовами namespace/unshare. Срабатывание на любой процесс, который и открывает setuid-бинарник, и создаёт userns.skb_ensure_writable() (хотя известных встроенных проверок нет).Вкратце: защитникам следует регистрировать и аудировать использование пользовательских пространств имён, команды tc и загрузку модулей. Один из ключевых подходов: отклонять или регистрировать любой вызов tc pedit от недоверенных пользователей. На скомпрометированных хостах проверьте, применён ли /etc/modprobe.d/disable-act_pedit.conf (его следует применить заранее).
Установите исправления: Основное исправление — обновление ядра. Все основные дистрибутивы выпустили обновления в июне 2026 года. Обновление до исправленного ядра (Linux 7.1.0 или новее, или бэкпорты от дистрибутивов) является окончательным решением.
Изменения конфигурации: Если установка исправлений невозможна немедленно, примените меры смягчения:
act_pedit: Если ваши нагрузки не требуют tc pedit, занесите модуль в чёрный список. Например: ```
echo 'install act_pedit /bin/true' | sudo tee /etc/modprobe.d/disable-act_pedit.conf
lsmod | grep -w act_pedit && sudo rmmod act_pedit
Это гарантирует, что действие не может быть загружено. (Это рекомендуется CloudLinux и TuxCare.) Не применяйте на хостах, которые легитимно используют tc pedit.
На Ubuntu 22.04+: ``` sudo sysctl -w kernel.unprivileged_userns_clone=0 echo 'kernel.unprivileged_userns_clone = 0' | sudo tee /etc/sysctl.d/99-pedit-cow.conf
Это предотвращает создание непривилегированными пользователями необходимого пользовательского пространства имен для получения CAP_NET_ADMIN. Примечание: отключение пространств имен может нарушить работу rootless containers и некоторых изолированных приложений.
- **Сброс кэша страниц (Изоляция):** Если вы подозреваете, что эксплойт был запущен, копии бинарных файлов в памяти могут быть заражены. Немедленно сбросьте кэш для их удаления: ```
sudo sh -c "echo 3 > /proc/sys/vm/drop_caches"
Это заставляет страницы перезагружаться с диска. Предостережение: Если злоумышленник уже имел root, очистка кэша не удалит никакого установленного им постоянства. Считайте такие хосты скомпрометированными.
Минимальные привилегии: Проверьте и ограничьте круг лиц, имеющих право использовать tc. Для эксплуатации требуется только CAP_NET_ADMIN; убедитесь, что этой возможностью обладают только доверенные администраторы. Используйте RBAC или контейнеризацию для ограничения выдачи привилегий.
Сетевой контроль: Хотя напрямую сетевая атака невозможна, обеспечьте мониторинг использования петлевого интерфейса. Фаерволлинг 127.0.0.1 непрактичен, но убедитесь, что для манипуляций TC используется только трафик localhost.
Рекомендации вендоров: Обратитесь к официальным рекомендациям для вашей ОС. Red Hat выпустил RHSA-2026:27354 (и связанные) для RHEL 8/9/10, Debian — DSA-6355-1, на странице Ubuntu с CVE перечислены исправленные ядра и т. д. (См. раздел «Ссылки».)
Долгосрочное исправление заключается в установке обновлённых ядер на все затронутые системы. Пакеты ядра, содержащие исправление, должны быть установлены, а системы — перезагружены. Для контейнеров или систем, которые невозможно перезагрузить, рассмотрите решения для «живого» патчинга (например, KernelCare), для которых подготовлены исправления.
Кроме того, при проектировании системы следует исходить из того, что доступные из пользовательского пространства интерфейсы ядра могут со временем меняться. Ограничение CAP_NET_ADMIN и фильтрация использования tc — хорошие практики, выходящие за рамки данной ошибки.
Если произошла компрометация, пересоберите систему. Уязвимость отравляет только страничный кэш, но злоумышленник с root мог выполнить и другие вредоносные действия; необходима криминалистическая проверка. Не полагайтесь на сканирование целостности файлов после эксплуатации, поскольку, как отмечено, PoC оставляет файлы на диске нетронутыми. Безопасный путь исправления — перезагрузка и установка патча.
С учётом этих факторов типичный вектор CVSS v3.1: AV:L/AC:L/PR:H/UI:N/S:U/C:N/I:H/A:H, дающий Базовый балл 6.0 (Средний). Однако следует отметить, что CVSS не учитывает, что данная уязвимость предоставляет повышение привилегий до root, что на практике является критическим. (Некоторые источники вычисляли CVSSv4 для подобных ошибок; например, PT DBugs указывает 8.5 по CVSSv4.)
Серьёзность часто оценивается как Важная/Критическая вендорами. В рекомендациях Red Hat по этому CVE указано Important, а AWS помечает его как Medium (CVSS 6.0). В любом случае, поскольку достигается root, практический риск наиболее высок на многопользовательских или совместно используемых системах.
Эта уязвимость относится к семейству ошибок отравления страничного кэша. Другие известные CVE:
splice() на pipe мог записывать в страничный кэш за границы COW. Она также позволяла перезаписывать файлы в памяти (без изменения на диске)./proc/self/mem с копированием при записи, позволявшая локальную запись в отображения «только для чтения».Каждая из них включает запись ядром по быстрому пути в память, которую оно считало своей исключительно, но это было не так. CVE-2026-46331 уникальна тем, что происходит в net/sched pedit action и использует пространства имён пользователей для обхода ограничений привилегий. В отличие от DirtyPipe или Dirty COW, не требуется вспомогательный привилегированный процесс (например, неправильно работающая система); достаточно одного непривилегированного пользователя.
Все ссылки из надёжных источников (рекомендации вендоров, опубликованные анализы, записи CVE/NVD).
act_pedit преждевременный расчёт возможности записи привёл к повреждению страничного кэша.tc или netlink атакующий создает qdisc и фильтр на lo, который соответствует всем пакетам (например, match u32 0 0) и прикрепляет действие pedit со специально подготовленными ключами. Каждый ключ имеет динамический тип заголовка (например, IP-заголовок для смещения L4) и смещение, выбранное так, чтобы фактическая позиция записи (начало заголовка + смещение) находилась чуть за пределами диапазона, охваченного skb_ensure_writable().echo '' > /dev/udp/127.0.0.1/53) для запуска фильтра. Ядро вызывает tcf_pedit_act(), выделяет диапазон COW, затем перебирает ключи. По крайней мере, одна запись ключа выходит за пределы предварительно выделенной области COW, что приводит к записи в общий pagecache./bin/su в сокет через sendfile или аналогично, так что буфер пакета ссылается на страницы этого файла. Затем запись за пределами границ повреждает копию /bin/su в памяти (конкретно точку входа ELF)./bin/su). Поскольку ядро непреднамеренно внедрило шелл-код, который выполняет setgid(0); setuid(0); execve("/bin/sh"), запуск su дает root-шелл. Файл на диске никогда не изменялся, поэтому никакие средства проверки целостности файлов на диске не покажут изменений.auditd), показывающие получение программами CAP_NET_ADMIN через userns или запись в /proc/[pid]/uid_map.