rxrpc: Miscellaneous fixes
Subsystems (5)
David Howells
maintainercover rxrpc: Miscellaneous fixes
Here are some fixes for rxrpc, as found by Sashiko[1]:
(1) Fix leaks in rxkad_verify_response().
(2) Fix lack of unsharing of RESPONSE packets.
(3) Fix integer overflow in RxGK ticket length check.
(4) Fix handling of rxkad-encrypted packets with crypto-misaligned lengths.
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 (4):
rxrpc: Fix memory leaks in rxkad_verify_response()
rxrpc: Fix conn-level packet handling to unshare RESPONSE packets
rxgk: Fix potential integer overflow in length check
rxrpc: Fix rxkad crypto unalignment handling
include/linux/key.h | 2 + include/trace/events/rxrpc.h | 1 + net/rxrpc/ar-internal.h | 2 +- net/rxrpc/conn_event.c | 12 ++- net/rxrpc/io_thread.c | 15 +--- net/rxrpc/rxgk_app.c | 2 +- net/rxrpc/rxgk_common.h | 1 + net/rxrpc/rxkad.c | 142 +++++++++++++---------------------- net/rxrpc/skbuff.c | 26 ++++++- 9 files changed, 94 insertions(+), 109 deletions(-)
David Howells
maintainerPATCH 1/4 rxrpc: Fix memory leaks in rxkad_verify_response()
Fix rxkad_verify_response() to free ticket by using a __free() construct rather than explicitly freeing it.
Also fix rxkad_verify_response() to free the server key by using a __free() construct.
--- include/linux/key.h | 2 + net/rxrpc/rxkad.c | 133 +++++++++++++++----------------------------- 2 files changed, 48 insertions(+), 87 deletions(-)
include/linux/key.h +2 -0
@@ -304,6 +304,8 @@ extern void key_put(struct key *key);extern bool key_put_tag (struct key_tag *tag);extern void key_remove_domain (struct key_tag *domain_tag); +DEFINE_FREE(key_put, struct key *, if (!IS_ERR(_T)) key_put(_T)) +static inline struct key *__key_get (struct key *key) {refcount_inc (&key->usage);
net/rxrpc/rxkad.c +46 -87
216 lines not on this page · raw message
David Howells
maintainerPATCH 2/4 rxrpc: Fix conn-level packet handling to unshare RESPONSE packets
In reply to David HowellsThe security operations that verify the RESPONSE packets decrypt bits of it in place - however, the sk_buff may be shared with a packet sniffer, which would lead to the sniffer seeing an apparently corrupt packet (actually decrypted).
Fix this by unsharing the skbuff before handing it off to the specific security handler.
--- net/rxrpc/ar-internal.h | 2 +- net/rxrpc/conn_event.c | 12 ++++++++++-- net/rxrpc/io_thread.c | 15 +++------------ net/rxrpc/skbuff.c | 26 ++++++++++++++++++++++---- 4 files changed, 36 insertions(+), 19 deletions(-)
net/rxrpc/ar-internal.h +1 -1
@@ -1486,7 +1486,7 @@ int rxrpc_server_keyring(struct rxrpc_sock *, sockptr_t, int);void rxrpc_kernel_data_consumed (struct rxrpc_call *,struct sk_buff *);void rxrpc_new_skb (struct sk_buff *,enum rxrpc_skb_trace );void rxrpc_see_skb (struct sk_buff *,enum rxrpc_skb_trace ); -void rxrpc_eaten_skb (struct sk_buff *,enum rxrpc_skb_trace ); +struct sk_buff *rxrpc_unshare_skb (struct sk_buff **_old,gfp_t gfp);void rxrpc_get_skb (struct sk_buff *,enum rxrpc_skb_trace );void rxrpc_free_skb (struct sk_buff *,enum rxrpc_skb_trace );void rxrpc_purge_queue (struct sk_buff_head *);
net/rxrpc/conn_event.c +10 -2
@@ -244,8 +244,9 @@ static void rxrpc_call_is_secure(struct rxrpc_call *call)* connection-level Rx packet processor */ static int rxrpc_process_event (struct rxrpc_connection *conn, -struct sk_buff *skb) +struct sk_buff **_skb) { +struct sk_buff *skb = *_skb;struct rxrpc_skb_priv *sp =rxrpc_skb (skb);bool secured = false;int ret;
@@ -270,6 +271,13 @@ static int rxrpc_process_event(struct rxrpc_connection *conn, }spin_unlock_irq (&conn->state_lock); + skb =rxrpc_unshare_skb (_skb,GFP_NOFS ); +if (!skb) +return -ENOMEM ; + +/* If unshared, skb will have changed. */ + sp =rxrpc_skb (skb); + ret = conn->security->verify_response (conn, skb);if (ret <0 )return ret;
@@ -371,7 +379,7 @@ static void rxrpc_do_process_connection(struct rxrpc_connection *conn)* connection that each one has when we've finished with it */ while ((skb =skb_dequeue (&conn->rx_queue))) {rxrpc_see_skb (skb, rxrpc_skb_see_conn_work); - ret =rxrpc_process_event (conn, skb); + ret =rxrpc_process_event (conn, &skb);switch (ret) {case -ENOMEM :case -EAGAIN :
net/rxrpc/io_thread.c +3 -12
@@ -249,19 +249,10 @@ static bool rxrpc_input_packet(struct rxrpc_local *local, struct sk_buff **_skb)* decryption. */ if (sp->hdr.securityIndex !=0 ) { - skb =skb_unshare (skb,GFP_ATOMIC ); -if (!skb) { -rxrpc_eaten_skb (*_skb, rxrpc_skb_eaten_by_unshare_nomem); - *_skb =NULL ; + skb =rxrpc_unshare_skb (_skb,GFP_ATOMIC ); +if (!skb)return just_discard; - } - -if (skb != *_skb) { -rxrpc_eaten_skb (*_skb, rxrpc_skb_eaten_by_unshare); - *_skb = skb; -rxrpc_new_skb (skb, rxrpc_skb_new_unshared); - sp =rxrpc_skb (skb); - } + sp =rxrpc_skb (skb); }break ;
net/rxrpc/skbuff.c +22 -4
@@ -47,12 +47,30 @@ void rxrpc_get_skb(struct sk_buff *skb, enum rxrpc_skb_trace why) }/* -* Note the dropping of a ref on a socket buffer by the core. +* Do the unsharing of a socket buffer, noting the event in the traces. */ -void rxrpc_eaten_skb (struct sk_buff *skb,enum rxrpc_skb_trace why) +struct sk_buff *rxrpc_unshare_skb (struct sk_buff **_old,gfp_t gfp) { -int n =atomic_inc_return (&rxrpc_n_rx_skbs); -trace_rxrpc_skb (skb,0 , n, why); +struct sk_buff *skb, *old = *_old; +int n, r =refcount_read (&old->users); + + skb =skb_unshare (old, gfp); +if (!skb) { + n =atomic_dec_return (&rxrpc_n_rx_skbs); +trace_rxrpc_skb (old, r, n, rxrpc_skb_eaten_by_unshare_nomem); + *_old =NULL ; +return skb; + } + +if (skb != old) { + n =atomic_read (&rxrpc_n_rx_skbs); +trace_rxrpc_skb (old, r, n, rxrpc_skb_eaten_by_unshare); +trace_rxrpc_skb (skb,refcount_read (&skb->users), n, + rxrpc_skb_new_unshared); + *_old = skb; + } + +return skb; }/*
David Howells
maintainerPATCH 3/4 rxgk: Fix potential integer overflow in length check
In reply to David HowellsFix potential integer overflow in rxgk_extract_token() when checking the length of the ticket. Rather than rounding up the value to be tested (which might overflow), round down the size of the available data.
--- net/rxrpc/rxgk_app.c | 2 +- net/rxrpc/rxgk_common.h | 1 + 2 files changed, 2 insertions(+), 1 deletion(-)
net/rxrpc/rxgk_app.c +1 -1
@@ -214,7 +214,7 @@ int rxgk_extract_token(struct rxrpc_connection *conn, struct sk_buff *skb, ticket_len =ntohl (container.token_len); ticket_offset = token_offset +sizeof (container); -if (xdr_round_up (ticket_len) > token_len -sizeof (container)) +if (ticket_len >xdr_round_down (token_len -sizeof (container))) goto short_packet;_debug ("KVNO %u" , kvno);
net/rxrpc/rxgk_common.h +1 -0
@@ -34,6 +34,7 @@ struct rxgk_context { };#define xdr_round_up (x) (round_up((x), sizeof(__be32))) +#define xdr_round_down (x) (round_down((x), sizeof(__be32)))#define xdr_object_len (x) (4 + xdr_round_up(x))/*
David Howells
maintainerPATCH 4/4 rxrpc: Fix rxkad crypto unalignment handling
In reply to David HowellsFix handling of a packet with a misaligned crypto length. Also handle non-ENOMEM errors from decryption by aborting. Further, remove the WARN_ON_ONCE() so that it can't be remotely triggered (a trace line can still be emitted).
--- include/trace/events/rxrpc.h | 1 + net/rxrpc/rxkad.c | 9 +++++++-- 2 files changed, 8 insertions(+), 2 deletions(-)
include/trace/events/rxrpc.h +1 -0
@@ -37,6 +37,7 @@ EM(rxkad_abort_1_short_encdata, "rxkad1-short-encdata") \ EM(rxkad_abort_1_short_header, "rxkad1-short-hdr") \ EM(rxkad_abort_2_short_check, "rxkad2-short-check") \ + EM(rxkad_abort_2_crypto_unaligned, "rxkad2-crypto-unaligned") \ EM(rxkad_abort_2_short_data, "rxkad2-short-data") \ EM(rxkad_abort_2_short_header, "rxkad2-short-hdr") \EM (rxkad_abort_2_short_len,"rxkad2-short-len" ) \
net/rxrpc/rxkad.c +7 -2
@@ -510,6 +510,9 @@ static int rxkad_verify_packet_2(struct rxrpc_call *call, struct sk_buff *skb,return rxrpc_abort_eproto (call, skb,RXKADSEALEDINCON , rxkad_abort_2_short_header); +/* Don't let the crypto algo see a misaligned length. */ + sp->len =round_down (sp->len,8 ); +/* Decrypt the skbuff in-place. TODO: We really want to decrypt * directly into the target buffer. */
@@ -543,8 +546,10 @@ static int rxkad_verify_packet_2(struct rxrpc_call *call, struct sk_buff *skb,if (sg != _sg)kfree (sg);if (ret <0 ) { -WARN_ON_ONCE (ret != -ENOMEM ); -return ret; +if (ret == -ENOMEM ) +return ret; +return rxrpc_abort_eproto (call, skb,RXKADSEALEDINCON , + rxkad_abort_2_crypto_unaligned); }/* Extract the decrypted packet length */
Simon Horman
reviewerRe: [PATCH net 1/4] rxrpc: Fix memory leaks in rxkad_verify_response()
In reply to David HowellsQuoted 10 lines · David Howells
Fix
rxkad_verify_response()to free ticket by using a__free()construct rather than explicitly freeing it.Also fix
rxkad_verify_response()to free the server key by using a__free()construct.Fixes 57af281e5389 ("rxrpc: Tidy up abort generation infrastructure")Fixes ec832bd06d6f ("rxrpc: Don't retain the server key in the connection")Signed-off-by David Howells <[email protected]>
...
Quoted 3 lines
index
eb7f2769d2b1..0acdc46f42c2100644net/rxrpc/rxkad.c +0
-0
...
net/rxrpc/rxkad.c static int rxkad_verify_response(struct rxrpc_connection *conn, · line 1166
Quoted 10 lines
net/rxrpc/rxkad.c +2
-1@@ -1160,16 +1159,15 @@ static int rxkad_verify_response(struct rxrpc_connection *conn, } ret = -ENOMEM ; - response = kzalloc_obj(struct rxkad_response, GFP_NOFS); + struct rxkad_response *response __free(kfree) = + kzalloc_obj(struct rxkad_response, GFP_NOFS);if (!response) goto temporary_error;
Hi David,
This goto, combined with the use of __free in the declaration of ticket below results in a compile error for x86_64 allmodconfig with clang 21.1.8.
net/rxrpc/rxkad.c:1165:3: error: cannot jump from this goto statement to its label
1165 | goto temporary_error;
| ^ net/rxrpc/rxkad.c:1192:8: note: jump bypasses initialization of variable with __attribute__((cleanup))
1192 | void *ticket __free(kfree) = kmalloc(ticket_len, GFP_NOFS);
| ^
Moreover, the use of this construct is discouraged in Networking code:
1.7.3. Using device-managed and cleanup.h constructs¶
Netdev remains skeptical about promises of all “auto-cleanup” APIs, including even devm_ helpers, historically. They are not the preferred style of implementation, merely an acceptable one.
Use of guard() is discouraged within any function longer than 20 lines, scoped_guard() is considered more readable. Using normal lock/unlock is still (weakly) preferred.
Low level cleanup constructs (such as __free()) can be used when building APIs and helpers, especially scoped iterators. However, direct use of __free() within networking core and drivers is discouraged. Similar guidance applies to declaring variables mid-function.
https://docs.kernel.org/process/maintainer-netdev.html#using-device-managed-and-cleanup-h-constructs
And to round things out, Sashiko also points out problems with the use of __free() in this patch.
...
Quoted 8 lines
net/rxrpc/rxkad.c +2
-2/* extract the kerberos ticket and decrypt and decode it */ ret = -ENOMEM ; - ticket =kmalloc (ticket_len,GFP_NOFS ); + void *ticket __free(kfree) = kmalloc(ticket_len, GFP_NOFS);if (!ticket) - goto temporary_error_free_resp; + goto temporary_error;
...
Quoted 10 lines
temporary_error:net/rxrpc/rxkad.c +0
-1/* Ignore the response packet if we got a temporary error such as * ENOMEM. We just want to send the challenge again. Note that we * also come out this way if the ticket decryption fails. */ -key_put (server_key);return ret; }
Signature · 1 line
pw-bot: changes-requested
Simon Horman
reviewerRe: [PATCH net 2/4] rxrpc: Fix conn-level packet handling to unshare RESPONSE packets
In reply to David HowellsFrom: 'Simon Horman' <[email protected]>
This is an AI-generated review of your patch. The human sending this email has considered the AI review valid, or at least plausible. Full review at: https://sashiko.dev
---
Subject: rxrpc: Fix conn-level packet handling to unshare RESPONSE packets
This commit modifies the RxRPC connection-level packet processor to unshare RESPONSE packets before decryption. It introduces a new rxrpc_unshare_skb() helper to safely unshare skbuffs passed via a double pointer and replaces direct calls to skb_unshare().
Quoted 4 lines
net/rxrpc/conn_event.c +0
-0
[ ... ]
net/rxrpc/conn_event.c static void rxrpc_do_process_connection(struct rxrpc_connection *conn) · line 385
Quoted 9 lines
net/rxrpc/conn_event.c +1
-1@@ -371,7 +379,7 @@ static void rxrpc_do_process_connection(struct rxrpc_connection *conn)* connection that each one has when we've finished with it */ while ((skb =skb_dequeue (&conn->rx_queue))) {rxrpc_see_skb (skb, rxrpc_skb_see_conn_work); - ret =rxrpc_process_event (conn, skb); + ret =rxrpc_process_event (conn, &skb);switch (ret) {case -ENOMEM :case -EAGAIN :
Looking at the code immediately following this hunk in rxrpc_do_process_connection():
switch (ret) {
case -ENOMEM:
case -EAGAIN:
skb_queue_head(&conn->rx_queue, skb);
rxrpc_queue_conn(conn, rxrpc_conn_queue_retry_work);
break;If rxrpc_process_event() fails with -ENOMEM because rxrpc_unshare_skb() failed, rxrpc_unshare_skb() will have set *_skb = NULL.
Does this mean skb is NULL when we reach skb_queue_head()?
Since skb_queue_head() dereferences the skb parameter, this appears to result in a NULL pointer dereference. Furthermore, since skb_unshare() frees the original skb on allocation failure, the packet is already gone and requeuing it wouldn't be possible anyway.
Quoted 4 lines
net/rxrpc/io_thread.c +0
-0
[ ... ]
net/rxrpc/io_thread.c static bool rxrpc_input_packet(struct rxrpc_local *local, struct sk_buff **_skb) · line 257
Quoted 12 lines
net/rxrpc/io_thread.c +2
-5@@ -249,19 +249,10 @@ static bool rxrpc_input_packet(struct rxrpc_local *local, struct sk_buff **_skb)* decryption. */ if (sp->hdr.securityIndex !=0 ) { - skb =skb_unshare (skb,GFP_ATOMIC ); -if (!skb) { -rxrpc_eaten_skb (*_skb, rxrpc_skb_eaten_by_unshare_nomem); - *_skb =NULL ; + skb =rxrpc_unshare_skb (_skb,GFP_ATOMIC ); +if (!skb)return just_discard; - }
This isn't a new bug introduced by this patch, but since we are modifying the unshare path here: when rxrpc_unshare_skb() fails, it sets *_skb = NULL and returns just_discard.
Back in rxrpc_io_thread(), the packet is processed like this:
net/rxrpc/io_thread.c:rxrpc_io_thread() {
...
while ((skb = __skb_dequeue(&rx_queue))) {
struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
switch (skb->mark) {
case RXRPC_SKB_MARK_PACKET:
skb->priority = 0;
if (!rxrpc_input_packet(local, &skb))
rxrpc_reject_packet(local, skb);
trace_rxrpc_rx_done(skb->mark, skb->priority);...
If rxrpc_input_packet() sets skb to NULL and returns false (just_discard), does this cause a NULL pointer dereference when trace_rxrpc_rx_done() tries to access skb->mark?
David Howells
maintainerRe: [PATCH net 2/4] rxrpc: Fix conn-level packet handling to unshare RESPONSE packets
Quoted 3 lines · Simon Horman
This isn't a new bug introduced by this patch, but since we are modifying the unshare path here: when
rxrpc_unshare_skb()fails, it sets*_skb= NULL and returnsjust_discard.
Is there a way to avoid having skb_unshare() eat your ref to the source skbuff if it fails?
David