{
  "affected": [
    {
      "ecosystem_specific": {
        "urgency": "not yet assigned"
      },
      "package": {
        "ecosystem": "Debian:12",
        "name": "linux"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "0"
            },
            {
              "fixed": "6.1.170-1"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    },
    {
      "ecosystem_specific": {
        "urgency": "not yet assigned"
      },
      "package": {
        "ecosystem": "Debian:13",
        "name": "linux"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "0"
            },
            {
              "fixed": "6.12.85-1"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    },
    {
      "ecosystem_specific": {
        "urgency": "not yet assigned"
      },
      "package": {
        "ecosystem": "Debian:14",
        "name": "linux"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "0"
            },
            {
              "fixed": "6.19.10-1"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    },
    {
      "ecosystem_specific": {
        "urgency": "not yet assigned"
      },
      "package": {
        "ecosystem": "Debian:11",
        "name": "linux-6.1"
      },
      "ranges": [
        {
          "events": [
            {
              "introduced": "0"
            },
            {
              "fixed": "6.1.170-1~deb11u1"
            }
          ],
          "type": "ECOSYSTEM"
        }
      ]
    }
  ],
  "details": "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-\u003esyn_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-\u003esk_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() -\u003e 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-\u003ersk_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-\u003esk) x2                                    -\u003e smc_sock freed!     tcp_check_req()       smc_tcp_syn_recv_sock():         smc = user_data(sk)           -\u003e NULL or dangling         smc-\u003equeued_smc_hs           -\u003e 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(\u0026smc-\u003esk.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",
  "id": "DEBIAN-CVE-2026-23450",
  "modified": "2026-05-02T09:48:00.136846914Z",
  "published": "2026-04-03T16:16:31.243Z",
  "references": [
    {
      "type": "ADVISORY",
      "url": "https://security-tracker.debian.org/tracker/CVE-2026-23450"
    }
  ],
  "severity": [
    {
      "score": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H",
      "type": "CVSS_V3"
    }
  ],
  "upstream": [
    "CVE-2026-23450"
  ]
}