can: bcm: add locking for bcm_op runtime updates

The CAN broadcast manager (CAN BCM) can send a sequence of CAN frames via
hrtimer. The content and also the length of the sequence can be changed
resp reduced at runtime where the 'currframe' counter is then set to zero.

Although this appeared to be a safe operation the updates of 'currframe'
can be triggered from user space and hrtimer context in bcm_can_tx().
Anderson Nascimento created a proof of concept that triggered a KASAN
slab-out-of-bounds read access which can be prevented with a spin_lock_bh.

At the rework of bcm_can_tx() the 'count' variable has been moved into
the protected section as this variable can be modified from both contexts
too.

Fixes: ffd980f976e7 ("[CAN]: Add broadcast manager (bcm) protocol")
Reported-by: Anderson Nascimento <anderson@allelesecurity.com>
Tested-by: Anderson Nascimento <anderson@allelesecurity.com>
Reviewed-by: Marc Kleine-Budde <mkl@pengutronix.de>
Signed-off-by: Oliver Hartkopp <socketcan@hartkopp.net>
Link: https://patch.msgid.link/20250519125027.11900-1-socketcan@hartkopp.net
Cc: stable@vger.kernel.org
Signed-off-by: Marc Kleine-Budde <mkl@pengutronix.de>

diff --git a/net/can/bcm.c b/net/can/bcm.c
index 0bca1b9..871707d 100644 (file)
--- a/net/can/bcm.c
+++ b/net/can/bcm.c
@@ -58,6 +58,7 @@
 #include <linux/can/skb.h>
 #include <linux/can/bcm.h>
 #include <linux/slab.h>
+#include <linux/spinlock.h>
 #include <net/sock.h>
 #include <net/net_namespace.h>
 
@@ -122,6 +123,7 @@ struct bcm_op {
        struct canfd_frame last_sframe;
        struct sock *sk;
        struct net_device *rx_reg_dev;
+       spinlock_t bcm_tx_lock; /* protect currframe/count in runtime updates */
 };
 
 struct bcm_sock {
@@ -285,13 +287,18 @@ static void bcm_can_tx(struct bcm_op *op)
 {
        struct sk_buff *skb;
        struct net_device *dev;
-       struct canfd_frame *cf = op->frames + op->cfsiz * op->currframe;
+       struct canfd_frame *cf;
        int err;
 
        /* no target device? => exit */
        if (!op->ifindex)
                return;
 
+       /* read currframe under lock protection */
+       spin_lock_bh(&op->bcm_tx_lock);
+       cf = op->frames + op->cfsiz * op->currframe;
+       spin_unlock_bh(&op->bcm_tx_lock);
+
        dev = dev_get_by_index(sock_net(op->sk), op->ifindex);
        if (!dev) {
                /* RFC: should this bcm_op remove itself here? */
@@ -312,6 +319,10 @@ static void bcm_can_tx(struct bcm_op *op)
        skb->dev = dev;
        can_skb_set_owner(skb, op->sk);
        err = can_send(skb, 1);
+
+       /* update currframe and count under lock protection */
+       spin_lock_bh(&op->bcm_tx_lock);
+
        if (!err)
                op->frames_abs++;
 
@@ -320,6 +331,11 @@ static void bcm_can_tx(struct bcm_op *op)
        /* reached last frame? */
        if (op->currframe >= op->nframes)
                op->currframe = 0;
+
+       if (op->count > 0)
+               op->count--;
+
+       spin_unlock_bh(&op->bcm_tx_lock);
 out:
        dev_put(dev);
 }
@@ -430,7 +446,7 @@ static enum hrtimer_restart bcm_tx_timeout_handler(struct hrtimer *hrtimer)
        struct bcm_msg_head msg_head;
 
        if (op->kt_ival1 && (op->count > 0)) {
-               op->count--;
+               bcm_can_tx(op);
                if (!op->count && (op->flags & TX_COUNTEVT)) {
 
                        /* create notification to user */
@@ -445,7 +461,6 @@ static enum hrtimer_restart bcm_tx_timeout_handler(struct hrtimer *hrtimer)
 
                        bcm_send_to_user(op, &msg_head, NULL, 0);
                }
-               bcm_can_tx(op);
 
        } else if (op->kt_ival2) {
                bcm_can_tx(op);
@@ -956,6 +971,27 @@ static int bcm_tx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,
                }
                op->flags = msg_head->flags;
 
+               /* only lock for unlikely count/nframes/currframe changes */
+               if (op->nframes != msg_head->nframes ||
+                   op->flags & TX_RESET_MULTI_IDX ||
+                   op->flags & SETTIMER) {
+
+                       spin_lock_bh(&op->bcm_tx_lock);
+
+                       if (op->nframes != msg_head->nframes ||
+                           op->flags & TX_RESET_MULTI_IDX) {
+                               /* potentially update changed nframes */
+                               op->nframes = msg_head->nframes;
+                               /* restart multiple frame transmission */
+                               op->currframe = 0;
+                       }
+
+                       if (op->flags & SETTIMER)
+                               op->count = msg_head->count;
+
+                       spin_unlock_bh(&op->bcm_tx_lock);
+               }
+
        } else {
                /* insert new BCM operation for the given can_id */
 
@@ -963,9 +999,14 @@ static int bcm_tx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,
                if (!op)
                        return -ENOMEM;
 
+               spin_lock_init(&op->bcm_tx_lock);
                op->can_id = msg_head->can_id;
                op->cfsiz = CFSIZ(msg_head->flags);
                op->flags = msg_head->flags;
+               op->nframes = msg_head->nframes;
+
+               if (op->flags & SETTIMER)
+                       op->count = msg_head->count;
 
                /* create array for CAN frames and copy the data */
                if (msg_head->nframes > 1) {
@@ -1023,22 +1064,8 @@ static int bcm_tx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,
 
        } /* if ((op = bcm_find_op(&bo->tx_ops, msg_head->can_id, ifindex))) */
 
-       if (op->nframes != msg_head->nframes) {
-               op->nframes   = msg_head->nframes;
-               /* start multiple frame transmission with index 0 */
-               op->currframe = 0;
-       }
-
-       /* check flags */
-
-       if (op->flags & TX_RESET_MULTI_IDX) {
-               /* start multiple frame transmission with index 0 */
-               op->currframe = 0;
-       }
-
        if (op->flags & SETTIMER) {
                /* set timer values */
-               op->count = msg_head->count;
                op->ival1 = msg_head->ival1;
                op->ival2 = msg_head->ival2;
                op->kt_ival1 = bcm_timeval_to_ktime(msg_head->ival1);
@@ -1055,11 +1082,8 @@ static int bcm_tx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,
                op->flags |= TX_ANNOUNCE;
        }
 
-       if (op->flags & TX_ANNOUNCE) {
+       if (op->flags & TX_ANNOUNCE)
                bcm_can_tx(op);
-               if (op->count)
-                       op->count--;
-       }
 
        if (op->flags & STARTTIMER)
                bcm_tx_start_timer(op);