1 /* 2 * Copyright (C) 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package android.net.wifi; 18 19 import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_DPP; 20 import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_EAP; 21 import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_EAP_SUITE_B; 22 import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE; 23 import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT; 24 import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_OPEN; 25 import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_OSEN; 26 import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_OWE; 27 import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_PASSPOINT_R1_R2; 28 import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_PASSPOINT_R3; 29 import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_PSK; 30 import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_SAE; 31 import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_WAPI_CERT; 32 import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_WAPI_PSK; 33 import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_WEP; 34 import static android.net.wifi.WifiConfiguration.getSecurityTypeName; 35 36 import static org.junit.Assert.assertArrayEquals; 37 import static org.junit.Assert.assertEquals; 38 import static org.junit.Assert.assertFalse; 39 import static org.junit.Assert.assertNotNull; 40 import static org.junit.Assert.assertNotSame; 41 import static org.junit.Assert.assertTrue; 42 import static org.junit.Assume.assumeFalse; 43 import static org.junit.Assume.assumeTrue; 44 import static org.mockito.Mockito.mock; 45 46 import android.net.MacAddress; 47 import android.net.ProxyInfo; 48 import android.net.wifi.WifiConfiguration.GroupCipher; 49 import android.net.wifi.WifiConfiguration.KeyMgmt; 50 import android.net.wifi.WifiConfiguration.NetworkSelectionStatus; 51 import android.net.wifi.WifiConfiguration.PairwiseCipher; 52 import android.net.wifi.WifiConfiguration.Protocol; 53 import android.os.Parcel; 54 import android.os.ParcelUuid; 55 import android.util.Pair; 56 57 import androidx.test.filters.SmallTest; 58 59 import com.android.modules.utils.build.SdkLevel; 60 import com.android.net.module.util.MacAddressUtils; 61 62 import org.junit.Before; 63 import org.junit.Test; 64 65 import java.util.ArrayList; 66 import java.util.Arrays; 67 import java.util.BitSet; 68 import java.util.List; 69 70 /** 71 * Unit tests for {@link android.net.wifi.WifiConfiguration}. 72 */ 73 @SmallTest 74 public class WifiConfigurationTest { 75 private static final String TEST_PASSPOINT_UNIQUE_ID = "uniqueId"; 76 private static final int TEST_CARRIER_ID = 1234; 77 private static final int TEST_SUB_ID = 3; 78 private static final String TEST_PACKAGE_NAME = "google.com"; 79 private static final int[] SECURITY_TYPES_EXCEPT_PASSPOINT = { 80 SECURITY_TYPE_OPEN, 81 SECURITY_TYPE_WEP, 82 SECURITY_TYPE_PSK, 83 SECURITY_TYPE_EAP, 84 SECURITY_TYPE_SAE, 85 SECURITY_TYPE_EAP_SUITE_B, 86 SECURITY_TYPE_OWE, 87 SECURITY_TYPE_WAPI_PSK, 88 SECURITY_TYPE_WAPI_CERT, 89 SECURITY_TYPE_EAP_WPA3_ENTERPRISE, 90 SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT}; 91 92 @Before setUp()93 public void setUp() { 94 } 95 96 /** 97 * Check that parcel marshalling/unmarshalling works 98 * 99 * Create and populate a WifiConfiguration. 100 * Marshall and unmashall it, and expect to recover a copy of the original. 101 * Marshall the resulting object, and expect the bytes to match the 102 * first marshall result. 103 */ 104 @Test testWifiConfigurationParcel()105 public void testWifiConfigurationParcel() { 106 String cookie = "C O.o |<IE"; 107 WifiConfiguration config = new WifiConfiguration(); 108 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 109 config.setPasspointManagementObjectTree(cookie); 110 config.trusted = false; 111 config.oemPaid = true; 112 config.oemPrivate = true; 113 config.carrierMerged = true; 114 config.updateIdentifier = "1234"; 115 config.fromWifiNetworkSpecifier = true; 116 config.fromWifiNetworkSuggestion = true; 117 config.setRandomizedMacAddress(MacAddressUtils.createRandomUnicastAddress()); 118 MacAddress macBeforeParcel = config.getRandomizedMacAddress(); 119 config.subscriptionId = 1; 120 config.carrierId = 1189; 121 config.restricted = true; 122 config.isCurrentlyConnected = true; 123 config.setIsUserSelected(true); 124 config.setSubscriptionGroup(ParcelUuid.fromString("0000110B-0000-1000-8000-00805F9B34FB")); 125 config.getNetworkSelectionStatus().setDisableTime(12333); 126 config.getNetworkSelectionStatus().setDisableEndTime(45666); 127 if (SdkLevel.isAtLeastV()) { 128 config.setVendorData(OuiKeyedDataUtil.createTestOuiKeyedDataList(5)); 129 } 130 assertEquals(12333, config.getNetworkSelectionStatus().getDisableTime()); 131 assertEquals(45666, config.getNetworkSelectionStatus().getDisableEndTime()); 132 Parcel parcelW = Parcel.obtain(); 133 config.writeToParcel(parcelW, 0); 134 byte[] bytes = parcelW.marshall(); 135 parcelW.recycle(); 136 137 Parcel parcelR = Parcel.obtain(); 138 parcelR.unmarshall(bytes, 0, bytes.length); 139 parcelR.setDataPosition(0); 140 WifiConfiguration reconfig = WifiConfiguration.CREATOR.createFromParcel(parcelR); 141 142 // lacking a useful config.equals, check two fields near the end. 143 assertEquals(cookie, reconfig.getMoTree()); 144 assertEquals(macBeforeParcel, reconfig.getRandomizedMacAddress()); 145 assertEquals(config.updateIdentifier, reconfig.updateIdentifier); 146 assertFalse(reconfig.trusted); 147 assertTrue(reconfig.fromWifiNetworkSpecifier); 148 assertTrue(reconfig.fromWifiNetworkSuggestion); 149 assertTrue(reconfig.oemPaid); 150 assertTrue(reconfig.oemPrivate); 151 assertTrue(reconfig.carrierMerged); 152 assertEquals(config.carrierId, reconfig.carrierId); 153 assertEquals(config.subscriptionId, reconfig.subscriptionId); 154 assertEquals(config.getSubscriptionGroup(), reconfig.getSubscriptionGroup()); 155 assertTrue(reconfig.restricted); 156 assertTrue(reconfig.isCurrentlyConnected); 157 assertTrue(reconfig.isUserSelected()); 158 assertEquals(config.getBssidAllowlist(), reconfig.getBssidAllowlist()); 159 assertEquals( 160 SecurityParams.createSecurityParamsBySecurityType( 161 WifiConfiguration.SECURITY_TYPE_PSK), 162 reconfig.getSecurityParams( 163 WifiConfiguration.SECURITY_TYPE_PSK)); 164 assertEquals(config.getNetworkSelectionStatus().getDisableTime(), 165 reconfig.getNetworkSelectionStatus().getDisableTime()); 166 assertEquals(config.getNetworkSelectionStatus().getDisableEndTime(), 167 reconfig.getNetworkSelectionStatus().getDisableEndTime()); 168 if (SdkLevel.isAtLeastV()) { 169 assertTrue(config.getVendorData().equals(reconfig.getVendorData())); 170 } 171 172 Parcel parcelWW = Parcel.obtain(); 173 reconfig.writeToParcel(parcelWW, 0); 174 byte[] rebytes = parcelWW.marshall(); 175 parcelWW.recycle(); 176 177 assertArrayEquals(bytes, rebytes); 178 } 179 180 @Test testWifiConfigurationCopyConstructor()181 public void testWifiConfigurationCopyConstructor() { 182 WifiConfiguration config = new WifiConfiguration(); 183 config.trusted = false; 184 config.oemPaid = true; 185 config.oemPrivate = true; 186 config.carrierMerged = true; 187 config.updateIdentifier = "1234"; 188 config.fromWifiNetworkSpecifier = true; 189 config.fromWifiNetworkSuggestion = true; 190 config.setRandomizedMacAddress(MacAddressUtils.createRandomUnicastAddress()); 191 MacAddress macBeforeParcel = config.getRandomizedMacAddress(); 192 config.subscriptionId = 1; 193 config.carrierId = 1189; 194 config.restricted = true; 195 config.isCurrentlyConnected = true; 196 config.setIsUserSelected(true); 197 if (SdkLevel.isAtLeastV()) { 198 config.setVendorData(OuiKeyedDataUtil.createTestOuiKeyedDataList(5)); 199 } 200 201 WifiConfiguration reconfig = new WifiConfiguration(config); 202 203 // lacking a useful config.equals, check two fields near the end. 204 assertEquals(macBeforeParcel, reconfig.getRandomizedMacAddress()); 205 assertEquals(config.updateIdentifier, reconfig.updateIdentifier); 206 assertFalse(reconfig.trusted); 207 assertTrue(reconfig.fromWifiNetworkSpecifier); 208 assertTrue(reconfig.fromWifiNetworkSuggestion); 209 assertTrue(reconfig.oemPaid); 210 assertTrue(reconfig.oemPrivate); 211 assertTrue(reconfig.carrierMerged); 212 assertEquals(config.carrierId, reconfig.carrierId); 213 assertEquals(config.subscriptionId, reconfig.subscriptionId); 214 assertTrue(reconfig.restricted); 215 assertTrue(reconfig.isCurrentlyConnected); 216 assertTrue(reconfig.isUserSelected()); 217 if (SdkLevel.isAtLeastV()) { 218 assertTrue(config.getVendorData().equals(reconfig.getVendorData())); 219 } 220 } 221 222 @Test testIsOpenNetwork_IsOpen_NullWepKeys()223 public void testIsOpenNetwork_IsOpen_NullWepKeys() { 224 WifiConfiguration config = new WifiConfiguration(); 225 config.allowedKeyManagement.clear(); 226 config.wepKeys = null; 227 228 assertTrue(config.isOpenNetwork()); 229 } 230 231 @Test testIsOpenNetwork_IsOpen_ZeroLengthWepKeysArray()232 public void testIsOpenNetwork_IsOpen_ZeroLengthWepKeysArray() { 233 WifiConfiguration config = new WifiConfiguration(); 234 config.allowedKeyManagement.clear(); 235 config.wepKeys = new String[0]; 236 237 assertTrue(config.isOpenNetwork()); 238 } 239 240 @Test testIsOpenNetwork_IsOpen_NullWepKeysArray()241 public void testIsOpenNetwork_IsOpen_NullWepKeysArray() { 242 WifiConfiguration config = new WifiConfiguration(); 243 config.allowedKeyManagement.clear(); 244 config.wepKeys = new String[1]; 245 246 assertTrue(config.isOpenNetwork()); 247 } 248 249 @Test testIsOpenNetwork_NotOpen_HasWepKeys()250 public void testIsOpenNetwork_NotOpen_HasWepKeys() { 251 WifiConfiguration config = new WifiConfiguration(); 252 config.allowedKeyManagement.clear(); 253 config.wepKeys = new String[] {"test"}; 254 255 assertFalse(config.isOpenNetwork()); 256 } 257 258 @Test testIsOpenNetwork_NotOpen_HasNullWepKeyFollowedByNonNullKey()259 public void testIsOpenNetwork_NotOpen_HasNullWepKeyFollowedByNonNullKey() { 260 WifiConfiguration config = new WifiConfiguration(); 261 config.allowedKeyManagement.clear(); 262 config.wepKeys = new String[] {null, null, "test"}; 263 264 assertFalse(config.isOpenNetwork()); 265 } 266 267 @Test testIsOpenNetwork_NotOpen_HasAuthType()268 public void testIsOpenNetwork_NotOpen_HasAuthType() { 269 int[] securityTypes = new int [] { 270 SECURITY_TYPE_WEP, 271 SECURITY_TYPE_PSK, 272 SECURITY_TYPE_EAP, 273 SECURITY_TYPE_SAE, 274 SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT, 275 SECURITY_TYPE_WAPI_PSK, 276 SECURITY_TYPE_WAPI_CERT, 277 SECURITY_TYPE_EAP_WPA3_ENTERPRISE, 278 SECURITY_TYPE_OSEN, 279 }; 280 for (int type: securityTypes) { 281 WifiConfiguration config = new WifiConfiguration(); 282 config.setSecurityParams(type); 283 config.wepKeys = null; 284 285 assertFalse("Open network reported when security type was set to " 286 + type, config.isOpenNetwork()); 287 } 288 } 289 290 @Test testIsOpenNetwork_NotOpen_HasAuthTypeNoneAndMore()291 public void testIsOpenNetwork_NotOpen_HasAuthTypeNoneAndMore() { 292 WifiConfiguration config = new WifiConfiguration(); 293 config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE); 294 config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_EAP); 295 config.wepKeys = null; 296 config.convertLegacyFieldsToSecurityParamsIfNeeded(); 297 298 assertFalse(config.isOpenNetwork()); 299 } 300 301 @Test testSetRandomizedMacAddress_ChangesSavedAddress()302 public void testSetRandomizedMacAddress_ChangesSavedAddress() { 303 WifiConfiguration config = new WifiConfiguration(); 304 MacAddress defaultMac = MacAddress.fromString(WifiInfo.DEFAULT_MAC_ADDRESS); 305 assertEquals(defaultMac, config.getRandomizedMacAddress()); 306 307 MacAddress macToChangeInto = MacAddressUtils.createRandomUnicastAddress(); 308 config.setRandomizedMacAddress(macToChangeInto); 309 MacAddress macAfterChange = config.getRandomizedMacAddress(); 310 311 assertEquals(macToChangeInto, macAfterChange); 312 } 313 314 @Test testSetRandomizedMacAddress_DoesNothingWhenNull()315 public void testSetRandomizedMacAddress_DoesNothingWhenNull() { 316 WifiConfiguration config = new WifiConfiguration(); 317 MacAddress defaultMac = MacAddress.fromString(WifiInfo.DEFAULT_MAC_ADDRESS); 318 config.setRandomizedMacAddress(null); 319 assertEquals(defaultMac, config.getRandomizedMacAddress()); 320 } 321 322 /** 323 * Verifies that updateIdentifier should be copied for copy constructor. 324 */ 325 @Test testUpdateIdentifierForCopyConstructor()326 public void testUpdateIdentifierForCopyConstructor() { 327 WifiConfiguration config = new WifiConfiguration(); 328 config.updateIdentifier = "1234"; 329 WifiConfiguration copyConfig = new WifiConfiguration(config); 330 331 assertEquals(config.updateIdentifier, copyConfig.updateIdentifier); 332 } 333 334 /** 335 * Verifies that getKeyIdForCredentials returns the expected string for Enterprise networks 336 * @throws Exception 337 */ 338 @Test testGetKeyIdForCredentials()339 public void testGetKeyIdForCredentials() throws Exception { 340 WifiConfiguration config = new WifiConfiguration(); 341 final String mSsid = "\"TestAP\""; 342 config.SSID = mSsid; 343 344 // Test various combinations 345 // EAP with TLS 346 config.allowedKeyManagement.set(KeyMgmt.WPA_EAP); 347 config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.TLS); 348 config.enterpriseConfig.setPhase2Method(WifiEnterpriseConfig.Phase2.NONE); 349 String keyId = config.getKeyIdForCredentials(config); 350 assertEquals(keyId, mSsid + "_WPA_EAP_TLS_NULL"); 351 352 // EAP with TTLS & MSCHAPv2 353 config.allowedKeyManagement.set(KeyMgmt.WPA_EAP); 354 config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.TTLS); 355 config.enterpriseConfig.setPhase2Method(WifiEnterpriseConfig.Phase2.MSCHAPV2); 356 keyId = config.getKeyIdForCredentials(config); 357 assertEquals(keyId, mSsid + "_WPA_EAP_TTLS_MSCHAPV2"); 358 359 // Suite-B 192 with PWD & GTC 360 config.allowedKeyManagement.clear(); 361 config.allowedKeyManagement.set(KeyMgmt.SUITE_B_192); 362 config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.PWD); 363 config.enterpriseConfig.setPhase2Method(WifiEnterpriseConfig.Phase2.GTC); 364 keyId = config.getKeyIdForCredentials(config); 365 assertEquals(keyId, mSsid + "_SUITE_B_192_PWD_GTC"); 366 367 // IEEE8021X with SIM 368 config.allowedKeyManagement.clear(); 369 config.allowedKeyManagement.set(KeyMgmt.IEEE8021X); 370 config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.SIM); 371 config.enterpriseConfig.setPhase2Method(WifiEnterpriseConfig.Phase2.NONE); 372 keyId = config.getKeyIdForCredentials(config); 373 assertEquals(keyId, mSsid + "_IEEE8021X_SIM_NULL"); 374 375 // Try calling this method with non-Enterprise network, expect an exception 376 boolean exceptionThrown = false; 377 try { 378 config.allowedKeyManagement.clear(); 379 config.allowedKeyManagement.set(KeyMgmt.WPA2_PSK); 380 config.preSharedKey = "TestPsk"; 381 keyId = config.getKeyIdForCredentials(config); 382 } catch (IllegalStateException e) { 383 exceptionThrown = true; 384 } 385 assertTrue(exceptionThrown); 386 } 387 388 /** 389 * Verifies that getKeyIdForCredentials returns the expected string for Suggestion Enterprise 390 * networks 391 * @throws Exception 392 */ 393 @Test testGetKeyIdForCredentialsForSuggestion()394 public void testGetKeyIdForCredentialsForSuggestion() throws Exception { 395 WifiConfiguration config = new WifiConfiguration(); 396 final String mSsid = "\"TestAP\""; 397 final String packageName = "TestApp"; 398 final String bSsid = MacAddressUtils.createRandomUnicastAddress().toString(); 399 String suggestionSuffix = "_" + bSsid + "_" + packageName; 400 config.SSID = mSsid; 401 config.fromWifiNetworkSuggestion = true; 402 config.creatorName = packageName; 403 config.BSSID = bSsid; 404 405 // Test various combinations 406 // EAP with TLS 407 config.allowedKeyManagement.set(KeyMgmt.WPA_EAP); 408 config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.TLS); 409 config.enterpriseConfig.setPhase2Method(WifiEnterpriseConfig.Phase2.NONE); 410 String keyId = config.getKeyIdForCredentials(config); 411 assertEquals(keyId, mSsid + "_WPA_EAP_TLS_NULL" + suggestionSuffix); 412 413 // EAP with TTLS & MSCHAPv2 414 config.allowedKeyManagement.set(KeyMgmt.WPA_EAP); 415 config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.TTLS); 416 config.enterpriseConfig.setPhase2Method(WifiEnterpriseConfig.Phase2.MSCHAPV2); 417 keyId = config.getKeyIdForCredentials(config); 418 assertEquals(keyId, mSsid + "_WPA_EAP_TTLS_MSCHAPV2" + suggestionSuffix); 419 420 // Suite-B 192 with PWD & GTC 421 config.allowedKeyManagement.clear(); 422 config.allowedKeyManagement.set(KeyMgmt.SUITE_B_192); 423 config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.PWD); 424 config.enterpriseConfig.setPhase2Method(WifiEnterpriseConfig.Phase2.GTC); 425 keyId = config.getKeyIdForCredentials(config); 426 assertEquals(keyId, mSsid + "_SUITE_B_192_PWD_GTC" + suggestionSuffix); 427 428 // IEEE8021X with SIM 429 config.allowedKeyManagement.clear(); 430 config.allowedKeyManagement.set(KeyMgmt.IEEE8021X); 431 config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.SIM); 432 config.enterpriseConfig.setPhase2Method(WifiEnterpriseConfig.Phase2.NONE); 433 keyId = config.getKeyIdForCredentials(config); 434 assertEquals(keyId, mSsid + "_IEEE8021X_SIM_NULL" + suggestionSuffix); 435 436 // Try calling this method with non-Enterprise network, expect an exception 437 boolean exceptionThrown = false; 438 try { 439 config.allowedKeyManagement.clear(); 440 config.allowedKeyManagement.set(KeyMgmt.WPA2_PSK); 441 config.preSharedKey = "TestPsk"; 442 keyId = config.getKeyIdForCredentials(config); 443 } catch (IllegalStateException e) { 444 exceptionThrown = true; 445 } 446 assertTrue(exceptionThrown); 447 } 448 449 /** 450 * Verifies that getSsidAndSecurityTypeString returns the correct String for networks of 451 * various different security types 452 */ 453 @Test testGetSsidAndSecurityTypeString()454 public void testGetSsidAndSecurityTypeString() { 455 WifiConfiguration config = new WifiConfiguration(); 456 final String mSsid = "\"TestAp\""; 457 config.SSID = mSsid; 458 459 // Test various combinations 460 config.allowedKeyManagement.set(KeyMgmt.WPA_PSK); 461 assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.WPA_PSK], 462 config.getSsidAndSecurityTypeString()); 463 464 config.allowedKeyManagement.clear(); 465 config.allowedKeyManagement.set(KeyMgmt.WPA_EAP); 466 assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.WPA_EAP], 467 config.getSsidAndSecurityTypeString()); 468 469 config.wepKeys[0] = "TestWep"; 470 config.allowedKeyManagement.clear(); 471 assertEquals(mSsid + "WEP", config.getSsidAndSecurityTypeString()); 472 473 // set WEP key and give a valid index. 474 config.wepKeys[0] = null; 475 config.wepKeys[2] = "TestWep"; 476 config.wepTxKeyIndex = 2; 477 config.allowedKeyManagement.clear(); 478 assertEquals(mSsid + "WEP", config.getSsidAndSecurityTypeString()); 479 480 // set WEP key but does not give a valid index. 481 config.wepKeys[0] = null; 482 config.wepKeys[2] = "TestWep"; 483 config.wepTxKeyIndex = 0; 484 config.allowedKeyManagement.clear(); 485 config.allowedKeyManagement.set(KeyMgmt.OWE); 486 assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.OWE], config.getSsidAndSecurityTypeString()); 487 488 config.wepKeys[0] = null; 489 config.wepTxKeyIndex = 0; 490 config.allowedKeyManagement.clear(); 491 config.allowedKeyManagement.set(KeyMgmt.OWE); 492 assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.OWE], config.getSsidAndSecurityTypeString()); 493 494 config.allowedKeyManagement.clear(); 495 config.allowedKeyManagement.set(KeyMgmt.SAE); 496 assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.SAE], config.getSsidAndSecurityTypeString()); 497 498 config.allowedKeyManagement.clear(); 499 config.allowedKeyManagement.set(KeyMgmt.SUITE_B_192); 500 assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.SUITE_B_192], 501 config.getSsidAndSecurityTypeString()); 502 503 config.allowedKeyManagement.clear(); 504 config.allowedKeyManagement.set(KeyMgmt.NONE); 505 assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.NONE], config.getSsidAndSecurityTypeString()); 506 507 config.allowedKeyManagement.clear(); 508 config.allowedKeyManagement.set(KeyMgmt.WAPI_PSK); 509 assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.WAPI_PSK], 510 config.getSsidAndSecurityTypeString()); 511 512 config.allowedKeyManagement.clear(); 513 config.allowedKeyManagement.set(KeyMgmt.WAPI_CERT); 514 assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.WAPI_CERT], 515 config.getSsidAndSecurityTypeString()); 516 517 // WPA2 Enterprise configuration with PMF required 518 config.allowedKeyManagement.clear(); 519 config.allowedKeyManagement.set(KeyMgmt.WPA_EAP); 520 config.requirePmf = true; 521 assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.WPA_EAP], 522 config.getSsidAndSecurityTypeString()); 523 524 // WPA3 Enterprise configuration 525 config.allowedKeyManagement.clear(); 526 config.allowedKeyManagement.set(KeyMgmt.WPA_EAP); 527 config.requirePmf = true; 528 config.allowedProtocols.set(Protocol.RSN); 529 assertEquals(mSsid + "WPA3_EAP", 530 config.getSsidAndSecurityTypeString()); 531 } 532 533 /** 534 * Verifies that getNetworkKey returns the correct String for networks of 535 * various different security types, the result should be stable. 536 */ 537 @Test testGetNetworkKeyString()538 public void testGetNetworkKeyString() { 539 WifiConfiguration config = new WifiConfiguration(); 540 final String mSsid = "\"TestAp\""; 541 config.SSID = mSsid; 542 543 // Test various combinations 544 config.allowedKeyManagement.set(KeyMgmt.WPA_PSK); 545 assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.WPA_PSK], 546 config.getNetworkKey()); 547 548 config.allowedKeyManagement.clear(); 549 config.allowedKeyManagement.set(KeyMgmt.WPA_EAP); 550 assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.WPA_EAP], 551 config.getNetworkKey()); 552 553 config.wepKeys[0] = "TestWep"; 554 config.allowedKeyManagement.clear(); 555 assertEquals(mSsid + "WEP", config.getNetworkKey()); 556 557 // set WEP key and give a valid index. 558 config.wepKeys[0] = null; 559 config.wepKeys[2] = "TestWep"; 560 config.wepTxKeyIndex = 2; 561 config.allowedKeyManagement.clear(); 562 assertEquals(mSsid + "WEP", config.getNetworkKey()); 563 564 // set WEP key but does not give a valid index. 565 config.wepKeys[0] = null; 566 config.wepKeys[2] = "TestWep"; 567 config.wepTxKeyIndex = 0; 568 config.allowedKeyManagement.clear(); 569 config.allowedKeyManagement.set(KeyMgmt.OWE); 570 assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.OWE], config.getNetworkKey()); 571 572 config.wepKeys[0] = null; 573 config.wepTxKeyIndex = 0; 574 config.allowedKeyManagement.clear(); 575 config.allowedKeyManagement.set(KeyMgmt.OWE); 576 assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.OWE], config.getNetworkKey()); 577 578 config.allowedKeyManagement.clear(); 579 config.allowedKeyManagement.set(KeyMgmt.SAE); 580 assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.SAE], config.getNetworkKey()); 581 582 config.allowedKeyManagement.clear(); 583 config.allowedKeyManagement.set(KeyMgmt.SUITE_B_192); 584 assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.SUITE_B_192], 585 config.getNetworkKey()); 586 587 config.allowedKeyManagement.clear(); 588 config.allowedKeyManagement.set(KeyMgmt.NONE); 589 assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.NONE], config.getNetworkKey()); 590 591 config.allowedKeyManagement.clear(); 592 config.allowedKeyManagement.set(KeyMgmt.WAPI_PSK); 593 assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.WAPI_PSK], 594 config.getNetworkKey()); 595 596 config.allowedKeyManagement.clear(); 597 config.allowedKeyManagement.set(KeyMgmt.WAPI_CERT); 598 assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.WAPI_CERT], 599 config.getNetworkKey()); 600 601 config.allowedKeyManagement.clear(); 602 config.setPasspointUniqueId(TEST_PASSPOINT_UNIQUE_ID); 603 assertEquals(TEST_PASSPOINT_UNIQUE_ID, config.getNetworkKey()); 604 } 605 606 /** 607 * Ensure that the {@link NetworkSelectionStatus.DisableReasonInfo}s are populated in 608 * {@link NetworkSelectionStatus#DISABLE_REASON_INFOS} for reason codes from 0 to 609 * {@link NetworkSelectionStatus#NETWORK_SELECTION_DISABLED_MAX} - 1. 610 */ 611 @Test testNetworkSelectionDisableReasonInfosPopulated()612 public void testNetworkSelectionDisableReasonInfosPopulated() { 613 assertEquals(NetworkSelectionStatus.NETWORK_SELECTION_DISABLED_MAX, 614 NetworkSelectionStatus.DISABLE_REASON_INFOS.size()); 615 for (int i = 0; i < NetworkSelectionStatus.NETWORK_SELECTION_DISABLED_MAX; i++) { 616 assertNotNull(NetworkSelectionStatus.DISABLE_REASON_INFOS.get(i)); 617 } 618 } 619 620 /** 621 * Ensure that {@link NetworkSelectionStatus#getMaxNetworkSelectionDisableReason()} returns 622 * the maximum disable reason. 623 */ 624 @Test testNetworkSelectionGetMaxNetworkSelectionDisableReason()625 public void testNetworkSelectionGetMaxNetworkSelectionDisableReason() { 626 int maxReason = Integer.MIN_VALUE; 627 for (int i = 0; i < NetworkSelectionStatus.DISABLE_REASON_INFOS.size(); i++) { 628 int reason = NetworkSelectionStatus.DISABLE_REASON_INFOS.keyAt(i); 629 maxReason = Math.max(maxReason, reason); 630 } 631 assertEquals(maxReason, NetworkSelectionStatus.getMaxNetworkSelectionDisableReason()); 632 } 633 634 /** 635 * Ensure that {@link NetworkSelectionStatus#setCandidateSecurityParams(SecurityParams)} 636 * and {{@link NetworkSelectionStatus#getCandidateSecurityParams()} work 637 * as expectation. 638 */ 639 @Test testCandidateSecurityParams()640 public void testCandidateSecurityParams() { 641 NetworkSelectionStatus status = new NetworkSelectionStatus(); 642 SecurityParams params = SecurityParams.createSecurityParamsBySecurityType( 643 SECURITY_TYPE_PSK); 644 status.setCandidateSecurityParams(params); 645 assertEquals(params, status.getCandidateSecurityParams()); 646 } 647 648 /** 649 * Ensure that {@link NetworkSelectionStatus#setLastUsedSecurityParams(SecurityParams)} 650 * and {{@link NetworkSelectionStatus#getLastUsedSecurityParams()} work 651 * as expectation. 652 */ 653 @Test testLastUsedSecurityParams()654 public void testLastUsedSecurityParams() { 655 NetworkSelectionStatus status = new NetworkSelectionStatus(); 656 SecurityParams params = SecurityParams.createSecurityParamsBySecurityType( 657 SECURITY_TYPE_PSK); 658 status.setLastUsedSecurityParams(params); 659 assertEquals(params, status.getLastUsedSecurityParams()); 660 } 661 662 663 @Test testSetHttpProxyShouldNotCrashOnBadInput()664 public void testSetHttpProxyShouldNotCrashOnBadInput() { 665 ProxyInfo badHttpProxy = new ProxyInfo((ProxyInfo) null); 666 667 WifiConfiguration wifiConfiguration = new WifiConfiguration(); 668 wifiConfiguration.setHttpProxy(badHttpProxy); 669 } 670 671 /** 672 * Ensure that {@link WifiConfiguration#setSecurityParams(int)} sets up the 673 * {@link WifiConfiguration} object correctly for SAE security type. 674 * @throws Exception 675 */ 676 @Test testSetSecurityParamsForSae()677 public void testSetSecurityParamsForSae() throws Exception { 678 WifiConfiguration config = new WifiConfiguration(); 679 680 config.setSecurityParams(SECURITY_TYPE_SAE); 681 682 assertTrue(config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.SAE)); 683 assertTrue(config.allowedPairwiseCiphers.get(WifiConfiguration.PairwiseCipher.CCMP)); 684 assertTrue(config.allowedPairwiseCiphers.get(WifiConfiguration.PairwiseCipher.GCMP_256)); 685 assertTrue(config.allowedGroupCiphers.get(WifiConfiguration.GroupCipher.CCMP)); 686 assertTrue(config.allowedGroupCiphers.get(WifiConfiguration.GroupCipher.GCMP_256)); 687 assertTrue(config.requirePmf); 688 } 689 690 /** 691 * Ensure that {@link WifiConfiguration#setSecurityParams(int)} sets up the 692 * {@link WifiConfiguration} object correctly for OWE security type. 693 * @throws Exception 694 */ 695 @Test testSetSecurityParamsForOwe()696 public void testSetSecurityParamsForOwe() throws Exception { 697 WifiConfiguration config = new WifiConfiguration(); 698 699 config.setSecurityParams(SECURITY_TYPE_OWE); 700 701 assertTrue(config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.OWE)); 702 assertTrue(config.allowedPairwiseCiphers.get(WifiConfiguration.PairwiseCipher.CCMP)); 703 assertTrue(config.allowedPairwiseCiphers.get(WifiConfiguration.PairwiseCipher.GCMP_256)); 704 assertTrue(config.allowedGroupCiphers.get(WifiConfiguration.GroupCipher.CCMP)); 705 assertTrue(config.allowedGroupCiphers.get(WifiConfiguration.GroupCipher.GCMP_256)); 706 assertTrue(config.requirePmf); 707 } 708 709 /** 710 * Ensure that {@link WifiConfiguration#setSecurityParams(int)} sets up the 711 * {@link WifiConfiguration} object correctly for Suite-B security type. 712 * @throws Exception 713 */ 714 @Test testSetSecurityParamsForSuiteB()715 public void testSetSecurityParamsForSuiteB() throws Exception { 716 WifiConfiguration config = new WifiConfiguration(); 717 718 config.setSecurityParams(SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT); 719 720 assertTrue(config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.SUITE_B_192)); 721 assertTrue(config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.WPA_EAP)); 722 assertTrue(config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.IEEE8021X)); 723 assertTrue(config.allowedPairwiseCiphers.get(WifiConfiguration.PairwiseCipher.GCMP_256)); 724 assertTrue(config.allowedGroupCiphers.get(WifiConfiguration.GroupCipher.GCMP_256)); 725 assertTrue(config.allowedGroupManagementCiphers 726 .get(WifiConfiguration.GroupMgmtCipher.BIP_GMAC_256)); 727 assertTrue(config.requirePmf); 728 } 729 730 /** 731 * Ensure that {@link WifiConfiguration#setSecurityParams(int)} sets up the 732 * {@link WifiConfiguration} object correctly for WPA3 Enterprise security type. 733 * @throws Exception 734 */ 735 @Test testSetSecurityParamsForWpa3Enterprise()736 public void testSetSecurityParamsForWpa3Enterprise() throws Exception { 737 WifiConfiguration config = new WifiConfiguration(); 738 739 config.setSecurityParams(SECURITY_TYPE_EAP_WPA3_ENTERPRISE); 740 741 assertTrue(config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.WPA_EAP)); 742 assertTrue(config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.IEEE8021X)); 743 assertTrue(config.allowedPairwiseCiphers.get(WifiConfiguration.PairwiseCipher.CCMP)); 744 assertTrue(config.allowedPairwiseCiphers.get(WifiConfiguration.PairwiseCipher.GCMP_256)); 745 assertTrue(config.allowedGroupCiphers.get(WifiConfiguration.GroupCipher.CCMP)); 746 assertTrue(config.allowedGroupCiphers.get(WifiConfiguration.GroupCipher.GCMP_256)); 747 assertTrue(config.requirePmf); 748 } 749 750 /** 751 * Test that the NetworkSelectionStatus Builder returns the same values that was set, and that 752 * calling build multiple times returns different instances. 753 */ 754 @Test testNetworkSelectionStatusBuilder()755 public void testNetworkSelectionStatusBuilder() throws Exception { 756 NetworkSelectionStatus.Builder builder = new NetworkSelectionStatus.Builder() 757 .setNetworkSelectionDisableReason( 758 NetworkSelectionStatus.DISABLED_ASSOCIATION_REJECTION) 759 .setNetworkSelectionStatus( 760 NetworkSelectionStatus.NETWORK_SELECTION_PERMANENTLY_DISABLED); 761 762 NetworkSelectionStatus status1 = builder.build(); 763 764 assertEquals(NetworkSelectionStatus.DISABLED_ASSOCIATION_REJECTION, 765 status1.getNetworkSelectionDisableReason()); 766 assertEquals(NetworkSelectionStatus.NETWORK_SELECTION_PERMANENTLY_DISABLED, 767 status1.getNetworkSelectionStatus()); 768 769 NetworkSelectionStatus status2 = builder 770 .setNetworkSelectionDisableReason(NetworkSelectionStatus.DISABLED_BY_WRONG_PASSWORD) 771 .build(); 772 773 // different instances 774 assertNotSame(status1, status2); 775 776 // assert that status1 didn't change 777 assertEquals(NetworkSelectionStatus.DISABLED_ASSOCIATION_REJECTION, 778 status1.getNetworkSelectionDisableReason()); 779 assertEquals(NetworkSelectionStatus.NETWORK_SELECTION_PERMANENTLY_DISABLED, 780 status1.getNetworkSelectionStatus()); 781 782 // assert that status2 changed 783 assertEquals(NetworkSelectionStatus.DISABLED_BY_WRONG_PASSWORD, 784 status2.getNetworkSelectionDisableReason()); 785 assertEquals(NetworkSelectionStatus.NETWORK_SELECTION_PERMANENTLY_DISABLED, 786 status2.getNetworkSelectionStatus()); 787 } 788 789 @Test testNeedsPreSharedKey()790 public void testNeedsPreSharedKey() throws Exception { 791 WifiConfiguration configuration = new WifiConfiguration(); 792 793 configuration.setSecurityParams(SECURITY_TYPE_PSK); 794 assertTrue(configuration.needsPreSharedKey()); 795 796 configuration.setSecurityParams(SECURITY_TYPE_SAE); 797 assertTrue(configuration.needsPreSharedKey()); 798 799 configuration.setSecurityParams(SECURITY_TYPE_WAPI_PSK); 800 assertTrue(configuration.needsPreSharedKey()); 801 802 configuration.setSecurityParams(SECURITY_TYPE_OPEN); 803 assertFalse(configuration.needsPreSharedKey()); 804 805 configuration.setSecurityParams(SECURITY_TYPE_OWE); 806 assertFalse(configuration.needsPreSharedKey()); 807 808 configuration.setSecurityParams(SECURITY_TYPE_EAP); 809 assertFalse(configuration.needsPreSharedKey()); 810 811 configuration.setSecurityParams(SECURITY_TYPE_EAP_WPA3_ENTERPRISE); 812 assertFalse(configuration.needsPreSharedKey()); 813 814 configuration.setSecurityParams(SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT); 815 assertFalse(configuration.needsPreSharedKey()); 816 } 817 818 @Test testGetAuthType()819 public void testGetAuthType() throws Exception { 820 WifiConfiguration configuration = new WifiConfiguration(); 821 822 configuration.setSecurityParams(SECURITY_TYPE_PSK); 823 assertEquals(KeyMgmt.WPA_PSK, configuration.getAuthType()); 824 825 configuration.setSecurityParams(SECURITY_TYPE_SAE); 826 assertEquals(KeyMgmt.SAE, configuration.getAuthType()); 827 828 configuration.setSecurityParams(SECURITY_TYPE_WAPI_PSK); 829 assertEquals(KeyMgmt.WAPI_PSK, configuration.getAuthType()); 830 831 configuration.setSecurityParams(SECURITY_TYPE_OPEN); 832 assertEquals(KeyMgmt.NONE, configuration.getAuthType()); 833 834 configuration.setSecurityParams(SECURITY_TYPE_OWE); 835 assertEquals(KeyMgmt.OWE, configuration.getAuthType()); 836 837 configuration.setSecurityParams(SECURITY_TYPE_EAP); 838 assertEquals(KeyMgmt.WPA_EAP, configuration.getAuthType()); 839 840 configuration.setSecurityParams(SECURITY_TYPE_EAP_WPA3_ENTERPRISE); 841 assertEquals(KeyMgmt.WPA_EAP, configuration.getAuthType()); 842 843 configuration.setSecurityParams(SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT); 844 assertEquals(KeyMgmt.SUITE_B_192, configuration.getAuthType()); 845 846 configuration.setSecurityParams(SECURITY_TYPE_WAPI_CERT); 847 assertEquals(KeyMgmt.WAPI_CERT, configuration.getAuthType()); 848 } 849 850 @Test (expected = IllegalStateException.class) testGetAuthTypeFailure1()851 public void testGetAuthTypeFailure1() throws Exception { 852 WifiConfiguration configuration = new WifiConfiguration(); 853 854 configuration.setSecurityParams(SECURITY_TYPE_PSK); 855 configuration.allowedKeyManagement.set(KeyMgmt.IEEE8021X); 856 configuration.getAuthType(); 857 } 858 859 @Test (expected = IllegalStateException.class) testGetAuthTypeFailure2()860 public void testGetAuthTypeFailure2() throws Exception { 861 WifiConfiguration configuration = new WifiConfiguration(); 862 863 configuration.allowedKeyManagement.set(KeyMgmt.IEEE8021X); 864 configuration.allowedKeyManagement.set(KeyMgmt.WPA_EAP); 865 configuration.allowedKeyManagement.set(KeyMgmt.SAE); 866 configuration.getAuthType(); 867 } 868 869 /** 870 * Verifies that getProfileKey returns the correct String for networks of 871 * various different security types, the result should be stable. 872 */ 873 @Test testGetProfileKeyString()874 public void testGetProfileKeyString() { 875 assumeTrue(SdkLevel.isAtLeastS()); 876 WifiConfiguration config = new WifiConfiguration(); 877 final String mSsid = "\"TestAp\""; 878 config.SSID = mSsid; 879 config.carrierId = TEST_CARRIER_ID; 880 config.subscriptionId = TEST_SUB_ID; 881 config.creatorName = TEST_PACKAGE_NAME; 882 883 884 // Test various combinations 885 config.allowedKeyManagement.set(KeyMgmt.WPA_PSK); 886 config.fromWifiNetworkSuggestion = false; 887 assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.WPA_PSK], TEST_PACKAGE_NAME, 888 TEST_CARRIER_ID, TEST_SUB_ID, false), config.getProfileKey()); 889 // Hexadecimal SSIDs should match regardless of upper/lower case. 890 config.SSID = "aBcDeF"; 891 assertEquals(createProfileKey("abcdef", KeyMgmt.strings[KeyMgmt.WPA_PSK], TEST_PACKAGE_NAME, 892 TEST_CARRIER_ID, TEST_SUB_ID, false), config.getProfileKey()); 893 config.SSID = mSsid; 894 config.fromWifiNetworkSuggestion = true; 895 assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.WPA_PSK], TEST_PACKAGE_NAME, 896 TEST_CARRIER_ID, TEST_SUB_ID, true), config.getProfileKey()); 897 898 config.allowedKeyManagement.clear(); 899 config.allowedKeyManagement.set(KeyMgmt.WPA_EAP); 900 config.fromWifiNetworkSuggestion = false; 901 assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.WPA_EAP], TEST_PACKAGE_NAME, 902 TEST_CARRIER_ID, TEST_SUB_ID, false), config.getProfileKey()); 903 config.fromWifiNetworkSuggestion = true; 904 assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.WPA_EAP], TEST_PACKAGE_NAME, 905 TEST_CARRIER_ID, TEST_SUB_ID, true), config.getProfileKey()); 906 907 config.wepKeys[0] = "TestWep"; 908 config.allowedKeyManagement.clear(); 909 config.fromWifiNetworkSuggestion = false; 910 assertEquals(createProfileKey(mSsid, "WEP", TEST_PACKAGE_NAME, 911 TEST_CARRIER_ID, TEST_SUB_ID, false), config.getProfileKey()); 912 config.fromWifiNetworkSuggestion = true; 913 assertEquals(createProfileKey(mSsid, "WEP", TEST_PACKAGE_NAME, 914 TEST_CARRIER_ID, TEST_SUB_ID, true), config.getProfileKey()); 915 916 // set WEP key and give a valid index. 917 config.wepKeys[0] = null; 918 config.wepKeys[2] = "TestWep"; 919 config.wepTxKeyIndex = 2; 920 config.allowedKeyManagement.clear(); 921 config.fromWifiNetworkSuggestion = false; 922 assertEquals(createProfileKey(mSsid, "WEP", TEST_PACKAGE_NAME, 923 TEST_CARRIER_ID, TEST_SUB_ID, false), config.getProfileKey()); 924 config.fromWifiNetworkSuggestion = true; 925 assertEquals(createProfileKey(mSsid, "WEP", TEST_PACKAGE_NAME, 926 TEST_CARRIER_ID, TEST_SUB_ID, true), config.getProfileKey()); 927 928 // set WEP key but does not give a valid index. 929 config.wepKeys[0] = null; 930 config.wepKeys[2] = "TestWep"; 931 config.wepTxKeyIndex = 0; 932 config.allowedKeyManagement.clear(); 933 config.allowedKeyManagement.set(KeyMgmt.OWE); 934 config.fromWifiNetworkSuggestion = false; 935 assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.OWE], TEST_PACKAGE_NAME, 936 TEST_CARRIER_ID, TEST_SUB_ID, false), config.getProfileKey()); 937 config.fromWifiNetworkSuggestion = true; 938 assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.OWE], TEST_PACKAGE_NAME, 939 TEST_CARRIER_ID, TEST_SUB_ID, true), config.getProfileKey()); 940 941 config.wepKeys[0] = null; 942 config.wepTxKeyIndex = 0; 943 config.allowedKeyManagement.clear(); 944 config.allowedKeyManagement.set(KeyMgmt.OWE); 945 config.fromWifiNetworkSuggestion = false; 946 assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.OWE], TEST_PACKAGE_NAME, 947 TEST_CARRIER_ID, TEST_SUB_ID, false), config.getProfileKey()); 948 config.fromWifiNetworkSuggestion = true; 949 assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.OWE], TEST_PACKAGE_NAME, 950 TEST_CARRIER_ID, TEST_SUB_ID, true), config.getProfileKey()); 951 952 config.allowedKeyManagement.clear(); 953 config.allowedKeyManagement.set(KeyMgmt.SAE); 954 config.fromWifiNetworkSuggestion = false; 955 assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.SAE], TEST_PACKAGE_NAME, 956 TEST_CARRIER_ID, TEST_SUB_ID, false), config.getProfileKey()); 957 config.fromWifiNetworkSuggestion = true; 958 assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.SAE], TEST_PACKAGE_NAME, 959 TEST_CARRIER_ID, TEST_SUB_ID, true), config.getProfileKey()); 960 961 config.allowedKeyManagement.clear(); 962 config.allowedKeyManagement.set(KeyMgmt.SUITE_B_192); 963 config.fromWifiNetworkSuggestion = false; 964 assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.SUITE_B_192], 965 TEST_PACKAGE_NAME, TEST_CARRIER_ID, TEST_SUB_ID, false), config.getProfileKey()); 966 config.fromWifiNetworkSuggestion = true; 967 assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.SUITE_B_192], 968 TEST_PACKAGE_NAME, TEST_CARRIER_ID, TEST_SUB_ID, true), config.getProfileKey()); 969 970 config.allowedKeyManagement.clear(); 971 config.allowedKeyManagement.set(KeyMgmt.NONE); 972 config.fromWifiNetworkSuggestion = false; 973 assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.NONE], TEST_PACKAGE_NAME, 974 TEST_CARRIER_ID, TEST_SUB_ID, false), config.getProfileKey()); 975 config.fromWifiNetworkSuggestion = true; 976 assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.NONE], TEST_PACKAGE_NAME, 977 TEST_CARRIER_ID, TEST_SUB_ID, true), config.getProfileKey()); 978 979 config.allowedKeyManagement.clear(); 980 config.allowedKeyManagement.set(KeyMgmt.WAPI_PSK); 981 config.fromWifiNetworkSuggestion = false; 982 assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.WAPI_PSK], TEST_PACKAGE_NAME, 983 TEST_CARRIER_ID, TEST_SUB_ID, false), config.getProfileKey()); 984 config.fromWifiNetworkSuggestion = true; 985 assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.WAPI_PSK], TEST_PACKAGE_NAME, 986 TEST_CARRIER_ID, TEST_SUB_ID, true), config.getProfileKey()); 987 988 config.allowedKeyManagement.clear(); 989 config.allowedKeyManagement.set(KeyMgmt.WAPI_CERT); 990 config.fromWifiNetworkSuggestion = false; 991 assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.WAPI_CERT], TEST_PACKAGE_NAME, 992 TEST_CARRIER_ID, TEST_SUB_ID, false), config.getProfileKey()); 993 config.fromWifiNetworkSuggestion = true; 994 assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.WAPI_CERT], TEST_PACKAGE_NAME, 995 TEST_CARRIER_ID, TEST_SUB_ID, true), config.getProfileKey()); 996 997 config.allowedKeyManagement.clear(); 998 config.setPasspointUniqueId(TEST_PASSPOINT_UNIQUE_ID); 999 assertEquals(TEST_PASSPOINT_UNIQUE_ID, config.getProfileKey()); 1000 } 1001 1002 @Test testGetProfileKeyOnR()1003 public void testGetProfileKeyOnR() { 1004 assumeFalse(SdkLevel.isAtLeastS()); 1005 WifiConfiguration config = new WifiConfiguration(); 1006 final String mSsid = "\"TestAp\""; 1007 config.SSID = mSsid; 1008 config.carrierId = TEST_CARRIER_ID; 1009 config.subscriptionId = TEST_SUB_ID; 1010 config.creatorName = TEST_PACKAGE_NAME; 1011 1012 assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.NONE] , config.getProfileKey()); 1013 } 1014 createProfileKey(String ssid, String keyMgmt, String providerName, int carrierId, int subId, boolean isFromSuggestion)1015 private String createProfileKey(String ssid, String keyMgmt, String providerName, 1016 int carrierId, int subId, boolean isFromSuggestion) { 1017 StringBuilder sb = new StringBuilder(); 1018 sb.append(ssid).append(keyMgmt); 1019 if (isFromSuggestion) { 1020 sb.append("_").append(providerName).append('-') 1021 .append(carrierId).append('-').append(subId); 1022 } 1023 return sb.toString(); 1024 } 1025 verifyAllowedKeyManagement(WifiConfiguration config, int[] akms)1026 private void verifyAllowedKeyManagement(WifiConfiguration config, int[] akms) { 1027 for (int akm: akms) { 1028 assertTrue(config.getSecurityParamsList().stream() 1029 .anyMatch(params -> params.getAllowedKeyManagement().get(akm))); 1030 } 1031 } 1032 verifyAllowedProtocols(WifiConfiguration config, int[] aps)1033 private void verifyAllowedProtocols(WifiConfiguration config, int[] aps) { 1034 for (int ap: aps) { 1035 assertTrue(config.getSecurityParamsList().stream() 1036 .anyMatch(params -> params.getAllowedProtocols().get(ap))); 1037 } 1038 } 1039 verifyAllowedPairwiseCiphers(WifiConfiguration config, int[] apcs)1040 private void verifyAllowedPairwiseCiphers(WifiConfiguration config, int[] apcs) { 1041 for (int apc: apcs) { 1042 assertTrue(config.getSecurityParamsList().stream() 1043 .anyMatch(params -> params.getAllowedPairwiseCiphers().get(apc))); 1044 } 1045 } 1046 verifyAllowedGroupCiphers(WifiConfiguration config, int[] agcs)1047 private void verifyAllowedGroupCiphers(WifiConfiguration config, int[] agcs) { 1048 for (int agc: agcs) { 1049 assertTrue(config.getSecurityParamsList().stream() 1050 .anyMatch(params -> params.getAllowedGroupCiphers().get(agc))); 1051 } 1052 } 1053 createNetworkKey(String ssid, String keyMgmt, String providerName, int carrierId, int subId, boolean isFromSuggestion)1054 private String createNetworkKey(String ssid, String keyMgmt, String providerName, 1055 int carrierId, int subId, boolean isFromSuggestion) { 1056 StringBuilder sb = new StringBuilder(); 1057 sb.append(ssid).append(keyMgmt); 1058 if (isFromSuggestion) { 1059 sb.append("_").append(providerName).append('-') 1060 .append(carrierId).append('-').append(subId); 1061 } 1062 return sb.toString(); 1063 } 1064 1065 /** Verify that adding security types works as expected. */ 1066 @Test testAddSecurityTypes()1067 public void testAddSecurityTypes() { 1068 WifiConfiguration config = new WifiConfiguration(); 1069 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 1070 config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_SAE); 1071 config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_WAPI_PSK); 1072 List<SecurityParams> paramsList = config.getSecurityParamsList(); 1073 assertEquals(3, paramsList.size()); 1074 1075 verifyAllowedKeyManagement(config, new int[] { 1076 KeyMgmt.WPA_PSK, KeyMgmt.SAE, KeyMgmt.WAPI_PSK}); 1077 verifyAllowedProtocols(config, new int[] {Protocol.WPA, Protocol.RSN, Protocol.WAPI}); 1078 verifyAllowedPairwiseCiphers(config, new int[] { 1079 PairwiseCipher.CCMP, PairwiseCipher.TKIP, 1080 PairwiseCipher.GCMP_128, PairwiseCipher.GCMP_256, 1081 PairwiseCipher.SMS4}); 1082 verifyAllowedGroupCiphers(config, new int[] { 1083 GroupCipher.CCMP, GroupCipher.TKIP, 1084 GroupCipher.GCMP_128, GroupCipher.GCMP_256, 1085 GroupCipher.SMS4}); 1086 } 1087 1088 /** Check that a personal security type can be added to a personal configuration. */ 1089 @Test testAddPersonalTypeToPersonalConfiguration()1090 public void testAddPersonalTypeToPersonalConfiguration() { 1091 WifiConfiguration config = new WifiConfiguration(); 1092 config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 1093 config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_SAE); 1094 } 1095 1096 /** Check that an enterprise security type can be added to an enterprise configuration. */ 1097 @Test testAddEnterpriseTypeToEnterpriseConfiguration()1098 public void testAddEnterpriseTypeToEnterpriseConfiguration() { 1099 WifiConfiguration config = new WifiConfiguration(); 1100 config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP); 1101 config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.SIM); 1102 config.enterpriseConfig.setPhase2Method(WifiEnterpriseConfig.Phase2.NONE); 1103 config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE); 1104 } 1105 1106 /** Verify that adding an enterprise type to a personal configuration. */ 1107 @Test (expected = IllegalArgumentException.class) testAddEnterpriseTypeToPersonalConfig()1108 public void testAddEnterpriseTypeToPersonalConfig() { 1109 WifiConfiguration config = new WifiConfiguration(); 1110 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 1111 config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP); 1112 } 1113 1114 /** Verify that adding a personal type to an enterprise configuration. */ 1115 @Test (expected = IllegalArgumentException.class) testAddPersonalTypeToEnterpriseConfig()1116 public void testAddPersonalTypeToEnterpriseConfig() { 1117 WifiConfiguration config = new WifiConfiguration(); 1118 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP); 1119 config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.SIM); 1120 config.enterpriseConfig.setPhase2Method(WifiEnterpriseConfig.Phase2.NONE); 1121 config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 1122 } 1123 1124 /** Check that an open security cannot be added to a non-open configuration. */ 1125 @Test(expected = IllegalArgumentException.class) testAddOpenTypeToNonOpenConfiguration()1126 public void testAddOpenTypeToNonOpenConfiguration() { 1127 WifiConfiguration config = new WifiConfiguration(); 1128 config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 1129 config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_OPEN); 1130 } 1131 1132 /** Check that a non-open security cannot be added to an open configuration. */ 1133 @Test(expected = IllegalArgumentException.class) testAddNonOpenTypeToOpenConfiguration()1134 public void testAddNonOpenTypeToOpenConfiguration() { 1135 WifiConfiguration config = new WifiConfiguration(); 1136 config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_OPEN); 1137 config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 1138 } 1139 1140 /** Check that a OSEN security cannot be added as additional type. */ 1141 @Test(expected = IllegalArgumentException.class) testAddOsenTypeToConfiguration()1142 public void testAddOsenTypeToConfiguration() { 1143 WifiConfiguration config = new WifiConfiguration(); 1144 config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 1145 config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_OSEN); 1146 } 1147 1148 /** Verify that adding duplicate security types raises the exception. */ 1149 @Test (expected = IllegalArgumentException.class) testAddDuplicateSecurityTypes()1150 public void testAddDuplicateSecurityTypes() { 1151 WifiConfiguration config = new WifiConfiguration(); 1152 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 1153 config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 1154 } 1155 1156 /** Verify that adding duplicate security params raises the exception. */ 1157 @Test (expected = IllegalArgumentException.class) testAddDuplicateSecurityParams()1158 public void testAddDuplicateSecurityParams() { 1159 WifiConfiguration config = new WifiConfiguration(); 1160 config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 1161 config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 1162 } 1163 1164 /** Verify that Suite-B type works as expected. */ 1165 @Test testAddSuiteBSecurityType()1166 public void testAddSuiteBSecurityType() { 1167 WifiConfiguration config = new WifiConfiguration(); 1168 config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE); 1169 config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.SIM); 1170 config.enterpriseConfig.setPhase2Method(WifiEnterpriseConfig.Phase2.NONE); 1171 config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT); 1172 1173 assertFalse(config.isSuiteBCipherEcdheRsaEnabled()); 1174 config.enableSuiteBCiphers(false, true); 1175 assertTrue(config.isSuiteBCipherEcdheRsaEnabled()); 1176 } 1177 1178 /** Verify that FILS bit can be set correctly. */ 1179 @Test testFilsKeyMgmt()1180 public void testFilsKeyMgmt() { 1181 WifiConfiguration config = new WifiConfiguration(); 1182 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 1183 config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_SAE); 1184 1185 config.enableFils(false, true); 1186 assertFalse(config.isFilsSha256Enabled()); 1187 assertTrue(config.isFilsSha384Enabled()); 1188 } 1189 1190 /** Verify that SAE mode can be configured correctly. */ 1191 @Test testSaeTypeMethods()1192 public void testSaeTypeMethods() { 1193 WifiConfiguration config = new WifiConfiguration(); 1194 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); 1195 config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_SAE); 1196 1197 SecurityParams saeParams = config.getSecurityParams(WifiConfiguration.SECURITY_TYPE_SAE); 1198 assertNotNull(saeParams); 1199 assertFalse(saeParams.isSaeH2eOnlyMode()); 1200 assertFalse(saeParams.isSaePkOnlyMode()); 1201 1202 config.enableSaeH2eOnlyMode(true); 1203 config.enableSaePkOnlyMode(true); 1204 1205 saeParams = config.getSecurityParams(WifiConfiguration.SECURITY_TYPE_SAE); 1206 assertNotNull(saeParams); 1207 assertTrue(saeParams.isSaeH2eOnlyMode()); 1208 assertTrue(saeParams.isSaePkOnlyMode()); 1209 } 1210 1211 /** Verify the legacy configuration conversion */ 1212 @Test testLegacyConfigurationConversion()1213 public void testLegacyConfigurationConversion() { 1214 Pair[] keyMgmtSecurityTypePairs = new Pair[] { 1215 new Pair<>(KeyMgmt.NONE, SECURITY_TYPE_OPEN), 1216 new Pair<>(KeyMgmt.OWE, SECURITY_TYPE_OWE), 1217 new Pair<>(KeyMgmt.OSEN, SECURITY_TYPE_OSEN), 1218 new Pair<>(KeyMgmt.WPA_PSK, SECURITY_TYPE_PSK), 1219 new Pair<>(KeyMgmt.WPA2_PSK, SECURITY_TYPE_PSK), 1220 new Pair<>(KeyMgmt.FT_PSK, SECURITY_TYPE_PSK), 1221 new Pair<>(KeyMgmt.WPA_PSK_SHA256, SECURITY_TYPE_PSK), 1222 new Pair<>(KeyMgmt.SAE, SECURITY_TYPE_SAE), 1223 new Pair<>(KeyMgmt.WPA_EAP, SECURITY_TYPE_EAP), 1224 new Pair<>(KeyMgmt.FT_EAP, SECURITY_TYPE_EAP), 1225 new Pair<>(KeyMgmt.IEEE8021X, SECURITY_TYPE_EAP), 1226 new Pair<>(KeyMgmt.WPA_EAP_SHA256, SECURITY_TYPE_EAP), 1227 new Pair<>(KeyMgmt.FILS_SHA256, SECURITY_TYPE_EAP), 1228 new Pair<>(KeyMgmt.FILS_SHA384, SECURITY_TYPE_EAP), 1229 new Pair<>(KeyMgmt.SUITE_B_192, SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT), 1230 new Pair<>(KeyMgmt.WAPI_CERT, SECURITY_TYPE_WAPI_CERT), 1231 new Pair<>(KeyMgmt.WAPI_PSK, SECURITY_TYPE_WAPI_PSK), 1232 new Pair<>(KeyMgmt.DPP, SECURITY_TYPE_DPP), 1233 }; 1234 1235 for (Pair pair: keyMgmtSecurityTypePairs) { 1236 WifiConfiguration config = new WifiConfiguration(); 1237 config.allowedKeyManagement.set((int) pair.first); 1238 config.convertLegacyFieldsToSecurityParamsIfNeeded(); 1239 assertNotNull(config.getSecurityParams((int) pair.second)); 1240 } 1241 1242 // If none of key management is set, it should be open. 1243 WifiConfiguration emptyConfig = new WifiConfiguration(); 1244 emptyConfig.convertLegacyFieldsToSecurityParamsIfNeeded(); 1245 assertNotNull(emptyConfig.getSecurityParams(SECURITY_TYPE_OPEN)); 1246 1247 // If EAP key management is set and requirePmf is true, it is WPA3 Enterprise. 1248 WifiConfiguration wpa3EnterpriseConfig = new WifiConfiguration(); 1249 wpa3EnterpriseConfig.allowedKeyManagement.set(KeyMgmt.WPA_EAP_SHA256); 1250 wpa3EnterpriseConfig.requirePmf = true; 1251 wpa3EnterpriseConfig.allowedProtocols.set(Protocol.RSN); 1252 wpa3EnterpriseConfig.convertLegacyFieldsToSecurityParamsIfNeeded(); 1253 assertNotNull(wpa3EnterpriseConfig.getSecurityParams(SECURITY_TYPE_EAP_WPA3_ENTERPRISE)); 1254 1255 // If key management is NONE and wep key is set, it is WEP type. 1256 WifiConfiguration wepConfig = new WifiConfiguration(); 1257 wepConfig.allowedKeyManagement.set(KeyMgmt.NONE); 1258 wepConfig.wepKeys = new String[] {"\"abcdef\""}; 1259 wepConfig.convertLegacyFieldsToSecurityParamsIfNeeded(); 1260 assertNotNull(wepConfig.getSecurityParams(SECURITY_TYPE_WEP)); 1261 } 1262 1263 /** Verify the set security params by SecurityParams objects. */ 1264 @Test testSetBySecurityParamsObject()1265 public void testSetBySecurityParamsObject() { 1266 int[] securityTypes = new int[] { 1267 SECURITY_TYPE_WAPI_CERT, 1268 SECURITY_TYPE_WAPI_PSK, 1269 SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT, 1270 SECURITY_TYPE_OWE, 1271 SECURITY_TYPE_SAE, 1272 SECURITY_TYPE_OSEN, 1273 SECURITY_TYPE_EAP, 1274 SECURITY_TYPE_PSK, 1275 SECURITY_TYPE_OPEN, 1276 SECURITY_TYPE_PASSPOINT_R1_R2, 1277 SECURITY_TYPE_PASSPOINT_R3, 1278 }; 1279 for (int type: securityTypes) { 1280 WifiConfiguration config = new WifiConfiguration(); 1281 config.setSecurityParams(type); 1282 assertTrue(config.isSecurityType(type)); 1283 assertNotNull(config.getSecurityParams(type)); 1284 } 1285 } 1286 1287 /** Verify the set security params by an allowed key management mask. */ 1288 @Test testSetSecurityParamsByAllowedKeyManagement()1289 public void testSetSecurityParamsByAllowedKeyManagement() { 1290 Pair[] keyMgmtSecurityTypePairs = new Pair[] { 1291 new Pair<>(KeyMgmt.WAPI_CERT, SECURITY_TYPE_WAPI_CERT), 1292 new Pair<>(KeyMgmt.WAPI_PSK, SECURITY_TYPE_WAPI_PSK), 1293 new Pair<>(KeyMgmt.SUITE_B_192, SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT), 1294 new Pair<>(KeyMgmt.OWE, SECURITY_TYPE_OWE), 1295 new Pair<>(KeyMgmt.SAE, SECURITY_TYPE_SAE), 1296 new Pair<>(KeyMgmt.OSEN, SECURITY_TYPE_OSEN), 1297 new Pair<>(KeyMgmt.WPA2_PSK, SECURITY_TYPE_PSK), 1298 new Pair<>(KeyMgmt.WPA_EAP, SECURITY_TYPE_EAP), 1299 new Pair<>(KeyMgmt.WPA_PSK, SECURITY_TYPE_PSK), 1300 new Pair<>(KeyMgmt.NONE, SECURITY_TYPE_OPEN), 1301 }; 1302 1303 for (Pair pair: keyMgmtSecurityTypePairs) { 1304 BitSet akm = new BitSet(); 1305 akm.set((int) pair.first); 1306 WifiConfiguration config = new WifiConfiguration(); 1307 config.setSecurityParams(akm); 1308 assertNotNull(config.getSecurityParams((int) pair.second)); 1309 } 1310 } 1311 1312 /** Verify the set security params by an invalid allowed key management mask. */ 1313 @Test (expected = IllegalArgumentException.class) testSetSecurityParamsByInvalidAllowedKeyManagement()1314 public void testSetSecurityParamsByInvalidAllowedKeyManagement() { 1315 WifiConfiguration config = new WifiConfiguration(); 1316 BitSet akm = null; 1317 config.setSecurityParams(akm); 1318 } 1319 1320 /** Verify the set security params by a security params list. */ 1321 @Test testSetSecurityParamsBySecurityParamsList()1322 public void testSetSecurityParamsBySecurityParamsList() { 1323 WifiConfiguration config = new WifiConfiguration(); 1324 config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.SIM); 1325 config.enterpriseConfig.setPhase2Method(WifiEnterpriseConfig.Phase2.NONE); 1326 config.addSecurityParams(SECURITY_TYPE_EAP); 1327 config.addSecurityParams(SECURITY_TYPE_EAP_WPA3_ENTERPRISE); 1328 assertTrue(config.isSecurityType(SECURITY_TYPE_EAP)); 1329 assertTrue(config.isSecurityType(SECURITY_TYPE_EAP_WPA3_ENTERPRISE)); 1330 assertFalse(config.isSecurityType(SECURITY_TYPE_PSK)); 1331 assertFalse(config.isSecurityType(SECURITY_TYPE_SAE)); 1332 1333 List<SecurityParams> list = new ArrayList<>(); 1334 list.add(SecurityParams.createSecurityParamsBySecurityType(SECURITY_TYPE_PSK)); 1335 list.add(SecurityParams.createSecurityParamsBySecurityType(SECURITY_TYPE_SAE)); 1336 config.setSecurityParams(list); 1337 assertFalse(config.isSecurityType(SECURITY_TYPE_EAP)); 1338 assertFalse(config.isSecurityType(SECURITY_TYPE_EAP_WPA3_ENTERPRISE)); 1339 assertTrue(config.isSecurityType(SECURITY_TYPE_PSK)); 1340 assertTrue(config.isSecurityType(SECURITY_TYPE_SAE)); 1341 } 1342 1343 /** Verify the set security params by an empty security params list. */ 1344 @Test (expected = IllegalArgumentException.class) testSetSecurityParamsByEmptySecurityParamsList()1345 public void testSetSecurityParamsByEmptySecurityParamsList() { 1346 WifiConfiguration config = new WifiConfiguration(); 1347 List<SecurityParams> list = new ArrayList<>(); 1348 config.setSecurityParams(list); 1349 } 1350 1351 /** Verify the set security params by a null security params list. */ 1352 @Test (expected = IllegalArgumentException.class) testSetSecurityParamsByNullSecurityParamsList()1353 public void testSetSecurityParamsByNullSecurityParamsList() { 1354 WifiConfiguration config = new WifiConfiguration(); 1355 List<SecurityParams> list = null; 1356 config.setSecurityParams(list); 1357 } 1358 1359 /** 1360 * Verifies that getNetworkKeyFromSecurityType returns the correct String 1361 * for networks of various different security types, the result should be stable. 1362 * 1363 * Note: DO NOT update the test if it happens failure! Fixed it is necessary, otherwise 1364 * we will break Wi-Fi data usage functionality. 1365 */ 1366 @Test testGetNetworkKeyFromSecurityTypeString()1367 public void testGetNetworkKeyFromSecurityTypeString() { 1368 WifiConfiguration config = new WifiConfiguration(); 1369 final String mSsid = "\"TestAp\""; 1370 config.SSID = mSsid; 1371 config.carrierId = TEST_CARRIER_ID; 1372 config.subscriptionId = TEST_SUB_ID; 1373 config.creatorName = TEST_PACKAGE_NAME; 1374 1375 for (int securityType : SECURITY_TYPES_EXCEPT_PASSPOINT) { 1376 assertEquals(createNetworkKey(mSsid, getSecurityTypeName(securityType), 1377 TEST_PACKAGE_NAME, TEST_CARRIER_ID, TEST_SUB_ID, false), 1378 config.getNetworkKeyFromSecurityType(securityType)); 1379 } 1380 1381 // Test for passpoint configuration. 1382 config.setPasspointUniqueId(TEST_PASSPOINT_UNIQUE_ID); 1383 assertEquals(TEST_SUB_ID + "-" + TEST_PASSPOINT_UNIQUE_ID, 1384 config.getNetworkKeyFromSecurityType(SECURITY_TYPE_PASSPOINT_R1_R2)); 1385 } 1386 1387 /** 1388 * Verifies that getAllNetworkKeys returns the correct String set 1389 * for networks of various different security types, the result should be stable. 1390 * 1391 * Note: DO NOT update the test if it happens failure! Fixed it is necessary, otherwise 1392 * we will break Wi-Fi data usage functionality. 1393 */ 1394 @Test testGetAllPersistableNetworkKeysString()1395 public void testGetAllPersistableNetworkKeysString() { 1396 WifiConfiguration config = new WifiConfiguration(); 1397 final String mSsid = "\"TestAp\""; 1398 config.SSID = mSsid; 1399 config.carrierId = TEST_CARRIER_ID; 1400 config.subscriptionId = TEST_SUB_ID; 1401 config.creatorName = TEST_PACKAGE_NAME; 1402 for (int securityType : SECURITY_TYPES_EXCEPT_PASSPOINT) { 1403 config.setSecurityParams(securityType); 1404 assertTrue(config.getAllNetworkKeys().contains( 1405 createNetworkKey(mSsid, getSecurityTypeName(securityType), 1406 TEST_PACKAGE_NAME, TEST_CARRIER_ID, TEST_SUB_ID, false))); 1407 } 1408 1409 // Test with multi-security types 1410 config.setSecurityParams(SECURITY_TYPE_PSK); 1411 config.addSecurityParams(SECURITY_TYPE_SAE); 1412 assertTrue(config.getAllNetworkKeys().contains( 1413 createNetworkKey(mSsid, getSecurityTypeName(SECURITY_TYPE_PSK), 1414 TEST_PACKAGE_NAME, TEST_CARRIER_ID, TEST_SUB_ID, false))); 1415 assertTrue(config.getAllNetworkKeys().contains( 1416 createNetworkKey(mSsid, getSecurityTypeName(SECURITY_TYPE_SAE), 1417 TEST_PACKAGE_NAME, TEST_CARRIER_ID, TEST_SUB_ID, false))); 1418 // Test for passpoint configuration. 1419 config.setPasspointUniqueId(TEST_PASSPOINT_UNIQUE_ID); 1420 assertTrue(config.getAllNetworkKeys().contains( 1421 config.getNetworkKeyFromSecurityType(SECURITY_TYPE_PASSPOINT_R1_R2))); 1422 } 1423 1424 /** 1425 * Verifies that vendor data can be set and retrieved successfully. 1426 */ 1427 @Test testSetAndGetVendorData()1428 public void testSetAndGetVendorData() { 1429 assumeTrue(SdkLevel.isAtLeastV()); 1430 WifiConfiguration config = new WifiConfiguration(); 1431 assertNotNull(config.getVendorData()); // non-null default value 1432 1433 List<OuiKeyedData> vendorData = Arrays.asList(mock(OuiKeyedData.class)); 1434 config.setVendorData(vendorData); 1435 assertTrue(vendorData.equals(config.getVendorData())); 1436 } 1437 } 1438