1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "extensions/common/permissions/usb_device_permission.h"
#include <string>
#include <utility>
#include <vector>
#include "base/check.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "extensions/common/extension.h"
#include "extensions/common/features/behavior_feature.h"
#include "extensions/common/features/feature.h"
#include "extensions/common/features/feature_provider.h"
#include "extensions/common/permissions/permissions_info.h"
#include "extensions/strings/grit/extensions_strings.h"
#include "services/device/public/cpp/usb/usb_ids.h"
#include "ui/base/l10n/l10n_util.h"
namespace extensions {
namespace {
const int kHidInterfaceClass = 3;
bool IsInterfaceClassPermissionAlowed(const Extension* extension) {
const Feature* feature = FeatureProvider::GetBehaviorFeature(
behavior_feature::kAllowUsbDevicesPermissionInterfaceClass);
if (!feature)
return false;
if (!extension)
return false;
return feature->IsAvailableToExtension(extension).is_available();
}
} // namespace
// static
std::unique_ptr<UsbDevicePermission::CheckParam>
UsbDevicePermission::CheckParam::ForUsbDevice(
const Extension* extension,
const device::mojom::UsbDeviceInfo& device_info) {
return CheckParam::ForUsbDeviceAndInterface(
extension, device_info,
UsbDevicePermissionData::SPECIAL_VALUE_UNSPECIFIED);
}
// static
std::unique_ptr<UsbDevicePermission::CheckParam>
UsbDevicePermission::CheckParam::ForDeviceWithAnyInterfaceClass(
const Extension* extension,
uint16_t vendor_id,
uint16_t product_id,
int interface_id) {
return std::make_unique<CheckParam>(extension, vendor_id, product_id,
std::unique_ptr<std::set<int>>(),
interface_id);
}
// static
std::unique_ptr<UsbDevicePermission::CheckParam>
UsbDevicePermission::CheckParam::ForUsbDeviceAndInterface(
const Extension* extension,
const device::mojom::UsbDeviceInfo& device_info,
int interface_id) {
std::unique_ptr<std::set<int>> interface_classes(new std::set<int>());
// If device class is set, match interface class against it as well. This is
// to enable filtering devices by device-only class (for example, hubs), which
// might or might not have an interface with class set to device class value.
if (device_info.class_code)
interface_classes->insert(device_info.class_code);
for (const auto& configuration : device_info.configurations) {
for (const auto& interface : configuration->interfaces) {
for (const auto& alternate : interface->alternates)
interface_classes->insert(alternate->class_code);
}
}
return std::make_unique<CheckParam>(
extension, device_info.vendor_id, device_info.product_id,
std::move(interface_classes), interface_id);
}
// static
std::unique_ptr<UsbDevicePermission::CheckParam>
UsbDevicePermission::CheckParam::ForHidDevice(const Extension* extension,
uint16_t vendor_id,
uint16_t product_id) {
std::unique_ptr<std::set<int>> interface_classes(new std::set<int>());
interface_classes->insert(kHidInterfaceClass);
return std::make_unique<UsbDevicePermission::CheckParam>(
extension, vendor_id, product_id, std::move(interface_classes),
UsbDevicePermissionData::SPECIAL_VALUE_UNSPECIFIED);
}
UsbDevicePermission::CheckParam::CheckParam(
const Extension* extension,
uint16_t vendor_id,
uint16_t product_id,
std::unique_ptr<std::set<int>> interface_classes,
int interface_id)
: vendor_id(vendor_id),
product_id(product_id),
interface_classes(std::move(interface_classes)),
interface_id(interface_id),
interface_class_allowed(IsInterfaceClassPermissionAlowed(extension)) {}
UsbDevicePermission::CheckParam::~CheckParam() = default;
UsbDevicePermission::UsbDevicePermission(const APIPermissionInfo* info)
: SetDisjunctionPermission<UsbDevicePermissionData, UsbDevicePermission>(
info) {}
UsbDevicePermission::~UsbDevicePermission() = default;
bool UsbDevicePermission::FromValue(
const base::Value* value,
std::string* error,
std::vector<std::string>* unhandled_permissions) {
bool parsed_ok =
SetDisjunctionPermission<UsbDevicePermissionData, UsbDevicePermission>::
FromValue(value, error, unhandled_permissions);
if (parsed_ok && data_set_.empty()) {
if (error)
*error = "NULL or empty permission list";
return false;
}
return parsed_ok;
}
PermissionIDSet UsbDevicePermission::GetPermissions() const {
PermissionIDSet ids;
std::set<uint16_t> unknown_product_vendors;
bool found_unknown_vendor = false;
for (const UsbDevicePermissionData& data : data_set_) {
// Interface class permissions should be only available in kiosk sessions,
// don't include those in installation warning for now.
if (data.interface_class() != UsbDevicePermissionData::SPECIAL_VALUE_ANY)
continue;
const char* vendor = device::UsbIds::GetVendorName(data.vendor_id());
if (vendor) {
const char* product =
device::UsbIds::GetProductName(data.vendor_id(), data.product_id());
if (product) {
std::u16string product_name_and_vendor = l10n_util::GetStringFUTF16(
IDS_EXTENSION_USB_DEVICE_PRODUCT_NAME_AND_VENDOR,
base::UTF8ToUTF16(product), base::UTF8ToUTF16(vendor));
ids.insert(mojom::APIPermissionID::kUsbDevice, product_name_and_vendor);
} else {
unknown_product_vendors.insert(data.vendor_id());
}
} else {
found_unknown_vendor = true;
}
}
for (uint16_t vendor_id : unknown_product_vendors) {
const char* vendor = device::UsbIds::GetVendorName(vendor_id);
DCHECK(vendor);
ids.insert(mojom::APIPermissionID::kUsbDeviceUnknownProduct,
base::UTF8ToUTF16(vendor));
}
if (found_unknown_vendor)
ids.insert(mojom::APIPermissionID::kUsbDeviceUnknownVendor);
return ids;
}
} // namespace extensions
|
