1#!/usr/bin/env python3.4 2# 3# Copyright 2016 - The Android Open Source Project 4# 5# Licensed under the Apache License, Version 2.0 (the "License"); 6# you may not use this file except in compliance with the License. 7# You may obtain a copy of the License at 8# 9# http://www.apache.org/licenses/LICENSE-2.0 10# 11# Unless required by applicable law or agreed to in writing, software 12# distributed under the License is distributed on an "AS IS" BASIS, 13# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14# See the License for the specific language governing permissions and 15# limitations under the License. 16 17import time 18import acts.utils 19 20from acts import asserts 21from acts import signals 22from acts.test_decorators import test_tracker_info 23from acts_contrib.test_utils.wifi import wifi_test_utils as wutils 24from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest 25 26WifiEnums = wutils.WifiEnums 27DEFAULT_TIMEOUT = 10 28 29# EAP Macros 30EAP = WifiEnums.Eap 31EapPhase2 = WifiEnums.EapPhase2 32# Enterprise Config Macros 33Ent = WifiEnums.Enterprise 34 35 36class WifiEnterpriseTest(WifiBaseTest): 37 def setup_class(self): 38 super().setup_class() 39 self.enable_packet_log = True 40 41 self.dut = self.android_devices[0] 42 # If running in a setup with attenuators, set attenuation on all 43 # channels to zero. 44 if getattr(self, "attenuators", []): 45 for a in self.attenuators: 46 a.set_atten(0) 47 required_userparam_names = ( 48 "ca_cert", "client_cert", "client_key", "eap_identity", 49 "eap_password", "invalid_ca_cert", "invalid_client_cert", 50 "invalid_client_key", "device_password", "radius_conf_2g", 51 "radius_conf_5g", "radius_conf_pwd", "wifi6_models", "sim_supported_models") 52 opt_param_names = ["domain_suffix_match"] 53 self.unpack_userparams(required_userparam_names, 54 opt_param_names, 55 roaming_consortium_ids=None, 56 plmn=None, 57 ocsp=0) 58 59 if "AccessPoint" in self.user_params: 60 self.legacy_configure_ap_and_start( 61 ent_network=True, 62 radius_conf_2g=self.radius_conf_2g, 63 radius_conf_5g=self.radius_conf_5g, 64 ent_network_pwd=True, 65 radius_conf_pwd=self.radius_conf_pwd, 66 wpa_network=True, 67 ap_count=2, 68 ) 69 elif "OpenWrtAP" in self.user_params: 70 self.configure_openwrt_ap_and_start( 71 ent_network=True, 72 radius_conf_2g=self.radius_conf_2g, 73 radius_conf_5g=self.radius_conf_5g, 74 ent_network_pwd=True, 75 radius_conf_pwd=self.radius_conf_pwd, 76 wpa_network=True, 77 ap_count=2, 78 ) 79 self.ent_network_2g = self.ent_networks[0]["2g"] 80 self.ent_network_5g = self.ent_networks[0]["5g"] 81 self.ent_network_pwd = self.ent_networks_pwd[0]["2g"] 82 if hasattr(self, "reference_networks") and \ 83 isinstance(self.reference_networks, list): 84 self.wpa_psk_2g = self.reference_networks[0]["2g"] 85 self.wpa_psk_5g = self.reference_networks[0]["5g"] 86 87 # Default configs for EAP networks. 88 self.config_peap0 = { 89 Ent.EAP: int(EAP.PEAP), 90 Ent.CA_CERT: self.ca_cert, 91 Ent.IDENTITY: self.eap_identity, 92 Ent.PASSWORD: self.eap_password, 93 Ent.PHASE2: int(EapPhase2.MSCHAPV2), 94 WifiEnums.SSID_KEY: self.ent_network_5g[WifiEnums.SSID_KEY], 95 Ent.OCSP: self.ocsp, 96 Ent.DOM_SUFFIX_MATCH: self.domain_suffix_match, 97 } 98 self.config_peap1 = dict(self.config_peap0) 99 self.config_peap1[WifiEnums.SSID_KEY] = \ 100 self.ent_network_2g[WifiEnums.SSID_KEY] 101 self.config_tls = { 102 Ent.EAP: int(EAP.TLS), 103 Ent.CA_CERT: self.ca_cert, 104 WifiEnums.SSID_KEY: self.ent_network_2g[WifiEnums.SSID_KEY], 105 Ent.CLIENT_CERT: self.client_cert, 106 Ent.PRIVATE_KEY_ID: self.client_key, 107 Ent.IDENTITY: self.eap_identity, 108 Ent.OCSP: self.ocsp, 109 Ent.DOM_SUFFIX_MATCH: self.domain_suffix_match, 110 } 111 self.config_ttls = { 112 Ent.EAP: int(EAP.TTLS), 113 Ent.CA_CERT: self.ca_cert, 114 Ent.IDENTITY: self.eap_identity, 115 Ent.PASSWORD: self.eap_password, 116 Ent.PHASE2: int(EapPhase2.MSCHAPV2), 117 WifiEnums.SSID_KEY: self.ent_network_2g[WifiEnums.SSID_KEY], 118 Ent.OCSP: self.ocsp, 119 Ent.DOM_SUFFIX_MATCH: self.domain_suffix_match, 120 } 121 self.config_pwd = { 122 Ent.EAP: int(EAP.PWD), 123 Ent.IDENTITY: self.eap_identity, 124 Ent.PASSWORD: self.eap_password, 125 WifiEnums.SSID_KEY: self.ent_network_pwd[WifiEnums.SSID_KEY], 126 } 127 self.config_sim = { 128 Ent.EAP: int(EAP.SIM), 129 WifiEnums.SSID_KEY: self.ent_network_2g[WifiEnums.SSID_KEY], 130 } 131 self.config_aka = { 132 Ent.EAP: int(EAP.AKA), 133 WifiEnums.SSID_KEY: self.ent_network_2g[WifiEnums.SSID_KEY], 134 } 135 self.config_aka_prime = { 136 Ent.EAP: int(EAP.AKA_PRIME), 137 WifiEnums.SSID_KEY: self.ent_network_2g[WifiEnums.SSID_KEY], 138 } 139 140 # Set screen lock password so ConfigStore is unlocked. 141 self.dut.droid.setDevicePassword(self.device_password) 142 143 def teardown_class(self): 144 wutils.reset_wifi(self.dut) 145 self.dut.droid.disableDevicePassword(self.device_password) 146 self.dut.ed.clear_all_events() 147 148 def setup_test(self): 149 super().setup_test() 150 self.dut.droid.wifiStartTrackingStateChange() 151 self.dut.droid.wakeLockAcquireBright() 152 self.dut.droid.wakeUpNow() 153 wutils.reset_wifi(self.dut) 154 self.dut.ed.clear_all_events() 155 156 def teardown_test(self): 157 super().teardown_test() 158 self.dut.droid.wakeLockRelease() 159 self.dut.droid.goToSleepNow() 160 self.dut.droid.wifiStopTrackingStateChange() 161 # Turn off airplane mode 162 acts.utils.force_airplane_mode(self.dut, False) 163 wutils.set_attns(self.attenuators, "default") 164 165 """Helper Functions""" 166 167 def eap_negative_connect_logic(self, config, ad): 168 """Tries to connect to an enterprise network with invalid credentials 169 and expect a failure. 170 171 Args: 172 config: A dict representing an invalid EAP credential. 173 174 Returns: 175 True if connection failed as expected, False otherwise. 176 """ 177 with asserts.assert_raises(signals.TestFailure, extras=config): 178 verdict = wutils.wifi_connect(ad, config) 179 asserts.explicit_pass("Connection failed as expected.") 180 181 def gen_negative_configs(self, config, neg_params): 182 """Generic function used to generate negative configs. 183 184 For all the valid configurations, if a param in the neg_params also 185 exists in a config, a copy of the config is made with an invalid value 186 of the param. 187 188 Args: 189 config: A valid configuration. 190 neg_params: A dict that has all the invalid values. 191 192 Returns: 193 An invalid configurations generated based on the valid 194 configuration. Each invalid configuration has a different invalid 195 field. 196 """ 197 negative_config = dict(config) 198 if negative_config in [ 199 self.config_sim, self.config_aka, self.config_aka_prime 200 ]: 201 negative_config[WifiEnums.SSID_KEY] = 'wrong_hostapd_ssid' 202 for k, v in neg_params.items(): 203 # Skip negative test for TLS's identity field since it's not 204 # used for auth. 205 if config[Ent.EAP] == EAP.TLS and k == Ent.IDENTITY: 206 continue 207 if k in config: 208 negative_config[k] = v 209 negative_config["invalid_field"] = k 210 return negative_config 211 212 def gen_negative_eap_configs(self, config): 213 """Generates invalid configurations for different EAP authentication 214 types. 215 216 For all the valid EAP configurations, if a param that is part of the 217 authentication info exists in a config, a copy of the config is made 218 with an invalid value of the param. 219 220 Args: 221 A valid network configration 222 223 Returns: 224 An invalid EAP configuration. 225 """ 226 neg_params = { 227 Ent.CLIENT_CERT: self.invalid_client_cert, 228 Ent.CA_CERT: self.invalid_ca_cert, 229 Ent.PRIVATE_KEY_ID: self.invalid_client_key, 230 Ent.IDENTITY: "fake_identity", 231 Ent.PASSWORD: "wrong_password" 232 } 233 return self.gen_negative_configs(config, neg_params) 234 235 def eap_connect_toggle_wifi(self, config, *args): 236 """Connects to an enterprise network, toggles wifi state and ensures 237 that the device reconnects. 238 239 This logic expect the enterprise network to have Internet access. 240 241 Args: 242 config: A dict representing a wifi enterprise configuration. 243 args: args to be passed to |wutils.eap_connect|. 244 245 Returns: 246 True if the connection is successful and Internet access works. 247 """ 248 ad = args[0] 249 wutils.wifi_connect(ad, config) 250 wutils.verify_11ax_wifi_connection( 251 self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) 252 wutils.toggle_wifi_and_wait_for_reconnection(ad, 253 config, 254 num_of_tries=5) 255 wutils.verify_11ax_wifi_connection( 256 self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) 257 258 def toggle_out_of_range_stress(self, stress_count=3): 259 """toggle_out_of_range_stress.""" 260 current_network = self.dut.droid.wifiGetConnectionInfo() 261 self.log.info("Current network: {}".format(current_network)) 262 for count in range(stress_count): 263 # move the DUT out of range 264 self.attenuators[0].set_atten(95) 265 self.attenuators[1].set_atten(95) 266 self.attenuators[2].set_atten(95) 267 self.attenuators[3].set_atten(95) 268 time.sleep(20) 269 try: 270 wutils.start_wifi_connection_scan(self.dut) 271 wifi_results = self.dut.droid.wifiGetScanResults() 272 self.log.debug("Scan result {}".format(wifi_results)) 273 time.sleep(20) 274 current_network = self.dut.droid.wifiGetConnectionInfo() 275 self.log.info("Current network: {}".format(current_network)) 276 asserts.assert_true( 277 ('network_id' in current_network and 278 current_network['network_id'] == -1), 279 "Device is connected to network {}".format(current_network)) 280 time.sleep(DEFAULT_TIMEOUT) 281 finally: 282 self.dut.droid.wifiLockRelease() 283 # move the DUT back in range 284 wutils.set_attns(self.attenuators, "default") 285 time.sleep(30) 286 try: 287 wutils.start_wifi_connection_scan(self.dut) 288 wifi_results = self.dut.droid.wifiGetScanResults() 289 self.log.debug("Scan result {}".format(wifi_results)) 290 time.sleep(20) 291 current_network = self.dut.droid.wifiGetConnectionInfo() 292 self.log.info("Current network: {}".format(current_network)) 293 asserts.assert_true( 294 ('network_id' in current_network and 295 current_network['network_id'] != -1), 296 "Device is disconnected to network {}".format(current_network)) 297 time.sleep(DEFAULT_TIMEOUT) 298 finally: 299 self.dut.droid.wifiLockRelease() 300 301 def check_connection(self, network_bssid): 302 """Check current wifi connection networks. 303 Args: 304 network_bssid: Network bssid to which connection. 305 Returns: 306 True if connection to given network happen, else return False. 307 """ 308 time.sleep(10) #time for connection state to be updated 309 self.log.info("Check network for {}".format(network_bssid)) 310 current_network = self.dut.droid.wifiGetConnectionInfo() 311 self.log.debug("Current network: {}".format(current_network)) 312 if WifiEnums.BSSID_KEY in current_network: 313 return current_network[WifiEnums.BSSID_KEY] == network_bssid 314 return False 315 316 """ Tests """ 317 318 # EAP connect tests 319 """ Test connecting to enterprise networks of different authentication 320 types. 321 322 The authentication types tested are: 323 EAP-TLS 324 EAP-PEAP with different phase2 types. 325 EAP-TTLS with different phase2 types. 326 327 Procedures: 328 For each enterprise wifi network 329 1. Connect to the network. 330 2. Send a GET request to a website and check response. 331 332 Expect: 333 Successful connection and Internet access through the enterprise 334 networks. 335 """ 336 337 @test_tracker_info(uuid="4e720cac-ea17-4de7-a540-8dc7c49f9713") 338 def test_eap_connect_with_config_tls(self): 339 wutils.wifi_connect(self.dut, self.config_tls) 340 wutils.verify_11ax_wifi_connection( 341 self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) 342 343 @test_tracker_info(uuid="10e3a5e9-0018-4162-a9fa-b41500f13340") 344 def test_eap_connect_with_config_pwd(self): 345 wutils.wifi_connect(self.dut, self.config_pwd) 346 wutils.verify_11ax_wifi_connection( 347 self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) 348 349 @test_tracker_info(uuid="b4513f78-a1c4-427f-bfc7-2a6b3da714b5") 350 def test_eap_connect_with_config_sim(self): 351 asserts.skip_if(self.dut.model not in self.sim_supported_models, 352 "DUT can not equip with mobile SIM card") 353 wutils.wifi_connect(self.dut, self.config_sim) 354 wutils.verify_11ax_wifi_connection( 355 self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) 356 357 @test_tracker_info(uuid="7d390e30-cb67-4b55-bf00-567adad2d9b0") 358 def test_eap_connect_with_config_aka(self): 359 wutils.wifi_connect(self.dut, self.config_aka) 360 wutils.verify_11ax_wifi_connection( 361 self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) 362 363 @test_tracker_info(uuid="742f921b-27c3-4b68-a3ca-88e64fe79c1d") 364 def test_eap_connect_with_config_aka_prime(self): 365 wutils.wifi_connect(self.dut, self.config_aka_prime) 366 wutils.verify_11ax_wifi_connection( 367 self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) 368 369 @test_tracker_info(uuid="d34e30f3-6ef6-459f-b47a-e78ed90ce4c6") 370 def test_eap_connect_with_config_ttls_none(self): 371 config = dict(self.config_ttls) 372 config[WifiEnums.Enterprise.PHASE2] = WifiEnums.EapPhase2.NONE.value 373 wutils.wifi_connect(self.dut, config) 374 wutils.verify_11ax_wifi_connection( 375 self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) 376 377 @test_tracker_info(uuid="0dca3a15-472e-427c-8e06-4e38088ee973") 378 def test_eap_connect_with_config_ttls_pap(self): 379 config = dict(self.config_ttls) 380 config[WifiEnums.Enterprise.PHASE2] = WifiEnums.EapPhase2.PAP.value 381 wutils.wifi_connect(self.dut, config) 382 wutils.verify_11ax_wifi_connection( 383 self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) 384 385 @test_tracker_info(uuid="47c4b459-2cb1-4fc7-b4e7-82534e8e090e") 386 def test_eap_connect_with_config_ttls_mschap(self): 387 config = dict(self.config_ttls) 388 config[WifiEnums.Enterprise.PHASE2] = WifiEnums.EapPhase2.MSCHAP.value 389 wutils.wifi_connect(self.dut, config) 390 wutils.verify_11ax_wifi_connection( 391 self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) 392 393 @test_tracker_info(uuid="fdb286c7-8069-481d-baf0-c5dd7a31ff03") 394 def test_eap_connect_with_config_ttls_mschapv2(self): 395 config = dict(self.config_ttls) 396 config[ 397 WifiEnums.Enterprise.PHASE2] = WifiEnums.EapPhase2.MSCHAPV2.value 398 wutils.wifi_connect(self.dut, config) 399 wutils.verify_11ax_wifi_connection( 400 self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) 401 402 @test_tracker_info(uuid="d9315962-7987-4ee7-905d-6972c78ce8a1") 403 def test_eap_connect_with_config_ttls_gtc(self): 404 config = dict(self.config_ttls) 405 config[WifiEnums.Enterprise.PHASE2] = WifiEnums.EapPhase2.GTC.value 406 wutils.wifi_connect(self.dut, config) 407 wutils.verify_11ax_wifi_connection( 408 self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) 409 410 @test_tracker_info(uuid="90a67bd3-30da-4daf-8ab0-d964d7ad19be") 411 def test_eap_connect_with_config_peap0_mschapv2(self): 412 config = dict(self.config_peap0) 413 config[ 414 WifiEnums.Enterprise.PHASE2] = WifiEnums.EapPhase2.MSCHAPV2.value 415 wutils.wifi_connect(self.dut, config) 416 wutils.verify_11ax_wifi_connection( 417 self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) 418 419 @test_tracker_info(uuid="3c451ba4-0c83-4eef-bc95-db4c21893008") 420 def test_eap_connect_with_config_peap0_gtc(self): 421 config = dict(self.config_peap0) 422 config[WifiEnums.Enterprise.PHASE2] = WifiEnums.EapPhase2.GTC.value 423 wutils.wifi_connect(self.dut, config) 424 wutils.verify_11ax_wifi_connection( 425 self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) 426 427 @test_tracker_info(uuid="6b45157d-0325-417a-af18-11af5d240d79") 428 def test_eap_connect_with_config_peap1_mschapv2(self): 429 config = dict(self.config_peap1) 430 config[ 431 WifiEnums.Enterprise.PHASE2] = WifiEnums.EapPhase2.MSCHAPV2.value 432 wutils.wifi_connect(self.dut, config) 433 wutils.verify_11ax_wifi_connection( 434 self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) 435 436 @test_tracker_info(uuid="1663decc-71ae-4f95-a027-8a6dbf9c337f") 437 def test_eap_connect_with_config_peap1_gtc(self): 438 config = dict(self.config_peap1) 439 config[WifiEnums.Enterprise.PHASE2] = WifiEnums.EapPhase2.GTC.value 440 wutils.wifi_connect(self.dut, config) 441 wutils.verify_11ax_wifi_connection( 442 self.dut, self.wifi6_models, "wifi6_ap" in self.user_params) 443 444 # EAP connect negative tests 445 """ Test connecting to enterprise networks. 446 447 Procedures: 448 For each enterprise wifi network 449 1. Connect to the network with invalid credentials. 450 451 Expect: 452 Fail to establish connection. 453 """ 454 455 @test_tracker_info(uuid="b2a91f1f-ccd7-4bd1-ab81-19aab3d8ee38") 456 def test_eap_connect_negative_with_config_tls(self): 457 config = self.gen_negative_eap_configs(self.config_tls) 458 self.eap_negative_connect_logic(config, self.dut) 459 460 @test_tracker_info(uuid="b7fb8517-5d52-468e-890a-40ea24129bf1") 461 def test_network_selection_status_wpa2_eap_tls_invalid_cert(self): 462 config = self.gen_negative_eap_configs(self.config_tls) 463 try: 464 wutils.connect_to_wifi_network(self.dut, config) 465 asserts.fail( 466 "WPA2 EAP TLS worked with invalid cert. Expected to fail.") 467 except: 468 asserts.assert_true( 469 self.dut.droid.wifiIsNetworkTemporaryDisabledForNetwork(config), 470 "WiFi network is not temporary disabled.") 471 asserts.explicit_pass( 472 "Connection failed with correct network selection status.") 473 474 @test_tracker_info(uuid="6466abde-1d16-4168-9dd8-1e7a0a19889b") 475 def test_eap_connect_negative_with_config_pwd(self): 476 config = self.gen_negative_eap_configs(self.config_pwd) 477 self.eap_negative_connect_logic(config, self.dut) 478 479 @test_tracker_info(uuid="d7742a2a-85b0-409a-99d8-47711ddc5612") 480 def test_eap_connect_negative_with_config_sim(self): 481 asserts.skip_if(self.dut.model not in self.sim_supported_models, 482 "DUT can not equip with mobile SIM card") 483 config = self.gen_negative_eap_configs(self.config_sim) 484 self.eap_negative_connect_logic(config, self.dut) 485 486 @test_tracker_info(uuid="0ec0de93-cab3-4f41-960b-c0af64ff48c4") 487 def test_eap_connect_negative_with_config_aka(self): 488 config = self.gen_negative_eap_configs(self.config_aka) 489 self.eap_negative_connect_logic(config, self.dut) 490 491 @test_tracker_info(uuid="bb640ea4-32a6-48ea-87c9-f7128fffbbf6") 492 def test_eap_connect_negative_with_config_aka_prime(self): 493 config = self.gen_negative_eap_configs(self.config_aka_prime) 494 self.eap_negative_connect_logic(config, self.dut) 495 496 @test_tracker_info(uuid="86336ada-0ced-45a4-8a22-c4aa23c81111") 497 def test_eap_connect_negative_with_config_ttls_none(self): 498 config = dict(self.config_ttls) 499 config[WifiEnums.Enterprise.PHASE2] = WifiEnums.EapPhase2.NONE.value 500 config = self.gen_negative_eap_configs(config) 501 self.eap_negative_connect_logic(config, self.dut) 502 503 @test_tracker_info(uuid="71e0498d-9973-4958-94bd-79051c328920") 504 def test_eap_connect_negative_with_config_ttls_pap(self): 505 config = dict(self.config_ttls) 506 config[WifiEnums.Enterprise.PHASE2] = WifiEnums.EapPhase2.PAP.value 507 config = self.gen_negative_eap_configs(config) 508 self.eap_negative_connect_logic(config, self.dut) 509 510 @test_tracker_info(uuid="c04142a8-b204-4d2d-98dc-150b16c8397e") 511 def test_eap_connect_negative_with_config_ttls_mschap(self): 512 config = dict(self.config_ttls) 513 config[WifiEnums.Enterprise.PHASE2] = WifiEnums.EapPhase2.MSCHAP.value 514 config = self.gen_negative_eap_configs(config) 515 self.eap_negative_connect_logic(config, self.dut) 516 517 @test_tracker_info(uuid="625e7aa5-e3e6-4bbe-98c0-5aad8ca1555b") 518 def test_eap_connect_negative_with_config_ttls_mschapv2(self): 519 config = dict(self.config_ttls) 520 config[ 521 WifiEnums.Enterprise.PHASE2] = WifiEnums.EapPhase2.MSCHAPV2.value 522 config = self.gen_negative_eap_configs(config) 523 self.eap_negative_connect_logic(config, self.dut) 524 525 @test_tracker_info(uuid="24ea0d80-0a3f-41c2-8e05-d6387e589058") 526 def test_eap_connect_negative_with_config_ttls_gtc(self): 527 config = dict(self.config_ttls) 528 config[WifiEnums.Enterprise.PHASE2] = WifiEnums.EapPhase2.GTC.value 529 config = self.gen_negative_eap_configs(config) 530 self.eap_negative_connect_logic(config, self.dut) 531 532 @test_tracker_info(uuid="b7c1f0f8-6338-4501-8e1d-c9b136aaba88") 533 def test_eap_connect_negative_with_config_peap0_mschapv2(self): 534 config = dict(self.config_peap0) 535 config[ 536 WifiEnums.Enterprise.PHASE2] = WifiEnums.EapPhase2.MSCHAPV2.value 537 config = self.gen_negative_eap_configs(config) 538 self.eap_negative_connect_logic(config, self.dut) 539 540 @test_tracker_info(uuid="9cf83dcb-38ad-4f75-9ea9-98de1cfaf7f3") 541 def test_eap_connect_negative_with_config_peap0_gtc(self): 542 config = dict(self.config_peap0) 543 config[WifiEnums.Enterprise.PHASE2] = WifiEnums.EapPhase2.GTC.value 544 config = self.gen_negative_eap_configs(config) 545 self.eap_negative_connect_logic(config, self.dut) 546 547 @test_tracker_info(uuid="89bb2b6b-d073-402a-bdc1-68ac5f8752a3") 548 def test_eap_connect_negative_with_config_peap1_mschapv2(self): 549 config = dict(self.config_peap1) 550 config[ 551 WifiEnums.Enterprise.PHASE2] = WifiEnums.EapPhase2.MSCHAPV2.value 552 config = self.gen_negative_eap_configs(config) 553 self.eap_negative_connect_logic(config, self.dut) 554 555 @test_tracker_info(uuid="2252a864-9ff7-43b5-82d9-afe57d1f5e5f") 556 def test_eap_connect_negative_with_config_peap1_gtc(self): 557 config = dict(self.config_peap1) 558 config[WifiEnums.Enterprise.PHASE2] = WifiEnums.EapPhase2.GTC.value 559 config = self.gen_negative_eap_configs(config) 560 self.eap_negative_connect_logic(config, self.dut) 561 562 # EAP connect config store tests 563 """ Test connecting to enterprise networks of different authentication 564 types after wifi toggle. 565 566 The authentication types tested are: 567 EAP-TLS 568 EAP-PEAP with different phase2 types. 569 EAP-TTLS with different phase2 types. 570 571 Procedures: 572 For each enterprise wifi network 573 1. Connect to the network. 574 2. Send a GET request to a website and check response. 575 3. Toggle wifi. 576 4. Ensure that the device reconnects to the same network. 577 578 Expect: 579 Successful connection and Internet access through the enterprise 580 networks. 581 """ 582 583 @test_tracker_info(uuid="2a933b7f-27d7-4201-a34f-25b9d8072a8c") 584 def test_eap_connect_config_store_with_config_tls(self): 585 self.eap_connect_toggle_wifi(self.config_tls, self.dut) 586 587 @test_tracker_info(uuid="08dc071b-9fea-408a-a3f6-d3493869f6d4") 588 def test_eap_connect_config_store_with_config_pwd(self): 589 self.eap_connect_toggle_wifi(self.config_pwd, self.dut) 590 591 @test_tracker_info(uuid="230cb03e-58bc-41cb-b9b3-7215c2ab2325") 592 def test_eap_connect_config_store_with_config_sim(self): 593 asserts.skip_if(self.dut.model not in self.sim_supported_models, 594 "DUT can not equip with mobile SIM card") 595 self.eap_connect_toggle_wifi(self.config_sim, self.dut) 596 597 @test_tracker_info(uuid="dfc3e59c-2309-4598-8c23-bb3fe95ef89f") 598 def test_eap_connect_config_store_with_config_aka(self): 599 self.eap_connect_toggle_wifi(self.config_aka, self.dut) 600 601 @test_tracker_info(uuid="6050a1d1-4f3a-476d-bf93-638abd066790") 602 def test_eap_connect_config_store_with_config_aka_prime(self): 603 self.eap_connect_toggle_wifi(self.config_aka_prime, self.dut) 604 605 @test_tracker_info(uuid="03108057-cc44-4a80-8331-77c93694099c") 606 def test_eap_connect_config_store_with_config_ttls_none(self): 607 config = dict(self.config_ttls) 608 config[WifiEnums.Enterprise.PHASE2] = WifiEnums.EapPhase2.NONE.value 609 self.eap_connect_toggle_wifi(config, self.dut) 610 611 @test_tracker_info(uuid="53dd8195-e272-4589-a261-b8fa3607ad8d") 612 def test_eap_connect_config_store_with_config_ttls_pap(self): 613 config = dict(self.config_ttls) 614 config[WifiEnums.Enterprise.PHASE2] = WifiEnums.EapPhase2.PAP.value 615 self.eap_connect_toggle_wifi(config, self.dut) 616 617 @test_tracker_info(uuid="640f697b-9c62-4b19-bd76-53b236a152e0") 618 def test_eap_connect_config_store_with_config_ttls_mschap(self): 619 config = dict(self.config_ttls) 620 config[WifiEnums.Enterprise.PHASE2] = WifiEnums.EapPhase2.MSCHAP.value 621 self.eap_connect_toggle_wifi(config, self.dut) 622 623 @test_tracker_info(uuid="f0243684-fae0-46f3-afbd-bf525fc712e2") 624 def test_eap_connect_config_store_with_config_ttls_mschapv2(self): 625 config = dict(self.config_ttls) 626 config[ 627 WifiEnums.Enterprise.PHASE2] = WifiEnums.EapPhase2.MSCHAPV2.value 628 self.eap_connect_toggle_wifi(config, self.dut) 629 630 @test_tracker_info(uuid="49ec7202-3b00-49c3-970a-201360888c74") 631 def test_eap_connect_config_store_with_config_ttls_gtc(self): 632 config = dict(self.config_ttls) 633 config[WifiEnums.Enterprise.PHASE2] = WifiEnums.EapPhase2.GTC.value 634 self.eap_connect_toggle_wifi(config, self.dut) 635 636 @test_tracker_info(uuid="1c6abfa3-f344-4e28-b891-5481ab79efcf") 637 def test_eap_connect_config_store_with_config_peap0_mschapv2(self): 638 config = dict(self.config_peap0) 639 config[ 640 WifiEnums.Enterprise.PHASE2] = WifiEnums.EapPhase2.MSCHAPV2.value 641 self.eap_connect_toggle_wifi(config, self.dut) 642 643 @test_tracker_info(uuid="2815bc76-49fa-43a5-a4b6-84788f9809d5") 644 def test_eap_connect_config_store_with_config_peap0_gtc(self): 645 config = dict(self.config_peap0) 646 config[WifiEnums.Enterprise.PHASE2] = WifiEnums.EapPhase2.GTC.value 647 self.eap_connect_toggle_wifi(config, self.dut) 648 649 @test_tracker_info(uuid="e93f7472-6895-4e36-bff2-9b2dcfd07ad0") 650 def test_eap_connect_config_store_with_config_peap1_mschapv2(self): 651 config = dict(self.config_peap1) 652 config[ 653 WifiEnums.Enterprise.PHASE2] = WifiEnums.EapPhase2.MSCHAPV2.value 654 self.eap_connect_toggle_wifi(config, self.dut) 655 656 @test_tracker_info(uuid="6da72fa0-b858-4475-9559-46fe052d0d64") 657 def test_eap_connect_config_store_with_config_peap1_gtc(self): 658 config = dict(self.config_peap1) 659 config[WifiEnums.Enterprise.PHASE2] = WifiEnums.EapPhase2.GTC.value 660 self.eap_connect_toggle_wifi(config, self.dut) 661 662 # Airplane mode on with wifi connect tests 663 """ Test connecting to enterprise networks of different authentication 664 types after airplane mode on. 665 666 The authentication types tested are: 667 EAP-SIM 668 EAP-AKA 669 EAP-AKA_PRIME 670 671 Procedures: 672 For each enterprise wifi network 673 1. Turn on Airplane mode 674 2. Toggle wifi.. 675 3. Ensure that the device connects to the enterprise network. 676 677 Expect: 678 Successful connection and Internet access through the enterprise 679 networks with Airplane mode on. 680 """ 681 682 @test_tracker_info(uuid="54b96a6c-f366-421c-9a72-80d7ee8fac8f") 683 def test_eap_connect_with_config_sim_airplane_on(self): 684 asserts.skip_if(self.dut.model not in self.sim_supported_models, 685 "DUT can not equip with mobile SIM card") 686 self.log.info("Toggling Airplane mode ON") 687 asserts.assert_true( 688 acts.utils.force_airplane_mode(self.dut, True), 689 "Can not turn on airplane mode on: %s" % self.dut.serial) 690 time.sleep(DEFAULT_TIMEOUT) 691 wutils.wifi_toggle_state(self.dut, True) 692 wutils.wifi_connect(self.dut, self.config_sim) 693 self.log.info("Toggling Airplane mode OFF") 694 asserts.assert_true( 695 acts.utils.force_airplane_mode(self.dut, False), 696 "Can not turn OFF airplane mode: %s" % self.dut.serial) 697 wutils.start_wifi_connection_scan_and_ensure_network_found( 698 self.dut, self.config_sim[WifiEnums.SSID_KEY]) 699 700 @test_tracker_info(uuid="344f63f6-7c99-4507-8036-757f9f911d20") 701 def test_eap_connect_with_config_aka_airplane_on(self): 702 self.log.info("Toggling Airplane mode ON") 703 asserts.assert_true( 704 acts.utils.force_airplane_mode(self.dut, True), 705 "Can not turn on airplane mode on: %s" % self.dut.serial) 706 time.sleep(DEFAULT_TIMEOUT) 707 wutils.wifi_toggle_state(self.dut, True) 708 wutils.wifi_connect(self.dut, self.config_aka) 709 self.log.info("Toggling Airplane mode OFF") 710 asserts.assert_true( 711 acts.utils.force_airplane_mode(self.dut, False), 712 "Can not turn OFF airplane mode: %s" % self.dut.serial) 713 wutils.start_wifi_connection_scan_and_ensure_network_found( 714 self.dut, self.config_aka[WifiEnums.SSID_KEY]) 715 716 @test_tracker_info(uuid="5502b8c8-89d7-4ce9-afee-cae50e71f5f4") 717 def test_eap_connect_with_config_aka_prime_airplane_on(self): 718 self.log.info("Toggling Airplane mode ON") 719 asserts.assert_true( 720 acts.utils.force_airplane_mode(self.dut, True), 721 "Can not turn on airplane mode on: %s" % self.dut.serial) 722 time.sleep(DEFAULT_TIMEOUT) 723 wutils.wifi_toggle_state(self.dut, True) 724 wutils.wifi_connect(self.dut, self.config_aka_prime) 725 self.log.info("Toggling Airplane mode OFF") 726 asserts.assert_true( 727 acts.utils.force_airplane_mode(self.dut, False), 728 "Can not turn OFF airplane mode: %s" % self.dut.serial) 729 wutils.start_wifi_connection_scan_and_ensure_network_found( 730 self.dut, self.config_aka_prime[WifiEnums.SSID_KEY]) 731 732 @test_tracker_info(uuid="360a6fec-f4ee-4ecd-9b15-e836c977d6db") 733 def test_connect_eap_sim_network_out_of_range_back(self): 734 """Test connecting to enterprise networks to do out of range 735 then back in range 3 times 736 1. Connecting EAP-SIM network 737 2. Move DUT out of range then back in range 3 times 738 3. Check that device is connected to network. 739 """ 740 asserts.skip_if(self.dut.model not in self.sim_supported_models, 741 "DUT can not equip with mobile SIM card") 742 wutils.wifi_connect(self.dut, self.config_sim) 743 self.toggle_out_of_range_stress() 744 745 @test_tracker_info(uuid="9fb71afb-5599-4ca1-b458-09752c40bb0d") 746 def test_eap_sim_network_out_of_range_back_airplane(self): 747 """Test connecting to enterprise networks with airplne mode on 748 to do out of range then back in range 3 times 749 1. Turn on airplane mode 750 2. Connecting EAP-SIM network 751 3. Move DUT out of range then back in range 3 times 752 4. Check that device is connected to network. 753 """ 754 asserts.skip_if(self.dut.model not in self.sim_supported_models, 755 "DUT can not equip with mobile SIM card") 756 self.log.debug("Toggling Airplane mode ON") 757 asserts.assert_true( 758 acts.utils.force_airplane_mode(self.dut, True), 759 "Can not turn on airplane mode on: %s" % self.dut.serial) 760 time.sleep(DEFAULT_TIMEOUT) 761 self.log.debug("Toggling WiFi mode ON") 762 wutils.wifi_toggle_state(self.dut, True) 763 time.sleep(DEFAULT_TIMEOUT) 764 wutils.wifi_connect(self.dut, self.config_sim) 765 self.toggle_out_of_range_stress() 766 767 @test_tracker_info(uuid="9e899c55-1a62-498c-bbf1-e9472e42e84f") 768 def test_eap_sim_network_reboot(self): 769 """Test connecting to enterprise networks with airplne mode on 770 to do out of range then back in range 3 times 771 1. Connecting EAP-SIM network 772 3. Check that device is connected to network after reboot. 773 """ 774 asserts.skip_if(self.dut.model not in self.sim_supported_models, 775 "DUT can not equip with mobile SIM card") 776 self.dut.droid.disableDevicePassword(self.device_password) 777 wutils.wifi_connect(self.dut, self.config_sim) 778 current_network = self.dut.droid.wifiGetConnectionInfo() 779 self.log.info("Current network: {}".format(current_network)) 780 self.dut.reboot() 781 time.sleep(DEFAULT_TIMEOUT) 782 self.check_connection(self.config_sim) 783 784 @test_tracker_info(uuid="8e7465fb-5b16-4abb-92d8-a2c79355e377") 785 def test_connect_to_EAP_SIM_network_switch_to_WPA2(self): 786 """Test connecting PSK's AP1 and one EAP AP2 network switch test 787 1. Connect to a PSK's AP1 before connect to EAP-SIM AP2 network. 788 2. Out of PSK's AP1 range. 789 3. Connect to EAP-SIM network, then in AP1 range to switch WPA2-PSK network. 790 """ 791 asserts.skip_if(self.dut.model not in self.sim_supported_models, 792 "DUT can not equip with mobile SIM card") 793 attn1 = self.attenuators[0] 794 attn2 = self.attenuators[2] 795 if "OpenWrtAP" in self.user_params: 796 attn2 = self.attenuators[1] 797 ap1_network = self.config_sim 798 ap2_network = self.reference_networks[1]["2g"] 799 attn1.set_atten(0) 800 attn2.set_atten(0) 801 wutils.connect_to_wifi_network(self.dut, ap2_network) 802 #Enable EAP network signal 803 attn2.set_atten(95) 804 time.sleep(DEFAULT_TIMEOUT) 805 wutils.connect_to_wifi_network(self.dut, ap1_network) 806 current_network = self.dut.droid.wifiGetConnectionInfo() 807 self.log.info("Current network: {}".format(current_network)) 808 #Enable SSID1 network signal 809 attn1.set_atten(95) 810 attn2.set_atten(0) 811 time.sleep(20) 812 self.check_connection(ap2_network) 813