HID: magicmouse: prevent unbounded recursion in magicmouse_raw_event()

[ Upstream commit db8d634128d2ba88d79c0b601e983ebe14bb0519 ]

magicmouse_raw_event() handles DOUBLE_REPORT_ID (0xf7) packets, which pack
two touch reports into one, by splitting the packet and calling itself on
each half. The only guard against runaway recursion is a "size < 1" check,
which stops zero-sized calls but does not bound the recursion depth.

A malicious HID device that matches this driver can send a report starting
with DOUBLE_REPORT_ID and filled with the sequence [0xf7, 0x00]. Each level
consumes two bytes and recurses on the remainder, so an incoming report of
up to HID_MAX_BUFFER_SIZE (16 KiB) drives roughly 8000 nested calls. That
easily exhausts the 16 KiB kernel stack, leading to a stack overflow: a
panic with CONFIG_VMAP_STACK, or memory corruption without it.

A double report only ever wraps two normal reports; it is never
legitimately nested. Refuse to re-enter the DOUBLE_REPORT_ID case from a
recursive call so the recursion depth is bounded to two, while all valid
packets keep being parsed exactly as before.

Fixes: a462230e16ac ("HID: magicmouse: enable Magic Trackpad support")
Link: https://lore.kernel.org/linux-input/20260706181347.700DB1F00A3F@smtp.kernel.org/
Cc: stable@vger.kernel.org
Signed-off-by: Jose Villaseñor Montfort <pepemontfort@gmail.com>
Reviewed-by: Alec Hall <signshop.alec@gmail.com>
Tested-by: Alec Hall <signshop.alec@gmail.com>
Signed-off-by: Jiri Kosina <jkosina@suse.com>
Signed-off-by: Sasha Levin <sashal@kernel.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/drivers/hid/hid-magicmouse.c b/drivers/hid/hid-magicmouse.c
index ccdb29559fec2ac715aa83239785749128f2a72f..0480e7d216bc4f8916b4db75c9bd82f28ae4f5bf 100644 (file)
--- a/drivers/hid/hid-magicmouse.c
+++ b/drivers/hid/hid-magicmouse.c
@@ -383,8 +383,8 @@ static void magicmouse_emit_touch(struct magicmouse_sc *msc, int raw_id, u8 *tda
        }
 }
 
-static int magicmouse_raw_event(struct hid_device *hdev,
-               struct hid_report *report, u8 *data, int size)
+static int __magicmouse_raw_event(struct hid_device *hdev,
+               struct hid_report *report, u8 *data, int size, bool nested)
 {
        struct magicmouse_sc *msc = hid_get_drvdata(hdev);
        struct input_dev *input = msc->input;
@@ -495,6 +495,15 @@ static int magicmouse_raw_event(struct hid_device *hdev,
                 * packet.
                 */
 
+               /*
+                * A double report only ever wraps two normal reports, so it is
+                * never nested. Refuse to recurse a second time; otherwise a
+                * malicious device could chain DOUBLE_REPORT_ID packets to drive
+                * unbounded recursion and overflow the kernel stack.
+                */
+               if (nested)
+                       return 0;
+
                /* Ensure that we have at least 2 elements (report type and size) */
                if (size < 2)
                        return 0;
@@ -506,9 +515,9 @@ static int magicmouse_raw_event(struct hid_device *hdev,
                        return 0;
                }
 
-               magicmouse_raw_event(hdev, report, data + 2, data[1]);
-               magicmouse_raw_event(hdev, report, data + 2 + data[1],
-                       size - 2 - data[1]);
+               __magicmouse_raw_event(hdev, report, data + 2, data[1], true);
+               __magicmouse_raw_event(hdev, report, data + 2 + data[1],
+                       size - 2 - data[1], true);
                return 0;
        default:
                return 0;
@@ -534,6 +543,12 @@ static int magicmouse_raw_event(struct hid_device *hdev,
        return 1;
 }
 
+static int magicmouse_raw_event(struct hid_device *hdev,
+               struct hid_report *report, u8 *data, int size)
+{
+       return __magicmouse_raw_event(hdev, report, data, size, false);
+}
+
 static int magicmouse_event(struct hid_device *hdev, struct hid_field *field,
                struct hid_usage *usage, __s32 value)
 {