1 /*
2  *
3  *  Copyright 2019 The Android Open Source Project
4  *
5  *  Licensed under the Apache License, Version 2.0 (the "License");
6  *  you may not use this file except in compliance with the License.
7  *  You may obtain a copy of the License at:
8  *
9  *  http://www.apache.org/licenses/LICENSE-2.0
10  *
11  *  Unless required by applicable law or agreed to in writing, software
12  *  distributed under the License is distributed on an "AS IS" BASIS,
13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  *  See the License for the specific language governing permissions and
15  *  limitations under the License.
16  *
17  */
18 #include "security/pairing/classic_pairing_handler.h"
19 
20 #include <gtest/gtest.h>
21 #include <memory>
22 #include <utility>
23 
24 #include "hci/hci_packets.h"
25 #include "packet/raw_builder.h"
26 #include "security/channel/security_manager_channel.h"
27 #include "security/initial_informations.h"
28 #include "security/smp_packets.h"
29 #include "security/test/fake_hci_layer.h"
30 #include "security/test/fake_name_db.h"
31 #include "security/test/fake_security_interface.h"
32 
33 namespace bluetooth {
34 namespace security {
35 namespace pairing {
36 namespace {
37 
38 using bluetooth::security::channel::SecurityManagerChannel;
39 using hci::Address;
40 using hci::AuthenticationRequirements;
41 using hci::CommandCompleteBuilder;
42 using hci::IoCapabilityRequestReplyBuilder;
43 using hci::IoCapabilityRequestView;
44 using hci::OobDataPresent;
45 using hci::OpCode;
46 using os::Handler;
47 using os::Thread;
48 using packet::RawBuilder;
49 
50 class FakeSecurityManagerChannel : public channel::SecurityManagerChannel {
51  public:
FakeSecurityManagerChannel(os::Handler * handler,hci::HciLayer * hci_layer)52   FakeSecurityManagerChannel(os::Handler* handler, hci::HciLayer* hci_layer)
53       : channel::SecurityManagerChannel(handler, hci_layer) {}
~FakeSecurityManagerChannel()54   ~FakeSecurityManagerChannel() {}
55 
OnLinkConnected(std::unique_ptr<l2cap::classic::LinkSecurityInterface> link)56   void OnLinkConnected(std::unique_ptr<l2cap::classic::LinkSecurityInterface> link) override {
57     LOG_ERROR("CALLED");
58   }
59 
OnLinkDisconnected(hci::Address address)60   void OnLinkDisconnected(hci::Address address) override {
61     LOG_ERROR("CALLED");
62   }
63 
OnEncryptionChange(hci::Address address,bool encrypted)64   void OnEncryptionChange(hci::Address address, bool encrypted) override {
65     LOG_ERROR("CALLED");
66   }
67 
OnAuthenticationComplete(hci::ErrorCode hci_status,hci::Address remote)68   void OnAuthenticationComplete(hci::ErrorCode hci_status, hci::Address remote) override {
69     LOG_ERROR("CALLED");
70   }
71 };
72 
73 class TestUI : public UI {
74  public:
75   ~TestUI() = default;
DisplayPairingPrompt(const hci::AddressWithType & address,std::string name)76   void DisplayPairingPrompt(const hci::AddressWithType& address, std::string name) override {}
Cancel(const hci::AddressWithType & address)77   void Cancel(const hci::AddressWithType& address) override {}
DisplayConfirmValue(ConfirmationData data)78   void DisplayConfirmValue(ConfirmationData data) override {}
DisplayYesNoDialog(ConfirmationData data)79   void DisplayYesNoDialog(ConfirmationData data) override {}
DisplayEnterPasskeyDialog(ConfirmationData data)80   void DisplayEnterPasskeyDialog(ConfirmationData data) override {}
DisplayPasskey(ConfirmationData data)81   void DisplayPasskey(ConfirmationData data) override {}
DisplayEnterPinDialog(ConfirmationData data)82   void DisplayEnterPinDialog(ConfirmationData data) override {}
83 };
84 
85 class SecurityManagerChannelCallback : public channel::ISecurityManagerChannelListener {
86  public:
SecurityManagerChannelCallback(pairing::ClassicPairingHandler * pairing_handler)87   explicit SecurityManagerChannelCallback(pairing::ClassicPairingHandler* pairing_handler)
88       : pairing_handler_(pairing_handler) {}
OnHciEventReceived(hci::EventView packet)89   void OnHciEventReceived(hci::EventView packet) override {
90     auto event = hci::EventView::Create(packet);
91     ASSERT_LOG(event.IsValid(), "Received invalid packet");
92     const hci::EventCode code = event.GetEventCode();
93     switch (code) {
94       case hci::EventCode::PIN_CODE_REQUEST:
95         pairing_handler_->OnReceive(hci::PinCodeRequestView::Create(event));
96         break;
97       case hci::EventCode::LINK_KEY_REQUEST:
98         pairing_handler_->OnReceive(hci::LinkKeyRequestView::Create(event));
99         break;
100       case hci::EventCode::LINK_KEY_NOTIFICATION:
101         pairing_handler_->OnReceive(hci::LinkKeyNotificationView::Create(event));
102         break;
103       case hci::EventCode::IO_CAPABILITY_REQUEST:
104         pairing_handler_->OnReceive(hci::IoCapabilityRequestView::Create(event));
105         break;
106       case hci::EventCode::IO_CAPABILITY_RESPONSE:
107         pairing_handler_->OnReceive(hci::IoCapabilityResponseView::Create(event));
108         break;
109       case hci::EventCode::SIMPLE_PAIRING_COMPLETE:
110         pairing_handler_->OnReceive(hci::SimplePairingCompleteView::Create(event));
111         break;
112       case hci::EventCode::RETURN_LINK_KEYS:
113         pairing_handler_->OnReceive(hci::ReturnLinkKeysView::Create(event));
114         break;
115       case hci::EventCode::REMOTE_OOB_DATA_REQUEST:
116         pairing_handler_->OnReceive(hci::RemoteOobDataRequestView::Create(event));
117         break;
118       case hci::EventCode::USER_PASSKEY_NOTIFICATION:
119         pairing_handler_->OnReceive(hci::UserPasskeyNotificationView::Create(event));
120         break;
121       case hci::EventCode::KEYPRESS_NOTIFICATION:
122         pairing_handler_->OnReceive(hci::KeypressNotificationView::Create(event));
123         break;
124       case hci::EventCode::USER_CONFIRMATION_REQUEST:
125         pairing_handler_->OnReceive(hci::UserConfirmationRequestView::Create(event));
126         break;
127       case hci::EventCode::USER_PASSKEY_REQUEST:
128         pairing_handler_->OnReceive(hci::UserPasskeyRequestView::Create(event));
129         break;
130       default:
131         ASSERT_LOG(false, "Cannot handle received packet: %s", hci::EventCodeText(code).c_str());
132         break;
133     }
134   }
135 
OnConnectionClosed(hci::Address address)136   void OnConnectionClosed(hci::Address address) override {
137     LOG_INFO("Called");
138   }
139 
140  private:
141   pairing::ClassicPairingHandler* pairing_handler_ = nullptr;
142 };
143 
144 bool expect_success_ = true;
145 
pairing_complete_callback(bluetooth::hci::Address address,PairingResultOrFailure status)146 static void pairing_complete_callback(bluetooth::hci::Address address, PairingResultOrFailure status) {
147   if (expect_success_) {
148     ASSERT_TRUE(std::holds_alternative<PairingResult>(status));
149   } else {
150     ASSERT_FALSE(std::holds_alternative<PairingResult>(status));
151   }
152 }
153 
154 class ClassicPairingHandlerTest : public ::testing::Test {
155  protected:
SetUp()156   void SetUp() override {
157     expect_success_ = true;
158     hci_layer_ = new FakeHciLayer();
159     name_db_module_ = new FakeNameDbModule();
160     fake_registry_.InjectTestModule(&FakeHciLayer::Factory, hci_layer_);
161     fake_registry_.InjectTestModule(&neighbor::NameDbModule::Factory, name_db_module_);
162     handler_ = fake_registry_.GetTestModuleHandler(&FakeHciLayer::Factory);
163     channel_ = new FakeSecurityManagerChannel(handler_, hci_layer_);
164     security_record_ = std::make_shared<record::SecurityRecord>(device_);
165     user_interface_ = new TestUI();
166     user_interface_handler_ = handler_;
167     pairing_handler_ = new pairing::ClassicPairingHandler(
168         channel_,
169         security_record_,
170         handler_,
171         common::Bind(&pairing_complete_callback),
172         user_interface_,
173         user_interface_handler_,
174         "Fake name",
175         name_db_module_);
176     channel_callback_ = new SecurityManagerChannelCallback(pairing_handler_);
177     channel_->SetChannelListener(channel_callback_);
178     security_interface_ = new FakeSecurityInterface(handler_, channel_);
179     channel_->SetSecurityInterface(security_interface_);
180   }
181 
TearDown()182   void TearDown() override {
183     channel_->SetChannelListener(nullptr);
184     synchronize();
185     fake_registry_.StopAll();
186     delete user_interface_;
187     delete pairing_handler_;
188     delete channel_;
189     delete channel_callback_;
190     delete security_interface_;
191   }
192 
synchronize()193   void synchronize() {
194     fake_registry_.SynchronizeModuleHandler(&FakeHciLayer::Factory, std::chrono::milliseconds(20));
195     fake_registry_.SynchronizeModuleHandler(&FakeNameDbModule::Factory, std::chrono::milliseconds(20));
196   }
197 
ReceiveLinkKeyRequest(hci::AddressWithType device)198   void ReceiveLinkKeyRequest(hci::AddressWithType device) {
199     hci_layer_->IncomingEvent(hci::LinkKeyRequestBuilder::Create(device.GetAddress()));
200     synchronize();
201   }
202 
ReceiveIoCapabilityRequest(hci::AddressWithType device)203   void ReceiveIoCapabilityRequest(hci::AddressWithType device) {
204     hci_layer_->IncomingEvent(hci::IoCapabilityRequestBuilder::Create(device.GetAddress()));
205     synchronize();
206   }
207 
ReceiveIoCapabilityResponse(hci::AddressWithType device,hci::IoCapability io_cap,hci::OobDataPresent oob_present,hci::AuthenticationRequirements auth_reqs)208   void ReceiveIoCapabilityResponse(hci::AddressWithType device, hci::IoCapability io_cap,
209                                    hci::OobDataPresent oob_present, hci::AuthenticationRequirements auth_reqs) {
210     hci_layer_->IncomingEvent(
211         hci::IoCapabilityResponseBuilder::Create(device.GetAddress(), io_cap, oob_present, auth_reqs));
212     synchronize();
213   }
214 
ReceiveOobDataRequest(hci::AddressWithType device)215   void ReceiveOobDataRequest(hci::AddressWithType device) {
216     hci_layer_->IncomingEvent(hci::RemoteOobDataRequestBuilder::Create(device.GetAddress()));
217     synchronize();
218   }
219 
ReceiveUserConfirmationRequest(hci::AddressWithType device,uint32_t numeric_value)220   void ReceiveUserConfirmationRequest(hci::AddressWithType device, uint32_t numeric_value) {
221     hci_layer_->IncomingEvent(hci::UserConfirmationRequestBuilder::Create(device.GetAddress(), numeric_value));
222     synchronize();
223   }
224 
ReceiveSimplePairingComplete(hci::ErrorCode status,hci::AddressWithType device)225   void ReceiveSimplePairingComplete(hci::ErrorCode status, hci::AddressWithType device) {
226     hci_layer_->IncomingEvent(hci::SimplePairingCompleteBuilder::Create(status, device.GetAddress()));
227     synchronize();
228   }
229 
ReceiveLinkKeyNotification(hci::AddressWithType device,std::array<uint8_t,16> link_key,hci::KeyType key_type)230   void ReceiveLinkKeyNotification(hci::AddressWithType device, std::array<uint8_t, 16> link_key,
231                                   hci::KeyType key_type) {
232     hci_layer_->IncomingEvent(hci::LinkKeyNotificationBuilder::Create(device.GetAddress(), link_key, key_type));
233     synchronize();
234   }
235 
236   TestModuleRegistry fake_registry_;
237   Thread& thread_ = fake_registry_.GetTestThread();
238   Handler* handler_ = nullptr;
239   FakeHciLayer* hci_layer_ = nullptr;
240   hci::AddressWithType device_;
241   SecurityManagerChannelCallback* channel_callback_ = nullptr;
242   channel::SecurityManagerChannel* channel_ = nullptr;
243   pairing::ClassicPairingHandler* pairing_handler_ = nullptr;
244   std::shared_ptr<record::SecurityRecord> security_record_ = nullptr;
245   UI* user_interface_;
246   os::Handler* user_interface_handler_;
247   l2cap::classic::SecurityInterface* security_interface_ = nullptr;
248   FakeNameDbModule* name_db_module_ = nullptr;
249 };
250 
251 // Security Manager Boot Sequence (Required for SSP, these are already set at boot time)
252 //  - WriteSimplePairingMode
253 //  - WriteSecureConnectionsHostSupport
254 //  - WriteAuthenticatedPayloadTimeout
255 
256 /*** Locally initiated ***/
257 // Security Pairing Sequence (JustWorks)
258 //  -> *Establish L2CAP connection*
259 //  -> AuthenticationRequested (L2CAP handles this)
260 //  <- LinkKeyRequest   // This is entry point for remote initiated
261 //  -> LinkKeyRequestNegativeReply
262 //  <- IoCapabilityRequest
263 //  -> IoCapabilityRequestReply
264 //  <- IoCapabilityResponse
265 //  <- UserConfirmationRequest
266 //  -> UserConfirmationRequestReply (auto)
267 //  <- SimplePairingComplete
268 //  <- LinkKeyNotification
269 //  <- AuthenticationComplete
270 //  -> SetConnectionEncryption
271 //  <- EncryptionChange
272 //  -> L2capConnectionResponse (if triggered by L2cap connection request)
273 
GetLastCommand(FakeHciLayer * hci_layer)274 hci::SecurityCommandView GetLastCommand(FakeHciLayer* hci_layer) {
275   auto last_command = std::move(hci_layer->GetLastCommand()->command);
276   auto command_packet = GetPacketView(std::move(last_command));
277   auto command_packet_view = hci::CommandView::Create(command_packet);
278   auto security_command_view = hci::SecurityCommandView::Create(command_packet_view);
279   if (!security_command_view.IsValid()) {
280     LOG_ERROR("Invalid security command received");
281   }
282   return security_command_view;
283 }
284 
TEST_F(ClassicPairingHandlerTest,setup_teardown)285 TEST_F(ClassicPairingHandlerTest, setup_teardown) {}
286 
287 /*** JustWorks (Numeric Comparison w/ no UI) ***/
288 // display_only + display_only is JustWorks no confirmation
289 // Needs dialog as per security a bug unless pairing is temporary
TEST_F(ClassicPairingHandlerTest,locally_initiatied_display_only_display_only_temp)290 TEST_F(ClassicPairingHandlerTest, locally_initiatied_display_only_display_only_temp) {
291   hci::IoCapability injected_io_capability = hci::IoCapability::DISPLAY_ONLY;
292   hci::AuthenticationRequirements injected_authentication_requirements = hci::AuthenticationRequirements::NO_BONDING;
293   pairing_handler_->Initiate(
294       true, injected_io_capability, injected_authentication_requirements, pairing::OobData(), pairing::OobData());
295   ReceiveLinkKeyRequest(device_);
296   auto security_command_view = GetLastCommand(hci_layer_);
297   auto link_key_neg_reply = hci::LinkKeyRequestNegativeReplyView::Create(security_command_view);
298   ASSERT_TRUE(link_key_neg_reply.IsValid());
299   ASSERT_EQ(OpCode::LINK_KEY_REQUEST_NEGATIVE_REPLY, link_key_neg_reply.GetOpCode());
300   ReceiveIoCapabilityRequest(device_);
301   security_command_view = GetLastCommand(hci_layer_);
302   ASSERT_EQ(OpCode::IO_CAPABILITY_REQUEST_REPLY, security_command_view.GetOpCode());
303   auto io_cap_request_reply = hci::IoCapabilityRequestReplyView::Create(security_command_view);
304   ASSERT_TRUE(io_cap_request_reply.IsValid());
305   ASSERT_EQ(injected_io_capability, io_cap_request_reply.GetIoCapability());
306   ASSERT_EQ(hci::OobDataPresent::NOT_PRESENT, io_cap_request_reply.GetOobPresent());
307   ASSERT_EQ(injected_authentication_requirements, io_cap_request_reply.GetAuthenticationRequirements());
308   ReceiveIoCapabilityResponse(device_, hci::IoCapability::DISPLAY_ONLY, hci::OobDataPresent::NOT_PRESENT,
309                               hci::AuthenticationRequirements::NO_BONDING);
310   uint32_t numeric_value = 0x123;
311   ReceiveUserConfirmationRequest(device_, numeric_value);
312   security_command_view = GetLastCommand(hci_layer_);
313   ASSERT_EQ(OpCode::USER_CONFIRMATION_REQUEST_REPLY, security_command_view.GetOpCode());
314   auto user_conf_request_reply = hci::UserConfirmationRequestReplyView::Create(security_command_view);
315   ASSERT_TRUE(user_conf_request_reply.IsValid());
316   ReceiveSimplePairingComplete(hci::ErrorCode::SUCCESS, device_);
317   std::array<uint8_t, 16> link_key = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5};
318   hci::KeyType key_type = hci::KeyType::DEBUG_COMBINATION;
319   ReceiveLinkKeyNotification(device_, link_key, key_type);
320   ASSERT_EQ(link_key, security_record_->GetLinkKey());
321   ASSERT_EQ(key_type, security_record_->GetKeyType());
322   ASSERT_FALSE(security_record_->IsAuthenticated());
323   ASSERT_FALSE(security_record_->RequiresMitmProtection());
324 }
325 
326 // display_only + display_yes_no is JustWorks no confirmation
327 // Needs dialog as per security a bug unless pairing is temporary
TEST_F(ClassicPairingHandlerTest,locally_initiatied_display_only_display_yes_no_temp)328 TEST_F(ClassicPairingHandlerTest, locally_initiatied_display_only_display_yes_no_temp) {
329   hci::IoCapability injected_io_capability = hci::IoCapability::DISPLAY_ONLY;
330   hci::AuthenticationRequirements injected_authentication_requirements = hci::AuthenticationRequirements::NO_BONDING;
331   pairing_handler_->Initiate(
332       true, injected_io_capability, injected_authentication_requirements, pairing::OobData(), pairing::OobData());
333   ReceiveLinkKeyRequest(device_);
334   auto security_command_view = GetLastCommand(hci_layer_);
335   auto link_key_neg_reply = hci::LinkKeyRequestNegativeReplyView::Create(security_command_view);
336   ASSERT_TRUE(link_key_neg_reply.IsValid());
337   ASSERT_EQ(OpCode::LINK_KEY_REQUEST_NEGATIVE_REPLY, link_key_neg_reply.GetOpCode());
338   ReceiveIoCapabilityRequest(device_);
339   security_command_view = GetLastCommand(hci_layer_);
340   ASSERT_EQ(OpCode::IO_CAPABILITY_REQUEST_REPLY, security_command_view.GetOpCode());
341   auto io_cap_request_reply = hci::IoCapabilityRequestReplyView::Create(security_command_view);
342   ASSERT_TRUE(io_cap_request_reply.IsValid());
343   ASSERT_EQ(injected_io_capability, io_cap_request_reply.GetIoCapability());
344   ASSERT_EQ(hci::OobDataPresent::NOT_PRESENT, io_cap_request_reply.GetOobPresent());
345   ASSERT_EQ(injected_authentication_requirements, io_cap_request_reply.GetAuthenticationRequirements());
346   ReceiveIoCapabilityResponse(device_, hci::IoCapability::DISPLAY_YES_NO, hci::OobDataPresent::NOT_PRESENT,
347                               hci::AuthenticationRequirements::NO_BONDING);
348   uint32_t numeric_value = 0x123;
349   ReceiveUserConfirmationRequest(device_, numeric_value);
350   security_command_view = GetLastCommand(hci_layer_);
351   ASSERT_EQ(OpCode::USER_CONFIRMATION_REQUEST_REPLY, security_command_view.GetOpCode());
352   auto user_conf_request_reply = hci::UserConfirmationRequestReplyView::Create(security_command_view);
353   ASSERT_TRUE(user_conf_request_reply.IsValid());
354   ReceiveSimplePairingComplete(hci::ErrorCode::SUCCESS, device_);
355   std::array<uint8_t, 16> link_key = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5};
356   hci::KeyType key_type = hci::KeyType::DEBUG_COMBINATION;
357   ReceiveLinkKeyNotification(device_, link_key, key_type);
358   ASSERT_EQ(link_key, security_record_->GetLinkKey());
359   ASSERT_EQ(key_type, security_record_->GetKeyType());
360   ASSERT_TRUE(security_record_->IsAuthenticated());
361   ASSERT_FALSE(security_record_->RequiresMitmProtection());
362 }
363 
364 // display_only + no_input_no_output is JustWorks no confirmation
365 // Needs dialog as per security a bug unless pairing is temporary
TEST_F(ClassicPairingHandlerTest,locally_initiatied_display_only_no_input_no_output_temp)366 TEST_F(ClassicPairingHandlerTest, locally_initiatied_display_only_no_input_no_output_temp) {
367   hci::IoCapability injected_io_capability = hci::IoCapability::DISPLAY_ONLY;
368   hci::AuthenticationRequirements injected_authentication_requirements = hci::AuthenticationRequirements::NO_BONDING;
369   pairing_handler_->Initiate(
370       true, injected_io_capability, injected_authentication_requirements, pairing::OobData(), pairing::OobData());
371   ReceiveLinkKeyRequest(device_);
372   auto security_command_view = GetLastCommand(hci_layer_);
373   auto link_key_neg_reply = hci::LinkKeyRequestNegativeReplyView::Create(security_command_view);
374   ASSERT_TRUE(link_key_neg_reply.IsValid());
375   ASSERT_EQ(OpCode::LINK_KEY_REQUEST_NEGATIVE_REPLY, link_key_neg_reply.GetOpCode());
376   ReceiveIoCapabilityRequest(device_);
377   security_command_view = GetLastCommand(hci_layer_);
378   ASSERT_EQ(OpCode::IO_CAPABILITY_REQUEST_REPLY, security_command_view.GetOpCode());
379   auto io_cap_request_reply = hci::IoCapabilityRequestReplyView::Create(security_command_view);
380   ASSERT_TRUE(io_cap_request_reply.IsValid());
381   ASSERT_EQ(injected_io_capability, io_cap_request_reply.GetIoCapability());
382   ASSERT_EQ(hci::OobDataPresent::NOT_PRESENT, io_cap_request_reply.GetOobPresent());
383   ASSERT_EQ(injected_authentication_requirements, io_cap_request_reply.GetAuthenticationRequirements());
384   ReceiveIoCapabilityResponse(device_, hci::IoCapability::NO_INPUT_NO_OUTPUT, hci::OobDataPresent::NOT_PRESENT,
385                               hci::AuthenticationRequirements::NO_BONDING);
386   uint32_t numeric_value = 0x123;
387   ReceiveUserConfirmationRequest(device_, numeric_value);
388   security_command_view = GetLastCommand(hci_layer_);
389   ASSERT_EQ(OpCode::USER_CONFIRMATION_REQUEST_REPLY, security_command_view.GetOpCode());
390   auto user_conf_request_reply = hci::UserConfirmationRequestReplyView::Create(security_command_view);
391   ASSERT_TRUE(user_conf_request_reply.IsValid());
392   ReceiveSimplePairingComplete(hci::ErrorCode::SUCCESS, device_);
393   std::array<uint8_t, 16> link_key = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5};
394   hci::KeyType key_type = hci::KeyType::DEBUG_COMBINATION;
395   ReceiveLinkKeyNotification(device_, link_key, key_type);
396   ASSERT_EQ(link_key, security_record_->GetLinkKey());
397   ASSERT_EQ(key_type, security_record_->GetKeyType());
398   ASSERT_TRUE(security_record_->IsAuthenticated());
399   ASSERT_FALSE(security_record_->RequiresMitmProtection());
400 }
401 
402 // keyboard_only + no_input_no_output is JustWorks no confirmation
403 // Needs dialog as per security a bug unless pairing is temporary
TEST_F(ClassicPairingHandlerTest,locally_initiatied_keyboard_only_no_input_no_output_temp)404 TEST_F(ClassicPairingHandlerTest, locally_initiatied_keyboard_only_no_input_no_output_temp) {
405   hci::IoCapability injected_io_capability = hci::IoCapability::KEYBOARD_ONLY;
406   hci::AuthenticationRequirements injected_authentication_requirements = hci::AuthenticationRequirements::NO_BONDING;
407   pairing_handler_->Initiate(
408       true, injected_io_capability, injected_authentication_requirements, pairing::OobData(), pairing::OobData());
409   ReceiveLinkKeyRequest(device_);
410   auto security_command_view = GetLastCommand(hci_layer_);
411   auto link_key_neg_reply = hci::LinkKeyRequestNegativeReplyView::Create(security_command_view);
412   ASSERT_TRUE(link_key_neg_reply.IsValid());
413   ASSERT_EQ(OpCode::LINK_KEY_REQUEST_NEGATIVE_REPLY, link_key_neg_reply.GetOpCode());
414   ReceiveIoCapabilityRequest(device_);
415   security_command_view = GetLastCommand(hci_layer_);
416   ASSERT_EQ(OpCode::IO_CAPABILITY_REQUEST_REPLY, security_command_view.GetOpCode());
417   auto io_cap_request_reply = hci::IoCapabilityRequestReplyView::Create(security_command_view);
418   ASSERT_TRUE(io_cap_request_reply.IsValid());
419   ASSERT_EQ(injected_io_capability, io_cap_request_reply.GetIoCapability());
420   ASSERT_EQ(hci::OobDataPresent::NOT_PRESENT, io_cap_request_reply.GetOobPresent());
421   ASSERT_EQ(injected_authentication_requirements, io_cap_request_reply.GetAuthenticationRequirements());
422   ReceiveIoCapabilityResponse(device_, hci::IoCapability::NO_INPUT_NO_OUTPUT, hci::OobDataPresent::NOT_PRESENT,
423                               hci::AuthenticationRequirements::NO_BONDING);
424   uint32_t numeric_value = 0x123;
425   ReceiveUserConfirmationRequest(device_, numeric_value);
426   security_command_view = GetLastCommand(hci_layer_);
427   ASSERT_EQ(OpCode::USER_CONFIRMATION_REQUEST_REPLY, security_command_view.GetOpCode());
428   auto user_conf_request_reply = hci::UserConfirmationRequestReplyView::Create(security_command_view);
429   ASSERT_TRUE(user_conf_request_reply.IsValid());
430   ReceiveSimplePairingComplete(hci::ErrorCode::SUCCESS, device_);
431   std::array<uint8_t, 16> link_key = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5};
432   hci::KeyType key_type = hci::KeyType::DEBUG_COMBINATION;
433   ReceiveLinkKeyNotification(device_, link_key, key_type);
434   ASSERT_EQ(link_key, security_record_->GetLinkKey());
435   ASSERT_EQ(key_type, security_record_->GetKeyType());
436   ASSERT_FALSE(security_record_->IsAuthenticated());
437   ASSERT_FALSE(security_record_->RequiresMitmProtection());
438 }
439 
440 // no_input_no_output + display_only is JustWorks no confirmation
441 // Needs dialog as per security a bug unless pairing is temporary
TEST_F(ClassicPairingHandlerTest,locally_initiatied_no_input_no_output_display_only_temp)442 TEST_F(ClassicPairingHandlerTest, locally_initiatied_no_input_no_output_display_only_temp) {
443   hci::IoCapability injected_io_capability = hci::IoCapability::NO_INPUT_NO_OUTPUT;
444   hci::AuthenticationRequirements injected_authentication_requirements = hci::AuthenticationRequirements::NO_BONDING;
445   pairing_handler_->Initiate(
446       true, injected_io_capability, injected_authentication_requirements, pairing::OobData(), pairing::OobData());
447   ReceiveLinkKeyRequest(device_);
448   auto security_command_view = GetLastCommand(hci_layer_);
449   auto link_key_neg_reply = hci::LinkKeyRequestNegativeReplyView::Create(security_command_view);
450   ASSERT_TRUE(link_key_neg_reply.IsValid());
451   ASSERT_EQ(OpCode::LINK_KEY_REQUEST_NEGATIVE_REPLY, link_key_neg_reply.GetOpCode());
452   ReceiveIoCapabilityRequest(device_);
453   security_command_view = GetLastCommand(hci_layer_);
454   ASSERT_EQ(OpCode::IO_CAPABILITY_REQUEST_REPLY, security_command_view.GetOpCode());
455   auto io_cap_request_reply = hci::IoCapabilityRequestReplyView::Create(security_command_view);
456   ASSERT_TRUE(io_cap_request_reply.IsValid());
457   ASSERT_EQ(injected_io_capability, io_cap_request_reply.GetIoCapability());
458   ASSERT_EQ(hci::OobDataPresent::NOT_PRESENT, io_cap_request_reply.GetOobPresent());
459   ASSERT_EQ(injected_authentication_requirements, io_cap_request_reply.GetAuthenticationRequirements());
460   ReceiveIoCapabilityResponse(device_, hci::IoCapability::DISPLAY_ONLY, hci::OobDataPresent::NOT_PRESENT,
461                               hci::AuthenticationRequirements::NO_BONDING);
462   uint32_t numeric_value = 0x123;
463   ReceiveUserConfirmationRequest(device_, numeric_value);
464   security_command_view = GetLastCommand(hci_layer_);
465   ASSERT_EQ(OpCode::USER_CONFIRMATION_REQUEST_REPLY, security_command_view.GetOpCode());
466   auto user_conf_request_reply = hci::UserConfirmationRequestReplyView::Create(security_command_view);
467   ASSERT_TRUE(user_conf_request_reply.IsValid());
468   ReceiveSimplePairingComplete(hci::ErrorCode::SUCCESS, device_);
469   std::array<uint8_t, 16> link_key = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5};
470   hci::KeyType key_type = hci::KeyType::DEBUG_COMBINATION;
471   ReceiveLinkKeyNotification(device_, link_key, key_type);
472   ASSERT_EQ(link_key, security_record_->GetLinkKey());
473   ASSERT_EQ(key_type, security_record_->GetKeyType());
474   ASSERT_FALSE(security_record_->IsAuthenticated());
475   ASSERT_FALSE(security_record_->RequiresMitmProtection());
476 }
477 
478 // no_input_no_output + display_yes_no is JustWorks no confirmation
479 // Needs dialog as per security a bug unless pairing is temporary
TEST_F(ClassicPairingHandlerTest,locally_initiatied_no_input_no_output_display_yes_no_temp)480 TEST_F(ClassicPairingHandlerTest, locally_initiatied_no_input_no_output_display_yes_no_temp) {
481   hci::IoCapability injected_io_capability = hci::IoCapability::NO_INPUT_NO_OUTPUT;
482   hci::AuthenticationRequirements injected_authentication_requirements = hci::AuthenticationRequirements::NO_BONDING;
483   pairing_handler_->Initiate(
484       true, injected_io_capability, injected_authentication_requirements, pairing::OobData(), pairing::OobData());
485   ReceiveLinkKeyRequest(device_);
486   auto security_command_view = GetLastCommand(hci_layer_);
487   auto link_key_neg_reply = hci::LinkKeyRequestNegativeReplyView::Create(security_command_view);
488   ASSERT_TRUE(link_key_neg_reply.IsValid());
489   ASSERT_EQ(OpCode::LINK_KEY_REQUEST_NEGATIVE_REPLY, link_key_neg_reply.GetOpCode());
490   ReceiveIoCapabilityRequest(device_);
491   security_command_view = GetLastCommand(hci_layer_);
492   ASSERT_EQ(OpCode::IO_CAPABILITY_REQUEST_REPLY, security_command_view.GetOpCode());
493   auto io_cap_request_reply = hci::IoCapabilityRequestReplyView::Create(security_command_view);
494   ASSERT_TRUE(io_cap_request_reply.IsValid());
495   ASSERT_EQ(injected_io_capability, io_cap_request_reply.GetIoCapability());
496   ASSERT_EQ(hci::OobDataPresent::NOT_PRESENT, io_cap_request_reply.GetOobPresent());
497   ASSERT_EQ(injected_authentication_requirements, io_cap_request_reply.GetAuthenticationRequirements());
498   ReceiveIoCapabilityResponse(device_, hci::IoCapability::DISPLAY_YES_NO, hci::OobDataPresent::NOT_PRESENT,
499                               hci::AuthenticationRequirements::NO_BONDING);
500   uint32_t numeric_value = 0x123;
501   ReceiveUserConfirmationRequest(device_, numeric_value);
502   security_command_view = GetLastCommand(hci_layer_);
503   ASSERT_EQ(OpCode::USER_CONFIRMATION_REQUEST_REPLY, security_command_view.GetOpCode());
504   auto user_conf_request_reply = hci::UserConfirmationRequestReplyView::Create(security_command_view);
505   ASSERT_TRUE(user_conf_request_reply.IsValid());
506   ReceiveSimplePairingComplete(hci::ErrorCode::SUCCESS, device_);
507   std::array<uint8_t, 16> link_key = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5};
508   hci::KeyType key_type = hci::KeyType::DEBUG_COMBINATION;
509   ReceiveLinkKeyNotification(device_, link_key, key_type);
510   ASSERT_EQ(link_key, security_record_->GetLinkKey());
511   ASSERT_EQ(key_type, security_record_->GetKeyType());
512   ASSERT_FALSE(security_record_->IsAuthenticated());
513   ASSERT_FALSE(security_record_->RequiresMitmProtection());
514 }
515 
516 // no_input_no_output + keyboard_only is JustWorks no confirmation
517 // Needs dialog as per security a bug unless pairing is temporary
TEST_F(ClassicPairingHandlerTest,locally_initiatied_no_input_no_output_keyboard_only_temp)518 TEST_F(ClassicPairingHandlerTest, locally_initiatied_no_input_no_output_keyboard_only_temp) {
519   hci::IoCapability injected_io_capability = hci::IoCapability::NO_INPUT_NO_OUTPUT;
520   hci::AuthenticationRequirements injected_authentication_requirements = hci::AuthenticationRequirements::NO_BONDING;
521   pairing_handler_->Initiate(
522       true, injected_io_capability, injected_authentication_requirements, pairing::OobData(), pairing::OobData());
523   ReceiveLinkKeyRequest(device_);
524   auto security_command_view = GetLastCommand(hci_layer_);
525   auto link_key_neg_reply = hci::LinkKeyRequestNegativeReplyView::Create(security_command_view);
526   ASSERT_TRUE(link_key_neg_reply.IsValid());
527   ASSERT_EQ(OpCode::LINK_KEY_REQUEST_NEGATIVE_REPLY, link_key_neg_reply.GetOpCode());
528   ReceiveIoCapabilityRequest(device_);
529   security_command_view = GetLastCommand(hci_layer_);
530   ASSERT_EQ(OpCode::IO_CAPABILITY_REQUEST_REPLY, security_command_view.GetOpCode());
531   auto io_cap_request_reply = hci::IoCapabilityRequestReplyView::Create(security_command_view);
532   ASSERT_TRUE(io_cap_request_reply.IsValid());
533   ASSERT_EQ(injected_io_capability, io_cap_request_reply.GetIoCapability());
534   ASSERT_EQ(hci::OobDataPresent::NOT_PRESENT, io_cap_request_reply.GetOobPresent());
535   ASSERT_EQ(injected_authentication_requirements, io_cap_request_reply.GetAuthenticationRequirements());
536   ReceiveIoCapabilityResponse(device_, hci::IoCapability::KEYBOARD_ONLY, hci::OobDataPresent::NOT_PRESENT,
537                               hci::AuthenticationRequirements::NO_BONDING);
538   uint32_t numeric_value = 0x123;
539   ReceiveUserConfirmationRequest(device_, numeric_value);
540   security_command_view = GetLastCommand(hci_layer_);
541   ASSERT_EQ(OpCode::USER_CONFIRMATION_REQUEST_REPLY, security_command_view.GetOpCode());
542   auto user_conf_request_reply = hci::UserConfirmationRequestReplyView::Create(security_command_view);
543   ASSERT_TRUE(user_conf_request_reply.IsValid());
544   ReceiveSimplePairingComplete(hci::ErrorCode::SUCCESS, device_);
545   std::array<uint8_t, 16> link_key = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5};
546   hci::KeyType key_type = hci::KeyType::DEBUG_COMBINATION;
547   ReceiveLinkKeyNotification(device_, link_key, key_type);
548   ASSERT_EQ(link_key, security_record_->GetLinkKey());
549   ASSERT_EQ(key_type, security_record_->GetKeyType());
550   ASSERT_FALSE(security_record_->IsAuthenticated());
551   ASSERT_FALSE(security_record_->RequiresMitmProtection());
552 }
553 
554 // no_input_no_output + no_input_no_output is JustWorks no confirmation
555 // Needs dialog as per security a bug unless pairing is temporary
TEST_F(ClassicPairingHandlerTest,locally_initiatied_no_input_no_output_no_input_no_output_temp)556 TEST_F(ClassicPairingHandlerTest, locally_initiatied_no_input_no_output_no_input_no_output_temp) {
557   hci::IoCapability injected_io_capability = hci::IoCapability::NO_INPUT_NO_OUTPUT;
558   hci::AuthenticationRequirements injected_authentication_requirements = hci::AuthenticationRequirements::NO_BONDING;
559   pairing_handler_->Initiate(
560       true, injected_io_capability, injected_authentication_requirements, pairing::OobData(), pairing::OobData());
561   ReceiveLinkKeyRequest(device_);
562   auto security_command_view = GetLastCommand(hci_layer_);
563   auto link_key_neg_reply = hci::LinkKeyRequestNegativeReplyView::Create(security_command_view);
564   ASSERT_TRUE(link_key_neg_reply.IsValid());
565   ASSERT_EQ(OpCode::LINK_KEY_REQUEST_NEGATIVE_REPLY, link_key_neg_reply.GetOpCode());
566   ReceiveIoCapabilityRequest(device_);
567   security_command_view = GetLastCommand(hci_layer_);
568   ASSERT_EQ(OpCode::IO_CAPABILITY_REQUEST_REPLY, security_command_view.GetOpCode());
569   auto io_cap_request_reply = hci::IoCapabilityRequestReplyView::Create(security_command_view);
570   ASSERT_TRUE(io_cap_request_reply.IsValid());
571   ASSERT_EQ(injected_io_capability, io_cap_request_reply.GetIoCapability());
572   ASSERT_EQ(hci::OobDataPresent::NOT_PRESENT, io_cap_request_reply.GetOobPresent());
573   ASSERT_EQ(injected_authentication_requirements, io_cap_request_reply.GetAuthenticationRequirements());
574   ReceiveIoCapabilityResponse(device_, hci::IoCapability::NO_INPUT_NO_OUTPUT, hci::OobDataPresent::NOT_PRESENT,
575                               hci::AuthenticationRequirements::NO_BONDING);
576   uint32_t numeric_value = 0x123;
577   ReceiveUserConfirmationRequest(device_, numeric_value);
578   security_command_view = GetLastCommand(hci_layer_);
579   ASSERT_EQ(OpCode::USER_CONFIRMATION_REQUEST_REPLY, security_command_view.GetOpCode());
580   auto user_conf_request_reply = hci::UserConfirmationRequestReplyView::Create(security_command_view);
581   ASSERT_TRUE(user_conf_request_reply.IsValid());
582   ReceiveSimplePairingComplete(hci::ErrorCode::SUCCESS, device_);
583   std::array<uint8_t, 16> link_key = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5};
584   hci::KeyType key_type = hci::KeyType::DEBUG_COMBINATION;
585   ReceiveLinkKeyNotification(device_, link_key, key_type);
586   ASSERT_EQ(link_key, security_record_->GetLinkKey());
587   ASSERT_EQ(key_type, security_record_->GetKeyType());
588   ASSERT_FALSE(security_record_->IsAuthenticated());
589   ASSERT_FALSE(security_record_->RequiresMitmProtection());
590 }
591 
TEST_F(ClassicPairingHandlerTest,remote_initiatied_no_input_no_output_no_input_no_output_with_missing_oob_data)592 TEST_F(ClassicPairingHandlerTest, remote_initiatied_no_input_no_output_no_input_no_output_with_missing_oob_data) {}
593 
594 // CreateBondOutOfBand no_input_no_output + no_input_no_output OOB Data missing when asked
TEST_F(ClassicPairingHandlerTest,locally_initiatied_no_input_no_output_no_input_no_output_with_missing_oob_data)595 TEST_F(ClassicPairingHandlerTest, locally_initiatied_no_input_no_output_no_input_no_output_with_missing_oob_data) {
596   expect_success_ = false;
597   hci::IoCapability injected_io_capability = hci::IoCapability::NO_INPUT_NO_OUTPUT;
598   hci::AuthenticationRequirements injected_authentication_requirements = hci::AuthenticationRequirements::NO_BONDING;
599   pairing_handler_->Initiate(
600       true, injected_io_capability, injected_authentication_requirements, pairing::OobData(), pairing::OobData());
601 
602   ReceiveLinkKeyRequest(device_);
603   auto security_command_view = GetLastCommand(hci_layer_);
604   auto link_key_neg_reply = hci::LinkKeyRequestNegativeReplyView::Create(security_command_view);
605   ASSERT_TRUE(link_key_neg_reply.IsValid());
606   ASSERT_EQ(OpCode::LINK_KEY_REQUEST_NEGATIVE_REPLY, link_key_neg_reply.GetOpCode());
607   ReceiveIoCapabilityRequest(device_);
608   security_command_view = GetLastCommand(hci_layer_);
609   ASSERT_EQ(OpCode::IO_CAPABILITY_REQUEST_REPLY, security_command_view.GetOpCode());
610   auto io_cap_request_reply = hci::IoCapabilityRequestReplyView::Create(security_command_view);
611   ASSERT_TRUE(io_cap_request_reply.IsValid());
612   ASSERT_EQ(injected_io_capability, io_cap_request_reply.GetIoCapability());
613   ASSERT_EQ(hci::OobDataPresent::NOT_PRESENT, io_cap_request_reply.GetOobPresent());
614   ASSERT_EQ(injected_authentication_requirements, io_cap_request_reply.GetAuthenticationRequirements());
615   ReceiveIoCapabilityResponse(
616       device_,
617       hci::IoCapability::NO_INPUT_NO_OUTPUT,
618       hci::OobDataPresent::NOT_PRESENT,
619       hci::AuthenticationRequirements::NO_BONDING);
620   // At this point the pairing handler thinks it has NOT_PRESENT
621   ReceiveOobDataRequest(device_);
622   security_command_view = GetLastCommand(hci_layer_);
623   auto oob_data_req_neg_reply = hci::RemoteOobDataRequestNegativeReplyView::Create(security_command_view);
624   ASSERT_TRUE(oob_data_req_neg_reply.IsValid());
625   ASSERT_EQ(OpCode::REMOTE_OOB_DATA_REQUEST_NEGATIVE_REPLY, oob_data_req_neg_reply.GetOpCode());
626   ReceiveSimplePairingComplete(hci::ErrorCode::AUTHENTICATION_FAILURE, device_);
627 }
628 
629 // CreateBondOutOfBand no_input_no_output + no_input_no_output OOB Data P192
TEST_F(ClassicPairingHandlerTest,locally_initiatied_no_input_no_output_no_input_no_output_p192_oob_data)630 TEST_F(ClassicPairingHandlerTest, locally_initiatied_no_input_no_output_no_input_no_output_p192_oob_data) {
631   hci::IoCapability injected_io_capability = hci::IoCapability::NO_INPUT_NO_OUTPUT;
632   hci::AuthenticationRequirements injected_authentication_requirements = hci::AuthenticationRequirements::NO_BONDING;
633   pairing::OobData oob_data(
634       {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0});
635   pairing_handler_->Initiate(
636       true, injected_io_capability, injected_authentication_requirements, oob_data, pairing::OobData());
637 
638   ReceiveLinkKeyRequest(device_);
639   auto security_command_view = GetLastCommand(hci_layer_);
640   auto link_key_neg_reply = hci::LinkKeyRequestNegativeReplyView::Create(security_command_view);
641   ASSERT_TRUE(link_key_neg_reply.IsValid());
642   ASSERT_EQ(OpCode::LINK_KEY_REQUEST_NEGATIVE_REPLY, link_key_neg_reply.GetOpCode());
643   ReceiveIoCapabilityRequest(device_);
644   security_command_view = GetLastCommand(hci_layer_);
645   ASSERT_EQ(OpCode::IO_CAPABILITY_REQUEST_REPLY, security_command_view.GetOpCode());
646   auto io_cap_request_reply = hci::IoCapabilityRequestReplyView::Create(security_command_view);
647   ASSERT_TRUE(io_cap_request_reply.IsValid());
648   ASSERT_EQ(injected_io_capability, io_cap_request_reply.GetIoCapability());
649   ASSERT_EQ(hci::OobDataPresent::P_192_PRESENT, io_cap_request_reply.GetOobPresent());
650   ASSERT_EQ(injected_authentication_requirements, io_cap_request_reply.GetAuthenticationRequirements());
651   ReceiveIoCapabilityResponse(
652       device_,
653       hci::IoCapability::NO_INPUT_NO_OUTPUT,
654       hci::OobDataPresent::NOT_PRESENT,
655       hci::AuthenticationRequirements::NO_BONDING);
656   // At this point the pairing handler thinks it has NOT_PRESENT
657   ReceiveOobDataRequest(device_);
658   security_command_view = GetLastCommand(hci_layer_);
659   // NOTE(optedoblivion): Extended data is manually disabled in the pairing handler
660   // since the controller doesn't seem to currently have support.
661   auto oob_data_req_reply = hci::RemoteOobDataRequestReplyView::Create(security_command_view);
662   ASSERT_TRUE(oob_data_req_reply.IsValid());
663   ASSERT_EQ(OpCode::REMOTE_OOB_DATA_REQUEST_REPLY, oob_data_req_reply.GetOpCode());
664   ReceiveSimplePairingComplete(hci::ErrorCode::SUCCESS, device_);
665   std::array<uint8_t, 16> link_key = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5};
666   hci::KeyType key_type = hci::KeyType::DEBUG_COMBINATION;
667   ReceiveLinkKeyNotification(device_, link_key, key_type);
668   ASSERT_EQ(link_key, security_record_->GetLinkKey());
669   ASSERT_EQ(key_type, security_record_->GetKeyType());
670   ASSERT_FALSE(security_record_->IsAuthenticated());
671   ASSERT_FALSE(security_record_->RequiresMitmProtection());
672 }
673 
674 // CreateBondOutOfBand no_input_no_output + no_input_no_output OOB Data P256
TEST_F(ClassicPairingHandlerTest,locally_initiatied_no_input_no_output_no_input_no_output_p256_oob_data)675 TEST_F(ClassicPairingHandlerTest, locally_initiatied_no_input_no_output_no_input_no_output_p256_oob_data) {
676   hci::IoCapability injected_io_capability = hci::IoCapability::NO_INPUT_NO_OUTPUT;
677   hci::AuthenticationRequirements injected_authentication_requirements = hci::AuthenticationRequirements::NO_BONDING;
678   pairing::OobData oob_data(
679       {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0});
680   pairing_handler_->Initiate(
681       true, injected_io_capability, injected_authentication_requirements, pairing::OobData(), oob_data);
682   ReceiveLinkKeyRequest(device_);
683   auto security_command_view = GetLastCommand(hci_layer_);
684   auto link_key_neg_reply = hci::LinkKeyRequestNegativeReplyView::Create(security_command_view);
685   ASSERT_TRUE(link_key_neg_reply.IsValid());
686   ASSERT_EQ(OpCode::LINK_KEY_REQUEST_NEGATIVE_REPLY, link_key_neg_reply.GetOpCode());
687   ReceiveIoCapabilityRequest(device_);
688   security_command_view = GetLastCommand(hci_layer_);
689   ASSERT_EQ(OpCode::IO_CAPABILITY_REQUEST_REPLY, security_command_view.GetOpCode());
690   auto io_cap_request_reply = hci::IoCapabilityRequestReplyView::Create(security_command_view);
691   ASSERT_TRUE(io_cap_request_reply.IsValid());
692   ASSERT_EQ(injected_io_capability, io_cap_request_reply.GetIoCapability());
693   ASSERT_EQ(hci::OobDataPresent::P_256_PRESENT, io_cap_request_reply.GetOobPresent());
694   ASSERT_EQ(injected_authentication_requirements, io_cap_request_reply.GetAuthenticationRequirements());
695   ReceiveIoCapabilityResponse(
696       device_,
697       hci::IoCapability::NO_INPUT_NO_OUTPUT,
698       hci::OobDataPresent::NOT_PRESENT,
699       hci::AuthenticationRequirements::NO_BONDING);
700   // At this point the pairing handler thinks it has NOT_PRESENT
701   ReceiveOobDataRequest(device_);
702   security_command_view = GetLastCommand(hci_layer_);
703   auto oob_data_req_reply = hci::RemoteOobExtendedDataRequestReplyView::Create(security_command_view);
704   ASSERT_TRUE(oob_data_req_reply.IsValid());
705   ASSERT_EQ(OpCode::REMOTE_OOB_EXTENDED_DATA_REQUEST_REPLY, oob_data_req_reply.GetOpCode());
706   ReceiveSimplePairingComplete(hci::ErrorCode::SUCCESS, device_);
707   std::array<uint8_t, 16> link_key = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5};
708   hci::KeyType key_type = hci::KeyType::DEBUG_COMBINATION;
709   ReceiveLinkKeyNotification(device_, link_key, key_type);
710   ASSERT_EQ(link_key, security_record_->GetLinkKey());
711   ASSERT_EQ(key_type, security_record_->GetKeyType());
712   ASSERT_FALSE(security_record_->IsAuthenticated());
713   ASSERT_FALSE(security_record_->RequiresMitmProtection());
714 }
715 
716 // CreateBondOutOfBand no_input_no_output + no_input_no_output OOB Data P192 and 256
TEST_F(ClassicPairingHandlerTest,locally_initiatied_no_input_no_output_no_input_no_output_p192_and_256_oob_data)717 TEST_F(ClassicPairingHandlerTest, locally_initiatied_no_input_no_output_no_input_no_output_p192_and_256_oob_data) {
718   hci::IoCapability injected_io_capability = hci::IoCapability::NO_INPUT_NO_OUTPUT;
719   hci::AuthenticationRequirements injected_authentication_requirements = hci::AuthenticationRequirements::NO_BONDING;
720   pairing::OobData oob_data(
721       {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0});
722   pairing_handler_->Initiate(true, injected_io_capability, injected_authentication_requirements, oob_data, oob_data);
723   ReceiveLinkKeyRequest(device_);
724   auto security_command_view = GetLastCommand(hci_layer_);
725   auto link_key_neg_reply = hci::LinkKeyRequestNegativeReplyView::Create(security_command_view);
726   ASSERT_TRUE(link_key_neg_reply.IsValid());
727   ASSERT_EQ(OpCode::LINK_KEY_REQUEST_NEGATIVE_REPLY, link_key_neg_reply.GetOpCode());
728   ReceiveIoCapabilityRequest(device_);
729   security_command_view = GetLastCommand(hci_layer_);
730   ASSERT_EQ(OpCode::IO_CAPABILITY_REQUEST_REPLY, security_command_view.GetOpCode());
731   auto io_cap_request_reply = hci::IoCapabilityRequestReplyView::Create(security_command_view);
732   ASSERT_TRUE(io_cap_request_reply.IsValid());
733   ASSERT_EQ(injected_io_capability, io_cap_request_reply.GetIoCapability());
734   ASSERT_EQ(hci::OobDataPresent::P_192_AND_256_PRESENT, io_cap_request_reply.GetOobPresent());
735   ASSERT_EQ(injected_authentication_requirements, io_cap_request_reply.GetAuthenticationRequirements());
736   ReceiveIoCapabilityResponse(
737       device_,
738       hci::IoCapability::NO_INPUT_NO_OUTPUT,
739       hci::OobDataPresent::NOT_PRESENT,
740       hci::AuthenticationRequirements::NO_BONDING);
741   // At this point the pairing handler thinks it has NOT_PRESENT
742   ReceiveOobDataRequest(device_);
743   security_command_view = GetLastCommand(hci_layer_);
744   auto oob_data_req_reply = hci::RemoteOobExtendedDataRequestReplyView::Create(security_command_view);
745   ASSERT_TRUE(oob_data_req_reply.IsValid());
746   ASSERT_EQ(OpCode::REMOTE_OOB_EXTENDED_DATA_REQUEST_REPLY, oob_data_req_reply.GetOpCode());
747   ReceiveSimplePairingComplete(hci::ErrorCode::SUCCESS, device_);
748   std::array<uint8_t, 16> link_key = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5};
749   hci::KeyType key_type = hci::KeyType::DEBUG_COMBINATION;
750   ReceiveLinkKeyNotification(device_, link_key, key_type);
751   ASSERT_EQ(link_key, security_record_->GetLinkKey());
752   ASSERT_EQ(key_type, security_record_->GetKeyType());
753   ASSERT_FALSE(security_record_->IsAuthenticated());
754   ASSERT_FALSE(security_record_->RequiresMitmProtection());
755 }
756 
757 /*** Numeric Comparison ***/
758 // display_yes_no + display_only
759 
760 // display_yes_no + display_yes_no
761 // display_yes_no + keyboard_only
762 // display_yes_no + no_input_no_output
763 
764 // keyboard_only + display_only
765 // keyboard_only + display_yes_no
766 
767 // keyboard_only + keyboard_only  (a just works I missed)
768 
769 // Remotely initiated
770 
771 // Collisions
772 
773 }  // namespace
774 }  // namespace pairing
775 }  // namespace security
776 }  // namespace bluetooth
777