// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chromeos/ash/components/dbus/userdataauth/cryptohome_misc_client.h"
#include <memory>
#include <utility>
#include <google/protobuf/message_lite.h>
#include "base/functional/bind.h"
#include "base/location.h"
#include "base/logging.h"
#include "base/memory/raw_ptr.h"
#include "base/task/single_thread_task_runner.h"
#include "base/time/time.h"
#include "chromeos/ash/components/dbus/userdataauth/fake_cryptohome_misc_client.h"
#include "chromeos/dbus/common/blocking_method_caller.h"
#include "dbus/bus.h"
#include "dbus/message.h"
#include "dbus/object_path.h"
#include "dbus/object_proxy.h"
#include "third_party/cros_system_api/dbus/cryptohome/dbus-constants.h"
namespace ash {
namespace {
// The default timeout for all method call within CryptohomeMisc interface.
// Note that it is known that cryptohomed could be slow to respond to calls
// certain conditions. D-Bus call blocking for as long as 2 minutes have been
// observed in testing conditions/CQ.
constexpr int kCryptohomeMiscDefaultTimeoutMS = 5 * 60 * 1000;
CryptohomeMiscClient* g_instance = nullptr;
// Tries to parse a proto message from |response| into |proto|.
// Returns false if |response| is nullptr or the message cannot be parsed.
bool ParseProto(dbus::Response* response,
google::protobuf::MessageLite* proto) {
if (!response) {
LOG(ERROR) << "Failed to call cryptohomed";
return false;
}
dbus::MessageReader reader(response);
if (!reader.PopArrayOfBytesAsProto(proto)) {
LOG(ERROR) << "Failed to parse response message from cryptohomed";
return false;
}
return true;
}
// "Real" implementation of CryptohomeMiscClient talking to the cryptohomed's
// CryptohomeMisc interface on the Chrome OS side.
class CryptohomeMiscClientImpl : public CryptohomeMiscClient {
public:
CryptohomeMiscClientImpl() = default;
~CryptohomeMiscClientImpl() override = default;
// Not copyable or movable.
CryptohomeMiscClientImpl(const CryptohomeMiscClientImpl&) = delete;
CryptohomeMiscClientImpl& operator=(const CryptohomeMiscClientImpl&) = delete;
void Init(dbus::Bus* bus) {
proxy_ = bus->GetObjectProxy(
::user_data_auth::kUserDataAuthServiceName,
dbus::ObjectPath(::user_data_auth::kUserDataAuthServicePath));
blocking_method_caller_ =
std::make_unique<chromeos::BlockingMethodCaller>(bus, proxy_);
}
// CryptohomeMiscClient override:
void WaitForServiceToBeAvailable(
chromeos::WaitForServiceToBeAvailableCallback callback) override {
proxy_->WaitForServiceToBeAvailable(std::move(callback));
}
void GetSystemSalt(const ::user_data_auth::GetSystemSaltRequest& request,
GetSystemSaltCallback callback) override {
CallProtoMethod(::user_data_auth::kGetSystemSalt,
::user_data_auth::kCryptohomeMiscInterface, request,
std::move(callback));
}
void GetSanitizedUsername(
const ::user_data_auth::GetSanitizedUsernameRequest& request,
GetSanitizedUsernameCallback callback) override {
CallProtoMethod(::user_data_auth::kGetSanitizedUsername,
::user_data_auth::kCryptohomeMiscInterface, request,
std::move(callback));
}
void GetLoginStatus(const ::user_data_auth::GetLoginStatusRequest& request,
GetLoginStatusCallback callback) override {
CallProtoMethod(::user_data_auth::kGetLoginStatus,
::user_data_auth::kCryptohomeMiscInterface, request,
std::move(callback));
}
void LockToSingleUserMountUntilReboot(
const ::user_data_auth::LockToSingleUserMountUntilRebootRequest& request,
LockToSingleUserMountUntilRebootCallback callback) override {
CallProtoMethod(::user_data_auth::kLockToSingleUserMountUntilReboot,
::user_data_auth::kCryptohomeMiscInterface, request,
std::move(callback));
}
void GetRsuDeviceId(const ::user_data_auth::GetRsuDeviceIdRequest& request,
GetRsuDeviceIdCallback callback) override {
CallProtoMethod(::user_data_auth::kGetRsuDeviceId,
::user_data_auth::kCryptohomeMiscInterface, request,
std::move(callback));
}
std::optional<::user_data_auth::GetSanitizedUsernameReply>
BlockingGetSanitizedUsername(
const ::user_data_auth::GetSanitizedUsernameRequest& request) override {
return BlockingCallProtoMethod<::user_data_auth::GetSanitizedUsernameReply>(
::user_data_auth::kGetSanitizedUsername,
::user_data_auth::kCryptohomeMiscInterface, request);
}
private:
// Calls cryptohomed's |method_name| method in |interface_name| interface,
// passing in |request| as input with |timeout_ms|. Once the (asynchronous)
// call finishes, |callback| is called with the response proto.
template <typename RequestType, typename ReplyType>
void CallProtoMethodWithTimeout(
const char* method_name,
const char* interface_name,
int timeout_ms,
const RequestType& request,
chromeos::DBusMethodCallback<ReplyType> callback) {
dbus::MethodCall method_call(interface_name, method_name);
dbus::MessageWriter writer(&method_call);
if (!writer.AppendProtoAsArrayOfBytes(request)) {
LOG(ERROR)
<< "Failed to append protobuf when calling CryptohomeMisc method "
<< method_name;
base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
FROM_HERE, base::BindOnce(std::move(callback), std::nullopt));
return;
}
// Bind with the weak pointer of |this| so the response is not
// handled once |this| is already destroyed.
proxy_->CallMethod(
&method_call, timeout_ms,
base::BindOnce(&CryptohomeMiscClientImpl::HandleResponse<ReplyType>,
weak_factory_.GetWeakPtr(), std::move(callback)));
}
// Calls cryptohomed's |method_name| method in |interface_name| interface,
// passing in |request| as input with the default CryptohomeMisc timeout. Once
// the (asynchronous) call finishes, |callback| is called with the response
// proto.
template <typename RequestType, typename ReplyType>
void CallProtoMethod(const char* method_name,
const char* interface_name,
const RequestType& request,
chromeos::DBusMethodCallback<ReplyType> callback) {
CallProtoMethodWithTimeout(method_name, interface_name,
kCryptohomeMiscDefaultTimeoutMS, request,
std::move(callback));
}
// Parses the response proto message from |response| and calls |callback| with
// the decoded message. Calls |callback| with std::nullopt on error, including
// timeout.
template <typename ReplyType>
void HandleResponse(chromeos::DBusMethodCallback<ReplyType> callback,
dbus::Response* response) {
ReplyType reply_proto;
if (!ParseProto(response, &reply_proto)) {
LOG(ERROR) << "Failed to parse reply protobuf from CryptohomeMisc method";
std::move(callback).Run(std::nullopt);
return;
}
std::move(callback).Run(reply_proto);
}
template <typename ReplyType, typename RequestType>
std::optional<ReplyType> BlockingCallProtoMethod(const char* method_name,
const char* interface_name,
const RequestType& request) {
dbus::MethodCall method_call(interface_name, method_name);
dbus::MessageWriter writer(&method_call);
if (!writer.AppendProtoAsArrayOfBytes(request)) {
LOG(ERROR) << "Failed to append protobuf when calling CryptohomeMisc "
"method (blocking) "
<< method_name;
return std::nullopt;
}
std::unique_ptr<dbus::Response> response(
blocking_method_caller_->CallMethodAndBlock(&method_call)
.value_or(nullptr));
if (!response) {
LOG(ERROR) << "DBus call failed for CryptohomeMisc method (blocking) "
<< method_name;
return std::nullopt;
}
ReplyType reply_proto;
if (!ParseProto(response.get(), &reply_proto)) {
LOG(ERROR)
<< "Failed to parse proto from CryptohomeMisc method (blocking) "
<< method_name;
return std::nullopt;
}
return reply_proto;
}
// D-Bus proxy for cryptohomed, not owned.
raw_ptr<dbus::ObjectProxy> proxy_ = nullptr;
// For making blocking dbus calls.
std::unique_ptr<chromeos::BlockingMethodCaller> blocking_method_caller_;
base::WeakPtrFactory<CryptohomeMiscClientImpl> weak_factory_{this};
};
} // namespace
CryptohomeMiscClient::CryptohomeMiscClient() {
CHECK(!g_instance);
g_instance = this;
}
CryptohomeMiscClient::~CryptohomeMiscClient() {
CHECK_EQ(this, g_instance);
g_instance = nullptr;
}
// static
void CryptohomeMiscClient::Initialize(dbus::Bus* bus) {
CHECK(bus);
(new CryptohomeMiscClientImpl())->Init(bus);
}
// static
void CryptohomeMiscClient::InitializeFake() {
new FakeCryptohomeMiscClient();
}
// static
void CryptohomeMiscClient::Shutdown() {
CHECK(g_instance);
delete g_instance;
// The destructor resets |g_instance|.
DCHECK(!g_instance);
}
// static
CryptohomeMiscClient* CryptohomeMiscClient::Get() {
return g_instance;
}
} // namespace ash
Codebase Browser
chromium