[BUG] net/smc: out-of-bounds WRITE of 869056 bytes into a 65504-byte send buffer, from a peer-credited sndbuf_space (SMC-D DMB-nocopy)

From: Piyus Kedia

Date: Sun Nov 22 2026 - 00:32:53 EST


Hi,

A second finding in net/smc, on the transmit side this time.

Summary
=======

Affected: net.git main at d5b89d55a322 and the 7.3.1 tree we work on.

Problem: smc_tx_sendmsg() clamps the first of its two ring chunks against
the send buffer and the second not at all, so the copy is bounded only by
conn->sndbuf_space. On the SMC-D DMB-nocopy path that counter is credited
from the peer's consumer cursor. A peer that reports an oversized cursor
therefore makes memcpy_from_msg() write sendmsg() data past the end of the
send buffer.

Relationship to the other report: the cursor itself is what our other patch
("net/smc: validate the peer's CDC cursors against our own buffers", v2)
validates, and with that applied the known way to inflate this counter is
closed. We are still reporting this separately because the bound
smc_tx_sendmsg() needs is its own: nothing at the copy says the length fits
the buffer, and a reader of the second chunk has to go and prove it
elsewhere. Take this as hardening if you prefer - we would rather send it
than assume the cursor check is the last word.


1. Root cause
=============

net/smc/smc_tx.c:235-265, smc_tx_sendmsg():

writespace = atomic_read(&conn->sndbuf_space);
/* not more than what user space asked for */
copylen = min_t(size_t, send_remaining, writespace);
/* determine start of sndbuf */
sndbuf_base = conn->sndbuf_desc->cpu_addr;
smc_curs_copy(&prep, &conn->tx_curs_prep, conn);
tx_cnt_prep = prep.count;
/* either unwrapped case, or 1st chunk of wrapped case */
chunk_len = min_t(size_t, copylen, conn->sndbuf_desc->len -
tx_cnt_prep);
chunk_len_sum = chunk_len;
chunk_off = tx_cnt_prep;
for (chunk = 0; chunk < 2; chunk++) {
rc = memcpy_from_msg(sndbuf_base + chunk_off, msg, chunk_len);
...

and for the second iteration (:263-265):

chunk_len = copylen - chunk_len_sum; /* remainder */
chunk_len_sum += chunk_len;
chunk_off = 0; /* modulo offset in send ring buffer */

The first chunk cannot pass the end of the buffer because it is clamped to
sndbuf_desc->len - tx_cnt_prep. The second is the remainder of copylen with
no clamp, written at offset 0. So the total written is copylen, and copylen
is bounded only by writespace.


2. Why sndbuf_space is not ours
===============================

For SMC-R, and for SMC-D in the copying mode, the counter is credited from
cursors this side computed - smc_cdc_tx_handler() and the tail of
smc_cdc_msg_send() use conn->tx_curs_sent - and is safe.

The exception is the DMB-nocopy path. net/smc/smc_cdc.c:356-370:

if (conn->lgr->is_smcd &&
smc_ism_support_dmb_nocopy(conn->lgr->smcd)) {
diff_tx = smc_curs_diff(conn->sndbuf_desc->len,
&conn->tx_curs_fin,
&conn->local_rx_ctrl.cons);
smp_mb__before_atomic();
atomic_add(diff_tx, &conn->sndbuf_space);
/* guarantee 0 <= sndbuf_space <= sndbuf_desc->len */

conn->local_rx_ctrl.cons is the peer's consumer cursor, taken from the CDC
message. The comment states the invariant smc_tx_sendmsg() depends on; the
add does not establish it, and before our other patch nothing on the way
here compared that cursor with any buffer length. On SMC-D in particular
smcd_cdc_rx_tsklet() reads the cursors out of the DMB the peer writes into
with no validation at all.

Two details that matter for judging it:

- The nocopy sndbuf is the peer's DMB. smcd_buf_attach()
(net/smc/smc_core.c:2622-2650) attaches the peer's DMB and then does

buf_desc->cpu_addr = (u8 *)buf_desc->cpu_addr +
sizeof(struct smcd_cdc_msg);
buf_desc->len -= sizeof(struct smcd_cdc_msg);

so an overflow of this buffer runs off the end of that DMB mapping, and
sndbuf_desc->len equals the peer's RMB size - which is why a single
bound on the consumer cursor covers both uses of it.
- The data written is the local application's own sendmsg() payload. The
peer chooses the length; the sender chooses the bytes.

CONFIG_DIBS_LO advertises nocopy support (dibs_lo_support_dmb_nocopy()
returns DIBS_LO_SUPPORT_NOCOPY), so the branch is live on an ordinary
x86_64 kernel, not only on s390 ISM hardware.


3. What we observed
===================

A hostile peer is what the bug needs, and the only SMC-D device we have is
the loopback-ISM (dibs) device, where both ends are the same kernel and every
cursor is therefore kernel-generated and in range. Userspace cannot write
the cursor either: the CDC sits at the base of the DMB, smcd_buf_attach()
starts the ghost sndbuf past it, and SMC sockets are .mmap = sock_no_mmap.

So we stood the peer in with a debug patch that overrides the consumer cursor
in smcd_cdc_rx_tsklet() AFTER validation - nothing else is changed, and that
is precisely the state the send path has to survive on its own: a credit it
did not compute. simulated-peer-debug.patch in this directory is that patch
plus the two pr_info()s quoted below.

The credit goes out of range exactly as the code says it can:

SMC2DBG diff_tx=1000000 space_before=65504 sndlen=65504 cons=1000000
SMC2DBG diff_tx=1065504 space_before=0 sndlen=65504 cons=1000000

conn->sndbuf_space reaches 1065504 on a 65504-byte send buffer. One
sendmsg() of 4 MB then turns that into an oversized copy, and the second
chunk is written at offset 0 with the remainder:

SMCTXDBG chunk=0 off=0 len=65504 sndlen=65504 in bounds
SMCTXDBG chunk=1 off=0 len=869056 sndlen=65504 past the end

==================================================================
BUG: KASAN: use-after-free in _copy_from_iter+0x197/0xfd0
Write of size 869056 at addr ffff888057980020 by task b/9467

_copy_from_iter+0x197/0xfd0
smc_tx_sendmsg+0x1011/0x12c0
smc_sendmsg+0x1a2/0x2a0
sock_sendmsg+0x19d/0x270
__sys_sendto+0x22a/0x300

The full report is in
kasan-smc-tx-sendmsg-oob-write-mainline-7.4-rc3.txt.

With the patch applied and the same injected credit, every chunk stays inside
the buffer (len 65504 or less, and no second chunk past the end), KASAN is
silent, and an 8 MB transfer over the same connection completes with its
contents verified - so the clamp does not break a correct sender.

What this does and does not establish. It establishes that an out-of-range
credit becomes an out-of-bounds write of attacker-chosen length, and that the
patch stops it. It does not establish that a real SMC-D peer can produce
that credit - for that you need an ISM device, and the cursor's path from
the wire is the one our other patch validates. We would rather you weigh
this knowing exactly which half was simulated.


4. Impact
=========

Stating only what the code shows, since we have no run to point at:

- An out-of-bounds WRITE, not a read: memcpy_from_msg() into
sndbuf_base + chunk_off for a length the peer influences - 869056 bytes
into a 65504-byte buffer in our run.
- The attacker is the remote SMC-D peer. No local privilege is involved;
the local application is an ordinary sender.
- The bytes written are the local sender's payload rather than the peer's,
which limits what a peer can place there but not where it lands.
- Reachable only with CONFIG_SMC, an ISM/dibs device whose
support_dmb_nocopy() is true, and an SMC-D connection to that peer.

We are not claiming an exploit, and we have not looked at what follows the
DMB mapping.


5. Reproducer
=============

There is no reproducer that uses only unmodified kernel interfaces, for the
reasons in section 3: the cursor cannot be forged from userspace on the one
SMC-D device we have.

What we can send, to anyone who wants to repeat the run: the debug patch that
stands in for the peer (simulated-peer-debug.patch, 70 lines, including the
two pr_info()s) and the SMC-D bulk-transfer program it is driven with. The
program needs CONFIG_SMC, CONFIG_DIBS_LO and KASAN, and a registered UEID -
without one the SMC-Dv2 handshake declines with 0x03030008
(SMC_CLC_DECL_NOUEID) and silently falls back to TCP.


6. Suggested fix
================

Attached: 0001-net-smc-bound-a-send-against-the-send-buffer-not-aga.patch

One line: clamp copylen to conn->sndbuf_desc->len after it has been clamped
to what userspace asked for. That bounds the copy at the point the copy is
made, whatever the credit says, and changes nothing for a correct peer.

The alternative is to cap the credit at the atomic_add(), which would
enforce the invariant the comment there states. We are happy to send that
instead, or both; we chose the clamp because it is local to the code that
has to be safe.


7. What was and was not checked
===============================

- The patch builds and net/smc/smc_tx.o compiles clean on net.git main at
d5b89d55a322 with clang and KASAN.
- SMC-D traffic over loopback-ISM works with it applied (section 3).
- The three receive-side faults in our other report still do not fire on
the kernel carrying both patches.

Not checked:

- Real ISM hardware, or any SMC-D peer that is not this kernel.
- The write side on SMC-R, where sndbuf_space is credited from our own
cursors; we believe it is not reachable there and are not claiming it
is.
- Whether a peer can steer what the overflow lands on.

How this was found: by AI-driven fuzzing built on top of syzkaller. Its analysis was then checked by hand against the code, and the credit inflation in
section 3 measured. The out-of-bounds write was not reproduced.


Thanks,
Piyus Kedia
Kapil Vaswani