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 <string>
18
19 #include <brillo/bind_lambda.h>
20 #include <brillo/dbus/dbus_object_test_helpers.h>
21 #include <dbus/mock_bus.h>
22 #include <dbus/mock_exported_object.h>
23 #include <gmock/gmock.h>
24 #include <gtest/gtest.h>
25
26 #include "tpm_manager/common/mock_tpm_nvram_interface.h"
27 #include "tpm_manager/common/mock_tpm_ownership_interface.h"
28 #include "tpm_manager/common/tpm_manager_constants.h"
29 #include "tpm_manager/common/tpm_nvram_dbus_interface.h"
30 #include "tpm_manager/common/tpm_ownership_dbus_interface.h"
31 #include "tpm_manager/server/dbus_service.h"
32
33 using testing::_;
34 using testing::Invoke;
35 using testing::NiceMock;
36 using testing::Return;
37 using testing::StrictMock;
38 using testing::WithArgs;
39
40 namespace tpm_manager {
41
42 class DBusServiceTest : public testing::Test {
43 public:
44 ~DBusServiceTest() override = default;
SetUp()45 void SetUp() override {
46 dbus::Bus::Options options;
47 mock_bus_ = new NiceMock<dbus::MockBus>(options);
48 dbus::ObjectPath path(kTpmManagerServicePath);
49 mock_exported_object_ =
50 new NiceMock<dbus::MockExportedObject>(mock_bus_.get(), path);
51 ON_CALL(*mock_bus_, GetExportedObject(path))
52 .WillByDefault(Return(mock_exported_object_.get()));
53 dbus_service_.reset(new DBusService(mock_bus_, &mock_nvram_service_,
54 &mock_ownership_service_));
55 scoped_refptr<brillo::dbus_utils::AsyncEventSequencer> sequencer(
56 new brillo::dbus_utils::AsyncEventSequencer());
57 dbus_service_->RegisterDBusObjectsAsync(sequencer.get());
58 }
59
60 template <typename RequestProtobufType, typename ReplyProtobufType>
ExecuteMethod(const std::string & method_name,const RequestProtobufType & request,ReplyProtobufType * reply,const std::string & interface)61 void ExecuteMethod(const std::string& method_name,
62 const RequestProtobufType& request,
63 ReplyProtobufType* reply,
64 const std::string& interface) {
65 std::unique_ptr<dbus::MethodCall> call =
66 CreateMethodCall(method_name, interface);
67 dbus::MessageWriter writer(call.get());
68 writer.AppendProtoAsArrayOfBytes(request);
69 auto response = brillo::dbus_utils::testing::CallMethod(
70 dbus_service_->dbus_object_, call.get());
71 dbus::MessageReader reader(response.get());
72 EXPECT_TRUE(reader.PopArrayOfBytesAsProto(reply));
73 }
74
75 protected:
CreateMethodCall(const std::string & method_name,const std::string & interface)76 std::unique_ptr<dbus::MethodCall> CreateMethodCall(
77 const std::string& method_name,
78 const std::string& interface) {
79 std::unique_ptr<dbus::MethodCall> call(
80 new dbus::MethodCall(interface, method_name));
81 call->SetSerial(1);
82 return call;
83 }
84
85 scoped_refptr<dbus::MockBus> mock_bus_;
86 scoped_refptr<dbus::MockExportedObject> mock_exported_object_;
87 StrictMock<MockTpmNvramInterface> mock_nvram_service_;
88 StrictMock<MockTpmOwnershipInterface> mock_ownership_service_;
89 std::unique_ptr<DBusService> dbus_service_;
90 };
91
TEST_F(DBusServiceTest,CopyableCallback)92 TEST_F(DBusServiceTest, CopyableCallback) {
93 EXPECT_CALL(mock_ownership_service_, GetTpmStatus(_, _))
94 .WillOnce(WithArgs<1>(Invoke(
95 [](const TpmOwnershipInterface::GetTpmStatusCallback& callback) {
96 // Copy the callback, then call the original.
97 GetTpmStatusReply reply;
98 base::Closure copy = base::Bind(callback, reply);
99 callback.Run(reply);
100 })));
101 GetTpmStatusRequest request;
102 GetTpmStatusReply reply;
103 ExecuteMethod(kGetTpmStatus, request, &reply, kTpmOwnershipInterface);
104 }
105
TEST_F(DBusServiceTest,GetTpmStatus)106 TEST_F(DBusServiceTest, GetTpmStatus) {
107 GetTpmStatusRequest request;
108 EXPECT_CALL(mock_ownership_service_, GetTpmStatus(_, _))
109 .WillOnce(Invoke(
110 [](const GetTpmStatusRequest& request,
111 const TpmOwnershipInterface::GetTpmStatusCallback& callback) {
112 GetTpmStatusReply reply;
113 reply.set_status(STATUS_SUCCESS);
114 reply.set_enabled(true);
115 reply.set_owned(true);
116 reply.set_dictionary_attack_counter(3);
117 reply.set_dictionary_attack_threshold(4);
118 reply.set_dictionary_attack_lockout_in_effect(true);
119 reply.set_dictionary_attack_lockout_seconds_remaining(5);
120 callback.Run(reply);
121 }));
122 GetTpmStatusReply reply;
123 ExecuteMethod(kGetTpmStatus, request, &reply, kTpmOwnershipInterface);
124 EXPECT_EQ(STATUS_SUCCESS, reply.status());
125 EXPECT_TRUE(reply.enabled());
126 EXPECT_TRUE(reply.owned());
127 EXPECT_EQ(3, reply.dictionary_attack_counter());
128 EXPECT_EQ(4, reply.dictionary_attack_threshold());
129 EXPECT_TRUE(reply.dictionary_attack_lockout_in_effect());
130 EXPECT_EQ(5, reply.dictionary_attack_lockout_seconds_remaining());
131 }
132
TEST_F(DBusServiceTest,TakeOwnership)133 TEST_F(DBusServiceTest, TakeOwnership) {
134 EXPECT_CALL(mock_ownership_service_, TakeOwnership(_, _))
135 .WillOnce(Invoke(
136 [](const TakeOwnershipRequest& request,
137 const TpmOwnershipInterface::TakeOwnershipCallback& callback) {
138 TakeOwnershipReply reply;
139 reply.set_status(STATUS_SUCCESS);
140 callback.Run(reply);
141 }));
142 TakeOwnershipRequest request;
143 TakeOwnershipReply reply;
144 ExecuteMethod(kTakeOwnership, request, &reply, kTpmOwnershipInterface);
145 EXPECT_EQ(STATUS_SUCCESS, reply.status());
146 }
147
TEST_F(DBusServiceTest,RemoveOwnerDependency)148 TEST_F(DBusServiceTest, RemoveOwnerDependency) {
149 std::string owner_dependency("owner_dependency");
150 RemoveOwnerDependencyRequest request;
151 request.set_owner_dependency(owner_dependency);
152 EXPECT_CALL(mock_ownership_service_, RemoveOwnerDependency(_, _))
153 .WillOnce(Invoke([&owner_dependency](
154 const RemoveOwnerDependencyRequest& request,
155 const TpmOwnershipInterface::RemoveOwnerDependencyCallback&
156 callback) {
157 EXPECT_TRUE(request.has_owner_dependency());
158 EXPECT_EQ(owner_dependency, request.owner_dependency());
159 RemoveOwnerDependencyReply reply;
160 reply.set_status(STATUS_SUCCESS);
161 callback.Run(reply);
162 }));
163 RemoveOwnerDependencyReply reply;
164 ExecuteMethod(kRemoveOwnerDependency, request, &reply,
165 kTpmOwnershipInterface);
166 EXPECT_EQ(STATUS_SUCCESS, reply.status());
167 }
168
TEST_F(DBusServiceTest,DefineSpace)169 TEST_F(DBusServiceTest, DefineSpace) {
170 uint32_t nvram_index = 5;
171 size_t nvram_length = 32;
172 DefineSpaceRequest request;
173 request.set_index(nvram_index);
174 request.set_size(nvram_length);
175 EXPECT_CALL(mock_nvram_service_, DefineSpace(_, _))
176 .WillOnce(Invoke([nvram_index, nvram_length](
177 const DefineSpaceRequest& request,
178 const TpmNvramInterface::DefineSpaceCallback& callback) {
179 EXPECT_TRUE(request.has_index());
180 EXPECT_EQ(nvram_index, request.index());
181 EXPECT_TRUE(request.has_size());
182 EXPECT_EQ(nvram_length, request.size());
183 DefineSpaceReply reply;
184 reply.set_result(NVRAM_RESULT_SUCCESS);
185 callback.Run(reply);
186 }));
187 DefineSpaceReply reply;
188 ExecuteMethod(kDefineSpace, request, &reply, kTpmNvramInterface);
189 EXPECT_EQ(NVRAM_RESULT_SUCCESS, reply.result());
190 }
191
TEST_F(DBusServiceTest,DestroySpace)192 TEST_F(DBusServiceTest, DestroySpace) {
193 uint32_t nvram_index = 5;
194 DestroySpaceRequest request;
195 request.set_index(nvram_index);
196 EXPECT_CALL(mock_nvram_service_, DestroySpace(_, _))
197 .WillOnce(Invoke([nvram_index](
198 const DestroySpaceRequest& request,
199 const TpmNvramInterface::DestroySpaceCallback& callback) {
200 EXPECT_TRUE(request.has_index());
201 EXPECT_EQ(nvram_index, request.index());
202 DestroySpaceReply reply;
203 reply.set_result(NVRAM_RESULT_SUCCESS);
204 callback.Run(reply);
205 }));
206 DestroySpaceReply reply;
207 ExecuteMethod(kDestroySpace, request, &reply, kTpmNvramInterface);
208 EXPECT_EQ(NVRAM_RESULT_SUCCESS, reply.result());
209 }
210
TEST_F(DBusServiceTest,WriteSpace)211 TEST_F(DBusServiceTest, WriteSpace) {
212 uint32_t nvram_index = 5;
213 std::string nvram_data("nvram_data");
214 WriteSpaceRequest request;
215 request.set_index(nvram_index);
216 request.set_data(nvram_data);
217 EXPECT_CALL(mock_nvram_service_, WriteSpace(_, _))
218 .WillOnce(Invoke([nvram_index, nvram_data](
219 const WriteSpaceRequest& request,
220 const TpmNvramInterface::WriteSpaceCallback& callback) {
221 EXPECT_TRUE(request.has_index());
222 EXPECT_EQ(nvram_index, request.index());
223 EXPECT_TRUE(request.has_data());
224 EXPECT_EQ(nvram_data, request.data());
225 WriteSpaceReply reply;
226 reply.set_result(NVRAM_RESULT_SUCCESS);
227 callback.Run(reply);
228 }));
229 WriteSpaceReply reply;
230 ExecuteMethod(kWriteSpace, request, &reply, kTpmNvramInterface);
231 EXPECT_EQ(NVRAM_RESULT_SUCCESS, reply.result());
232 }
233
TEST_F(DBusServiceTest,ReadSpace)234 TEST_F(DBusServiceTest, ReadSpace) {
235 uint32_t nvram_index = 5;
236 std::string nvram_data("nvram_data");
237 ReadSpaceRequest request;
238 request.set_index(nvram_index);
239 EXPECT_CALL(mock_nvram_service_, ReadSpace(_, _))
240 .WillOnce(Invoke([nvram_index, nvram_data](
241 const ReadSpaceRequest& request,
242 const TpmNvramInterface::ReadSpaceCallback& callback) {
243 EXPECT_TRUE(request.has_index());
244 EXPECT_EQ(nvram_index, request.index());
245 ReadSpaceReply reply;
246 reply.set_result(NVRAM_RESULT_SUCCESS);
247 reply.set_data(nvram_data);
248 callback.Run(reply);
249 }));
250 ReadSpaceReply reply;
251 ExecuteMethod(kReadSpace, request, &reply, kTpmNvramInterface);
252 EXPECT_EQ(NVRAM_RESULT_SUCCESS, reply.result());
253 EXPECT_TRUE(reply.has_data());
254 EXPECT_EQ(nvram_data, reply.data());
255 }
256
TEST_F(DBusServiceTest,LockSpace)257 TEST_F(DBusServiceTest, LockSpace) {
258 uint32_t nvram_index = 5;
259 LockSpaceRequest request;
260 request.set_index(nvram_index);
261 request.set_lock_read(true);
262 request.set_lock_write(true);
263 EXPECT_CALL(mock_nvram_service_, LockSpace(_, _))
264 .WillOnce(Invoke(
265 [nvram_index](const LockSpaceRequest& request,
266 const TpmNvramInterface::LockSpaceCallback& callback) {
267 EXPECT_TRUE(request.has_index());
268 EXPECT_EQ(nvram_index, request.index());
269 EXPECT_TRUE(request.lock_read());
270 EXPECT_TRUE(request.lock_write());
271 LockSpaceReply reply;
272 reply.set_result(NVRAM_RESULT_SUCCESS);
273 callback.Run(reply);
274 }));
275 LockSpaceReply reply;
276 ExecuteMethod(kLockSpace, request, &reply, kTpmNvramInterface);
277 EXPECT_EQ(NVRAM_RESULT_SUCCESS, reply.result());
278 }
279
TEST_F(DBusServiceTest,ListSpaces)280 TEST_F(DBusServiceTest, ListSpaces) {
281 constexpr uint32_t nvram_index_list[] = {3, 4, 5};
282 ListSpacesRequest request;
283 EXPECT_CALL(mock_nvram_service_, ListSpaces(_, _))
284 .WillOnce(Invoke([nvram_index_list](
285 const ListSpacesRequest& request,
286 const TpmNvramInterface::ListSpacesCallback& callback) {
287 ListSpacesReply reply;
288 reply.set_result(NVRAM_RESULT_SUCCESS);
289 for (auto index : nvram_index_list) {
290 reply.add_index_list(index);
291 }
292 callback.Run(reply);
293 }));
294 ListSpacesReply reply;
295 ExecuteMethod(kListSpaces, request, &reply, kTpmNvramInterface);
296 EXPECT_EQ(NVRAM_RESULT_SUCCESS, reply.result());
297 EXPECT_EQ(arraysize(nvram_index_list), reply.index_list_size());
298 for (size_t i = 0; i < 3; i++) {
299 EXPECT_EQ(nvram_index_list[i], reply.index_list(i));
300 }
301 }
302
TEST_F(DBusServiceTest,GetSpaceInfo)303 TEST_F(DBusServiceTest, GetSpaceInfo) {
304 uint32_t nvram_index = 5;
305 size_t nvram_size = 32;
306 GetSpaceInfoRequest request;
307 request.set_index(nvram_index);
308 EXPECT_CALL(mock_nvram_service_, GetSpaceInfo(_, _))
309 .WillOnce(Invoke([nvram_index, nvram_size](
310 const GetSpaceInfoRequest& request,
311 const TpmNvramInterface::GetSpaceInfoCallback& callback) {
312 EXPECT_TRUE(request.has_index());
313 EXPECT_EQ(nvram_index, request.index());
314 GetSpaceInfoReply reply;
315 reply.set_result(NVRAM_RESULT_SUCCESS);
316 reply.set_size(nvram_size);
317 reply.set_is_read_locked(true);
318 reply.set_is_write_locked(true);
319 callback.Run(reply);
320 }));
321 GetSpaceInfoReply reply;
322 ExecuteMethod(kGetSpaceInfo, request, &reply, kTpmNvramInterface);
323 EXPECT_EQ(NVRAM_RESULT_SUCCESS, reply.result());
324 EXPECT_TRUE(reply.has_size());
325 EXPECT_EQ(nvram_size, reply.size());
326 EXPECT_TRUE(reply.is_read_locked());
327 EXPECT_TRUE(reply.is_write_locked());
328 }
329
330 } // namespace tpm_manager
331