1154 lines
46 KiB
Python
1154 lines
46 KiB
Python
#!/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 """
|