extensions/common/permissions/usb_device_permission_unittest.cc

// Copyright (c) 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <memory>

#include "base/memory/ref_counted.h"
#include "device/usb/mock_usb_device.h"
#include "device/usb/usb_descriptors.h"
#include "extensions/common/extension_builder.h"
#include "extensions/common/features/feature_channel.h"
#include "extensions/common/features/feature_session_type.h"
#include "extensions/common/permissions/usb_device_permission.h"
#include "extensions/common/permissions/usb_device_permission_data.h"
#include "extensions/common/value_builder.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace extensions {

namespace {

// ID of test USB device config to which interfaces described by
// |interface_classes| parameter of |CreateTestUsbDevice| should be added.
const int kUsbConfigWithInterfaces = 1;

// ID of test USB device config created by |CreateTestUsbDevice| that contains
// no interfaces.
const int kUsbConfigWithoutInterfaces = 2;

scoped_refptr<device::MockUsbDevice> CreateTestUsbDevice(
    uint16_t vendor_id,
    uint16_t product_id,
    uint8_t device_class,
    const std::vector<uint8_t> interface_classes) {
  std::vector<device::UsbConfigDescriptor> configs;
  configs.emplace_back(kUsbConfigWithInterfaces, false, false, 0);
  configs.emplace_back(kUsbConfigWithoutInterfaces, false, false, 0);

  for (size_t i = 0; i < interface_classes.size(); ++i)
    configs[0].interfaces.emplace_back(i, 0, interface_classes[i], 255, 255);

  return new device::MockUsbDevice(vendor_id, product_id, device_class,
                                   configs);
}

scoped_refptr<const Extension> CreateTestApp(
    std::unique_ptr<base::Value> usb_device_permission) {
  return ExtensionBuilder()
      .SetManifest(
          DictionaryBuilder()
              .Set("name", "test app")
              .Set("version", "1")
              .Set("app",
                   DictionaryBuilder()
                       .Set("background",
                            DictionaryBuilder()
                                .Set("scripts", ListBuilder()
                                                    .Append("background.js")
                                                    .Build())
                                .Build())
                       .Build())
              .Set("permissions",
                   ListBuilder()
                       .Append("usb")
                       .Append(DictionaryBuilder()
                                   .Set("usbDevices",
                                        ListBuilder()
                                            .Append(std::move(
                                                usb_device_permission))
                                            .Build())
                                   .Build())
                       .Build())
              .Build())
      .Build();
}

}  // namespace

TEST(USBDevicePermissionTest, PermissionDataOrder) {
  EXPECT_LT(UsbDevicePermissionData(0x02ad, 0x138c, -1, -1),
            UsbDevicePermissionData(0x02ad, 0x138d, -1, -1));
  ASSERT_LT(UsbDevicePermissionData(0x02ad, 0x138d, -1, -1),
            UsbDevicePermissionData(0x02ae, 0x138c, -1, -1));
  EXPECT_LT(UsbDevicePermissionData(0x02ad, 0x138c, 1, 3),
            UsbDevicePermissionData(0x02ad, 0x138c, 2, 2));
  EXPECT_LT(UsbDevicePermissionData(0x02ad, 0x138c, 1, 2),
            UsbDevicePermissionData(0x02ad, 0x138c, 1, 3));
}

TEST(USBDevicePermissionTest, CheckVendorAndProductId) {
  std::unique_ptr<base::Value> permission_data_value =
      DictionaryBuilder()
          .Set("vendorId", 0x02ad)
          .Set("productId", 0x138c)
          .Build();

  UsbDevicePermissionData permission_data;
  ASSERT_TRUE(permission_data.FromValue(permission_data_value.get()));

  scoped_refptr<const Extension> app =
      CreateTestApp(std::move(permission_data_value));

  {
    std::unique_ptr<UsbDevicePermission::CheckParam> param =
        UsbDevicePermission::CheckParam::ForDeviceWithAnyInterfaceClass(
            app.get(), 0x02ad, 0x138c,
            UsbDevicePermissionData::SPECIAL_VALUE_UNSPECIFIED);

    EXPECT_TRUE(permission_data.Check(param.get()));
  }

  {
    std::unique_ptr<UsbDevicePermission::CheckParam> param =
        UsbDevicePermission::CheckParam::ForDeviceWithAnyInterfaceClass(
            app.get(), 0x138c, 0x02ad,
            UsbDevicePermissionData::SPECIAL_VALUE_UNSPECIFIED);

    EXPECT_FALSE(permission_data.Check(param.get()));
  }

  {
    std::unique_ptr<UsbDevicePermission::CheckParam> param =
        UsbDevicePermission::CheckParam::ForDeviceWithAnyInterfaceClass(
            app.get(), 0x02ad, 0x138c, 3);

    EXPECT_FALSE(permission_data.Check(param.get()));
  }
}

TEST(USBDevicePermissionTest, CheckInterfaceId) {
  std::unique_ptr<base::Value> permission_data_value =
      DictionaryBuilder()
          .Set("vendorId", 0x02ad)
          .Set("productId", 0x138c)
          .Set("interfaceId", 3)
          .Build();
  UsbDevicePermissionData permission_data;
  ASSERT_TRUE(permission_data.FromValue(permission_data_value.get()));

  scoped_refptr<const Extension> app =
      CreateTestApp(std::move(permission_data_value));
  {
    std::unique_ptr<UsbDevicePermission::CheckParam> param =
        UsbDevicePermission::CheckParam::ForDeviceWithAnyInterfaceClass(
            app.get(), 0x02ad, 0x138c, 3);

    EXPECT_TRUE(permission_data.Check(param.get()));
  }

  {
    std::unique_ptr<UsbDevicePermission::CheckParam> param =
        UsbDevicePermission::CheckParam::ForDeviceWithAnyInterfaceClass(
            app.get(), 0x02ad, 0x138c, 2);

    EXPECT_FALSE(permission_data.Check(param.get()));
  }

  {
    std::unique_ptr<UsbDevicePermission::CheckParam> param =
        UsbDevicePermission::CheckParam::ForDeviceWithAnyInterfaceClass(
            app.get(), 0x02ad, 0x138c,
            UsbDevicePermissionData::SPECIAL_VALUE_UNSPECIFIED);

    EXPECT_TRUE(permission_data.Check(param.get()));
  }
}

TEST(USBDevicePermissionTest, InterfaceClass) {
  std::unique_ptr<base::Value> permission_data_value =
      DictionaryBuilder().Set("interfaceClass", 3).Build();
  UsbDevicePermissionData permission_data;
  EXPECT_TRUE(permission_data.FromValue(permission_data_value.get()));

  scoped_refptr<const Extension> app =
      CreateTestApp(std::move(permission_data_value));

  {
    std::unique_ptr<UsbDevicePermission::CheckParam> param =
        UsbDevicePermission::CheckParam::ForDeviceWithAnyInterfaceClass(
            app.get(), 0x02ad, 0x138c,
            UsbDevicePermissionData::SPECIAL_VALUE_UNSPECIFIED);

    // Interface class permission should be ignored when not in kiosk session.
    EXPECT_FALSE(permission_data.Check(param.get()));
  }

  {
    std::unique_ptr<base::AutoReset<FeatureSessionType>> scoped_session_type(
        ScopedCurrentFeatureSessionType(FeatureSessionType::KIOSK));
    ScopedCurrentChannel channel(version_info::Channel::DEV);

    std::unique_ptr<UsbDevicePermission::CheckParam> param =
        UsbDevicePermission::CheckParam::ForDeviceWithAnyInterfaceClass(
            app.get(), 0x02ad, 0x138c,
            UsbDevicePermissionData::SPECIAL_VALUE_UNSPECIFIED);

    // |ForDeviceWithAnyInterfaceClass| creates check param that matches any
    // interfaceClass permission property - needed in cases where set of
    // interface classes supported by a USB device is not known.
    // In this case, there is a usbDevice permisison with only interfaceClass
    // set, so the param is accepted.
    EXPECT_TRUE(permission_data.Check(param.get()));
  }
}

TEST(USBDevicePermissionTest, InterfaceClassWithVendorId) {
  std::unique_ptr<base::Value> permission_data_value =
      DictionaryBuilder()
          .Set("vendorId", 0x02ad)
          .Set("interfaceClass", 3)
          .Build();
  UsbDevicePermissionData permission_data;
  EXPECT_TRUE(permission_data.FromValue(permission_data_value.get()));

  scoped_refptr<const Extension> app =
      CreateTestApp(std::move(permission_data_value));

  {
    std::unique_ptr<UsbDevicePermission::CheckParam> param =
        UsbDevicePermission::CheckParam::ForDeviceWithAnyInterfaceClass(
            app.get(), 0x02ad, 0x138c,
            UsbDevicePermissionData::SPECIAL_VALUE_UNSPECIFIED);

    EXPECT_FALSE(permission_data.Check(param.get()));
  }

  {
    std::unique_ptr<base::AutoReset<FeatureSessionType>> scoped_session_type(
        ScopedCurrentFeatureSessionType(FeatureSessionType::KIOSK));
    ScopedCurrentChannel channel(version_info::Channel::DEV);

    std::unique_ptr<UsbDevicePermission::CheckParam> param =
        UsbDevicePermission::CheckParam::ForDeviceWithAnyInterfaceClass(
            app.get(), 0x02ad, 0x138c,
            UsbDevicePermissionData::SPECIAL_VALUE_UNSPECIFIED);

    EXPECT_TRUE(permission_data.Check(param.get()));
  }

  {
    std::unique_ptr<base::AutoReset<FeatureSessionType>> scoped_session_type(
        ScopedCurrentFeatureSessionType(FeatureSessionType::KIOSK));
    ScopedCurrentChannel channel(version_info::Channel::DEV);

    std::unique_ptr<UsbDevicePermission::CheckParam> param =
        UsbDevicePermission::CheckParam::ForDeviceWithAnyInterfaceClass(
            app.get(), 0x138c, 0x138c,
            UsbDevicePermissionData::SPECIAL_VALUE_UNSPECIFIED);

    EXPECT_FALSE(permission_data.Check(param.get()));
  }
}

TEST(USBDevicePermissionTest, CheckHidUsbAgainstInterfaceClass) {
  std::unique_ptr<base::Value> permission_data_value =
      DictionaryBuilder()
          .Set("vendorId", 0x02ad)
          .Set("interfaceClass", 3)
          .Build();
  UsbDevicePermissionData permission_data;
  EXPECT_TRUE(permission_data.FromValue(permission_data_value.get()));

  scoped_refptr<const Extension> app =
      CreateTestApp(std::move(permission_data_value));

  {
    std::unique_ptr<UsbDevicePermission::CheckParam> param =
        UsbDevicePermission::CheckParam::ForHidDevice(app.get(), 0x02ad,
                                                      0x138c);

    EXPECT_FALSE(permission_data.Check(param.get()));
  }

  {
    std::unique_ptr<base::AutoReset<FeatureSessionType>> scoped_session_type(
        ScopedCurrentFeatureSessionType(FeatureSessionType::KIOSK));
    ScopedCurrentChannel channel(version_info::Channel::DEV);

    std::unique_ptr<UsbDevicePermission::CheckParam> param =
        UsbDevicePermission::CheckParam::ForHidDevice(app.get(), 0x02ad,
                                                      0x138c);

    EXPECT_TRUE(permission_data.Check(param.get()));
  }

  {
    std::unique_ptr<base::AutoReset<FeatureSessionType>> scoped_session_type(
        ScopedCurrentFeatureSessionType(FeatureSessionType::KIOSK));
    ScopedCurrentChannel channel(version_info::Channel::DEV);

    std::unique_ptr<UsbDevicePermission::CheckParam> param =
        UsbDevicePermission::CheckParam::ForHidDevice(app.get(), 0x138c,
                                                      0x138c);

    EXPECT_FALSE(permission_data.Check(param.get()));
  }
}

TEST(USBDevicePermissionTest, CheckHidUsbAgainstDeviceIds) {
  std::unique_ptr<base::Value> permission_data_value =
      DictionaryBuilder()
          .Set("vendorId", 0x02ad)
          .Set("productId", 0x138c)
          .Build();
  UsbDevicePermissionData permission_data;
  EXPECT_TRUE(permission_data.FromValue(permission_data_value.get()));

  scoped_refptr<const Extension> app =
      CreateTestApp(std::move(permission_data_value));

  {
    std::unique_ptr<UsbDevicePermission::CheckParam> param =
        UsbDevicePermission::CheckParam::ForHidDevice(app.get(), 0x02ad,
                                                      0x138c);

    EXPECT_TRUE(permission_data.Check(param.get()));
  }

  {
    std::unique_ptr<UsbDevicePermission::CheckParam> param =
        UsbDevicePermission::CheckParam::ForHidDevice(app.get(), 0x138c,
                                                      0x138c);

    EXPECT_FALSE(permission_data.Check(param.get()));
  }
}

TEST(USBDevicePermissionTest, CheckDeviceAgainstDeviceIds) {
  std::unique_ptr<base::Value> permission_data_value =
      DictionaryBuilder()
          .Set("vendorId", 0x02ad)
          .Set("productId", 0x138c)
          .Build();
  UsbDevicePermissionData permission_data;
  EXPECT_TRUE(permission_data.FromValue(permission_data_value.get()));

  scoped_refptr<const Extension> app =
      CreateTestApp(std::move(permission_data_value));

  {
    scoped_refptr<device::MockUsbDevice> device =
        CreateTestUsbDevice(0x02ad, 0x138c, 0x9, std::vector<uint8_t>());
    std::unique_ptr<UsbDevicePermission::CheckParam> param =
        UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), device.get());

    EXPECT_TRUE(permission_data.Check(param.get()));
  }

  {
    scoped_refptr<device::MockUsbDevice> device =
        CreateTestUsbDevice(0x138c, 0x138c, 0x9, std::vector<uint8_t>());
    std::unique_ptr<UsbDevicePermission::CheckParam> param =
        UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), device.get());

    EXPECT_FALSE(permission_data.Check(param.get()));
  }
}

TEST(USBDevicePermissionTest, CheckDeviceAgainstDeviceClass) {
  std::unique_ptr<base::Value> permission_data_value =
      DictionaryBuilder().Set("interfaceClass", 0x9).Build();
  UsbDevicePermissionData permission_data;
  EXPECT_TRUE(permission_data.FromValue(permission_data_value.get()));

  scoped_refptr<const Extension> app =
      CreateTestApp(std::move(permission_data_value));

  {
    scoped_refptr<device::MockUsbDevice> device =
        CreateTestUsbDevice(0x02ad, 0x138c, 0x9, std::vector<uint8_t>());
    std::unique_ptr<UsbDevicePermission::CheckParam> param =
        UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), device.get());

    EXPECT_FALSE(permission_data.Check(param.get()));
  }

  {
    std::unique_ptr<base::AutoReset<FeatureSessionType>> scoped_session_type(
        ScopedCurrentFeatureSessionType(FeatureSessionType::KIOSK));
    ScopedCurrentChannel channel(version_info::Channel::DEV);

    scoped_refptr<device::MockUsbDevice> device =
        CreateTestUsbDevice(0x02ad, 0x138c, 0x9, std::vector<uint8_t>());
    std::unique_ptr<UsbDevicePermission::CheckParam> param =
        UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), device.get());

    EXPECT_TRUE(permission_data.Check(param.get()));
  }
  {
    std::unique_ptr<base::AutoReset<FeatureSessionType>> scoped_session_type(
        ScopedCurrentFeatureSessionType(FeatureSessionType::KIOSK));
    ScopedCurrentChannel channel(version_info::Channel::DEV);

    scoped_refptr<device::MockUsbDevice> device =
        CreateTestUsbDevice(0x02ad, 0x138c, 0x3, std::vector<uint8_t>());
    std::unique_ptr<UsbDevicePermission::CheckParam> param =
        UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), device.get());

    EXPECT_FALSE(permission_data.Check(param.get()));
  }
}

TEST(USBDevicePermissionTest, IgnoreNullDeviceClass) {
  std::unique_ptr<base::Value> permission_data_value =
      DictionaryBuilder().Set("interfaceClass", 0).Build();
  UsbDevicePermissionData permission_data;
  EXPECT_TRUE(permission_data.FromValue(permission_data_value.get()));

  scoped_refptr<const Extension> app =
      CreateTestApp(std::move(permission_data_value));

  {
    std::unique_ptr<base::AutoReset<FeatureSessionType>> scoped_session_type(
        ScopedCurrentFeatureSessionType(FeatureSessionType::KIOSK));
    ScopedCurrentChannel channel(version_info::Channel::DEV);

    scoped_refptr<device::MockUsbDevice> device =
        CreateTestUsbDevice(0x02ad, 0x138c, 0, std::vector<uint8_t>());
    std::unique_ptr<UsbDevicePermission::CheckParam> param =
        UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), device.get());

    EXPECT_FALSE(permission_data.Check(param.get()));
  }
}

TEST(USBDevicePermissionTest, CheckDeviceAgainstInterfaceClass) {
  std::unique_ptr<base::Value> permission_data_value =
      DictionaryBuilder().Set("interfaceClass", 0x3).Build();
  UsbDevicePermissionData permission_data;
  EXPECT_TRUE(permission_data.FromValue(permission_data_value.get()));

  scoped_refptr<const Extension> app =
      CreateTestApp(std::move(permission_data_value));

  {
    scoped_refptr<device::MockUsbDevice> device =
        CreateTestUsbDevice(0x02ad, 0x138c, 0, {2, 3});
    std::unique_ptr<UsbDevicePermission::CheckParam> param =
        UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), device.get());

    EXPECT_FALSE(permission_data.Check(param.get()));
  }

  {
    // Interface should match inactive configuration when none of configurations
    // is active.
    std::unique_ptr<base::AutoReset<FeatureSessionType>> scoped_session_type(
        ScopedCurrentFeatureSessionType(FeatureSessionType::KIOSK));
    ScopedCurrentChannel channel(version_info::Channel::DEV);

    scoped_refptr<device::MockUsbDevice> device =
        CreateTestUsbDevice(0x02ad, 0x138c, 0, {2, 3});
    std::unique_ptr<UsbDevicePermission::CheckParam> param =
        UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), device.get());

    EXPECT_TRUE(permission_data.Check(param.get()));
  }

  {
    std::unique_ptr<base::AutoReset<FeatureSessionType>> scoped_session_type(
        ScopedCurrentFeatureSessionType(FeatureSessionType::KIOSK));
    ScopedCurrentChannel channel(version_info::Channel::DEV);

    scoped_refptr<device::MockUsbDevice> device =
        CreateTestUsbDevice(0x02ad, 0x138c, 0, {2, 3});
    device->ActiveConfigurationChanged(kUsbConfigWithInterfaces);
    std::unique_ptr<UsbDevicePermission::CheckParam> param =
        UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), device.get());

    EXPECT_TRUE(permission_data.Check(param.get()));
  }

  {
    // Interface should match inactive configuration when another configuration
    // is active.
    std::unique_ptr<base::AutoReset<FeatureSessionType>> scoped_session_type(
        ScopedCurrentFeatureSessionType(FeatureSessionType::KIOSK));
    ScopedCurrentChannel channel(version_info::Channel::DEV);

    scoped_refptr<device::MockUsbDevice> device =
        CreateTestUsbDevice(0x02ad, 0x138c, 0, {2, 3});
    device->ActiveConfigurationChanged(kUsbConfigWithoutInterfaces);
    std::unique_ptr<UsbDevicePermission::CheckParam> param =
        UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), device.get());

    EXPECT_TRUE(permission_data.Check(param.get()));
  }

  {
    std::unique_ptr<base::AutoReset<FeatureSessionType>> scoped_session_type(
        ScopedCurrentFeatureSessionType(FeatureSessionType::KIOSK));
    ScopedCurrentChannel channel(version_info::Channel::DEV);

    scoped_refptr<device::MockUsbDevice> device =
        CreateTestUsbDevice(0x02ad, 0x138c, 0, {4, 5});
    std::unique_ptr<UsbDevicePermission::CheckParam> param =
        UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), device.get());

    EXPECT_FALSE(permission_data.Check(param.get()));
  }
}

TEST(USBDevicePermissionTest, CheckDeviceAndInterfaceId) {
  std::unique_ptr<base::Value> permission_data_value =
      DictionaryBuilder()
          .Set("vendorId", 0x02ad)
          .Set("productId", 0x138c)
          .Set("interfaceId", 3)
          .Build();
  UsbDevicePermissionData permission_data;
  EXPECT_TRUE(permission_data.FromValue(permission_data_value.get()));

  scoped_refptr<const Extension> app =
      CreateTestApp(std::move(permission_data_value));

  {
    scoped_refptr<device::MockUsbDevice> device =
        CreateTestUsbDevice(0x02ad, 0x138c, 0, std::vector<uint8_t>());
    std::unique_ptr<UsbDevicePermission::CheckParam> param =
        UsbDevicePermission::CheckParam::ForUsbDeviceAndInterface(
            app.get(), device.get(), 3);

    EXPECT_TRUE(permission_data.Check(param.get()));
  }

  {
    scoped_refptr<device::MockUsbDevice> device =
        CreateTestUsbDevice(0x02ad, 0x138c, 0, std::vector<uint8_t>());
    std::unique_ptr<UsbDevicePermission::CheckParam> param =
        UsbDevicePermission::CheckParam::ForUsbDeviceAndInterface(
            app.get(), device.get(), 2);

    EXPECT_FALSE(permission_data.Check(param.get()));
  }
}

TEST(USBDevicePermissionTest,
     CheckDeviceAndInterfaceIDAgainstMissingInterfaceId) {
  std::unique_ptr<base::Value> permission_data_value =
      DictionaryBuilder()
          .Set("vendorId", 0x02ad)
          .Set("productId", 0x138c)
          .Build();
  UsbDevicePermissionData permission_data;
  EXPECT_TRUE(permission_data.FromValue(permission_data_value.get()));

  scoped_refptr<const Extension> app =
      CreateTestApp(std::move(permission_data_value));

  {
    scoped_refptr<device::MockUsbDevice> device =
        CreateTestUsbDevice(0x02ad, 0x138c, 0, std::vector<uint8_t>());
    std::unique_ptr<UsbDevicePermission::CheckParam> param =
        UsbDevicePermission::CheckParam::ForUsbDeviceAndInterface(
            app.get(), device.get(), 3);

    EXPECT_FALSE(permission_data.Check(param.get()));
  }
}

TEST(USBDevicePermissionTest, InvalidPermission_NoVendorId) {
  std::unique_ptr<base::Value> permission_data_value =
      DictionaryBuilder()
          .Set("productId", 0x138c)
          .Set("interfaceClass", 3)
          .Build();
  UsbDevicePermissionData permission_data;
  ASSERT_FALSE(permission_data.FromValue(permission_data_value.get()));
}

TEST(USBDevicePermissionTest, InvalidPermission_OnlyVendorId) {
  std::unique_ptr<base::Value> permission_data_value =
      DictionaryBuilder().Set("vendorId", 0x02ad).Build();
  UsbDevicePermissionData permission_data;
  ASSERT_FALSE(permission_data.FromValue(permission_data_value.get()));
}

TEST(USBDevicePermissionTest, InvalidPermission_NoProductIdWithInterfaceId) {
  std::unique_ptr<base::Value> permission_data_value =
      DictionaryBuilder().Set("vendorId", 0x02ad).Set("interfaceId", 3).Build();
  UsbDevicePermissionData permission_data;
  ASSERT_FALSE(permission_data.FromValue(permission_data_value.get()));
}

TEST(USBDevicePermissionTest, RejectInterfaceIdIfInterfaceClassPresent) {
  std::unique_ptr<base::Value> permission_data_value =
      DictionaryBuilder()
          .Set("vendorId", 0x02ad)
          .Set("productId", 0x128c)
          .Set("interfaceId", 3)
          .Set("interfaceClass", 7)
          .Build();
  UsbDevicePermissionData permission_data;
  ASSERT_FALSE(permission_data.FromValue(permission_data_value.get()));
}

}  // namespace extensions