From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: usb: core: add option of only authorizing internal devices From: Dmitry Torokhov Message-Id: <20190217072151.GA244815@dtor-ws> Date: Sat, 16 Feb 2019 23:21:51 -0800 To: Greg Kroah-Hartman , Alan Stern Cc: linux-kernel@vger.kernel.org, linux-usb@vger.kernel.org List-ID: T24gQ2hyb21lIE9TIHdlIHdhbnQgdG8gdXNlIFVTQmd1YXJkIHRvIHBvdGVudGlhbGx5IGxpbWl0 IGFjY2VzcyB0byBVU0IKZGV2aWNlcyBiYXNlZCBvbiBwb2xpY3kuIFdlIGhvd2V2ZXIgdG8gZG8g bm90IHdhbnQgdG8gd2FpdCBmb3IgdXNlcnNwYWNlIHRvCmNvbWUgdXAgYmVmb3JlIGluaXRpYWxp emluZyBmaXhlZCBVU0IgZGV2aWNlcyB0byBub3QgcmVncmVzcyBvdXIgYm9vdAp0aW1lcy4KClRo aXMgcGF0Y2ggYWRkcyBvcHRpb24gdG8gaW5zdHJ1Y3QgdGhlIGtlcm5lbCB0byBvbmx5IGF1dGhv cml6ZSBkZXZpY2VzCmNvbm5lY3RlZCB0byB0aGUgaW50ZXJuYWwgcG9ydHMuIFByZXZpb3VzbHkg d2UgY291bGQgZWl0aGVyIGF1dGhvcml6ZQphbGwgb3Igbm9uZSAob3IsIGJ5IGRlZmF1bHQsIHdl J2Qgb25seSBhdXRob3JpemUgd2lyZWQgZGV2aWNlcykuCgpUaGUgYmVoYXZpb3IgaXMgY29udHJv bGxlZCB2aWEgdXNiY29yZS5hdXRob3JpemVkX2RlZmF1bHQgY29tbWFuZCBsaW5lCm9wdGlvbi4K ClNpZ25lZC1vZmYtYnk6IERtaXRyeSBUb3Jva2hvdiA8ZHRvckBjaHJvbWl1bS5vcmc+Ci0tLQog Li4uL2FkbWluLWd1aWRlL2tlcm5lbC1wYXJhbWV0ZXJzLnR4dCAgICAgICAgIHwgIDMgKy0KIERv Y3VtZW50YXRpb24vdXNiL2F1dGhvcml6YXRpb24udHh0ICAgICAgICAgICB8ICA0ICstCiBkcml2 ZXJzL3VzYi9jb3JlL2hjZC5jICAgICAgICAgICAgICAgICAgICAgICAgfCA1MSArKysrKysrKysr Ky0tLS0tLS0tCiBkcml2ZXJzL3VzYi9jb3JlL3VzYi5jICAgICAgICAgICAgICAgICAgICAgICAg fCAzMyArKysrKysrKystLS0KIGluY2x1ZGUvbGludXgvdXNiL2hjZC5oICAgICAgICAgICAgICAg ICAgICAgICB8IDEwICsrLS0KIDUgZmlsZXMgY2hhbmdlZCwgNjkgaW5zZXJ0aW9ucygrKSwgMzIg ZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9hZG1pbi1ndWlkZS9rZXJu ZWwtcGFyYW1ldGVycy50eHQgYi9Eb2N1bWVudGF0aW9uL2FkbWluLWd1aWRlL2tlcm5lbC1wYXJh bWV0ZXJzLnR4dAppbmRleCBhZWZkMzU4YTVjYTMuLjQ0NDY5MTkwODliOSAxMDA2NDQKLS0tIGEv RG9jdW1lbnRhdGlvbi9hZG1pbi1ndWlkZS9rZXJuZWwtcGFyYW1ldGVycy50eHQKKysrIGIvRG9j dW1lbnRhdGlvbi9hZG1pbi1ndWlkZS9rZXJuZWwtcGFyYW1ldGVycy50eHQKQEAgLTQ2NzUsNyAr NDY3NSw4IEBACiAJdXNiY29yZS5hdXRob3JpemVkX2RlZmF1bHQ9CiAJCQlbVVNCXSBEZWZhdWx0 IFVTQiBkZXZpY2UgYXV0aG9yaXphdGlvbjoKIAkJCShkZWZhdWx0IC0xID0gYXV0aG9yaXplZCBl eGNlcHQgZm9yIHdpcmVsZXNzIFVTQiwKLQkJCTAgPSBub3QgYXV0aG9yaXplZCwgMSA9IGF1dGhv cml6ZWQpCisJCQkwID0gbm90IGF1dGhvcml6ZWQsIDEgPSBhdXRob3JpemVkLCAyID0gYXV0aG9y aXplZAorCQkJaWYgZGV2aWNlIGNvbm5lY3RlZCB0byBpbnRlcm5hbCBwb3J0KQogCiAJdXNiY29y ZS5hdXRvc3VzcGVuZD0KIAkJCVtVU0JdIFRoZSBhdXRvc3VzcGVuZCB0aW1lIGRlbGF5IChpbiBz ZWNvbmRzKSB1c2VkCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3VzYi9hdXRob3JpemF0aW9u LnR4dCBiL0RvY3VtZW50YXRpb24vdXNiL2F1dGhvcml6YXRpb24udHh0CmluZGV4IGM3ZTk4NWYw NWQ4Zi4uNjhjMDAxYWNhNzhjIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL3VzYi9hdXRob3Jp emF0aW9uLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL3VzYi9hdXRob3JpemF0aW9uLnR4dApAQCAt MzQsNyArMzQsOSBAQCAkIGVjaG8gMSA+IC9zeXMvYnVzL3VzYi9kZXZpY2VzL3VzYlgvYXV0aG9y aXplZF9kZWZhdWx0CiBCeSBkZWZhdWx0LCBXaXJlZCBVU0IgZGV2aWNlcyBhcmUgYXV0aG9yaXpl ZCBieSBkZWZhdWx0IHRvCiBjb25uZWN0LiBXaXJlbGVzcyBVU0IgaG9zdHMgZGVhdXRob3JpemUg YnkgZGVmYXVsdCBhbGwgbmV3IGNvbm5lY3RlZAogZGV2aWNlcyAodGhpcyBpcyBzbyBiZWNhdXNl IHdlIG5lZWQgdG8gZG8gYW4gYXV0aGVudGljYXRpb24gcGhhc2UKLWJlZm9yZSBhdXRob3Jpemlu ZykuCitiZWZvcmUgYXV0aG9yaXppbmcpLiBXcml0aW5nICIyIiB0byB0aGUgYXV0aG9yaXplZF9k ZWZhdWx0IGF0dHJpYnV0ZQorY2F1c2VzIGtlcm5lbCB0byBvbmx5IGF1dGhvcml6ZSBieSBkZWZh dWx0IGRldmljZXMgY29ubmVjdGVkIHRvIGludGVybmFsCitVU0IgcG9ydHMuCiAKIAogRXhhbXBs ZSBzeXN0ZW0gbG9ja2Rvd24gKGxhbWUpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9jb3JlL2hj ZC5jIGIvZHJpdmVycy91c2IvY29yZS9oY2QuYwppbmRleCA0ODcwMjVkMzFkNDQuLjRhNzhiZjE5 MWQ3OCAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvY29yZS9oY2QuYworKysgYi9kcml2ZXJzL3Vz Yi9jb3JlL2hjZC5jCkBAIC0zNzMsMTMgKzM3MywxOSBAQCBzdGF0aWMgY29uc3QgdTggc3Nfcmhf Y29uZmlnX2Rlc2NyaXB0b3JbXSA9IHsKICAqIC0xIGlzIGF1dGhvcml6ZWQgZm9yIGFsbCBkZXZp Y2VzIGV4Y2VwdCB3aXJlbGVzcyAob2xkIGJlaGF2aW91cikKICAqIDAgaXMgdW5hdXRob3JpemVk IGZvciBhbGwgZGV2aWNlcwogICogMSBpcyBhdXRob3JpemVkIGZvciBhbGwgZGV2aWNlcworICog MiBpcyBhdXRob3JpemVkIGZvciBpbnRlcm5hbCBkZXZpY2VzCiAgKi8KLXN0YXRpYyBpbnQgYXV0 aG9yaXplZF9kZWZhdWx0ID0gLTE7CisjZGVmaW5lIFVTQl9BVVRIT1JJWkVfV0lSRUQJLTEKKyNk ZWZpbmUgVVNCX0FVVEhPUklaRV9OT05FCTAKKyNkZWZpbmUgVVNCX0FVVEhPUklaRV9BTEwJMQor I2RlZmluZSBVU0JfQVVUSE9SSVpFX0lOVEVSTkFMCTIKKworc3RhdGljIGludCBhdXRob3JpemVk X2RlZmF1bHQgPSBVU0JfQVVUSE9SSVpFX1dJUkVEOwogbW9kdWxlX3BhcmFtKGF1dGhvcml6ZWRf ZGVmYXVsdCwgaW50LCBTX0lSVUdPfFNfSVdVU1IpOwogTU9EVUxFX1BBUk1fREVTQyhhdXRob3Jp emVkX2RlZmF1bHQsCiAJCSJEZWZhdWx0IFVTQiBkZXZpY2UgYXV0aG9yaXphdGlvbjogMCBpcyBu b3QgYXV0aG9yaXplZCwgMSBpcyAiCi0JCSJhdXRob3JpemVkLCAtMSBpcyBhdXRob3JpemVkIGV4 Y2VwdCBmb3Igd2lyZWxlc3MgVVNCIChkZWZhdWx0LCAiCi0JCSJvbGQgYmVoYXZpb3VyIik7CisJ CSJhdXRob3JpemVkLCAyIGlzIGF1dGhvcml6ZWQgZm9yIGludGVybmFsIGRldmljZXMsIC0xIGlz ICIKKwkJImF1dGhvcml6ZWQgZXhjZXB0IGZvciB3aXJlbGVzcyBVU0IgKGRlZmF1bHQsIG9sZCBi ZWhhdmlvdXIiKTsKIC8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCiAKIC8qKgpAQCAtODg0LDcgKzg5MCw3 IEBAIHN0YXRpYyBzc2l6ZV90IGF1dGhvcml6ZWRfZGVmYXVsdF9zaG93KHN0cnVjdCBkZXZpY2Ug KmRldiwKIAlzdHJ1Y3QgdXNiX2hjZCAqaGNkOwogCiAJaGNkID0gYnVzX3RvX2hjZCh1c2JfYnVz KTsKLQlyZXR1cm4gc25wcmludGYoYnVmLCBQQUdFX1NJWkUsICIldVxuIiwgISFIQ0RfREVWX0FV VEhPUklaRUQoaGNkKSk7CisJcmV0dXJuIHNucHJpbnRmKGJ1ZiwgUEFHRV9TSVpFLCAiJXVcbiIs IGhjZC0+ZGV2X3BvbGljeSk7CiB9CiAKIHN0YXRpYyBzc2l6ZV90IGF1dGhvcml6ZWRfZGVmYXVs dF9zdG9yZShzdHJ1Y3QgZGV2aWNlICpkZXYsCkBAIC05MDAsMTEgKzkwNiw4IEBAIHN0YXRpYyBz c2l6ZV90IGF1dGhvcml6ZWRfZGVmYXVsdF9zdG9yZShzdHJ1Y3QgZGV2aWNlICpkZXYsCiAJaGNk ID0gYnVzX3RvX2hjZCh1c2JfYnVzKTsKIAlyZXN1bHQgPSBzc2NhbmYoYnVmLCAiJXVcbiIsICZ2 YWwpOwogCWlmIChyZXN1bHQgPT0gMSkgewotCQlpZiAodmFsKQotCQkJc2V0X2JpdChIQ0RfRkxB R19ERVZfQVVUSE9SSVpFRCwgJmhjZC0+ZmxhZ3MpOwotCQllbHNlCi0JCQljbGVhcl9iaXQoSENE X0ZMQUdfREVWX0FVVEhPUklaRUQsICZoY2QtPmZsYWdzKTsKLQorCQloY2QtPmRldl9wb2xpY3kg PSB2YWwgPD0gVVNCX0RFVklDRV9BVVRIT1JJWkVfSU5URVJOQUwgPworCQkJdmFsIDogVVNCX0RF VklDRV9BVVRIT1JJWkVfQUxMOwogCQlyZXN1bHQgPSBzaXplOwogCX0gZWxzZSB7CiAJCXJlc3Vs dCA9IC1FSU5WQUw7CkBAIC0yNzQ1LDE4ICsyNzQ4LDI2IEBAIGludCB1c2JfYWRkX2hjZChzdHJ1 Y3QgdXNiX2hjZCAqaGNkLAogCiAJZGV2X2luZm8oaGNkLT5zZWxmLmNvbnRyb2xsZXIsICIlc1xu IiwgaGNkLT5wcm9kdWN0X2Rlc2MpOwogCi0JLyogS2VlcCBvbGQgYmVoYXZpb3VyIGlmIGF1dGhv cml6ZWRfZGVmYXVsdCBpcyBub3QgaW4gWzAsIDFdLiAqLwotCWlmIChhdXRob3JpemVkX2RlZmF1 bHQgPCAwIHx8IGF1dGhvcml6ZWRfZGVmYXVsdCA+IDEpIHsKLQkJaWYgKGhjZC0+d2lyZWxlc3Mp Ci0JCQljbGVhcl9iaXQoSENEX0ZMQUdfREVWX0FVVEhPUklaRUQsICZoY2QtPmZsYWdzKTsKLQkJ ZWxzZQotCQkJc2V0X2JpdChIQ0RfRkxBR19ERVZfQVVUSE9SSVpFRCwgJmhjZC0+ZmxhZ3MpOwot CX0gZWxzZSB7Ci0JCWlmIChhdXRob3JpemVkX2RlZmF1bHQpCi0JCQlzZXRfYml0KEhDRF9GTEFH X0RFVl9BVVRIT1JJWkVELCAmaGNkLT5mbGFncyk7Ci0JCWVsc2UKLQkJCWNsZWFyX2JpdChIQ0Rf RkxBR19ERVZfQVVUSE9SSVpFRCwgJmhjZC0+ZmxhZ3MpOworCXN3aXRjaCAoYXV0aG9yaXplZF9k ZWZhdWx0KSB7CisJY2FzZSBVU0JfQVVUSE9SSVpFX05PTkU6CisJCWhjZC0+ZGV2X3BvbGljeSA9 IFVTQl9ERVZJQ0VfQVVUSE9SSVpFX05PTkU7CisJCWJyZWFrOworCisJY2FzZSBVU0JfQVVUSE9S SVpFX0FMTDoKKwkJaGNkLT5kZXZfcG9saWN5ID0gVVNCX0RFVklDRV9BVVRIT1JJWkVfQUxMOwor CQlicmVhazsKKworCWNhc2UgVVNCX0FVVEhPUklaRV9JTlRFUk5BTDoKKwkJaGNkLT5kZXZfcG9s aWN5ID0gVVNCX0RFVklDRV9BVVRIT1JJWkVfSU5URVJOQUw7CisJCWJyZWFrOworCisJY2FzZSBV U0JfQVVUSE9SSVpFX1dJUkVEOgorCWRlZmF1bHQ6CisJCWhjZC0+ZGV2X3BvbGljeSA9IGhjZC0+ d2lyZWxlc3MgPworCQkJVVNCX0RFVklDRV9BVVRIT1JJWkVfTk9ORSA6IFVTQl9ERVZJQ0VfQVVU SE9SSVpFX0FMTDsKKwkJYnJlYWs7CiAJfQorCiAJc2V0X2JpdChIQ0RfRkxBR19IV19BQ0NFU1NJ QkxFLCAmaGNkLT5mbGFncyk7CiAKIAkvKiBwZXIgZGVmYXVsdCBhbGwgaW50ZXJmYWNlcyBhcmUg YXV0aG9yaXplZCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvY29yZS91c2IuYyBiL2RyaXZl cnMvdXNiL2NvcmUvdXNiLmMKaW5kZXggNGViZmJkNzM3OTA1Li45YjU4NTJlMzEzZjUgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvdXNiL2NvcmUvdXNiLmMKKysrIGIvZHJpdmVycy91c2IvY29yZS91c2Iu YwpAQCAtNDYsOCArNDYsNyBAQAogI2luY2x1ZGUgPGxpbnV4L21tLmg+CiAjaW5jbHVkZSA8bGlu dXgvZG1hLW1hcHBpbmcuaD4KIAotI2luY2x1ZGUgInVzYi5oIgotCisjaW5jbHVkZSAiaHViLmgi CiAKIGNvbnN0IGNoYXIgKnVzYmNvcmVfbmFtZSA9ICJ1c2Jjb3JlIjsKIApAQCAtNTM2LDYgKzUz NSwyNyBAQCBzdGF0aWMgdW5zaWduZWQgdXNiX2J1c19pc193dXNiKHN0cnVjdCB1c2JfYnVzICpi dXMpCiAJcmV0dXJuIGhjZC0+d2lyZWxlc3M7CiB9CiAKK3N0YXRpYyBib29sIHVzYl9kZXZfYXV0 aG9yaXplZChzdHJ1Y3QgdXNiX2RldmljZSAqZGV2LCBzdHJ1Y3QgdXNiX2hjZCAqaGNkKQorewor CXN0cnVjdCB1c2JfaHViICpodWI7CisKKwlpZiAoIWRldi0+cGFyZW50KQorCQlyZXR1cm4gdHJ1 ZTsgLyogUm9vdCBodWIgYWx3YXlzIG9rIFthbmQgYWx3YXlzIHdpcmVkXSAqLworCisJc3dpdGNo IChoY2QtPmRldl9wb2xpY3kpIHsKKwljYXNlIFVTQl9ERVZJQ0VfQVVUSE9SSVpFX05PTkU6CisJ ZGVmYXVsdDoKKwkJcmV0dXJuIGZhbHNlOworCisJY2FzZSBVU0JfREVWSUNFX0FVVEhPUklaRV9B TEw6CisJCXJldHVybiB0cnVlOworCisJY2FzZSBVU0JfREVWSUNFX0FVVEhPUklaRV9JTlRFUk5B TDoKKwkJaHViID0gdXNiX2h1Yl90b19zdHJ1Y3RfaHViKGRldi0+cGFyZW50KTsKKwkJcmV0dXJu IGh1Yi0+cG9ydHNbZGV2LT5wb3J0bnVtIC0gMV0tPmNvbm5lY3RfdHlwZSA9PQorCQkJCVVTQl9Q T1JUX0NPTk5FQ1RfVFlQRV9IQVJEX1dJUkVEOworCX0KK30KIAogLyoqCiAgKiB1c2JfYWxsb2Nf ZGV2IC0gdXNiIGRldmljZSBjb25zdHJ1Y3RvciAodXNiY29yZS1pbnRlcm5hbCkKQEAgLTY2Mywx MiArNjgzLDExIEBAIHN0cnVjdCB1c2JfZGV2aWNlICp1c2JfYWxsb2NfZGV2KHN0cnVjdCB1c2Jf ZGV2aWNlICpwYXJlbnQsCiAJZGV2LT5jb25uZWN0X3RpbWUgPSBqaWZmaWVzOwogCWRldi0+YWN0 aXZlX2R1cmF0aW9uID0gLWppZmZpZXM7CiAjZW5kaWYKLQlpZiAocm9vdF9odWIpCS8qIFJvb3Qg aHViIGFsd2F5cyBvayBbYW5kIGFsd2F5cyB3aXJlZF0gKi8KLQkJZGV2LT5hdXRob3JpemVkID0g MTsKLQllbHNlIHsKLQkJZGV2LT5hdXRob3JpemVkID0gISFIQ0RfREVWX0FVVEhPUklaRUQodXNi X2hjZCk7CisKKwlkZXYtPmF1dGhvcml6ZWQgPSB1c2JfZGV2X2F1dGhvcml6ZWQoZGV2LCB1c2Jf aGNkKTsKKwlpZiAoIXJvb3RfaHViKQogCQlkZXYtPnd1c2IgPSB1c2JfYnVzX2lzX3d1c2IoYnVz KSA/IDEgOiAwOwotCX0KKwogCXJldHVybiBkZXY7CiB9CiBFWFBPUlRfU1lNQk9MX0dQTCh1c2Jf YWxsb2NfZGV2KTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvdXNiL2hjZC5oIGIvaW5jbHVk ZS9saW51eC91c2IvaGNkLmgKaW5kZXggOTdlMmRkZWMxOGIxLi43YzQ2OTUxNzAxY2EgMTAwNjQ0 Ci0tLSBhL2luY2x1ZGUvbGludXgvdXNiL2hjZC5oCisrKyBiL2luY2x1ZGUvbGludXgvdXNiL2hj ZC5oCkBAIC03Miw2ICs3MiwxMiBAQCBzdHJ1Y3QgZ2l2ZWJhY2tfdXJiX2JoIHsKIAlzdHJ1Y3Qg dXNiX2hvc3RfZW5kcG9pbnQgKmNvbXBsZXRpbmdfZXA7CiB9OwogCitlbnVtIHVzYl9kZXZfYXV0 aG9yaXplX3BvbGljeSB7CisJVVNCX0RFVklDRV9BVVRIT1JJWkVfTk9ORQk9IDAsCisJVVNCX0RF VklDRV9BVVRIT1JJWkVfQUxMCT0gMSwKKwlVU0JfREVWSUNFX0FVVEhPUklaRV9JTlRFUk5BTAk9 IDIsCit9OworCiBzdHJ1Y3QgdXNiX2hjZCB7CiAKIAkvKgpAQCAtMTE3LDcgKzEyMyw2IEBAIHN0 cnVjdCB1c2JfaGNkIHsKICNkZWZpbmUgSENEX0ZMQUdfUkhfUlVOTklORwkJNQkvKiByb290IGh1 YiBpcyBydW5uaW5nPyAqLwogI2RlZmluZSBIQ0RfRkxBR19ERUFECQkJNgkvKiBjb250cm9sbGVy IGhhcyBkaWVkPyAqLwogI2RlZmluZSBIQ0RfRkxBR19JTlRGX0FVVEhPUklaRUQJNwkvKiBhdXRo b3JpemUgaW50ZXJmYWNlcz8gKi8KLSNkZWZpbmUgSENEX0ZMQUdfREVWX0FVVEhPUklaRUQJCTgJ LyogYXV0aG9yaXplIGRldmljZXM/ICovCiAKIAkvKiBUaGUgZmxhZ3MgY2FuIGJlIHRlc3RlZCB1 c2luZyB0aGVzZSBtYWNyb3M7IHRoZXkgYXJlIGxpa2VseSB0bwogCSAqIGJlIHNsaWdodGx5IGZh c3RlciB0aGFuIHRlc3RfYml0KCkuCkBAIC0xNDIsOCArMTQ3LDcgQEAgc3RydWN0IHVzYl9oY2Qg ewogCSAqIG9yIHRoZXkgcmVxdWlyZSBleHBsaWNpdCB1c2VyIHNwYWNlIGF1dGhvcml6YXRpb247 IHRoaXMgYml0IGlzCiAJICogc2V0dGFibGUgdGhyb3VnaCAvc3lzL2NsYXNzL3VzYl9ob3N0L1gv YXV0aG9yaXplZF9kZWZhdWx0CiAJICovCi0jZGVmaW5lIEhDRF9ERVZfQVVUSE9SSVpFRChoY2Qp IFwKLQkoKGhjZCktPmZsYWdzICYgKDFVIDw8IEhDRF9GTEFHX0RFVl9BVVRIT1JJWkVEKSkKKwll bnVtIHVzYl9kZXZfYXV0aG9yaXplX3BvbGljeSBkZXZfcG9saWN5OwogCiAJLyogRmxhZ3MgdGhh dCBnZXQgc2V0IG9ubHkgZHVyaW5nIEhDRCByZWdpc3RyYXRpb24gb3IgcmVtb3ZhbC4gKi8KIAl1 bnNpZ25lZAkJcmhfcmVnaXN0ZXJlZDoxOy8qIGlzIHJvb3QgaHViIHJlZ2lzdGVyZWQ/ICovCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-8.7 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED,USER_AGENT_MUTT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id EB82BC43381 for ; Sun, 17 Feb 2019 07:21:58 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 9AE7921A4A for ; Sun, 17 Feb 2019 07:21:58 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=chromium.org header.i=@chromium.org header.b="i5yQOJ1t" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728002AbfBQHV5 (ORCPT ); Sun, 17 Feb 2019 02:21:57 -0500 Received: from mail-pf1-f196.google.com ([209.85.210.196]:44778 "EHLO mail-pf1-f196.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726788AbfBQHVz (ORCPT ); Sun, 17 Feb 2019 02:21:55 -0500 Received: by mail-pf1-f196.google.com with SMTP id u6so6957143pfh.11 for ; Sat, 16 Feb 2019 23:21:55 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; h=date:from:to:cc:subject:message-id:mime-version:content-disposition :user-agent; bh=IsR40mg9Ce6c5QV73d3O/4yPWwcefsy47mVst6TYP+k=; b=i5yQOJ1tqTcuY8PNCfesgHMBj8Ao+WA4oxkHiZJ05yetnpTquMGhT2hi4wv59SdbSm U8qiTUPdtJb76rJ4tQoM46PblMqs4lKcAV4ayn+jn+WfKz9BXernEDHUNkfeTI/NcWPv fzGYPRj+HVcjtpRZ/6CH6NVr6YtROfG6Am0tI= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:from:to:cc:subject:message-id:mime-version :content-disposition:user-agent; bh=IsR40mg9Ce6c5QV73d3O/4yPWwcefsy47mVst6TYP+k=; b=myk20XRIxd8Mzlz4JfV1Zlufl+LN92lomwXUg5Xi3VSHIuKiK/hovEIa+26uHWSZ0e WrZlS0Xl7VqXAOuY5gGlTM2x7XerJIgfpzGqUaovWRNwCYID891O42ZPPkKU0rIfU2hY 6sq+tJPxHlC0BImSqzg3XU/PWcgP9ZHD5BJTOTi0kAe9lpGMuAfNQ8oeAotnfyR5jISX zUqRqypCDE6EACq9qVEta99ySiwVBVANTVxH2e2zdkEoF5zOaXVECNqHoaaSGDjjFQl+ SfLxwPiHBdcRBVxUeJhHSAM5n95f5uFQDTXVEXI44m/ghOhdamw2nQ1nWoMVBzTvx6ni q1gw== X-Gm-Message-State: AHQUAub2uzIsxFZ/DIHHsuIVwHcHBWN97cPxRxw1pYkQ6TckeBCRb7if AvbY86U2ZX6aon7twVOUL+TFYTLboKE= X-Google-Smtp-Source: AHgI3Ib7jN89RAemWe8ZRX+mNAzmv/0bpkeIXkM3hQMcNXGKyujgT9/Zm2oro5uhkbNOWKRjdDqXUg== X-Received: by 2002:a62:170b:: with SMTP id 11mr17852458pfx.47.1550388114805; Sat, 16 Feb 2019 23:21:54 -0800 (PST) Received: from dtor-ws ([2620:15c:202:201:3adc:b08c:7acc:b325]) by smtp.gmail.com with ESMTPSA id s73sm25376812pfi.124.2019.02.16.23.21.53 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Sat, 16 Feb 2019 23:21:53 -0800 (PST) Date: Sat, 16 Feb 2019 23:21:51 -0800 From: Dmitry Torokhov To: Greg Kroah-Hartman , Alan Stern Cc: linux-kernel@vger.kernel.org, linux-usb@vger.kernel.org Subject: [PATCH] usb: core: add option of only authorizing internal devices Message-ID: <20190217072151.GA244815@dtor-ws> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline User-Agent: Mutt/1.10.1 (2018-07-13) Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Chrome OS we want to use USBguard to potentially limit access to USB devices based on policy. We however to do not want to wait for userspace to come up before initializing fixed USB devices to not regress our boot times. This patch adds option to instruct the kernel to only authorize devices connected to the internal ports. Previously we could either authorize all or none (or, by default, we'd only authorize wired devices). The behavior is controlled via usbcore.authorized_default command line option. Signed-off-by: Dmitry Torokhov --- .../admin-guide/kernel-parameters.txt | 3 +- Documentation/usb/authorization.txt | 4 +- drivers/usb/core/hcd.c | 51 +++++++++++-------- drivers/usb/core/usb.c | 33 +++++++++--- include/linux/usb/hcd.h | 10 ++-- 5 files changed, 69 insertions(+), 32 deletions(-) diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt index aefd358a5ca3..4446919089b9 100644 --- a/Documentation/admin-guide/kernel-parameters.txt +++ b/Documentation/admin-guide/kernel-parameters.txt @@ -4675,7 +4675,8 @@ usbcore.authorized_default= [USB] Default USB device authorization: (default -1 = authorized except for wireless USB, - 0 = not authorized, 1 = authorized) + 0 = not authorized, 1 = authorized, 2 = authorized + if device connected to internal port) usbcore.autosuspend= [USB] The autosuspend time delay (in seconds) used diff --git a/Documentation/usb/authorization.txt b/Documentation/usb/authorization.txt index c7e985f05d8f..68c001aca78c 100644 --- a/Documentation/usb/authorization.txt +++ b/Documentation/usb/authorization.txt @@ -34,7 +34,9 @@ $ echo 1 > /sys/bus/usb/devices/usbX/authorized_default By default, Wired USB devices are authorized by default to connect. Wireless USB hosts deauthorize by default all new connected devices (this is so because we need to do an authentication phase -before authorizing). +before authorizing). Writing "2" to the authorized_default attribute +causes kernel to only authorize by default devices connected to internal +USB ports. Example system lockdown (lame) diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c index 487025d31d44..4a78bf191d78 100644 --- a/drivers/usb/core/hcd.c +++ b/drivers/usb/core/hcd.c @@ -373,13 +373,19 @@ static const u8 ss_rh_config_descriptor[] = { * -1 is authorized for all devices except wireless (old behaviour) * 0 is unauthorized for all devices * 1 is authorized for all devices + * 2 is authorized for internal devices */ -static int authorized_default = -1; +#define USB_AUTHORIZE_WIRED -1 +#define USB_AUTHORIZE_NONE 0 +#define USB_AUTHORIZE_ALL 1 +#define USB_AUTHORIZE_INTERNAL 2 + +static int authorized_default = USB_AUTHORIZE_WIRED; module_param(authorized_default, int, S_IRUGO|S_IWUSR); MODULE_PARM_DESC(authorized_default, "Default USB device authorization: 0 is not authorized, 1 is " - "authorized, -1 is authorized except for wireless USB (default, " - "old behaviour"); + "authorized, 2 is authorized for internal devices, -1 is " + "authorized except for wireless USB (default, old behaviour"); /*-------------------------------------------------------------------------*/ /** @@ -884,7 +890,7 @@ static ssize_t authorized_default_show(struct device *dev, struct usb_hcd *hcd; hcd = bus_to_hcd(usb_bus); - return snprintf(buf, PAGE_SIZE, "%u\n", !!HCD_DEV_AUTHORIZED(hcd)); + return snprintf(buf, PAGE_SIZE, "%u\n", hcd->dev_policy); } static ssize_t authorized_default_store(struct device *dev, @@ -900,11 +906,8 @@ static ssize_t authorized_default_store(struct device *dev, hcd = bus_to_hcd(usb_bus); result = sscanf(buf, "%u\n", &val); if (result == 1) { - if (val) - set_bit(HCD_FLAG_DEV_AUTHORIZED, &hcd->flags); - else - clear_bit(HCD_FLAG_DEV_AUTHORIZED, &hcd->flags); - + hcd->dev_policy = val <= USB_DEVICE_AUTHORIZE_INTERNAL ? + val : USB_DEVICE_AUTHORIZE_ALL; result = size; } else { result = -EINVAL; @@ -2745,18 +2748,26 @@ int usb_add_hcd(struct usb_hcd *hcd, dev_info(hcd->self.controller, "%s\n", hcd->product_desc); - /* Keep old behaviour if authorized_default is not in [0, 1]. */ - if (authorized_default < 0 || authorized_default > 1) { - if (hcd->wireless) - clear_bit(HCD_FLAG_DEV_AUTHORIZED, &hcd->flags); - else - set_bit(HCD_FLAG_DEV_AUTHORIZED, &hcd->flags); - } else { - if (authorized_default) - set_bit(HCD_FLAG_DEV_AUTHORIZED, &hcd->flags); - else - clear_bit(HCD_FLAG_DEV_AUTHORIZED, &hcd->flags); + switch (authorized_default) { + case USB_AUTHORIZE_NONE: + hcd->dev_policy = USB_DEVICE_AUTHORIZE_NONE; + break; + + case USB_AUTHORIZE_ALL: + hcd->dev_policy = USB_DEVICE_AUTHORIZE_ALL; + break; + + case USB_AUTHORIZE_INTERNAL: + hcd->dev_policy = USB_DEVICE_AUTHORIZE_INTERNAL; + break; + + case USB_AUTHORIZE_WIRED: + default: + hcd->dev_policy = hcd->wireless ? + USB_DEVICE_AUTHORIZE_NONE : USB_DEVICE_AUTHORIZE_ALL; + break; } + set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags); /* per default all interfaces are authorized */ diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c index 4ebfbd737905..9b5852e313f5 100644 --- a/drivers/usb/core/usb.c +++ b/drivers/usb/core/usb.c @@ -46,8 +46,7 @@ #include #include -#include "usb.h" - +#include "hub.h" const char *usbcore_name = "usbcore"; @@ -536,6 +535,27 @@ static unsigned usb_bus_is_wusb(struct usb_bus *bus) return hcd->wireless; } +static bool usb_dev_authorized(struct usb_device *dev, struct usb_hcd *hcd) +{ + struct usb_hub *hub; + + if (!dev->parent) + return true; /* Root hub always ok [and always wired] */ + + switch (hcd->dev_policy) { + case USB_DEVICE_AUTHORIZE_NONE: + default: + return false; + + case USB_DEVICE_AUTHORIZE_ALL: + return true; + + case USB_DEVICE_AUTHORIZE_INTERNAL: + hub = usb_hub_to_struct_hub(dev->parent); + return hub->ports[dev->portnum - 1]->connect_type == + USB_PORT_CONNECT_TYPE_HARD_WIRED; + } +} /** * usb_alloc_dev - usb device constructor (usbcore-internal) @@ -663,12 +683,11 @@ struct usb_device *usb_alloc_dev(struct usb_device *parent, dev->connect_time = jiffies; dev->active_duration = -jiffies; #endif - if (root_hub) /* Root hub always ok [and always wired] */ - dev->authorized = 1; - else { - dev->authorized = !!HCD_DEV_AUTHORIZED(usb_hcd); + + dev->authorized = usb_dev_authorized(dev, usb_hcd); + if (!root_hub) dev->wusb = usb_bus_is_wusb(bus) ? 1 : 0; - } + return dev; } EXPORT_SYMBOL_GPL(usb_alloc_dev); diff --git a/include/linux/usb/hcd.h b/include/linux/usb/hcd.h index 97e2ddec18b1..7c46951701ca 100644 --- a/include/linux/usb/hcd.h +++ b/include/linux/usb/hcd.h @@ -72,6 +72,12 @@ struct giveback_urb_bh { struct usb_host_endpoint *completing_ep; }; +enum usb_dev_authorize_policy { + USB_DEVICE_AUTHORIZE_NONE = 0, + USB_DEVICE_AUTHORIZE_ALL = 1, + USB_DEVICE_AUTHORIZE_INTERNAL = 2, +}; + struct usb_hcd { /* @@ -117,7 +123,6 @@ struct usb_hcd { #define HCD_FLAG_RH_RUNNING 5 /* root hub is running? */ #define HCD_FLAG_DEAD 6 /* controller has died? */ #define HCD_FLAG_INTF_AUTHORIZED 7 /* authorize interfaces? */ -#define HCD_FLAG_DEV_AUTHORIZED 8 /* authorize devices? */ /* The flags can be tested using these macros; they are likely to * be slightly faster than test_bit(). @@ -142,8 +147,7 @@ struct usb_hcd { * or they require explicit user space authorization; this bit is * settable through /sys/class/usb_host/X/authorized_default */ -#define HCD_DEV_AUTHORIZED(hcd) \ - ((hcd)->flags & (1U << HCD_FLAG_DEV_AUTHORIZED)) + enum usb_dev_authorize_policy dev_policy; /* Flags that get set only during HCD registration or removal. */ unsigned rh_registered:1;/* is root hub registered? */ -- 2.21.0.rc0.258.g878e2cd30e-goog -- Dmitry