Add method GetKeyFromSystem to WiFiService on Windows and Mac.

components/wifi/wifi_service_mac.mm

 // Copyright 2014 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"
 
 #import <netinet/in.h>
 #import <CoreWLAN/CoreWLAN.h>
 #import <SystemConfiguration/SystemConfiguration.h>
 
 #include "base/bind.h"
+#include "base/mac/foundation_util.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/mac/scoped_nsobject.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/sys_string_conversions.h"
 #include "components/onc/onc_constants.h"
 
 #if !defined(MAC_OS_X_VERSION_10_7) || \
     MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_7
 
 // Local definitions of API added in Mac OS X 10.7
@@ skipping 68 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 GetKeyFromSystem(const std::string& network_guid,
+                                bool get_plaintext_key,
+                                std::string* key_data,
+                                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:
   // Checks |ns_error| and if is not |nil|, then stores |error_name|
   // into |error|.
@@ skipping 250 matching lines @@
     NSError* ns_error = nil;
     [interface_ setPower:NO error:&ns_error];
     CheckError(ns_error, kErrorAssociateToNetwork, error);
     [interface_ setPower:YES error:&ns_error];
     CheckError(ns_error, kErrorAssociateToNetwork, error);
   } else {
     *error = kErrorNotConnected;
   }
 }
 
+void WiFiServiceMac::GetKeyFromSystem(const std::string& network_guid,
+                                      bool get_plaintext_key,
+                                      std::string* key_data,
+                                      std::string* error) {
+  static const char kAirPortServiceName[] = "AirPort";
+
+  UInt32 password_length = 0;
+  void *password_data = NULL;
+  OSStatus status = noErr;
+  if (get_plaintext_key) {
+    status = SecKeychainFindGenericPassword(NULL,
+                                            strlen(kAirPortServiceName),
+                                            kAirPortServiceName,
+                                            network_guid.length(),
+                                            network_guid.c_str(),
+                                            &password_length,
+                                            &password_data,
+                                            NULL);
+  } else {
+    NSDictionary *query = [NSDictionary dictionaryWithObjectsAndKeys:
+        (id)kSecClassGenericPassword, kSecClass,
+        SSIDFromGUID(network_guid), kSecAttrAccount,
+        kCFBooleanTrue, kSecReturnRef,
+        nil];
+
+    CFDataRef data = NULL;
+    status = SecItemCopyMatching(base::mac::NSToCFCast(query),
+                                 reinterpret_cast<CFTypeRef *>(&data));
+    base::ScopedCFTypeRef<CFDataRef> scoped_data(data);
+  }
+
+  if (status != errSecSuccess) {
+    *error = kErrorNotFound;
+    return;
+  }
+
+  if (password_data) {
+    *key_data = std::string(reinterpret_cast<char*>(password_data),
+                            password_length);
+    SecKeychainItemFreeContent(NULL, password_data);
+  }
+}
+
 void WiFiServiceMac::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;
 
   // Remove previous OS notifications observer.
   if (wlan_observer_) {
@@ skipping 214 matching lines @@
   NetworkGuidList changed_networks(1, network_guid);
   message_loop_proxy_->PostTask(
       FROM_HERE,
       base::Bind(networks_changed_observer_, changed_networks));
 }
 
 // static
 WiFiService* WiFiService::Create() { return new WiFiServiceMac(); }
 
 }  // namespace wifi