[PATCH v3 30/31] USB: Authorize interfaces through device trust

From: Leon Romanovsky

Date: Wed Nov 18 2026 - 14:34:45 EST


From: Leon Romanovsky <leonro@xxxxxxxxxx>

An interface denied by USB defaults must remain blocked until its trust
policy permits binding. Keeping an independent denial flag would prevent
generic trust authorization from making that interface usable.

Represent the initial denial as blocked policy when trust is enabled, and
let interface authorization request unrestricted operation. Preserve
explicit USB deauthorization and report rejected policy changes to
userspace. Interface policies remain independent of the device policy.

Signed-off-by: Leon Romanovsky <leonro@xxxxxxxxxx>
---
Documentation/ABI/testing/sysfs-bus-usb | 5 +++++
Documentation/usb/authorization.rst | 11 +++++++++++
drivers/usb/core/driver.c | 2 +-
drivers/usb/core/message.c | 23 ++++++++++++++++++-----
drivers/usb/core/sysfs.c | 7 +++++--
drivers/usb/core/usb.h | 2 +-
include/linux/usb.h | 9 +++++++--
7 files changed, 48 insertions(+), 11 deletions(-)

diff --git a/Documentation/ABI/testing/sysfs-bus-usb b/Documentation/ABI/testing/sysfs-bus-usb
index 5213117fd957e..62e326710ef5f 100644
--- a/Documentation/ABI/testing/sysfs-bus-usb
+++ b/Documentation/ABI/testing/sysfs-bus-usb
@@ -12,6 +12,11 @@ Description:

A deauthorized interface cannot be probed or claimed.

+ With device trust enabled at boot, an interface that is not
+ authorized by default starts with the "blocked" trust policy
+ (see sysfs-devices-trust). Writing 1 then requests the "unrestricted"
+ policy. Deauthorizing does not change the committed trust level.
+
What: /sys/bus/usb/devices/usbX/interface_authorized_default
Date: August 2015
Description:
diff --git a/Documentation/usb/authorization.rst b/Documentation/usb/authorization.rst
index 150a14970e951..31ff34df29717 100644
--- a/Documentation/usb/authorization.rst
+++ b/Documentation/usb/authorization.rst
@@ -120,6 +120,13 @@ Deny interfaces per default::
Per default the interface_authorized_default bit is 1.
So all interfaces would authorized per default.

+With device trust enabled, an interface that is not authorized by default
+starts with the "blocked" trust policy, and writing 1 to its "authorized"
+attribute requests the "unrestricted" policy. Device and interface trust policies
+are independent: selecting "adversary" for a USB device does not select it
+for its interfaces. Set interface policies separately before their drivers
+bind, using boot rules when necessary.
+
Note:
If a deauthorized interface will be authorized so the driver probing must
be triggered manually by writing INTERFACE to /sys/bus/usb/drivers_probe
@@ -127,3 +134,7 @@ Note:
For drivers that need multiple interfaces all needed interfaces should be
authorized first. After that the drivers should be probed.
This avoids side effects.
+
+Driver boot rules apply when an interface is claimed, including before
+registration. An interface deauthorized through sysfs must still be
+authorized before it can be claimed.
diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c
index b10b80b5fd6d4..893bcdb430878 100644
--- a/drivers/usb/core/driver.c
+++ b/drivers/usb/core/driver.c
@@ -338,7 +338,7 @@ static int usb_probe_interface(struct device *dev)
if (udev->authorized == 0) {
dev_info(&intf->dev, "Device is not authorized for usage\n");
return error;
- } else if (intf->authorized == 0) {
+ } else if (!usb_interface_authorized(intf)) {
dev_info(&intf->dev, "Interface %d is not authorized for usage\n",
intf->altsetting->desc.bInterfaceNumber);
return error;
diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
index 0a022ce8739c2..d388d7371a247 100644
--- a/drivers/usb/core/message.c
+++ b/drivers/usb/core/message.c
@@ -1881,16 +1881,24 @@ void usb_deauthorize_interface(struct usb_interface *intf)
* usb_authorize_interface - authorize an USB interface
*
* @intf: USB interface structure
+ *
+ * Return: 0 on success, or the error of the trust policy request.
*/
-void usb_authorize_interface(struct usb_interface *intf)
+int usb_authorize_interface(struct usb_interface *intf)
{
struct device *dev = &intf->dev;
+ int ret = 0;

- if (!intf->authorized) {
- device_lock(dev);
- intf->authorized = 1; /* authorize interface */
- device_unlock(dev);
+ device_lock(dev);
+ if (device_policy_is_blocked(dev)) {
+ ret = device_trust_set_policy_locked(dev, DEVICE_TRUST_POLICY_UNRESTRICTED);
+ if (ret)
+ goto out_unlock;
}
+ intf->authorized = 1;
+out_unlock:
+ device_unlock(dev);
+ return ret;
}

static int usb_if_uevent(const struct device *dev, struct kobj_uevent_env *env)
@@ -2213,6 +2221,11 @@ static int usb_set_configuration_internal(struct usb_device *dev, int configurat
intf->altsetting = intfc->altsetting;
intf->num_altsetting = intfc->num_altsetting;
intf->authorized = !!HCD_INTF_AUTHORIZED(hcd);
+ if (device_trust_enabled()) {
+ if (!intf->authorized)
+ intf->dev.trust_policy = DEVICE_TRUST_POLICY_BLOCKED;
+ intf->authorized = 1;
+ }
kref_get(&intfc->ref);

alt = usb_altnum_to_altsetting(intf, 0);
diff --git a/drivers/usb/core/sysfs.c b/drivers/usb/core/sysfs.c
index d22dc78457d79..b8974e9db3a22 100644
--- a/drivers/usb/core/sysfs.c
+++ b/drivers/usb/core/sysfs.c
@@ -1213,7 +1213,7 @@ static ssize_t interface_authorized_show(struct device *dev,
{
struct usb_interface *intf = to_usb_interface(dev);

- return sysfs_emit(buf, "%u\n", intf->authorized);
+ return sysfs_emit(buf, "%u\n", usb_interface_authorized(intf));
}

/*
@@ -1225,12 +1225,15 @@ static ssize_t interface_authorized_store(struct device *dev,
struct usb_interface *intf = to_usb_interface(dev);
bool val;
struct kernfs_node *kn;
+ int ret;

if (kstrtobool(buf, &val) != 0)
return -EINVAL;

if (val) {
- usb_authorize_interface(intf);
+ ret = usb_authorize_interface(intf);
+ if (ret)
+ return ret;
} else {
/*
* Prevent deadlock if another process is concurrently
diff --git a/drivers/usb/core/usb.h b/drivers/usb/core/usb.h
index 1b2de58fd6cef..233dacbc446b4 100644
--- a/drivers/usb/core/usb.h
+++ b/drivers/usb/core/usb.h
@@ -34,7 +34,7 @@ extern void usb_disable_device(struct usb_device *dev, int skip_ep0);
extern int usb_deauthorize_device(struct usb_device *);
extern int usb_authorize_device(struct usb_device *);
extern void usb_deauthorize_interface(struct usb_interface *);
-extern void usb_authorize_interface(struct usb_interface *);
+extern int usb_authorize_interface(struct usb_interface *);
extern void usb_detect_quirks(struct usb_device *udev);
extern void usb_detect_interface_quirks(struct usb_device *udev);
extern void usb_release_quirk_list(void);
diff --git a/include/linux/usb.h b/include/linux/usb.h
index d372712eba34c..9399c816b367d 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -204,8 +204,8 @@ enum usb_wireless_status {
* has been deferred.
* @needs_binding: flag set when the driver should be re-probed or unbound
* following a reset or suspend operation it doesn't support.
- * @authorized: This allows to (de)authorize individual interfaces instead
- * a whole device in contrast to the device authorization.
+ * @authorized: USB authorization flag; trust policy may also restrict use,
+ * see usb_interface_authorized().
* @wireless_status: if the USB device uses a receiver/emitter combo, whether
* the emitter is connected.
* @wireless_status_work: Used for scheduling wireless status changes
@@ -278,6 +278,11 @@ struct usb_interface {

#define to_usb_interface(__dev) container_of_const(__dev, struct usb_interface, dev)

+static inline bool usb_interface_authorized(const struct usb_interface *intf)
+{
+ return intf->authorized && !device_policy_is_blocked(&intf->dev);
+}
+
static inline void *usb_get_intfdata(struct usb_interface *intf)
{
return dev_get_drvdata(&intf->dev);

--
2.56.1