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 19 matching lines @@
   chromeos::ShillDeviceClient::TestInterface* device_test_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateApiTest);
 };
 
 TEST_F(NetworkingPrivateApiTest, SetSharedNetworkProperties) {
   EXPECT_EQ(networking_private::kErrorAccessToSharedConfig,
             RunFunctionAndReturnError(
                 new NetworkingPrivateSetPropertiesFunction(),
                 base::StringPrintf(
-                    "[\"%s\", {\"WiFi\": {\"Passphrase\": \"passphrase\"}}]",
+                    R"(["%s", {"WiFi": {"Passphrase": "passphrase"}}])",
                     kSharedWifiGuid)));
 }
 
 TEST_F(NetworkingPrivateApiTest, SetPrivateNetworkPropertiesWebUI) {
   scoped_refptr<NetworkingPrivateSetPropertiesFunction> set_properties =
       new NetworkingPrivateSetPropertiesFunction();
   set_properties->set_source_context_type(Feature::WEBUI_CONTEXT);
 
   RunFunction(
       set_properties.get(),
-      base::StringPrintf("[\"%s\", {\"Priority\": 0}]", kSharedWifiGuid));
+      base::StringPrintf(R"(["%s", {"Priority": 0}])", kSharedWifiGuid));
   EXPECT_EQ(ExtensionFunction::SUCCEEDED, *set_properties->response_type());
 
   const chromeos::NetworkState* network =
       chromeos::NetworkHandler::Get()
           ->network_state_handler()
           ->GetNetworkStateFromGuid(kSharedWifiGuid);
   ASSERT_TRUE(network);
   EXPECT_FALSE(network->IsPrivate());
   EXPECT_EQ(0, GetNetworkPriority(network));
 }
 
 TEST_F(NetworkingPrivateApiTest, SetPrivateNetworkProperties) {
   scoped_refptr<NetworkingPrivateSetPropertiesFunction> set_properties =
       new NetworkingPrivateSetPropertiesFunction();
   RunFunction(
       set_properties.get(),
-      base::StringPrintf("[\"%s\", {\"Priority\": 0}]", kPrivateWifiGuid));
+      base::StringPrintf(R"(["%s", {"Priority": 0}])", kPrivateWifiGuid));
   EXPECT_EQ(ExtensionFunction::SUCCEEDED, *set_properties->response_type());
 
   const chromeos::NetworkState* network =
       chromeos::NetworkHandler::Get()
           ->network_state_handler()
           ->GetNetworkStateFromGuid(kPrivateWifiGuid);
   ASSERT_TRUE(network);
   EXPECT_TRUE(network->IsPrivate());
   EXPECT_EQ(0, GetNetworkPriority(network));
 }
 
 TEST_F(NetworkingPrivateApiTest, CreateSharedNetwork) {
   EXPECT_EQ(
       networking_private::kErrorAccessToSharedConfig,
       RunFunctionAndReturnError(new NetworkingPrivateCreateNetworkFunction(),
-                                "[true, {"
-                                "  \"Type\": \"WiFi\","
-                                "  \"WiFi\": {"
-                                "    \"SSID\": \"New network\","
-                                "    \"Security\": \"None\""
-                                "}}]"));
+                                R"([true, {
+                                     "Type": "WiFi",
+                                     "WiFi": {
+                                       "SSID": "New network",
+                                       "Security": "None"
+                                     }
+                                   }])"));
 }
 
 TEST_F(NetworkingPrivateApiTest, CreateSharedNetworkWebUI) {
   scoped_refptr<NetworkingPrivateCreateNetworkFunction> create_network =
       new NetworkingPrivateCreateNetworkFunction();
   create_network->set_source_context_type(Feature::WEBUI_CONTEXT);
 
   std::unique_ptr<base::Value> result =
       RunFunctionAndReturnValue(create_network.get(),
-                                "[true, {"
-                                "  \"Priority\": 1,"
-                                "  \"Type\": \"WiFi\","
-                                "  \"WiFi\": {"
-                                "    \"SSID\": \"New network\","
-                                "    \"Security\": \"None\""
-                                "}}]");
+                                R"([true, {
+                                     "Priority": 1,
+                                     "Type": "WiFi",
+                                     "WiFi": {
+                                       "SSID": "New network",
+                                       "Security": "None"
+                                     }
+                                   }])");
 
   ASSERT_TRUE(result);
   ASSERT_TRUE(result->is_string());
 
   std::string guid = result->GetString();
   const chromeos::NetworkState* network = chromeos::NetworkHandler::Get()
                                               ->network_state_handler()
                                               ->GetNetworkStateFromGuid(guid);
   ASSERT_TRUE(network);
   EXPECT_FALSE(network->IsPrivate());
   ASSERT_EQ(1, GetNetworkPriority(network));
 }
 
 TEST_F(NetworkingPrivateApiTest, CreatePrivateNetwork) {
   std::unique_ptr<base::Value> result =
       RunFunctionAndReturnValue(new NetworkingPrivateCreateNetworkFunction(),
-                                "[false, {"
-                                "  \"Priority\": 1,"
-                                "  \"Type\": \"WiFi\","
-                                "  \"WiFi\": {"
-                                "    \"SSID\": \"New WiFi\","
-                                "    \"Security\": \"WPA-PSK\""
-                                "}}]");
+                                R"([false, {
+                                     "Priority": 1,
+                                     "Type": "WiFi",
+                                     "WiFi": {
+                                       "SSID": "New WiFi",
+                                       "Security": "WPA-PSK"
+                                     }
+                                   }])");
 
   ASSERT_TRUE(result);
   ASSERT_TRUE(result->is_string());
 
   // Test the created config can be changed now.
   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));
 
   scoped_refptr<NetworkingPrivateSetPropertiesFunction> set_properties =
       new NetworkingPrivateSetPropertiesFunction();
 
   RunFunction(set_properties.get(),
-              base::StringPrintf("[\"%s\", {\"Priority\": 2}]", guid.c_str()));
+              base::StringPrintf(R"(["%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(R"([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(R"([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(R"([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(R"([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(R"([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(R"([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(R"([false, {
+                                                        "Priority": 1,
+                                                        "Type": "WiFi",
+                                                        "WiFi": {
+                                                          "HexSSID": "%s",
+                                                          "Security": "WPA-PSK"
+                                                        }
+                                                      }])",
+                                                   network_hex_ssid.c_str())));
+}
+
 }  // namespace extensions