rxrpc: Miscellaneous fixes
Subsystems (4)
David Howells
maintainercover rxrpc: Miscellaneous fixes
Here are some miscellaneous AF_RXRPC fixes:
(1) Make sure rxrpc_verify_data() allocates a buffer, even if the DATA packet being looked at is zero length to avoid potential NULL-pointer exceptions.
(2) Don't move an OOB message (e.g. an RxGK CHALLENGE) off the receive queue onto the pending queue in recvmsg() if MSG_PEEK is specified.
(3) Fix a potential UAF in rxgk_issue_challenge() in which a tracepoint refers to memory just freed by a different pointer.
(4) Fix afs net namespace teardown to cancel the incoming call preallocation charger before we disable listening (which will delete the preallocation queue).
(5) Fix rxrpc_kernel_charge_accept() to use the socket mutex to defend against listen(0)/shutdown simultaneously deleting the preallocation queue.
David
The patches can be found here also:
http://git.kernel.org/cgit/linux/kernel/git/dhowells/linux-fs.git/log/?h=rxrpc-fixes
David Howells (2):
rxrpc: Fix UAF in rxgk_issue_challenge()
afs: Fix netns teardown to cancel the preallocation charger
Hyunwoo Kim (1):
rxrpc: Don't move a peeked OOB message onto the pending queue
Jeffrey Altman (1):
rxrpc: rxrpc_verify_data ensure rx_dec_buffer alloc
Li Daming (1):
rxrpc: serialize kernel accept preallocation with socket teardown
fs/afs/rxrpc.c | 6 ++++-- net/rxrpc/call_accept.c | 25 +++++++++++++++++++------ net/rxrpc/recvmsg.c | 13 +++++++------ net/rxrpc/rxgk.c | 3 ++- 4 files changed, 32 insertions(+), 15 deletions(-)
David Howells
maintainerPATCH 1/5 rxrpc: rxrpc_verify_data ensure rx_dec_buffer alloc
From: Jeffrey Altman <[email protected]>
rxrpc_recvmsg_data() calls rxrpc_verify_data() whenever the rxrpc_call.rx_dec_buffer is unallocated and assumes that upon successful return that rx_dec_buffer must be allocated. However, rxrpc_verify_data() does not request an allocation if the rxrpc_skb_priv.len is zero.
In addition, failure to allocate rx_dec_buffer will result in a call to skb_copy_bits() with a NULL destination which can trigger a NULL pointer dereference.
To prevent these issues rxrpc_verify_data() is modified to always attempt to allocate the rxrpc_call.rx_dec_buffer if it is NULL.
This issue was identified with assistance of a private sashiko instance.
--- net/rxrpc/recvmsg.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
net/rxrpc/recvmsg.c +1 -1
@@ -161,7 +161,7 @@ static int rxrpc_verify_data(struct rxrpc_call *call, struct sk_buff *skb)struct rxrpc_skb_priv *sp =rxrpc_skb (skb);int ret; -if (sp->len > call->rx_dec_bsize) { +if (sp->len > call->rx_dec_bsize || !call->rx_dec_buffer) {/* Make sure we can hold a 1412-byte jumbo subpacket and make * sure that the buffer size is aligned to a crypto blocksize. */
David Howells
maintainerPATCH 2/5 rxrpc: Don't move a peeked OOB message onto the pending queue
In reply to David HowellsFrom: Hyunwoo Kim <[email protected]>
rxrpc_recvmsg_oob() takes a received oob message off recvmsg_oobq and, if a response is needed, moves it onto the pending_oobq tree. However, only the unlink from recvmsg_oobq is guarded by MSG_PEEK; the move onto pending_oobq always runs.
As a result, reading a challenge with MSG_PEEK leaves the skb on recvmsg_oobq while also adding it to pending_oobq. Since struct sk_buff's rbnode shares storage with its next and prev pointers, rb_insert_color() overwrites the list linkage, and the skb, which holds a single reference, becomes reachable from both queues at once.
When the socket is closed both queues are drained in turn. While draining recvmsg_oobq, __skb_unlink() follows the next and prev pointers that rbnode has overwritten and writes to a bad address. Also, as the skb holds a single reference but is freed from each queue, both the skb and the connection reference it holds are released twice. This leads to memory corruption and to a use-after-free caused by the connection refcount underflow.
MSG_PEEK does not consume the message from the queue, so only unlink it from recvmsg_oobq and then move it onto pending_oobq or free it when the message is actually consumed.
--- net/rxrpc/recvmsg.c | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-)
net/rxrpc/recvmsg.c +6 -5
@@ -262,12 +262,13 @@ static int rxrpc_recvmsg_oob(struct socket *sock, struct msghdr *msg,break ; } -if (!(flags &MSG_PEEK )) +if (!(flags &MSG_PEEK )) {skb_unlink (skb, &rx->recvmsg_oobq); -if (need_response) -rxrpc_add_pending_oob (rx, skb); -else -rxrpc_free_skb (skb, rxrpc_skb_put_oob); +if (need_response) +rxrpc_add_pending_oob (rx, skb); +else +rxrpc_free_skb (skb, rxrpc_skb_put_oob); + }return ret; }
David Howells
maintainerPATCH 3/5 rxrpc: Fix UAF in rxgk_issue_challenge()
In reply to David HowellsFix rxgk_issue_challenge() to free the page containing the challenge content after invoking the tracepoint as the whdr passed to the tracepoint points into the page just freed.
--- net/rxrpc/rxgk.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
net/rxrpc/rxgk.c +2 -1
@@ -687,16 +687,17 @@ static int rxgk_issue_challenge(struct rxrpc_connection *conn) ret =do_udp_sendmsg (conn->local->socket, &msg, len);if (ret >0 )rxrpc_peer_mark_tx (conn->peer); -__free_page (page);if (ret <0 ) {trace_rxrpc_tx_fail (conn->debug_id, serial, ret, rxrpc_tx_point_rxgk_challenge); +__free_page (page);return -EAGAIN ; }trace_rxrpc_tx_packet (conn->debug_id, whdr, rxrpc_tx_point_rxgk_challenge); +__free_page (page);_leave (" = 0" );return 0 ; }
David Howells
maintainerPATCH 4/5 afs: Fix netns teardown to cancel the preallocation charger
In reply to David HowellsFix the teardown of an afs network namespace to make sure it cancels the work item that keeps the preallocated rxrpc call/conn/peer queue charged before incoming calls are disabled (i.e. listen 0).
Also, if net->live is false because the afs netns is being deleted, make afs_charge_preallocation() skip charging and make afs_rx_new_call() avoid requeuing the charger.
(This was found by AI review).
--- fs/afs/rxrpc.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
fs/afs/rxrpc.c +4 -2
@@ -127,6 +127,7 @@ void afs_close_socket(struct afs_net *net) {_enter ("" ); +cancel_work_sync (&net->charge_preallocation_work);kernel_listen (net->socket,0 );flush_workqueue (afs_async_calls);
@@ -742,7 +743,7 @@ void afs_charge_preallocation(struct work_struct *work) container_of(work, struct afs_net, charge_preallocation_work);struct afs_call *call = net->spare_incoming_call; -for (;;) { +while (READ_ONCE (net->live)) {if (!call) { call =afs_alloc_call (net, &afs_RXCMxxxx,GFP_KERNEL );if (!call)
@@ -792,7 +793,8 @@ static void afs_rx_new_call(struct sock *sk, struct rxrpc_call *rxcall,if (!call->server)trace_afs_cm_no_server (call,rxrpc_kernel_remote_srx (call->peer)); -queue_work (afs_wq, &net->charge_preallocation_work); +if (net->live) +queue_work (afs_wq, &net->charge_preallocation_work); }/*
Jakub Kicinski
maintainerRe: [PATCH net 4/5] afs: Fix netns teardown to cancel the preallocation charger
Quoted 9 lines · On Tue, 9 Jun 2026 15:09:08 +0100 David Howells wrote:
Fix the teardown of an afs network namespace to make sure it cancels the work item that keeps the preallocated rxrpc call/conn/peer queue charged before incoming calls are disabled (i.e. listen 0).
Also, if
net->liveis false because the afs netns is being deleted, makeafs_charge_preallocation()skip charging and makeafs_rx_new_call()avoid requeuing the charger.(This was found by AI review).
Both Sashikos think this patch is still racy FWIW but not a blocker IMO
David Howells
maintainerPATCH 5/5 rxrpc: serialize kernel accept preallocation with socket teardown
In reply to David HowellsFrom: Li Daming <[email protected]>
rxrpc_kernel_charge_accept() reads rx->backlog without any socket/backlog synchronization and passes that raw pointer into rxrpc_service_prealloc_one(). A concurrent rxrpc_discard_prealloc() sets rx->backlog = NULL and frees the backlog rings, so a kernel preallocation worker can keep using a freed struct rxrpc_backlog while updating *_backlog_head/tail and array slots.
Serialize the state check and backlog lookup with the socket lock, and reject kernel preallocation once teardown has disabled listening or discarded the service backlog.
--- net/rxrpc/call_accept.c | 25 +++++++++++++++++++------ 1 file changed, 19 insertions(+), 6 deletions(-)
net/rxrpc/call_accept.c +19 -6
@@ -471,13 +471,26 @@ int rxrpc_kernel_charge_accept(struct socket *sock, rxrpc_notify_rx_t notify_rx, unsigned long user_call_ID, gfp_t gfp, unsigned int debug_id) { - struct rxrpc_sock *rx = rxrpc_sk(sock->sk); -struct rxrpc_backlog *b = rx->backlog; + struct rxrpc_backlog *b; +struct rxrpc_sock *rx; +struct sock *sk; +int ret; -if (sock->sk->sk_state ==RXRPC_CLOSE ) -return -ESHUTDOWN ; + sk = sock->sk; + rx =rxrpc_sk (sk); + +lock_sock (sk); +if (sk->sk_state !=RXRPC_SERVER_LISTENING || !rx->backlog) { + ret = -ESHUTDOWN ; + goto out; + } + + b = rx->backlog; + ret =rxrpc_service_prealloc_one (rx, b, notify_rx, user_call_ID, + gfp, debug_id); -return rxrpc_service_prealloc_one (rx, b, notify_rx, user_call_ID, - gfp, debug_id); +out: +release_sock (sk); +return ret; }EXPORT_SYMBOL (rxrpc_kernel_charge_accept);
This series was applied to netdev/net.git (main) by Jakub Kicinski <[email protected]>:
Hello:
This series was applied to netdev/net.git (main)
by Jakub Kicinski <[email protected]>:
Quoted 10 lines · On Tue, 9 Jun 2026 15:09:04 +0100 you wrote:
Here are some miscellaneous
AF_RXRPCfixes:(1) Make sure
rxrpc_verify_data()allocates a buffer, even if the DATA packet being looked at is zero length to avoid potential NULL-pointer exceptions.(2) Don't move an OOB message (e.g. an RxGK CHALLENGE) off the receive queue onto the pending queue in
recvmsg()ifMSG_PEEKis specified.[...]
Here is the summary with links:
- [net,1/5] rxrpc: rxrpc_verify_data ensure rx_dec_buffer alloc
https://git.kernel.org/netdev/net/c/16c8ae9735c5 - [net,2/5] rxrpc: Don't move a peeked OOB message onto the pending queue https://git.kernel.org/netdev/net/c/5801cff7d5d7 - [net,3/5] rxrpc: Fix UAF in rxgk_issue_challenge() https://git.kernel.org/netdev/net/c/107a4cb0d47e - [net,4/5] afs: Fix netns teardown to cancel the preallocation charger https://git.kernel.org/netdev/net/c/47694fbc9d24 - [net,5/5] rxrpc: serialize kernel accept preallocation with socket teardown https://git.kernel.org/netdev/net/c/dc175389b18c
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html