1 /*
2 *
3 * Copyright 2020 The Android Open Source Project
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 */
18
19 #include <gmock/gmock.h>
20 #include <gtest/gtest.h>
21
22 #include <iomanip>
23 #include <iostream>
24 #include <map>
25 #include <sstream>
26 #include <vector>
27
28 #include "btif/include/btif_hh.h"
29 #include "common/init_flags.h"
30 #include "hci/include/hci_layer.h"
31 #include "internal_include/stack_config.h"
32 #include "osi/include/allocator.h"
33 #include "osi/include/osi.h"
34 #include "stack/btm/btm_dev.h"
35 #include "stack/btm/btm_int_types.h"
36 #include "stack/btm/btm_sco.h"
37 #include "stack/btm/btm_sec.h"
38 #include "stack/btm/security_device_record.h"
39 #include "stack/include/acl_api.h"
40 #include "stack/include/acl_hci_link_interface.h"
41 #include "stack/include/btm_client_interface.h"
42 #include "stack/include/hcidefs.h"
43 #include "stack/include/sec_hci_link_interface.h"
44 #include "stack/l2cap/l2c_int.h"
45 #include "test/common/mock_functions.h"
46 #include "test/mock/mock_device_iot_config.h"
47 #include "test/mock/mock_osi_list.h"
48 #include "test/mock/mock_stack_hcic_hcicmds.h"
49 #include "types/raw_address.h"
50
51 using testing::Each;
52 using testing::Eq;
53
54 namespace mock = test::mock::stack_hcic_hcicmds;
55
56 extern tBTM_CB btm_cb;
57
58 uint8_t btif_trace_level = BT_TRACE_LEVEL_DEBUG;
59 uint8_t appl_trace_level = BT_TRACE_LEVEL_VERBOSE;
60 btif_hh_cb_t btif_hh_cb;
61 tL2C_CB l2cb;
62
hci_layer_get_interface()63 const hci_t* hci_layer_get_interface() { return nullptr; }
64
65 const std::string kSmpOptions("mock smp options");
66 const std::string kBroadcastAudioConfigOptions(
67 "mock broadcast audio config options");
68
69 namespace {
70
71 using testing::_;
72 using testing::DoAll;
73 using testing::NotNull;
74 using testing::Pointee;
75 using testing::Return;
76 using testing::SaveArg;
77 using testing::SaveArgPointee;
78 using testing::StrEq;
79 using testing::StrictMock;
80 using testing::Test;
81
82 // NOTE: The production code allows N+1 device records.
83 constexpr size_t kBtmSecMaxDeviceRecords =
84 static_cast<size_t>(BTM_SEC_MAX_DEVICE_RECORDS + 1);
85
Hex16(int n)86 std::string Hex16(int n) {
87 std::ostringstream oss;
88 oss << "0x" << std::hex << std::setw(4) << std::setfill('0') << n;
89 return oss.str();
90 }
91
92 class StackBtmTest : public Test {
93 public:
94 protected:
SetUp()95 void SetUp() override { reset_mock_function_count_map(); }
TearDown()96 void TearDown() override {}
97 };
98
99 class StackBtmWithInitFreeTest : public StackBtmTest {
100 public:
101 protected:
SetUp()102 void SetUp() override {
103 StackBtmTest::SetUp();
104 btm_cb.Init(BTM_SEC_MODE_SC);
105 }
TearDown()106 void TearDown() override {
107 btm_cb.Free();
108 StackBtmTest::TearDown();
109 }
110 };
111
TEST_F(StackBtmTest,GlobalLifecycle)112 TEST_F(StackBtmTest, GlobalLifecycle) {
113 get_btm_client_interface().lifecycle.btm_init();
114 get_btm_client_interface().lifecycle.btm_free();
115 }
116
TEST_F(StackBtmTest,DynamicLifecycle)117 TEST_F(StackBtmTest, DynamicLifecycle) {
118 auto* btm = new tBTM_CB();
119 delete btm;
120 }
121
TEST_F(StackBtmTest,InitFree)122 TEST_F(StackBtmTest, InitFree) {
123 btm_cb.Init(0x1);
124 btm_cb.Free();
125 }
126
TEST_F(StackBtmTest,tSCO_CB)127 TEST_F(StackBtmTest, tSCO_CB) {
128 bluetooth::common::InitFlags::SetAllForTesting();
129 tSCO_CB* p_sco = &btm_cb.sco_cb;
130 p_sco->Init();
131 p_sco->Free();
132 }
133
TEST_F(StackBtmTest,InformClientOnConnectionSuccess)134 TEST_F(StackBtmTest, InformClientOnConnectionSuccess) {
135 get_btm_client_interface().lifecycle.btm_init();
136
137 RawAddress bda({0x11, 0x22, 0x33, 0x44, 0x55, 0x66});
138
139 btm_acl_connected(bda, 2, HCI_SUCCESS, false);
140 ASSERT_EQ(1, get_func_call_count("BTA_dm_acl_up"));
141
142 get_btm_client_interface().lifecycle.btm_free();
143 }
144
TEST_F(StackBtmTest,NoInformClientOnConnectionFail)145 TEST_F(StackBtmTest, NoInformClientOnConnectionFail) {
146 get_btm_client_interface().lifecycle.btm_init();
147
148 RawAddress bda({0x11, 0x22, 0x33, 0x44, 0x55, 0x66});
149
150 btm_acl_connected(bda, 2, HCI_ERR_NO_CONNECTION, false);
151 ASSERT_EQ(0, get_func_call_count("BTA_dm_acl_up"));
152
153 get_btm_client_interface().lifecycle.btm_free();
154 }
155
TEST_F(StackBtmTest,default_packet_type)156 TEST_F(StackBtmTest, default_packet_type) {
157 get_btm_client_interface().lifecycle.btm_init();
158
159 btm_cb.acl_cb_.SetDefaultPacketTypeMask(0x4321);
160 ASSERT_EQ(0x4321, btm_cb.acl_cb_.DefaultPacketTypes());
161
162 get_btm_client_interface().lifecycle.btm_free();
163 }
164
TEST_F(StackBtmTest,change_packet_type)165 TEST_F(StackBtmTest, change_packet_type) {
166 int cnt = 0;
167 get_btm_client_interface().lifecycle.btm_init();
168
169 btm_cb.acl_cb_.SetDefaultPacketTypeMask(0xffff);
170 ASSERT_EQ(0xffff, btm_cb.acl_cb_.DefaultPacketTypes());
171
172 // Create connection
173 RawAddress bda({0x11, 0x22, 0x33, 0x44, 0x55, 0x66});
174 btm_acl_created(bda, 0x123, HCI_ROLE_CENTRAL, BT_TRANSPORT_BR_EDR);
175
176 uint64_t features = 0xffffffffffffffff;
177 acl_process_supported_features(0x123, features);
178
179 uint16_t handle{0};
180 uint16_t packet_types{0};
181
182 mock::btsnd_hcic_change_conn_type.body = [&handle, &packet_types](
183 uint16_t h, uint16_t p) {
184 handle = h;
185 packet_types = p;
186 };
187 btm_set_packet_types_from_address(bda, 0x55aa);
188 ASSERT_EQ(++cnt, get_func_call_count("btsnd_hcic_change_conn_type"));
189 ASSERT_EQ(0x123, handle);
190 ASSERT_EQ(Hex16(0x4400 | HCI_PKT_TYPES_MASK_DM1), Hex16(packet_types));
191
192 btm_set_packet_types_from_address(bda, 0xffff);
193 ASSERT_EQ(++cnt, get_func_call_count("btsnd_hcic_change_conn_type"));
194 ASSERT_EQ(0x123, handle);
195 ASSERT_EQ(Hex16(0xcc00 | HCI_PKT_TYPES_MASK_DM1 | HCI_PKT_TYPES_MASK_DH1),
196 Hex16(packet_types));
197
198 btm_set_packet_types_from_address(bda, 0x0);
199 ASSERT_EQ(0x123, handle);
200 ASSERT_EQ(Hex16(0xcc18), Hex16(packet_types));
201
202 mock::btsnd_hcic_change_conn_type = {};
203 get_btm_client_interface().lifecycle.btm_free();
204 }
205
TEST(ScoTest,make_sco_packet)206 TEST(ScoTest, make_sco_packet) {
207 std::vector<uint8_t> data = {10, 20, 30};
208 uint16_t handle = 0xab;
209 BT_HDR* p = btm_sco_make_packet(data, handle);
210 ASSERT_EQ(p->event, BT_EVT_TO_LM_HCI_SCO);
211 ASSERT_EQ(p->len, 3 + data.size());
212 ASSERT_EQ(p->data[0], 0xab);
213 ASSERT_EQ(p->data[1], 0);
214 ASSERT_EQ(p->data[2], 3);
215 ASSERT_EQ(p->data[3], 10);
216 ASSERT_EQ(p->data[4], 20);
217 ASSERT_EQ(p->data[5], 30);
218 osi_free(p);
219 }
220
TEST(BtmTest,BTM_EIR_MAX_SERVICES)221 TEST(BtmTest, BTM_EIR_MAX_SERVICES) { ASSERT_EQ(46, BTM_EIR_MAX_SERVICES); }
222
223 } // namespace
224
225 void btm_sec_rmt_name_request_complete(const RawAddress* p_bd_addr,
226 const uint8_t* p_bd_name,
227 tHCI_STATUS status);
228
229 struct {
230 RawAddress bd_addr;
231 DEV_CLASS dc;
232 tBTM_BD_NAME bd_name;
233 } btm_test;
234
TEST(SecTest,btm_sec_rmt_name_request_complete)235 TEST(SecTest, btm_sec_rmt_name_request_complete) {
236 bluetooth::common::InitFlags::SetAllForTesting();
237 btm_cb.Init(0);
238
239 ASSERT_TRUE(BTM_SecAddRmtNameNotifyCallback(
240 [](const RawAddress& bd_addr, DEV_CLASS dc, tBTM_BD_NAME bd_name) {
241 btm_test.bd_addr = bd_addr;
242 memcpy(btm_test.dc, dc, DEV_CLASS_LEN);
243 memcpy(btm_test.bd_name, bd_name, BTM_MAX_REM_BD_NAME_LEN);
244 }));
245
246 RawAddress bd_addr = RawAddress({0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6});
247 const uint8_t* p_bd_name = (const uint8_t*)"MyTestName";
248
249 btm_test = {};
250 btm_sec_rmt_name_request_complete(&bd_addr, p_bd_name, HCI_SUCCESS);
251
252 ASSERT_THAT(btm_test.bd_name, Each(Eq(0)));
253 ASSERT_THAT(btm_test.dc, Each(Eq(0)));
254 ASSERT_EQ(bd_addr, btm_test.bd_addr);
255
256 btm_test = {};
257 ASSERT_TRUE(btm_find_or_alloc_dev(bd_addr) != nullptr);
258 btm_sec_rmt_name_request_complete(&bd_addr, p_bd_name, HCI_SUCCESS);
259
260 ASSERT_STREQ((const char*)p_bd_name, (const char*)btm_test.bd_name);
261 ASSERT_THAT(btm_test.dc, Each(Eq(0)));
262 ASSERT_EQ(bd_addr, btm_test.bd_addr);
263
264 btm_cb.Free();
265 }
266
TEST_F(StackBtmWithInitFreeTest,btm_sec_encrypt_change)267 TEST_F(StackBtmWithInitFreeTest, btm_sec_encrypt_change) {
268 bluetooth::common::InitFlags::SetAllForTesting();
269
270 RawAddress bd_addr = RawAddress({0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6});
271 const uint16_t classic_handle = 0x1234;
272 const uint16_t ble_handle = 0x9876;
273
274 // Check the collision conditionals
275 btm_cb.collision_start_time = 0UL;
276 btm_sec_encrypt_change(classic_handle, HCI_ERR_LMP_ERR_TRANS_COLLISION, 0x01);
277 uint64_t collision_start_time = btm_cb.collision_start_time;
278 ASSERT_NE(0UL, collision_start_time);
279
280 btm_cb.collision_start_time = 0UL;
281 btm_sec_encrypt_change(classic_handle, HCI_ERR_DIFF_TRANSACTION_COLLISION,
282 0x01);
283 collision_start_time = btm_cb.collision_start_time;
284 ASSERT_NE(0UL, collision_start_time);
285
286 // No device
287 btm_cb.collision_start_time = 0;
288 btm_sec_encrypt_change(classic_handle, HCI_SUCCESS, 0x01);
289 ASSERT_EQ(0UL, btm_cb.collision_start_time);
290
291 // Setup device
292 tBTM_SEC_DEV_REC* device_record = btm_sec_allocate_dev_rec();
293 ASSERT_NE(nullptr, device_record);
294 ASSERT_EQ(BTM_SEC_IN_USE, device_record->sec_flags);
295 device_record->bd_addr = bd_addr;
296 device_record->hci_handle = classic_handle;
297 device_record->ble_hci_handle = ble_handle;
298
299 // With classic device encryption enable
300 btm_sec_encrypt_change(classic_handle, HCI_SUCCESS, 0x01);
301 ASSERT_EQ(BTM_SEC_IN_USE | BTM_SEC_AUTHENTICATED | BTM_SEC_ENCRYPTED,
302 device_record->sec_flags);
303
304 // With classic device encryption disable
305 btm_sec_encrypt_change(classic_handle, HCI_SUCCESS, 0x00);
306 ASSERT_EQ(BTM_SEC_IN_USE | BTM_SEC_AUTHENTICATED, device_record->sec_flags);
307 device_record->sec_flags = BTM_SEC_IN_USE;
308
309 // With le device encryption enable
310 btm_sec_encrypt_change(ble_handle, HCI_SUCCESS, 0x01);
311 ASSERT_EQ(BTM_SEC_IN_USE | BTM_SEC_LE_ENCRYPTED, device_record->sec_flags);
312
313 // With le device encryption disable
314 btm_sec_encrypt_change(ble_handle, HCI_SUCCESS, 0x00);
315 ASSERT_EQ(BTM_SEC_IN_USE, device_record->sec_flags);
316 device_record->sec_flags = BTM_SEC_IN_USE;
317
318 wipe_secrets_and_remove(device_record);
319 }
320
TEST_F(StackBtmWithInitFreeTest,BTM_SetEncryption)321 TEST_F(StackBtmWithInitFreeTest, BTM_SetEncryption) {
322 const RawAddress bd_addr = RawAddress({0x11, 0x22, 0x33, 0x44, 0x55, 0x66});
323 const tBT_TRANSPORT transport{BT_TRANSPORT_LE};
324 tBTM_SEC_CALLBACK* p_callback{nullptr};
325 tBTM_BLE_SEC_ACT sec_act{BTM_BLE_SEC_ENCRYPT};
326
327 // No device
328 ASSERT_EQ(BTM_WRONG_MODE, BTM_SetEncryption(bd_addr, transport, p_callback,
329 nullptr, sec_act));
330
331 // With device
332 tBTM_SEC_DEV_REC* device_record = btm_sec_allocate_dev_rec();
333 ASSERT_NE(nullptr, device_record);
334 device_record->bd_addr = bd_addr;
335 device_record->hci_handle = 0x1234;
336
337 ASSERT_EQ(BTM_WRONG_MODE, BTM_SetEncryption(bd_addr, transport, p_callback,
338 nullptr, sec_act));
339
340 wipe_secrets_and_remove(device_record);
341 }
342
TEST_F(StackBtmTest,sco_state_text)343 TEST_F(StackBtmTest, sco_state_text) {
344 std::vector<std::pair<tSCO_STATE, std::string>> states = {
345 std::make_pair(SCO_ST_UNUSED, "SCO_ST_UNUSED"),
346 std::make_pair(SCO_ST_LISTENING, "SCO_ST_LISTENING"),
347 std::make_pair(SCO_ST_W4_CONN_RSP, "SCO_ST_W4_CONN_RSP"),
348 std::make_pair(SCO_ST_CONNECTING, "SCO_ST_CONNECTING"),
349 std::make_pair(SCO_ST_CONNECTED, "SCO_ST_CONNECTED"),
350 std::make_pair(SCO_ST_DISCONNECTING, "SCO_ST_DISCONNECTING"),
351 std::make_pair(SCO_ST_PEND_UNPARK, "SCO_ST_PEND_UNPARK"),
352 std::make_pair(SCO_ST_PEND_ROLECHANGE, "SCO_ST_PEND_ROLECHANGE"),
353 std::make_pair(SCO_ST_PEND_MODECHANGE, "SCO_ST_PEND_MODECHANGE"),
354 };
355 for (const auto& state : states) {
356 ASSERT_STREQ(state.second.c_str(), sco_state_text(state.first).c_str());
357 }
358 std::ostringstream oss;
359 oss << "unknown_sco_state: " << std::numeric_limits<std::uint16_t>::max();
360 ASSERT_STREQ(oss.str().c_str(),
361 sco_state_text(static_cast<tSCO_STATE>(
362 std::numeric_limits<std::uint16_t>::max()))
363 .c_str());
364 }
365
TEST_F(StackBtmTest,btm_ble_sec_req_act_text)366 TEST_F(StackBtmTest, btm_ble_sec_req_act_text) {
367 ASSERT_EQ("BTM_BLE_SEC_REQ_ACT_NONE",
368 btm_ble_sec_req_act_text(BTM_BLE_SEC_REQ_ACT_NONE));
369 ASSERT_EQ("BTM_BLE_SEC_REQ_ACT_ENCRYPT",
370 btm_ble_sec_req_act_text(BTM_BLE_SEC_REQ_ACT_ENCRYPT));
371 ASSERT_EQ("BTM_BLE_SEC_REQ_ACT_PAIR",
372 btm_ble_sec_req_act_text(BTM_BLE_SEC_REQ_ACT_PAIR));
373 ASSERT_EQ("BTM_BLE_SEC_REQ_ACT_DISCARD",
374 btm_ble_sec_req_act_text(BTM_BLE_SEC_REQ_ACT_DISCARD));
375 }
376
TEST_F(StackBtmWithInitFreeTest,btm_sec_allocate_dev_rec__all)377 TEST_F(StackBtmWithInitFreeTest, btm_sec_allocate_dev_rec__all) {
378 tBTM_SEC_DEV_REC* records[kBtmSecMaxDeviceRecords];
379
380 // Fill up the records
381 for (size_t i = 0; i < kBtmSecMaxDeviceRecords; i++) {
382 ASSERT_EQ(i, list_length(btm_cb.sec_dev_rec));
383 records[i] = btm_sec_allocate_dev_rec();
384 ASSERT_NE(nullptr, records[i]);
385 }
386
387 // Second pass up the records
388 for (size_t i = 0; i < kBtmSecMaxDeviceRecords; i++) {
389 ASSERT_EQ(kBtmSecMaxDeviceRecords, list_length(btm_cb.sec_dev_rec));
390 records[i] = btm_sec_allocate_dev_rec();
391 ASSERT_NE(nullptr, records[i]);
392 }
393
394 // NOTE: The memory allocated for each record is automatically
395 // allocated by the btm module and freed when the device record
396 // list is freed.
397 // Further, the memory for each record is reused when necessary.
398 }
399
TEST_F(StackBtmTest,btm_oob_data_text)400 TEST_F(StackBtmTest, btm_oob_data_text) {
401 std::vector<std::pair<tBTM_OOB_DATA, std::string>> datas = {
402 std::make_pair(BTM_OOB_NONE, "BTM_OOB_NONE"),
403 std::make_pair(BTM_OOB_PRESENT_192, "BTM_OOB_PRESENT_192"),
404 std::make_pair(BTM_OOB_PRESENT_256, "BTM_OOB_PRESENT_256"),
405 std::make_pair(BTM_OOB_PRESENT_192_AND_256,
406 "BTM_OOB_PRESENT_192_AND_256"),
407 std::make_pair(BTM_OOB_UNKNOWN, "BTM_OOB_UNKNOWN"),
408 };
409 for (const auto& data : datas) {
410 ASSERT_STREQ(data.second.c_str(), btm_oob_data_text(data.first).c_str());
411 }
412 auto unknown = base::StringPrintf("UNKNOWN[%hhu]",
413 std::numeric_limits<std::uint8_t>::max());
414 ASSERT_STREQ(unknown.c_str(),
415 btm_oob_data_text(static_cast<tBTM_OOB_DATA>(
416 std::numeric_limits<std::uint8_t>::max()))
417 .c_str());
418 }
419
TEST_F(StackBtmTest,bond_type_text)420 TEST_F(StackBtmTest, bond_type_text) {
421 std::vector<std::pair<tBTM_SEC_DEV_REC::tBTM_BOND_TYPE, std::string>> datas =
422 {
423 std::make_pair(tBTM_SEC_DEV_REC::BOND_TYPE_UNKNOWN,
424 "tBTM_SEC_DEV_REC::BOND_TYPE_UNKNOWN"),
425 std::make_pair(tBTM_SEC_DEV_REC::BOND_TYPE_PERSISTENT,
426 "tBTM_SEC_DEV_REC::BOND_TYPE_PERSISTENT"),
427 std::make_pair(tBTM_SEC_DEV_REC::BOND_TYPE_TEMPORARY,
428 "tBTM_SEC_DEV_REC::BOND_TYPE_TEMPORARY"),
429 };
430 for (const auto& data : datas) {
431 ASSERT_STREQ(data.second.c_str(), bond_type_text(data.first).c_str());
432 }
433 auto unknown = base::StringPrintf("UNKNOWN[%hhu]",
434 std::numeric_limits<std::uint8_t>::max());
435 ASSERT_STREQ(unknown.c_str(),
436 bond_type_text(static_cast<tBTM_SEC_DEV_REC::tBTM_BOND_TYPE>(
437 std::numeric_limits<std::uint8_t>::max()))
438 .c_str());
439 }
440
TEST_F(StackBtmWithInitFreeTest,wipe_secrets_and_remove)441 TEST_F(StackBtmWithInitFreeTest, wipe_secrets_and_remove) {
442 bluetooth::common::InitFlags::SetAllForTesting();
443
444 RawAddress bd_addr = RawAddress({0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6});
445 const uint16_t classic_handle = 0x1234;
446 const uint16_t ble_handle = 0x9876;
447
448 // Setup device
449 tBTM_SEC_DEV_REC* device_record = btm_sec_allocate_dev_rec();
450 ASSERT_NE(nullptr, device_record);
451 ASSERT_EQ(BTM_SEC_IN_USE, device_record->sec_flags);
452 device_record->bd_addr = bd_addr;
453 device_record->hci_handle = classic_handle;
454 device_record->ble_hci_handle = ble_handle;
455
456 wipe_secrets_and_remove(device_record);
457 }
458