| #!/usr/bin/env python3.4 |
| # |
| # Copyright 2018 - 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. |
| |
| import binascii |
| import queue |
| import time |
| |
| from acts import asserts |
| from acts import utils |
| from acts.test_decorators import test_tracker_info |
| from acts_contrib.test_utils.wifi import wifi_constants |
| from acts_contrib.test_utils.wifi import wifi_test_utils as wutils |
| from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest |
| from acts_contrib.test_utils.wifi.aware import aware_test_utils as autils |
| |
| class WifiDppTest(WifiBaseTest): |
| """This class tests the DPP API surface. |
| |
| Attributes: The tests in this class require one DUT and one helper phone |
| device. |
| The tests in this class do not require a SIM. |
| """ |
| |
| DPP_TEST_TIMEOUT = 60 |
| DPP_TEST_SSID_PREFIX = "dpp_test_ssid_" |
| DPP_TEST_SECURITY_SAE = "SAE" |
| DPP_TEST_SECURITY_PSK_PASSPHRASE = "PSK_PASSPHRASE" |
| DPP_TEST_SECURITY_PSK = "PSK" |
| |
| DPP_TEST_EVENT_DPP_CALLBACK = "onDppCallback" |
| DPP_TEST_EVENT_DATA = "data" |
| DPP_TEST_EVENT_ENROLLEE_SUCCESS = "onEnrolleeSuccess" |
| DPP_TEST_EVENT_CONFIGURATOR_SUCCESS = "onConfiguratorSuccess" |
| DPP_TEST_EVENT_PROGRESS = "onProgress" |
| DPP_TEST_EVENT_FAILURE = "onFailure" |
| DPP_TEST_EVENT_URI_GENERATED = "onBootstrapUriGenerated" |
| DPP_TEST_MESSAGE_TYPE = "Type" |
| DPP_TEST_MESSAGE_STATUS = "Status" |
| DPP_TEST_MESSAGE_NETWORK_ID = "NetworkId" |
| DPP_TEST_MESSAGE_FAILURE_SSID = "onFailureSsid" |
| DPP_TEST_MESSAGE_FAILURE_CHANNEL_LIST = "onFailureChannelList" |
| DPP_TEST_MESSAGE_FAILURE_BAND_LIST = "onFailureBandList" |
| DPP_TEST_MESSAGE_GENERATED_URI = "generatedUri" |
| |
| DPP_TEST_NETWORK_ROLE_STA = "sta" |
| DPP_TEST_NETWORK_ROLE_AP = "ap" |
| |
| DPP_TEST_PARAM_SSID = "SSID" |
| DPP_TEST_PARAM_PASSWORD = "password" |
| |
| WPA_SUPPLICANT_SECURITY_SAE = "sae" |
| WPA_SUPPLICANT_SECURITY_PSK = "psk" |
| |
| DPP_TEST_CRYPTOGRAPHY_CURVE_PRIME256V1 = "prime256v1" |
| DPP_TEST_CRYPTOGRAPHY_CURVE_SECP384R1 = "secp384r1" |
| DPP_TEST_CRYPTOGRAPHY_CURVE_SECP521R1 = "secp521r1" |
| DPP_TEST_CRYPTOGRAPHY_CURVE_BRAINPOOLP256R1 = "brainpoolP256r1" |
| DPP_TEST_CRYPTOGRAPHY_CURVE_BRAINPOOLP384R1 = "brainpoolp384r1" |
| DPP_TEST_CRYPTOGRAPHY_CURVE_BRAINPOOLP512R1 = "brainpoolP512r1" |
| |
| DPP_EVENT_PROGRESS_AUTHENTICATION_SUCCESS = 0 |
| DPP_EVENT_PROGRESS_RESPONSE_PENDING = 1 |
| DPP_EVENT_PROGRESS_CONFIGURATION_SENT_WAITING_RESPONSE = 2 |
| DPP_EVENT_PROGRESS_CONFIGURATION_ACCEPTED = 3 |
| |
| DPP_EVENT_SUCCESS_CONFIGURATION_SENT = 0 |
| DPP_EVENT_SUCCESS_CONFIGURATION_APPLIED = 1 |
| |
| def setup_class(self): |
| """ Sets up the required dependencies from the config file and configures the device for |
| WifiService API tests. |
| |
| Returns: |
| True is successfully configured the requirements for testing. |
| """ |
| super().setup_class() |
| # Device 0 is under test. Device 1 performs the responder role |
| self.dut = self.android_devices[0] |
| self.helper_dev = self.android_devices[1] |
| |
| # Do a simple version of init - mainly just sync the time and enable |
| # verbose logging. We would also like to test with phones in less |
| # constrained states (or add variations where we specifically |
| # constrain). |
| utils.require_sl4a((self.dut,)) |
| utils.sync_device_time(self.dut) |
| |
| req_params = ["dpp_r1_test_only"] |
| opt_param = ["wifi_psk_network", "wifi_sae_network"] |
| self.unpack_userparams( |
| req_param_names=req_params, opt_param_names=opt_param) |
| if "OpenWrtAP" in self.user_params: |
| self.configure_openwrt_ap_and_start(wpa_network=True, |
| sae_network=True) |
| self.wifi_psk_network = self.wpa_networks[0]["5g"].copy() |
| self.wifi_sae_network = self.sae_networks[0]["2g"].copy() |
| |
| self.dut.log.info( |
| "Parsed configs: %s %s" % (self.wifi_psk_network, self.wifi_sae_network)) |
| |
| # Set up the networks. This is optional. In case these networks are not initialized, |
| # the script will create random ones. However, a real AP is required to pass DPP R2 test. |
| # Most efficient setup would be to use an AP in WPA2/WPA3 transition mode. |
| if self.DPP_TEST_PARAM_SSID in self.wifi_psk_network: |
| self.psk_network_ssid = self.wifi_psk_network[self.DPP_TEST_PARAM_SSID] |
| else: |
| self.psk_network_ssid = None |
| |
| if self.DPP_TEST_PARAM_PASSWORD in self.wifi_psk_network: |
| self.psk_network_password = self.wifi_psk_network[self.DPP_TEST_PARAM_PASSWORD] |
| else: |
| self.psk_network_ssid = None |
| |
| if self.DPP_TEST_PARAM_SSID in self.wifi_sae_network: |
| self.sae_network_ssid = self.wifi_sae_network[self.DPP_TEST_PARAM_SSID] |
| else: |
| self.sae_network_ssid = None |
| |
| if self.DPP_TEST_PARAM_PASSWORD in self.wifi_sae_network: |
| self.sae_network_password = self.wifi_sae_network[self.DPP_TEST_PARAM_PASSWORD] |
| else: |
| self.sae_network_ssid = None |
| |
| if self.dpp_r1_test_only == "False": |
| if not self.wifi_psk_network or not self.wifi_sae_network: |
| asserts.fail("Must specify wifi_psk_network and wifi_sae_network for DPP R2 tests") |
| |
| # Enable verbose logging on the dut |
| self.dut.droid.wifiEnableVerboseLogging(1) |
| asserts.assert_true(self.dut.droid.wifiGetVerboseLoggingLevel() == 1, |
| "Failed to enable WiFi verbose logging on the dut.") |
| |
| def teardown_class(self): |
| wutils.reset_wifi(self.dut) |
| |
| def create_and_save_wifi_network_config(self, security, random_network=False, |
| r2_auth_error=False): |
| """ Create a config with random SSID and password. |
| |
| Args: |
| security: Security type: PSK or SAE |
| random_network: A boolean that indicates if to create a random network |
| r2_auth_error: A boolean that indicates if to create a network with a bad password |
| |
| Returns: |
| A tuple with the config and networkId for the newly created and |
| saved network. |
| """ |
| if security == self.DPP_TEST_SECURITY_PSK or \ |
| security == self.DPP_TEST_SECURITY_PSK_PASSPHRASE: |
| if self.psk_network_ssid is None or self.psk_network_password is None or \ |
| random_network is True: |
| config_ssid = self.DPP_TEST_SSID_PREFIX + utils.rand_ascii_str(8) |
| config_password = utils.rand_ascii_str(8) |
| else: |
| config_ssid = self.psk_network_ssid |
| if r2_auth_error: |
| config_password = utils.rand_ascii_str(8) |
| else: |
| config_password = self.psk_network_password |
| else: |
| if self.sae_network_ssid is None or self.sae_network_password is None or \ |
| random_network is True: |
| config_ssid = self.DPP_TEST_SSID_PREFIX + utils.rand_ascii_str(8) |
| config_password = utils.rand_ascii_str(8) |
| else: |
| config_ssid = self.sae_network_ssid |
| if r2_auth_error: |
| config_password = utils.rand_ascii_str(8) |
| else: |
| config_password = self.sae_network_password |
| |
| self.dut.log.info( |
| "creating config: %s %s %s" % (config_ssid, config_password, security)) |
| config = { |
| wutils.WifiEnums.SSID_KEY: config_ssid, |
| wutils.WifiEnums.PWD_KEY: config_password, |
| wutils.WifiEnums.SECURITY: security |
| } |
| |
| # Now save the config. |
| network_id = self.dut.droid.wifiAddNetwork(config) |
| self.dut.log.info("saved config: network_id = %d" % network_id) |
| return network_id |
| |
| def check_network_config_saved(self, expected_ssid, security, network_id): |
| """ Get the configured networks and check if the provided network ID is present. |
| |
| Args: |
| expected_ssid: Expected SSID to match with received configuration. |
| security: Security type to match, PSK or SAE |
| |
| Returns: |
| True if the WifiConfig is present. |
| """ |
| networks = self.dut.droid.wifiGetConfiguredNetworks() |
| if not networks: |
| return False |
| |
| # Normalize PSK and PSK Passphrase to PSK |
| if security == self.DPP_TEST_SECURITY_PSK_PASSPHRASE: |
| security = self.DPP_TEST_SECURITY_PSK |
| |
| # If the device doesn't support SAE, then the test fallbacks to PSK |
| if not self.dut.droid.wifiIsWpa3SaeSupported() and \ |
| security == self.DPP_TEST_SECURITY_SAE: |
| security = self.DPP_TEST_SECURITY_PSK |
| |
| for network in networks: |
| if network_id == network['networkId'] and \ |
| security == network[wutils.WifiEnums.SECURITY] and \ |
| expected_ssid == network[wutils.WifiEnums.SSID_KEY]: |
| self.log.info("Found SSID %s" % network[wutils.WifiEnums.SSID_KEY]) |
| return True |
| return False |
| |
| def forget_network(self, network_id): |
| """ Simple method to call wifiForgetNetwork and wait for confirmation callback. |
| |
| Returns: |
| True if network was successfully deleted. |
| """ |
| self.dut.log.info("Deleting config: networkId = %s" % network_id) |
| self.dut.droid.wifiForgetNetwork(network_id) |
| try: |
| event = self.dut.ed.pop_event(wifi_constants.WIFI_FORGET_NW_SUCCESS, 10) |
| return True |
| except queue.Empty: |
| self.dut.log.error("Failed to forget network") |
| return False |
| |
| def gen_uri(self, device, info="DPP_TESTER", chan="81/1", mac=None): |
| """Generate a URI on a device |
| |
| Args: |
| device: Device object |
| mac: MAC address to use |
| info: Optional info to be embedded in URI |
| chan: Optional channel info |
| |
| Returns: |
| URI ID to be used later |
| """ |
| |
| # Clean up any previous URIs |
| self.del_uri(device, "'*'") |
| |
| self.log.info("Generating a URI for the Responder") |
| cmd = "wpa_cli -iwlan0 DPP_BOOTSTRAP_GEN type=qrcode info=%s" % info |
| |
| if mac: |
| cmd += " mac=%s" % mac |
| |
| if chan: |
| cmd += " chan=%s" % chan |
| |
| result = device.adb.shell(cmd) |
| |
| if "FAIL" in result: |
| asserts.fail("gen_uri: Failed to generate a URI. Command used: %s" % cmd) |
| |
| device.log.info("Generated URI, id = %s" % result) |
| |
| return result |
| |
| def get_uri(self, device, uri_id): |
| """Get a previously generated URI from a device |
| |
| Args: |
| device: Device object |
| uri_id: URI ID returned by gen_uri method |
| |
| Returns: |
| URI string |
| |
| """ |
| self.log.info("Reading the contents of the URI of the Responder") |
| cmd = "wpa_cli -iwlan0 DPP_BOOTSTRAP_GET_URI %s" % uri_id |
| result = device.adb.shell(cmd) |
| |
| if "FAIL" in result: |
| asserts.fail("get_uri: Failed to read URI. Command used: %s" % cmd) |
| |
| device.log.info("URI contents = %s" % result) |
| |
| return result |
| |
| def del_uri(self, device, uri_id): |
| """Delete a previously generated URI |
| |
| Args: |
| device: Device object |
| uri_id: URI ID returned by gen_uri method |
| """ |
| self.log.info("Deleting the Responder URI") |
| cmd = "wpa_cli -iwlan0 DPP_BOOTSTRAP_REMOVE %s" % uri_id |
| result = device.adb.shell(cmd) |
| |
| # If URI was already flushed, ignore a failure here |
| if "FAIL" not in result: |
| device.log.info("Deleted URI, id = %s" % uri_id) |
| |
| def start_responder_configurator(self, |
| device, |
| freq=2412, |
| net_role=DPP_TEST_NETWORK_ROLE_STA, |
| security=DPP_TEST_SECURITY_SAE, |
| invalid_config=False): |
| """Start a responder on helper device |
| |
| Args: |
| device: Device object |
| freq: Frequency to listen on |
| net_role: Network role to configure |
| security: Security type: SAE or PSK |
| invalid_config: Send invalid configuration (negative test) |
| |
| Returns: |
| ssid: SSID name of the network to be configured |
| |
| """ |
| if not net_role or (net_role != self.DPP_TEST_NETWORK_ROLE_STA and |
| net_role != self.DPP_TEST_NETWORK_ROLE_AP): |
| asserts.fail("start_responder: Must specify net_role sta or ap") |
| |
| self.log.info("Starting Responder in Configurator mode, frequency %sMHz" % freq) |
| |
| conf = "conf=%s-" % net_role |
| |
| use_psk = False |
| |
| if security == self.DPP_TEST_SECURITY_SAE: |
| if not self.dut.droid.wifiIsWpa3SaeSupported(): |
| self.log.warning("SAE not supported on device! reverting to PSK") |
| security = self.DPP_TEST_SECURITY_PSK_PASSPHRASE |
| |
| ssid = self.DPP_TEST_SSID_PREFIX + utils.rand_ascii_str(8) |
| password = utils.rand_ascii_str(8) |
| |
| if security == self.DPP_TEST_SECURITY_SAE: |
| conf += self.WPA_SUPPLICANT_SECURITY_SAE |
| if not self.sae_network_ssid is None: |
| ssid = self.sae_network_ssid |
| password = self.sae_network_password |
| elif security == self.DPP_TEST_SECURITY_PSK_PASSPHRASE: |
| conf += self.WPA_SUPPLICANT_SECURITY_PSK |
| if not self.psk_network_ssid is None: |
| ssid = self.psk_network_ssid |
| password = self.psk_network_password |
| else: |
| conf += self.WPA_SUPPLICANT_SECURITY_PSK |
| use_psk = True |
| |
| self.log.debug("SSID = %s" % ssid) |
| |
| ssid_encoded = binascii.hexlify(ssid.encode()).decode() |
| |
| if use_psk: |
| psk = utils.rand_ascii_str(16) |
| if not invalid_config: |
| psk_encoded = binascii.b2a_hex(psk.encode()).decode() |
| else: |
| # Use the psk as is without hex encoding, will make it invalid |
| psk_encoded = psk |
| self.log.debug("PSK = %s" % psk) |
| else: |
| if not invalid_config: |
| password_encoded = binascii.b2a_hex(password.encode()).decode() |
| else: |
| # Use the password as is without hex encoding, will make it invalid |
| password_encoded = password |
| self.log.debug("Password = %s" % password) |
| |
| conf += " ssid=%s" % ssid_encoded |
| |
| if password: # SAE password or PSK passphrase |
| conf += " pass=%s" % password_encoded |
| else: # PSK |
| conf += " psk=%s" % psk_encoded |
| |
| # Stop responder first |
| self.stop_responder(device) |
| |
| cmd = "wpa_cli -iwlan0 set dpp_configurator_params guard=1 %s" % conf |
| device.log.debug("Command used: %s" % cmd) |
| result = self.helper_dev.adb.shell(cmd) |
| if "FAIL" in result: |
| asserts.fail( |
| "start_responder_configurator: Failure. Command used: %s" % cmd) |
| |
| cmd = "wpa_cli -iwlan0 DPP_LISTEN %d role=configurator netrole=%s" % (freq, |
| net_role) |
| device.log.debug("Command used: %s" % cmd) |
| result = self.helper_dev.adb.shell(cmd) |
| if "FAIL" in result: |
| asserts.fail( |
| "start_responder_configurator: Failure. Command used: %s" % cmd) |
| |
| device.log.info("Started responder in configurator mode") |
| return ssid |
| |
| def start_responder_enrollee(self, |
| device, |
| freq=2412, |
| net_role=DPP_TEST_NETWORK_ROLE_STA): |
| """Start a responder-enrollee on helper device |
| |
| Args: |
| device: Device object |
| freq: Frequency to listen on |
| net_role: Network role to request |
| |
| Returns: |
| ssid: SSID name of the network to be configured |
| |
| """ |
| if not net_role or (net_role != self.DPP_TEST_NETWORK_ROLE_STA and |
| net_role != self.DPP_TEST_NETWORK_ROLE_AP): |
| asserts.fail("start_responder: Must specify net_role sta or ap") |
| |
| # Stop responder first |
| self.stop_responder(device) |
| self.log.info("Starting Responder in Enrollee mode, frequency %sMHz" % freq) |
| |
| cmd = "wpa_cli -iwlan0 DPP_LISTEN %d role=enrollee netrole=%s" % (freq, net_role) |
| result = device.adb.shell(cmd) |
| |
| if "FAIL" in result: |
| asserts.fail("start_responder_enrollee: Failure. Command used: %s" % cmd) |
| |
| device.adb.shell("wpa_cli -iwlan0 set dpp_config_processing 2") |
| |
| device.log.info("Started responder in enrollee mode") |
| |
| def stop_responder(self, device, flush=False): |
| """Stop responder on helper device |
| |
| Args: |
| device: Device object |
| """ |
| result = device.adb.shell("wpa_cli -iwlan0 DPP_STOP_LISTEN") |
| if "FAIL" in result: |
| asserts.fail("stop_responder: Failed to stop responder") |
| device.adb.shell("wpa_cli -iwlan0 set dpp_configurator_params") |
| device.adb.shell("wpa_cli -iwlan0 set dpp_config_processing 0") |
| if flush: |
| device.adb.shell("wpa_cli -iwlan0 flush") |
| device.log.info("Stopped responder") |
| |
| def start_dpp_as_initiator_configurator(self, |
| security, |
| use_mac, |
| responder_chan="81/1", |
| responder_freq=2412, |
| net_role=DPP_TEST_NETWORK_ROLE_STA, |
| cause_timeout=False, |
| fail_authentication=False, |
| invalid_uri=False, |
| r2_no_ap=False, |
| r2_auth_error=False): |
| """ Test Easy Connect (DPP) as initiator configurator. |
| |
| 1. Enable wifi, if needed |
| 2. Create and save a random config. |
| 3. Generate a URI using the helper device |
| 4. Start DPP as responder-enrollee on helper device |
| 5. Start DPP as initiator configurator on dut |
| 6. Check if configurator sent successfully |
| 7. Delete the URI from helper device |
| 8. Remove the config. |
| |
| Args: |
| security: Security type, a string "SAE" or "PSK" |
| use_mac: A boolean indicating whether to use the device's MAC |
| address (if True) or use a Broadcast (if False). |
| responder_chan: Responder channel to specify in the URI |
| responder_freq: Frequency that the Responder would actually listen on. |
| Note: To succeed, there must be a correlation between responder_chan, which is what |
| the URI advertises, and responder_freq which is the actual frequency. See: |
| https://en.wikipedia.org/wiki/List_of_WLAN_channels |
| net_role: Network role, a string "sta" or "ap" |
| cause_timeout: Intentionally don't start the responder to cause a |
| timeout |
| fail_authentication: Fail authentication by corrupting the |
| responder's key |
| invalid_uri: Use garbage string instead of a URI |
| r2_no_ap: Indicates if to test DPP R2 no AP failure event |
| r2_auth_error: Indicates if to test DPP R2 authentication failure |
| """ |
| if not self.dut.droid.wifiIsEasyConnectSupported(): |
| self.log.warning("Easy Connect is not supported on device!") |
| return |
| |
| wutils.wifi_toggle_state(self.dut, True) |
| test_network_id = self.create_and_save_wifi_network_config(security, random_network=r2_no_ap, |
| r2_auth_error=r2_auth_error) |
| |
| if use_mac: |
| mac = autils.get_mac_addr(self.helper_dev, "wlan0") |
| else: |
| mac = None |
| |
| if invalid_uri: |
| enrollee_uri = "dskjgnkdjfgnkdsjfgnsDFGDIFGKDSJFGFDbgjdsnbkjdfnkbgsdfgFDSGSDfgesouhgureho" \ |
| "iu3ht98368903434089ut4958763094u0934ujg094j5oifegjfds" |
| else: |
| # Generate a URI with default info and channel |
| uri_id = self.gen_uri(self.helper_dev, chan=responder_chan, mac=mac) |
| |
| # Get the URI. This is equal to scanning a QR code |
| enrollee_uri = self.get_uri(self.helper_dev, uri_id) |
| |
| # Corrupt the responder key if required |
| if fail_authentication: |
| enrollee_uri = enrollee_uri[:80] + "DeAdBeeF" + enrollee_uri[88:] |
| self.log.info("Corrupted enrollee URI: %s" % enrollee_uri) |
| |
| if not cause_timeout: |
| # Start DPP as an enrolle-responder for STA on helper device |
| self.start_responder_enrollee(self.helper_dev, freq=responder_freq, net_role=net_role) |
| else: |
| self.log.info("Not starting DPP responder on purpose") |
| |
| self.log.info("Starting DPP in Configurator-Initiator mode") |
| |
| # Start DPP as configurator-initiator on dut |
| self.dut.droid.startEasyConnectAsConfiguratorInitiator(enrollee_uri, |
| test_network_id, net_role) |
| |
| start_time = time.time() |
| while time.time() < start_time + self.DPP_TEST_TIMEOUT: |
| dut_event = self.dut.ed.pop_event(self.DPP_TEST_EVENT_DPP_CALLBACK, |
| self.DPP_TEST_TIMEOUT) |
| if dut_event[self.DPP_TEST_EVENT_DATA][self.DPP_TEST_MESSAGE_TYPE] \ |
| == self.DPP_TEST_EVENT_ENROLLEE_SUCCESS: |
| asserts.fail("DPP failure, unexpected result!") |
| break |
| if dut_event[self.DPP_TEST_EVENT_DATA][self.DPP_TEST_MESSAGE_TYPE] \ |
| == self.DPP_TEST_EVENT_CONFIGURATOR_SUCCESS: |
| if cause_timeout or fail_authentication or invalid_uri or r2_no_ap or r2_auth_error: |
| asserts.fail( |
| "Unexpected DPP success, status code: %s" % |
| dut_event[self.DPP_TEST_EVENT_DATA][self.DPP_TEST_MESSAGE_STATUS]) |
| else: |
| val = dut_event[self.DPP_TEST_EVENT_DATA][ |
| self.DPP_TEST_MESSAGE_STATUS] |
| if val == self.DPP_EVENT_SUCCESS_CONFIGURATION_SENT: |
| self.dut.log.info("DPP Configuration sent success") |
| if val == self.DPP_EVENT_SUCCESS_CONFIGURATION_APPLIED: |
| self.dut.log.info("DPP Configuration applied by enrollee") |
| break |
| if dut_event[self.DPP_TEST_EVENT_DATA][self.DPP_TEST_MESSAGE_TYPE] \ |
| == self.DPP_TEST_EVENT_PROGRESS: |
| self.dut.log.info("DPP progress event") |
| val = dut_event[self.DPP_TEST_EVENT_DATA][self.DPP_TEST_MESSAGE_STATUS] |
| if val == self.DPP_EVENT_PROGRESS_AUTHENTICATION_SUCCESS: |
| self.dut.log.info("DPP Authentication success") |
| elif val == self.DPP_EVENT_PROGRESS_RESPONSE_PENDING: |
| self.dut.log.info("DPP Response pending") |
| elif val == self.DPP_EVENT_PROGRESS_CONFIGURATION_SENT_WAITING_RESPONSE: |
| self.dut.log.info("DPP Configuration sent, waiting response") |
| elif val == self.DPP_EVENT_PROGRESS_CONFIGURATION_ACCEPTED: |
| self.dut.log.info("Configuration accepted") |
| continue |
| if dut_event[self.DPP_TEST_EVENT_DATA][ |
| self.DPP_TEST_MESSAGE_TYPE] == self.DPP_TEST_EVENT_FAILURE: |
| if cause_timeout or fail_authentication or invalid_uri or r2_no_ap or r2_auth_error: |
| self.dut.log.info( |
| "Error %s occurred, as expected" % |
| dut_event[self.DPP_TEST_EVENT_DATA][self.DPP_TEST_MESSAGE_STATUS]) |
| if r2_no_ap or r2_auth_error: |
| if not dut_event[self.DPP_TEST_EVENT_DATA][self.DPP_TEST_MESSAGE_FAILURE_SSID]: |
| asserts.fail("Expected SSID value in DPP R2 onFailure event") |
| self.dut.log.info( |
| "Enrollee searched for SSID %s" % |
| dut_event[self.DPP_TEST_EVENT_DATA][self.DPP_TEST_MESSAGE_FAILURE_SSID]) |
| if r2_no_ap: |
| if not dut_event[self.DPP_TEST_EVENT_DATA][self.DPP_TEST_MESSAGE_FAILURE_CHANNEL_LIST]: |
| asserts.fail("Expected Channel list value in DPP R2 onFailure event") |
| self.dut.log.info( |
| "Enrollee scanned the following channels: %s" % |
| dut_event[self.DPP_TEST_EVENT_DATA][self.DPP_TEST_MESSAGE_FAILURE_CHANNEL_LIST]) |
| if r2_no_ap or r2_auth_error: |
| if not dut_event[self.DPP_TEST_EVENT_DATA][self.DPP_TEST_MESSAGE_FAILURE_BAND_LIST]: |
| asserts.fail("Expected Band Support list value in DPP R2 onFailure event") |
| self.dut.log.info( |
| "Enrollee supports the following bands: %s" % |
| dut_event[self.DPP_TEST_EVENT_DATA][self.DPP_TEST_MESSAGE_FAILURE_BAND_LIST]) |
| else: |
| asserts.fail( |
| "DPP failure, status code: %s" % |
| dut_event[self.DPP_TEST_EVENT_DATA][self.DPP_TEST_MESSAGE_STATUS]) |
| break |
| |
| # Clear all pending events. |
| self.dut.ed.clear_all_events() |
| |
| # Stop responder |
| self.stop_responder(self.helper_dev, flush=True) |
| |
| if not invalid_uri: |
| # Delete URI |
| self.del_uri(self.helper_dev, uri_id) |
| |
| asserts.assert_true( |
| self.forget_network(test_network_id), |
| "Test network not deleted from configured networks.") |
| |
| def start_dpp_as_initiator_enrollee(self, |
| security, |
| use_mac, |
| cause_timeout=False, |
| invalid_config=False): |
| """ Test Easy Connect (DPP) as initiator enrollee. |
| |
| 1. Enable wifi, if needed |
| 2. Start DPP as responder-configurator on helper device |
| 3. Start DPP as initiator enrollee on dut |
| 4. Check if configuration received successfully |
| 5. Delete the URI from helper device |
| 6. Remove the config. |
| |
| Args: |
| security: Security type, a string "SAE" or "PSK" |
| use_mac: A boolean indicating whether to use the device's MAC |
| address (if True) or use a Broadcast (if False). |
| cause_timeout: Intentionally don't start the responder to cause a |
| timeout |
| invalid_config: Responder to intentionally send malformed |
| configuration |
| """ |
| if not self.dut.droid.wifiIsEasyConnectSupported(): |
| self.log.warning("Easy Connect is not supported on device!") |
| return |
| |
| wutils.wifi_toggle_state(self.dut, True) |
| |
| if use_mac: |
| mac = autils.get_mac_addr(self.helper_dev, "wlan0") |
| else: |
| mac = None |
| |
| # Generate a URI with default info and channel |
| uri_id = self.gen_uri(self.helper_dev, mac=mac) |
| |
| # Get the URI. This is equal to scanning a QR code |
| configurator_uri = self.get_uri(self.helper_dev, uri_id) |
| |
| if not cause_timeout: |
| # Start DPP as an configurator-responder for STA on helper device |
| ssid = self.start_responder_configurator( |
| self.helper_dev, security=security, invalid_config=invalid_config) |
| else: |
| self.log.info( |
| "Not starting a responder configurator on helper device, on purpose") |
| ssid = self.DPP_TEST_SSID_PREFIX + utils.rand_ascii_str(8) |
| |
| self.log.info("Starting DPP in Enrollee-Initiator mode") |
| |
| # Start DPP as enrollee-initiator on dut |
| self.dut.droid.startEasyConnectAsEnrolleeInitiator(configurator_uri) |
| |
| network_id = 0 |
| |
| start_time = time.time() |
| while time.time() < start_time + self.DPP_TEST_TIMEOUT: |
| dut_event = self.dut.ed.pop_event(self.DPP_TEST_EVENT_DPP_CALLBACK, |
| self.DPP_TEST_TIMEOUT) |
| if dut_event[self.DPP_TEST_EVENT_DATA][ |
| self.DPP_TEST_MESSAGE_TYPE] == self.DPP_TEST_EVENT_ENROLLEE_SUCCESS: |
| if cause_timeout or invalid_config: |
| asserts.fail( |
| "Unexpected DPP success, status code: %s" % |
| dut_event[self.DPP_TEST_EVENT_DATA][self.DPP_TEST_MESSAGE_STATUS]) |
| else: |
| self.dut.log.info("DPP Configuration received success") |
| network_id = dut_event[self.DPP_TEST_EVENT_DATA][ |
| self.DPP_TEST_MESSAGE_NETWORK_ID] |
| self.dut.log.info("NetworkID: %d" % network_id) |
| break |
| if dut_event[self.DPP_TEST_EVENT_DATA][ |
| self |
| .DPP_TEST_MESSAGE_TYPE] == self.DPP_TEST_EVENT_CONFIGURATOR_SUCCESS: |
| asserts.fail( |
| "DPP failure, unexpected result: %s" % |
| dut_event[self.DPP_TEST_EVENT_DATA][self.DPP_TEST_MESSAGE_STATUS]) |
| break |
| if dut_event[self.DPP_TEST_EVENT_DATA][ |
| self.DPP_TEST_MESSAGE_TYPE] == self.DPP_TEST_EVENT_PROGRESS: |
| self.dut.log.info("DPP progress event") |
| val = dut_event[self.DPP_TEST_EVENT_DATA][self.DPP_TEST_MESSAGE_STATUS] |
| if val == 0: |
| self.dut.log.info("DPP Authentication success") |
| elif val == 1: |
| self.dut.log.info("DPP Response pending") |
| continue |
| if dut_event[self.DPP_TEST_EVENT_DATA][ |
| self.DPP_TEST_MESSAGE_TYPE] == self.DPP_TEST_EVENT_FAILURE: |
| if cause_timeout or invalid_config: |
| self.dut.log.info( |
| "Error %s occurred, as expected" % |
| dut_event[self.DPP_TEST_EVENT_DATA][self.DPP_TEST_MESSAGE_STATUS]) |
| else: |
| asserts.fail( |
| "DPP failure, status code: %s" % |
| dut_event[self.DPP_TEST_EVENT_DATA][self.DPP_TEST_MESSAGE_STATUS]) |
| break |
| asserts.fail("Unknown message received") |
| |
| # Clear all pending events. |
| self.dut.ed.clear_all_events() |
| |
| # Stop responder |
| self.stop_responder(self.helper_dev, flush=True) |
| |
| # Delete URI |
| self.del_uri(self.helper_dev, uri_id) |
| |
| if not (invalid_config or cause_timeout): |
| # Check that the saved network is what we expect |
| asserts.assert_true( |
| self.check_network_config_saved(ssid, security, network_id), |
| "Could not find the expected network: %s" % ssid) |
| |
| asserts.assert_true( |
| self.forget_network(network_id), |
| "Test network not deleted from configured networks.") |
| |
| def stop_initiator(self, device, flush=False): |
| """Stop initiator on helper device |
| |
| Args: |
| device: Device object |
| """ |
| result = device.adb.shell("wpa_cli -iwlan0 DPP_STOP_LISTEN") |
| if "FAIL" in result: |
| asserts.fail("stop_initiator: Failed to stop initiator") |
| if flush: |
| device.adb.shell("wpa_cli -iwlan0 flush") |
| device.log.info("Stopped initiator") |
| |
| def start_initiator_configurator(self, |
| device, |
| uri, |
| security=DPP_TEST_SECURITY_SAE): |
| """Start a responder on helper device |
| |
| Args: |
| device: Device object |
| uri: peer uri |
| security: Security type: SAE or PSK |
| |
| Returns: |
| ssid: SSID name of the network to be configured |
| uri_id: bootstrap id |
| """ |
| |
| self.log.info("Starting Initiator in Configurator mode") |
| |
| use_psk = False |
| |
| conf = " role=configurator" |
| conf += " conf=sta-" |
| |
| if security == self.DPP_TEST_SECURITY_SAE: |
| if not self.dut.droid.wifiIsWpa3SaeSupported(): |
| self.log.warning("SAE not supported on device! reverting to PSK") |
| security = self.DPP_TEST_SECURITY_PSK_PASSPHRASE |
| |
| ssid = self.DPP_TEST_SSID_PREFIX + utils.rand_ascii_str(8) |
| password = utils.rand_ascii_str(8) |
| |
| if security == self.DPP_TEST_SECURITY_SAE: |
| conf += self.WPA_SUPPLICANT_SECURITY_SAE |
| if not self.sae_network_ssid is None: |
| ssid = self.sae_network_ssid |
| password = self.sae_network_password |
| elif security == self.DPP_TEST_SECURITY_PSK_PASSPHRASE: |
| conf += self.WPA_SUPPLICANT_SECURITY_PSK |
| if not self.psk_network_ssid is None: |
| ssid = self.psk_network_ssid |
| password = self.psk_network_password |
| else: |
| conf += self.WPA_SUPPLICANT_SECURITY_PSK |
| use_psk = True |
| |
| self.log.debug("SSID = %s" % ssid) |
| |
| ssid_encoded = binascii.hexlify(ssid.encode()).decode() |
| |
| if use_psk: |
| psk = utils.rand_ascii_str(16) |
| psk_encoded = binascii.b2a_hex(psk.encode()).decode() |
| self.log.debug("PSK = %s" % psk) |
| else: |
| password_encoded = binascii.b2a_hex(password.encode()).decode() |
| self.log.debug("Password = %s" % password) |
| |
| conf += " ssid=%s" % ssid_encoded |
| |
| if password: # SAE password or PSK passphrase |
| conf += " pass=%s" % password_encoded |
| else: # PSK |
| conf += " psk=%s" % psk_encoded |
| |
| cmd = "wpa_cli -iwlan0 DPP_QR_CODE '%s'" % (uri) |
| self.log.info ("Command used: %s" % cmd) |
| result = self.helper_dev.adb.shell(cmd) |
| if "FAIL" in result: |
| asserts.fail( |
| "start_initiator_configurator: Failure. Command used: %s" % cmd) |
| |
| uri_id = result |
| device.log.info("peer id = %s" % result) |
| |
| cmd = "wpa_cli -iwlan0 DPP_AUTH_INIT peer=%s %s " % (result, conf) |
| self.log.info("Command used: %s" % cmd) |
| result = self.helper_dev.adb.shell(cmd) |
| if "FAIL" in result: |
| asserts.fail( |
| "start_responder_configurator: Failure. Command used: %s" % cmd) |
| |
| device.log.info("Started initiator in configurator mode") |
| return ssid, uri_id |
| |
| def start_dpp_as_responder_enrollee(self, |
| security, |
| curve): |
| """ Test Easy Connect (DPP) as responder enrollee. |
| |
| 1. Enable wifi, if needed |
| 2. Start DPP as Responder - Enrollee on DUT |
| 3. Receive the generated URI from DUT |
| 3. Start DPP as Initiator - Configurator on helper device by passing the URI |
| 4. Check if configuration received successfully on DUT |
| 5. Remove the configuration. |
| |
| Args: |
| security: Security type, a string "SAE" or "PSK" |
| curve: cryptography curve type, a string DPP_TEST_CRYPTOGRAPHY_CURVE_XXX |
| """ |
| if not self.dut.droid.wifiIsEasyConnectEnrolleeResponderModeSupported(): |
| self.log.warning("Easy Connect Enrollee responder mode is not supported on device!") |
| return |
| |
| wutils.wifi_toggle_state(self.dut, True) |
| |
| self.log.info("Starting DPP in Enrollee-Responder mode, curve: %s" % curve) |
| |
| # Start DPP as Enrollee-Responder on DUT |
| self.dut.droid.startEasyConnectAsEnrolleeResponder("DPP_RESPONDER_TESTER", curve) |
| |
| network_id = 0 |
| |
| start_time = time.time() |
| while time.time() < start_time + self.DPP_TEST_TIMEOUT: |
| dut_event = self.dut.ed.pop_event(self.DPP_TEST_EVENT_DPP_CALLBACK, |
| self.DPP_TEST_TIMEOUT) |
| if dut_event[self.DPP_TEST_EVENT_DATA][ |
| self.DPP_TEST_MESSAGE_TYPE] == self.DPP_TEST_EVENT_ENROLLEE_SUCCESS: |
| self.dut.log.info("DPP Configuration received success") |
| network_id = dut_event[self.DPP_TEST_EVENT_DATA][ |
| self.DPP_TEST_MESSAGE_NETWORK_ID] |
| self.dut.log.info("NetworkID: %d" % network_id) |
| break |
| if dut_event[self.DPP_TEST_EVENT_DATA][ |
| self.DPP_TEST_MESSAGE_TYPE] == self.DPP_TEST_EVENT_URI_GENERATED: |
| self.dut.log.info( |
| "Generated URI %s" % |
| dut_event[self.DPP_TEST_EVENT_DATA][self.DPP_TEST_MESSAGE_GENERATED_URI]) |
| uri = dut_event[self.DPP_TEST_EVENT_DATA][self.DPP_TEST_MESSAGE_GENERATED_URI] |
| |
| # Start DPP as an configurator-initiator for STA on helper device |
| result = self.start_initiator_configurator(self.helper_dev, uri, security=security) |
| continue |
| if dut_event[self.DPP_TEST_EVENT_DATA][ |
| self.DPP_TEST_MESSAGE_TYPE] == self.DPP_TEST_EVENT_PROGRESS: |
| self.dut.log.info("DPP progress event") |
| val = dut_event[self.DPP_TEST_EVENT_DATA][self.DPP_TEST_MESSAGE_STATUS] |
| if val == 0: |
| self.dut.log.info("DPP Authentication success") |
| elif val == 1: |
| self.dut.log.info("DPP Response pending") |
| continue |
| if dut_event[self.DPP_TEST_EVENT_DATA][ |
| self.DPP_TEST_MESSAGE_TYPE] == self.DPP_TEST_EVENT_FAILURE: |
| asserts.fail( |
| "DPP failure, status code: %s" % |
| dut_event[self.DPP_TEST_EVENT_DATA][self.DPP_TEST_MESSAGE_STATUS]) |
| break |
| asserts.fail("Unknown message received") |
| |
| # Clear all pending events. |
| self.dut.ed.clear_all_events() |
| |
| # Stop initiator |
| self.stop_initiator(self.helper_dev, flush=True) |
| |
| # Delete URI |
| if not result is None: |
| self.log.info("SSID: %s URI_ID: %s" % (result[0], result[1])) |
| self.del_uri(self.helper_dev, result[1]) |
| |
| # Check that the saved network is what we expect |
| asserts.assert_true( |
| self.check_network_config_saved(result[0], security, network_id), |
| "Could not find the expected network: %s" % result[0]) |
| asserts.assert_true( |
| self.forget_network(network_id), |
| "Test network not deleted from configured networks.") |
| else: |
| asserts.fail("Failed to configure initiator") |
| |
| """ Tests Begin """ |
| |
| @test_tracker_info(uuid="30893d51-2069-4e1c-8917-c8a840f91b59") |
| @WifiBaseTest.wifi_test_wrap |
| def test_dpp_as_initiator_configurator_with_psk_5G(self): |
| asserts.skip_if(not self.dut.droid.wifiIs5GHzBandSupported() or |
| not self.helper_dev.droid.wifiIs5GHzBandSupported(), |
| "5G not supported on at least on test device") |
| self.start_dpp_as_initiator_configurator( |
| security=self.DPP_TEST_SECURITY_PSK, responder_chan="126/149", responder_freq=5745, |
| use_mac=True) |
| |
| @test_tracker_info(uuid="54d1d19a-aece-459c-b819-9d4b1ae63f77") |
| @WifiBaseTest.wifi_test_wrap |
| def test_dpp_as_initiator_configurator_with_psk_5G_broadcast(self): |
| asserts.skip_if(not self.dut.droid.wifiIs5GHzBandSupported() or |
| not self.helper_dev.droid.wifiIs5GHzBandSupported(), |
| "5G not supported on at least on test device") |
| self.start_dpp_as_initiator_configurator( |
| security=self.DPP_TEST_SECURITY_PSK, responder_chan="126/149", responder_freq=5745, |
| use_mac=False) |
| |
| @test_tracker_info(uuid="18270a69-300c-4f54-87fd-c19073a2854e ") |
| @WifiBaseTest.wifi_test_wrap |
| def test_dpp_as_initiator_configurator_with_psk_no_chan_in_uri_listen_on_5745_broadcast(self): |
| asserts.skip_if(not self.dut.droid.wifiIs5GHzBandSupported() or |
| not self.helper_dev.droid.wifiIs5GHzBandSupported(), |
| "5G not supported on at least on test device") |
| self.start_dpp_as_initiator_configurator( |
| security=self.DPP_TEST_SECURITY_PSK, responder_chan=None, responder_freq=5745, use_mac=False) |
| |
| @test_tracker_info(uuid="fbdd687c-954a-400b-9da3-2d17e28b0798") |
| @WifiBaseTest.wifi_test_wrap |
| def test_dpp_as_initiator_configurator_with_psk_no_chan_in_uri_listen_on_5745(self): |
| asserts.skip_if(not self.dut.droid.wifiIs5GHzBandSupported() or |
| not self.helper_dev.droid.wifiIs5GHzBandSupported(), |
| "5G not supported on at least on test device") |
| self.start_dpp_as_initiator_configurator( |
| security=self.DPP_TEST_SECURITY_PSK, responder_chan=None, responder_freq=5745, use_mac=True) |
| |
| @test_tracker_info(uuid="570f499f-ab12-4405-af14-c9ed36da2e01") |
| @WifiBaseTest.wifi_test_wrap |
| def test_dpp_as_initiator_configurator_with_psk_no_chan_in_uri_listen_on_2462_broadcast(self): |
| self.start_dpp_as_initiator_configurator( |
| security=self.DPP_TEST_SECURITY_PSK, responder_chan=None, responder_freq=2462, use_mac=False) |
| |
| @test_tracker_info(uuid="e1f083e0-0878-4c49-8ac5-d7c6bba24625") |
| @WifiBaseTest.wifi_test_wrap |
| def test_dpp_as_initiator_configurator_with_psk_no_chan_in_uri_listen_on_2462(self): |
| self.start_dpp_as_initiator_configurator( |
| security=self.DPP_TEST_SECURITY_PSK, responder_chan=None, responder_freq=2462, use_mac=True) |
| |
| @test_tracker_info(uuid="d2a526f5-4269-493d-bd79-4e6d1b7b00f0") |
| @WifiBaseTest.wifi_test_wrap |
| def test_dpp_as_initiator_configurator_with_psk(self): |
| self.start_dpp_as_initiator_configurator( |
| security=self.DPP_TEST_SECURITY_PSK, use_mac=True) |
| |
| @test_tracker_info(uuid="6ead218c-222b-45b8-8aad-fe7d883ed631") |
| @WifiBaseTest.wifi_test_wrap |
| def test_dpp_as_initiator_configurator_with_sae(self): |
| self.start_dpp_as_initiator_configurator( |
| security=self.DPP_TEST_SECURITY_SAE, use_mac=True) |
| |
| @test_tracker_info(uuid="1686adb5-1b3c-4e6d-a969-6b007bdd990d") |
| @WifiBaseTest.wifi_test_wrap |
| def test_dpp_as_initiator_configurator_with_psk_passphrase(self): |
| self.start_dpp_as_initiator_configurator( |
| security=self.DPP_TEST_SECURITY_PSK_PASSPHRASE, use_mac=True) |
| |
| @test_tracker_info(uuid="3958feb5-1a0c-4487-9741-ac06f04c55a2") |
| @WifiBaseTest.wifi_test_wrap |
| def test_dpp_as_initiator_configurator_with_sae_broadcast(self): |
| self.start_dpp_as_initiator_configurator( |
| security=self.DPP_TEST_SECURITY_SAE, use_mac=False) |
| |
| @test_tracker_info(uuid="fe6d66f5-73a1-46e9-8f49-73b8f332cc8c") |
| @WifiBaseTest.wifi_test_wrap |
| def test_dpp_as_initiator_configurator_with_psk_passphrase_broadcast(self): |
| self.start_dpp_as_initiator_configurator( |
| security=self.DPP_TEST_SECURITY_PSK_PASSPHRASE, use_mac=False) |
| |
| @test_tracker_info(uuid="9edd372d-e2f1-4545-8d04-6a1636fcbc4b") |
| @WifiBaseTest.wifi_test_wrap |
| def test_dpp_as_initiator_configurator_with_sae_for_ap(self): |
| self.start_dpp_as_initiator_configurator( |
| security=self.DPP_TEST_SECURITY_SAE, |
| use_mac=True, |
| net_role=self.DPP_TEST_NETWORK_ROLE_AP) |
| |
| @test_tracker_info(uuid="e9eec912-d665-4926-beac-859cb13dc17b") |
| @WifiBaseTest.wifi_test_wrap |
| def test_dpp_as_initiator_configurator_with_psk_passphrase_for_ap(self): |
| self.start_dpp_as_initiator_configurator( |
| security=self.DPP_TEST_SECURITY_PSK_PASSPHRASE, |
| use_mac=True, |
| net_role=self.DPP_TEST_NETWORK_ROLE_AP) |
| |
| @test_tracker_info(uuid="8055694f-606f-41dd-9826-3ea1e9b007f8") |
| @WifiBaseTest.wifi_test_wrap |
| def test_dpp_as_initiator_enrollee_with_sae(self): |
| self.start_dpp_as_initiator_enrollee( |
| security=self.DPP_TEST_SECURITY_SAE, use_mac=True) |
| |
| @test_tracker_info(uuid="c1e9f605-b5c0-4e53-8a08-1b0087a667fa") |
| @WifiBaseTest.wifi_test_wrap |
| def test_dpp_as_initiator_enrollee_with_psk_passphrase(self): |
| self.start_dpp_as_initiator_enrollee( |
| security=self.DPP_TEST_SECURITY_PSK_PASSPHRASE, use_mac=True) |
| |
| @test_tracker_info(uuid="1d7f30ad-2f9a-427a-8059-651dc8827ae2") |
| @WifiBaseTest.wifi_test_wrap |
| def test_dpp_as_initiator_enrollee_with_sae_broadcast(self): |
| self.start_dpp_as_initiator_enrollee( |
| security=self.DPP_TEST_SECURITY_SAE, use_mac=False) |
| |
| @test_tracker_info(uuid="0cfc2645-600e-4f2b-ab5c-fcee6d363a9a") |
| @WifiBaseTest.wifi_test_wrap |
| def test_dpp_as_initiator_enrollee_with_psk_passphrase_broadcast(self): |
| self.start_dpp_as_initiator_enrollee( |
| security=self.DPP_TEST_SECURITY_PSK_PASSPHRASE, use_mac=False) |
| |
| @test_tracker_info(uuid="2e26b248-65dd-41f6-977b-e223d72b2de9") |
| @WifiBaseTest.wifi_test_wrap |
| def test_start_dpp_as_initiator_enrollee_receive_invalid_config(self): |
| self.start_dpp_as_initiator_enrollee( |
| security=self.DPP_TEST_SECURITY_PSK_PASSPHRASE, |
| use_mac=True, |
| invalid_config=True) |
| |
| @test_tracker_info(uuid="ed189661-d1c1-4626-9f01-3b7bb8a417fe") |
| @WifiBaseTest.wifi_test_wrap |
| def test_dpp_as_initiator_configurator_fail_authentication(self): |
| self.start_dpp_as_initiator_configurator( |
| security=self.DPP_TEST_SECURITY_PSK_PASSPHRASE, |
| use_mac=True, |
| fail_authentication=True) |
| |
| @test_tracker_info(uuid="5a8c6587-fbb4-4a27-9cba-af6f8935833a") |
| @WifiBaseTest.wifi_test_wrap |
| def test_dpp_as_initiator_configurator_fail_unicast_timeout(self): |
| self.start_dpp_as_initiator_configurator( |
| security=self.DPP_TEST_SECURITY_PSK_PASSPHRASE, |
| use_mac=True, |
| cause_timeout=True) |
| |
| @test_tracker_info(uuid="b12353ac-1a04-4036-81a4-2d2d0c653dbb") |
| @WifiBaseTest.wifi_test_wrap |
| def test_dpp_as_initiator_configurator_fail_broadcast_timeout(self): |
| self.start_dpp_as_initiator_configurator( |
| security=self.DPP_TEST_SECURITY_PSK_PASSPHRASE, |
| use_mac=False, |
| cause_timeout=True) |
| |
| @test_tracker_info(uuid="eeff91be-09ce-4a33-8b4f-ece40eb51c76") |
| @WifiBaseTest.wifi_test_wrap |
| def test_dpp_as_initiator_configurator_invalid_uri(self): |
| self.start_dpp_as_initiator_configurator( |
| security=self.DPP_TEST_SECURITY_PSK_PASSPHRASE, |
| use_mac=True, |
| invalid_uri=True) |
| |
| @test_tracker_info(uuid="1fa25f58-0d0e-40bd-8714-ab78957514d9") |
| @WifiBaseTest.wifi_test_wrap |
| def test_start_dpp_as_initiator_enrollee_fail_timeout(self): |
| self.start_dpp_as_initiator_enrollee( |
| security=self.DPP_TEST_SECURITY_PSK_PASSPHRASE, |
| use_mac=True, |
| cause_timeout=True) |
| |
| @test_tracker_info(uuid="23601af8-118e-4ba8-89e3-5da2e37bbd7d") |
| def test_dpp_as_initiator_configurator_fail_r2_no_ap(self): |
| asserts.skip_if(self.dpp_r1_test_only == "True", |
| "DPP R1 test, skipping this test for DPP R2 only") |
| self.start_dpp_as_initiator_configurator( |
| security=self.DPP_TEST_SECURITY_PSK, use_mac=True, r2_no_ap=True) |
| |
| @test_tracker_info(uuid="7f9756d3-f28f-498e-8dcf-ac3816303998") |
| def test_dpp_as_initiator_configurator_fail_r2_auth_error(self): |
| asserts.skip_if(self.dpp_r1_test_only == "True", |
| "DPP R1 test, skipping this test for DPP R2 only") |
| self.start_dpp_as_initiator_configurator( |
| security=self.DPP_TEST_SECURITY_PSK, use_mac=True, r2_auth_error=True) |
| |
| @test_tracker_info(uuid="608c8d47-b9ed-4668-a438-cf5035d27818") |
| @WifiBaseTest.wifi_test_wrap |
| def test_dpp_as_responder_enrollee_with_psk_passphrase_curve_prime256v1(self): |
| self.start_dpp_as_responder_enrollee( |
| security=self.DPP_TEST_SECURITY_PSK_PASSPHRASE, |
| curve=self.DPP_TEST_CRYPTOGRAPHY_CURVE_PRIME256V1) |
| |
| @test_tracker_info(uuid="51d47a54-e19e-4513-b6e8-161e786db0b0") |
| @WifiBaseTest.wifi_test_wrap |
| def test_dpp_as_responder_enrollee_with_sae_curve_prime256v1(self): |
| self.start_dpp_as_responder_enrollee( |
| security=self.DPP_TEST_SECURITY_SAE, |
| curve=self.DPP_TEST_CRYPTOGRAPHY_CURVE_PRIME256V1) |
| |
| @test_tracker_info(uuid="f4ede61b-2cee-4ff0-b9d6-3dca9245021b") |
| @WifiBaseTest.wifi_test_wrap |
| def test_dpp_as_responder_enrollee_with_psk_passphrase_curve_secp384r1(self): |
| self.start_dpp_as_responder_enrollee( |
| security=self.DPP_TEST_SECURITY_PSK_PASSPHRASE, |
| curve=self.DPP_TEST_CRYPTOGRAPHY_CURVE_SECP384R1) |
| |
| @test_tracker_info(uuid="57855cba-9cf2-4837-ae77-3dc78bf8b3b5") |
| @WifiBaseTest.wifi_test_wrap |
| def test_dpp_as_responder_enrollee_with_sae_curve_secp384r1(self): |
| self.start_dpp_as_responder_enrollee( |
| security=self.DPP_TEST_SECURITY_SAE, |
| curve=self.DPP_TEST_CRYPTOGRAPHY_CURVE_SECP384R1) |
| |
| @test_tracker_info(uuid="eb9c22a0-f17e-4985-b1b0-fdd3871d29b7") |
| @WifiBaseTest.wifi_test_wrap |
| def test_dpp_as_responder_enrollee_with_psk_passphrase_curve_secp521r1(self): |
| self.start_dpp_as_responder_enrollee( |
| security=self.DPP_TEST_SECURITY_PSK_PASSPHRASE, |
| curve=self.DPP_TEST_CRYPTOGRAPHY_CURVE_SECP521R1) |
| |
| @test_tracker_info(uuid="2677e549-a37a-42f6-8fab-c9a68fcf15f9") |
| @WifiBaseTest.wifi_test_wrap |
| def test_dpp_as_responder_enrollee_with_sae_curve_secp521r1(self): |
| self.start_dpp_as_responder_enrollee( |
| security=self.DPP_TEST_SECURITY_SAE, |
| curve=self.DPP_TEST_CRYPTOGRAPHY_CURVE_SECP521R1) |
| |
| """ Tests End """ |
