1 // Copyright 2023 The Pigweed Authors
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License"); you may not
4 // use this file except in compliance with the License. You may obtain a copy of
5 // the License at
6 //
7 // https://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
11 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
12 // License for the specific language governing permissions and limitations under
13 // the License.
14
15 // inclusive-language: disable
16
17 #include "pw_bluetooth_sapphire/internal/host/gap/pairing_state.h"
18
19 #include <gmock/gmock.h>
20 #include <gtest/gtest.h>
21
22 #include "pw_bluetooth_sapphire/internal/host/gap/fake_pairing_delegate.h"
23 #include "pw_bluetooth_sapphire/internal/host/gap/peer_cache.h"
24 #include "pw_bluetooth_sapphire/internal/host/hci/fake_bredr_connection.h"
25 #include "pw_bluetooth_sapphire/internal/host/sm/types.h"
26 #include "pw_bluetooth_sapphire/internal/host/testing/controller_test.h"
27 #include "pw_bluetooth_sapphire/internal/host/testing/fake_peer.h"
28 #include "pw_bluetooth_sapphire/internal/host/testing/inspect.h"
29 #include "pw_bluetooth_sapphire/internal/host/testing/inspect_util.h"
30 #include "pw_bluetooth_sapphire/internal/host/testing/mock_controller.h"
31 #include "pw_bluetooth_sapphire/internal/host/testing/test_helpers.h"
32 #include "pw_bluetooth_sapphire/internal/host/testing/test_packets.h"
33 #include "pw_bluetooth_sapphire/internal/host/transport/error.h"
34
35 namespace bt::gap {
36 namespace {
37
38 using namespace inspect::testing;
39
40 using hci::testing::FakeBrEdrConnection;
41 using hci_spec::kUserConfirmationRequestEventCode;
42 using hci_spec::kUserPasskeyNotificationEventCode;
43 using hci_spec::kUserPasskeyRequestEventCode;
44 using pw::bluetooth::emboss::AuthenticationRequirements;
45 using pw::bluetooth::emboss::IoCapability;
46
47 const hci_spec::ConnectionHandle kTestHandle(0x0A0B);
48 const DeviceAddress kLocalAddress(DeviceAddress::Type::kBREDR,
49 {0x22, 0x11, 0x00, 0xCC, 0xBB, 0xAA});
50 const DeviceAddress kPeerAddress(DeviceAddress::Type::kBREDR,
51 {0x99, 0x88, 0x77, 0xFF, 0xEE, 0xDD});
52 const auto kTestLocalIoCap = sm::IOCapability::kDisplayYesNo;
53 const auto kTestPeerIoCap = IoCapability::DISPLAY_ONLY;
54 const uint32_t kTestPasskey = 123456;
55 const auto kTestLinkKeyValue = UInt128{0x00,
56 0x00,
57 0x00,
58 0x00,
59 0x00,
60 0x00,
61 0x00,
62 0x00,
63 0x00,
64 0x00,
65 0x00,
66 0x00,
67 0x00,
68 0x00,
69 0x00,
70 0x01};
71 const hci_spec::LinkKey kTestLinkKey(kTestLinkKeyValue, 0, 0);
72 const auto kTestUnauthenticatedLinkKeyType192 =
73 hci_spec::LinkKeyType::kUnauthenticatedCombination192;
74 const auto kTestAuthenticatedLinkKeyType192 =
75 hci_spec::LinkKeyType::kAuthenticatedCombination192;
76 const auto kTestUnauthenticatedLinkKeyType256 =
77 hci_spec::LinkKeyType::kUnauthenticatedCombination256;
78 const auto kTestLegacyLinkKeyType = hci_spec::LinkKeyType::kCombination;
79 const auto kTestChangedLinkKeyType = hci_spec::LinkKeyType::kChangedCombination;
80 const BrEdrSecurityRequirements kNoSecurityRequirements{
81 .authentication = false, .secure_connections = false};
82
NoOpStatusCallback(hci_spec::ConnectionHandle,hci::Result<>)83 void NoOpStatusCallback(hci_spec::ConnectionHandle, hci::Result<>) {}
NoOpUserConfirmationCallback(bool)84 void NoOpUserConfirmationCallback(bool) {}
NoOpUserPasskeyCallback(std::optional<uint32_t>)85 void NoOpUserPasskeyCallback(std::optional<uint32_t>) {}
86
87 class NoOpPairingDelegate final : public PairingDelegate {
88 public:
NoOpPairingDelegate(sm::IOCapability io_capability)89 NoOpPairingDelegate(sm::IOCapability io_capability)
90 : io_capability_(io_capability), weak_self_(this) {}
91
GetWeakPtr()92 PairingDelegate::WeakPtr GetWeakPtr() { return weak_self_.GetWeakPtr(); }
93
94 // PairingDelegate overrides that do nothing.
95 ~NoOpPairingDelegate() override = default;
io_capability() const96 sm::IOCapability io_capability() const override { return io_capability_; }
CompletePairing(PeerId peer_id,sm::Result<> status)97 void CompletePairing(PeerId peer_id, sm::Result<> status) override {}
ConfirmPairing(PeerId peer_id,ConfirmCallback confirm)98 void ConfirmPairing(PeerId peer_id, ConfirmCallback confirm) override {}
DisplayPasskey(PeerId peer_id,uint32_t passkey,DisplayMethod method,ConfirmCallback confirm)99 void DisplayPasskey(PeerId peer_id,
100 uint32_t passkey,
101 DisplayMethod method,
102 ConfirmCallback confirm) override {}
RequestPasskey(PeerId peer_id,PasskeyResponseCallback respond)103 void RequestPasskey(PeerId peer_id,
104 PasskeyResponseCallback respond) override {}
105
106 private:
107 const sm::IOCapability io_capability_;
108 WeakSelf<PairingDelegate> weak_self_;
109 };
110
111 using TestBase = testing::FakeDispatcherControllerTest<testing::MockController>;
112 class PairingStateTest : public TestBase {
113 public:
114 PairingStateTest() = default;
115 virtual ~PairingStateTest() = default;
116
SetUp()117 void SetUp() override {
118 TestBase::SetUp();
119 InitializeACLDataChannel();
120
121 peer_cache_ = std::make_unique<PeerCache>(dispatcher());
122 peer_ = peer_cache_->NewPeer(kPeerAddress, /*connectable=*/true);
123
124 auth_request_count_ = 0;
125 send_auth_request_callback_ = [this]() { auth_request_count_++; };
126
127 connection_ = MakeFakeConnection();
128 }
129
TearDown()130 void TearDown() override {
131 peer_ = nullptr;
132 peer_cache_ = nullptr;
133
134 EXPECT_CMD_PACKET_OUT(test_device(),
135 testing::DisconnectPacket(kTestHandle));
136 connection_.reset();
137
138 TestBase::TearDown();
139 }
140
MakeAuthRequestCallback()141 fit::closure MakeAuthRequestCallback() {
142 return send_auth_request_callback_.share();
143 }
144
MakeFakeConnection()145 std::unique_ptr<FakeBrEdrConnection> MakeFakeConnection() {
146 return std::make_unique<FakeBrEdrConnection>(
147 kTestHandle,
148 kLocalAddress,
149 kPeerAddress,
150 pw::bluetooth::emboss::ConnectionRole::CENTRAL,
151 transport()->GetWeakPtr());
152 }
153
connection() const154 FakeBrEdrConnection* connection() const { return connection_.get(); }
peer_cache() const155 PeerCache* peer_cache() const { return peer_cache_.get(); }
peer() const156 Peer* peer() const { return peer_; }
auth_request_count() const157 size_t auth_request_count() const { return auth_request_count_; }
158
159 private:
160 std::unique_ptr<PeerCache> peer_cache_;
161 Peer* peer_;
162 size_t auth_request_count_;
163 fit::closure send_auth_request_callback_;
164 std::unique_ptr<FakeBrEdrConnection> connection_;
165 };
166
167 class PairingStateDeathTest : public PairingStateTest {};
168
TEST_F(PairingStateTest,PairingStateStartsAsResponder)169 TEST_F(PairingStateTest, PairingStateStartsAsResponder) {
170 PairingState pairing_state(peer()->GetWeakPtr(),
171 connection(),
172 /*link_initiated=*/false,
173 MakeAuthRequestCallback(),
174 NoOpStatusCallback);
175 EXPECT_FALSE(pairing_state.initiator());
176 }
177
TEST_F(PairingStateTest,PairingStateRemainsResponderAfterPeerIoCapResponse)178 TEST_F(PairingStateTest, PairingStateRemainsResponderAfterPeerIoCapResponse) {
179 PairingState pairing_state(peer()->GetWeakPtr(),
180 connection(),
181 /*link_initiated=*/false,
182 MakeAuthRequestCallback(),
183 NoOpStatusCallback);
184 pairing_state.OnIoCapabilityResponse(kTestPeerIoCap);
185 EXPECT_EQ(0u, auth_request_count());
186 EXPECT_FALSE(pairing_state.initiator());
187 }
188
TEST_F(PairingStateTest,PairingStateBecomesInitiatorAfterLocalPairingInitiated)189 TEST_F(PairingStateTest,
190 PairingStateBecomesInitiatorAfterLocalPairingInitiated) {
191 PairingState pairing_state(peer()->GetWeakPtr(),
192 connection(),
193 /*link_initiated=*/false,
194 MakeAuthRequestCallback(),
195 NoOpStatusCallback);
196 NoOpPairingDelegate pairing_delegate(kTestLocalIoCap);
197 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
198 pairing_state.InitiatePairing(kNoSecurityRequirements, NoOpStatusCallback);
199 EXPECT_EQ(1u, auth_request_count());
200 EXPECT_TRUE(pairing_state.initiator());
201 }
202
TEST_F(PairingStateTest,PairingStateSendsAuthenticationRequestOnceForDuplicateRequest)203 TEST_F(PairingStateTest,
204 PairingStateSendsAuthenticationRequestOnceForDuplicateRequest) {
205 PairingState pairing_state(peer()->GetWeakPtr(),
206 connection(),
207 /*link_initiated=*/false,
208 MakeAuthRequestCallback(),
209 NoOpStatusCallback);
210 NoOpPairingDelegate pairing_delegate(kTestLocalIoCap);
211 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
212
213 pairing_state.InitiatePairing(kNoSecurityRequirements, NoOpStatusCallback);
214 EXPECT_EQ(1u, auth_request_count());
215 EXPECT_TRUE(pairing_state.initiator());
216
217 pairing_state.InitiatePairing(kNoSecurityRequirements, NoOpStatusCallback);
218 EXPECT_EQ(1u, auth_request_count());
219 EXPECT_TRUE(pairing_state.initiator());
220 }
221
TEST_F(PairingStateTest,PairingStateRemainsResponderIfPairingInitiatedWhileResponderPairingInProgress)222 TEST_F(
223 PairingStateTest,
224 PairingStateRemainsResponderIfPairingInitiatedWhileResponderPairingInProgress) {
225 PairingState pairing_state(peer()->GetWeakPtr(),
226 connection(),
227 /*link_initiated=*/false,
228 MakeAuthRequestCallback(),
229 NoOpStatusCallback);
230 pairing_state.OnIoCapabilityResponse(kTestPeerIoCap);
231 ASSERT_FALSE(pairing_state.initiator());
232
233 pairing_state.InitiatePairing(kNoSecurityRequirements, NoOpStatusCallback);
234 EXPECT_EQ(0u, auth_request_count());
235 EXPECT_FALSE(pairing_state.initiator());
236 }
237
TEST_F(PairingStateTest,StatusCallbackMayDestroyPairingState)238 TEST_F(PairingStateTest, StatusCallbackMayDestroyPairingState) {
239 std::unique_ptr<PairingState> pairing_state;
240 bool cb_called = false;
241 auto status_cb = [&pairing_state, &cb_called](
242 hci_spec::ConnectionHandle handle,
243 hci::Result<> status) {
244 EXPECT_TRUE(status.is_error());
245 cb_called = true;
246
247 // Note that this lambda is owned by the PairingState so its captures are
248 // invalid after this.
249 pairing_state = nullptr;
250 };
251
252 pairing_state = std::make_unique<PairingState>(peer()->GetWeakPtr(),
253 connection(),
254 /*link_initiated=*/false,
255 MakeAuthRequestCallback(),
256 status_cb);
257
258 // Unexpected event that should cause the status callback to be called with an
259 // error.
260 pairing_state->OnUserPasskeyNotification(kTestPasskey);
261
262 EXPECT_TRUE(cb_called);
263 }
264
TEST_F(PairingStateTest,InitiatorCallbackMayDestroyPairingState)265 TEST_F(PairingStateTest, InitiatorCallbackMayDestroyPairingState) {
266 std::unique_ptr<PairingState> pairing_state =
267 std::make_unique<PairingState>(peer()->GetWeakPtr(),
268 connection(),
269 /*link_initiated=*/false,
270 MakeAuthRequestCallback(),
271 NoOpStatusCallback);
272 bool cb_called = false;
273 auto status_cb = [&pairing_state, &cb_called](
274 hci_spec::ConnectionHandle handle,
275 hci::Result<> status) {
276 EXPECT_TRUE(status.is_error());
277 cb_called = true;
278
279 // Note that this lambda is owned by the PairingState so its captures are
280 // invalid after this.
281 pairing_state = nullptr;
282 };
283 NoOpPairingDelegate pairing_delegate(kTestLocalIoCap);
284 pairing_state->SetPairingDelegate(pairing_delegate.GetWeakPtr());
285 pairing_state->InitiatePairing(kNoSecurityRequirements, status_cb);
286
287 // Unexpected event that should cause the status callback to be called with an
288 // error.
289 pairing_state->OnUserPasskeyNotification(kTestPasskey);
290
291 EXPECT_TRUE(cb_called);
292 }
293
294 // Test helper to inspect StatusCallback invocations.
295 class TestStatusHandler final {
296 public:
MakeStatusCallback()297 auto MakeStatusCallback() {
298 return [this](hci_spec::ConnectionHandle handle, hci::Result<> status) {
299 call_count_++;
300 handle_ = handle;
301 status_ = status;
302 };
303 }
304
call_count() const305 auto call_count() const { return call_count_; }
306
307 // Returns std::nullopt if |call_count() < 1|, otherwise values from the most
308 // recent callback invocation.
handle() const309 auto& handle() const { return handle_; }
status() const310 auto& status() const { return status_; }
311
312 private:
313 int call_count_ = 0;
314 std::optional<hci_spec::ConnectionHandle> handle_;
315 std::optional<hci::Result<>> status_;
316 };
317
TEST_F(PairingStateTest,TestStatusHandlerTracksStatusCallbackInvocations)318 TEST_F(PairingStateTest, TestStatusHandlerTracksStatusCallbackInvocations) {
319 TestStatusHandler handler;
320 EXPECT_EQ(0, handler.call_count());
321 EXPECT_FALSE(handler.status());
322
323 PairingState::StatusCallback status_cb = handler.MakeStatusCallback();
324 EXPECT_EQ(0, handler.call_count());
325 EXPECT_FALSE(handler.status());
326
327 status_cb(hci_spec::ConnectionHandle(0x0A0B),
328 ToResult(pw::bluetooth::emboss::StatusCode::PAIRING_NOT_ALLOWED));
329 EXPECT_EQ(1, handler.call_count());
330 ASSERT_TRUE(handler.handle());
331 EXPECT_EQ(hci_spec::ConnectionHandle(0x0A0B), *handler.handle());
332 ASSERT_TRUE(handler.status());
333 EXPECT_EQ(ToResult(pw::bluetooth::emboss::StatusCode::PAIRING_NOT_ALLOWED),
334 *handler.status());
335 }
336
TEST_F(PairingStateTest,InitiatingPairingAfterErrorTriggersStatusCallbackWithError)337 TEST_F(PairingStateTest,
338 InitiatingPairingAfterErrorTriggersStatusCallbackWithError) {
339 TestStatusHandler link_status_handler;
340
341 PairingState pairing_state(peer()->GetWeakPtr(),
342 connection(),
343 /*link_initiated=*/false,
344 MakeAuthRequestCallback(),
345 link_status_handler.MakeStatusCallback());
346
347 // Unexpected event that should cause the status callback to be called with an
348 // error.
349 pairing_state.OnUserPasskeyNotification(kTestPasskey);
350
351 EXPECT_EQ(1, link_status_handler.call_count());
352 ASSERT_TRUE(link_status_handler.handle());
353 EXPECT_EQ(kTestHandle, *link_status_handler.handle());
354 ASSERT_TRUE(link_status_handler.status());
355 EXPECT_EQ(ToResult(HostError::kNotSupported), *link_status_handler.status());
356
357 // Try to initiate pairing again.
358 TestStatusHandler pairing_status_handler;
359 pairing_state.InitiatePairing(kNoSecurityRequirements,
360 pairing_status_handler.MakeStatusCallback());
361
362 // The status callback for pairing attempts made after a pairing failure
363 // should be rejected as canceled.
364 EXPECT_EQ(1, pairing_status_handler.call_count());
365 ASSERT_TRUE(pairing_status_handler.handle());
366 EXPECT_EQ(kTestHandle, *pairing_status_handler.handle());
367 ASSERT_TRUE(pairing_status_handler.status());
368 EXPECT_EQ(ToResult(HostError::kCanceled), *pairing_status_handler.status());
369 }
370
TEST_F(PairingStateTest,UnexpectedEncryptionChangeDoesNotTriggerStatusCallback)371 TEST_F(PairingStateTest,
372 UnexpectedEncryptionChangeDoesNotTriggerStatusCallback) {
373 TestStatusHandler status_handler;
374
375 PairingState pairing_state(peer()->GetWeakPtr(),
376 connection(),
377 /*link_initiated=*/false,
378 MakeAuthRequestCallback(),
379 status_handler.MakeStatusCallback());
380 NoOpPairingDelegate pairing_delegate(kTestLocalIoCap);
381 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
382
383 // Advance state machine.
384 pairing_state.InitiatePairing(kNoSecurityRequirements, NoOpStatusCallback);
385 static_cast<void>(pairing_state.OnLinkKeyRequest());
386 static_cast<void>(pairing_state.OnIoCapabilityRequest());
387 pairing_state.OnIoCapabilityResponse(kTestPeerIoCap);
388
389 ASSERT_EQ(0, connection()->start_encryption_count());
390 ASSERT_EQ(0, status_handler.call_count());
391
392 connection()->TriggerEncryptionChangeCallback(fit::ok(true));
393 EXPECT_EQ(0, status_handler.call_count());
394 }
395
TEST_F(PairingStateTest,PeerMayNotChangeLinkKeyWhenNotEncrypted)396 TEST_F(PairingStateTest, PeerMayNotChangeLinkKeyWhenNotEncrypted) {
397 TestStatusHandler status_handler;
398
399 PairingState pairing_state(peer()->GetWeakPtr(),
400 connection(),
401 /*link_initiated=*/false,
402 MakeAuthRequestCallback(),
403 status_handler.MakeStatusCallback());
404 ASSERT_FALSE(connection()->ltk().has_value());
405
406 pairing_state.OnLinkKeyNotification(kTestLinkKeyValue,
407 kTestChangedLinkKeyType);
408
409 EXPECT_FALSE(connection()->ltk().has_value());
410 EXPECT_EQ(1, status_handler.call_count());
411 ASSERT_TRUE(status_handler.handle());
412 EXPECT_EQ(kTestHandle, *status_handler.handle());
413 ASSERT_TRUE(status_handler.status());
414 EXPECT_EQ(ToResult(HostError::kInsufficientSecurity),
415 *status_handler.status());
416 }
417
TEST_F(PairingStateTest,PeerMayChangeLinkKeyWhenInIdleState)418 TEST_F(PairingStateTest, PeerMayChangeLinkKeyWhenInIdleState) {
419 TestStatusHandler status_handler;
420
421 PairingState pairing_state(peer()->GetWeakPtr(),
422 connection(),
423 /*link_initiated=*/false,
424 MakeAuthRequestCallback(),
425 status_handler.MakeStatusCallback());
426 connection()->set_link_key(hci_spec::LinkKey(UInt128(), 0, 0),
427 kTestAuthenticatedLinkKeyType192);
428
429 pairing_state.OnLinkKeyNotification(kTestLinkKeyValue,
430 kTestChangedLinkKeyType);
431
432 ASSERT_TRUE(connection()->ltk().has_value());
433 EXPECT_EQ(kTestLinkKeyValue, connection()->ltk().value().value());
434 ASSERT_TRUE(connection()->ltk_type().has_value());
435 EXPECT_EQ(kTestChangedLinkKeyType, connection()->ltk_type().value());
436 EXPECT_EQ(0, status_handler.call_count());
437 }
438
439 // Inject events that occur during the course of a successful pairing as an
440 // initiator, but not including enabling link encryption.
AdvanceToEncryptionAsInitiator(PairingState * pairing_state)441 void AdvanceToEncryptionAsInitiator(PairingState* pairing_state) {
442 static_cast<void>(pairing_state->OnLinkKeyRequest());
443 static_cast<void>(pairing_state->OnIoCapabilityRequest());
444 pairing_state->OnIoCapabilityResponse(kTestPeerIoCap);
445 pairing_state->OnUserConfirmationRequest(kTestPasskey,
446 NoOpUserConfirmationCallback);
447 pairing_state->OnSimplePairingComplete(
448 pw::bluetooth::emboss::StatusCode::SUCCESS);
449 pairing_state->OnLinkKeyNotification(kTestLinkKeyValue,
450 kTestUnauthenticatedLinkKeyType192);
451 pairing_state->OnAuthenticationComplete(
452 pw::bluetooth::emboss::StatusCode::SUCCESS);
453 }
454
TEST_F(PairingStateTest,SuccessfulEncryptionChangeTriggersStatusCallback)455 TEST_F(PairingStateTest, SuccessfulEncryptionChangeTriggersStatusCallback) {
456 TestStatusHandler status_handler;
457
458 PairingState pairing_state(peer()->GetWeakPtr(),
459 connection(),
460 /*link_initiated=*/false,
461 MakeAuthRequestCallback(),
462 status_handler.MakeStatusCallback());
463 NoOpPairingDelegate pairing_delegate(kTestLocalIoCap);
464 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
465
466 // Advance state machine.
467 pairing_state.InitiatePairing(kNoSecurityRequirements, NoOpStatusCallback);
468 AdvanceToEncryptionAsInitiator(&pairing_state);
469
470 ASSERT_EQ(0, status_handler.call_count());
471
472 EXPECT_EQ(1, connection()->start_encryption_count());
473 connection()->TriggerEncryptionChangeCallback(fit::ok(true));
474 EXPECT_EQ(1, status_handler.call_count());
475 ASSERT_TRUE(status_handler.handle());
476 EXPECT_EQ(kTestHandle, *status_handler.handle());
477 ASSERT_TRUE(status_handler.status());
478 EXPECT_EQ(fit::ok(), *status_handler.status());
479 }
480
TEST_F(PairingStateTest,EncryptionChangeErrorTriggersStatusCallbackWithError)481 TEST_F(PairingStateTest, EncryptionChangeErrorTriggersStatusCallbackWithError) {
482 TestStatusHandler status_handler;
483
484 PairingState pairing_state(peer()->GetWeakPtr(),
485 connection(),
486 /*link_initiated=*/false,
487 MakeAuthRequestCallback(),
488 status_handler.MakeStatusCallback());
489 NoOpPairingDelegate pairing_delegate(kTestLocalIoCap);
490 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
491
492 // Advance state machine.
493 static_cast<void>(pairing_state.InitiatePairing(kNoSecurityRequirements,
494 NoOpStatusCallback));
495 AdvanceToEncryptionAsInitiator(&pairing_state);
496
497 ASSERT_EQ(0, status_handler.call_count());
498
499 EXPECT_EQ(1, connection()->start_encryption_count());
500 connection()->TriggerEncryptionChangeCallback(
501 fit::error(Error(HostError::kInsufficientSecurity)));
502 EXPECT_EQ(1, status_handler.call_count());
503 ASSERT_TRUE(status_handler.handle());
504 EXPECT_EQ(kTestHandle, *status_handler.handle());
505 ASSERT_TRUE(status_handler.status());
506 EXPECT_EQ(ToResult(HostError::kInsufficientSecurity),
507 *status_handler.status());
508 }
509
TEST_F(PairingStateTest,EncryptionChangeToDisabledTriggersStatusCallbackWithError)510 TEST_F(PairingStateTest,
511 EncryptionChangeToDisabledTriggersStatusCallbackWithError) {
512 TestStatusHandler status_handler;
513
514 PairingState pairing_state(peer()->GetWeakPtr(),
515 connection(),
516 /*link_initiated=*/false,
517 MakeAuthRequestCallback(),
518 status_handler.MakeStatusCallback());
519 NoOpPairingDelegate pairing_delegate(kTestLocalIoCap);
520 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
521
522 // Advance state machine.
523 pairing_state.InitiatePairing(kNoSecurityRequirements, NoOpStatusCallback);
524 AdvanceToEncryptionAsInitiator(&pairing_state);
525
526 ASSERT_EQ(0, status_handler.call_count());
527
528 EXPECT_EQ(1, connection()->start_encryption_count());
529 connection()->TriggerEncryptionChangeCallback(fit::ok(false));
530 EXPECT_EQ(1, status_handler.call_count());
531 ASSERT_TRUE(status_handler.handle());
532 EXPECT_EQ(kTestHandle, *status_handler.handle());
533 ASSERT_TRUE(status_handler.status());
534 EXPECT_EQ(ToResult(HostError::kFailed), *status_handler.status());
535 }
536
TEST_F(PairingStateTest,EncryptionChangeToEnableCallsInitiatorCallbacks)537 TEST_F(PairingStateTest, EncryptionChangeToEnableCallsInitiatorCallbacks) {
538 PairingState pairing_state(peer()->GetWeakPtr(),
539 connection(),
540 /*link_initiated=*/false,
541 MakeAuthRequestCallback(),
542 NoOpStatusCallback);
543 NoOpPairingDelegate pairing_delegate(kTestLocalIoCap);
544 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
545
546 // Advance state machine.
547 TestStatusHandler status_handler_0;
548 pairing_state.InitiatePairing(kNoSecurityRequirements,
549 status_handler_0.MakeStatusCallback());
550 AdvanceToEncryptionAsInitiator(&pairing_state);
551 EXPECT_TRUE(pairing_state.initiator());
552
553 // Try to initiate pairing while pairing is in progress.
554 TestStatusHandler status_handler_1;
555 static_cast<void>(pairing_state.InitiatePairing(
556 kNoSecurityRequirements, status_handler_1.MakeStatusCallback()));
557
558 EXPECT_TRUE(pairing_state.initiator());
559 ASSERT_EQ(0, status_handler_0.call_count());
560 ASSERT_EQ(0, status_handler_1.call_count());
561
562 connection()->TriggerEncryptionChangeCallback(fit::ok(true));
563 EXPECT_EQ(1, status_handler_0.call_count());
564 EXPECT_EQ(1, status_handler_1.call_count());
565 ASSERT_TRUE(status_handler_0.handle());
566 EXPECT_EQ(kTestHandle, *status_handler_0.handle());
567 ASSERT_TRUE(status_handler_0.status());
568 EXPECT_EQ(fit::ok(), *status_handler_0.status());
569 ASSERT_TRUE(status_handler_1.handle());
570 EXPECT_EQ(kTestHandle, *status_handler_1.handle());
571 ASSERT_TRUE(status_handler_1.status());
572 EXPECT_EQ(fit::ok(), *status_handler_1.status());
573
574 // Errors for a new pairing shouldn't invoke the initiators' callbacks.
575 pairing_state.OnUserPasskeyNotification(kTestPasskey);
576 EXPECT_EQ(1, status_handler_0.call_count());
577 EXPECT_EQ(1, status_handler_1.call_count());
578 }
579
TEST_F(PairingStateTest,InitiatingPairingOnResponderWaitsForPairingToFinish)580 TEST_F(PairingStateTest, InitiatingPairingOnResponderWaitsForPairingToFinish) {
581 PairingState pairing_state(peer()->GetWeakPtr(),
582 connection(),
583 /*link_initiated=*/false,
584 MakeAuthRequestCallback(),
585 NoOpStatusCallback);
586 NoOpPairingDelegate pairing_delegate(kTestLocalIoCap);
587 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
588
589 // Advance state machine as pairing responder.
590 pairing_state.OnIoCapabilityResponse(kTestPeerIoCap);
591 ASSERT_FALSE(pairing_state.initiator());
592 static_cast<void>(pairing_state.OnIoCapabilityRequest());
593 pairing_state.OnUserConfirmationRequest(kTestPasskey,
594 NoOpUserConfirmationCallback);
595
596 // Try to initiate pairing while pairing is in progress.
597 TestStatusHandler status_handler;
598 pairing_state.InitiatePairing(kNoSecurityRequirements,
599 status_handler.MakeStatusCallback());
600 EXPECT_FALSE(pairing_state.initiator());
601
602 // Keep advancing state machine.
603 pairing_state.OnSimplePairingComplete(
604 pw::bluetooth::emboss::StatusCode::SUCCESS);
605 pairing_state.OnLinkKeyNotification(kTestLinkKeyValue,
606 kTestUnauthenticatedLinkKeyType192);
607
608 EXPECT_FALSE(pairing_state.initiator());
609 ASSERT_EQ(0, status_handler.call_count());
610
611 // The attempt to initiate pairing should have its status callback notified.
612 connection()->TriggerEncryptionChangeCallback(fit::ok(true));
613 EXPECT_EQ(1, status_handler.call_count());
614 ASSERT_TRUE(status_handler.handle());
615 EXPECT_EQ(kTestHandle, *status_handler.handle());
616 ASSERT_TRUE(status_handler.status());
617 EXPECT_EQ(fit::ok(), *status_handler.status());
618
619 // Errors for a new pairing shouldn't invoke the attempted initiator's
620 // callback.
621 pairing_state.OnUserPasskeyNotification(kTestPasskey);
622 EXPECT_EQ(1, status_handler.call_count());
623 }
624
TEST_F(PairingStateTest,UnresolvedPairingCallbackIsCalledOnDestruction)625 TEST_F(PairingStateTest, UnresolvedPairingCallbackIsCalledOnDestruction) {
626 TestStatusHandler overall_status, request_status;
627 {
628 PairingState pairing_state(peer()->GetWeakPtr(),
629 connection(),
630 /*link_initiated=*/false,
631 MakeAuthRequestCallback(),
632 overall_status.MakeStatusCallback());
633 NoOpPairingDelegate pairing_delegate(kTestLocalIoCap);
634 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
635
636 // Advance state machine as pairing responder.
637 pairing_state.OnIoCapabilityResponse(kTestPeerIoCap);
638 ASSERT_FALSE(pairing_state.initiator());
639 static_cast<void>(pairing_state.OnIoCapabilityRequest());
640 pairing_state.OnUserConfirmationRequest(kTestPasskey,
641 NoOpUserConfirmationCallback);
642
643 // Try to initiate pairing while pairing is in progress.
644 pairing_state.InitiatePairing(kNoSecurityRequirements,
645 request_status.MakeStatusCallback());
646 EXPECT_FALSE(pairing_state.initiator());
647
648 // Keep advancing state machine.
649 pairing_state.OnSimplePairingComplete(
650 pw::bluetooth::emboss::StatusCode::SUCCESS);
651 pairing_state.OnLinkKeyNotification(kTestLinkKeyValue,
652 kTestUnauthenticatedLinkKeyType192);
653
654 // as pairing_state falls out of scope, we expect additional pairing
655 // callbacks to be called
656 ASSERT_EQ(0, overall_status.call_count());
657 ASSERT_EQ(0, request_status.call_count());
658 }
659
660 ASSERT_EQ(0, overall_status.call_count());
661
662 ASSERT_EQ(1, request_status.call_count());
663 ASSERT_TRUE(request_status.handle());
664 EXPECT_EQ(kTestHandle, *request_status.handle());
665 EXPECT_EQ(ToResult(HostError::kLinkDisconnected), *request_status.status());
666 }
667
TEST_F(PairingStateTest,InitiatorPairingStateRejectsIoCapReqWithoutPairingDelegate)668 TEST_F(PairingStateTest,
669 InitiatorPairingStateRejectsIoCapReqWithoutPairingDelegate) {
670 TestStatusHandler owner_status_handler;
671 PairingState pairing_state(peer()->GetWeakPtr(),
672 connection(),
673 /*link_initiated=*/false,
674 MakeAuthRequestCallback(),
675 owner_status_handler.MakeStatusCallback());
676
677 TestStatusHandler initiator_status_handler;
678 // Advance state machine to Initiator Waiting IOCap Request
679 pairing_state.InitiatePairing(kNoSecurityRequirements,
680 initiator_status_handler.MakeStatusCallback());
681 EXPECT_TRUE(pairing_state.initiator());
682 // We should permit the pairing state machine to continue even without a
683 // PairingDelegate, as we may have an existing bond to restore, which can be
684 // done without a PairingDelegate.
685 EXPECT_EQ(0, owner_status_handler.call_count());
686 EXPECT_EQ(0, initiator_status_handler.call_count());
687 // We will only start the pairing process if there is no stored bond
688 EXPECT_EQ(std::nullopt, pairing_state.OnLinkKeyRequest());
689 // We expect to be notified that there are no IOCapabilities, as there is no
690 // PairingDelegate to provide them
691 EXPECT_EQ(std::nullopt, pairing_state.OnIoCapabilityRequest());
692 // All callbacks should be notified of pairing failure
693 EXPECT_EQ(1, owner_status_handler.call_count());
694 EXPECT_EQ(1, initiator_status_handler.call_count());
695 ASSERT_TRUE(initiator_status_handler.status());
696 EXPECT_EQ(ToResult(HostError::kNotReady), *initiator_status_handler.status());
697 EXPECT_EQ(initiator_status_handler.status(), owner_status_handler.status());
698 }
699
TEST_F(PairingStateTest,ResponderPairingStateRejectsIoCapReqWithoutPairingDelegate)700 TEST_F(PairingStateTest,
701 ResponderPairingStateRejectsIoCapReqWithoutPairingDelegate) {
702 TestStatusHandler status_handler;
703 PairingState pairing_state(peer()->GetWeakPtr(),
704 connection(),
705 /*link_initiated=*/false,
706 MakeAuthRequestCallback(),
707 status_handler.MakeStatusCallback());
708
709 // Advance state machine to Responder Waiting IOCap Request
710 pairing_state.OnIoCapabilityResponse(
711 pw::bluetooth::emboss::IoCapability::DISPLAY_YES_NO);
712 EXPECT_FALSE(pairing_state.initiator());
713 EXPECT_EQ(0, status_handler.call_count());
714
715 // We expect to be notified that there are no IOCapabilities, as there is no
716 // PairingDelegate to provide them.
717 EXPECT_EQ(std::nullopt, pairing_state.OnIoCapabilityRequest());
718 // All callbacks should be notified of pairing failure
719 EXPECT_EQ(1, status_handler.call_count());
720 ASSERT_TRUE(status_handler.status());
721 EXPECT_EQ(ToResult(HostError::kNotReady), *status_handler.status());
722 }
723
TEST_F(PairingStateTest,UnexpectedLinkKeyAuthenticationRaisesError)724 TEST_F(PairingStateTest, UnexpectedLinkKeyAuthenticationRaisesError) {
725 TestStatusHandler status_handler;
726
727 PairingState pairing_state(peer()->GetWeakPtr(),
728 connection(),
729 /*link_initiated=*/false,
730 MakeAuthRequestCallback(),
731 status_handler.MakeStatusCallback());
732 NoOpPairingDelegate pairing_delegate(sm::IOCapability::kDisplayOnly);
733 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
734
735 // Advance state machine.
736 pairing_state.OnIoCapabilityResponse(IoCapability::DISPLAY_YES_NO);
737 ASSERT_FALSE(pairing_state.initiator());
738 static_cast<void>(pairing_state.OnIoCapabilityRequest());
739 pairing_state.OnUserConfirmationRequest(kTestPasskey,
740 NoOpUserConfirmationCallback);
741 pairing_state.OnSimplePairingComplete(
742 pw::bluetooth::emboss::StatusCode::SUCCESS);
743
744 // Provide an authenticated link key when this should have resulted in an
745 // unauthenticated link key
746 pairing_state.OnLinkKeyNotification(kTestLinkKeyValue,
747 kTestAuthenticatedLinkKeyType192);
748
749 EXPECT_EQ(1, status_handler.call_count());
750 ASSERT_TRUE(status_handler.handle());
751 EXPECT_EQ(kTestHandle, *status_handler.handle());
752 ASSERT_TRUE(status_handler.status());
753 EXPECT_EQ(ToResult(HostError::kInsufficientSecurity),
754 *status_handler.status());
755 }
756
TEST_F(PairingStateTest,LegacyPairingLinkKeyRaisesError)757 TEST_F(PairingStateTest, LegacyPairingLinkKeyRaisesError) {
758 TestStatusHandler status_handler;
759
760 PairingState pairing_state(peer()->GetWeakPtr(),
761 connection(),
762 /*link_initiated=*/false,
763 MakeAuthRequestCallback(),
764 status_handler.MakeStatusCallback());
765 NoOpPairingDelegate pairing_delegate(sm::IOCapability::kNoInputNoOutput);
766 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
767
768 // Advance state machine.
769 pairing_state.OnIoCapabilityResponse(IoCapability::DISPLAY_YES_NO);
770 ASSERT_FALSE(pairing_state.initiator());
771 static_cast<void>(pairing_state.OnIoCapabilityRequest());
772 pairing_state.OnUserConfirmationRequest(kTestPasskey,
773 NoOpUserConfirmationCallback);
774 pairing_state.OnSimplePairingComplete(
775 pw::bluetooth::emboss::StatusCode::SUCCESS);
776
777 // Provide a legacy pairing link key type.
778 pairing_state.OnLinkKeyNotification(kTestLinkKeyValue,
779 kTestLegacyLinkKeyType);
780
781 EXPECT_EQ(1, status_handler.call_count());
782 ASSERT_TRUE(status_handler.handle());
783 EXPECT_EQ(kTestHandle, *status_handler.handle());
784 ASSERT_TRUE(status_handler.status());
785 EXPECT_EQ(ToResult(HostError::kInsufficientSecurity),
786 *status_handler.status());
787 }
788
TEST_F(PairingStateTest,PairingSetsConnectionLinkKey)789 TEST_F(PairingStateTest, PairingSetsConnectionLinkKey) {
790 TestStatusHandler status_handler;
791
792 PairingState pairing_state(peer()->GetWeakPtr(),
793 connection(),
794 /*link_initiated=*/false,
795 MakeAuthRequestCallback(),
796 status_handler.MakeStatusCallback());
797 NoOpPairingDelegate pairing_delegate(sm::IOCapability::kNoInputNoOutput);
798 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
799
800 // Advance state machine.
801 pairing_state.OnIoCapabilityResponse(IoCapability::DISPLAY_YES_NO);
802 ASSERT_FALSE(pairing_state.initiator());
803 static_cast<void>(pairing_state.OnIoCapabilityRequest());
804 pairing_state.OnUserConfirmationRequest(kTestPasskey,
805 NoOpUserConfirmationCallback);
806 pairing_state.OnSimplePairingComplete(
807 pw::bluetooth::emboss::StatusCode::SUCCESS);
808
809 ASSERT_FALSE(connection()->ltk());
810 pairing_state.OnLinkKeyNotification(kTestLinkKeyValue,
811 kTestUnauthenticatedLinkKeyType192);
812 ASSERT_TRUE(connection()->ltk());
813 EXPECT_EQ(kTestLinkKeyValue, connection()->ltk()->value());
814
815 EXPECT_EQ(0, status_handler.call_count());
816 }
817
TEST_F(PairingStateTest,SecureConnectionsRequiresSecureConnectionsLinkKeySuccess)818 TEST_F(PairingStateTest,
819 SecureConnectionsRequiresSecureConnectionsLinkKeySuccess) {
820 TestStatusHandler status_handler;
821
822 PairingState pairing_state(peer()->GetWeakPtr(),
823 connection(),
824 /*link_initiated=*/false,
825 MakeAuthRequestCallback(),
826 status_handler.MakeStatusCallback());
827 NoOpPairingDelegate pairing_delegate(sm::IOCapability::kDisplayOnly);
828 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
829
830 // Set peer lmp_features: Secure Connections (Host Support)
831 peer()->SetFeaturePage(
832 1u,
833 static_cast<uint64_t>(
834 hci_spec::LMPFeature::kSecureConnectionsHostSupport));
835
836 // Set peer lmp_features: Secure Connections (Controller Support)
837 peer()->SetFeaturePage(
838 2u,
839 static_cast<uint64_t>(
840 hci_spec::LMPFeature::kSecureConnectionsControllerSupport));
841
842 // Advance state machine.
843 pairing_state.OnIoCapabilityResponse(IoCapability::DISPLAY_YES_NO);
844 ASSERT_FALSE(pairing_state.initiator());
845 static_cast<void>(pairing_state.OnIoCapabilityRequest());
846 pairing_state.OnUserConfirmationRequest(kTestPasskey,
847 NoOpUserConfirmationCallback);
848 pairing_state.OnSimplePairingComplete(
849 pw::bluetooth::emboss::StatusCode::SUCCESS);
850
851 // Ensure that P-256 authenticated link key was provided
852 pairing_state.OnLinkKeyNotification(
853 kTestLinkKeyValue,
854 kTestUnauthenticatedLinkKeyType256,
855 /*local_secure_connections_supported=*/true);
856
857 ASSERT_TRUE(connection()->ltk());
858 EXPECT_EQ(kTestLinkKeyValue, connection()->ltk()->value());
859
860 EXPECT_EQ(0, status_handler.call_count());
861 }
862
TEST_F(PairingStateTest,SecureConnectionsRequiresSecureConnectionsLinkKeyFail)863 TEST_F(PairingStateTest,
864 SecureConnectionsRequiresSecureConnectionsLinkKeyFail) {
865 TestStatusHandler status_handler;
866
867 PairingState pairing_state(peer()->GetWeakPtr(),
868 connection(),
869 /*link_initiated=*/false,
870 MakeAuthRequestCallback(),
871 status_handler.MakeStatusCallback());
872 NoOpPairingDelegate pairing_delegate(sm::IOCapability::kDisplayOnly);
873 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
874
875 // Set peer lmp_features: Secure Connections (Host Support)
876 peer()->SetFeaturePage(
877 1u,
878 static_cast<uint64_t>(
879 hci_spec::LMPFeature::kSecureConnectionsHostSupport));
880
881 // Set peer lmp_features: Secure Connections (Controller Support)
882 peer()->SetFeaturePage(
883 2u,
884 static_cast<uint64_t>(
885 hci_spec::LMPFeature::kSecureConnectionsControllerSupport));
886
887 // Advance state machine.
888 pairing_state.OnIoCapabilityResponse(IoCapability::DISPLAY_YES_NO);
889 ASSERT_FALSE(pairing_state.initiator());
890 static_cast<void>(pairing_state.OnIoCapabilityRequest());
891 pairing_state.OnUserConfirmationRequest(kTestPasskey,
892 NoOpUserConfirmationCallback);
893 pairing_state.OnSimplePairingComplete(
894 pw::bluetooth::emboss::StatusCode::SUCCESS);
895
896 // Provide P-192 authenticated link key when this should have resulted in an
897 // P-256 link key
898 pairing_state.OnLinkKeyNotification(
899 kTestLinkKeyValue,
900 kTestUnauthenticatedLinkKeyType192,
901 /*local_secure_connections_supported=*/true);
902
903 EXPECT_EQ(1, status_handler.call_count());
904 ASSERT_TRUE(status_handler.handle());
905 EXPECT_EQ(kTestHandle, *status_handler.handle());
906 ASSERT_TRUE(status_handler.status());
907 EXPECT_EQ(ToResult(HostError::kInsufficientSecurity),
908 *status_handler.status());
909 }
910
TEST_F(PairingStateTest,NumericComparisonPairingComparesPasskeyOnInitiatorDisplayYesNoSide)911 TEST_F(PairingStateTest,
912 NumericComparisonPairingComparesPasskeyOnInitiatorDisplayYesNoSide) {
913 TestStatusHandler status_handler;
914
915 PairingState pairing_state(peer()->GetWeakPtr(),
916 connection(),
917 /*link_initiated=*/false,
918 MakeAuthRequestCallback(),
919 status_handler.MakeStatusCallback());
920 FakePairingDelegate pairing_delegate(sm::IOCapability::kDisplayYesNo);
921 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
922
923 // Advance state machine.
924 pairing_state.InitiatePairing(kNoSecurityRequirements,
925 status_handler.MakeStatusCallback());
926 ASSERT_TRUE(pairing_state.initiator());
927 static_cast<void>(pairing_state.OnLinkKeyRequest());
928 EXPECT_EQ(IoCapability::DISPLAY_YES_NO,
929 *pairing_state.OnIoCapabilityRequest());
930
931 pairing_state.OnIoCapabilityResponse(IoCapability::DISPLAY_YES_NO);
932
933 pairing_delegate.SetDisplayPasskeyCallback(
934 [this](PeerId peer_id,
935 uint32_t value,
936 PairingDelegate::DisplayMethod method,
937 auto cb) {
938 EXPECT_EQ(peer()->identifier(), peer_id);
939 EXPECT_EQ(kTestPasskey, value);
940 EXPECT_EQ(PairingDelegate::DisplayMethod::kComparison, method);
941 ASSERT_TRUE(cb);
942 cb(true);
943 });
944 bool confirmed = false;
945 pairing_state.OnUserConfirmationRequest(
946 kTestPasskey, [&confirmed](bool confirm) { confirmed = confirm; });
947 EXPECT_TRUE(confirmed);
948
949 pairing_delegate.SetCompletePairingCallback(
950 [this](PeerId peer_id, sm::Result<> status) {
951 EXPECT_EQ(peer()->identifier(), peer_id);
952 EXPECT_EQ(fit::ok(), status);
953 });
954 pairing_state.OnSimplePairingComplete(
955 pw::bluetooth::emboss::StatusCode::SUCCESS);
956
957 EXPECT_EQ(0, status_handler.call_count());
958 }
959
TEST_F(PairingStateTest,NumericComparisonPairingComparesPasskeyOnResponderDisplayYesNoSide)960 TEST_F(PairingStateTest,
961 NumericComparisonPairingComparesPasskeyOnResponderDisplayYesNoSide) {
962 TestStatusHandler status_handler;
963
964 PairingState pairing_state(peer()->GetWeakPtr(),
965 connection(),
966 /*link_initiated=*/false,
967 MakeAuthRequestCallback(),
968 status_handler.MakeStatusCallback());
969 FakePairingDelegate pairing_delegate(sm::IOCapability::kDisplayYesNo);
970 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
971
972 // Advance state machine.
973 pairing_state.OnIoCapabilityResponse(IoCapability::DISPLAY_YES_NO);
974 ASSERT_FALSE(pairing_state.initiator());
975 EXPECT_EQ(IoCapability::DISPLAY_YES_NO,
976 *pairing_state.OnIoCapabilityRequest());
977
978 pairing_delegate.SetDisplayPasskeyCallback(
979 [this](PeerId peer_id,
980 uint32_t value,
981 PairingDelegate::DisplayMethod method,
982 auto cb) {
983 EXPECT_EQ(peer()->identifier(), peer_id);
984 EXPECT_EQ(kTestPasskey, value);
985 EXPECT_EQ(PairingDelegate::DisplayMethod::kComparison, method);
986 ASSERT_TRUE(cb);
987 cb(true);
988 });
989 bool confirmed = false;
990 pairing_state.OnUserConfirmationRequest(
991 kTestPasskey, [&confirmed](bool confirm) { confirmed = confirm; });
992 EXPECT_TRUE(confirmed);
993
994 pairing_delegate.SetCompletePairingCallback(
995 [this](PeerId peer_id, sm::Result<> status) {
996 EXPECT_EQ(peer()->identifier(), peer_id);
997 EXPECT_EQ(fit::ok(), status);
998 });
999 pairing_state.OnSimplePairingComplete(
1000 pw::bluetooth::emboss::StatusCode::SUCCESS);
1001
1002 EXPECT_EQ(0, status_handler.call_count());
1003 }
1004
1005 // v5.0, Vol 3, Part C, Sec 5.2.2.6 call this "Numeric Comparison with automatic
1006 // confirmation on device B only and Yes/No confirmation on whether to pair on
1007 // device A. Device A does not show the confirmation value." and it should
1008 // result in user consent.
TEST_F(PairingStateTest,NumericComparisonWithoutValueRequestsConsentFromDisplayYesNoSide)1009 TEST_F(PairingStateTest,
1010 NumericComparisonWithoutValueRequestsConsentFromDisplayYesNoSide) {
1011 TestStatusHandler status_handler;
1012
1013 PairingState pairing_state(peer()->GetWeakPtr(),
1014 connection(),
1015 /*link_initiated=*/false,
1016 MakeAuthRequestCallback(),
1017 status_handler.MakeStatusCallback());
1018 FakePairingDelegate pairing_delegate(sm::IOCapability::kDisplayYesNo);
1019 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
1020
1021 // Advance state machine.
1022 pairing_state.OnIoCapabilityResponse(IoCapability::NO_INPUT_NO_OUTPUT);
1023 ASSERT_FALSE(pairing_state.initiator());
1024 EXPECT_EQ(IoCapability::DISPLAY_YES_NO,
1025 *pairing_state.OnIoCapabilityRequest());
1026
1027 pairing_delegate.SetConfirmPairingCallback([this](PeerId peer_id, auto cb) {
1028 EXPECT_EQ(peer()->identifier(), peer_id);
1029 ASSERT_TRUE(cb);
1030 cb(true);
1031 });
1032 bool confirmed = false;
1033 pairing_state.OnUserConfirmationRequest(
1034 kTestPasskey, [&confirmed](bool confirm) { confirmed = confirm; });
1035 EXPECT_TRUE(confirmed);
1036
1037 pairing_delegate.SetCompletePairingCallback(
1038 [this](PeerId peer_id, sm::Result<> status) {
1039 EXPECT_EQ(peer()->identifier(), peer_id);
1040 EXPECT_EQ(fit::ok(), status);
1041 });
1042 pairing_state.OnSimplePairingComplete(
1043 pw::bluetooth::emboss::StatusCode::SUCCESS);
1044
1045 EXPECT_EQ(0, status_handler.call_count());
1046 }
1047
TEST_F(PairingStateTest,PasskeyEntryPairingDisplaysPasskeyToDisplayOnlySide)1048 TEST_F(PairingStateTest, PasskeyEntryPairingDisplaysPasskeyToDisplayOnlySide) {
1049 TestStatusHandler status_handler;
1050
1051 PairingState pairing_state(peer()->GetWeakPtr(),
1052 connection(),
1053 /*link_initiated=*/false,
1054 MakeAuthRequestCallback(),
1055 status_handler.MakeStatusCallback());
1056 FakePairingDelegate pairing_delegate(sm::IOCapability::kDisplayOnly);
1057 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
1058
1059 // Advance state machine.
1060 pairing_state.OnIoCapabilityResponse(IoCapability::KEYBOARD_ONLY);
1061 ASSERT_FALSE(pairing_state.initiator());
1062 EXPECT_EQ(IoCapability::DISPLAY_ONLY, *pairing_state.OnIoCapabilityRequest());
1063
1064 pairing_delegate.SetDisplayPasskeyCallback(
1065 [this](PeerId peer_id,
1066 uint32_t value,
1067 PairingDelegate::DisplayMethod method,
1068 auto cb) {
1069 EXPECT_EQ(peer()->identifier(), peer_id);
1070 EXPECT_EQ(kTestPasskey, value);
1071 EXPECT_EQ(PairingDelegate::DisplayMethod::kPeerEntry, method);
1072 EXPECT_TRUE(cb);
1073 });
1074 pairing_state.OnUserPasskeyNotification(kTestPasskey);
1075
1076 pairing_delegate.SetCompletePairingCallback(
1077 [this](PeerId peer_id, sm::Result<> status) {
1078 EXPECT_EQ(peer()->identifier(), peer_id);
1079 EXPECT_EQ(fit::ok(), status);
1080 });
1081 pairing_state.OnSimplePairingComplete(
1082 pw::bluetooth::emboss::StatusCode::SUCCESS);
1083
1084 EXPECT_EQ(0, status_handler.call_count());
1085 }
1086
TEST_F(PairingStateTest,PasskeyEntryPairingRequestsPasskeyFromKeyboardOnlySide)1087 TEST_F(PairingStateTest,
1088 PasskeyEntryPairingRequestsPasskeyFromKeyboardOnlySide) {
1089 TestStatusHandler status_handler;
1090
1091 PairingState pairing_state(peer()->GetWeakPtr(),
1092 connection(),
1093 /*link_initiated=*/false,
1094 MakeAuthRequestCallback(),
1095 status_handler.MakeStatusCallback());
1096 FakePairingDelegate pairing_delegate(sm::IOCapability::kKeyboardOnly);
1097 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
1098
1099 // Advance state machine.
1100 pairing_state.OnIoCapabilityResponse(IoCapability::DISPLAY_ONLY);
1101 ASSERT_FALSE(pairing_state.initiator());
1102 EXPECT_EQ(IoCapability::KEYBOARD_ONLY,
1103 *pairing_state.OnIoCapabilityRequest());
1104
1105 pairing_delegate.SetRequestPasskeyCallback([this](PeerId peer_id, auto cb) {
1106 EXPECT_EQ(peer()->identifier(), peer_id);
1107 ASSERT_TRUE(cb);
1108 cb(kTestPasskey);
1109 });
1110 bool cb_called = false;
1111 std::optional<uint32_t> passkey;
1112 auto passkey_cb = [&cb_called,
1113 &passkey](std::optional<uint32_t> pairing_state_passkey) {
1114 cb_called = true;
1115 passkey = pairing_state_passkey;
1116 };
1117
1118 pairing_state.OnUserPasskeyRequest(std::move(passkey_cb));
1119 EXPECT_TRUE(cb_called);
1120 ASSERT_TRUE(passkey);
1121 EXPECT_EQ(kTestPasskey, *passkey);
1122
1123 pairing_delegate.SetCompletePairingCallback(
1124 [this](PeerId peer_id, sm::Result<> status) {
1125 EXPECT_EQ(peer()->identifier(), peer_id);
1126 EXPECT_EQ(fit::ok(), status);
1127 });
1128 pairing_state.OnSimplePairingComplete(
1129 pw::bluetooth::emboss::StatusCode::SUCCESS);
1130
1131 EXPECT_EQ(0, status_handler.call_count());
1132 }
1133
TEST_F(PairingStateTest,JustWorksPairingOutgoingConnectDoesNotRequestUserActionInitiator)1134 TEST_F(PairingStateTest,
1135 JustWorksPairingOutgoingConnectDoesNotRequestUserActionInitiator) {
1136 TestStatusHandler owner_status_handler;
1137 TestStatusHandler initiator_status_handler;
1138 PairingState pairing_state(peer()->GetWeakPtr(),
1139 connection(),
1140 /*link_initiated=*/true,
1141 MakeAuthRequestCallback(),
1142 owner_status_handler.MakeStatusCallback());
1143
1144 FakePairingDelegate pairing_delegate(sm::IOCapability::kNoInputNoOutput);
1145 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
1146
1147 // Advance state machine to Initiator Waiting IOCap Request
1148 pairing_state.InitiatePairing(kNoSecurityRequirements,
1149 initiator_status_handler.MakeStatusCallback());
1150 EXPECT_TRUE(pairing_state.initiator());
1151 static_cast<void>(pairing_state.OnLinkKeyRequest());
1152 EXPECT_EQ(IoCapability::NO_INPUT_NO_OUTPUT,
1153 *pairing_state.OnIoCapabilityRequest());
1154
1155 pairing_state.OnIoCapabilityResponse(IoCapability::NO_INPUT_NO_OUTPUT);
1156 bool confirmed = false;
1157 pairing_state.OnUserConfirmationRequest(
1158 kTestPasskey, [&confirmed](bool confirm) { confirmed = confirm; });
1159 EXPECT_TRUE(confirmed);
1160
1161 pairing_delegate.SetCompletePairingCallback(
1162 [this](PeerId peer_id, sm::Result<> status) {
1163 EXPECT_EQ(peer()->identifier(), peer_id);
1164 EXPECT_EQ(fit::ok(), status);
1165 });
1166 pairing_state.OnSimplePairingComplete(
1167 pw::bluetooth::emboss::StatusCode::SUCCESS);
1168
1169 EXPECT_EQ(0, owner_status_handler.call_count());
1170 EXPECT_EQ(0, initiator_status_handler.call_count());
1171 }
1172
TEST_F(PairingStateTest,JustWorksPairingOutgoingConnectDoesNotRequestUserActionResponder)1173 TEST_F(PairingStateTest,
1174 JustWorksPairingOutgoingConnectDoesNotRequestUserActionResponder) {
1175 TestStatusHandler status_handler;
1176
1177 PairingState pairing_state(peer()->GetWeakPtr(),
1178 connection(),
1179 /*link_initiated=*/true,
1180 MakeAuthRequestCallback(),
1181 status_handler.MakeStatusCallback());
1182 FakePairingDelegate pairing_delegate(sm::IOCapability::kNoInputNoOutput);
1183 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
1184
1185 // Advance state machine.
1186 pairing_state.OnIoCapabilityResponse(IoCapability::NO_INPUT_NO_OUTPUT);
1187 ASSERT_FALSE(pairing_state.initiator());
1188 EXPECT_EQ(IoCapability::NO_INPUT_NO_OUTPUT,
1189 *pairing_state.OnIoCapabilityRequest());
1190
1191 bool confirmed = false;
1192 pairing_state.OnUserConfirmationRequest(
1193 kTestPasskey, [&confirmed](bool confirm) { confirmed = confirm; });
1194 EXPECT_TRUE(confirmed);
1195
1196 pairing_delegate.SetCompletePairingCallback(
1197 [this](PeerId peer_id, sm::Result<> status) {
1198 EXPECT_EQ(peer()->identifier(), peer_id);
1199 EXPECT_EQ(fit::ok(), status);
1200 });
1201 pairing_state.OnSimplePairingComplete(
1202 pw::bluetooth::emboss::StatusCode::SUCCESS);
1203
1204 EXPECT_EQ(0, status_handler.call_count());
1205 }
1206
TEST_F(PairingStateTest,JustWorksPairingIncomingConnectRequiresConfirmationRejectedResponder)1207 TEST_F(PairingStateTest,
1208 JustWorksPairingIncomingConnectRequiresConfirmationRejectedResponder) {
1209 TestStatusHandler status_handler;
1210
1211 PairingState pairing_state(peer()->GetWeakPtr(),
1212 connection(),
1213 /*link_initiated=*/false,
1214 MakeAuthRequestCallback(),
1215 status_handler.MakeStatusCallback());
1216 FakePairingDelegate pairing_delegate(sm::IOCapability::kNoInputNoOutput);
1217 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
1218
1219 // Advance state machine.
1220 pairing_state.OnIoCapabilityResponse(IoCapability::NO_INPUT_NO_OUTPUT);
1221 ASSERT_FALSE(pairing_state.initiator());
1222 EXPECT_EQ(IoCapability::NO_INPUT_NO_OUTPUT,
1223 *pairing_state.OnIoCapabilityRequest());
1224
1225 pairing_delegate.SetConfirmPairingCallback([this](PeerId peer_id, auto cb) {
1226 EXPECT_EQ(peer()->identifier(), peer_id);
1227 ASSERT_TRUE(cb);
1228 cb(false);
1229 });
1230 bool confirmed = true;
1231 pairing_state.OnUserConfirmationRequest(
1232 kTestPasskey, [&confirmed](bool confirm) { confirmed = confirm; });
1233 EXPECT_FALSE(confirmed);
1234
1235 // Eventually the controller sends a SimplePairingComplete indicating the
1236 // failure.
1237 pairing_delegate.SetCompletePairingCallback(
1238 [this](PeerId peer_id, sm::Result<> status) {
1239 EXPECT_EQ(peer()->identifier(), peer_id);
1240 EXPECT_TRUE(status.is_error());
1241 });
1242 pairing_state.OnSimplePairingComplete(
1243 pw::bluetooth::emboss::StatusCode::AUTHENTICATION_FAILURE);
1244
1245 EXPECT_EQ(1, status_handler.call_count());
1246 ASSERT_TRUE(status_handler.status());
1247 EXPECT_EQ(ToResult(pw::bluetooth::emboss::StatusCode::AUTHENTICATION_FAILURE),
1248 *status_handler.status());
1249 }
1250
TEST_F(PairingStateTest,JustWorksPairingIncomingConnectRequiresConfirmationRejectedInitiator)1251 TEST_F(PairingStateTest,
1252 JustWorksPairingIncomingConnectRequiresConfirmationRejectedInitiator) {
1253 TestStatusHandler owner_status_handler;
1254 TestStatusHandler initiator_status_handler;
1255 PairingState pairing_state(peer()->GetWeakPtr(),
1256 connection(),
1257 /*link_initiated=*/false,
1258 MakeAuthRequestCallback(),
1259 owner_status_handler.MakeStatusCallback());
1260
1261 FakePairingDelegate pairing_delegate(sm::IOCapability::kNoInputNoOutput);
1262 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
1263
1264 // Advance state machine to Initiator Waiting IOCap Request
1265 pairing_state.InitiatePairing(kNoSecurityRequirements,
1266 initiator_status_handler.MakeStatusCallback());
1267 EXPECT_TRUE(pairing_state.initiator());
1268 static_cast<void>(pairing_state.OnLinkKeyRequest());
1269 EXPECT_EQ(IoCapability::NO_INPUT_NO_OUTPUT,
1270 *pairing_state.OnIoCapabilityRequest());
1271
1272 pairing_state.OnIoCapabilityResponse(IoCapability::NO_INPUT_NO_OUTPUT);
1273
1274 pairing_delegate.SetConfirmPairingCallback([this](PeerId peer_id, auto cb) {
1275 EXPECT_EQ(peer()->identifier(), peer_id);
1276 ASSERT_TRUE(cb);
1277 cb(false);
1278 });
1279 bool confirmed = true;
1280 pairing_state.OnUserConfirmationRequest(
1281 kTestPasskey, [&confirmed](bool confirm) { confirmed = confirm; });
1282 EXPECT_FALSE(confirmed);
1283
1284 // Eventually the controller sends a SimplePairingComplete indicating the
1285 // failure.
1286 pairing_delegate.SetCompletePairingCallback(
1287 [this](PeerId peer_id, sm::Result<> status) {
1288 EXPECT_EQ(peer()->identifier(), peer_id);
1289 EXPECT_TRUE(status.is_error());
1290 });
1291 pairing_state.OnSimplePairingComplete(
1292 pw::bluetooth::emboss::StatusCode::AUTHENTICATION_FAILURE);
1293
1294 EXPECT_EQ(1, owner_status_handler.call_count());
1295 ASSERT_TRUE(owner_status_handler.status());
1296 EXPECT_EQ(ToResult(pw::bluetooth::emboss::StatusCode::AUTHENTICATION_FAILURE),
1297 *owner_status_handler.status());
1298 EXPECT_EQ(1, initiator_status_handler.call_count());
1299 ASSERT_TRUE(initiator_status_handler.status());
1300 EXPECT_EQ(ToResult(pw::bluetooth::emboss::StatusCode::AUTHENTICATION_FAILURE),
1301 *initiator_status_handler.status());
1302 }
1303
TEST_F(PairingStateTest,JustWorksPairingIncomingConnectRequiresConfirmationAcceptedResponder)1304 TEST_F(PairingStateTest,
1305 JustWorksPairingIncomingConnectRequiresConfirmationAcceptedResponder) {
1306 TestStatusHandler status_handler;
1307
1308 PairingState pairing_state(peer()->GetWeakPtr(),
1309 connection(),
1310 /*link_initiated=*/false,
1311 MakeAuthRequestCallback(),
1312 status_handler.MakeStatusCallback());
1313 FakePairingDelegate pairing_delegate(sm::IOCapability::kNoInputNoOutput);
1314 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
1315
1316 // Advance state machine.
1317 pairing_state.OnIoCapabilityResponse(IoCapability::NO_INPUT_NO_OUTPUT);
1318 ASSERT_FALSE(pairing_state.initiator());
1319 EXPECT_EQ(IoCapability::NO_INPUT_NO_OUTPUT,
1320 *pairing_state.OnIoCapabilityRequest());
1321
1322 pairing_delegate.SetConfirmPairingCallback([this](PeerId peer_id, auto cb) {
1323 EXPECT_EQ(peer()->identifier(), peer_id);
1324 ASSERT_TRUE(cb);
1325 cb(true);
1326 });
1327 bool confirmed = false;
1328 pairing_state.OnUserConfirmationRequest(
1329 kTestPasskey, [&confirmed](bool confirm) { confirmed = confirm; });
1330 EXPECT_TRUE(confirmed);
1331
1332 pairing_delegate.SetCompletePairingCallback(
1333 [this](PeerId peer_id, sm::Result<> status) {
1334 EXPECT_EQ(peer()->identifier(), peer_id);
1335 EXPECT_EQ(fit::ok(), status);
1336 });
1337 pairing_state.OnSimplePairingComplete(
1338 pw::bluetooth::emboss::StatusCode::SUCCESS);
1339
1340 EXPECT_EQ(0, status_handler.call_count());
1341 }
1342
TEST_F(PairingStateTest,JustWorksPairingIncomingConnectRequiresConfirmationAcceptedInitiator)1343 TEST_F(PairingStateTest,
1344 JustWorksPairingIncomingConnectRequiresConfirmationAcceptedInitiator) {
1345 TestStatusHandler owner_status_handler;
1346 TestStatusHandler initiator_status_handler;
1347 PairingState pairing_state(peer()->GetWeakPtr(),
1348 connection(),
1349 /*link_initiated=*/false,
1350 MakeAuthRequestCallback(),
1351 owner_status_handler.MakeStatusCallback());
1352
1353 FakePairingDelegate pairing_delegate(sm::IOCapability::kNoInputNoOutput);
1354 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
1355
1356 // Advance state machine to Initiator Waiting IOCap Request
1357 pairing_state.InitiatePairing(kNoSecurityRequirements,
1358 initiator_status_handler.MakeStatusCallback());
1359 EXPECT_TRUE(pairing_state.initiator());
1360 static_cast<void>(pairing_state.OnLinkKeyRequest());
1361 EXPECT_EQ(IoCapability::NO_INPUT_NO_OUTPUT,
1362 *pairing_state.OnIoCapabilityRequest());
1363
1364 pairing_state.OnIoCapabilityResponse(IoCapability::NO_INPUT_NO_OUTPUT);
1365
1366 pairing_delegate.SetConfirmPairingCallback([this](PeerId peer_id, auto cb) {
1367 EXPECT_EQ(peer()->identifier(), peer_id);
1368 ASSERT_TRUE(cb);
1369 cb(true);
1370 });
1371 bool confirmed = false;
1372 pairing_state.OnUserConfirmationRequest(
1373 kTestPasskey, [&confirmed](bool confirm) { confirmed = confirm; });
1374 EXPECT_TRUE(confirmed);
1375
1376 pairing_delegate.SetCompletePairingCallback(
1377 [this](PeerId peer_id, sm::Result<> status) {
1378 EXPECT_EQ(peer()->identifier(), peer_id);
1379 EXPECT_EQ(fit::ok(), status);
1380 });
1381 pairing_state.OnSimplePairingComplete(
1382 pw::bluetooth::emboss::StatusCode::SUCCESS);
1383
1384 EXPECT_EQ(0, owner_status_handler.call_count());
1385 EXPECT_EQ(0, initiator_status_handler.call_count());
1386 }
1387
1388 // Event injectors. Return values are necessarily ignored in order to make types
1389 // match, so don't use these functions to test return values. Likewise,
1390 // arguments have been filled with test defaults for a successful pairing flow.
LinkKeyRequest(PairingState * pairing_state)1391 void LinkKeyRequest(PairingState* pairing_state) {
1392 static_cast<void>(pairing_state->OnLinkKeyRequest());
1393 }
IoCapabilityRequest(PairingState * pairing_state)1394 void IoCapabilityRequest(PairingState* pairing_state) {
1395 static_cast<void>(pairing_state->OnIoCapabilityRequest());
1396 }
IoCapabilityResponse(PairingState * pairing_state)1397 void IoCapabilityResponse(PairingState* pairing_state) {
1398 pairing_state->OnIoCapabilityResponse(kTestPeerIoCap);
1399 }
UserConfirmationRequest(PairingState * pairing_state)1400 void UserConfirmationRequest(PairingState* pairing_state) {
1401 pairing_state->OnUserConfirmationRequest(kTestPasskey,
1402 NoOpUserConfirmationCallback);
1403 }
UserPasskeyRequest(PairingState * pairing_state)1404 void UserPasskeyRequest(PairingState* pairing_state) {
1405 pairing_state->OnUserPasskeyRequest(NoOpUserPasskeyCallback);
1406 }
UserPasskeyNotification(PairingState * pairing_state)1407 void UserPasskeyNotification(PairingState* pairing_state) {
1408 pairing_state->OnUserPasskeyNotification(kTestPasskey);
1409 }
SimplePairingComplete(PairingState * pairing_state)1410 void SimplePairingComplete(PairingState* pairing_state) {
1411 pairing_state->OnSimplePairingComplete(
1412 pw::bluetooth::emboss::StatusCode::SUCCESS);
1413 }
LinkKeyNotification(PairingState * pairing_state)1414 void LinkKeyNotification(PairingState* pairing_state) {
1415 pairing_state->OnLinkKeyNotification(kTestLinkKeyValue,
1416 kTestUnauthenticatedLinkKeyType192);
1417 }
AuthenticationComplete(PairingState * pairing_state)1418 void AuthenticationComplete(PairingState* pairing_state) {
1419 pairing_state->OnAuthenticationComplete(
1420 pw::bluetooth::emboss::StatusCode::SUCCESS);
1421 }
1422
1423 // Test suite fixture that genericizes an injected pairing state event. The
1424 // event being tested should be retrieved with the GetParam method, which
1425 // returns a default event injector. For example:
1426 //
1427 // PairingState pairing_state;
1428 // GetParam()(&pairing_state);
1429 //
1430 // This is named so that the instantiated test description looks correct:
1431 //
1432 // PairingStateTest/HandlesEvent.<test case>/<index of event>
1433 class HandlesEvent
1434 : public PairingStateTest,
1435 public ::testing::WithParamInterface<void (*)(PairingState*)> {
1436 public:
SetUp()1437 void SetUp() override {
1438 PairingStateTest::SetUp();
1439
1440 pairing_delegate_ = std::make_unique<NoOpPairingDelegate>(kTestLocalIoCap);
1441 pairing_state_ =
1442 std::make_unique<PairingState>(peer()->GetWeakPtr(),
1443 connection(),
1444 /*link_initiated=*/false,
1445 MakeAuthRequestCallback(),
1446 status_handler_.MakeStatusCallback());
1447 pairing_state().SetPairingDelegate(pairing_delegate_->GetWeakPtr());
1448 }
1449
TearDown()1450 void TearDown() override {
1451 pairing_state_.reset();
1452 PairingStateTest::TearDown();
1453 }
1454
status_handler() const1455 const TestStatusHandler& status_handler() const { return status_handler_; }
pairing_state()1456 PairingState& pairing_state() { return *pairing_state_; }
1457
1458 // Returns an event injector that was passed to INSTANTIATE_TEST_SUITE_P.
event() const1459 auto* event() const { return GetParam(); }
1460
InjectEvent()1461 void InjectEvent() { event()(&pairing_state()); }
1462
1463 private:
1464 TestStatusHandler status_handler_;
1465 std::unique_ptr<NoOpPairingDelegate> pairing_delegate_;
1466 std::unique_ptr<PairingState> pairing_state_;
1467 };
1468
1469 // The tests here exercise that PairingState can be successfully advances
1470 // through the expected pairing flow and generates errors when the pairing flow
1471 // occurs out of order. This is intended to cover its internal state machine
1472 // transitions and not the side effects.
1473 INSTANTIATE_TEST_SUITE_P(PairingStateTest,
1474 HandlesEvent,
1475 ::testing::Values(LinkKeyRequest,
1476 IoCapabilityRequest,
1477 IoCapabilityResponse,
1478 UserConfirmationRequest,
1479 UserPasskeyRequest,
1480 UserPasskeyNotification,
1481 SimplePairingComplete,
1482 LinkKeyNotification,
1483 AuthenticationComplete));
1484
TEST_P(HandlesEvent,InIdleState)1485 TEST_P(HandlesEvent, InIdleState) {
1486 RETURN_IF_FATAL(InjectEvent());
1487 if (event() == LinkKeyRequest || event() == IoCapabilityResponse) {
1488 EXPECT_EQ(0, status_handler().call_count());
1489 } else {
1490 EXPECT_EQ(1, status_handler().call_count());
1491 ASSERT_TRUE(status_handler().handle());
1492 EXPECT_EQ(kTestHandle, *status_handler().handle());
1493 ASSERT_TRUE(status_handler().status());
1494 EXPECT_EQ(ToResult(HostError::kNotSupported), status_handler().status());
1495 }
1496 }
1497
TEST_P(HandlesEvent,InInitiatorWaitLinkKeyRequestState)1498 TEST_P(HandlesEvent, InInitiatorWaitLinkKeyRequestState) {
1499 // Advance state machine.
1500 static_cast<void>(pairing_state().InitiatePairing(kNoSecurityRequirements,
1501 NoOpStatusCallback));
1502
1503 RETURN_IF_FATAL(InjectEvent());
1504 if (event() == LinkKeyRequest) {
1505 EXPECT_EQ(0, status_handler().call_count());
1506 } else {
1507 EXPECT_EQ(1, status_handler().call_count());
1508 ASSERT_TRUE(status_handler().status());
1509 EXPECT_EQ(ToResult(HostError::kNotSupported), status_handler().status());
1510 }
1511 }
1512
TEST_P(HandlesEvent,InInitiatorWaitIoCapRequest)1513 TEST_P(HandlesEvent, InInitiatorWaitIoCapRequest) {
1514 // Advance state machine.
1515 pairing_state().InitiatePairing(kNoSecurityRequirements, NoOpStatusCallback);
1516 static_cast<void>(pairing_state().OnLinkKeyRequest());
1517
1518 RETURN_IF_FATAL(InjectEvent());
1519 if (event() == IoCapabilityRequest) {
1520 EXPECT_EQ(0, status_handler().call_count());
1521 } else {
1522 EXPECT_EQ(1, status_handler().call_count());
1523 ASSERT_TRUE(status_handler().status());
1524 EXPECT_EQ(ToResult(HostError::kNotSupported), status_handler().status());
1525 }
1526 }
1527
TEST_P(HandlesEvent,InInitiatorWaitAuthCompleteSkippingSimplePairing)1528 TEST_P(HandlesEvent, InInitiatorWaitAuthCompleteSkippingSimplePairing) {
1529 peer()->MutBrEdr().SetBondData(
1530 sm::LTK(sm::SecurityProperties(kTestUnauthenticatedLinkKeyType192),
1531 kTestLinkKey));
1532
1533 // Advance state machine.
1534 pairing_state().InitiatePairing(kNoSecurityRequirements, NoOpStatusCallback);
1535 EXPECT_NE(std::nullopt, pairing_state().OnLinkKeyRequest());
1536
1537 RETURN_IF_FATAL(InjectEvent());
1538 if (event() == AuthenticationComplete) {
1539 EXPECT_EQ(0, status_handler().call_count());
1540 EXPECT_EQ(1, connection()->start_encryption_count());
1541 } else {
1542 EXPECT_EQ(1, status_handler().call_count());
1543 ASSERT_TRUE(status_handler().status());
1544 EXPECT_EQ(ToResult(HostError::kNotSupported), status_handler().status());
1545 }
1546 }
1547
TEST_P(HandlesEvent,InInitiatorWaitIoCapResponseState)1548 TEST_P(HandlesEvent, InInitiatorWaitIoCapResponseState) {
1549 // Advance state machine.
1550 static_cast<void>(pairing_state().InitiatePairing(kNoSecurityRequirements,
1551 NoOpStatusCallback));
1552 static_cast<void>(pairing_state().OnLinkKeyRequest());
1553 static_cast<void>(pairing_state().OnIoCapabilityRequest());
1554
1555 RETURN_IF_FATAL(InjectEvent());
1556 if (event() == IoCapabilityResponse) {
1557 EXPECT_EQ(0, status_handler().call_count());
1558 } else {
1559 EXPECT_EQ(1, status_handler().call_count());
1560 ASSERT_TRUE(status_handler().status());
1561 EXPECT_EQ(ToResult(HostError::kNotSupported), status_handler().status());
1562 }
1563 }
1564
TEST_P(HandlesEvent,InResponderWaitIoCapRequestState)1565 TEST_P(HandlesEvent, InResponderWaitIoCapRequestState) {
1566 // Advance state machine.
1567 pairing_state().OnIoCapabilityResponse(kTestPeerIoCap);
1568
1569 RETURN_IF_FATAL(InjectEvent());
1570 if (event() == IoCapabilityRequest) {
1571 EXPECT_EQ(0, status_handler().call_count());
1572 } else {
1573 EXPECT_EQ(1, status_handler().call_count());
1574 ASSERT_TRUE(status_handler().status());
1575 EXPECT_EQ(ToResult(HostError::kNotSupported), status_handler().status());
1576 }
1577 }
1578
TEST_P(HandlesEvent,InErrorStateAfterIoCapRequestRejectedWithoutPairingDelegate)1579 TEST_P(HandlesEvent,
1580 InErrorStateAfterIoCapRequestRejectedWithoutPairingDelegate) {
1581 // Clear the default pairing delegate set by the fixture.
1582 pairing_state().SetPairingDelegate(PairingDelegate::WeakPtr());
1583
1584 // Advance state machine.
1585 pairing_state().OnIoCapabilityResponse(kTestPeerIoCap);
1586 EXPECT_FALSE(pairing_state().OnIoCapabilityRequest());
1587
1588 // PairingState no longer accepts events because being not ready to pair has
1589 // raised an error.
1590 RETURN_IF_FATAL(InjectEvent());
1591 EXPECT_LE(1, status_handler().call_count());
1592 ASSERT_TRUE(status_handler().status());
1593 if (event() == LinkKeyRequest || event() == IoCapabilityResponse) {
1594 // Peer attempted to pair again, which raises an additional "not ready"
1595 // error.
1596 EXPECT_EQ(ToResult(HostError::kNotReady), status_handler().status());
1597 } else {
1598 EXPECT_EQ(ToResult(HostError::kNotSupported), status_handler().status());
1599 }
1600 }
1601
TEST_P(HandlesEvent,InWaitUserConfirmationStateAsInitiator)1602 TEST_P(HandlesEvent, InWaitUserConfirmationStateAsInitiator) {
1603 NoOpPairingDelegate pairing_delegate(sm::IOCapability::kDisplayOnly);
1604 pairing_state().SetPairingDelegate(pairing_delegate.GetWeakPtr());
1605
1606 // Advance state machine.
1607 pairing_state().InitiatePairing(kNoSecurityRequirements, NoOpStatusCallback);
1608 static_cast<void>(pairing_state().OnLinkKeyRequest());
1609 static_cast<void>(pairing_state().OnIoCapabilityRequest());
1610 pairing_state().OnIoCapabilityResponse(IoCapability::DISPLAY_YES_NO);
1611 ASSERT_TRUE(pairing_state().initiator());
1612
1613 RETURN_IF_FATAL(InjectEvent());
1614 if (event() == UserConfirmationRequest) {
1615 EXPECT_EQ(0, status_handler().call_count());
1616 } else {
1617 EXPECT_EQ(1, status_handler().call_count());
1618 ASSERT_TRUE(status_handler().status());
1619 EXPECT_EQ(ToResult(HostError::kNotSupported), status_handler().status());
1620 }
1621 }
1622
TEST_P(HandlesEvent,InWaitUserPasskeyRequestStateAsInitiator)1623 TEST_P(HandlesEvent, InWaitUserPasskeyRequestStateAsInitiator) {
1624 NoOpPairingDelegate pairing_delegate(sm::IOCapability::kKeyboardOnly);
1625 pairing_state().SetPairingDelegate(pairing_delegate.GetWeakPtr());
1626
1627 // Advance state machine.
1628 pairing_state().InitiatePairing(kNoSecurityRequirements, NoOpStatusCallback);
1629 static_cast<void>(pairing_state().OnLinkKeyRequest());
1630 static_cast<void>(pairing_state().OnIoCapabilityRequest());
1631 pairing_state().OnIoCapabilityResponse(IoCapability::DISPLAY_ONLY);
1632 ASSERT_TRUE(pairing_state().initiator());
1633
1634 RETURN_IF_FATAL(InjectEvent());
1635 if (event() == UserPasskeyRequest) {
1636 EXPECT_EQ(0, status_handler().call_count());
1637 } else {
1638 EXPECT_EQ(1, status_handler().call_count());
1639 ASSERT_TRUE(status_handler().status());
1640 EXPECT_EQ(ToResult(HostError::kNotSupported), status_handler().status());
1641 }
1642 }
1643
TEST_P(HandlesEvent,InWaitUserPasskeyNotificationStateAsInitiator)1644 TEST_P(HandlesEvent, InWaitUserPasskeyNotificationStateAsInitiator) {
1645 NoOpPairingDelegate pairing_delegate(sm::IOCapability::kDisplayOnly);
1646 pairing_state().SetPairingDelegate(pairing_delegate.GetWeakPtr());
1647
1648 // Advance state machine.
1649 pairing_state().InitiatePairing(kNoSecurityRequirements, NoOpStatusCallback);
1650 static_cast<void>(pairing_state().OnLinkKeyRequest());
1651 static_cast<void>(pairing_state().OnIoCapabilityRequest());
1652 pairing_state().OnIoCapabilityResponse(IoCapability::KEYBOARD_ONLY);
1653 ASSERT_TRUE(pairing_state().initiator());
1654
1655 RETURN_IF_FATAL(InjectEvent());
1656 if (event() == UserPasskeyNotification) {
1657 EXPECT_EQ(0, status_handler().call_count());
1658 } else {
1659 EXPECT_EQ(1, status_handler().call_count());
1660 ASSERT_TRUE(status_handler().status());
1661 EXPECT_EQ(ToResult(HostError::kNotSupported), status_handler().status());
1662 }
1663 }
1664
1665 // TODO(xow): Split into three tests depending on the pairing event expected.
TEST_P(HandlesEvent,InWaitUserConfirmationStateAsResponder)1666 TEST_P(HandlesEvent, InWaitUserConfirmationStateAsResponder) {
1667 NoOpPairingDelegate pairing_delegate(sm::IOCapability::kDisplayOnly);
1668 pairing_state().SetPairingDelegate(pairing_delegate.GetWeakPtr());
1669
1670 // Advance state machine.
1671 pairing_state().OnIoCapabilityResponse(IoCapability::DISPLAY_YES_NO);
1672 static_cast<void>(pairing_state().OnIoCapabilityRequest());
1673 ASSERT_FALSE(pairing_state().initiator());
1674
1675 RETURN_IF_FATAL(InjectEvent());
1676 if (event() == UserConfirmationRequest) {
1677 EXPECT_EQ(0, status_handler().call_count());
1678 } else {
1679 EXPECT_EQ(1, status_handler().call_count());
1680 ASSERT_TRUE(status_handler().status());
1681 EXPECT_EQ(ToResult(HostError::kNotSupported), status_handler().status());
1682 }
1683 }
1684
TEST_P(HandlesEvent,InWaitUserPasskeyRequestStateAsResponder)1685 TEST_P(HandlesEvent, InWaitUserPasskeyRequestStateAsResponder) {
1686 NoOpPairingDelegate pairing_delegate(sm::IOCapability::kKeyboardOnly);
1687 pairing_state().SetPairingDelegate(pairing_delegate.GetWeakPtr());
1688
1689 // Advance state machine.
1690 pairing_state().OnIoCapabilityResponse(IoCapability::DISPLAY_ONLY);
1691 static_cast<void>(pairing_state().OnIoCapabilityRequest());
1692 ASSERT_FALSE(pairing_state().initiator());
1693
1694 RETURN_IF_FATAL(InjectEvent());
1695 if (event() == UserPasskeyRequest) {
1696 EXPECT_EQ(0, status_handler().call_count());
1697 } else {
1698 EXPECT_EQ(1, status_handler().call_count());
1699 ASSERT_TRUE(status_handler().status());
1700 EXPECT_EQ(ToResult(HostError::kNotSupported), status_handler().status());
1701 }
1702 }
1703
TEST_P(HandlesEvent,InWaitUserNotificationStateAsResponder)1704 TEST_P(HandlesEvent, InWaitUserNotificationStateAsResponder) {
1705 NoOpPairingDelegate pairing_delegate(sm::IOCapability::kDisplayOnly);
1706 pairing_state().SetPairingDelegate(pairing_delegate.GetWeakPtr());
1707
1708 // Advance state machine.
1709 pairing_state().OnIoCapabilityResponse(IoCapability::KEYBOARD_ONLY);
1710 static_cast<void>(pairing_state().OnIoCapabilityRequest());
1711 ASSERT_FALSE(pairing_state().initiator());
1712
1713 RETURN_IF_FATAL(InjectEvent());
1714 if (event() == UserPasskeyNotification) {
1715 EXPECT_EQ(0, status_handler().call_count());
1716 } else {
1717 EXPECT_EQ(1, status_handler().call_count());
1718 ASSERT_TRUE(status_handler().status());
1719 EXPECT_EQ(ToResult(HostError::kNotSupported), status_handler().status());
1720 }
1721 }
1722
TEST_P(HandlesEvent,InWaitPairingCompleteState)1723 TEST_P(HandlesEvent, InWaitPairingCompleteState) {
1724 // Advance state machine.
1725 pairing_state().OnIoCapabilityResponse(kTestPeerIoCap);
1726 static_cast<void>(pairing_state().OnIoCapabilityRequest());
1727 pairing_state().OnUserConfirmationRequest(kTestPasskey,
1728 NoOpUserConfirmationCallback);
1729
1730 RETURN_IF_FATAL(InjectEvent());
1731 if (event() == SimplePairingComplete) {
1732 EXPECT_EQ(0, status_handler().call_count());
1733 } else {
1734 EXPECT_EQ(1, status_handler().call_count());
1735 ASSERT_TRUE(status_handler().status());
1736 EXPECT_EQ(ToResult(HostError::kNotSupported), status_handler().status());
1737 }
1738 }
1739
TEST_P(HandlesEvent,InWaitLinkKeyState)1740 TEST_P(HandlesEvent, InWaitLinkKeyState) {
1741 // Advance state machine.
1742 pairing_state().OnIoCapabilityResponse(kTestPeerIoCap);
1743 static_cast<void>(pairing_state().OnIoCapabilityRequest());
1744 pairing_state().OnUserConfirmationRequest(kTestPasskey,
1745 NoOpUserConfirmationCallback);
1746 pairing_state().OnSimplePairingComplete(
1747 pw::bluetooth::emboss::StatusCode::SUCCESS);
1748 EXPECT_EQ(0, connection()->start_encryption_count());
1749
1750 RETURN_IF_FATAL(InjectEvent());
1751 if (event() == LinkKeyNotification) {
1752 EXPECT_EQ(0, status_handler().call_count());
1753 EXPECT_EQ(1, connection()->start_encryption_count());
1754 } else {
1755 EXPECT_EQ(1, status_handler().call_count());
1756 ASSERT_TRUE(status_handler().status());
1757 EXPECT_EQ(ToResult(HostError::kNotSupported), status_handler().status());
1758 }
1759 }
1760
TEST_P(HandlesEvent,InInitiatorWaitAuthCompleteStateAfterSimplePairing)1761 TEST_P(HandlesEvent, InInitiatorWaitAuthCompleteStateAfterSimplePairing) {
1762 // Advance state machine.
1763 pairing_state().InitiatePairing(kNoSecurityRequirements, NoOpStatusCallback);
1764 static_cast<void>(pairing_state().OnLinkKeyRequest());
1765 static_cast<void>(pairing_state().OnIoCapabilityRequest());
1766 pairing_state().OnIoCapabilityResponse(kTestPeerIoCap);
1767 pairing_state().OnUserConfirmationRequest(kTestPasskey,
1768 NoOpUserConfirmationCallback);
1769 pairing_state().OnSimplePairingComplete(
1770 pw::bluetooth::emboss::StatusCode::SUCCESS);
1771 pairing_state().OnLinkKeyNotification(kTestLinkKeyValue,
1772 kTestUnauthenticatedLinkKeyType192);
1773 ASSERT_TRUE(pairing_state().initiator());
1774 EXPECT_EQ(0, connection()->start_encryption_count());
1775
1776 RETURN_IF_FATAL(InjectEvent());
1777 if (event() == AuthenticationComplete) {
1778 EXPECT_EQ(0, status_handler().call_count());
1779 EXPECT_EQ(1, connection()->start_encryption_count());
1780 } else {
1781 EXPECT_EQ(1, status_handler().call_count());
1782 ASSERT_TRUE(status_handler().status());
1783 EXPECT_EQ(ToResult(HostError::kNotSupported), status_handler().status());
1784 }
1785 }
1786
TEST_P(HandlesEvent,InWaitEncryptionStateAsInitiator)1787 TEST_P(HandlesEvent, InWaitEncryptionStateAsInitiator) {
1788 // Advance state machine.
1789 pairing_state().InitiatePairing(kNoSecurityRequirements, NoOpStatusCallback);
1790 static_cast<void>(pairing_state().OnLinkKeyRequest());
1791 static_cast<void>(pairing_state().OnIoCapabilityRequest());
1792 pairing_state().OnIoCapabilityResponse(kTestPeerIoCap);
1793 pairing_state().OnUserConfirmationRequest(kTestPasskey,
1794 NoOpUserConfirmationCallback);
1795 pairing_state().OnSimplePairingComplete(
1796 pw::bluetooth::emboss::StatusCode::SUCCESS);
1797 pairing_state().OnLinkKeyNotification(kTestLinkKeyValue,
1798 kTestUnauthenticatedLinkKeyType192);
1799 pairing_state().OnAuthenticationComplete(
1800 pw::bluetooth::emboss::StatusCode::SUCCESS);
1801 ASSERT_TRUE(pairing_state().initiator());
1802
1803 RETURN_IF_FATAL(InjectEvent());
1804
1805 if (event() == IoCapabilityResponse) {
1806 // Restarting the pairing is allowed in this state.
1807 EXPECT_EQ(0, status_handler().call_count());
1808 } else {
1809 // Should not receive anything else other than OnEncryptionChange.
1810 EXPECT_EQ(1, status_handler().call_count());
1811 ASSERT_TRUE(status_handler().status());
1812 EXPECT_EQ(ToResult(HostError::kNotSupported), status_handler().status());
1813 }
1814 }
1815
TEST_P(HandlesEvent,InWaitEncryptionStateAsResponder)1816 TEST_P(HandlesEvent, InWaitEncryptionStateAsResponder) {
1817 // Advance state machine.
1818 pairing_state().OnIoCapabilityResponse(kTestPeerIoCap);
1819 static_cast<void>(pairing_state().OnIoCapabilityRequest());
1820 pairing_state().OnUserConfirmationRequest(kTestPasskey,
1821 NoOpUserConfirmationCallback);
1822 pairing_state().OnSimplePairingComplete(
1823 pw::bluetooth::emboss::StatusCode::SUCCESS);
1824 pairing_state().OnLinkKeyNotification(kTestLinkKeyValue,
1825 kTestUnauthenticatedLinkKeyType192);
1826 ASSERT_FALSE(pairing_state().initiator());
1827
1828 RETURN_IF_FATAL(InjectEvent());
1829
1830 if (event() == IoCapabilityResponse) {
1831 // Restarting the pairing is allowed in this state.
1832 EXPECT_EQ(0, status_handler().call_count());
1833 } else {
1834 // Should not receive anything else other than OnEncryptionChange.
1835 EXPECT_EQ(1, status_handler().call_count());
1836 ASSERT_TRUE(status_handler().status());
1837 EXPECT_EQ(ToResult(HostError::kNotSupported), status_handler().status());
1838 }
1839 }
1840
TEST_P(HandlesEvent,InWaitEncryptionStateAsResponderForBonded)1841 TEST_P(HandlesEvent, InWaitEncryptionStateAsResponderForBonded) {
1842 // We are previously bonded.
1843 auto existing_link_key = sm::LTK(
1844 sm::SecurityProperties(kTestUnauthenticatedLinkKeyType192), kTestLinkKey);
1845 peer()->MutBrEdr().SetBondData(existing_link_key);
1846
1847 // Advance state machine.
1848 static_cast<void>(pairing_state().OnLinkKeyRequest());
1849 ASSERT_FALSE(pairing_state().initiator());
1850
1851 RETURN_IF_FATAL(InjectEvent());
1852
1853 if (event() == IoCapabilityResponse) {
1854 // This re-starts the pairing as a responder.
1855 EXPECT_EQ(0, status_handler().call_count());
1856 } else {
1857 // Should not receive anything else other than OnEncryptionChange, receiving
1858 // anything else is a failure.
1859 EXPECT_EQ(1, status_handler().call_count());
1860 ASSERT_TRUE(status_handler().status());
1861 EXPECT_EQ(ToResult(HostError::kNotSupported), status_handler().status());
1862 }
1863 }
1864
TEST_P(HandlesEvent,InIdleStateAfterOnePairing)1865 TEST_P(HandlesEvent, InIdleStateAfterOnePairing) {
1866 // Advance state machine.
1867 static_cast<void>(pairing_state().InitiatePairing(kNoSecurityRequirements,
1868 NoOpStatusCallback));
1869 static_cast<void>(pairing_state().OnLinkKeyRequest());
1870 static_cast<void>(pairing_state().OnIoCapabilityRequest());
1871 pairing_state().OnIoCapabilityResponse(kTestPeerIoCap);
1872 pairing_state().OnUserConfirmationRequest(kTestPasskey,
1873 NoOpUserConfirmationCallback);
1874 pairing_state().OnSimplePairingComplete(
1875 pw::bluetooth::emboss::StatusCode::SUCCESS);
1876 pairing_state().OnLinkKeyNotification(kTestLinkKeyValue,
1877 kTestUnauthenticatedLinkKeyType192);
1878 pairing_state().OnAuthenticationComplete(
1879 pw::bluetooth::emboss::StatusCode::SUCCESS);
1880 ASSERT_TRUE(pairing_state().initiator());
1881
1882 // Successfully enabling encryption should allow pairing to start again.
1883 pairing_state().OnEncryptionChange(fit::ok(true));
1884 EXPECT_EQ(1, status_handler().call_count());
1885 ASSERT_TRUE(status_handler().status());
1886 EXPECT_EQ(fit::ok(), *status_handler().status());
1887 EXPECT_FALSE(pairing_state().initiator());
1888
1889 RETURN_IF_FATAL(InjectEvent());
1890 if (event() == LinkKeyRequest || event() == IoCapabilityResponse) {
1891 EXPECT_EQ(1, status_handler().call_count());
1892 } else {
1893 EXPECT_EQ(2, status_handler().call_count());
1894 ASSERT_TRUE(status_handler().status());
1895 EXPECT_EQ(ToResult(HostError::kNotSupported), status_handler().status());
1896 }
1897 }
1898
TEST_P(HandlesEvent,InFailedStateAfterPairingFailed)1899 TEST_P(HandlesEvent, InFailedStateAfterPairingFailed) {
1900 // Advance state machine.
1901 pairing_state().OnIoCapabilityResponse(kTestPeerIoCap);
1902 static_cast<void>(pairing_state().OnIoCapabilityRequest());
1903 pairing_state().OnUserConfirmationRequest(kTestPasskey,
1904 NoOpUserConfirmationCallback);
1905
1906 // Inject failure status.
1907 pairing_state().OnSimplePairingComplete(
1908 pw::bluetooth::emboss::StatusCode::AUTHENTICATION_FAILURE);
1909 EXPECT_EQ(1, status_handler().call_count());
1910 ASSERT_TRUE(status_handler().status());
1911 EXPECT_FALSE(status_handler().status()->is_ok());
1912
1913 RETURN_IF_FATAL(InjectEvent());
1914 EXPECT_EQ(2, status_handler().call_count());
1915 ASSERT_TRUE(status_handler().status());
1916 EXPECT_EQ(ToResult(HostError::kNotSupported), status_handler().status());
1917 }
1918
TEST_P(HandlesEvent,InFailedStateAfterAuthenticationFailed)1919 TEST_P(HandlesEvent, InFailedStateAfterAuthenticationFailed) {
1920 // Advance state machine.
1921 static_cast<void>(pairing_state().InitiatePairing(kNoSecurityRequirements,
1922 NoOpStatusCallback));
1923 static_cast<void>(pairing_state().OnLinkKeyRequest());
1924 static_cast<void>(pairing_state().OnIoCapabilityRequest());
1925 pairing_state().OnIoCapabilityResponse(kTestPeerIoCap);
1926 pairing_state().OnUserConfirmationRequest(kTestPasskey,
1927 NoOpUserConfirmationCallback);
1928 pairing_state().OnSimplePairingComplete(
1929 pw::bluetooth::emboss::StatusCode::SUCCESS);
1930 pairing_state().OnLinkKeyNotification(kTestLinkKeyValue,
1931 kTestUnauthenticatedLinkKeyType192);
1932
1933 // Inject failure status.
1934 pairing_state().OnAuthenticationComplete(
1935 pw::bluetooth::emboss::StatusCode::AUTHENTICATION_FAILURE);
1936 EXPECT_EQ(1, status_handler().call_count());
1937 ASSERT_TRUE(status_handler().status());
1938 EXPECT_FALSE(status_handler().status()->is_ok());
1939
1940 RETURN_IF_FATAL(InjectEvent());
1941 EXPECT_EQ(2, status_handler().call_count());
1942 ASSERT_TRUE(status_handler().status());
1943 EXPECT_EQ(ToResult(HostError::kNotSupported), status_handler().status());
1944 }
1945
1946 // PairingAction expected answers are inferred from "device A" Authentication
1947 // Stage 1 specs in v5.0 Vol 3, Part C, Sec 5.2.2.6, Table 5.7.
TEST_F(PairingStateTest,GetInitiatorPairingAction)1948 TEST_F(PairingStateTest, GetInitiatorPairingAction) {
1949 EXPECT_EQ(PairingAction::kAutomatic,
1950 GetInitiatorPairingAction(IoCapability::DISPLAY_ONLY,
1951 IoCapability::DISPLAY_ONLY));
1952 EXPECT_EQ(PairingAction::kDisplayPasskey,
1953 GetInitiatorPairingAction(IoCapability::DISPLAY_ONLY,
1954 IoCapability::DISPLAY_YES_NO));
1955 EXPECT_EQ(PairingAction::kDisplayPasskey,
1956 GetInitiatorPairingAction(IoCapability::DISPLAY_ONLY,
1957 IoCapability::KEYBOARD_ONLY));
1958 EXPECT_EQ(PairingAction::kAutomatic,
1959 GetInitiatorPairingAction(IoCapability::DISPLAY_ONLY,
1960 IoCapability::NO_INPUT_NO_OUTPUT));
1961
1962 EXPECT_EQ(PairingAction::kComparePasskey,
1963 GetInitiatorPairingAction(IoCapability::DISPLAY_YES_NO,
1964 IoCapability::DISPLAY_ONLY));
1965 EXPECT_EQ(PairingAction::kDisplayPasskey,
1966 GetInitiatorPairingAction(IoCapability::DISPLAY_YES_NO,
1967 IoCapability::DISPLAY_YES_NO));
1968 EXPECT_EQ(PairingAction::kDisplayPasskey,
1969 GetInitiatorPairingAction(IoCapability::DISPLAY_YES_NO,
1970 IoCapability::KEYBOARD_ONLY));
1971 EXPECT_EQ(PairingAction::kGetConsent,
1972 GetInitiatorPairingAction(IoCapability::DISPLAY_YES_NO,
1973 IoCapability::NO_INPUT_NO_OUTPUT));
1974
1975 EXPECT_EQ(PairingAction::kRequestPasskey,
1976 GetInitiatorPairingAction(IoCapability::KEYBOARD_ONLY,
1977 IoCapability::DISPLAY_ONLY));
1978 EXPECT_EQ(PairingAction::kRequestPasskey,
1979 GetInitiatorPairingAction(IoCapability::KEYBOARD_ONLY,
1980 IoCapability::DISPLAY_YES_NO));
1981 EXPECT_EQ(PairingAction::kRequestPasskey,
1982 GetInitiatorPairingAction(IoCapability::KEYBOARD_ONLY,
1983 IoCapability::KEYBOARD_ONLY));
1984 EXPECT_EQ(PairingAction::kAutomatic,
1985 GetInitiatorPairingAction(IoCapability::KEYBOARD_ONLY,
1986 IoCapability::NO_INPUT_NO_OUTPUT));
1987
1988 EXPECT_EQ(PairingAction::kAutomatic,
1989 GetInitiatorPairingAction(IoCapability::NO_INPUT_NO_OUTPUT,
1990 IoCapability::DISPLAY_ONLY));
1991 EXPECT_EQ(PairingAction::kAutomatic,
1992 GetInitiatorPairingAction(IoCapability::NO_INPUT_NO_OUTPUT,
1993 IoCapability::DISPLAY_YES_NO));
1994 EXPECT_EQ(PairingAction::kAutomatic,
1995 GetInitiatorPairingAction(IoCapability::NO_INPUT_NO_OUTPUT,
1996 IoCapability::KEYBOARD_ONLY));
1997 EXPECT_EQ(PairingAction::kAutomatic,
1998 GetInitiatorPairingAction(IoCapability::NO_INPUT_NO_OUTPUT,
1999 IoCapability::NO_INPUT_NO_OUTPUT));
2000 }
2001
2002 // Ibid., but for "device B."
TEST_F(PairingStateTest,GetResponderPairingAction)2003 TEST_F(PairingStateTest, GetResponderPairingAction) {
2004 EXPECT_EQ(PairingAction::kAutomatic,
2005 GetResponderPairingAction(IoCapability::DISPLAY_ONLY,
2006 IoCapability::DISPLAY_ONLY));
2007 EXPECT_EQ(PairingAction::kComparePasskey,
2008 GetResponderPairingAction(IoCapability::DISPLAY_ONLY,
2009 IoCapability::DISPLAY_YES_NO));
2010 EXPECT_EQ(PairingAction::kRequestPasskey,
2011 GetResponderPairingAction(IoCapability::DISPLAY_ONLY,
2012 IoCapability::KEYBOARD_ONLY));
2013 EXPECT_EQ(PairingAction::kAutomatic,
2014 GetResponderPairingAction(IoCapability::DISPLAY_ONLY,
2015 IoCapability::NO_INPUT_NO_OUTPUT));
2016
2017 EXPECT_EQ(PairingAction::kDisplayPasskey,
2018 GetResponderPairingAction(IoCapability::DISPLAY_YES_NO,
2019 IoCapability::DISPLAY_ONLY));
2020 EXPECT_EQ(PairingAction::kComparePasskey,
2021 GetResponderPairingAction(IoCapability::DISPLAY_YES_NO,
2022 IoCapability::DISPLAY_YES_NO));
2023 EXPECT_EQ(PairingAction::kRequestPasskey,
2024 GetResponderPairingAction(IoCapability::DISPLAY_YES_NO,
2025 IoCapability::KEYBOARD_ONLY));
2026 EXPECT_EQ(PairingAction::kAutomatic,
2027 GetResponderPairingAction(IoCapability::DISPLAY_YES_NO,
2028 IoCapability::NO_INPUT_NO_OUTPUT));
2029
2030 EXPECT_EQ(PairingAction::kDisplayPasskey,
2031 GetResponderPairingAction(IoCapability::KEYBOARD_ONLY,
2032 IoCapability::DISPLAY_ONLY));
2033 EXPECT_EQ(PairingAction::kDisplayPasskey,
2034 GetResponderPairingAction(IoCapability::KEYBOARD_ONLY,
2035 IoCapability::DISPLAY_YES_NO));
2036 EXPECT_EQ(PairingAction::kRequestPasskey,
2037 GetResponderPairingAction(IoCapability::KEYBOARD_ONLY,
2038 IoCapability::KEYBOARD_ONLY));
2039 EXPECT_EQ(PairingAction::kAutomatic,
2040 GetResponderPairingAction(IoCapability::KEYBOARD_ONLY,
2041 IoCapability::NO_INPUT_NO_OUTPUT));
2042
2043 EXPECT_EQ(PairingAction::kAutomatic,
2044 GetResponderPairingAction(IoCapability::NO_INPUT_NO_OUTPUT,
2045 IoCapability::DISPLAY_ONLY));
2046 EXPECT_EQ(PairingAction::kGetConsent,
2047 GetResponderPairingAction(IoCapability::NO_INPUT_NO_OUTPUT,
2048 IoCapability::DISPLAY_YES_NO));
2049 EXPECT_EQ(PairingAction::kGetConsent,
2050 GetResponderPairingAction(IoCapability::NO_INPUT_NO_OUTPUT,
2051 IoCapability::KEYBOARD_ONLY));
2052 EXPECT_EQ(PairingAction::kAutomatic,
2053 GetResponderPairingAction(IoCapability::NO_INPUT_NO_OUTPUT,
2054 IoCapability::NO_INPUT_NO_OUTPUT));
2055 }
2056
2057 // Events are obtained from ibid. association models, mapped to HCI sequences in
2058 // v5.0 Vol 3, Vol 2, Part F, Sec 4.2.10–15.
TEST_F(PairingStateTest,GetExpectedEvent)2059 TEST_F(PairingStateTest, GetExpectedEvent) {
2060 EXPECT_EQ(
2061 kUserConfirmationRequestEventCode,
2062 GetExpectedEvent(IoCapability::DISPLAY_ONLY, IoCapability::DISPLAY_ONLY));
2063 EXPECT_EQ(kUserConfirmationRequestEventCode,
2064 GetExpectedEvent(IoCapability::DISPLAY_ONLY,
2065 IoCapability::DISPLAY_YES_NO));
2066 EXPECT_EQ(kUserPasskeyNotificationEventCode,
2067 GetExpectedEvent(IoCapability::DISPLAY_ONLY,
2068 IoCapability::KEYBOARD_ONLY));
2069 EXPECT_EQ(kUserConfirmationRequestEventCode,
2070 GetExpectedEvent(IoCapability::DISPLAY_ONLY,
2071 IoCapability::NO_INPUT_NO_OUTPUT));
2072
2073 EXPECT_EQ(kUserConfirmationRequestEventCode,
2074 GetExpectedEvent(IoCapability::DISPLAY_YES_NO,
2075 IoCapability::DISPLAY_ONLY));
2076 EXPECT_EQ(kUserConfirmationRequestEventCode,
2077 GetExpectedEvent(IoCapability::DISPLAY_YES_NO,
2078 IoCapability::DISPLAY_YES_NO));
2079 EXPECT_EQ(kUserPasskeyNotificationEventCode,
2080 GetExpectedEvent(IoCapability::DISPLAY_YES_NO,
2081 IoCapability::KEYBOARD_ONLY));
2082 EXPECT_EQ(kUserConfirmationRequestEventCode,
2083 GetExpectedEvent(IoCapability::DISPLAY_YES_NO,
2084 IoCapability::NO_INPUT_NO_OUTPUT));
2085
2086 EXPECT_EQ(kUserPasskeyRequestEventCode,
2087 GetExpectedEvent(IoCapability::KEYBOARD_ONLY,
2088 IoCapability::DISPLAY_ONLY));
2089 EXPECT_EQ(kUserPasskeyRequestEventCode,
2090 GetExpectedEvent(IoCapability::KEYBOARD_ONLY,
2091 IoCapability::DISPLAY_YES_NO));
2092 EXPECT_EQ(kUserPasskeyRequestEventCode,
2093 GetExpectedEvent(IoCapability::KEYBOARD_ONLY,
2094 IoCapability::KEYBOARD_ONLY));
2095 EXPECT_EQ(kUserConfirmationRequestEventCode,
2096 GetExpectedEvent(IoCapability::KEYBOARD_ONLY,
2097 IoCapability::NO_INPUT_NO_OUTPUT));
2098
2099 EXPECT_EQ(kUserConfirmationRequestEventCode,
2100 GetExpectedEvent(IoCapability::NO_INPUT_NO_OUTPUT,
2101 IoCapability::DISPLAY_ONLY));
2102 EXPECT_EQ(kUserConfirmationRequestEventCode,
2103 GetExpectedEvent(IoCapability::NO_INPUT_NO_OUTPUT,
2104 IoCapability::DISPLAY_YES_NO));
2105 EXPECT_EQ(kUserConfirmationRequestEventCode,
2106 GetExpectedEvent(IoCapability::NO_INPUT_NO_OUTPUT,
2107 IoCapability::KEYBOARD_ONLY));
2108 EXPECT_EQ(kUserConfirmationRequestEventCode,
2109 GetExpectedEvent(IoCapability::NO_INPUT_NO_OUTPUT,
2110 IoCapability::NO_INPUT_NO_OUTPUT));
2111 }
2112
2113 // Level of authentication from ibid. table.
TEST_F(PairingStateTest,IsPairingAuthenticated)2114 TEST_F(PairingStateTest, IsPairingAuthenticated) {
2115 EXPECT_FALSE(IsPairingAuthenticated(IoCapability::DISPLAY_ONLY,
2116 IoCapability::DISPLAY_ONLY));
2117 EXPECT_FALSE(IsPairingAuthenticated(IoCapability::DISPLAY_ONLY,
2118 IoCapability::DISPLAY_YES_NO));
2119 EXPECT_TRUE(IsPairingAuthenticated(IoCapability::DISPLAY_ONLY,
2120 IoCapability::KEYBOARD_ONLY));
2121 EXPECT_FALSE(IsPairingAuthenticated(IoCapability::DISPLAY_ONLY,
2122 IoCapability::NO_INPUT_NO_OUTPUT));
2123
2124 EXPECT_FALSE(IsPairingAuthenticated(IoCapability::DISPLAY_YES_NO,
2125 IoCapability::DISPLAY_ONLY));
2126 EXPECT_TRUE(IsPairingAuthenticated(IoCapability::DISPLAY_YES_NO,
2127 IoCapability::DISPLAY_YES_NO));
2128 EXPECT_TRUE(IsPairingAuthenticated(IoCapability::DISPLAY_YES_NO,
2129 IoCapability::KEYBOARD_ONLY));
2130 EXPECT_FALSE(IsPairingAuthenticated(IoCapability::DISPLAY_YES_NO,
2131 IoCapability::NO_INPUT_NO_OUTPUT));
2132
2133 EXPECT_TRUE(IsPairingAuthenticated(IoCapability::KEYBOARD_ONLY,
2134 IoCapability::DISPLAY_ONLY));
2135 EXPECT_TRUE(IsPairingAuthenticated(IoCapability::KEYBOARD_ONLY,
2136 IoCapability::DISPLAY_YES_NO));
2137 EXPECT_TRUE(IsPairingAuthenticated(IoCapability::KEYBOARD_ONLY,
2138 IoCapability::KEYBOARD_ONLY));
2139 EXPECT_FALSE(IsPairingAuthenticated(IoCapability::KEYBOARD_ONLY,
2140 IoCapability::NO_INPUT_NO_OUTPUT));
2141
2142 EXPECT_FALSE(IsPairingAuthenticated(IoCapability::NO_INPUT_NO_OUTPUT,
2143 IoCapability::DISPLAY_ONLY));
2144 EXPECT_FALSE(IsPairingAuthenticated(IoCapability::NO_INPUT_NO_OUTPUT,
2145 IoCapability::DISPLAY_YES_NO));
2146 EXPECT_FALSE(IsPairingAuthenticated(IoCapability::NO_INPUT_NO_OUTPUT,
2147 IoCapability::KEYBOARD_ONLY));
2148 EXPECT_FALSE(IsPairingAuthenticated(IoCapability::NO_INPUT_NO_OUTPUT,
2149 IoCapability::NO_INPUT_NO_OUTPUT));
2150 }
2151
TEST_F(PairingStateTest,GetInitiatorAuthenticationRequirements)2152 TEST_F(PairingStateTest, GetInitiatorAuthenticationRequirements) {
2153 EXPECT_EQ(AuthenticationRequirements::MITM_GENERAL_BONDING,
2154 GetInitiatorAuthenticationRequirements(IoCapability::DISPLAY_ONLY));
2155 EXPECT_EQ(
2156 AuthenticationRequirements::MITM_GENERAL_BONDING,
2157 GetInitiatorAuthenticationRequirements(IoCapability::DISPLAY_YES_NO));
2158 EXPECT_EQ(
2159 AuthenticationRequirements::MITM_GENERAL_BONDING,
2160 GetInitiatorAuthenticationRequirements(IoCapability::KEYBOARD_ONLY));
2161 EXPECT_EQ(
2162 AuthenticationRequirements::GENERAL_BONDING,
2163 GetInitiatorAuthenticationRequirements(IoCapability::NO_INPUT_NO_OUTPUT));
2164 }
2165
TEST_F(PairingStateTest,GetResponderAuthenticationRequirements)2166 TEST_F(PairingStateTest, GetResponderAuthenticationRequirements) {
2167 EXPECT_EQ(AuthenticationRequirements::GENERAL_BONDING,
2168 GetResponderAuthenticationRequirements(IoCapability::DISPLAY_ONLY,
2169 IoCapability::DISPLAY_ONLY));
2170 EXPECT_EQ(AuthenticationRequirements::GENERAL_BONDING,
2171 GetResponderAuthenticationRequirements(
2172 IoCapability::DISPLAY_ONLY, IoCapability::DISPLAY_YES_NO));
2173 EXPECT_EQ(AuthenticationRequirements::MITM_GENERAL_BONDING,
2174 GetResponderAuthenticationRequirements(
2175 IoCapability::DISPLAY_ONLY, IoCapability::KEYBOARD_ONLY));
2176 EXPECT_EQ(AuthenticationRequirements::GENERAL_BONDING,
2177 GetResponderAuthenticationRequirements(
2178 IoCapability::DISPLAY_ONLY, IoCapability::NO_INPUT_NO_OUTPUT));
2179
2180 EXPECT_EQ(AuthenticationRequirements::GENERAL_BONDING,
2181 GetResponderAuthenticationRequirements(IoCapability::DISPLAY_YES_NO,
2182 IoCapability::DISPLAY_ONLY));
2183 EXPECT_EQ(AuthenticationRequirements::MITM_GENERAL_BONDING,
2184 GetResponderAuthenticationRequirements(
2185 IoCapability::DISPLAY_YES_NO, IoCapability::DISPLAY_YES_NO));
2186 EXPECT_EQ(AuthenticationRequirements::MITM_GENERAL_BONDING,
2187 GetResponderAuthenticationRequirements(
2188 IoCapability::DISPLAY_YES_NO, IoCapability::KEYBOARD_ONLY));
2189 EXPECT_EQ(
2190 AuthenticationRequirements::GENERAL_BONDING,
2191 GetResponderAuthenticationRequirements(IoCapability::DISPLAY_YES_NO,
2192 IoCapability::NO_INPUT_NO_OUTPUT));
2193
2194 EXPECT_EQ(AuthenticationRequirements::MITM_GENERAL_BONDING,
2195 GetResponderAuthenticationRequirements(IoCapability::KEYBOARD_ONLY,
2196 IoCapability::DISPLAY_ONLY));
2197 EXPECT_EQ(AuthenticationRequirements::MITM_GENERAL_BONDING,
2198 GetResponderAuthenticationRequirements(
2199 IoCapability::KEYBOARD_ONLY, IoCapability::DISPLAY_YES_NO));
2200 EXPECT_EQ(AuthenticationRequirements::MITM_GENERAL_BONDING,
2201 GetResponderAuthenticationRequirements(
2202 IoCapability::KEYBOARD_ONLY, IoCapability::KEYBOARD_ONLY));
2203 EXPECT_EQ(AuthenticationRequirements::GENERAL_BONDING,
2204 GetResponderAuthenticationRequirements(
2205 IoCapability::KEYBOARD_ONLY, IoCapability::NO_INPUT_NO_OUTPUT));
2206
2207 EXPECT_EQ(AuthenticationRequirements::GENERAL_BONDING,
2208 GetResponderAuthenticationRequirements(
2209 IoCapability::NO_INPUT_NO_OUTPUT, IoCapability::DISPLAY_ONLY));
2210 EXPECT_EQ(
2211 AuthenticationRequirements::GENERAL_BONDING,
2212 GetResponderAuthenticationRequirements(IoCapability::NO_INPUT_NO_OUTPUT,
2213 IoCapability::DISPLAY_YES_NO));
2214 EXPECT_EQ(AuthenticationRequirements::GENERAL_BONDING,
2215 GetResponderAuthenticationRequirements(
2216 IoCapability::NO_INPUT_NO_OUTPUT, IoCapability::KEYBOARD_ONLY));
2217 EXPECT_EQ(
2218 AuthenticationRequirements::GENERAL_BONDING,
2219 GetResponderAuthenticationRequirements(IoCapability::NO_INPUT_NO_OUTPUT,
2220 IoCapability::NO_INPUT_NO_OUTPUT));
2221 }
2222
TEST_F(PairingStateTest,SkipPairingIfExistingKeyMeetsSecurityRequirements)2223 TEST_F(PairingStateTest, SkipPairingIfExistingKeyMeetsSecurityRequirements) {
2224 TestStatusHandler status_handler;
2225
2226 PairingState pairing_state(peer()->GetWeakPtr(),
2227 connection(),
2228 /*link_initiated=*/false,
2229 MakeAuthRequestCallback(),
2230 status_handler.MakeStatusCallback());
2231 NoOpPairingDelegate pairing_delegate(sm::IOCapability::kNoInputNoOutput);
2232 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
2233
2234 connection()->set_link_key(kTestLinkKey, kTestAuthenticatedLinkKeyType192);
2235
2236 constexpr BrEdrSecurityRequirements kSecurityRequirements{
2237 .authentication = true, .secure_connections = false};
2238 TestStatusHandler initiator_status_handler;
2239 pairing_state.InitiatePairing(kSecurityRequirements,
2240 initiator_status_handler.MakeStatusCallback());
2241 EXPECT_EQ(0u, auth_request_count());
2242 EXPECT_FALSE(pairing_state.initiator());
2243 EXPECT_EQ(0, status_handler.call_count());
2244 ASSERT_EQ(1, initiator_status_handler.call_count());
2245 EXPECT_EQ(fit::ok(), *initiator_status_handler.status());
2246 }
2247
TEST_F(PairingStateTest,InitiatorAuthRequiredCausesOnLinkKeyRequestToReturnNullIfUnauthenticatedKeyExists)2248 TEST_F(
2249 PairingStateTest,
2250 InitiatorAuthRequiredCausesOnLinkKeyRequestToReturnNullIfUnauthenticatedKeyExists) {
2251 TestStatusHandler status_handler;
2252
2253 PairingState pairing_state(peer()->GetWeakPtr(),
2254 connection(),
2255 /*link_initiated=*/false,
2256 MakeAuthRequestCallback(),
2257 status_handler.MakeStatusCallback());
2258 NoOpPairingDelegate pairing_delegate(sm::IOCapability::kNoInputNoOutput);
2259 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
2260
2261 BrEdrSecurityRequirements security{.authentication = true,
2262 .secure_connections = false};
2263 pairing_state.InitiatePairing(security, status_handler.MakeStatusCallback());
2264
2265 peer()->MutBrEdr().SetBondData(
2266 sm::LTK(sm::SecurityProperties(kTestUnauthenticatedLinkKeyType192),
2267 kTestLinkKey));
2268
2269 EXPECT_EQ(std::nullopt, pairing_state.OnLinkKeyRequest());
2270 EXPECT_EQ(0, status_handler.call_count());
2271 }
2272
TEST_F(PairingStateTest,InitiatorNoSecurityRequirementsCausesOnLinkKeyRequestToReturnExistingKey)2273 TEST_F(
2274 PairingStateTest,
2275 InitiatorNoSecurityRequirementsCausesOnLinkKeyRequestToReturnExistingKey) {
2276 TestStatusHandler status_handler;
2277
2278 PairingState pairing_state(peer()->GetWeakPtr(),
2279 connection(),
2280 /*link_initiated=*/false,
2281 MakeAuthRequestCallback(),
2282 status_handler.MakeStatusCallback());
2283 NoOpPairingDelegate pairing_delegate(sm::IOCapability::kNoInputNoOutput);
2284 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
2285
2286 pairing_state.InitiatePairing(kNoSecurityRequirements, NoOpStatusCallback);
2287
2288 peer()->MutBrEdr().SetBondData(
2289 sm::LTK(sm::SecurityProperties(kTestUnauthenticatedLinkKeyType192),
2290 kTestLinkKey));
2291 EXPECT_FALSE(connection()->ltk().has_value());
2292
2293 auto reply_key = pairing_state.OnLinkKeyRequest();
2294 ASSERT_TRUE(reply_key.has_value());
2295 EXPECT_EQ(kTestLinkKey, reply_key.value());
2296 EXPECT_EQ(0, status_handler.call_count());
2297 EXPECT_TRUE(connection()->ltk().has_value());
2298 }
2299
TEST_F(PairingStateTest,InitiatorOnLinkKeyRequestReturnsNullIfBondDataDoesNotExist)2300 TEST_F(PairingStateTest,
2301 InitiatorOnLinkKeyRequestReturnsNullIfBondDataDoesNotExist) {
2302 TestStatusHandler status_handler;
2303
2304 PairingState pairing_state(peer()->GetWeakPtr(),
2305 connection(),
2306 /*link_initiated=*/false,
2307 MakeAuthRequestCallback(),
2308 status_handler.MakeStatusCallback());
2309 NoOpPairingDelegate pairing_delegate(sm::IOCapability::kNoInputNoOutput);
2310 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
2311
2312 pairing_state.InitiatePairing(kNoSecurityRequirements, NoOpStatusCallback);
2313
2314 auto reply_key = pairing_state.OnLinkKeyRequest();
2315 EXPECT_FALSE(reply_key.has_value());
2316 EXPECT_EQ(0, status_handler.call_count());
2317 }
2318
TEST_F(PairingStateTest,IdleStateOnLinkKeyRequestReturnsLinkKeyWhenBondDataExists)2319 TEST_F(PairingStateTest,
2320 IdleStateOnLinkKeyRequestReturnsLinkKeyWhenBondDataExists) {
2321 TestStatusHandler status_handler;
2322
2323 PairingState pairing_state(peer()->GetWeakPtr(),
2324 connection(),
2325 /*link_initiated=*/false,
2326 MakeAuthRequestCallback(),
2327 status_handler.MakeStatusCallback());
2328 NoOpPairingDelegate pairing_delegate(sm::IOCapability::kNoInputNoOutput);
2329 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
2330
2331 peer()->MutBrEdr().SetBondData(
2332 sm::LTK(sm::SecurityProperties(kTestUnauthenticatedLinkKeyType192),
2333 kTestLinkKey));
2334 EXPECT_FALSE(connection()->ltk().has_value());
2335
2336 auto reply_key = pairing_state.OnLinkKeyRequest();
2337 ASSERT_TRUE(reply_key.has_value());
2338 EXPECT_EQ(kTestLinkKey, reply_key.value());
2339 EXPECT_EQ(0, status_handler.call_count());
2340 EXPECT_TRUE(connection()->ltk().has_value());
2341 }
2342
TEST_F(PairingStateTest,IdleStateOnLinkKeyRequestReturnsNullWhenBondDataDoesNotExist)2343 TEST_F(PairingStateTest,
2344 IdleStateOnLinkKeyRequestReturnsNullWhenBondDataDoesNotExist) {
2345 TestStatusHandler status_handler;
2346
2347 PairingState pairing_state(peer()->GetWeakPtr(),
2348 connection(),
2349 /*link_initiated=*/false,
2350 MakeAuthRequestCallback(),
2351 status_handler.MakeStatusCallback());
2352 NoOpPairingDelegate pairing_delegate(sm::IOCapability::kNoInputNoOutput);
2353 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
2354
2355 auto reply_key = pairing_state.OnLinkKeyRequest();
2356 EXPECT_FALSE(reply_key.has_value());
2357 EXPECT_EQ(0, status_handler.call_count());
2358 }
2359
TEST_F(PairingStateTest,SimplePairingCompleteWithErrorCodeReceivedEarlyFailsPairing)2360 TEST_F(PairingStateTest,
2361 SimplePairingCompleteWithErrorCodeReceivedEarlyFailsPairing) {
2362 TestStatusHandler status_handler;
2363
2364 PairingState pairing_state(peer()->GetWeakPtr(),
2365 connection(),
2366 /*link_initiated=*/false,
2367 MakeAuthRequestCallback(),
2368 status_handler.MakeStatusCallback());
2369 NoOpPairingDelegate pairing_delegate(sm::IOCapability::kNoInputNoOutput);
2370 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
2371
2372 pairing_state.InitiatePairing(kNoSecurityRequirements, NoOpStatusCallback);
2373
2374 EXPECT_EQ(std::nullopt, pairing_state.OnLinkKeyRequest());
2375 EXPECT_EQ(IoCapability::NO_INPUT_NO_OUTPUT,
2376 *pairing_state.OnIoCapabilityRequest());
2377 EXPECT_EQ(0, status_handler.call_count());
2378
2379 const auto status_code =
2380 pw::bluetooth::emboss::StatusCode::PAIRING_NOT_ALLOWED;
2381 pairing_state.OnSimplePairingComplete(status_code);
2382 ASSERT_EQ(1, status_handler.call_count());
2383 EXPECT_EQ(ToResult(status_code), status_handler.status().value());
2384 }
2385
TEST_F(PairingStateDeathTest,OnLinkKeyRequestReceivedMissingPeerAsserts)2386 TEST_F(PairingStateDeathTest, OnLinkKeyRequestReceivedMissingPeerAsserts) {
2387 TestStatusHandler status_handler;
2388
2389 PairingState pairing_state(peer()->GetWeakPtr(),
2390 connection(),
2391 /*link_initiated=*/false,
2392 MakeAuthRequestCallback(),
2393 status_handler.MakeStatusCallback());
2394 NoOpPairingDelegate pairing_delegate(sm::IOCapability::kNoInputNoOutput);
2395 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
2396
2397 pairing_state.InitiatePairing(kNoSecurityRequirements, NoOpStatusCallback);
2398
2399 EXPECT_TRUE(peer_cache()->RemoveDisconnectedPeer(peer()->identifier()));
2400
2401 ASSERT_DEATH_IF_SUPPORTED(
2402 { [[maybe_unused]] auto reply_key = pairing_state.OnLinkKeyRequest(); },
2403 ".*peer.*");
2404 }
2405
TEST_F(PairingStateTest,AuthenticationCompleteWithErrorCodeReceivedEarlyFailsPairing)2406 TEST_F(PairingStateTest,
2407 AuthenticationCompleteWithErrorCodeReceivedEarlyFailsPairing) {
2408 TestStatusHandler status_handler;
2409
2410 PairingState pairing_state(peer()->GetWeakPtr(),
2411 connection(),
2412 /*link_initiated=*/false,
2413 MakeAuthRequestCallback(),
2414 status_handler.MakeStatusCallback());
2415 NoOpPairingDelegate pairing_delegate(sm::IOCapability::kNoInputNoOutput);
2416 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
2417
2418 pairing_state.InitiatePairing(kNoSecurityRequirements, NoOpStatusCallback);
2419
2420 EXPECT_EQ(std::nullopt, pairing_state.OnLinkKeyRequest());
2421 EXPECT_EQ(0, status_handler.call_count());
2422
2423 const auto status_code =
2424 pw::bluetooth::emboss::StatusCode::AUTHENTICATION_FAILURE;
2425 pairing_state.OnAuthenticationComplete(status_code);
2426 ASSERT_EQ(1, status_handler.call_count());
2427 EXPECT_EQ(ToResult(status_code), status_handler.status().value());
2428 }
2429
TEST_F(PairingStateTest,AuthenticationCompleteWithMissingKeyRetriesWithoutKeyAndDoesntAutoConfirmRejected)2430 TEST_F(
2431 PairingStateTest,
2432 AuthenticationCompleteWithMissingKeyRetriesWithoutKeyAndDoesntAutoConfirmRejected) {
2433 TestStatusHandler status_handler;
2434
2435 PairingState pairing_state(peer()->GetWeakPtr(),
2436 connection(),
2437 /*link_initiated=*/true,
2438 MakeAuthRequestCallback(),
2439 status_handler.MakeStatusCallback());
2440 FakePairingDelegate pairing_delegate(sm::IOCapability::kNoInputNoOutput);
2441 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
2442
2443 auto existing_link_key = sm::LTK(
2444 sm::SecurityProperties(kTestUnauthenticatedLinkKeyType192), kTestLinkKey);
2445
2446 peer()->MutBrEdr().SetBondData(existing_link_key);
2447 EXPECT_FALSE(connection()->ltk().has_value());
2448
2449 pairing_state.InitiatePairing(kNoSecurityRequirements, NoOpStatusCallback);
2450 EXPECT_EQ(1u, auth_request_count());
2451
2452 auto reply_key = pairing_state.OnLinkKeyRequest();
2453 ASSERT_TRUE(reply_key.has_value());
2454 EXPECT_EQ(kTestLinkKey, reply_key.value());
2455 EXPECT_EQ(0, status_handler.call_count());
2456
2457 // Peer says that they don't have a key.
2458 pairing_state.OnAuthenticationComplete(
2459 pw::bluetooth::emboss::StatusCode::PIN_OR_KEY_MISSING);
2460 ASSERT_EQ(0, status_handler.call_count());
2461 // We should retry the authentication request, this time pretending we don't
2462 // have a key.
2463 EXPECT_EQ(2u, auth_request_count());
2464
2465 EXPECT_EQ(std::nullopt, pairing_state.OnLinkKeyRequest());
2466 EXPECT_EQ(0, status_handler.call_count());
2467
2468 static_cast<void>(pairing_state.OnIoCapabilityRequest());
2469 pairing_state.OnIoCapabilityResponse(IoCapability::NO_INPUT_NO_OUTPUT);
2470 pairing_delegate.SetConfirmPairingCallback([this](PeerId peer_id, auto cb) {
2471 EXPECT_EQ(peer()->identifier(), peer_id);
2472 ASSERT_TRUE(cb);
2473 cb(false);
2474 });
2475 bool confirmed = true;
2476 pairing_state.OnUserConfirmationRequest(
2477 kTestPasskey, [&confirmed](bool confirm) { confirmed = confirm; });
2478
2479 EXPECT_FALSE(confirmed);
2480
2481 pairing_delegate.SetCompletePairingCallback(
2482 [this](PeerId peer_id, sm::Result<> status) {
2483 EXPECT_EQ(peer()->identifier(), peer_id);
2484 EXPECT_TRUE(status.is_error());
2485 });
2486
2487 // The controller sends a SimplePairingComplete indicating the failure after
2488 // we send a Negative Confirmation.
2489 const auto status_code =
2490 pw::bluetooth::emboss::StatusCode::AUTHENTICATION_FAILURE;
2491 pairing_state.OnSimplePairingComplete(status_code);
2492
2493 // The bonding key should not have been touched.
2494 EXPECT_EQ(existing_link_key, peer()->bredr()->link_key());
2495
2496 EXPECT_EQ(1, status_handler.call_count());
2497 ASSERT_TRUE(status_handler.status().has_value());
2498 EXPECT_EQ(ToResult(status_code), status_handler.status().value());
2499 }
2500
TEST_F(PairingStateTest,ResponderSignalsCompletionOfPairing)2501 TEST_F(PairingStateTest, ResponderSignalsCompletionOfPairing) {
2502 TestStatusHandler status_handler;
2503
2504 PairingState pairing_state(peer()->GetWeakPtr(),
2505 connection(),
2506 /*link_initiated=*/false,
2507 MakeAuthRequestCallback(),
2508 status_handler.MakeStatusCallback());
2509 EXPECT_FALSE(pairing_state.initiator());
2510
2511 auto existing_link_key = sm::LTK(
2512 sm::SecurityProperties(kTestUnauthenticatedLinkKeyType192), kTestLinkKey);
2513
2514 peer()->MutBrEdr().SetBondData(existing_link_key);
2515 EXPECT_FALSE(connection()->ltk().has_value());
2516
2517 auto reply_key = pairing_state.OnLinkKeyRequest();
2518 ASSERT_TRUE(reply_key.has_value());
2519 EXPECT_EQ(kTestLinkKey, reply_key.value());
2520 EXPECT_EQ(0, status_handler.call_count());
2521
2522 // If a pairing request comes in after the peer has already asked for the key,
2523 // we add it's completion to the queue.
2524 TestStatusHandler new_pairing_handler;
2525 pairing_state.InitiatePairing(kNoSecurityRequirements,
2526 new_pairing_handler.MakeStatusCallback());
2527
2528 connection()->TriggerEncryptionChangeCallback(fit::ok(true));
2529
2530 auto expected_status = pw::bluetooth::emboss::StatusCode::SUCCESS;
2531 EXPECT_EQ(1, status_handler.call_count());
2532 ASSERT_TRUE(status_handler.status().has_value());
2533 EXPECT_EQ(ToResult(expected_status), status_handler.status().value());
2534
2535 // and the new pairing handler gets called back too
2536 EXPECT_EQ(1, new_pairing_handler.call_count());
2537 ASSERT_TRUE(new_pairing_handler.status().has_value());
2538 EXPECT_EQ(ToResult(expected_status), new_pairing_handler.status().value());
2539
2540 // The link key should be stored in the connection now.
2541 EXPECT_EQ(kTestLinkKey, connection()->ltk());
2542 }
2543
TEST_F(PairingStateTest,AuthenticationCompleteWithMissingKeyRetriesWithoutKeyAndDoesntAutoConfirmAccepted)2544 TEST_F(
2545 PairingStateTest,
2546 AuthenticationCompleteWithMissingKeyRetriesWithoutKeyAndDoesntAutoConfirmAccepted) {
2547 TestStatusHandler status_handler;
2548
2549 PairingState pairing_state(peer()->GetWeakPtr(),
2550 connection(),
2551 /*link_initiated=*/true,
2552 MakeAuthRequestCallback(),
2553 status_handler.MakeStatusCallback());
2554 FakePairingDelegate pairing_delegate(sm::IOCapability::kNoInputNoOutput);
2555 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
2556
2557 auto existing_link_key = sm::LTK(
2558 sm::SecurityProperties(kTestUnauthenticatedLinkKeyType192), kTestLinkKey);
2559
2560 peer()->MutBrEdr().SetBondData(existing_link_key);
2561 EXPECT_FALSE(connection()->ltk().has_value());
2562
2563 pairing_state.InitiatePairing(kNoSecurityRequirements, NoOpStatusCallback);
2564 EXPECT_EQ(1u, auth_request_count());
2565
2566 auto reply_key = pairing_state.OnLinkKeyRequest();
2567 ASSERT_TRUE(reply_key.has_value());
2568 EXPECT_EQ(kTestLinkKey, reply_key.value());
2569 EXPECT_EQ(0, status_handler.call_count());
2570
2571 // Peer says that they don't have a key.
2572 pairing_state.OnAuthenticationComplete(
2573 pw::bluetooth::emboss::StatusCode::PIN_OR_KEY_MISSING);
2574 ASSERT_EQ(0, status_handler.call_count());
2575 // We should retry the authentication request, this time pretending we don't
2576 // have a key.
2577 EXPECT_EQ(2u, auth_request_count());
2578
2579 EXPECT_EQ(std::nullopt, pairing_state.OnLinkKeyRequest());
2580 EXPECT_EQ(0, status_handler.call_count());
2581
2582 static_cast<void>(pairing_state.OnIoCapabilityRequest());
2583 pairing_state.OnIoCapabilityResponse(IoCapability::NO_INPUT_NO_OUTPUT);
2584 pairing_delegate.SetConfirmPairingCallback([this](PeerId peer_id, auto cb) {
2585 EXPECT_EQ(peer()->identifier(), peer_id);
2586 ASSERT_TRUE(cb);
2587 cb(true);
2588 });
2589 bool confirmed = false;
2590 pairing_state.OnUserConfirmationRequest(
2591 kTestPasskey, [&confirmed](bool confirm) { confirmed = confirm; });
2592
2593 EXPECT_TRUE(confirmed);
2594
2595 pairing_delegate.SetCompletePairingCallback(
2596 [this](PeerId peer_id, sm::Result<> status) {
2597 EXPECT_EQ(peer()->identifier(), peer_id);
2598 EXPECT_EQ(fit::ok(), status);
2599 });
2600
2601 // The controller sends a SimplePairingComplete indicating the success, then
2602 // the controller sends us the new link key, and Authentication Complete.
2603 // Negative Confirmation.
2604 auto status_code = pw::bluetooth::emboss::StatusCode::SUCCESS;
2605 pairing_state.OnSimplePairingComplete(status_code);
2606
2607 const auto new_link_key_value = UInt128{0xC0,
2608 0xDE,
2609 0xFA,
2610 0xCE,
2611 0x00,
2612 0x00,
2613 0x00,
2614 0x00,
2615 0x00,
2616 0x00,
2617 0x00,
2618 0x00,
2619 0x00,
2620 0x00,
2621 0x00,
2622 0x04};
2623
2624 pairing_state.OnLinkKeyNotification(new_link_key_value,
2625 kTestUnauthenticatedLinkKeyType192);
2626 pairing_state.OnAuthenticationComplete(
2627 pw::bluetooth::emboss::StatusCode::SUCCESS);
2628 // then we request encryption, which when it finishes, completes pairing.
2629 ASSERT_EQ(1, connection()->start_encryption_count());
2630 connection()->TriggerEncryptionChangeCallback(fit::ok(true));
2631
2632 EXPECT_EQ(1, status_handler.call_count());
2633 ASSERT_TRUE(status_handler.status().has_value());
2634 EXPECT_EQ(ToResult(status_code), status_handler.status().value());
2635
2636 // The new link key should be stored in the connection now.
2637 auto new_link_key = hci_spec::LinkKey(new_link_key_value, 0, 0);
2638 EXPECT_EQ(new_link_key, connection()->ltk());
2639 }
2640
TEST_F(PairingStateTest,MultipleQueuedPairingRequestsWithSameSecurityRequirementsCompleteAtSameTimeWithSuccess)2641 TEST_F(
2642 PairingStateTest,
2643 MultipleQueuedPairingRequestsWithSameSecurityRequirementsCompleteAtSameTimeWithSuccess) {
2644 TestStatusHandler status_handler;
2645
2646 PairingState pairing_state(peer()->GetWeakPtr(),
2647 connection(),
2648 /*link_initiated=*/false,
2649 MakeAuthRequestCallback(),
2650 status_handler.MakeStatusCallback());
2651 NoOpPairingDelegate pairing_delegate(sm::IOCapability::kNoInputNoOutput);
2652 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
2653
2654 TestStatusHandler initiate_status_handler_0;
2655 pairing_state.InitiatePairing(kNoSecurityRequirements,
2656 initiate_status_handler_0.MakeStatusCallback());
2657 EXPECT_EQ(1u, auth_request_count());
2658
2659 TestStatusHandler initiate_status_handler_1;
2660 pairing_state.InitiatePairing(kNoSecurityRequirements,
2661 initiate_status_handler_1.MakeStatusCallback());
2662 EXPECT_EQ(1u, auth_request_count());
2663
2664 AdvanceToEncryptionAsInitiator(&pairing_state);
2665 EXPECT_EQ(0, status_handler.call_count());
2666 EXPECT_EQ(1, connection()->start_encryption_count());
2667
2668 connection()->TriggerEncryptionChangeCallback(fit::ok(true));
2669 EXPECT_EQ(1, status_handler.call_count());
2670 ASSERT_TRUE(status_handler.status());
2671 EXPECT_EQ(fit::ok(), *status_handler.status());
2672 ASSERT_EQ(1, initiate_status_handler_0.call_count());
2673 EXPECT_EQ(fit::ok(), *initiate_status_handler_0.status());
2674 ASSERT_EQ(1, initiate_status_handler_1.call_count());
2675 EXPECT_EQ(fit::ok(), *initiate_status_handler_1.status());
2676 }
2677
TEST_F(PairingStateTest,MultipleQueuedPairingRequestsWithAuthSecurityRequirementsCompleteAtSameTimeWithInsufficientSecurityFailure)2678 TEST_F(
2679 PairingStateTest,
2680 MultipleQueuedPairingRequestsWithAuthSecurityRequirementsCompleteAtSameTimeWithInsufficientSecurityFailure) {
2681 TestStatusHandler status_handler;
2682
2683 PairingState pairing_state(peer()->GetWeakPtr(),
2684 connection(),
2685 /*link_initiated=*/false,
2686 MakeAuthRequestCallback(),
2687 status_handler.MakeStatusCallback());
2688 NoOpPairingDelegate pairing_delegate(sm::IOCapability::kNoInputNoOutput);
2689 pairing_state.SetPairingDelegate(pairing_delegate.GetWeakPtr());
2690
2691 constexpr BrEdrSecurityRequirements kSecurityRequirements{
2692 .authentication = true, .secure_connections = false};
2693
2694 TestStatusHandler initiate_status_handler_0;
2695 pairing_state.InitiatePairing(kSecurityRequirements,
2696 initiate_status_handler_0.MakeStatusCallback());
2697 EXPECT_EQ(1u, auth_request_count());
2698
2699 TestStatusHandler initiate_status_handler_1;
2700 pairing_state.InitiatePairing(kSecurityRequirements,
2701 initiate_status_handler_1.MakeStatusCallback());
2702 EXPECT_EQ(1u, auth_request_count());
2703
2704 // Pair with unauthenticated link key.
2705 AdvanceToEncryptionAsInitiator(&pairing_state);
2706 EXPECT_EQ(0, status_handler.call_count());
2707 EXPECT_EQ(1, connection()->start_encryption_count());
2708
2709 connection()->TriggerEncryptionChangeCallback(fit::ok(true));
2710 EXPECT_EQ(1, status_handler.call_count());
2711 ASSERT_TRUE(status_handler.status());
2712 EXPECT_EQ(fit::ok(), *status_handler.status());
2713 ASSERT_EQ(1, initiate_status_handler_0.call_count());
2714 EXPECT_EQ(ToResult(HostError::kInsufficientSecurity),
2715 initiate_status_handler_0.status().value());
2716 ASSERT_EQ(1, initiate_status_handler_1.call_count());
2717 EXPECT_EQ(ToResult(HostError::kInsufficientSecurity),
2718 initiate_status_handler_1.status().value());
2719 }
2720
TEST_F(PairingStateTest,AuthPairingRequestDuringInitiatorNoAuthPairingFailsQueuedAuthPairingRequest)2721 TEST_F(
2722 PairingStateTest,
2723 AuthPairingRequestDuringInitiatorNoAuthPairingFailsQueuedAuthPairingRequest) {
2724 TestStatusHandler status_handler;
2725
2726 PairingState pairing_state(peer()->GetWeakPtr(),
2727 connection(),
2728 /*link_initiated=*/false,
2729 MakeAuthRequestCallback(),
2730 status_handler.MakeStatusCallback());
2731 NoOpPairingDelegate pairing_delegate_no_io(
2732 sm::IOCapability::kNoInputNoOutput);
2733 pairing_state.SetPairingDelegate(pairing_delegate_no_io.GetWeakPtr());
2734
2735 TestStatusHandler initiate_status_handler_0;
2736 pairing_state.InitiatePairing(kNoSecurityRequirements,
2737 initiate_status_handler_0.MakeStatusCallback());
2738
2739 TestStatusHandler initiate_status_handler_1;
2740 constexpr BrEdrSecurityRequirements kSecurityRequirements{
2741 .authentication = true, .secure_connections = false};
2742 pairing_state.InitiatePairing(kSecurityRequirements,
2743 initiate_status_handler_1.MakeStatusCallback());
2744
2745 // Pair with unauthenticated link key.
2746 AdvanceToEncryptionAsInitiator(&pairing_state);
2747
2748 EXPECT_EQ(0, status_handler.call_count());
2749 EXPECT_EQ(1, connection()->start_encryption_count());
2750
2751 FakePairingDelegate fake_pairing_delegate(sm::IOCapability::kDisplayYesNo);
2752 pairing_state.SetPairingDelegate(fake_pairing_delegate.GetWeakPtr());
2753
2754 connection()->TriggerEncryptionChangeCallback(fit::ok(true));
2755 EXPECT_EQ(1, status_handler.call_count());
2756 ASSERT_TRUE(status_handler.status());
2757 EXPECT_EQ(fit::ok(), *status_handler.status());
2758 ASSERT_EQ(1, initiate_status_handler_0.call_count());
2759 EXPECT_EQ(fit::ok(), *initiate_status_handler_0.status());
2760 ASSERT_EQ(1, initiate_status_handler_1.call_count());
2761 EXPECT_EQ(ToResult(HostError::kInsufficientSecurity),
2762 initiate_status_handler_1.status().value());
2763
2764 // Pairing for second request should not start.
2765 EXPECT_FALSE(pairing_state.initiator());
2766 }
2767
TEST_F(PairingStateTest,InitiatingPairingDuringAuthenticationWithExistingUnauthenticatedLinkKey)2768 TEST_F(
2769 PairingStateTest,
2770 InitiatingPairingDuringAuthenticationWithExistingUnauthenticatedLinkKey) {
2771 TestStatusHandler status_handler;
2772
2773 PairingState pairing_state(peer()->GetWeakPtr(),
2774 connection(),
2775 /*link_initiated=*/false,
2776 MakeAuthRequestCallback(),
2777 status_handler.MakeStatusCallback());
2778 FakePairingDelegate fake_pairing_delegate(sm::IOCapability::kDisplayYesNo);
2779 pairing_state.SetPairingDelegate(fake_pairing_delegate.GetWeakPtr());
2780
2781 peer()->MutBrEdr().SetBondData(
2782 sm::LTK(sm::SecurityProperties(kTestUnauthenticatedLinkKeyType192),
2783 kTestLinkKey));
2784
2785 TestStatusHandler initiator_status_handler_0;
2786 pairing_state.InitiatePairing(
2787 kNoSecurityRequirements, initiator_status_handler_0.MakeStatusCallback());
2788 EXPECT_EQ(1u, auth_request_count());
2789
2790 TestStatusHandler initiator_status_handler_1;
2791 constexpr BrEdrSecurityRequirements kSecurityRequirements{
2792 .authentication = true, .secure_connections = false};
2793 pairing_state.InitiatePairing(
2794 kSecurityRequirements, initiator_status_handler_1.MakeStatusCallback());
2795 EXPECT_EQ(1u, auth_request_count());
2796
2797 // Authenticate with link key.
2798 EXPECT_NE(std::nullopt, pairing_state.OnLinkKeyRequest());
2799 EXPECT_TRUE(connection()->ltk().has_value());
2800 pairing_state.OnAuthenticationComplete(
2801 pw::bluetooth::emboss::StatusCode::SUCCESS);
2802
2803 EXPECT_EQ(0, status_handler.call_count());
2804 EXPECT_EQ(1, connection()->start_encryption_count());
2805
2806 connection()->TriggerEncryptionChangeCallback(fit::ok(true));
2807 ASSERT_EQ(1, status_handler.call_count());
2808 EXPECT_EQ(fit::ok(), *status_handler.status());
2809 ASSERT_EQ(1, initiator_status_handler_0.call_count());
2810 EXPECT_EQ(fit::ok(), *initiator_status_handler_0.status());
2811 EXPECT_EQ(0, initiator_status_handler_1.call_count());
2812
2813 fake_pairing_delegate.SetDisplayPasskeyCallback(
2814 [](PeerId peer_id,
2815 uint32_t value,
2816 PairingDelegate::DisplayMethod method,
2817 auto cb) { cb(true); });
2818 fake_pairing_delegate.SetCompletePairingCallback(
2819 [](PeerId peer_id, sm::Result<> status) {
2820 EXPECT_EQ(fit::ok(), status);
2821 });
2822
2823 // Pairing for second request should start.
2824 EXPECT_EQ(2u, auth_request_count());
2825 EXPECT_TRUE(pairing_state.initiator());
2826 EXPECT_EQ(std::nullopt, pairing_state.OnLinkKeyRequest());
2827 EXPECT_EQ(IoCapability::DISPLAY_YES_NO,
2828 *pairing_state.OnIoCapabilityRequest());
2829 pairing_state.OnIoCapabilityResponse(IoCapability::DISPLAY_YES_NO);
2830
2831 bool confirmed = false;
2832 pairing_state.OnUserConfirmationRequest(
2833 kTestPasskey, [&confirmed](bool confirm) { confirmed = confirm; });
2834 EXPECT_TRUE(confirmed);
2835
2836 pairing_state.OnSimplePairingComplete(
2837 pw::bluetooth::emboss::StatusCode::SUCCESS);
2838 pairing_state.OnLinkKeyNotification(kTestLinkKeyValue,
2839 kTestAuthenticatedLinkKeyType192);
2840 pairing_state.OnAuthenticationComplete(
2841 pw::bluetooth::emboss::StatusCode::SUCCESS);
2842 EXPECT_EQ(2, connection()->start_encryption_count());
2843
2844 connection()->TriggerEncryptionChangeCallback(fit::ok(true));
2845 ASSERT_EQ(2, status_handler.call_count());
2846 EXPECT_EQ(fit::ok(), *status_handler.status());
2847 EXPECT_EQ(1, initiator_status_handler_0.call_count());
2848 ASSERT_EQ(1, initiator_status_handler_1.call_count());
2849 EXPECT_EQ(fit::ok(), *initiator_status_handler_1.status());
2850
2851 // No further pairing should occur.
2852 EXPECT_EQ(2u, auth_request_count());
2853 EXPECT_FALSE(pairing_state.initiator());
2854 }
2855
2856 #ifndef NINSPECT
TEST_F(PairingStateTest,Inspect)2857 TEST_F(PairingStateTest, Inspect) {
2858 TestStatusHandler status_handler;
2859
2860 inspect::Inspector inspector;
2861
2862 PairingState pairing_state(peer()->GetWeakPtr(),
2863 connection(),
2864 /*link_initiated=*/false,
2865 MakeAuthRequestCallback(),
2866 status_handler.MakeStatusCallback());
2867
2868 pairing_state.AttachInspect(inspector.GetRoot(), "pairing_state");
2869
2870 auto security_properties_matcher = AllOf(NodeMatches(AllOf(
2871 NameMatches("security_properties"),
2872 PropertyList(UnorderedElementsAre(StringIs("level", "not secure"),
2873 BoolIs("encrypted", false),
2874 BoolIs("secure_connections", false),
2875 BoolIs("authenticated", false))))));
2876
2877 auto pairing_state_matcher =
2878 AllOf(NodeMatches(AllOf(NameMatches("pairing_state"),
2879 PropertyList(UnorderedElementsAre(
2880 StringIs("encryption_status", "OFF"))))),
2881 ChildrenMatch(UnorderedElementsAre(security_properties_matcher)));
2882
2883 inspect::Hierarchy hierarchy = bt::testing::ReadInspect(inspector);
2884 EXPECT_THAT(hierarchy, ChildrenMatch(ElementsAre(pairing_state_matcher)));
2885 }
2886 #endif // NINSPECT
2887
2888 } // namespace
2889 } // namespace bt::gap
2890