1// 2// Copyright (C) 2015 The Android Open Source Project 3// 4// Licensed under the Apache License, Version 2.0 (the "License"); 5// you may not use this file except in compliance with the License. 6// You may obtain a copy of the License at 7// 8// http://www.apache.org/licenses/LICENSE-2.0 9// 10// Unless required by applicable law or agreed to in writing, software 11// distributed under the License is distributed on an "AS IS" BASIS, 12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13// See the License for the specific language governing permissions and 14// limitations under the License. 15// 16 17#include "attestation/client/dbus_proxy.h" 18 19#include <brillo/bind_lambda.h> 20#include <brillo/dbus/dbus_method_invoker.h> 21 22#include "attestation/common/dbus_interface.h" 23 24namespace { 25 26// Use a two minute timeout because TPM operations can take a long time and 27// there may be a few of them queued up. 28const int kDBusTimeoutMS = 120000; 29 30} // namespace 31 32namespace attestation { 33 34DBusProxy::DBusProxy() {} 35DBusProxy::~DBusProxy() { 36 if (bus_) { 37 bus_->ShutdownAndBlock(); 38 } 39} 40 41bool DBusProxy::Initialize() { 42 dbus::Bus::Options options; 43 options.bus_type = dbus::Bus::SYSTEM; 44 bus_ = new dbus::Bus(options); 45 object_proxy_ = bus_->GetObjectProxy( 46 attestation::kAttestationServiceName, 47 dbus::ObjectPath(attestation::kAttestationServicePath)); 48 return (object_proxy_ != nullptr); 49} 50 51void DBusProxy::CreateGoogleAttestedKey( 52 const CreateGoogleAttestedKeyRequest& request, 53 const CreateGoogleAttestedKeyCallback& callback) { 54 auto on_error = [callback](brillo::Error* error) { 55 CreateGoogleAttestedKeyReply reply; 56 reply.set_status(STATUS_NOT_AVAILABLE); 57 callback.Run(reply); 58 }; 59 brillo::dbus_utils::CallMethodWithTimeout( 60 kDBusTimeoutMS, object_proxy_, attestation::kAttestationInterface, 61 attestation::kCreateGoogleAttestedKey, callback, base::Bind(on_error), 62 request); 63} 64 65void DBusProxy::GetKeyInfo(const GetKeyInfoRequest& request, 66 const GetKeyInfoCallback& callback) { 67 auto on_error = [callback](brillo::Error* error) { 68 GetKeyInfoReply reply; 69 reply.set_status(STATUS_NOT_AVAILABLE); 70 callback.Run(reply); 71 }; 72 brillo::dbus_utils::CallMethodWithTimeout( 73 kDBusTimeoutMS, object_proxy_, attestation::kAttestationInterface, 74 attestation::kGetKeyInfo, callback, base::Bind(on_error), request); 75} 76 77void DBusProxy::GetEndorsementInfo(const GetEndorsementInfoRequest& request, 78 const GetEndorsementInfoCallback& callback) { 79 auto on_error = [callback](brillo::Error* error) { 80 GetEndorsementInfoReply reply; 81 reply.set_status(STATUS_NOT_AVAILABLE); 82 callback.Run(reply); 83 }; 84 brillo::dbus_utils::CallMethodWithTimeout( 85 kDBusTimeoutMS, object_proxy_, attestation::kAttestationInterface, 86 attestation::kGetEndorsementInfo, callback, base::Bind(on_error), 87 request); 88} 89 90void DBusProxy::GetAttestationKeyInfo( 91 const GetAttestationKeyInfoRequest& request, 92 const GetAttestationKeyInfoCallback& callback) { 93 auto on_error = [callback](brillo::Error* error) { 94 GetAttestationKeyInfoReply reply; 95 reply.set_status(STATUS_NOT_AVAILABLE); 96 callback.Run(reply); 97 }; 98 brillo::dbus_utils::CallMethodWithTimeout( 99 kDBusTimeoutMS, object_proxy_, attestation::kAttestationInterface, 100 attestation::kGetAttestationKeyInfo, callback, base::Bind(on_error), 101 request); 102} 103 104void DBusProxy::ActivateAttestationKey( 105 const ActivateAttestationKeyRequest& request, 106 const ActivateAttestationKeyCallback& callback) { 107 auto on_error = [callback](brillo::Error* error) { 108 ActivateAttestationKeyReply reply; 109 reply.set_status(STATUS_NOT_AVAILABLE); 110 callback.Run(reply); 111 }; 112 brillo::dbus_utils::CallMethodWithTimeout( 113 kDBusTimeoutMS, object_proxy_, attestation::kAttestationInterface, 114 attestation::kActivateAttestationKey, callback, base::Bind(on_error), 115 request); 116} 117 118void DBusProxy::CreateCertifiableKey( 119 const CreateCertifiableKeyRequest& request, 120 const CreateCertifiableKeyCallback& callback) { 121 auto on_error = [callback](brillo::Error* error) { 122 CreateCertifiableKeyReply reply; 123 reply.set_status(STATUS_NOT_AVAILABLE); 124 callback.Run(reply); 125 }; 126 brillo::dbus_utils::CallMethodWithTimeout( 127 kDBusTimeoutMS, object_proxy_, attestation::kAttestationInterface, 128 attestation::kCreateCertifiableKey, callback, base::Bind(on_error), 129 request); 130} 131 132void DBusProxy::Decrypt(const DecryptRequest& request, 133 const DecryptCallback& callback) { 134 auto on_error = [callback](brillo::Error* error) { 135 DecryptReply reply; 136 reply.set_status(STATUS_NOT_AVAILABLE); 137 callback.Run(reply); 138 }; 139 brillo::dbus_utils::CallMethodWithTimeout( 140 kDBusTimeoutMS, object_proxy_, attestation::kAttestationInterface, 141 attestation::kDecrypt, callback, base::Bind(on_error), request); 142} 143 144void DBusProxy::Sign(const SignRequest& request, const SignCallback& callback) { 145 auto on_error = [callback](brillo::Error* error) { 146 SignReply reply; 147 reply.set_status(STATUS_NOT_AVAILABLE); 148 callback.Run(reply); 149 }; 150 brillo::dbus_utils::CallMethodWithTimeout( 151 kDBusTimeoutMS, object_proxy_, attestation::kAttestationInterface, 152 attestation::kSign, callback, base::Bind(on_error), request); 153} 154 155void DBusProxy::RegisterKeyWithChapsToken( 156 const RegisterKeyWithChapsTokenRequest& request, 157 const RegisterKeyWithChapsTokenCallback& callback) { 158 auto on_error = [callback](brillo::Error* error) { 159 RegisterKeyWithChapsTokenReply reply; 160 reply.set_status(STATUS_NOT_AVAILABLE); 161 callback.Run(reply); 162 }; 163 brillo::dbus_utils::CallMethodWithTimeout( 164 kDBusTimeoutMS, object_proxy_, attestation::kAttestationInterface, 165 attestation::kRegisterKeyWithChapsToken, callback, base::Bind(on_error), 166 request); 167} 168 169} // namespace attestation 170