Set HexSSID in network config before matching it against policies

extensions/browser/api/networking_private/networking_private_chromeos_unittest.cc

 // Copyright 2017 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 "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_device_client.h"
 #include "chromeos/dbus/shill_profile_client.h"
 #include "chromeos/dbus/shill_service_client.h"
 #include "chromeos/login/login_state.h"
 #include "chromeos/network/managed_network_configuration_handler.h"
 #include "chromeos/network/network_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
+#include "components/onc/onc_constants.h"
 #include "extensions/browser/api/networking_private/networking_private_api.h"
 #include "extensions/browser/api_unittest.h"
 #include "extensions/common/value_builder.h"
 #include "third_party/cros_system_api/dbus/shill/dbus-constants.h"
 
 namespace extensions {
 
 namespace {
 
 const char kUserHash[] = "test_user_hash";
 const char kUserProfilePath[] = "/network_profile/user/shill";
 
 const char kWifiDevicePath[] = "/device/stub_wifi_device";
 
 const char kSharedWifiServicePath[] = "/service/shared_wifi";
 const char kSharedWifiGuid[] = "shared_wifi_guid";
 const char kSharedWifiName[] = "shared_wifi";
 
 const char kPrivateWifiServicePath[] = "/service/private_wifi";
 const char kPrivateWifiGuid[] = "private_wifi_guid";
 const char kPrivateWifiName[] = "private_wifi";
 
+const char kManagedUserWifiGuid[] = "managed_user_wifi_guid";
+const char kManagedUserWifiSsid[] = "managed_user_wifi";
+
+const char kManagedDeviceWifiGuid[] = "managed_device_wifi_guid";
+const char kManagedDeviceWifiSsid[] = "managed_device_wifi";
+
 }  // namespace
 
 class NetworkingPrivateApiTest : public ApiUnitTest {
  public:
   NetworkingPrivateApiTest() {}
   ~NetworkingPrivateApiTest() override {}
 
   void SetUp() override {
     ApiUnitTest::SetUp();
 
@@ skipping 71 matching lines @@
                                       shill::kProfileProperty,
                                       base::Value(kUserProfilePath));
     profile_test_->AddService(kUserProfilePath, kPrivateWifiServicePath);
   }
 
   void SetUpNetworkPolicy() {
     chromeos::ManagedNetworkConfigurationHandler* config_handler =
         chromeos::NetworkHandler::Get()
             ->managed_network_configuration_handler();
 
+    const std::string user_policy_ssid = kManagedUserWifiSsid;
+    std::unique_ptr<base::ListValue> user_policy_onc =
+        ListBuilder()
+            .Append(DictionaryBuilder()
+                        .Set("GUID", kManagedUserWifiGuid)
+                        .Set("Type", "WiFi")
+                        .Set("WiFi",
+                             DictionaryBuilder()
+                                 .Set("Passphrase", "fake")
+                                 .Set("SSID", user_policy_ssid)
+                                 .Set("HexSSID",
+                                      base::HexEncode(user_policy_ssid.c_str(),
+                                                      user_policy_ssid.size()))
+                                 .Set("Security", "WPA-PSK")
+                                 .Build())
+                        .Build())
+            .Build();
+
     config_handler->SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUserHash,
-                              base::ListValue(), base::DictionaryValue());
+                              *user_policy_onc, base::DictionaryValue());
 
+    const std::string device_policy_ssid = kManagedDeviceWifiSsid;
+    std::unique_ptr<base::ListValue> device_policy_onc =
+        ListBuilder()
+            .Append(DictionaryBuilder()
+                        .Set("GUID", kManagedDeviceWifiGuid)
+                        .Set("Type", "WiFi")
+                        .Set("WiFi",
+                             DictionaryBuilder()
+                                 .Set("SSID", device_policy_ssid)
+                                 .Set("HexSSID", base::HexEncode(
+                                                     device_policy_ssid.c_str(),
+                                                     device_policy_ssid.size()))
+                                 .Set("Security", "None")
+                                 .Build())
+                        .Build())
+            .Build();
     config_handler->SetPolicy(::onc::ONC_SOURCE_DEVICE_POLICY, "",
-                              base::ListValue(), base::DictionaryValue());
+                              *device_policy_onc, base::DictionaryValue());
   }
 
   void AddSharedNetworkToUserProfile() {
     service_test_->SetServiceProperty(kSharedWifiServicePath,
                                       shill::kProfileProperty,
                                       base::Value(kUserProfilePath));
     profile_test_->AddService(kUserProfilePath, kSharedWifiServicePath);
 
     base::RunLoop().RunUntilIdle();
   }
@@ skipping 131 matching lines @@
   scoped_refptr<NetworkingPrivateSetPropertiesFunction> set_properties =
       new NetworkingPrivateSetPropertiesFunction();
 
   RunFunction(set_properties.get(),
               base::StringPrintf("[\"%s\", {\"Priority\": 2}]", guid.c_str()));
   EXPECT_EQ(ExtensionFunction::SUCCEEDED, *set_properties->response_type());
 
   EXPECT_EQ(2, GetNetworkPriority(network));
 }
 
+TEST_F(NetworkingPrivateApiTest, CreatePrivateNetwork_NonMatchingSsids) {
+  const std::string network_ssid = "new_wifi_config";
+  const std::string network_hex_ssid =
+      base::HexEncode(network_ssid.c_str(), network_ssid.size());
+  std::unique_ptr<base::Value> result = RunFunctionAndReturnValue(
+      new NetworkingPrivateCreateNetworkFunction(),
+      base::StringPrintf("[false, {"
+                         "  \"Priority\": 1,"
+                         "  \"Type\": \"WiFi\","
+                         "  \"WiFi\": {"
+                         "    \"SSID\": \"New WiFi\","
+                         "    \"HexSSID\": \"%s\","
+                         "    \"Security\": \"WPA-PSK\""
+                         "}}]",
+                         network_hex_ssid.c_str()));
+
+  ASSERT_TRUE(result);
+  ASSERT_TRUE(result->is_string());
+
+  // Test the created config can be changed now.
+  const std::string guid = result->GetString();
+  const chromeos::NetworkState* network = chromeos::NetworkHandler::Get()
+                                              ->network_state_handler()
+                                              ->GetNetworkStateFromGuid(guid);
+  ASSERT_TRUE(network);
+  EXPECT_TRUE(network->IsPrivate());
+  EXPECT_EQ(1, GetNetworkPriority(network));
+  EXPECT_EQ(network_hex_ssid, network->GetHexSsid());
+  EXPECT_EQ(network_ssid, network->name());
+}
+
+TEST_F(NetworkingPrivateApiTest,
+       CreateAlreadyConfiguredUserPrivateNetwork_BySsid) {
+  EXPECT_EQ("NetworkAlreadyConfigured",
+            RunFunctionAndReturnError(
+                new NetworkingPrivateCreateNetworkFunction(),
+                base::StringPrintf("[false, {"
+                                   "  \"Priority\": 1,"
+                                   "  \"Type\": \"WiFi\","
+                                   "  \"WiFi\": {"
+                                   "    \"SSID\": \"%s\","
+                                   "    \"Security\": \"WPA-PSK\""
+                                   "}}]",
+                                   kManagedUserWifiSsid)));
+}
+
+TEST_F(NetworkingPrivateApiTest,
+       CreateAlreadyConfiguredUserPrivateNetwork_ByHexSsid) {
+  std::string network_hex_ssid =
+      base::HexEncode(kManagedUserWifiSsid, sizeof(kManagedUserWifiSsid) - 1);
+  EXPECT_EQ("NetworkAlreadyConfigured",
+            RunFunctionAndReturnError(
+                new NetworkingPrivateCreateNetworkFunction(),
+                base::StringPrintf("[false, {"
+                                   "  \"Priority\": 1,"
+                                   "  \"Type\": \"WiFi\","
+                                   "  \"WiFi\": {"
+                                   "    \"HexSSID\": \"%s\","
+                                   "    \"Security\": \"WPA-PSK\""
+                                   "}}]",
+                                   network_hex_ssid.c_str())));
+}
+
+TEST_F(NetworkingPrivateApiTest,
+       CreateAlreadyConfiguredUserPrivateNetwork_NonMatchingSsids) {
+  std::string network_hex_ssid =
+      base::HexEncode(kManagedUserWifiSsid, sizeof(kManagedUserWifiSsid) - 1);
+  // HexSSID should take presedence over SSID.
+  EXPECT_EQ("NetworkAlreadyConfigured",
+            RunFunctionAndReturnError(
+                new NetworkingPrivateCreateNetworkFunction(),
+                base::StringPrintf("[false, {"
+                                   "  \"Priority\": 1,"
+                                   "  \"Type\": \"WiFi\","
+                                   "  \"WiFi\": {"
+                                   "    \"SSID\": \"wrong_ssid\","
+                                   "    \"HexSSID\": \"%s\","
+                                   "    \"Security\": \"WPA-PSK\""
+                                   "}}]",
+                                   network_hex_ssid.c_str())));
+}
+
+TEST_F(NetworkingPrivateApiTest,
+       CreateAlreadyConfiguredUserPrivateNetwork_ByHexSSID) {
+  std::string network_hex_ssid =
+      base::HexEncode(kManagedUserWifiSsid, sizeof(kManagedUserWifiSsid) - 1);
+  EXPECT_EQ("NetworkAlreadyConfigured",
+            RunFunctionAndReturnError(
+                new NetworkingPrivateCreateNetworkFunction(),
+                base::StringPrintf("[false, {"
+                                   "  \"Priority\": 1,"
+                                   "  \"Type\": \"WiFi\","
+                                   "  \"WiFi\": {"
+                                   "    \"HexSSID\": \"%s\","
+                                   "    \"Security\": \"WPA-PSK\""
+                                   "}}]",
+                                   network_hex_ssid.c_str())));
+}
+
+TEST_F(NetworkingPrivateApiTest, CreateAlreadyConfiguredDeviceNetwork) {
+  EXPECT_EQ(
+      "NetworkAlreadyConfigured",
+      RunFunctionAndReturnError(new NetworkingPrivateCreateNetworkFunction(),
+                                base::StringPrintf("[false, {"
+                                                   "  \"Priority\": 1,"
+                                                   "  \"Type\": \"WiFi\","
+                                                   "  \"WiFi\": {"
+                                                   "    \"SSID\": \"%s\""
+                                                   "}}]",
+                                                   kManagedDeviceWifiSsid)));
+}
+
+TEST_F(NetworkingPrivateApiTest,
+       CreateAlreadyConfiguredDeviceNetwork_ByHexSSID) {
+  std::string network_hex_ssid = base::HexEncode(
+      kManagedDeviceWifiSsid, sizeof(kManagedDeviceWifiSsid) - 1);
+  EXPECT_EQ("NetworkAlreadyConfigured",
+            RunFunctionAndReturnError(
+                new NetworkingPrivateCreateNetworkFunction(),
+                base::StringPrintf("[false, {"
+                                   "  \"Priority\": 1,"
+                                   "  \"Type\": \"WiFi\","
+                                   "  \"WiFi\": {"
+                                   "    \"HexSSID\": \"%s\","
+                                   "    \"Security\": \"WPA-PSK\""
+                                   "}}]",
+                                   network_hex_ssid.c_str())));
+}
+
 }  // namespace extensions