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