---

## Каталог

1. CVE-2015-8550
2. CVE-2016-9793
3. 4-20-BPF-integer
4. CVE-2017-5123
5. CVE-2017-6074
6. CVE-2017-7308
7. CVE-2017-8890
8. CVE-2017-11176
9. CVE-2017-16995
10. CVE-2017-1000112
11. CVE-2018-5333
12. CVE-2019-9213 & CVE-2019-8956
13. CVE-2019-15666
14. CVE-2020-8835
15. CVE-2020-27194
16. CVE-2021-3156
17. CVE-2021-31440
18. CVE-2021-3490
19. CVE-2021-22555
20. CVE-2021-41073
21. CVE-2021-4154
22. CVE-2021-42008
23. CVE-2021-43267
24. CVE-2022-0185
25. CVE-2022-0847
26. CVE-2022-0995
27. CVE-2022-1015
28. CVE-2022-2588
29. CVE-2022-2602
30. CVE-2022-2639
31. CVE-2022-25636
32. CVE-2022-27666
33. CVE-2022-32250
34. CVE-2022-34918
35. CVE-2023-2598
36. CVE-2024-1086
37. CVE-2025-21702
38. CVE-2026-23271

---

## Детали

#### 1.CVE-2015-8550

[разбор](https://blog.csdn.net/panhewu9919/article/details/100891770) 

**Тестовая версия**: Linux-4.19.65

**Защита**: включены kaslr/SMEP, SMAP не включен.

**Уязвимость**: **Double-Fetch-уязвимость**, вызванная оптимизацией компилятора gcc, позволяющая напрямую перехватить поток управления.

#### 2. CVE-2016-9793

[разбор](https://blog.csdn.net/panhewu9919/article/details/120164051) 

**Тестовая версия**: Linux-4.8.13

**Защита**: KASLR/SMAP/SMEP не включены. Поддельная структура [skb_shared_info](https://elixir.bootlin.com/linux/v4.8.13/source/include/linux/skbuff.h#L414) находится в пользовательском пространстве — очевидно, что обойти SMAP нельзя.

**Уязвимость**: функция [sock_setsockopt()](https://elixir.bootlin.com/linux/v4.8.13/source/net/core/sock.c#L658) в `net/core/sock.c` **некорректно обрабатывает отрицательные значения**, из-за чего `sk_sndbuf` и `sk_rcvbuf` становятся отрицательными. При вызове `write` значения `skb->head` и `skb->end` устанавливаются неверно, а при последующем вызове `close` при освобождении происходит обращение к пользовательскому пространству, что вызывает ошибку. По адресу пользовательского пространства `0xfffffed0` подделывается структура [skb_shared_info](https://elixir.bootlin.com/linux/v4.8.13/source/include/linux/skbuff.h#L414), и через `skb_shared_info->destructor_arg->callback` перехватывается поток управления.

#### 3. 4-20-BPF-integer

[разбор](https://www.cnblogs.com/bsauce/p/11560224.html) 

**Тестовая версия**: Linux-4.20.0-rc3

**Защита**: SMEP включен, kaslr/SMAP не включены.

**Уязвимость**: в модуле Linux ebpf **целочисленное переполнение** в `queue_stack_map_alloc()` приводит к переполнению кучи. Изменение указателя виртуальной таблицы перехватывает поток управления на `xchg eax, esp`.

#### 4.CVE-2017-5123

[разбор](https://www.jianshu.com/p/90a040114188) 

**Тестовая версия**: Linux 4.14-rc4

**Защита**: SMEP / SMAP включены, KASLR отключен.

**Уязвимость**: реализация `waitid` в `/kernel/exit.c` при вызове `unsafe_put_user()` для копирования данных ядра в адреса пользовательского пространства не вызывает `access_ok()` для проверки корректности адреса, из-за чего данные фактически можно копировать в адреса пространства ядра. **waitid не проверяет допустимость пользовательского адреса, что приводит к произвольной записи нуля**. Можно выполнить shellcode с адреса 0 или перезаписать cred в пределах угаданного диапазона для повышения привилегий.

#### 5.CVE-2017-6074

[разбор](https://bsauce.github.io/2021/09/17/CVE-2017-6074/)      [ссылка](https://github.com/xairy/kernel-exploits/tree/master/CVE-2017-6074)

**Тестовая версия**: Linux-4.9.12

**Защита**: SMEP/SMAP включены, kASLR отключен.

**Уязвимость**: в реализации DCCP (протокол управления перегрузкой дейтаграмм) набора протоколов IPv6 в Linux функция [dccp_rcv_state_process()](https://elixir.bootlin.com/linux/v4.9.12/source/net/dccp/input.c#L574) из `net/dccp/input.c` в состоянии `LISTEN` некорректно обрабатывает структуру данных пакета `DCCP_PKT_REQUEST`. Если пользователь вызывает `setsockopt()` с опцией `IPV6_RECVPKTINFO`, возникает **Double-Free структуры `sk_buff`**. Метод эксплуатации аналогичен CVE-2016-8655. Первое срабатывание уязвимости: спреем кучи подделывается структура `po->rx_ring->prb_bdqc->retire_blk_timer`, выполняется `native_write_cr4(0x406e0)` для отключения SMEP/SMAP. Второе срабатывание: спреем кучи подделывается структура `skb-> ... ->destructor_arg`, выполняется `commit_creds(prepare_kernel_cred(0))` для повышения привилегий.

#### 6.CVE-2017-7308

[разбор](https://www.jianshu.com/p/b53862cd64a6)      [ссылка](https://github.com/xairy/kernel-exploits/tree/master/CVE-2017-7308)

**Тестовая версия**: Linux-4.10.6

**Защита**: SMEP / SMAP включены, KASLR отключен.

**Уязвимость**: функция [`packet_set_ring()`](https://elixir.bootlin.com/linux/v4.10.6/source/net/packet/af_packet.c#L4181) в `net/packet/af_packet.c` неправильно проверяет размер блока (size), условие оценки длины ошибочно, что приводит к **переполнению кучи**. Требуется привилегия `CAP_NET_RAW`. Дважды перехватываются указатели на функции: сначала отключается защита SMEP/SMAP, затем повышаются привилегии.

#### 7.CVE-2017-8890

[разбор](https://www.jianshu.com/p/699de662f567)      [ссылка](https://xz.aliyun.com/t/2383)

**Тестовая версия**: Linux-4.10.15

**Защита**: SMEP включен, kASLR и SMAP отключены.

**Уязвимость**: в функции [`inet_csk_clone_lock()`](https://elixir.bootlin.com/linux/v4.10.15/source/net/ipv4/inet_connection_sock.c#L652) из файла `net/ipv4/inet_connection_sock.c` присутствует уязвимость **Double-Free**. Double-Free используется для подмены указателя на callback-функцию RCU, отключения SMEP и перехода на shellcode для изменения cred.

#### 8.CVE-2017-11176

[разбор](https://www.jianshu.com/p/76041ec5c59f) 

**Тестовая версия**: Linux-4.11.9

**Защита**: SMEP включен, kASLR и SMAP отключены.

**Уязвимость**: в реализации очередей сообщений POSIX в ядре Linux функция `mq_notify()` не обнуляет указатель sock, что приводит к UAF. На самом деле это **Double-Free из-за гонки (race condition)**, однако окно гонки можно продлевать бесконечно.

#### 9.CVE-2017-16995

[разбор](https://www.cnblogs.com/bsauce/p/11583310.html) 

**Тестовая версия**: Linux-4.4.110

**Защита**: SMEP/SMAP/kaslr включены.

**Уязвимость**: в модуле Linux ebpf проблема **целочисленного расширения (integer extension)**. Основная проблема в том, что значения регистров в двух местах имеют разные типы, из-за чего функция проверки и реальная функция выполняются по-разному. Эта уязвимость не включает атаки на стек или перехват потока управления; повышение привилегий выполняется только с использованием данных системных вызовов. Это типичный пример Data-Oriented Attack на ядро Linux.

#### 10. CVE-2017-1000112

[разбор](https://www.jianshu.com/p/1fa163fd5b82)  	  [ссылка](https://bbs.pediy.com/thread-265319.htm)

**Тестовая версия**: Linux-4.12.6

**Защита**: SMEP включен, SMAP/kaslr отключены.

**Уязвимость**: функция [__ip_append_data()](https://elixir.bootlin.com/linux/v4.12.6/source/net/ipv4/ip_output.c#L910) в `net/ipv4/ip_output.c` не обеспечивает согласованности обработки UDP-датаграмм, поэтому при двух вызовах `send` можно переключиться с пути UFO на путь non-UFO, что приводит к **переполнению кучи**. При эксплуатации можно перехватить поток управления, перезаписав `skb_shared_info->destructor_arg->callback`.

#### 11. CVE-2018-5333

[разбор](https://blog.csdn.net/panhewu9919/article/details/119153052)  

**Тестовая версия**: Linux-4.14.13

**Защита**: SMEP включен, SMAP/kaslr отключены.

**Уязвимость**: в функции [`rds_cmsg_atomic()`](https://elixir.bootlin.com/linux/v4.14.13/source/net/rds/rdma.c#L788) из `net/rds/rdma.c` забывают обнулить `rm->atomic.op_active`, что при обращении [rds_atomic_free_op()](https://elixir.bootlin.com/linux/v4.14.13/source/net/rds/rdma.c#L474) -> [set_page_dirty()](https://elixir.bootlin.com/linux/v4.14.13/source/mm/page-writeback.c#L2559) к `page->page_link` приводит к **разыменованию нулевого указателя (`null-dereference`)**. По адресу 0 подделываются структура и указатели на функции, затем перехватывается поток управления.

#### 12. CVE-2019-9213 & CVE-2019-8956

[CVE-2019-9213-разбор](https://blog.csdn.net/panhewu9919/article/details/118557802)    [CVE-2019-8956-разбор](https://blog.csdn.net/panhewu9919/article/details/118557844)    

**Тестовая версия**: Linux-4.20.0 32-бит

**Защита**: SMEP включен, SMAP/kaslr отключены.

**Уязвимость**: 

- CVE-2019-9213: в функции [`expand_downwards()`](https://elixir.bootlin.com/linux/v4.20.7/source/mm/mmap.c#L2413) из `mm/mmap.c` неверно выполняется проверка минимального адреса mmap — проверка capabilities выполняется для неправильной задачи, что позволяет обойти ограничение `mmap_min_addr`. **Логическая уязвимость**. При использовании команды `LD_DEBUG=help /bin/su 1>&%d` выполняется операция записи (write); вместо cred эксплойта ошибочно проверяются cred процесса write, после чего низкий адрес помечается как доступный с привилегиями. Уязвимость успешно эксплуатируется только на 32-битных системах; причина неизвестна.
- CVE-2019-8956: функция [`sctp_sendmsg()`](https://elixir.bootlin.com/linux/v4.20.7/source/net/sctp/socket.c#L2025) из `net/sctp/socket.c` при обработке флага `SCTP_SENDALL` содержит уязвимость **разыменования нулевого указателя**. В сочетании с CVE-2019-9213, обходя ограничение `mmap_min_addr`, можно выполнить mmap по низкому адресу 0xd4, подделать структуру и перехватить поток управления.

#### 13. CVE-2019-15666

[разбор](https://bsauce.github.io/2021/09/14/CVE-2019-15666/)  	  [ссылка](https://github.com/riskeco/Lucky/blob/master/lucky0_RE.c)

**Тестовая версия**: Ubuntu 18.04 (4.15.0-20-generic #21)

**Защита**: SMEP/SMAP/kaslr включены.

**Уязвимость**: функция [verify_newpolicy_info()](https://elixir.bootlin.com/linux/v5.0.18/source/net/xfrm/xfrm_user.c#L1379) из `net/xfrm/xfrm_user.c` некорректно обрабатывает проверку `dir`, что приводит к **выходу за границы (out-of-bounds access)** в [__xfrm_policy_unlink()](https://elixir.bootlin.com/linux/v5.0.18/source/net/xfrm/xfrm_policy.c#L2202). Изначально это выход за границы на -1, но с помощью другого пути можно сконструировать UAF, позволяющий **записать 8 нулевых байт в освобождённый блок**. Объект уязвимости `xfrm_policy` находится в `kmalloc-1024`, структура cred — в `kmalloc-192`. Сначала с помощью `setxattr+userfaultfd` вокруг `policy0` распыляются кучи-блоки `kmalloc-1024`. После освобождения `policy0` одновременно освобождаются и распылённые блоки, что вынуждает slab после освобождения быть переиспользованным для cred дочернего процесса c. Затем срабатывает UAF: 8 нулевых байт записываются в освобождённый блок, чтобы изменить `gid/suid` в cred, после чего текущий пользователь добавляется в sudoers — так выполняется повышение привилегий.

#### 14. CVE-2020-8835

[разбор](https://www.cnblogs.com/bsauce/p/14123111.html)  	  [ссылка](https://xz.aliyun.com/t/7690)

**Тестовая версия**: Linux-5.5.0

**Защита**: SMEP/SMAP/kaslr включены.

**Уязвимость**: в `kernel/bpf/verifier.c` 64-битное значение некорректно преобразуется в 32-битное (просто берутся младшие 32 бита), возникает **усечение целого (integer truncation)**, из-за чего фаза проверки BPF-кода и фаза реального выполнения расходятся, что приводит к чтению/записи за границами.

#### 15. CVE-2020-27194

[разбор](https://www.jianshu.com/p/b6f11d8df37a)       [ссылка](https://github.com/willinin/CVE-2020-27194-exp)

**Тестовая версия**: Linux-5.8.14

**Защита**: SMEP/SMAP/kaslr включены.

**Уязвимость**: при выполнении операции OR в проверочной программе eBPF функция `scalar32_min_max_or()` присваивает 64-битное значение 32-битной переменной, что приводит к **усечению целого**. Затем диапазон регистра вычисляется неверно, что позволяет обойти проверки BPF и вызвать чтение/запись за границами.

#### 16. CVE-2021-3156

[разбор](https://www.jianshu.com/p/18f36f1342b3)       [эксплойт](https://github.com/blasty/CVE-2021-3156)

**Тестовая версия**: Ubuntu 19.04, Sudo 1.8.27

**Защита**: SMEP/SMAP/kaslr включены.

**Уязвимость**: при обработке аргументов командной строки sudo, когда команда заканчивается одним обратным слэшем, возникает логическая ошибка, приводящая к **переполнению кучи**.

#### 17. CVE-2021-31440

[разбор](https://bsauce.github.io/2021/06/09/CVE-2021-31440/)      [эксплойт](https://github.com/bsauce/kernel-exploit-factory/tree/main/CVE-2021-31440/exp)

**Тестовая версия**: Linux-5.11

**Защита**: SMEP/SMAP/kaslr включены.

**Уязвимость**: в модуле eBPF функция [`__reg_combine_64_into_32()`](https://elixir.bootlin.com/linux/v5.11.20/source/kernel/bpf/verifier.c#L1312) из `kernel/bpf/verifier.c` неверно вычисляет регистры. Используя расхождение между фазой проверки verifier и фактическим выполнением, выполняются чтение/запись за границами. Утечка базового адреса ядра, подделка таблицы функций, реализация произвольного чтения/записи и последующее изменение cred текущего потока.

#### 18. CVE-2021-3490

[разбор](https://bsauce.github.io/2021/08/31/CVE-2021-3490/)      [эксплойт](https://github.com/chompie1337/Linux_LPE_eBPF_CVE-2021-3490)

**Тестовая версия**: Linux-5.11, Linux-5.11.16

**Защита**: SMEP/SMAP/kaslr включены.

**Уязвимость**: в модуле eBPF отслеживание границ ALU32 для битовых операций (AND, OR и XOR) в `kernel/bpf/verifier.c` неправильно обновляет 32-битные границы, что приводит к чтению и записи за границами в ядре Linux и, как следствие, к выполнению произвольного кода. Три уязвимые функции: [scalar32_min_max_and()](https://elixir.bootlin.com/linux/v5.13-rc3/source/kernel/bpf/verifier.c#L7078), [scalar32_min_max_or()](https://elixir.bootlin.com/linux/v5.13-rc3/source/kernel/bpf/verifier.c#L7149), [scalar32_min_max_xor()](https://elixir.bootlin.com/linux/v5.13-rc3/source/kernel/bpf/verifier.c#L7219). Используя расхождение между фазой проверки verifier и фактическим выполнением, выполняются чтение/запись за границами. Утечка базового адреса ядра, подделка таблицы функций, реализация произвольного чтения/записи и последующее изменение cred текущего потока.

#### 19. CVE-2021-22555

[разбор](https://bsauce.github.io/2021/09/23/CVE-2021-22555/)      [эксплойт](https://github.com/google/security-research/blob/master/pocs/linux/cve-2021-22555/exploit.c)

**Тестовая версия**: Linux-5.11.14

**Защита**: KASLR/SMEP/SMAP включены.

**Уязвимость**: в подмодуле `ip_tables` модуля Netfilter из `net/netfilter/x_tables.c` при вызове `setsockopt()` с опцией `IPT_SO_SET_REPLACE` (или `IP6T_SO_SET_REPLACE`) структуры ядра требуется преобразовывать из 32-битных в 64-битные. Из-за неверного вычисления размера преобразования при вызове функции [xt_compat_match_from_user()](https://elixir.bootlin.com/linux/v5.11.14/source/net/netfilter/x_tables.c#L731) возникает **переполнение кучи с записью нулей, которое можно превратить в UAF**. Атакующий может использовать её для повышения привилегий или побега из контейнеров Docker и k8s ([kubernetes](https://zhuanlan.zhihu.com/p/29232090)). Требуется привилегия `CAP_NET_ADMIN` или поддержка пространств имён `user+network`.

#### 20. CVE-2021-41073

[разбор](https://bsauce.github.io/2022/07/11/CVE-2021-41073/)      [ссылка](https://www.graplsecurity.com/post/iou-ring-exploiting-the-linux-kernel)

**Тестовая версия**: Linux-5.14.6

**Защита**: KASLR/SMEP/SMAP включены. Не включены `CONFIG_SLAB_FREELIST_RANDOM` / `CONFIG_SLAB_FREELIST_HARDENED` / `CONFIG_BPF_JIT_ALWAYS_ON` / `CONFIG_MEMCG ` (по умолчанию включён).

**Уязвимость**: в функции `loop_rw_iter()` из `fs/io_uring.c` присутствует уязвимость **type confusion**: `io_kiocb->rw.addr` используется одновременно как адрес ядра и как пользовательский адрес, однако при инкременте в `loop_rw_iter()` они не различаются. Из-за этого при чтении файла адрес ядра ошибочно увеличивается, и в итоге некорректно **освобождается соседний buffer, расположенный по контролируемому смещению** (kmalloc-32). Условия эксплуатации очень строгие: поскольку объект уязвимости находится в kmalloc-32, отключается механизм защиты freelist; поскольку объект `seq_operations` выделяется с флагом `GFP_KERNEL_ACCOUNT`, отключается также механизм `CONFIG_MEMCG*`; в данной эксплуатации для повышения привилегий используется подмена указателя `sk_filter->prog` в eBPF и подделка BPF-программы, поэтому дополнительно отключается конфигурация `CONFIG_BPF_JIT_ALWAYS_ON`.

#### 21. CVE-2021-4154

[разбор](https://bsauce.github.io/2022/10/17/CVE-2021-4154/)      [ссылка](https://github.com/Markakd/DirtyCred)

**Тестовая версия**: Linux-5.13.3

**Защита**: KASLR/SMEP/SMAP включены.

**Уязвимость**: в функции [cgroup1_parse_param()](https://elixir.bootlin.com/linux/v5.13.3/source/kernel/cgroup/cgroup-v1.c#L905) из `kernel/cgroup/cgroup-v1.c` (вызывается через системный вызов `fsconfig`) присутствует type confusion, приводящая к **UAF**. Можно вызвать системный вызов `fsconfig` для установки произвольного fd; после закрытия этого файла объект `file`, соответствующий fd, будет освобождён. Таким образом, можно **освободить структуру `file`, соответствующую любому файловому дескриптору**. В данной статье используются два метода эксплуатации: первый — DirtyCred, второй — построение ROP. Сравнивая эти методы: преимущество DirtyCred в том, что он универсален для разных версий ядра и не требует адаптации; недостаток — для повышения привилегий необходимо перезаписывать привилегированные файлы, поэтому в контейнерах типа Docker повысить привилегии невозможно. Преимущество ROP — возможность произвольного чтения/записи памяти ядра и выполнения произвольного кода; недостаток — адаптация под разные версии ядра достаточно трудоёмка.

#### 22. CVE-2021-42008

[разбор](https://bsauce.github.io/2021/12/09/CVE-2021-42008/)      [ссылка](https://syst3mfailure.io/sixpack-slab-out-of-bounds)

**Тестовая версия**: Linux-5.13.12

**Защита**: KASLR / SMEP / SMAP / PTI включены.

**Уязвимость**: в функции [decode_data()](https://elixir.bootlin.com/linux/v5.13.12/source/drivers/net/hamradio/6pack.c#L826) из `drivers/net/hamradio/6pack.c` присутствует **переполнение кучи**; пользователю требуется привилегия `CAP_NET_ADMIN`. [sixpack_decode()](https://elixir.bootlin.com/linux/v5.13.12/source/drivers/net/hamradio/6pack.c#L962) может многократно вызывать [decode_data()](https://elixir.bootlin.com/linux/v5.13.12/source/drivers/net/hamradio/6pack.c#L826), которая декодирует ввод и сохраняет результат в [sixpack->cooked_buf](https://elixir.bootlin.com/linux/v5.13.12/source/drivers/net/hamradio/6pack.c#L98). Член `sixpack->rx_count_cooked` используется как индекс доступа к `sixpack->cooked_buf`, определяющий целевое смещение для записи декодированных байтов. Проблема в том, что при многократных вызовах `decode_data()` `rx_count_cooked` постоянно увеличивается, пока не превысит длину `cooked_buf` (400 байт), что приводит к записи за границы. Опираясь на [использование структуры msg_msg в ядре Linux для реализации произвольного чтения/записи](https://www.anquanke.com/post/id/252558), строятся чтение за границами и произвольная запись по адресу, затем изменяется `modprobe_path` для повышения привилегий. Недостаток — необходимость использовать `userfaultfd`, и не обойти требование `CAP_NET_ADMIN`.

#### 23. CVE-2021-43267

[разбор](https://bsauce.github.io/2021/12/06/CVE-2021-43267/)      [ссылка](https://haxx.in/posts/pwning-tipc/)

**Тестовая версия**: Linux-5.14.15

**Защита**: KASLR/SMEP/SMAP включены.

**Уязвимость**: находится в файле `net/tipc/crypto.c`. В протоколе TIPC (Transparent Inter-Process Communication) для связи внутри кластера неверно проверяется длина сообщений типа `MSG_CRYPTO`, что приводит к **переполнению кучи**. В функции [tipc_crypto_key_rcv()](https://elixir.bootlin.com/linux/v5.14.15/source/net/tipc/crypto.c#L2281) поле данных TIPC-сообщения (структура [tipc_msg](https://elixir.bootlin.com/linux/v5.14.15/source/net/tipc/msg.h#L148)) указывает на сообщение `MSG_CRYPTO` (структура [tipc_aead_key](https://elixir.bootlin.com/linux/v5.14.15/source/include/uapi/linux/tipc.h#L241)). При выделении пространства для `tipc_aead_key` и копировании `tipc_aead_key->key` не проверяется корректность `tipc_aead_key->keylen`, что приводит к выходу за границы при копировании. Проверяются только `header size` и `msg size` TIPC-сообщения, но не проверяется `tipc_aead_key->keylen` в сообщении `MSG_CRYPTO`. С помощью `elastic object` утекает базовый адрес ядра, затем `tty_struct->tty_operations.ioctl` подменяется на gadget произвольной записи (`mov   QWORD PTR [rdx],rsi`), и изменяется `modprobe_path` для повышения привилегий.

#### 24. CVE-2022-0185

[разбор](https://bsauce.github.io/2022/04/08/CVE-2022-0185/)  

**Тестовая версия**: Linux-5.11.22

**Защита**: KASLR/SMEP/SMAP включены.

**Уязвимость**: на Google kctf было выполнено повышение привилегий, выигран приз в 30 000 долларов. В модуле `File System Context` ядра (контекст файловой системы) в файле `fs/fs_context.c` присутствует **целочисленное переполнение**, приводящее к переполнению кучи. Атакующий должен обладать привилегией `CAP_SYS_ADMIN` либо использовать пространства имён, а именно `unshare(CLONE_NEWNS|CLONE_NEWUSER)` (эквивалентно команде `$ unshare -Urm`), чтобы попасть в пространство имён с привилегией `CAP_SYS_ADMIN`. Два способа эксплуатации: первый — использование **FUSE** (аналог userfault) для построения произвольной записи по адресу и изменения `modprobe_path`; второй — использование `msg_msg` для создания произвольного освобождения и построения ROP для повышения привилегий.

#### 25. CVE-2022-0847

[разбор](https://bsauce.github.io/2022/04/03/CVE-2022-0847/)      ссылка-[1](https://blog.csdn.net/Breeze_CAT/article/details/123393188) [2](https://www.anquanke.com/post/id/269886) [3](https://www.freebuf.com/vuls/324700.html)

**Тестовая версия**: Linux-5.16.10

**Защита**: KASLR/SMEP/SMAP включены.

**Уязвимость**: **уязвимость DirtyPipe**. Когда вызов `splice` связывает page cache файла с кольцевым буфером pipe [pipe_buffer](https://elixir.bootlin.com/linux/v5.16.10/source/include/linux/pipe_fs_i.h#L26), функции [copy_page_to_iter_pipe()](https://elixir.bootlin.com/linux/v5.16.10/source/lib/iov_iter.c#L384) и [push_pipe()](https://elixir.bootlin.com/linux/v5.16.10/source/lib/iov_iter.c#L547) не инициализируют член `flag` структуры [pipe_buffer](https://elixir.bootlin.com/linux/v5.16.10/source/include/linux/pipe_fs_i.h#L26) (уязвимость неинициализированной переменной). Из-за того, что флаг `PIPE_BUF_FLAG_CAN_MERGE` не сбрасывается, последующий вызов `pipe_write()` ошибочно считает операцию записи объединяемой, что позволяет записать нелегальные данные в page cache файла (восстанавливается после перезагрузки) и приводит к уязвимости перезаписи произвольных файлов. Уязвимость позволяет записывать в page cache любого файла. Метод повышения привилегий — изменение page cache для `/etc/passwd`: в течение короткого времени все процессы, обращающиеся к этому файлу, увидят изменённую страницу файлового кэша.

#### 26. CVE-2022-0995

[разбор](https://bsauce.github.io/2022/04/15/CVE-2022-0995/)     

**Тестовая версия**: Linux-5.11.22

**Защита**: KASLR/SMEP/SMAP включены.

**Уязвимость**: в подсистеме уведомлений о событиях `watch_queue ` присутствует **переполнение кучи**; уязвимая функция — [watch_queue_set_filter()](https://elixir.bootlin.com/linux/v5.16.14/source/kernel/watch_queue.c#L286). Ядро выполняет две проверки фильтра типа [watch_notification_type_filter](https://elixir.bootlin.com/linux/v5.16.14/source/include/uapi/linux/watch_queue.h#L52), передаваемого пользователем: первая проверка определяет размер выделяемой памяти, вторая — сохраняет пользовательский фильтр в этой памяти. Однако эти две проверки не согласованы, из-за чего выделяется слишком мало места и можно записать больше фильтров, чем предполагалось. Второе переполнение можно использовать для установки определённых битов в соседнем кучевом блоке. Дальнейший метод эксплуатации такой же, как у [CVE-2021-22555](https://bsauce.github.io/2021/09/23/CVE-2021-22555/).

#### 27. CVE-2022-1015

[разбор](https://bsauce.github.io/2022/07/16/CVE-2022-1015/)      [ссылка](https://blog.dbouman.nl/2022/04/02/How-The-Tables-Have-Turned-CVE-2022-1015-1016/)

**Тестовая версия**: Linux-5.17

**Защита**: KASLR/SMEP/SMAP включены.

**Уязвимость**: в модуле nftables функции [nft_parse_register_load()](https://elixir.bootlin.com/linux/v5.17/source/net/netfilter/nf_tables_api.c#L9325) и [nft_parse_register_store()](https://elixir.bootlin.com/linux/v5.17/source/net/netfilter/nf_tables_api.c#L9377) не ограничивают диапазон индексов регистров, что приводит к целочисленному переполнению (проходящему проверку диапазона) и, как следствие, к **переполнению стека с чтением/записью за границами**. При эксплуатации необходимо вернуться из контекста прерывания в пользовательское пространство: используется конец функции `__do_softirq()` для аккуратного возврата в контекст системного вызова, затем вызываются `switch_task_namespaces(current, &init_nsproxy)` и `commit_cred(&init_cred)` для повышения привилегий.

#### 28. CVE-2022-2588

[разбор](https://bsauce.github.io/2022/10/21/CVE-2022-2588/)      [ссылка](https://github.com/Markakd/CVE-2022-2588)

**Тестовая версия**: Linux-5.19.1

**Защита**: KASLR/SMEP/SMAP включены.

**Уязвимость**: аналогично [CVE-2021-3715](https://access.redhat.com/security/cve/cve-2021-3715) (см. [BlackHat 2021-Europe-Your Trash Kernel Bug, My Precious 0-day](https://zplin.me/talks/BHEU21_trash_kernel_bug.pdf), стр. 16), из-за несоответствия условий проверки при удалении объекта `route4_filter` из связного списка и его освобождении объект остаётся в списке после освобождения, что позволяет впоследствии вызвать **Double-Free**. Для срабатывания требуются `User Namespaces`. Повышение привилегий выполняется методом **DirtCred**.

#### 29. CVE-2022-2602

[разбор](https://bsauce.github.io/2022/06/08/CVE-2022-2602/)      [ссылка](https://1day.dev/notes/CVE-2022-2602-DirtyCred-File-Exploitation-applied-on-an-io_uring-UAF/)

**Тестовая версия**: Linux-5.18.19

**Защита**: KASLR/SMEP/SMAP включены.

**Уязвимость**: в компоненте io_uring есть функция `IORING_REGISTER_FILES`, которая позволяет помещать файлы в очередь `sock->receive_queue` io_uring. Однако механизм сборки мусора Linux GC (обрабатывающий только счётчики полёта (flight count) файлов io_uring и sock) может освободить зарегистрированные в io_uring файлы как мусор. При следующем использовании такого файла в io_uring (запись через writev, соответствующая операции `IORING_OP_WRITEV`) возникает **UAF**. Метод эксплуатации: поскольку сборщик мусора UNIX_GC ошибочно освобождает структуру `file`, всё ещё используемую в `io_uring` (в неё идёт запись вредоносных данных в обычный файл `"/tmp/rwA"`), применяется **метод DirtyCred**: открывается множество файлов `"/etc/passwd"`, перекрывающих только что освобождённую структуру `file`, и в итоге вредоносные данные реально записываются в `"/etc/passwd"`.

#### 30. CVE-2022-2639

[разбор](https://bsauce.github.io/2022/11/24/CVE-2022-2639/)      [ссылка](https://veritas501.github.io/2022_10_18-CVE-2022-2639%20%20openvswitch%20LPE%20%20%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/)

**Тестовая версия**: Linux-5.17.4

**Защита**: KASLR/SMEP/SMAP включены.

**Уязвимость**: в модуле ядра `openvswitch` в [reserve_sfa_size()](https://elixir.bootlin.com/linux/v5.17.4/source/net/openvswitch/flow_netlink.c#L2439) целочисленное переполнение приводит к **переполнению кучи записью в kmalloc-0x10000**; для построения cross-cache переполнения требуется использование распыления страниц (page spray). В данной статье используется `pipe-primitive` для модификации произвольных файлов, поэтому не требуется обходить KASLR/SMEP/SMAP/KPTI, и эксплуатация работает без адаптации между версиями. **Сначала создаётся pipe, выполняется splice с файлом только для чтения `/usr/bin/mount`, распылением кучи подделывается `pipe_buffer->flags = PIPE_BUF_FLAG_CAN_MERGE`, что позволяет записать suid-shell в файл `/usr/bin/mount` и затем повысить привилегии**. OOB срабатывает дважды: первый раз переполнение изменяет `msg_msg->m_ts` для внеграничного чтения соседнего `msg_msg->m_list.next` — **утечка адреса кучи kmalloc-1024**; второй раз переполнение изменяет `msg_msg->m_list.next`, указывая на утёкший адрес кучи kmalloc-1024, — **создание произвольного освобождения**.

#### 31. CVE-2022-25636

[разбор](https://bsauce.github.io/2022/12/13/CVE-2022-25636/)      [ссылка](https://github.com/Bonfee/CVE-2022-25636)

**Тестовая версия**: Linux-5.13.19

**Защита**: KASLR/SMEP/SMAP включены.

**Уязвимость**: в функции [nft_fwd_dup_netdev_offload()](https://elixir.bootlin.com/linux/v5.16.11/source/net/netfilter/nf_dup_netdev.c#L67) из `net/netfilter/nf_dup_netdev.c` модуля `nf_table` из-за несоответствия между вычислением выделяемого пространства и условиями при фактической инициализации возникает **OOB write** (система должна поддерживать разгрузку обработки пакетов — Network Interface Cards (NICs), что на практике встречается редко). **Переполнение записывает адрес объекта `net_device` (находящегося в kmalloc-4k)**. При этом размер объекта уязвимости может варьироваться (определяется количеством переданных правил с флагом `NFT_OFFLOAD_F_ACTION` и может соответствовать `kmalloc-128`, `kmalloc-192` и т.д.). Требуется привилегия `SYS_ADMIN`. При эксплуатации **указатель на кучу kmalloc-4k для `net_device` утекается через `msg_msgseg`, перезаписью указателя `msg_msg->security` создаётся произвольное освобождение, через штатную функцию `ioctl(fd, SIOCGIFHWADDR, leak)` читается `net_device->dev_addr` для утечки базового адреса ядра, а подделкой указателя на функцию `net_device->ethtool_ops->begin` перехватывается поток управления для повышения привилегий**.

#### 32. CVE-2022-27666

[разбор](https://paper.seebug.org/1889/)      [ссылка](https://etenal.me/archives/1825)

**Тестовая версия**: Linux-5.16.14

**Защита**: KASLR/SMEP/SMAP включены.

**Уязвимость**: на соревновании PWN2OWN было выполнено повышение привилегий на Ubuntu 21.10. В криптомодуле ядра esp6 приёмный буфер составляет 8 страниц, но отправитель может отправлять данные размером более 8 страниц; функция [null_skcipher_crypt()](https://elixir.bootlin.com/linux/v5.16.14/source/crypto/crypto_null.c#L76) приводит к **переполнению страницы (page overflow)**. В целом используется техника распыления страниц: сначала эластичный объект `user_key_payload` используется для утечки `msg_msg->next`, затем через `msg_msg` утекает адрес ядра `seq_operations->start`, и наконец с помощью `msg_msg` и обработки ошибок страниц FUSE строится произвольная запись для изменения `modprobe_path` и повышения привилегий.

#### 33. CVE-2022-32250[writeup](https://bsauce.github.io/2022/11/03/CVE-2022-32250/)      [reference](https://github.com/theori-io/CVE-2022-32250-exploit)

**Тестовая версия**: Linux-5.17.12

**Защита**: включены KASLR/SMEP/SMAP.

**Уязвимость**: в модуле `nftables`, в `net/netfilter/nf_tables_api.c`, при добавлении `nft_set` через `NFT_MSG_NEWSET`, при обработке expression `lookup` и `dynset`, из-за ошибочной проверки `NFT_EXPR_STATEFUL`, объект `nft_expr` после освобождения всё ещё остаётся в списке `nft_set->binding`, и при добавлении нового `nft_expr` возникает **UAF-запись** (для эксплуатации требуются права `CAP_NET_ADMIN`). UAF-запись записывает в смещение 0x18 области `kmalloc-64` адрес значения из смещения 0x18 другого heap-блока `kmalloc-64`. Метод эксплуатации — использование **`msg_msg` из mqueue для утечки базового адреса ядра**, поскольку `posix_msg_tree_node->msg_list` в mqueue имеет смещение 0x18 (и находится в `kmalloc-64`), что совпадает со смещением UAF-записи; кроме того, **`posix_msg_tree_node->msg_list` также можно использовать для построения Unlink-эксплуатации** с целью подмены `modprobe_path`. Использование `user_key_payload` для утечки heap-адреса (удобно для построения unlink) — уже избитая тема. Обратите внимание: необходимы версии libmnl или libnftnl не ниже ubuntu21.04.

#### 34. CVE-2022-34918

[writeup](https://bsauce.github.io/2022/07/26/CVE-2022-34918/)      [reference](https://www.randorisec.fr/crack-linux-firewall/)

**Тестовая версия**: Linux-5.17.15

**Защита**: включены KASLR/SMEP/SMAP.

**Уязвимость**: в модуле nftables в функции [nft_set_elem_init()](https://elixir.bootlin.com/linux/v5.18.10/source/net/netfilter/nf_tables_api.c#L5459) существует **переполнение кучи**, длина переполнения может достигать `64-16=48` байт, уязвимый объект может находиться в `kmalloc-{64,96,128,192}` (в данной эксплуатации выбран уязвимый объект в `kmalloc-64`). Эксплуатация — сначала строится heap-раскладка `vul_obj -> user_key_payload -> percpu_ref_data`, переполнение изменяет `user_key_payload->datalen` на 0xffff, что позволяет утечь базовый адрес ядра из `percpu_ref_data->release` и physmap-адрес из `percpu_ref_data->ref`; затем строится heap-раскладка `vul_obj -> simple_xattr`, переполнение изменяет список `simple_xattr->list`, и с помощью этого ограниченного произвольного записи `modprobe_path` изменяется с `/sbin/modprobe` на `/tmp/xxxxprobe` для повышения привилегий (произвольная запись срабатывает при удалении xattr из списка). Предварительным условием этой произвольной записи является утечка physmap-адреса: и `percpu_ref_data`, и `shm_file_data` содержат как базовый адрес ядра, так и physmap-адрес.

#### 35. CVE-2023-2598

[writeup](https://bsauce.github.io/2024/07/30/CVE-2023-2598/)      [reference](https://anatomic.rip/cve-2023-2598/)

**Тестовая версия**: Linux-6.3.1

**Защита**: включены KASLR/SMEP/SMAP.

**Уязвимость**: OOB-запись в модуле io_uring, позволяющая **выйти за границы при чтении/записи физической памяти**. Уязвимость находится в функции [io_sqe_buffer_register()](https://elixir.bootlin.com/linux/v6.3.1/source/io_uring/rsrc.c#L1230) из каталога `io_uring/rsrc.c`. При проверке того, принадлежат ли представленные для регистрации страницы одной составной странице (compound page), проверяется только совпадение первой страницы составной страницы, но не проверяется, являются ли представленные страницы одной и той же страницей. Можно зарегистрировать одну и ту же физическую страницу (выдавая её за составную страницу из нескольких физических страниц) и организовать произвольное чтение/запись за границами физической страницы любой длины.

Используя произвольное чтение/запись за границами физической страницы любой длины, можно произвольно читать и записывать расположенный позади объект sock; через `sock->sk_data_ready` утекает базовый адрес ядра, через `sock.sk_error_queue.next` — heap-адрес объекта sock, а подделка указателя на функцию `sock.__sk_common.skc_prot->ioctl` на [call_usermodehelper_exec()](https://elixir.bootlin.com/linux/v6.3.1/source/kernel/umh.c#L434) позволяет **перехватить поток управления**; дополнительно требуется подделать структуру `subprocess_info`, чтобы завершить эксплуатацию и в итоге выполнить **`/bin/sh -c /bin/sh &>/dev/ttyS0 </dev/ttyS0` для повышения привилегий**.

#### 36. CVE-2024-1086

[writeup](https://bsauce.github.io/2024/05/10/CVE-2024-1086/)      [reference](https://yanglingxi1993.github.io/dirty_pagetable/dirty_pagetable.html)

**Тестовая версия**: Linux-6.3.13

**Защита**: включены KASLR/SMEP/SMAP.

**Уязвимость**: в компоненте nf_tables подсистемы netfilter существует **UAF-уязвимость**. В функции [nft_verdict_init()](https://elixir.bootlin.com/linux/v6.3.13/source/net/netfilter/nf_tables_api.c#L10321) разрешается установка очень большого значения verdict (вредоносное значение 0xffff0000); в функции [nf_hook_slow()](https://elixir.bootlin.com/linux/v6.3.13/source/net/netfilter/core.c#L607) при обработке `NF_DROP` (0) сначала освобождается skb-пакет, а затем вызывается [NF_DROP_GETERR()](https://elixir.bootlin.com/linux/v6.3.13/source/include/linux/netfilter.h#L19) для изменения возвращаемого значения (в зависимости от значения verdict оно устанавливается в `NF_ACCEPT` — положительное значение 1). Последующая ссылка на skb вызывает UAF, и [NF_HOOK()](https://elixir.bootlin.com/linux/v6.3.13/source/include/linux/netfilter.h#L407) повторно освобождает skb. Метод эксплуатации — **создание перекрывающихся PMD-страниц и PTE-страниц**: `PMD[0]`/`PMD[1]` перезаписывают `PTE[0]`/`PTE[1]`; записью в пользовательский виртуальный адрес, соответствующий PTE-странице, подделывается PTE-страница, соответствующая `PMD[0]` (записи соответствуют физическим адресам), что позволяет записью в пользовательский виртуальный адрес, соответствующий PMD, **реализовать произвольную запись по физическому адресу**.

#### 37. CVE-2025-21702

[writeup](https://bsauce.github.io/2026/01/27/CVE-2025-21702/)      [reference](https://github.com/quanggle97/security-research/tree/master/pocs/linux/kernelctf/CVE-2025-21702_lts_cos)

**Тестовая версия**: Linux-6.6.75

**Защита**: включены KASLR/SMEP/SMAP.

**Уязвимость**: в модуле `net/sched`, когда для некоторого планировщика qdisc (у которого `sch->limit == 0`) вызывается функция `pfifo_tail_enqueue()`, длина очереди qlen этого qdisc некорректно увеличивается (хотя очередь уже полна, новый packet добавляется без предварительного удаления одного packet), при этом длина qlen родительского qdisc (вызывающего) не увеличивается, из-за чего qlen родительской очереди перестаёт равняться сумме qlen дочерних очередей, что позволяет сконструировать UAF. Утечка базового адреса ядра — с помощью принципа вставки узла красно-чёрного дерева подделывается `user_key_payload->datalen`, организуется чтение за границами, утекает указатель на функцию `xfrm_policy_timer` из соседнего объекта `xfrm_policy`. Перехват потока управления — подделывается указатель на функцию `UAF_hfsc_class->dequeue`; после постановки packet в очередь при его извлечении срабатывает `hfsc_dequeue()` -> `qdisc_dequeue_peeked()` -> `sch->dequeue()`, перехватывающий поток управления; регистр RDI контролируем.

#### 38. CVE-2026-23271

[writeup](https://bsauce.github.io/2026/05/29/CVE-2026-23271/)      [reference](https://github.com/simond67/security-research/tree/Add-kernelCTF-CVE-2026-23271_lts/pocs/linux/kernelctf/CVE-2026-23271_lts)

**Тестовая версия**: Linux-6.12.24

**Защита**: включены KASLR/SMEP/SMAP.

**Уязвимость**: в `kernel/events/` (подсистема perf) существует UAF-уязвимость из-за состояния гонки. Между `__perf_event_overflow()` и `perf_remove_from_context()` существует состояние гонки. Для software/tracepoint-управляемых perf-событий обработка overflow лишь запрещает вытеснение (не отключает аппаратные прерывания). В этом контексте путь очистки `perf_event_release_kernel()` → `perf_remove_from_context()` может выполняться параллельно на другом CPU, освобождая связанное с колбэком состояние события (например, `event->pending_task`) в то время, как оно всё ещё используется в пути overflow, что приводит к UAF. Исправление заключается в добавлении соответствующего механизма синхронизации в `__perf_event_overflow()`, гарантирующего, что путь освобождения не сможет продолжаться параллельно, пока путь overflow обращается к связанным с колбэком полям.
- Состояние гонки (Worker-поток запускает путь tracepoint overflow, Closer-поток параллельно вызывает `close()` на perf_event fd) вызывает `WARN_ON_ONCE`; после обнуления refcount `task_work_add` всё ещё добавляет `pending_task` уже освобождённого события в список task_work.
- Посредством опроса `/proc/sys/kernel/tainted` бита TAINT_WARN(512) обнаруживается успешность гонки; 1024 spray-потока синхронно освобождают слоты, и событием B занимается slab-слот, освобождённый событием A.
- Когда futex_wait возвращается в пользовательское пространство, `perf_pending_task` выполняет `put_event(событие B)`, ошибочно уменьшая refcount события B до 0, что формирует **стабильный висячий FD**.
- ID Oracle последовательно выделяет событие C, проверяя изменение ID, и точно определяет жертву; межкэшевая атака возвращает slab-страницу `perf_event_cache` в buddy, после чего выполняется reclaim через `msg_msgseg`.