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
24 namespace {
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.
28 const int kDBusTimeoutMS = 120000;
29
30 } // namespace
31
32 namespace attestation {
33
DBusProxy()34 DBusProxy::DBusProxy() {}
~DBusProxy()35 DBusProxy::~DBusProxy() {
36 if (bus_) {
37 bus_->ShutdownAndBlock();
38 }
39 }
40
Initialize()41 bool 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
CreateGoogleAttestedKey(const CreateGoogleAttestedKeyRequest & request,const CreateGoogleAttestedKeyCallback & callback)51 void 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
GetKeyInfo(const GetKeyInfoRequest & request,const GetKeyInfoCallback & callback)65 void 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
GetEndorsementInfo(const GetEndorsementInfoRequest & request,const GetEndorsementInfoCallback & callback)77 void 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
GetAttestationKeyInfo(const GetAttestationKeyInfoRequest & request,const GetAttestationKeyInfoCallback & callback)90 void 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
ActivateAttestationKey(const ActivateAttestationKeyRequest & request,const ActivateAttestationKeyCallback & callback)104 void 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
CreateCertifiableKey(const CreateCertifiableKeyRequest & request,const CreateCertifiableKeyCallback & callback)118 void 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
Decrypt(const DecryptRequest & request,const DecryptCallback & callback)132 void 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
Sign(const SignRequest & request,const SignCallback & callback)144 void 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
RegisterKeyWithChapsToken(const RegisterKeyWithChapsTokenRequest & request,const RegisterKeyWithChapsTokenCallback & callback)155 void 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