usb: gadget: fix race when gadget driver register via ioctl
Subsystems (2)
PATCH 1/1 usb: gadget: fix race when gadget driver register via ioctl
The usb_gadget_register_driver doesn't have inside locks to protect the driver, and If there is two threads are registered at the same time via the ioctl syscall, the system will crash as syzbot reported.
Call trace as:
driver_register+0x220/0x3a0 drivers/base/driver.c:171
usb_gadget_register_driver_owner+0xfb/0x1e0
drivers/usb/gadget/udc/core.c:1546
raw_ioctl_run drivers/usb/gadget/legacy/raw_gadget.c:513 [inline]
raw_ioctl+0x1883/0x2730 drivers/usb/gadget/legacy/raw_gadget.c:1220This routine allows two processes to register the same driver instance via ioctl syscall. which lead to a race condition.
We can fix it by adding a driver_lock to avoid double register.
--- drivers/usb/gadget/legacy/raw_gadget.c | 8 ++++++++ 1 file changed, 8 insertions(+)
drivers/usb/gadget/legacy/raw_gadget.c +8 -0
@@ -155,7 +155,9 @@ struct raw_dev {spinlock_t lock;const char *udc_name; +/* Protected by driver_lock for reentrant registration */ struct usb_gadget_driver driver; +struct mutex driver_lock;/* Reference to misc device: */ struct device *dev;
@@ -188,6 +190,8 @@ static struct raw_dev *dev_new(void)spin_lock_init (&dev->lock);init_completion (&dev->ep0_done);raw_event_queue_init (&dev->queue); +mutex_init (&dev->driver_lock); +return dev; }
@@ -398,7 +402,9 @@ static int raw_release(struct inode *inode, struct file *fd)spin_unlock_irqrestore (&dev->lock, flags);if (unregister) { +mutex_lock (&dev->driver_lock); ret =usb_gadget_unregister_driver (&dev->driver); +mutex_unlock (&dev->driver_lock);if (ret !=0 ) dev_err(dev->dev, "usb_gadget_unregister_driver() failed with %d\n",
@@ -510,7 +516,9 @@ static int raw_ioctl_run(struct raw_dev *dev, unsigned long value) }spin_unlock_irqrestore (&dev->lock, flags); +mutex_lock (&dev->driver_lock); ret =usb_gadget_register_driver (&dev->driver); +mutex_unlock (&dev->driver_lock);spin_lock_irqsave (&dev->lock, flags);if (ret) {
Signature · 1 line
2.29.0
Greg KH
maintainerQuoted 29 lines · Schspa Shi
The
usb_gadget_register_driverdoesn't have inside locks to protect the driver, and If there is two threads are registered at the same time via the ioctl syscall, the system will crash as syzbot reported.Call trace as:
driver_register+0x220/0x3a0 drivers/base/driver.c:171 usb_gadget_register_driver_owner+0xfb/0x1e0 drivers/usb/gadget/udc/core.c:1546 raw_ioctl_run drivers/usb/gadget/legacy/raw_gadget.c:513 [inline] raw_ioctl+0x1883/0x2730 drivers/usb/gadget/legacy/raw_gadget.c:1220This routine allows two processes to register the same driver instance via ioctl syscall. which lead to a race condition.
We can fix it by adding a
driver_lockto avoid double register.Reported-by [email protected]Signed-off-by Schspa Shi <[email protected]>--- drivers/usb/gadget/legacy/raw_gadget.c | 8 ++++++++ 1 file changed, 8 insertions(+)drivers/usb/gadget/legacy/raw_gadget.c +0
-0
drivers/usb/gadget/legacy/raw_gadget.c struct raw_dev { · line 160
Quoted 6 lines
drivers/usb/gadget/legacy/raw_gadget.c +2
-0@@ -155,7 +155,9 @@ struct raw_dev {spinlock_t lock;const char *udc_name; +/* Protected by driver_lock for reentrant registration */ struct usb_gadget_driver driver; +struct mutex driver_lock;
Why are you adding another lock here? What's wrong with the existing lock in this structure that requires an additional one?
Quoted 23 lines
drivers/usb/gadget/legacy/raw_gadget.c +4
-0/* Reference to misc device: */ struct device *dev;@@ -188,6 +190,8 @@ static struct raw_dev *dev_new(void)spin_lock_init (&dev->lock);init_completion (&dev->ep0_done);raw_event_queue_init (&dev->queue); +mutex_init (&dev->driver_lock); +return dev; }@@ -398,7 +402,9 @@ static int raw_release(struct inode *inode, struct file *fd)spin_unlock_irqrestore (&dev->lock, flags);if (unregister) { +mutex_lock (&dev->driver_lock); ret =usb_gadget_unregister_driver (&dev->driver); +mutex_unlock (&dev->driver_lock);if (ret !=0 ) dev_err(dev->dev, "usb_gadget_unregister_driver() failed with %d\n",
drivers/usb/gadget/legacy/raw_gadget.c static int raw_ioctl_run(struct raw_dev *dev, unsigned long value) · line 521
Quoted 6 lines
drivers/usb/gadget/legacy/raw_gadget.c +2
-0@@ -510,7 +516,9 @@ static int raw_ioctl_run(struct raw_dev *dev, unsigned long value) }spin_unlock_irqrestore (&dev->lock, flags); +mutex_lock (&dev->driver_lock); ret =usb_gadget_register_driver (&dev->driver); +mutex_unlock (&dev->driver_lock);
How can unregister race with register?
What ioctl is causing this race? What userspace program is doing this? Only one userspace program should be accessing this at once, right?
confused,
greg k-h
Quoted 66 lines · Greg KH
Quoted 29 lines · Schspa Shi
The
usb_gadget_register_driverdoesn't have inside locks to protect the driver, and If there is two threads are registered at the same time via the ioctl syscall, the system will crash as syzbot reported.Call trace as:
driver_register+0x220/0x3a0 drivers/base/driver.c:171 usb_gadget_register_driver_owner+0xfb/0x1e0 drivers/usb/gadget/udc/core.c:1546 raw_ioctl_run drivers/usb/gadget/legacy/raw_gadget.c:513 [inline] raw_ioctl+0x1883/0x2730 drivers/usb/gadget/legacy/raw_gadget.c:1220This routine allows two processes to register the same driver instance via ioctl syscall. which lead to a race condition.
We can fix it by adding a
driver_lockto avoid double register.Reported-by [email protected]Signed-off-by Schspa Shi <[email protected]>--- drivers/usb/gadget/legacy/raw_gadget.c | 8 ++++++++ 1 file changed, 8 insertions(+)drivers/usb/gadget/legacy/raw_gadget.c +0
-0drivers/usb/gadget/legacy/raw_gadget.c struct raw_dev { · line 160
Quoted 6 lines
drivers/usb/gadget/legacy/raw_gadget.c +2
-0@@ -155,7 +155,9 @@ struct raw_dev {spinlock_t lock;const char *udc_name; +/* Protected by driver_lock for reentrant registration */ struct usb_gadget_driver driver; +struct mutex driver_lock;Why are you adding another lock here? What's wrong with the existing lock in this structure that requires an additional one?
Quoted 26 lines
drivers/usb/gadget/legacy/raw_gadget.c +4
-0/* Reference to misc device: */ struct device *dev;@@ -188,6 +190,8 @@ static struct raw_dev *dev_new(void)spin_lock_init (&dev->lock);init_completion (&dev->ep0_done);raw_event_queue_init (&dev->queue); +mutex_init (&dev->driver_lock); +return dev; }@@ -398,7 +402,9 @@ static int raw_release(struct inode *inode, struct file *fd)spin_unlock_irqrestore (&dev->lock, flags);if (unregister) { +mutex_lock (&dev->driver_lock); ret =usb_gadget_unregister_driver (&dev->driver); +mutex_unlock (&dev->driver_lock);if (ret !=0 ) dev_err(dev->dev, "usb_gadget_unregister_driver() failed with %d\n",@@ -510,7 +516,9 @@ static int raw_ioctl_run(struct raw_dev *dev, unsigned long value) }spin_unlock_irqrestore (&dev->lock, flags);
Quoted 8 lines
drivers/usb/gadget/legacy/raw_gadget.c static int raw_ioctl_run(struct raw_dev *dev, unsigned long value) · line 521
Quoted 3 lines
drivers/usb/gadget/legacy/raw_gadget.c +2
-0+mutex_lock (&dev->driver_lock); ret =usb_gadget_register_driver (&dev->driver); +mutex_unlock (&dev->driver_lock);How can unregister race with register?
What ioctl is causing this race? What userspace program is doing this? Only one userspace program should be accessing this at once, right?
These questions are on the right track.
The problem here is not insufficient locking. The problem is that dev->state does not have a special state to indicate that the driver is being registered.
Before calling usb_gadget_register_driver(), while still holding dev->lock, the code should change dev->state to STATE_DEV_REGISTERING. Then no race can occur, because the second thread to acquire the spinlock will see that dev->state is not equal to STATE_DEV_INITIALIZED.
Alan Stern
Quoted 32 lines · Greg KH
Quoted 31 lines · Schspa Shi
The
usb_gadget_register_driverdoesn't have inside locks to protect the driver, and If there is two threads are registered at the same time via the ioctl syscall, the system will crash as syzbot reported.Call trace as:
driver_register+0x220/0x3a0 drivers/base/driver.c:171 usb_gadget_register_driver_owner+0xfb/0x1e0 drivers/usb/gadget/udc/core.c:1546 raw_ioctl_run drivers/usb/gadget/legacy/raw_gadget.c:513 [inline] raw_ioctl+0x1883/0x2730 drivers/usb/gadget/legacy/raw_gadget.c:1220This routine allows two processes to register the same driver instance via ioctl syscall. which lead to a race condition.
We can fix it by adding a
driver_lockto avoid double register.Reported-by [email protected]Signed-off-by Schspa Shi <[email protected]>--- drivers/usb/gadget/legacy/raw_gadget.c | 8 ++++++++ 1 file changed, 8 insertions(+)drivers/usb/gadget/legacy/raw_gadget.c +0
-0@@ -155,7 +155,9 @@ struct raw_dev {spinlock_t lock;
Quoted 8 lines
drivers/usb/gadget/legacy/raw_gadget.c struct raw_dev { · line 160
Quoted 4 lines
drivers/usb/gadget/legacy/raw_gadget.c +2
-0const char *udc_name; +/* Protected by driver_lock for reentrant registration */ struct usb_gadget_driver driver; +struct mutex driver_lock;Why are you adding another lock here? What's wrong with the existing lock in this structure that requires an additional one?
We can't use the existing lock, because it's a spinlock, and can't call usb_gadget_register_driver() in its critical section, it will hold "udc_lock" which is a mutex_lock. Moreover, a deeper, it will call driver_register(), which can't be called by atomic context too.
Quoted 6 lines
drivers/usb/gadget/legacy/raw_gadget.c static int raw_ioctl_run(struct raw_dev *dev, unsigned long value) · line 521
Quoted 3 lines
drivers/usb/gadget/legacy/raw_gadget.c +2
-0+mutex_lock (&dev->driver_lock); ret =usb_gadget_register_driver (&dev->driver); +mutex_unlock (&dev->driver_lock);How can unregister race with register?
I'm sorry for the confused race explanation, it's not unregister race with register, this lock around usb_gadget_unregister_driver() can be I will remove this lock in a new patchset if no other change needs to be made.
Quoted 4 lines
What ioctl is causing this race? What userspace program is doing this? Only one userspace program should be accessing this at once, right?
confused,
It's because of two processes calling to register the same driver instance, which causes the race condition.
The ioctl is USB_RAW_IOCTL_RUN, which can be called from userspace multi times or we should add protection to ioctl calls to avoid multi time device register?
In this usb gadget, the driver property should be passed from USB_RAW_IOCTL_INIT ioctl, which leave here a device_register by userspace.
For more details about this race.
Process 0 Process 1
USB_RAW_IOCTL_INIT
USB_RAW_IOCTL_RUN USB_RAW_IOCTL_RUN
usb_gadget_register_driver usb_gadget_register_driver
driver_register driver_register
Quoted 2 lines
greg k-h
---
BRs
Schspa Shi
Quoted 78 lines · Alan Stern
Quoted 66 lines · Greg KH
Quoted 29 lines · Schspa Shi
The
usb_gadget_register_driverdoesn't have inside locks to protect the driver, and If there is two threads are registered at the same time via the ioctl syscall, the system will crash as syzbot reported.Call trace as:
driver_register+0x220/0x3a0 drivers/base/driver.c:171 usb_gadget_register_driver_owner+0xfb/0x1e0 drivers/usb/gadget/udc/core.c:1546 raw_ioctl_run drivers/usb/gadget/legacy/raw_gadget.c:513 [inline] raw_ioctl+0x1883/0x2730 drivers/usb/gadget/legacy/raw_gadget.c:1220This routine allows two processes to register the same driver instance via ioctl syscall. which lead to a race condition.
We can fix it by adding a
driver_lockto avoid double register.Reported-by [email protected]Signed-off-by Schspa Shi <[email protected]>--- drivers/usb/gadget/legacy/raw_gadget.c | 8 ++++++++ 1 file changed, 8 insertions(+)drivers/usb/gadget/legacy/raw_gadget.c +0
-0drivers/usb/gadget/legacy/raw_gadget.c struct raw_dev { · line 160
Quoted 6 lines
drivers/usb/gadget/legacy/raw_gadget.c +2
-0@@ -155,7 +155,9 @@ struct raw_dev {spinlock_t lock;const char *udc_name; +/* Protected by driver_lock for reentrant registration */ struct usb_gadget_driver driver; +struct mutex driver_lock;Why are you adding another lock here? What's wrong with the existing lock in this structure that requires an additional one?
Quoted 26 lines
drivers/usb/gadget/legacy/raw_gadget.c +4
-0/* Reference to misc device: */ struct device *dev;@@ -188,6 +190,8 @@ static struct raw_dev *dev_new(void)spin_lock_init (&dev->lock);init_completion (&dev->ep0_done);raw_event_queue_init (&dev->queue); +mutex_init (&dev->driver_lock); +return dev; }@@ -398,7 +402,9 @@ static int raw_release(struct inode *inode, struct file *fd)spin_unlock_irqrestore (&dev->lock, flags);if (unregister) { +mutex_lock (&dev->driver_lock); ret =usb_gadget_unregister_driver (&dev->driver); +mutex_unlock (&dev->driver_lock);if (ret !=0 ) dev_err(dev->dev, "usb_gadget_unregister_driver() failed with %d\n",@@ -510,7 +516,9 @@ static int raw_ioctl_run(struct raw_dev *dev, unsigned long value) }spin_unlock_irqrestore (&dev->lock, flags);Quoted 8 lines
drivers/usb/gadget/legacy/raw_gadget.c static int raw_ioctl_run(struct raw_dev *dev, unsigned long value) · line 521
Quoted 3 lines
drivers/usb/gadget/legacy/raw_gadget.c +2
-0+mutex_lock (&dev->driver_lock); ret =usb_gadget_register_driver (&dev->driver); +mutex_unlock (&dev->driver_lock);How can unregister race with register?
What ioctl is causing this race? What userspace program is doing this? Only one userspace program should be accessing this at once, right?
These questions are on the right track.
Quoted 9 lines
The problem here is not insufficient locking. The problem is that
dev->statedoes not have a special state to indicate that the driver is being registered.Before calling
usb_gadget_register_driver(), while still holdingdev->lock, the code should changedev->statetoSTATE_DEV_REGISTERING. Then no race can occur, because the second thread to acquire the spinlock will see thatdev->stateis not equal toSTATE_DEV_INITIALIZED.
Yes, it's a good suggestion, I will upload a new patch set to use this method.
Quoted 1 line
Alan Stern
---
BRs
Schspa Shi
PATCH v2 1/1 usb: gadget: fix race when gadget driver register via ioctl
The usb_gadget_register_driver can be called multi time by to threads via USB_RAW_IOCTL_RUN ioctl syscall, which will lead to multiple registrations.
Call trace:
driver_register+0x220/0x3a0 drivers/base/driver.c:171
usb_gadget_register_driver_owner+0xfb/0x1e0
drivers/usb/gadget/udc/core.c:1546
raw_ioctl_run drivers/usb/gadget/legacy/raw_gadget.c:513 [inline]
raw_ioctl+0x1883/0x2730 drivers/usb/gadget/legacy/raw_gadget.c:1220
ioctl USB_RAW_IOCTL_RUNThis routine allows two processes to register the same driver instance via ioctl syscall. which lead to a race condition.
We can fix it by adding a new STATE_DEV_REGISTERING device state to avoid double register.
--- drivers/usb/gadget/legacy/raw_gadget.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/usb/gadget/legacy/raw_gadget.c +2 -0
@@ -146,6 +146,7 @@ enum dev_state {STATE_DEV_OPENED ,STATE_DEV_INITIALIZED ,STATE_DEV_RUNNING , +STATE_DEV_REGISTERING ,STATE_DEV_CLOSED , STATE_DEV_FAILED };
@@ -508,6 +509,7 @@ static int raw_ioctl_run(struct raw_dev *dev, unsigned long value) ret = -EINVAL ; goto out_unlock; } + dev->state =STATE_DEV_REGISTERING ;spin_unlock_irqrestore (&dev->lock, flags); ret =usb_gadget_register_driver (&dev->driver);
Signature · 1 line
2.24.3 (Apple Git-128)
Quoted 12 lines · Schspa Shi
The
usb_gadget_register_drivercan be called multi time by to threads viaUSB_RAW_IOCTL_RUNioctl syscall, which will lead to multiple registrations.Call trace: driver_register+0x220/0x3a0 drivers/base/driver.c:171 usb_gadget_register_driver_owner+0xfb/0x1e0 drivers/usb/gadget/udc/core.c:1546 raw_ioctl_run drivers/usb/gadget/legacy/raw_gadget.c:513 [inline] raw_ioctl+0x1883/0x2730 drivers/usb/gadget/legacy/raw_gadget.c:1220 ioctl USB_RAW_IOCTL_RUN
Quoted 5 lines
This routine allows two processes to register the same driver instance via ioctl syscall. which lead to a race condition.
We can fix it by adding a new
STATE_DEV_REGISTERINGdevice state to avoid double register.
Are you sure that this patch will fix the problem found by syzbot? That is, are you sure that the problem really was caused by two threads registering the same driver concurrently?
The fact that the error was "use after free" suggests that the problem might be something else. It looks like one of the threads was trying to access the driver structure after the other thread had done something that caused it to be deallocated, which suggests an error in reference counting.
Yes, this could be caused by two threads both registering the same driver. But the evidence doesn't prove that this is what happened, as far as I can see.
Alan Stern
Quoted 31 lines
Reported-by [email protected]Signed-off-by Schspa Shi <[email protected]>--- drivers/usb/gadget/legacy/raw_gadget.c | 2 ++ 1 file changed, 2 insertions(+)drivers/usb/gadget/legacy/raw_gadget.c +2
-0@@ -146,6 +146,7 @@ enum dev_state {STATE_DEV_OPENED ,STATE_DEV_INITIALIZED ,STATE_DEV_RUNNING , +STATE_DEV_REGISTERING ,STATE_DEV_CLOSED , STATE_DEV_FAILED };@@ -508,6 +509,7 @@ static int raw_ioctl_run(struct raw_dev *dev, unsigned long value) ret = -EINVAL ; goto out_unlock; } + dev->state =STATE_DEV_REGISTERING ;spin_unlock_irqrestore (&dev->lock, flags); ret =usb_gadget_register_driver (&dev->driver);Signature · 1 line
2.24.3 (Apple Git-128)
Quoted 16 lines · Alan Stern
Quoted 15 lines · Schspa Shi
The
usb_gadget_register_drivercan be called multi time by to threads viaUSB_RAW_IOCTL_RUNioctl syscall, which will lead to multiple registrations.Call trace: driver_register+0x220/0x3a0 drivers/base/driver.c:171 usb_gadget_register_driver_owner+0xfb/0x1e0 drivers/usb/gadget/udc/core.c:1546 raw_ioctl_run drivers/usb/gadget/legacy/raw_gadget.c:513 [inline] raw_ioctl+0x1883/0x2730 drivers/usb/gadget/legacy/raw_gadget.c:1220 ioctl USB_RAW_IOCTL_RUNThis routine allows two processes to register the same driver instance via ioctl syscall. which lead to a race condition.
Quoted 7 lines
Quoted 2 lines
We can fix it by adding a new
STATE_DEV_REGISTERINGdevice state to avoid double register.Are you sure that this patch will fix the problem found by syzbot? That is, are you sure that the problem really was caused by two threads registering the same driver concurrently?
Yes, from the console log from syzbot. T8324 alloced driver_private was released by T8326.
Quoted 6 lines
The fact that the error was "use after free" suggests that the problem might be something else. It looks like one of the threads was trying to access the driver structure after the other thread had done something that caused it to be deallocated, which suggests an error in reference counting.
The direct cause of this place is because of the refcount error, but the root cause is still caused by multiple registrations
Please refer to the following scenarios.
T1 T2
------------------------------------------------------------------usb_gadget_register_driver_owner
driver_register driver_register
driver_find driver_find
bus_add_driver bus_add_driver
priv alloced <context switch>
drv->p = priv;
<schedule out>
kobject_init_and_add // refcount = 1;
//couldn't find an available UDC or it's busy
<context switch>
priv alloced
drv->priv = priv;
kobject_init_and_add
---> refcount = 1 <------
// register success
<context switch>
===================== another ioctl/process ======================
driver_register
driver_find
k = kset_find_obj()
---> refcount = 2 <------
<context out>
driver_unregister
// drv->p become T2's priv
---> refcount = 1 <------
<context switch>
kobject_put(k)
---> refcount = 0 <------
return priv->driver;
--------UAF here----------There will be UAF in this scenario.
And all the logs reported by syzbot can be matched to this scenario.
Quoted 6 lines
Yes, this could be caused by two threads both registering the same driver. But the evidence doesn't prove that this is what happened, as far as I can see.
Alan Stern
BRs
Schspa Shi
Alan Stern
Acked-byQuoted 9 lines · Schspa Shi
Quoted 5 lines · Alan Stern
Are you sure that this patch will fix the problem found by syzbot? That is, are you sure that the problem really was caused by two threads registering the same driver concurrently?
Yes, from the console log from syzbot. T8324 alloced
driver_privatewas released by T8326.
That is a smoking gun.
Quoted 36 lines
Quoted 6 lines
The fact that the error was "use after free" suggests that the problem might be something else. It looks like one of the threads was trying to access the driver structure after the other thread had done something that caused it to be deallocated, which suggests an error in reference counting.
The direct cause of this place is because of the refcount error, but the root cause is still caused by multiple registrations
Please refer to the following scenarios.
T1 T2
------------------------------------------------------------------usb_gadget_register_driver_owner
driver_registerdriver_registerdriver_find driver_find bus_add_driver bus_add_driver priv alloced <context switch> drv->p = priv; <schedule out> kobject_init_and_add // refcount = 1; //couldn't find an available UDC or it's busy <context switch> priv alloced drv->priv = priv; kobject_init_and_add ---> refcount = 1 <------ // register success <context switch> ===================== another ioctl/process ====================== driver_register driver_find k = kset_find_obj() ---> refcount = 2 <------ <context out>
Quoted 8 lines
driver_unregister
//drv->pbecome T2's priv
---> refcount = 1 <------
<context switch>kobject_put(k) ---> refcount = 0 <------ return priv->driver; --------UAF here----------
It looks like you've got T2 calling driver_register and driver_find twice, but the overall idea is pretty clear.
Quoted 2 lines
There will be UAF in this scenario.
And all the logs reported by syzbot can be matched to this scenario.
And in any case it is obvious that the patch is necessary. (Although I would have put the new state before the RUNNING state, to reflect the actual order in which the states occur.)
Alan Stern
PATCH v3 1/1 usb: gadget: fix race when gadget driver register via ioctl
The usb_gadget_register_driver can be called multi time by to threads via USB_RAW_IOCTL_RUN ioctl syscall, which will lead to multiple registrations.
Call trace:
driver_register+0x220/0x3a0 drivers/base/driver.c:171
usb_gadget_register_driver_owner+0xfb/0x1e0
drivers/usb/gadget/udc/core.c:1546
raw_ioctl_run drivers/usb/gadget/legacy/raw_gadget.c:513 [inline]
raw_ioctl+0x1883/0x2730 drivers/usb/gadget/legacy/raw_gadget.c:1220
ioctl USB_RAW_IOCTL_RUNThis routine allows two processes to register the same driver instance via ioctl syscall. which lead to a race condition.
Please refer to the following scenarios.
T1 T2
------------------------------------------------------------------usb_gadget_register_driver_owner
driver_register driver_register
driver_find driver_find
bus_add_driver bus_add_driver
priv alloced <context switch>
drv->p = priv;
<schedule out>
kobject_init_and_add // refcount = 1;
//couldn't find an available UDC or it's busy
<context switch>
priv alloced
drv->priv = priv;
kobject_init_and_add
---> refcount = 1 <------
// register success
<context switch>
===================== another ioctl/process ======================
driver_register
driver_find
k = kset_find_obj()
---> refcount = 2 <------
<context out>
driver_unregister
// drv->p become T2's priv
---> refcount = 1 <------
<context switch>
kobject_put(k)
---> refcount = 0 <------
return priv->driver;
--------UAF here----------There will be UAF in this scenario.
We can fix it by adding a new STATE_DEV_REGISTERING device state to avoid double register.
---
Changelog:
v1 -> v2:
- Add a STATE_DEV_REGISTERING as Alan Stern suggested.
v2 -> v3:
- Adjust STATE_DEV_REGISTERING position to reflect the actual order in which the states occur.
- Add the fault scenarios to comments.
--- drivers/usb/gadget/legacy/raw_gadget.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/usb/gadget/legacy/raw_gadget.c +2 -0
@@ -145,6 +145,7 @@ enum dev_state {STATE_DEV_INVALID =0 ,STATE_DEV_OPENED ,STATE_DEV_INITIALIZED , +STATE_DEV_REGISTERING ,STATE_DEV_RUNNING ,STATE_DEV_CLOSED ,STATE_DEV_FAILED
@@ -508,6 +509,7 @@ static int raw_ioctl_run(struct raw_dev *dev, unsigned long value) ret = -EINVAL ; goto out_unlock; } + dev->state =STATE_DEV_REGISTERING ;spin_unlock_irqrestore (&dev->lock, flags); ret =usb_gadget_register_driver (&dev->driver);
Signature · 1 line
2.24.3 (Apple Git-128)
Quoted 95 lines · Schspa Shi
The
usb_gadget_register_drivercan be called multi time by to threads viaUSB_RAW_IOCTL_RUNioctl syscall, which will lead to multiple registrations.Call trace: driver_register+0x220/0x3a0 drivers/base/driver.c:171 usb_gadget_register_driver_owner+0xfb/0x1e0 drivers/usb/gadget/udc/core.c:1546 raw_ioctl_run drivers/usb/gadget/legacy/raw_gadget.c:513 [inline] raw_ioctl+0x1883/0x2730 drivers/usb/gadget/legacy/raw_gadget.c:1220 ioctl USB_RAW_IOCTL_RUNThis routine allows two processes to register the same driver instance via ioctl syscall. which lead to a race condition.
Please refer to the following scenarios.
T1 T2
------------------------------------------------------------------usb_gadget_register_driver_owner
driver_registerdriver_registerdriver_find driver_find bus_add_driver bus_add_driver priv alloced <context switch> drv->p = priv; <schedule out> kobject_init_and_add // refcount = 1; //couldn't find an available UDC or it's busy <context switch> priv alloced drv->priv = priv; kobject_init_and_add ---> refcount = 1 <------ // register success <context switch> ===================== another ioctl/process ====================== driver_register driver_find k = kset_find_obj() ---> refcount = 2 <------ <context out> driver_unregister // drv->p become T2's priv ---> refcount = 1 <------ <context switch> kobject_put(k) ---> refcount = 0 <------ return priv->driver; --------UAF here----------There will be UAF in this scenario.
We can fix it by adding a new
STATE_DEV_REGISTERINGdevice state to avoid double register.Reported-by [email protected]Signed-off-by Schspa Shi <[email protected]>---
Changelog:
v1 -> v2:
- Add aSTATE_DEV_REGISTERINGas Alan Stern suggested.
v2 -> v3:
- AdjustSTATE_DEV_REGISTERINGposition to reflect the actual order in which the states occur.
- Add the fault scenarios to comments.--- drivers/usb/gadget/legacy/raw_gadget.c | 2 ++ 1 file changed, 2 insertions(+)drivers/usb/gadget/legacy/raw_gadget.c +2
-1@@ -145,6 +145,7 @@ enum dev_state {STATE_DEV_INVALID =0 ,STATE_DEV_OPENED ,STATE_DEV_INITIALIZED , +STATE_DEV_REGISTERING ,STATE_DEV_RUNNING ,STATE_DEV_CLOSED ,STATE_DEV_FAILED @@ -508,6 +509,7 @@ static int raw_ioctl_run(struct raw_dev *dev, unsigned long value) ret = -EINVAL ; goto out_unlock; } + dev->state =STATE_DEV_REGISTERING ;spin_unlock_irqrestore (&dev->lock, flags); ret =usb_gadget_register_driver (&dev->driver); --
Quoted 2 lines
2.24.3 (Apple Git-128)
Thanks, Schspa!
Thanks for the review, Alan!