// Copyright 2015 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ash/webui/multidevice_debug/proximity_auth_webui_handler.h"
#include <algorithm>
#include <memory>
#include <sstream>
#include <utility>
#include "base/base64url.h"
#include "base/functional/bind.h"
#include "base/i18n/time_formatting.h"
#include "base/time/default_clock.h"
#include "base/time/default_tick_clock.h"
#include "base/values.h"
#include "chromeos/ash/components/multidevice/logging/logging.h"
#include "chromeos/ash/components/multidevice/software_feature_state.h"
#include "chromeos/ash/services/device_sync/proto/enum_util.h"
#include "components/prefs/pref_service.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/web_ui.h"
#include "device/bluetooth/public/cpp/bluetooth_uuid.h"
namespace ash {
namespace multidevice {
namespace {
constexpr const multidevice::SoftwareFeature kAllSoftareFeatures[] = {
multidevice::SoftwareFeature::kBetterTogetherHost,
multidevice::SoftwareFeature::kBetterTogetherClient,
multidevice::SoftwareFeature::kSmartLockHost,
multidevice::SoftwareFeature::kSmartLockClient,
multidevice::SoftwareFeature::kInstantTetheringHost,
multidevice::SoftwareFeature::kInstantTetheringClient,
multidevice::SoftwareFeature::kMessagesForWebHost,
multidevice::SoftwareFeature::kMessagesForWebClient,
multidevice::SoftwareFeature::kPhoneHubHost,
multidevice::SoftwareFeature::kPhoneHubClient,
multidevice::SoftwareFeature::kWifiSyncHost,
multidevice::SoftwareFeature::kWifiSyncClient,
multidevice::SoftwareFeature::kEcheHost,
multidevice::SoftwareFeature::kEcheClient,
multidevice::SoftwareFeature::kPhoneHubCameraRollHost,
multidevice::SoftwareFeature::kPhoneHubCameraRollClient};
// Keys in the JSON representation of a log message.
const char kLogMessageTextKey[] = "text";
const char kLogMessageTimeKey[] = "time";
const char kLogMessageFileKey[] = "file";
const char kLogMessageLineKey[] = "line";
const char kLogMessageSeverityKey[] = "severity";
// Keys in the JSON representation of a SyncState object for enrollment or
// device sync.
const char kSyncStateLastSuccessTime[] = "lastSuccessTime";
const char kSyncStateNextRefreshTime[] = "nextRefreshTime";
const char kSyncStateRecoveringFromFailure[] = "recoveringFromFailure";
const char kSyncStateOperationInProgress[] = "operationInProgress";
// 9999 days in milliseconds.
const double kFakeInfinityMillis = 863913600000;
double ConvertNextAttemptTimeToDouble(base::TimeDelta delta) {
// If no future attempt is scheduled, the next-attempt time is
// base::TimeDelta::Max(), which corresponds to an infinite double value. In
// order to store the next-attempt time as a double base::Value,
// std::isfinite() must be true. So, here we use 9999 days to represent the
// max next-attempt time to allow use with base::Value.
if (delta.is_max())
return kFakeInfinityMillis;
return delta.InMillisecondsF();
}
// Converts |log_message| to a raw dictionary value used as a JSON argument to
// JavaScript functions.
base::Value::Dict LogMessageToDictionary(
const multidevice::LogBuffer::LogMessage& log_message) {
base::Value::Dict dictionary;
dictionary.Set(kLogMessageTextKey, log_message.text);
dictionary.Set(kLogMessageTimeKey,
base::TimeFormatTimeOfDayWithMilliseconds(log_message.time));
dictionary.Set(kLogMessageFileKey, log_message.file);
dictionary.Set(kLogMessageLineKey, log_message.line);
dictionary.Set(kLogMessageSeverityKey,
static_cast<int>(log_message.severity));
return dictionary;
}
// Keys in the JSON representation of an ExternalDeviceInfo proto.
const char kExternalDevicePublicKey[] = "publicKey";
const char kExternalDevicePublicKeyTruncated[] = "publicKeyTruncated";
const char kExternalDeviceFriendlyName[] = "friendlyDeviceName";
const char kExternalDeviceNoPiiName[] = "noPiiName";
const char kExternalDeviceUnlockKey[] = "unlockKey";
const char kExternalDeviceMobileHotspot[] = "hasMobileHotspot";
const char kExternalDeviceFeatureStates[] = "featureStates";
// Creates a SyncState JSON object that can be passed to the WebUI.
base::Value::Dict CreateSyncStateDictionary(double last_success_time,
double next_refresh_time,
bool is_recovering_from_failure,
bool is_enrollment_in_progress) {
base::Value::Dict sync_state;
sync_state.Set(kSyncStateLastSuccessTime, last_success_time);
sync_state.Set(kSyncStateNextRefreshTime, next_refresh_time);
sync_state.Set(kSyncStateRecoveringFromFailure, is_recovering_from_failure);
sync_state.Set(kSyncStateOperationInProgress, is_enrollment_in_progress);
return sync_state;
}
std::string GenerateFeaturesString(const multidevice::RemoteDeviceRef& device) {
std::stringstream ss;
ss << "{";
bool logged_feature = false;
for (const auto& software_feature : kAllSoftareFeatures) {
multidevice::SoftwareFeatureState state =
device.GetSoftwareFeatureState(software_feature);
// Only log features with values.
if (state == multidevice::SoftwareFeatureState::kNotSupported)
continue;
logged_feature = true;
ss << software_feature << ": " << state << ", ";
}
if (logged_feature)
ss.seekp(-2, ss.cur); // Remove last ", " from the stream.
ss << "}";
return ss.str();
}
} // namespace
ProximityAuthWebUIHandler::ProximityAuthWebUIHandler(
device_sync::DeviceSyncClient* device_sync_client)
: device_sync_client_(device_sync_client),
web_contents_initialized_(false) {
CHECK(device_sync_client_);
}
ProximityAuthWebUIHandler::~ProximityAuthWebUIHandler() {
multidevice::LogBuffer::GetInstance()->RemoveObserver(this);
device_sync_client_->RemoveObserver(this);
}
void ProximityAuthWebUIHandler::RegisterMessages() {
web_ui()->RegisterMessageCallback(
"onWebContentsInitialized",
base::BindRepeating(&ProximityAuthWebUIHandler::OnWebContentsInitialized,
base::Unretained(this)));
web_ui()->RegisterMessageCallback(
"clearLogBuffer",
base::BindRepeating(&ProximityAuthWebUIHandler::ClearLogBuffer,
base::Unretained(this)));
web_ui()->RegisterMessageCallback(
"getLogMessages",
base::BindRepeating(&ProximityAuthWebUIHandler::GetLogMessages,
base::Unretained(this)));
web_ui()->RegisterMessageCallback(
"getLocalState",
base::BindRepeating(&ProximityAuthWebUIHandler::GetLocalState,
base::Unretained(this)));
web_ui()->RegisterMessageCallback(
"forceEnrollment",
base::BindRepeating(&ProximityAuthWebUIHandler::ForceEnrollment,
base::Unretained(this)));
web_ui()->RegisterMessageCallback(
"forceDeviceSync",
base::BindRepeating(&ProximityAuthWebUIHandler::ForceDeviceSync,
base::Unretained(this)));
}
void ProximityAuthWebUIHandler::OnLogMessageAdded(
const multidevice::LogBuffer::LogMessage& log_message) {
web_ui()->CallJavascriptFunctionUnsafe("LogBufferInterface.onLogMessageAdded",
LogMessageToDictionary(log_message));
}
void ProximityAuthWebUIHandler::OnLogBufferCleared() {
web_ui()->CallJavascriptFunctionUnsafe(
"LogBufferInterface.onLogBufferCleared");
}
void ProximityAuthWebUIHandler::OnEnrollmentFinished() {
// OnGetDebugInfo() will call NotifyOnEnrollmentFinished() with the enrollment
// state info.
enrollment_update_waiting_for_debug_info_ = true;
device_sync_client_->GetDebugInfo(
base::BindOnce(&ProximityAuthWebUIHandler::OnGetDebugInfo,
weak_ptr_factory_.GetWeakPtr()));
}
void ProximityAuthWebUIHandler::OnNewDevicesSynced() {
// OnGetDebugInfo() will call NotifyOnSyncFinished() with the device sync
// state info.
sync_update_waiting_for_debug_info_ = true;
device_sync_client_->GetDebugInfo(
base::BindOnce(&ProximityAuthWebUIHandler::OnGetDebugInfo,
weak_ptr_factory_.GetWeakPtr()));
}
void ProximityAuthWebUIHandler::OnWebContentsInitialized(
const base::Value::List& args) {
if (!web_contents_initialized_) {
device_sync_client_->AddObserver(this);
multidevice::LogBuffer::GetInstance()->AddObserver(this);
web_contents_initialized_ = true;
}
}
void ProximityAuthWebUIHandler::GetLogMessages(const base::Value::List& args) {
base::Value::List json_logs;
for (const auto& log : *multidevice::LogBuffer::GetInstance()->logs()) {
json_logs.Append(LogMessageToDictionary(log));
}
web_ui()->CallJavascriptFunctionUnsafe("LogBufferInterface.onGotLogMessages",
json_logs);
}
void ProximityAuthWebUIHandler::ClearLogBuffer(const base::Value::List& args) {
// The OnLogBufferCleared() observer function will be called after the buffer
// is cleared.
multidevice::LogBuffer::GetInstance()->Clear();
}
void ProximityAuthWebUIHandler::ForceEnrollment(const base::Value::List& args) {
device_sync_client_->ForceEnrollmentNow(
base::BindOnce(&ProximityAuthWebUIHandler::OnForceEnrollmentNow,
weak_ptr_factory_.GetWeakPtr()));
}
void ProximityAuthWebUIHandler::ForceDeviceSync(const base::Value::List& args) {
device_sync_client_->ForceSyncNow(
base::BindOnce(&ProximityAuthWebUIHandler::OnForceSyncNow,
weak_ptr_factory_.GetWeakPtr()));
}
void ProximityAuthWebUIHandler::GetLocalState(const base::Value::List& args) {
// OnGetDebugInfo() will call NotifyGotLocalState() with the enrollment and
// device sync state info.
get_local_state_update_waiting_for_debug_info_ = true;
device_sync_client_->GetDebugInfo(
base::BindOnce(&ProximityAuthWebUIHandler::OnGetDebugInfo,
weak_ptr_factory_.GetWeakPtr()));
}
base::Value ProximityAuthWebUIHandler::GetTruncatedLocalDeviceId() {
std::optional<multidevice::RemoteDeviceRef> local_device_metadata =
device_sync_client_->GetLocalDeviceMetadata();
std::string device_id =
local_device_metadata
? local_device_metadata->GetTruncatedDeviceIdForLogs()
: "Missing Device ID";
return base::Value(device_id);
}
base::Value::List ProximityAuthWebUIHandler::GetRemoteDevicesList() {
base::Value::List devices_list_value;
for (const auto& remote_device : device_sync_client_->GetSyncedDevices()) {
devices_list_value.Append(RemoteDeviceToDictionary(remote_device));
}
return devices_list_value;
}
base::Value::Dict ProximityAuthWebUIHandler::RemoteDeviceToDictionary(
const multidevice::RemoteDeviceRef& remote_device) {
// Set the fields in the ExternalDeviceInfo proto.
base::Value::Dict dictionary;
dictionary.Set(kExternalDevicePublicKey, remote_device.GetDeviceId());
dictionary.Set(kExternalDevicePublicKeyTruncated,
remote_device.GetTruncatedDeviceIdForLogs());
dictionary.Set(kExternalDeviceFriendlyName, remote_device.name());
dictionary.Set(kExternalDeviceNoPiiName, remote_device.pii_free_name());
dictionary.Set(kExternalDeviceUnlockKey,
remote_device.GetSoftwareFeatureState(
multidevice::SoftwareFeature::kSmartLockHost) ==
multidevice::SoftwareFeatureState::kEnabled);
dictionary.Set(kExternalDeviceMobileHotspot,
remote_device.GetSoftwareFeatureState(
multidevice::SoftwareFeature::kInstantTetheringHost) ==
multidevice::SoftwareFeatureState::kSupported);
dictionary.Set(kExternalDeviceFeatureStates,
GenerateFeaturesString(remote_device));
return dictionary;
}
void ProximityAuthWebUIHandler::OnForceEnrollmentNow(bool success) {
PA_LOG(VERBOSE) << "Force enrollment result: " << success;
}
void ProximityAuthWebUIHandler::OnForceSyncNow(bool success) {
PA_LOG(VERBOSE) << "Force sync result: " << success;
}
void ProximityAuthWebUIHandler::OnSetSoftwareFeatureState(
const std::string public_key,
device_sync::mojom::NetworkRequestResult result_code) {
std::string device_id = RemoteDevice::GenerateDeviceId(public_key);
if (result_code == device_sync::mojom::NetworkRequestResult::kSuccess) {
PA_LOG(VERBOSE) << "Successfully set SoftwareFeature state for device: "
<< device_id;
} else {
PA_LOG(ERROR) << "Failed to set SoftwareFeature state for device: "
<< device_id << ", error code: " << result_code;
}
}
void ProximityAuthWebUIHandler::OnGetDebugInfo(
device_sync::mojom::DebugInfoPtr debug_info_ptr) {
// If enrollment is not yet complete, no debug information is available.
if (!debug_info_ptr)
return;
if (enrollment_update_waiting_for_debug_info_) {
enrollment_update_waiting_for_debug_info_ = false;
NotifyOnEnrollmentFinished(
true /* success */,
CreateSyncStateDictionary(
debug_info_ptr->last_enrollment_time
.InMillisecondsFSinceUnixEpoch(),
ConvertNextAttemptTimeToDouble(
debug_info_ptr->time_to_next_enrollment_attempt),
debug_info_ptr->is_recovering_from_enrollment_failure,
debug_info_ptr->is_enrollment_in_progress));
}
if (sync_update_waiting_for_debug_info_) {
sync_update_waiting_for_debug_info_ = false;
NotifyOnSyncFinished(
true /* was_sync_successful */, true /* changed */,
CreateSyncStateDictionary(
debug_info_ptr->last_sync_time.InMillisecondsFSinceUnixEpoch(),
ConvertNextAttemptTimeToDouble(
debug_info_ptr->time_to_next_sync_attempt),
debug_info_ptr->is_recovering_from_sync_failure,
debug_info_ptr->is_sync_in_progress));
}
if (get_local_state_update_waiting_for_debug_info_) {
get_local_state_update_waiting_for_debug_info_ = false;
NotifyGotLocalState(
GetTruncatedLocalDeviceId(),
CreateSyncStateDictionary(
debug_info_ptr->last_enrollment_time
.InMillisecondsFSinceUnixEpoch(),
ConvertNextAttemptTimeToDouble(
debug_info_ptr->time_to_next_enrollment_attempt),
debug_info_ptr->is_recovering_from_enrollment_failure,
debug_info_ptr->is_enrollment_in_progress),
CreateSyncStateDictionary(
debug_info_ptr->last_sync_time.InMillisecondsFSinceUnixEpoch(),
ConvertNextAttemptTimeToDouble(
debug_info_ptr->time_to_next_sync_attempt),
debug_info_ptr->is_recovering_from_sync_failure,
debug_info_ptr->is_sync_in_progress),
GetRemoteDevicesList());
}
}
void ProximityAuthWebUIHandler::NotifyOnEnrollmentFinished(
bool success,
base::Value::Dict enrollment_state) {
PA_LOG(VERBOSE) << "Enrollment attempt completed with success=" << success
<< ":\n"
<< enrollment_state;
web_ui()->CallJavascriptFunctionUnsafe(
"LocalStateInterface.onEnrollmentStateChanged", enrollment_state);
}
void ProximityAuthWebUIHandler::NotifyOnSyncFinished(
bool was_sync_successful,
bool changed,
base::Value::Dict device_sync_state) {
PA_LOG(VERBOSE) << "Device sync completed with result=" << was_sync_successful
<< ":\n"
<< device_sync_state;
web_ui()->CallJavascriptFunctionUnsafe(
"LocalStateInterface.onDeviceSyncStateChanged", device_sync_state);
if (changed) {
base::Value::List synced_devices = GetRemoteDevicesList();
PA_LOG(VERBOSE) << "New unlock keys obtained after device sync:\n"
<< synced_devices;
web_ui()->CallJavascriptFunctionUnsafe(
"LocalStateInterface.onRemoteDevicesChanged", synced_devices);
}
}
void ProximityAuthWebUIHandler::NotifyGotLocalState(
base::Value truncated_local_device_id,
base::Value::Dict enrollment_state,
base::Value::Dict device_sync_state,
base::Value::List synced_devices) {
PA_LOG(VERBOSE) << "==== Got Local State ====\n"
<< "Device ID (truncated): " << truncated_local_device_id
<< "\nEnrollment State: \n"
<< enrollment_state << "Device Sync State: \n"
<< device_sync_state << "Synced devices: \n"
<< synced_devices;
web_ui()->CallJavascriptFunctionUnsafe(
"LocalStateInterface.onGotLocalState", truncated_local_device_id,
enrollment_state, device_sync_state, synced_devices);
}
} // namespace multidevice
} // namespace ash
Codebase Browser
chromium