Implement Networking Private API VerifyAndEncryptCredentials method

components/wifi/wifi_service_win.cc

 // Copyright 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 "components/wifi/wifi_service.h"
 
 #include <iphlpapi.h>
 #include <objbase.h>
 #include <wlanapi.h>
 
 #include <set>
 
 #include "base/base_paths_win.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/registry.h"
 #include "components/onc/onc_constants.h"
 #include "third_party/libxml/chromium/libxml_utils.h"
 
 namespace {
 const char kWiFiServiceError[] = "Error.WiFiService";
+const char kWiFiServiceErrorNotImplemented[] =
+    "Error.WiFiService.NotImplemented";
 const wchar_t kNwCategoryWizardRegKey[] =
     L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Network\\"
     L"NwCategoryWizard";
 const wchar_t kNwCategoryWizardRegValue[] = L"Show";
 const wchar_t kNwCategoryWizardSavedRegValue[] = L"ShowSaved";
 const wchar_t kNwCategoryWizardDeleteRegValue[] = L"ShowDelete";
 const wchar_t kWlanApiDll[] = L"wlanapi.dll";
 
 // WlanApi function names
 const char kWlanConnect[] = "WlanConnect";
@@ skipping 163 matching lines @@
                                    base::ListValue* network_list) OVERRIDE;
 
   virtual void RequestNetworkScan() OVERRIDE;
 
   virtual void StartConnect(const std::string& network_guid,
                             std::string* error) OVERRIDE;
 
   virtual void StartDisconnect(const std::string& network_guid,
                                std::string* error) OVERRIDE;
 
+  virtual void GetPassphraseFromSystem(const std::string& network_guid,
+                                       std::string* passphrase,
+                                       std::string* error) OVERRIDE;
+
   virtual void SetEventObservers(
       scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
       const NetworkGuidListCallback& networks_changed_observer,
       const NetworkGuidListCallback& network_list_changed_observer) OVERRIDE;
 
   virtual void RequestConnectedNetworkUpdate() OVERRIDE {}
 
  private:
   // Static callback for Windows WLAN_NOTIFICATION. Calls OnWlanNotification
   // on WiFiServiceImpl passed back as |context|.
@@ skipping 409 matching lines @@
       error_code = Disconnect();
       if (error_code == ERROR_SUCCESS) {
         NotifyNetworkChanged(network_guid);
         return;
       }
     }
   }
   CheckError(error_code, kWiFiServiceError, error);
 }
 
+void WiFiServiceImpl::GetPassphraseFromSystem(const std::string& network_guid,
+                                              std::string* passphrase,
+                                              std::string* error) {
+  DWORD error_code = EnsureInitialized();
+  if (CheckError(error_code, kWiFiServiceError, error))
+    return;
+
+  std::string profile_xml;
+  error_code = GetProfile(network_guid, &profile_xml);
+  if (CheckError(error_code, kWiFiServiceError, error))
+    return;
+
+  // Quick check to verify presence of <sharedKey> element.
+  if (profile_xml.find("<sharedKey>") == std::string::npos) {
+    *error = kWiFiServiceError;
+    return;
+  }
+
+  XmlReader reader;
+  if (reader.Load(profile_xml)) {
+    while(reader.Read()) {
+      reader.SkipToElement();
+      if (reader.NodeName() == "keyMaterial") {
+        reader.ReadElementContent(passphrase);
+        return;
+      }
+    }
+  }
+  // Did not find passphrase in the profile.
+  *error = kWiFiServiceError;
+}
+
 void WiFiServiceImpl::SetEventObservers(
     scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
     const NetworkGuidListCallback& networks_changed_observer,
     const NetworkGuidListCallback& network_list_changed_observer) {
   message_loop_proxy_.swap(message_loop_proxy);
   networks_changed_observer_ = networks_changed_observer;
   network_list_changed_observer_ = network_list_changed_observer;
 }
 
 void WiFiServiceImpl::OnWlanNotificationCallback(
@@ skipping 793 matching lines @@
 
 DWORD WiFiServiceImpl::GetProfile(const std::string& network_guid,
                                   std::string* profile_xml) {
   if (client_ == NULL) {
     NOTREACHED();
     return ERROR_NOINTERFACE;
   }
 
   DWORD error = ERROR_SUCCESS;
   base::string16 profile_name = ProfileNameFromGUID(network_guid);
+  DWORD flags = WLAN_PROFILE_GET_PLAINTEXT_KEY;
   LPWSTR str_profile_xml = NULL;
   error = WlanGetProfile_function_(client_,
                                    &interface_guid_,
                                    profile_name.c_str(),
                                    NULL,
                                    &str_profile_xml,
-                                   NULL,
+                                   &flags,
                                    NULL);
 
   if (error == ERROR_SUCCESS && str_profile_xml != NULL) {
     *profile_xml = base::UTF16ToUTF8(str_profile_xml);
   }
   // Clean up.
   if (str_profile_xml != NULL) {
     WlanFreeMemory_function_(str_profile_xml);
   }
 
@@ skipping 110 matching lines @@
     NetworkGuidList changed_networks(1, network_guid);
     message_loop_proxy_->PostTask(
         FROM_HERE,
         base::Bind(networks_changed_observer_, changed_networks));
   }
 }
 
 WiFiService* WiFiService::Create() { return new WiFiServiceImpl(); }
 
 }  // namespace wifi