В ядре Linux устранена следующая уязвимость:
net/smc: исправлено разыменование NULL и UAF в smc_tcp_syn_recv_sock(). Syzkaller сообщил о панике в smc_tcp_syn_recv_sock() [1].
smc_tcp_syn_recv_sock() вызывается в пути приема TCP
(softirq) через icsk_af_ops->syn_recv_sock на clcsock (TCP
гнездо для прослушивания). Он читает sk_user_data, чтобы получить smc_sock.
указатель.
Однако, когда сокет прослушивания SMC закрывается
одновременно smc_close_active() устанавливает clcsock->sk_user_data
в NULL под sk_callback_lock, а затем сам smc_sock
может быть освобожден через sock_put() в smc_release(). Это приводит к двум проблемам:
1) Разыменование нулевого указателя: sk_user_data имеет значение NULL, когда
доступ.
2) Использование после освобождения: sk_user_data читается как не NULL, но
smc_sock освобождается раньше своих полей (например, Queued_smc_hs,
ori_af_ops). Окно гонки выглядит так (вылет сизкаллера [1]
триггеры через путь cookie SYN: tcp_get_cookie_sock() ->
smc_tcp_syn_recv_sock(), но обычный путь tcp_check_req()
имеет ту же расу):
ЦП A (softirq) ЦП B (процесс ctx)
tcp_v4_rcv()
TCP_NEW_SYN_RECV:
sk = req->rsk_listener
sock_hold (ск)
/* Нет блокировки прослушивателя */
smc_close_active():
write_lock_bh(cb_lock)
sk_user_data = NULL
write_unlock_bh (cb_lock)
...
smc_clcsock_release()
sock_put(smc->sk) x2
-> smc_sock освобожден!
tcp_check_req()
smc_tcp_syn_recv_sock():
smc = user_data (ск)
-> NULL или висячий
smc->queued_smc_hs
-> крах!
Обратите внимание, что clcsock и smc_sock — два независимых объекта.
с отдельными рефсчетами.
Стек TCP содержит ссылку на
clcsock, который сохраняет его работоспособность, но это НЕ предотвращает
smc_sock от освобождения. Исправьте это, используя RCU и refcount_inc_not_zero() для безопасного
доступ к smc_sock. Поскольку smc_tcp_syn_recv_sock() вызывается
путь трехстороннего установления связи TCP, включающий read_lock_bh
sk_callback_lock слишком тяжел и не выдержит SYN.
нападение наводнения.
Использование rcu_read_lock() гораздо проще.
- Установите SOCK_RCU_FREE на сокете прослушивания SMC, чтобы
Освобождение smc_sock откладывается до окончания льготного периода RCU.
период. Это гарантирует, что память все еще действительна, когда
доступ осуществляется внутри rcu_read_lock().
— Используйте rcu_read_lock() для защиты чтения sk_user_data.
- Используйте refcount_inc_not_zero(&smc->sk.sk_refcnt), чтобы закрепить
smc_sock. Если счетчик рефсчетов уже достиг нуля (закройте
путь завершен), он возвращает false, и мы благополучно выходим из строя.
Примечание. smc_hs_congested() имеет аналогичное чтение без блокировки.
sk_user_data без rcu_read_lock(), но он проверяет только
NULL и обращается к глобальному smc_hs_wq, никогда не разыменовывая
любое поле smc_sock, поэтому оно не затрагивается. Воспроизводитель был проверен с помощью mdelay инъекции и smc_run,
проблема больше не возникает при применении этого патча.
[1] https://syzkaller.appspot.com/bug?extid=827ae2bfb3a3529333e9
Показать оригинальное описание (EN)
In the Linux kernel, the following vulnerability has been resolved: net/smc: fix NULL dereference and UAF in smc_tcp_syn_recv_sock() Syzkaller reported a panic in smc_tcp_syn_recv_sock() [1]. smc_tcp_syn_recv_sock() is called in the TCP receive path (softirq) via icsk_af_ops->syn_recv_sock on the clcsock (TCP listening socket). It reads sk_user_data to get the smc_sock pointer. However, when the SMC listen socket is being closed concurrently, smc_close_active() sets clcsock->sk_user_data to NULL under sk_callback_lock, and then the smc_sock itself can be freed via sock_put() in smc_release(). This leads to two issues: 1) NULL pointer dereference: sk_user_data is NULL when accessed. 2) Use-after-free: sk_user_data is read as non-NULL, but the smc_sock is freed before its fields (e.g., queued_smc_hs, ori_af_ops) are accessed. The race window looks like this (the syzkaller crash [1] triggers via the SYN cookie path: tcp_get_cookie_sock() -> smc_tcp_syn_recv_sock(), but the normal tcp_check_req() path has the same race): CPU A (softirq) CPU B (process ctx) tcp_v4_rcv() TCP_NEW_SYN_RECV: sk = req->rsk_listener sock_hold(sk) /* No lock on listener */ smc_close_active(): write_lock_bh(cb_lock) sk_user_data = NULL write_unlock_bh(cb_lock) ... smc_clcsock_release() sock_put(smc->sk) x2 -> smc_sock freed! tcp_check_req() smc_tcp_syn_recv_sock(): smc = user_data(sk) -> NULL or dangling smc->queued_smc_hs -> crash! Note that the clcsock and smc_sock are two independent objects with separate refcounts. TCP stack holds a reference on the clcsock, which keeps it alive, but this does NOT prevent the smc_sock from being freed. Fix this by using RCU and refcount_inc_not_zero() to safely access smc_sock. Since smc_tcp_syn_recv_sock() is called in the TCP three-way handshake path, taking read_lock_bh on sk_callback_lock is too heavy and would not survive a SYN flood attack. Using rcu_read_lock() is much more lightweight. - Set SOCK_RCU_FREE on the SMC listen socket so that smc_sock freeing is deferred until after the RCU grace period. This guarantees the memory is still valid when accessed inside rcu_read_lock(). - Use rcu_read_lock() to protect reading sk_user_data. - Use refcount_inc_not_zero(&smc->sk.sk_refcnt) to pin the smc_sock. If the refcount has already reached zero (close path completed), it returns false and we bail out safely. Note: smc_hs_congested() has a similar lockless read of sk_user_data without rcu_read_lock(), but it only checks for NULL and accesses the global smc_hs_wq, never dereferencing any smc_sock field, so it is not affected. Reproducer was verified with mdelay injection and smc_run, the issue no longer occurs with this patch applied. [1] https://syzkaller.appspot.com/bug?extid=827ae2bfb3a3529333e9