def test_connection_cert_connects(self):
self.send_hal_hci_command(hci_packets.WritePageTimeoutBuilder(0x4000))
# DUT Enables scans and gets its address
self.dut_hci.send_command_with_complete(
hci_packets.WriteScanEnableBuilder(
hci_packets.ScanEnable.INQUIRY_AND_PAGE_SCAN))
self.dut_hci.send_command_with_complete(
hci_packets.ReadBdAddrBuilder())
read_bd_addr_capture = HciCaptures.ReadBdAddrCompleteCapture()
assertThat(self.dut_hci.get_event_stream()).emits(read_bd_addr_capture)
address = read_bd_addr_capture.get().GetBdAddr()
# Cert Connects
self.send_hal_hci_command(
hci_packets.CreateConnectionBuilder(
address,
0xcc18, # Packet Type
hci_packets.PageScanRepetitionMode.R0,
0,
hci_packets.ClockOffsetValid.INVALID,
hci_packets.CreateConnectionRoleSwitch.ALLOW_ROLE_SWITCH))
# DUT Accepts
connection_request_capture = HciCaptures.ConnectionRequestCapture()
assertThat(self.dut_hci.get_event_stream()).emits(
connection_request_capture, timeout=timedelta(seconds=20))
connection_request = connection_request_capture.get()
self.dut_hci.send_command_with_status(
hci_packets.AcceptConnectionRequestBuilder(
connection_request.GetBdAddr(),
hci_packets.AcceptConnectionRequestRole.REMAIN_SLAVE))
(dut_handle, cert_handle) = self._verify_connection_complete()
# Send ACL Data
self.enqueue_acl_data(
dut_handle,
hci_packets.PacketBoundaryFlag.FIRST_NON_AUTOMATICALLY_FLUSHABLE,
hci_packets.BroadcastFlag.POINT_TO_POINT,
bytes(b'This is just SomeAclData'))
self.send_hal_acl_data(
cert_handle,
hci_packets.PacketBoundaryFlag.FIRST_NON_AUTOMATICALLY_FLUSHABLE,
hci_packets.BroadcastFlag.POINT_TO_POINT,
bytes(b'This is just SomeMoreAclData'))
assertThat(self.cert_hal.get_acl_stream()).emits(
lambda packet: b'SomeAclData' in packet.payload)
assertThat(self.dut_hci.get_raw_acl_stream()).emits(
lambda packet: b'SomeMoreAclData' in packet.data)
def complete_connection(self, event_stream):
connection_complete = HciCaptures.ConnectionCompleteCapture()
assertThat(event_stream).emits(connection_complete)
complete = connection_complete.get()
handle = complete.GetConnectionHandle()
address = complete.GetBdAddr()
return PyAclManagerAclConnection(self.acl_manager, address, handle,
event_stream)
def complete_connection(self):
connection_complete = HciCaptures.ConnectionCompleteCapture()
assertThat(self.event_stream).emits(connection_complete)
handle = connection_complete.get().GetConnectionHandle()
if self.acl_stream is None:
raise Exception("Please construct '%s' with acl_streaming=True!" % self.__class__.__name__)
return PyHciAclConnection(handle, self.acl_stream, self.device)
def accept_connection(self):
connection_request = HciCaptures.ConnectionRequestCapture()
assertThat(self.event_stream).emits(connection_request)
self.send_command(
hci_packets.AcceptConnectionRequestBuilder(connection_request.get().GetBdAddr(),
hci_packets.AcceptConnectionRequestRole.REMAIN_PERIPHERAL))
return self.complete_connection()
def _verify_le_connection_complete(self):
cert_conn_complete_capture = HalCaptures.LeConnectionCompleteCapture()
assertThat(self.cert_hal.get_hci_event_stream()).emits(
cert_conn_complete_capture)
cert_handle = cert_conn_complete_capture.get().GetConnectionHandle()
dut_conn_complete_capture = HciCaptures.LeConnectionCompleteCapture()
assertThat(self.dut_hci.get_le_event_stream()).emits(
dut_conn_complete_capture)
dut_handle = dut_conn_complete_capture.get().GetConnectionHandle()
return (dut_handle, cert_handle)
def accept_oob_pairing(self, dut_address):
logging.info("Cert: Waiting for IO_CAPABILITY_RESPONSE")
assertThat(self._hci_event_stream).emits(
HciMatchers.IoCapabilityResponse())
self.send_io_caps(dut_address)
logging.info("Cert: Waiting for SIMPLE_PAIRING_COMPLETE")
ssp_complete_capture = HciCaptures.SimplePairingCompleteCapture()
assertThat(self._hci_event_stream).emits(ssp_complete_capture)
ssp_complete = ssp_complete_capture.get()
logging.info(ssp_complete.GetStatus())
assertThat(ssp_complete.GetStatus()).isEqualTo(
hci_packets.ErrorCode.SUCCESS)
def complete_connection(self, event_stream):
connection_complete = HciCaptures.LeConnectionCompleteCapture()
assertThat(event_stream).emits(connection_complete)
complete = connection_complete.get()
handle = complete.GetConnectionHandle()
remote = complete.GetPeerAddress()
if complete.GetSubeventCode(
) == hci_packets.SubeventCode.ENHANCED_CONNECTION_COMPLETE:
address = complete.GetLocalResolvablePrivateAddress()
else:
address = None
connection = PyLeAclManagerAclConnection(self.le_acl_manager, address,
remote, handle, event_stream)
self.active_connections.append(connection)
return connection
def wait_for_disconnection_complete(self):
disconnection_complete = HciCaptures.DisconnectionCompleteCapture()
assertThat(self.connection_event_stream).emits(disconnection_complete)
self.disconnect_reason = disconnection_complete.get().GetReason()
def accept_connection(self):
connection_complete = HciCaptures.ConnectionCompleteCapture()
assertThat(self.incoming_connection_stream).emits(connection_complete)
handle = connection_complete.get().GetConnectionHandle()
return PyAclManagerAclConnection(self.device, self.acl_stream, None,
handle)
def wait_for_connection_complete(self):
connection_complete = HciCaptures.ConnectionCompleteCapture()
assertThat(self.connection_event_stream).emits(connection_complete)
self.handle = connection_complete.get().GetConnectionHandle()
def read_own_address(self):
self.send_command_with_complete(hci_packets.ReadBdAddrBuilder())
read_bd_addr = HciCaptures.ReadBdAddrCompleteCapture()
assertThat(self.event_stream).emits(read_bd_addr)
return read_bd_addr.get().GetBdAddr()
def complete_le_connection(self):
connection_complete = HciCaptures.LeConnectionCompleteCapture()
assertThat(self.hci_event_stream).emits(connection_complete)
handle = connection_complete.get().GetConnectionHandle()
return PyHalAclConnection(handle, self.acl_stream, self.device)
def get_oob_data_from_controller(self, pb_oob_data_type):
"""
Get the Out-of-band data for SSP pairing
:param pb_oob_data_type: Type of data needed
:return: a tuple of bytes (192c,192r,256c,256r) with increasing security; bytes may be all 0s depending on pb_oob_data_type value
"""
oob_data_type = self._oob_present_lookup[pb_oob_data_type]
if (oob_data_type == hci_packets.OobDataPresent.NOT_PRESENT):
logging.warn("No data present, no need to call get_oob_data")
return ([0 for i in range(0, 16)], [0 for i in range(0, 16)],
[0 for i in range(0, 16)], [0 for i in range(0, 16)])
logging.info("Cert: Requesting OOB data")
if oob_data_type == hci_packets.OobDataPresent.P_192_PRESENT:
# If host and controller supports secure connections we always used ReadLocalOobExtendedDataRequest
if self._secure_connections_enabled:
logging.info("Cert: Requesting P192 Data; secure connections")
complete_capture = HciCaptures.ReadLocalOobExtendedDataCompleteCapture(
)
self._enqueue_hci_command(
hci_packets.ReadLocalOobExtendedDataBuilder(), True)
logging.info("Cert: Waiting for OOB response from controller")
assertThat(self._hci_event_stream).emits(complete_capture)
command_complete = complete_capture.get()
complete = hci_packets.ReadLocalOobExtendedDataCompleteView(
command_complete)
return (list(complete.GetC192()), list(complete.GetR192()),
[0 for i in range(0, 16)], [0 for i in range(0, 16)])
# else we use ReadLocalDataRequest
else:
logging.info(
"Cert: Requesting P192 Data; no secure connections")
complete_capture = HciCaptures.ReadLocalOobDataCompleteCapture(
)
self._enqueue_hci_command(
hci_packets.ReadLocalOobDataBuilder(), True)
logging.info("Cert: Waiting for OOB response from controller")
assertThat(self._hci_event_stream).emits(complete_capture)
command_complete = complete_capture.get()
complete = hci_packets.ReadLocalOobDataCompleteView(
command_complete)
return (list(complete.GetC()), list(complete.GetR()),
[0 for i in range(0, 16)], [0 for i in range(0, 16)])
# Must be secure connection compatible to use these
elif oob_data_type == hci_packets.OobDataPresent.P_256_PRESENT:
logging.info(
"Cert: Requesting P256 Extended Data; secure connections")
complete_capture = HciCaptures.ReadLocalOobExtendedDataCompleteCapture(
)
self._enqueue_hci_command(
hci_packets.ReadLocalOobExtendedDataBuilder(), True)
logging.info("Cert: Waiting for OOB response from controller")
assertThat(self._hci_event_stream).emits(complete_capture)
command_complete = complete_capture.get()
complete = hci_packets.ReadLocalOobExtendedDataCompleteView(
command_complete)
return ([0 for i in range(0, 16)], [0 for i in range(0, 16)],
list(complete.GetC256()), list(complete.GetR256()))
else: # Both
logging.info(
"Cert: Requesting P192 AND P256 Extended Data; secure connections"
)
complete_capture = HciCaptures.ReadLocalOobExtendedDataCompleteCapture(
)
self._enqueue_hci_command(
hci_packets.ReadLocalOobExtendedDataBuilder(), True)
logging.info("Cert: Waiting for OOB response from controller")
assertThat(self._hci_event_stream).emits(complete_capture)
command_complete = complete_capture.get()
complete = hci_packets.ReadLocalOobExtendedDataCompleteView(
command_complete)
return (list(complete.GetC192()), list(complete.GetR192()),
list(complete.GetC256()), list(complete.GetR256()))
