| // 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 "chrome/browser/extensions/api/networking_private/networking_private_service_client.h" |
| |
| #include "base/base64.h" |
| #include "base/bind.h" |
| #include "base/sequenced_task_runner.h" |
| #include "base/strings/string_number_conversions.h" |
| #include "base/strings/string_util.h" |
| #include "base/threading/worker_pool.h" |
| #include "chrome/browser/browser_process.h" |
| #include "chrome/browser/extensions/api/networking_private/networking_private_crypto.h" |
| #include "chrome/common/extensions/api/networking_private.h" |
| #include "content/public/browser/browser_thread.h" |
| #include "content/public/browser/utility_process_host.h" |
| |
| using content::BrowserThread; |
| using extensions::api::networking_private::VerificationProperties; |
| |
| namespace extensions { |
| |
| namespace { |
| |
| const char kNetworkingPrivateServiceClient[] = "NetworkingPrivateServiceClient"; |
| const char kNetworkingPrivateSequenceTokenName[] = "NetworkingPrivate"; |
| |
| // Implementation of Verify* methods using NetworkingPrivateCrypto. |
| // TODO(mef): Move this into NetworkingPrivateCrypto class. |
| class CryptoVerifyImpl : public NetworkingPrivateServiceClient::CryptoVerify { |
| bool VerifyDestination(const VerificationProperties& properties) { |
| std::vector<std::string> data_parts; |
| data_parts.push_back(properties.device_ssid); |
| data_parts.push_back(properties.device_serial); |
| data_parts.push_back(properties.device_bssid); |
| data_parts.push_back(properties.public_key); |
| data_parts.push_back(properties.nonce); |
| std::string unsigned_data = JoinString(data_parts, ","); |
| std::string signed_data; |
| if (!base::Base64Decode(properties.signed_data, &signed_data)) |
| return false; |
| NetworkingPrivateCrypto crypto; |
| return crypto.VerifyCredentials(properties.certificate, |
| signed_data, |
| unsigned_data, |
| properties.device_bssid); |
| } |
| |
| virtual void VerifyDestination(scoped_ptr<base::ListValue> args, |
| bool* verified, |
| std::string* error) OVERRIDE { |
| using extensions::api::networking_private::VerifyDestination::Params; |
| scoped_ptr<Params> params = Params::Create(*args); |
| *verified = VerifyDestination(params->properties); |
| } |
| |
| virtual void VerifyAndEncryptData(scoped_ptr<base::ListValue> args, |
| std::string* base64_encoded_ciphertext, |
| std::string* error) OVERRIDE { |
| using extensions::api::networking_private::VerifyAndEncryptData::Params; |
| scoped_ptr<Params> params = Params::Create(*args); |
| |
| if (!VerifyDestination(params->properties)) { |
| *error = "VerifyError"; |
| return; |
| } |
| |
| std::string public_key; |
| if (!base::Base64Decode(params->properties.public_key, &public_key)) { |
| *error = "DecodeError"; |
| return; |
| } |
| |
| NetworkingPrivateCrypto crypto; |
| std::string ciphertext; |
| if (!crypto.EncryptByteString(public_key, params->data, &ciphertext)) { |
| *error = "EncryptError"; |
| return; |
| } |
| |
| if (!base::Base64Encode(ciphertext, base64_encoded_ciphertext)) { |
| *error = "EncodeError"; |
| return; |
| } |
| } |
| }; |
| |
| // Deletes WiFiService and CryptoVerify objects on worker thread. |
| void ShutdownServicesOnWorkerThread( |
| scoped_ptr<wifi::WiFiService> wifi_service, |
| scoped_ptr<NetworkingPrivateServiceClient::CryptoVerify> crypto_verify) { |
| DCHECK(wifi_service.get()); |
| DCHECK(crypto_verify.get()); |
| } |
| |
| } // namespace |
| |
| NetworkingPrivateServiceClient::NetworkingPrivateServiceClient( |
| wifi::WiFiService* wifi_service, |
| CryptoVerify* crypto_verify) |
| : crypto_verify_(crypto_verify), |
| wifi_service_(wifi_service), |
| weak_factory_(this) { |
| sequence_token_ = BrowserThread::GetBlockingPool()-> |
| GetNamedSequenceToken(kNetworkingPrivateSequenceTokenName); |
| task_runner_ = BrowserThread::GetBlockingPool()-> |
| GetSequencedTaskRunnerWithShutdownBehavior( |
| sequence_token_, |
| base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN); |
| task_runner_->PostTask( |
| FROM_HERE, |
| base::Bind( |
| &WiFiService::SetEventObservers, |
| base::Unretained(wifi_service_.get()), |
| base::MessageLoopProxy::current(), |
| base::Bind( |
| &NetworkingPrivateServiceClient::OnNetworksChangedEventOnUIThread, |
| weak_factory_.GetWeakPtr()), |
| base::Bind( |
| &NetworkingPrivateServiceClient:: |
| OnNetworkListChangedEventOnUIThread, |
| weak_factory_.GetWeakPtr()))); |
| task_runner_->PostTask( |
| FROM_HERE, |
| base::Bind( |
| &WiFiService::Initialize, |
| base::Unretained(wifi_service_.get()), |
| task_runner_)); |
| } |
| |
| NetworkingPrivateServiceClient::~NetworkingPrivateServiceClient() { |
| // Verify that these objects were passed to ShutdownServicesOnWorkerThread to |
| // be deleted after completion of all posted tasks. |
| DCHECK(!wifi_service_.get()); |
| DCHECK(!crypto_verify_.get()); |
| } |
| |
| NetworkingPrivateServiceClient::CryptoVerify* |
| NetworkingPrivateServiceClient::CryptoVerify::Create() { |
| return new CryptoVerifyImpl(); |
| } |
| |
| NetworkingPrivateServiceClient::ServiceCallbacks::ServiceCallbacks() {} |
| |
| NetworkingPrivateServiceClient::ServiceCallbacks::~ServiceCallbacks() {} |
| |
| void NetworkingPrivateServiceClient::Shutdown() { |
| DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
| // Clear callbacks map to release callbacks from UI thread. |
| callbacks_map_.Clear(); |
| // Post ShutdownServicesOnWorkerThread task to delete services when all posted |
| // tasks are done. |
| task_runner_->PostTask( |
| FROM_HERE, |
| base::Bind(&ShutdownServicesOnWorkerThread, |
| base::Passed(&wifi_service_), |
| base::Passed(&crypto_verify_))); |
| } |
| |
| void NetworkingPrivateServiceClient::AddObserver(Observer* observer) { |
| network_events_observers_.AddObserver(observer); |
| } |
| |
| void NetworkingPrivateServiceClient::RemoveObserver(Observer* observer) { |
| network_events_observers_.RemoveObserver(observer); |
| } |
| |
| NetworkingPrivateServiceClient::ServiceCallbacks* |
| NetworkingPrivateServiceClient::AddServiceCallbacks() { |
| ServiceCallbacks* service_callbacks = new ServiceCallbacks(); |
| service_callbacks->id = callbacks_map_.Add(service_callbacks); |
| return service_callbacks; |
| } |
| |
| void NetworkingPrivateServiceClient::RemoveServiceCallbacks( |
| ServiceCallbacksID callback_id) { |
| callbacks_map_.Remove(callback_id); |
| } |
| |
| void NetworkingPrivateServiceClient::GetProperties( |
| const std::string& network_guid, |
| const DictionaryResultCallback& callback, |
| const ErrorCallback& error_callback) { |
| ServiceCallbacks* service_callbacks = AddServiceCallbacks(); |
| service_callbacks->error_callback = error_callback; |
| service_callbacks->get_properties_callback = callback; |
| |
| DictionaryValue* properties = new DictionaryValue(); |
| std::string* error = new std::string; |
| |
| task_runner_->PostTaskAndReply( |
| FROM_HERE, |
| base::Bind(&WiFiService::GetProperties, |
| base::Unretained(wifi_service_.get()), |
| network_guid, |
| properties, |
| error), |
| base::Bind(&NetworkingPrivateServiceClient::AfterGetProperties, |
| weak_factory_.GetWeakPtr(), |
| service_callbacks->id, |
| network_guid, |
| base::Owned(properties), |
| base::Owned(error))); |
| } |
| |
| void NetworkingPrivateServiceClient::GetVisibleNetworks( |
| const std::string& network_type, |
| const ListResultCallback& callback) { |
| ServiceCallbacks* service_callbacks = AddServiceCallbacks(); |
| service_callbacks->get_visible_networks_callback = callback; |
| |
| ListValue* networks = new ListValue(); |
| |
| task_runner_->PostTaskAndReply( |
| FROM_HERE, |
| base::Bind(&WiFiService::GetVisibleNetworks, |
| base::Unretained(wifi_service_.get()), |
| network_type, |
| networks), |
| base::Bind(&NetworkingPrivateServiceClient::AfterGetVisibleNetworks, |
| weak_factory_.GetWeakPtr(), |
| service_callbacks->id, |
| base::Owned(networks))); |
| } |
| |
| void NetworkingPrivateServiceClient::RequestNetworkScan() { |
| task_runner_->PostTask( |
| FROM_HERE, |
| base::Bind(&WiFiService::RequestNetworkScan, |
| base::Unretained(wifi_service_.get()))); |
| } |
| |
| void NetworkingPrivateServiceClient::SetProperties( |
| const std::string& network_guid, |
| const base::DictionaryValue& properties, |
| const base::Closure& callback, |
| const ErrorCallback& error_callback) { |
| ServiceCallbacks* service_callbacks = AddServiceCallbacks(); |
| service_callbacks->error_callback = error_callback; |
| service_callbacks->set_properties_callback = callback; |
| |
| scoped_ptr<base::DictionaryValue> properties_ptr(properties.DeepCopy()); |
| std::string* error = new std::string; |
| |
| task_runner_->PostTaskAndReply( |
| FROM_HERE, |
| base::Bind(&WiFiService::SetProperties, |
| base::Unretained(wifi_service_.get()), |
| network_guid, |
| base::Passed(&properties_ptr), |
| error), |
| base::Bind(&NetworkingPrivateServiceClient::AfterSetProperties, |
| weak_factory_.GetWeakPtr(), |
| service_callbacks->id, |
| base::Owned(error))); |
| } |
| |
| |
| void NetworkingPrivateServiceClient::StartConnect( |
| const std::string& network_guid, |
| const base::Closure& callback, |
| const ErrorCallback& error_callback) { |
| ServiceCallbacks* service_callbacks = AddServiceCallbacks(); |
| service_callbacks->error_callback = error_callback; |
| service_callbacks->start_connect_callback = callback; |
| |
| std::string* error = new std::string; |
| |
| task_runner_->PostTaskAndReply( |
| FROM_HERE, |
| base::Bind(&WiFiService::StartConnect, |
| base::Unretained(wifi_service_.get()), |
| network_guid, |
| error), |
| base::Bind(&NetworkingPrivateServiceClient::AfterStartConnect, |
| weak_factory_.GetWeakPtr(), |
| service_callbacks->id, |
| base::Owned(error))); |
| } |
| |
| void NetworkingPrivateServiceClient::StartDisconnect( |
| const std::string& network_guid, |
| const base::Closure& callback, |
| const ErrorCallback& error_callback) { |
| ServiceCallbacks* service_callbacks = AddServiceCallbacks(); |
| service_callbacks->error_callback = error_callback; |
| service_callbacks->start_disconnect_callback = callback; |
| |
| std::string* error = new std::string; |
| |
| task_runner_->PostTaskAndReply( |
| FROM_HERE, |
| base::Bind(&WiFiService::StartDisconnect, |
| base::Unretained(wifi_service_.get()), |
| network_guid, |
| error), |
| base::Bind(&NetworkingPrivateServiceClient::AfterStartDisconnect, |
| weak_factory_.GetWeakPtr(), |
| service_callbacks->id, |
| base::Owned(error))); |
| } |
| |
| void NetworkingPrivateServiceClient::VerifyDestination( |
| scoped_ptr<base::ListValue> args, |
| const BoolResultCallback& callback, |
| const CryptoErrorCallback& error_callback) { |
| ServiceCallbacks* service_callbacks = AddServiceCallbacks(); |
| service_callbacks->crypto_error_callback = error_callback; |
| service_callbacks->verify_destination_callback = callback; |
| |
| bool* result = new bool; |
| std::string* error = new std::string; |
| |
| task_runner_->PostTaskAndReply( |
| FROM_HERE, |
| base::Bind(&CryptoVerify::VerifyDestination, |
| base::Unretained(crypto_verify_.get()), |
| base::Passed(&args), |
| result, |
| error), |
| base::Bind(&NetworkingPrivateServiceClient::AfterVerifyDestination, |
| weak_factory_.GetWeakPtr(), |
| service_callbacks->id, |
| base::Owned(result), |
| base::Owned(error))); |
| } |
| |
| void NetworkingPrivateServiceClient::VerifyAndEncryptData( |
| scoped_ptr<base::ListValue> args, |
| const StringResultCallback& callback, |
| const CryptoErrorCallback& error_callback) { |
| ServiceCallbacks* service_callbacks = AddServiceCallbacks(); |
| service_callbacks->crypto_error_callback = error_callback; |
| service_callbacks->verify_and_encrypt_data_callback = callback; |
| |
| std::string* result = new std::string; |
| std::string* error = new std::string; |
| |
| task_runner_->PostTaskAndReply( |
| FROM_HERE, |
| base::Bind(&CryptoVerify::VerifyAndEncryptData, |
| base::Unretained(crypto_verify_.get()), |
| base::Passed(&args), |
| result, |
| error), |
| base::Bind(&NetworkingPrivateServiceClient::AfterVerifyAndEncryptData, |
| weak_factory_.GetWeakPtr(), |
| service_callbacks->id, |
| base::Owned(result), |
| base::Owned(error))); |
| } |
| |
| void NetworkingPrivateServiceClient::AfterGetProperties( |
| ServiceCallbacksID callback_id, |
| const std::string& network_guid, |
| const DictionaryValue* properties, |
| const std::string* error) { |
| ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id); |
| DCHECK(service_callbacks); |
| if (!error->empty()) { |
| DCHECK(!service_callbacks->error_callback.is_null()); |
| service_callbacks->error_callback.Run(*error, |
| scoped_ptr<base::DictionaryValue>()); |
| } else { |
| DCHECK(!service_callbacks->get_properties_callback.is_null()); |
| service_callbacks->get_properties_callback.Run(network_guid, *properties); |
| } |
| RemoveServiceCallbacks(callback_id); |
| } |
| |
| void NetworkingPrivateServiceClient::AfterGetVisibleNetworks( |
| ServiceCallbacksID callback_id, |
| const ListValue* networks) { |
| ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id); |
| DCHECK(service_callbacks); |
| DCHECK(!service_callbacks->get_visible_networks_callback.is_null()); |
| service_callbacks->get_visible_networks_callback.Run(*networks); |
| RemoveServiceCallbacks(callback_id); |
| } |
| |
| void NetworkingPrivateServiceClient::AfterSetProperties( |
| ServiceCallbacksID callback_id, |
| const std::string* error) { |
| ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id); |
| DCHECK(service_callbacks); |
| if (!error->empty()) { |
| DCHECK(!service_callbacks->error_callback.is_null()); |
| service_callbacks->error_callback.Run(*error, |
| scoped_ptr<base::DictionaryValue>()); |
| } else { |
| DCHECK(!service_callbacks->set_properties_callback.is_null()); |
| service_callbacks->set_properties_callback.Run(); |
| } |
| RemoveServiceCallbacks(callback_id); |
| } |
| |
| void NetworkingPrivateServiceClient::AfterStartConnect( |
| ServiceCallbacksID callback_id, |
| const std::string* error) { |
| ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id); |
| DCHECK(service_callbacks); |
| if (!error->empty()) { |
| DCHECK(!service_callbacks->error_callback.is_null()); |
| service_callbacks->error_callback.Run(*error, |
| scoped_ptr<base::DictionaryValue>()); |
| } else { |
| DCHECK(!service_callbacks->start_connect_callback.is_null()); |
| service_callbacks->start_connect_callback.Run(); |
| } |
| RemoveServiceCallbacks(callback_id); |
| } |
| |
| void NetworkingPrivateServiceClient::AfterStartDisconnect( |
| ServiceCallbacksID callback_id, |
| const std::string* error) { |
| ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id); |
| DCHECK(service_callbacks); |
| if (!error->empty()) { |
| DCHECK(!service_callbacks->error_callback.is_null()); |
| service_callbacks->error_callback.Run(*error, |
| scoped_ptr<base::DictionaryValue>()); |
| } else { |
| DCHECK(!service_callbacks->start_disconnect_callback.is_null()); |
| service_callbacks->start_disconnect_callback.Run(); |
| } |
| RemoveServiceCallbacks(callback_id); |
| } |
| |
| void NetworkingPrivateServiceClient::AfterVerifyDestination( |
| ServiceCallbacksID callback_id, |
| const bool* result, |
| const std::string* error) { |
| ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id); |
| DCHECK(service_callbacks); |
| if (!error->empty()) { |
| DCHECK(!service_callbacks->crypto_error_callback.is_null()); |
| service_callbacks->crypto_error_callback.Run(*error, *error); |
| } else { |
| DCHECK(!service_callbacks->verify_destination_callback.is_null()); |
| service_callbacks->verify_destination_callback.Run(*result); |
| } |
| RemoveServiceCallbacks(callback_id); |
| } |
| |
| void NetworkingPrivateServiceClient::AfterVerifyAndEncryptData( |
| ServiceCallbacksID callback_id, |
| const std::string* result, |
| const std::string* error) { |
| ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id); |
| DCHECK(service_callbacks); |
| if (!error->empty()) { |
| DCHECK(!service_callbacks->crypto_error_callback.is_null()); |
| service_callbacks->crypto_error_callback.Run(*error, *error); |
| } else { |
| DCHECK(!service_callbacks->verify_and_encrypt_data_callback.is_null()); |
| service_callbacks->verify_and_encrypt_data_callback.Run(*result); |
| } |
| RemoveServiceCallbacks(callback_id); |
| } |
| |
| void NetworkingPrivateServiceClient::OnNetworksChangedEventOnUIThread( |
| const std::vector<std::string>& network_guids) { |
| DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
| FOR_EACH_OBSERVER(Observer, |
| network_events_observers_, |
| OnNetworksChangedEvent(network_guids)); |
| } |
| |
| void NetworkingPrivateServiceClient::OnNetworkListChangedEventOnUIThread( |
| const std::vector<std::string>& network_guids) { |
| DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
| FOR_EACH_OBSERVER(Observer, |
| network_events_observers_, |
| OnNetworkListChangedEvent(network_guids)); |
| } |
| |
| } // namespace extensions |
