POSIX CPU Timers TOCTOU race (CVE-2025-38352)

Tip

Вивчайте та практикуйте AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Вивчайте та практикуйте GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE) Вивчайте та практикуйте Azure Hacking: HackTricks Training Azure Red Team Expert (AzRTE)

Підтримайте HackTricks

На цій сторінці задокументовано TOCTOU race condition у Linux/Android POSIX CPU timers, який може пошкодити стан таймера і спричинити крах ядра, а за певних обставин — бути використаний для privilege escalation.

  • Affected component: kernel/time/posix-cpu-timers.c
  • Примітив: expiry vs deletion race під час завершення задачі (task exit)
  • Залежить від конфігурації: CONFIG_POSIX_CPU_TIMERS_TASK_WORK=n (шлях IRQ-context expiry)

Короткий огляд внутрішньої структури (релевантно для експлуатації)

  • Три CPU-годинники забезпечують облік таймерів через cpu_clock_sample():
  • CPUCLOCK_PROF: utime + stime
  • CPUCLOCK_VIRT: utime only
  • CPUCLOCK_SCHED: task_sched_runtime()
  • При створенні таймера він прив’язується до task/pid і ініціалізуються вузли timerqueue:
static int posix_cpu_timer_create(struct k_itimer *new_timer) {
struct pid *pid;
rcu_read_lock();
pid = pid_for_clock(new_timer->it_clock, false);
if (!pid) { rcu_read_unlock(); return -EINVAL; }
new_timer->kclock = &clock_posix_cpu;
timerqueue_init(&new_timer->it.cpu.node);
new_timer->it.cpu.pid = get_pid(pid);
rcu_read_unlock();
return 0;
}
  • Arming вставляє в per-base timerqueue і може оновити next-expiry cache:
static void arm_timer(struct k_itimer *timer, struct task_struct *p) {
struct posix_cputimer_base *base = timer_base(timer, p);
struct cpu_timer *ctmr = &timer->it.cpu;
u64 newexp = cpu_timer_getexpires(ctmr);
if (!cpu_timer_enqueue(&base->tqhead, ctmr)) return;
if (newexp < base->nextevt) base->nextevt = newexp;
}
  • Швидкий шлях уникає витратної обробки, якщо кешовані терміни завершення не вказують на можливе спрацьовування:
static inline bool fastpath_timer_check(struct task_struct *tsk) {
struct posix_cputimers *pct = &tsk->posix_cputimers;
if (!expiry_cache_is_inactive(pct)) {
u64 samples[CPUCLOCK_MAX];
task_sample_cputime(tsk, samples);
if (task_cputimers_expired(samples, pct))
return true;
}
return false;
}
  • Закінчення терміну збирає прострочені таймери, позначає їх як спрацьовані, переміщує їх з черги; фактична доставка відкладається:
#define MAX_COLLECTED 20
static u64 collect_timerqueue(struct timerqueue_head *head,
struct list_head *firing, u64 now) {
struct timerqueue_node *next; int i = 0;
while ((next = timerqueue_getnext(head))) {
struct cpu_timer *ctmr = container_of(next, struct cpu_timer, node);
u64 expires = cpu_timer_getexpires(ctmr);
if (++i == MAX_COLLECTED || now < expires) return expires;
ctmr->firing = 1;                           // critical state
rcu_assign_pointer(ctmr->handling, current);
cpu_timer_dequeue(ctmr);
list_add_tail(&ctmr->elist, firing);
}
return U64_MAX;
}

Два режими обробки спрацьовувань

  • CONFIG_POSIX_CPU_TIMERS_TASK_WORK=y: спрацьовування відкладене через task_work у цільовому task
  • CONFIG_POSIX_CPU_TIMERS_TASK_WORK=n: спрацьовування обробляється безпосередньо в контексті IRQ
void run_posix_cpu_timers(void) {
struct task_struct *tsk = current;
__run_posix_cpu_timers(tsk);
}
#ifdef CONFIG_POSIX_CPU_TIMERS_TASK_WORK
static inline void __run_posix_cpu_timers(struct task_struct *tsk) {
if (WARN_ON_ONCE(tsk->posix_cputimers_work.scheduled)) return;
tsk->posix_cputimers_work.scheduled = true;
task_work_add(tsk, &tsk->posix_cputimers_work.work, TWA_RESUME);
}
#else
static inline void __run_posix_cpu_timers(struct task_struct *tsk) {
lockdep_posixtimer_enter();
handle_posix_cpu_timers(tsk);                  // IRQ-context path
lockdep_posixtimer_exit();
}
#endif

У шляху IRQ-context список спрацьовувань обробляється поза sighand.

static void handle_posix_cpu_timers(struct task_struct *tsk) {
struct k_itimer *timer, *next; unsigned long flags, start;
LIST_HEAD(firing);
if (!lock_task_sighand(tsk, &flags)) return;   // may fail on exit
do {
start = READ_ONCE(jiffies); barrier();
check_thread_timers(tsk, &firing);
check_process_timers(tsk, &firing);
} while (!posix_cpu_timers_enable_work(tsk, start));
unlock_task_sighand(tsk, &flags);              // race window opens here
list_for_each_entry_safe(timer, next, &firing, it.cpu.elist) {
int cpu_firing;
spin_lock(&timer->it_lock);
list_del_init(&timer->it.cpu.elist);
cpu_firing = timer->it.cpu.firing;         // read then reset
timer->it.cpu.firing = 0;
if (likely(cpu_firing >= 0)) cpu_timer_fire(timer);
rcu_assign_pointer(timer->it.cpu.handling, NULL);
spin_unlock(&timer->it_lock);
}
}

Root cause: TOCTOU between IRQ-time expiry and concurrent deletion under task exit

Передумови

  • CONFIG_POSIX_CPU_TIMERS_TASK_WORK вимкнено (використовується IRQ path)
  • Цільова задача завершується, але ще не повністю reaped
  • Інший потік одночасно викликає posix_cpu_timer_del() для того ж таймера

Послідовність

  1. update_process_times() викликає run_posix_cpu_timers() в IRQ-контексті для задачі, що завершується.
  2. collect_timerqueue() встановлює ctmr->firing = 1 і переміщує таймер у тимчасовий firing list.
  3. handle_posix_cpu_timers() скидáє sighand через unlock_task_sighand(), щоб доставляти таймери поза блокуванням.
  4. Негайно після unlock задача, що завершується, може бути reaped; суміжний потік виконує posix_cpu_timer_del().
  5. У цьому вікні posix_cpu_timer_del() може не встигнути отримати стан через cpu_timer_task_rcu()/lock_task_sighand() і таким чином пропустити звичайний in-flight guard, що перевіряє timer->it.cpu.firing. Видалення відбувається так, ніби таймер не firing, руйнуючи стан під час обробки спрацювання таймера, що призводить до аварій/UB.

Чому TASK_WORK mode is safe by design

  • Якщо CONFIG_POSIX_CPU_TIMERS_TASK_WORK=y, спрацювання відтерміновується до task_work; exit_task_work виконується перед exit_notify, тому IRQ-time перекриття з reaping не відбувається.
  • Навіть тоді, якщо задача вже завершується, task_work_add() зазнає невдачі; gating on exit_state робить обидва режими узгодженими.

Виправлення (Android common kernel) і обґрунтування

  • Додати ранній return, якщо поточна задача завершується, блокуючи всю обробку:
// kernel/time/posix-cpu-timers.c (Android common kernel commit 157f357d50b5038e5eaad0b2b438f923ac40afeb)
if (tsk->exit_state)
return;
  • Це запобігає входу в handle_posix_cpu_timers() для завдань, що виходять, усуваючи вікно, у якому posix_cpu_timer_del() міг пропустити it.cpu.firing і змагатися з обробкою закінчення терміну.

Impact

  • Пошкодження пам’яті ядра в структурах таймерів під час одночасного завершення/видалення може призводити до негайних аварій (DoS) і є потужним примітивом для ескалації привілеїв через можливості довільної маніпуляції станом ядра.

Triggering the bug (safe, reproducible conditions) Build/config

  • Ensure CONFIG_POSIX_CPU_TIMERS_TASK_WORK=n and use a kernel without the exit_state gating fix.

Runtime strategy

  • Target a thread that is about to exit and attach a CPU timer to it (per-thread or process-wide clock):
  • For per-thread: timer_create(CLOCK_THREAD_CPUTIME_ID, …)
  • For process-wide: timer_create(CLOCK_PROCESS_CPUTIME_ID, …)
  • Arm with a very short initial expiration and small interval to maximize IRQ-path entries:
static timer_t t;
static void setup_cpu_timer(void) {
struct sigevent sev = {0};
sev.sigev_notify = SIGEV_SIGNAL;    // delivery type not critical for the race
sev.sigev_signo = SIGUSR1;
if (timer_create(CLOCK_THREAD_CPUTIME_ID, &sev, &t)) perror("timer_create");
struct itimerspec its = {0};
its.it_value.tv_nsec = 1;           // fire ASAP
its.it_interval.tv_nsec = 1;        // re-fire
if (timer_settime(t, 0, &its, NULL)) perror("timer_settime");
}
  • З суміжного потоку одночасно видаліть той самий таймер під час виходу цільового потоку:
void *deleter(void *arg) {
for (;;) (void)timer_delete(t);     // hammer delete in a loop
}
  • Посилювачі гонки: висока частота таймерних тиків планувальника, навантаження CPU, цикли повторного виходу/створення потоків. Аварія зазвичай проявляється, коли posix_cpu_timer_del() пропускає помічання спрацювання через неуспішний task lookup/locking одразу після unlock_task_sighand().

Виявлення та захист

  • Mitigation: застосувати exit_state guard; за можливості віддавати перевагу увімкненню CONFIG_POSIX_CPU_TIMERS_TASK_WORK.
  • Моніторинг: додати tracepoints/WARN_ONCE навколо unlock_task_sighand()/posix_cpu_timer_del(); сигналізувати, коли спостерігається it.cpu.firing==1 разом з failed cpu_timer_task_rcu()/lock_task_sighand(); стежити за невідповідностями timerqueue навколо виходу task.

Ключові місця для аудиту (для рецензентів)

  • update_process_times() → run_posix_cpu_timers() (IRQ)
  • __run_posix_cpu_timers() selection (TASK_WORK vs IRQ path)
  • collect_timerqueue(): sets ctmr->firing and moves nodes
  • handle_posix_cpu_timers(): drops sighand before firing loop
  • posix_cpu_timer_del(): relies on it.cpu.firing to detect in-flight expiry; ця перевірка пропускається, коли пошук/блокування task не вдається під час exit/reap

Примітки для досліджень експлуатації

  • Розкриту поведінку можна використовувати як надійну примітивну причину аварії ядра; перетворення її на privilege escalation зазвичай потребує додаткового контрольованого перекриття (object lifetime або write-what-where influence), що виходить за межі цього підсумку. Розглядайте будь-який PoC як потенційно дестабілізуючий і запускайте лише в емульторах/VMs.

Див. також

Ksmbd Streams Xattr Oob Write Cve 2025 37947

References

Tip

Вивчайте та практикуйте AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Вивчайте та практикуйте GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE) Вивчайте та практикуйте Azure Hacking: HackTricks Training Azure Red Team Expert (AzRTE)

Підтримайте HackTricks