| #!/usr/bin/env python3 |
| # |
| # Copyright (C) 2021 The Android Open Source Project |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| # use this file except in compliance with the License. You may obtain a copy of |
| # the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| # License for the specific language governing permissions and limitations under |
| # the License. |
| """ |
| PTS GAP/SEC/SEM Automation |
| |
| Optional custom parameter "collect_detailed_pass_logs" |
| Used to collect link keys and extra logs on pass results |
| to be used for certification purposes. |
| """ |
| |
| from acts import signals |
| from acts.base_test import BaseTestClass |
| from acts.test_decorators import test_tracker_info |
| from acts_contrib.test_utils.bt.bt_test_utils import generate_id_by_size |
| from acts_contrib.test_utils.fuchsia.bt_test_utils import le_scan_for_device_by_name |
| from acts_contrib.test_utils.fuchsia.bt_test_utils import get_link_keys |
| from acts_contrib.test_utils.fuchsia.bt_test_utils import unbond_all_known_devices |
| from contextlib import suppress |
| import inspect |
| |
| |
| class GapSecSemTest(BaseTestClass): |
| gatt_connect_err_message = "Gatt connection failed with: {}" |
| gatt_disconnect_err_message = "Gatt disconnection failed with: {}" |
| ble_advertise_interval = 50 |
| scan_timeout_seconds = 60 |
| |
| def setup_class(self): |
| super().setup_class() |
| self.pri_dut = self.fuchsia_devices[0] |
| # TODO: fxb/57968 Provide Facade for setting secure connections only mode, |
| # for the interim set this manually in the build. |
| self.sec_dut = self.fuchsia_devices[1] |
| for fd in self.fuchsia_devices: |
| fd.sl4f.bts_lib.initBluetoothSys() |
| # Optional user param for collecting enough information for |
| # certification on pass results. |
| self.collect_detailed_pass_logs = self.user_params.get( |
| "collect_detailed_pass_logs", False) |
| |
| def on_fail(self, test_name, begin_time): |
| for fd in self.fuchsia_devices: |
| fd.take_bug_report(test_name, begin_time) |
| |
| def teardown_test(self): |
| # Stop scanning and advertising on all devices at the end of a test. |
| with suppress(Exception): |
| for fd in self.fuchsia_devices: |
| fd.sl4f.ble_lib.bleStopBleAdvertising() |
| fd.bleStopBleScan() |
| for fd in self.fuchsia_devices: |
| unbond_all_known_devices(fd, self.log) |
| |
| def teardown_class(self): |
| for fd in self.fuchsia_devices: |
| fd.sl4f.bts_lib.requestDiscovery(False) |
| |
| def on_pass(self, test_name, begin_time): |
| if self.collect_detailed_pass_logs == True: |
| for fd in self.fuchsia_devices: |
| fd.take_bt_snoop_log(test_name) |
| fd.take_bug_report(test_name, begin_time) |
| |
| def _orchestrate_gatt_connection(self, central, peripheral): |
| """ Orchestrate a GATT connetion from the input Central |
| Fuchsia device to the Peripheral Fuchsia device. |
| Args: |
| central: The central Fuchsia device |
| peripheral: The peripheral Fuchsia device |
| peripheral: The peripheral role Fuchsia device |
| Returns: |
| Dictionary of device info if connection successful. |
| """ |
| adv_name = generate_id_by_size(10) |
| adv_data = { |
| "name": adv_name, |
| "appearance": None, |
| "service_data": None, |
| "tx_power_level": None, |
| "service_uuids": None, |
| "manufacturer_data": None, |
| "uris": None, |
| } |
| scan_response = None |
| connectable = True |
| |
| peripheral.sl4f.ble_lib.bleStartBleAdvertising( |
| adv_data, scan_response, self.ble_advertise_interval, connectable) |
| scan_filter = {"name_substring": adv_name} |
| central.sl4f.gattc_lib.bleStartBleScan(scan_filter) |
| device = le_scan_for_device_by_name(central, |
| self.log, |
| adv_name, |
| self.scan_timeout_seconds, |
| partial_match=False, |
| self_manage_scan=False) |
| if device is None: |
| raise signals.TestFailure("Scanner unable to find advertisement.") |
| connect_result = central.sl4f.gattc_lib.bleConnectToPeripheral( |
| device["id"]) |
| if connect_result.get("error") is not None: |
| raise signals.TestFailure( |
| self.gatt_connect_err_message.format( |
| connect_result.get("error"))) |
| self.log.info("Connection Successful...") |
| |
| return device |
| |
| def _orchestrate_gap_sec_sem_37_to_44_test(self, test_name, central, |
| peripheral, |
| is_central_pairing_initiator, |
| security_level): |
| """ Performs GAP/SEC/SEM/BV-37 to 44 tests. |
| These set of tests deal with varying modes and directions of |
| service level connections with LE secure Connections. |
| |
| Args: |
| test_name: The name of the test for logging purposes |
| central: The central role Fuchsia device |
| peripheral: The peripheral role Fuchsia device |
| is_central_pairing_initiator: True if Central should initiate |
| the pairing. False if Peripheral should initiate. |
| security_level: 1 for Encrypted, 2 for Authenticated |
| Orchestration Steps: |
| 1. Perform GATT connection from Central to Peripheral |
| 2. Pair with specified security_level in direction specified |
| by is_central_pairing_initiator. |
| 3. Exchange pairing pins |
| 4. Collect link keys if applicable |
| 5. Disconnect device |
| 6. Forget pairing. |
| """ |
| input_capabilities = "NONE" |
| output_capabilities = "NONE" |
| |
| central.sl4f.bts_lib.acceptPairing("KEYBOARD", "DISPLAY") |
| |
| peripheral.sl4f.bts_lib.acceptPairing("KEYBOARD", "DISPLAY") |
| |
| device = self._orchestrate_gatt_connection(central, peripheral) |
| # TODO: fxb/71289 Change once all peer IDs are ints and not strings |
| identifier = int("0x{}".format(device["id"]), 0) |
| bondable = True |
| transport = 2 #LE |
| if is_central_pairing_initiator: |
| pair_result = central.sl4f.bts_lib.pair(identifier, security_level, |
| bondable, transport) |
| if not is_central_pairing_initiator: |
| device_list = peripheral.sl4f.bts_lib.getKnownRemoteDevices( |
| )['result'] |
| print(device_list) |
| for id_dict in device_list: |
| d = device_list[id_dict] |
| name = None |
| if d['connected'] is True: |
| did = d['id'] |
| pair_result = peripheral.sl4f.bts_lib.pair(did, security_level, |
| bondable, transport) |
| |
| pins_transferred = False |
| pairing_pin = central.sl4f.bts_lib.getPairingPin()['result'] |
| if pairing_pin != "0" and pairing_pin is not None: |
| peripheral.sl4f.bts_lib.inputPairingPin(pairing_pin) |
| pins_transferred = True |
| if not pins_transferred: |
| pairing_pin = peripheral.sl4f.bts_lib.getPairingPin()['result'] |
| if pairing_pin != "0": |
| central.sl4f.bts_lib.inputPairingPin(pairing_pin) |
| |
| if self.collect_detailed_pass_logs == True: |
| save_path = f"{central.log_path}/{test_name}_stash_secure.store" |
| self.log.info( |
| f"Known Link Keys: {get_link_keys(central, save_path)}") |
| save_path = f"{peripheral.log_path}/{test_name}_stash_secure.store" |
| self.log.info( |
| f"Known Link Keys: {get_link_keys(peripheral, save_path)}") |
| |
| disconnect_result = central.sl4f.gattc_lib.bleDisconnectPeripheral( |
| device["id"]) |
| if disconnect_result.get("error") is not None: |
| raise signals.TestFailure( |
| self.gatt_disconnect_err_message.format( |
| disconnect_result.get("error"))) |
| self.log.info("Disconnection Successful...") |
| |
| central.sl4f.bts_lib.forgetDevice(identifier) |
| |
| raise signals.TestPass("Success") |
| |
| def test_gap_sec_sem_bv_37_c(self): |
| central = self.pri_dut |
| peripheral = self.sec_dut |
| is_central_pairing_initiator = True |
| security_level = 1 # Encrypted |
| test_name = inspect.currentframe().f_code.co_name |
| self._orchestrate_gap_sec_sem_37_to_44_test( |
| test_name, central, peripheral, is_central_pairing_initiator, |
| security_level) |
| |
| def test_gap_sec_sem_bv_38_c(self): |
| central = self.pri_dut |
| peripheral = self.sec_dut |
| is_central_pairing_initiator = True |
| security_level = 2 # Authenticated |
| test_name = inspect.currentframe().f_code.co_name |
| self._orchestrate_gap_sec_sem_37_to_44_test( |
| test_name, central, peripheral, is_central_pairing_initiator, |
| security_level) |
| |
| def test_gap_sec_sem_bv_39_c(self): |
| central = self.pri_dut |
| peripheral = self.sec_dut |
| is_central_pairing_initiator = False |
| security_level = 1 # Encrypted |
| test_name = inspect.currentframe().f_code.co_name |
| self._orchestrate_gap_sec_sem_37_to_44_test( |
| test_name, central, peripheral, is_central_pairing_initiator, |
| security_level) |
| |
| def test_gap_sec_sem_bv_40_c(self): |
| central = self.pri_dut |
| peripheral = self.sec_dut |
| is_central_pairing_initiator = False |
| security_level = 2 # Authenticated |
| test_name = inspect.currentframe().f_code.co_name |
| self._orchestrate_gap_sec_sem_37_to_44_test( |
| test_name, central, peripheral, is_central_pairing_initiator, |
| security_level) |
| |
| def test_gap_sec_sem_bv_41_c(self): |
| central = self.sec_dut |
| peripheral = self.pri_dut |
| is_central_pairing_initiator = True |
| security_level = 1 # Encrypted |
| test_name = inspect.currentframe().f_code.co_name |
| self._orchestrate_gap_sec_sem_37_to_44_test( |
| test_name, central, peripheral, is_central_pairing_initiator, |
| security_level) |
| |
| def test_gap_sec_sem_bv_42_c(self): |
| central = self.sec_dut |
| peripheral = self.pri_dut |
| is_central_pairing_initiator = True |
| security_level = 2 # Authenticated |
| test_name = inspect.currentframe().f_code.co_name |
| self._orchestrate_gap_sec_sem_37_to_44_test( |
| test_name, central, peripheral, is_central_pairing_initiator, |
| security_level) |
| |
| def test_gap_sec_sem_bv_43_c(self): |
| central = self.sec_dut |
| peripheral = self.pri_dut |
| is_central_pairing_initiator = False |
| security_level = 1 # Encrypted |
| test_name = inspect.currentframe().f_code.co_name |
| self._orchestrate_gap_sec_sem_37_to_44_test( |
| test_name, central, peripheral, is_central_pairing_initiator, |
| security_level) |
| |
| def test_gap_sec_sem_bv_44_c(self): |
| central = self.sec_dut |
| peripheral = self.pri_dut |
| is_central_pairing_initiator = False |
| security_level = 2 # Authenticated |
| test_name = inspect.currentframe().f_code.co_name |
| self._orchestrate_gap_sec_sem_37_to_44_test( |
| test_name, central, peripheral, is_central_pairing_initiator, |
| security_level) |
