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