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 com.android.server.wifi; 18 19 import static android.net.wifi.WifiEnterpriseConfig.OCSP_NONE; 20 import static android.net.wifi.WifiEnterpriseConfig.OCSP_REQUIRE_CERT_STATUS; 21 22 import static org.junit.Assert.assertEquals; 23 import static org.junit.Assert.assertFalse; 24 import static org.junit.Assert.assertTrue; 25 26 import android.content.pm.UserInfo; 27 import android.net.IpConfiguration; 28 import android.net.MacAddress; 29 import android.net.wifi.ScanResult; 30 import android.net.wifi.SecurityParams; 31 import android.net.wifi.WifiConfiguration; 32 import android.net.wifi.WifiEnterpriseConfig; 33 import android.net.wifi.WifiInfo; 34 import android.net.wifi.WifiManager; 35 import android.net.wifi.WifiNetworkSpecifier; 36 import android.net.wifi.WifiScanner; 37 import android.os.PatternMatcher; 38 import android.util.Pair; 39 40 import androidx.test.filters.SmallTest; 41 42 import org.junit.Test; 43 44 import java.security.cert.X509Certificate; 45 import java.util.ArrayList; 46 import java.util.Arrays; 47 import java.util.Collections; 48 import java.util.List; 49 50 /** 51 * Unit tests for {@link com.android.server.wifi.WifiConfigurationUtil}. 52 */ 53 @SmallTest 54 public class WifiConfigurationUtilTest extends WifiBaseTest { 55 static final int CURRENT_USER_ID = 0; 56 static final int CURRENT_USER_MANAGED_PROFILE_USER_ID = 10; 57 static final int OTHER_USER_ID = 11; 58 static final int TEST_UID = 10000; 59 static final String TEST_PACKAGE = "com.test"; 60 static final String TEST_SSID = "\"test_ssid\""; 61 static final String TEST_SSID_1 = "\"test_ssid_1\""; 62 static final String TEST_BSSID = "aa:aa:11:22:cc:dd"; 63 static final String TEST_BSSID_1 = "11:22:11:22:cc:dd"; 64 static final List<UserInfo> PROFILES = Arrays.asList( 65 new UserInfo(CURRENT_USER_ID, "owner", 0), 66 new UserInfo(CURRENT_USER_MANAGED_PROFILE_USER_ID, "managed profile", 0)); 67 private static final long SUPPORTED_FEATURES_ALL = Long.MAX_VALUE; 68 69 /** 70 * Verify that new WifiEnterpriseConfig is detected. 71 */ 72 @Test testEnterpriseConfigAdded()73 public void testEnterpriseConfigAdded() { 74 EnterpriseConfig eapConfig = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS) 75 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2) 76 .setIdentity("username", "password") 77 .setCaCerts(new X509Certificate[]{FakeKeys.CA_CERT0}); 78 79 assertTrue(WifiConfigurationUtil.hasEnterpriseConfigChanged( 80 null, eapConfig.enterpriseConfig)); 81 } 82 83 /** 84 * Verify WifiEnterpriseConfig eap change is detected. 85 */ 86 @Test testEnterpriseConfigEapChangeDetected()87 public void testEnterpriseConfigEapChangeDetected() { 88 EnterpriseConfig eapConfig = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS); 89 EnterpriseConfig peapConfig = new EnterpriseConfig(WifiEnterpriseConfig.Eap.PEAP); 90 91 assertTrue(WifiConfigurationUtil.hasEnterpriseConfigChanged(eapConfig.enterpriseConfig, 92 peapConfig.enterpriseConfig)); 93 } 94 95 /** 96 * Verify WifiEnterpriseConfig phase2 method change is detected. 97 */ 98 @Test testEnterpriseConfigPhase2ChangeDetected()99 public void testEnterpriseConfigPhase2ChangeDetected() { 100 EnterpriseConfig eapConfig = 101 new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS) 102 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2); 103 EnterpriseConfig papConfig = 104 new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS) 105 .setPhase2(WifiEnterpriseConfig.Phase2.PAP); 106 107 assertTrue(WifiConfigurationUtil.hasEnterpriseConfigChanged(eapConfig.enterpriseConfig, 108 papConfig.enterpriseConfig)); 109 } 110 111 /** 112 * Verify WifiEnterpriseConfig added Certificate is detected. 113 */ 114 @Test testCaCertificateAddedDetected()115 public void testCaCertificateAddedDetected() { 116 EnterpriseConfig eapConfigNoCerts = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS) 117 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2) 118 .setIdentity("username", "password"); 119 120 EnterpriseConfig eapConfig1Cert = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS) 121 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2) 122 .setIdentity("username", "password") 123 .setCaCerts(new X509Certificate[]{FakeKeys.CA_CERT0}); 124 125 assertTrue(WifiConfigurationUtil.hasEnterpriseConfigChanged( 126 eapConfigNoCerts.enterpriseConfig, eapConfig1Cert.enterpriseConfig)); 127 } 128 129 /** 130 * Verify WifiEnterpriseConfig Certificate change is detected. 131 */ 132 @Test testDifferentCaCertificateDetected()133 public void testDifferentCaCertificateDetected() { 134 EnterpriseConfig eapConfig = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS) 135 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2) 136 .setIdentity("username", "password") 137 .setCaCerts(new X509Certificate[]{FakeKeys.CA_CERT0}); 138 139 EnterpriseConfig eapConfigNewCert = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS) 140 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2) 141 .setIdentity("username", "password") 142 .setCaCerts(new X509Certificate[]{FakeKeys.CA_CERT1}); 143 144 assertTrue(WifiConfigurationUtil.hasEnterpriseConfigChanged(eapConfig.enterpriseConfig, 145 eapConfigNewCert.enterpriseConfig)); 146 } 147 148 /** 149 * Verify WifiEnterpriseConfig added Certificate changes are detected. 150 */ 151 @Test testCaCertificateChangesDetected()152 public void testCaCertificateChangesDetected() { 153 EnterpriseConfig eapConfig = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS) 154 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2) 155 .setIdentity("username", "password") 156 .setCaCerts(new X509Certificate[]{FakeKeys.CA_CERT0}); 157 158 EnterpriseConfig eapConfigAddedCert = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS) 159 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2) 160 .setIdentity("username", "password") 161 .setCaCerts(new X509Certificate[]{FakeKeys.CA_CERT0, FakeKeys.CA_CERT1}); 162 163 assertTrue(WifiConfigurationUtil.hasEnterpriseConfigChanged(eapConfig.enterpriseConfig, 164 eapConfigAddedCert.enterpriseConfig)); 165 } 166 167 /** 168 * Verify that WifiEnterpriseConfig does not detect changes for identical configs. 169 */ 170 @Test testWifiEnterpriseConfigNoChanges()171 public void testWifiEnterpriseConfigNoChanges() { 172 EnterpriseConfig eapConfig = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS) 173 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2) 174 .setIdentity("username", "password") 175 .setCaCerts(new X509Certificate[]{FakeKeys.CA_CERT0, FakeKeys.CA_CERT1}); 176 177 // Just to be clear that check is not against the same object 178 EnterpriseConfig eapConfigSame = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS) 179 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2) 180 .setIdentity("username", "password") 181 .setCaCerts(new X509Certificate[]{FakeKeys.CA_CERT0, FakeKeys.CA_CERT1}); 182 183 assertFalse(WifiConfigurationUtil.hasEnterpriseConfigChanged(eapConfig.enterpriseConfig, 184 eapConfigSame.enterpriseConfig)); 185 } 186 187 /** 188 * Verify that the validate method successfully validates good WifiConfigurations with ASCII 189 * values. 190 */ 191 @Test testValidatePositiveCases_AsciiSsidString()192 public void testValidatePositiveCases_AsciiSsidString() { 193 assertTrue(WifiConfigurationUtil.validate( 194 WifiConfigurationTestUtil.createOpenNetwork(), SUPPORTED_FEATURES_ALL, 195 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 196 assertTrue(WifiConfigurationUtil.validate( 197 WifiConfigurationTestUtil.createPskNetwork(), SUPPORTED_FEATURES_ALL, 198 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 199 assertTrue(WifiConfigurationUtil.validate( 200 WifiConfigurationTestUtil.createWepNetwork(), SUPPORTED_FEATURES_ALL, 201 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 202 assertTrue(WifiConfigurationUtil.validate( 203 WifiConfigurationTestUtil.createEapNetwork(), SUPPORTED_FEATURES_ALL, 204 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 205 assertTrue(WifiConfigurationUtil.validate( 206 WifiConfigurationTestUtil.createOweNetwork(), SUPPORTED_FEATURES_ALL, 207 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 208 assertTrue(WifiConfigurationUtil.validate( 209 WifiConfigurationTestUtil.createSaeNetwork(), SUPPORTED_FEATURES_ALL, 210 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 211 assertTrue(WifiConfigurationUtil.validate( 212 WifiConfigurationTestUtil.createEapSuiteBNetwork(), SUPPORTED_FEATURES_ALL, 213 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 214 } 215 216 /** 217 * Verify that the validate method successfully validates good WifiConfigurations with hex 218 * values. 219 */ 220 @Test testValidatePositiveCases_HexSsidString()221 public void testValidatePositiveCases_HexSsidString() { 222 WifiConfiguration config = WifiConfigurationTestUtil.createPskNetwork(); 223 config.SSID = "abcd1234555a"; 224 config.preSharedKey = "abcd123455151234556788990034556667332345667322344556676743233445"; 225 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 226 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 227 } 228 229 /** 230 * Verify that the validate method validates WifiConfiguration with "any" in the BSSID field. 231 */ 232 @Test testValidatePositiveCases_AnyBssidString()233 public void testValidatePositiveCases_AnyBssidString() { 234 WifiConfiguration config = WifiConfigurationTestUtil.createPskNetwork(); 235 config.BSSID = "any"; 236 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 237 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 238 assertTrue(WifiConfigurationUtil.validate( 239 config, SUPPORTED_FEATURES_ALL, WifiConfigurationUtil.VALIDATE_FOR_UPDATE)); 240 } 241 242 /** 243 * Verify that the validate method validates WifiConfiguration with masked psk string only for 244 * an update. 245 */ 246 @Test testValidatePositiveCases_MaskedPskString()247 public void testValidatePositiveCases_MaskedPskString() { 248 WifiConfiguration config = WifiConfigurationTestUtil.createPskNetwork(); 249 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 250 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 251 252 config.preSharedKey = WifiConfigurationUtil.PASSWORD_MASK; 253 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 254 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 255 assertTrue(WifiConfigurationUtil.validate( 256 config, SUPPORTED_FEATURES_ALL, WifiConfigurationUtil.VALIDATE_FOR_UPDATE)); 257 } 258 259 /** 260 * Verify that the validate method validates WifiConfiguration with null ssid only for an 261 * update. 262 */ 263 @Test testValidatePositiveCases_OnlyUpdateIgnoresNullSsid()264 public void testValidatePositiveCases_OnlyUpdateIgnoresNullSsid() { 265 WifiConfiguration config = new WifiConfiguration(); 266 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 267 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 268 assertTrue(WifiConfigurationUtil.validate( 269 config, SUPPORTED_FEATURES_ALL, WifiConfigurationUtil.VALIDATE_FOR_UPDATE)); 270 271 } 272 273 /** 274 * Verify that the validate method fails to validate WifiConfiguration with bad ssid length. 275 */ 276 @Test testValidateNegativeCases_BadAsciiSsidLength()277 public void testValidateNegativeCases_BadAsciiSsidLength() { 278 WifiConfiguration config = WifiConfigurationTestUtil.createOpenNetwork(); 279 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 280 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 281 282 config.SSID = "\"abcdfefeeretretyetretetetetetrertertrsreqwrwe\""; 283 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 284 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 285 config.SSID = "\"\""; 286 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 287 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 288 } 289 290 /** 291 * Verify that the validate method fails to validate WifiConfiguration with bad ssid length. 292 */ 293 @Test testValidateNegativeCases_BadUtf8SsidLength()294 public void testValidateNegativeCases_BadUtf8SsidLength() { 295 WifiConfiguration config = WifiConfigurationTestUtil.createOpenNetwork(); 296 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 297 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 298 299 config.SSID = "\"가하아너너ㅓ저저ㅓ어아아다자저ㅓ더타아어어러두어\""; 300 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 301 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 302 config.SSID = "\"\""; 303 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 304 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 305 } 306 307 /** 308 * Verify that the validate method fails to validate WifiConfiguration with malformed ssid 309 * string. 310 */ 311 @Test testValidateNegativeCases_MalformedAsciiSsidString()312 public void testValidateNegativeCases_MalformedAsciiSsidString() { 313 WifiConfiguration config = WifiConfigurationTestUtil.createOpenNetwork(); 314 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 315 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 316 317 config.SSID = "\"ab"; 318 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 319 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 320 } 321 322 /** 323 * Verify that the validate method fails to validate WifiConfiguration with bad ssid length. 324 */ 325 @Test testValidateNegativeCases_BadHexSsidLength()326 public void testValidateNegativeCases_BadHexSsidLength() { 327 WifiConfiguration config = WifiConfigurationTestUtil.createOpenNetwork(); 328 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 329 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 330 331 config.SSID = "abcdfe012345632423343543453456464545656464545646454ace34534545634535"; 332 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 333 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 334 config.SSID = ""; 335 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 336 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 337 } 338 339 /** 340 * Verify that the validate method fails to validate WifiConfiguration with malformed ssid 341 * string. 342 */ 343 @Test testValidateNegativeCases_MalformedHexSsidString()344 public void testValidateNegativeCases_MalformedHexSsidString() { 345 WifiConfiguration config = WifiConfigurationTestUtil.createOpenNetwork(); 346 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 347 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 348 349 config.SSID = "hello"; 350 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 351 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 352 } 353 354 /** 355 * Verify that the validate method fails to validate WifiConfiguration with bad psk length. 356 */ 357 @Test testValidateNegativeCases_BadAsciiPskLength()358 public void testValidateNegativeCases_BadAsciiPskLength() { 359 WifiConfiguration config = WifiConfigurationTestUtil.createPskNetwork(); 360 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 361 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 362 363 config.preSharedKey = "\"abcdffeeretretyetreteteteabe34tetrertertrsraaaaaaaaaaa345eqwrweewq" 364 + "weqe\""; 365 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 366 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 367 config.preSharedKey = "\"454\""; 368 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 369 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 370 } 371 372 @Test testValidateNegativeCases_BadAsciiPskLengthWapi()373 public void testValidateNegativeCases_BadAsciiPskLengthWapi() { 374 WifiConfiguration config = WifiConfigurationTestUtil.createWapiPskNetwork(); 375 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 376 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 377 378 config.preSharedKey = "\"abcdffeeretretyetreteteteabe34tetrertertrsraaaaaaaaaaa345eqwrweewq" 379 + "weqe\""; 380 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 381 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 382 config.preSharedKey = "\"454\""; 383 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 384 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 385 } 386 387 /** 388 * Verify that the validate method fails to validate WifiConfiguration with bad sae length. 389 */ 390 @Test testValidateNegativeCases_BadAsciiSaeLength()391 public void testValidateNegativeCases_BadAsciiSaeLength() { 392 WifiConfiguration config = WifiConfigurationTestUtil.createSaeNetwork(); 393 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 394 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 395 396 config.preSharedKey = "\"abcdffeeretretyetreteteteabe34tetrertertrsraaaaaaaaaaa345eqwrweewq" 397 + "weqe\""; 398 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 399 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 400 config.preSharedKey = "\"\""; 401 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 402 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 403 } 404 405 /** 406 * Verify that the validate method fails to validate WifiConfiguration with malformed psk 407 * string. 408 */ 409 @Test testValidateNegativeCases_MalformedAsciiPskString()410 public void testValidateNegativeCases_MalformedAsciiPskString() { 411 WifiConfiguration config = WifiConfigurationTestUtil.createPskNetwork(); 412 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 413 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 414 415 config.preSharedKey = "\"abcdfefeeretrety"; 416 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 417 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 418 } 419 420 @Test testValidateNegativeCases_MalformedAsciiPskStringWapi()421 public void testValidateNegativeCases_MalformedAsciiPskStringWapi() { 422 WifiConfiguration config = WifiConfigurationTestUtil.createWapiPskNetwork(); 423 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 424 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 425 426 config.preSharedKey = "\"abcdfefeeretrety"; 427 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 428 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 429 } 430 431 /** 432 * Verify that the validate method fails to validate WifiConfiguration with malformed sae 433 * string. 434 */ 435 @Test testValidateNegativeCases_MalformedAsciiSaeString()436 public void testValidateNegativeCases_MalformedAsciiSaeString() { 437 WifiConfiguration config = WifiConfigurationTestUtil.createSaeNetwork(); 438 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 439 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 440 441 config.preSharedKey = "\"abcdfefeeretrety"; 442 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 443 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 444 } 445 446 /** 447 * Verify that the validate method fails to validate WifiConfiguration with bad psk length. 448 */ 449 @Test testValidateNegativeCases_BadHexPskLength()450 public void testValidateNegativeCases_BadHexPskLength() { 451 WifiConfiguration config = WifiConfigurationTestUtil.createPskNetwork(); 452 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 453 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 454 455 config.preSharedKey = "abcd123456788990013453445345465465476546"; 456 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 457 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 458 config.preSharedKey = ""; 459 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 460 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 461 } 462 463 @Test testValidateNegativeCases_BadHexPskLengthWapi()464 public void testValidateNegativeCases_BadHexPskLengthWapi() { 465 WifiConfiguration config = WifiConfigurationTestUtil.createWapiPskNetwork(); 466 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 467 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 468 469 config.preSharedKey = "abcd123456788990013453445345465465476546"; 470 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 471 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 472 config.preSharedKey = ""; 473 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 474 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 475 } 476 477 /** 478 * Verify that the validate method fails to validate WifiConfiguration with malformed psk 479 * string. 480 */ 481 @Test testValidateNegativeCases_MalformedHexPskString()482 public void testValidateNegativeCases_MalformedHexPskString() { 483 WifiConfiguration config = WifiConfigurationTestUtil.createPskNetwork(); 484 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 485 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 486 487 config.preSharedKey = "adbdfgretrtyrtyrty"; 488 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 489 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 490 } 491 492 @Test testValidateNegativeCases_MalformedHexPskStringWapi()493 public void testValidateNegativeCases_MalformedHexPskStringWapi() { 494 WifiConfiguration config = WifiConfigurationTestUtil.createWapiPskNetwork(); 495 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 496 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 497 498 config.preSharedKey = "adbdfgretrtyrtyrty"; 499 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 500 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 501 } 502 503 /** 504 * Verify that the validate method fails to validate WifiConfiguration with malformed sae 505 * string. 506 */ 507 @Test testValidateNegativeCases_MalformedHexSaeString()508 public void testValidateNegativeCases_MalformedHexSaeString() { 509 WifiConfiguration config = WifiConfigurationTestUtil.createSaeNetwork(); 510 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 511 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 512 513 config.preSharedKey = "adbdfgretrtyrtyrty"; 514 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 515 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 516 } 517 518 /** 519 * Verify that the validate method validates WifiConfiguration with masked wep key only for 520 * an update. 521 */ 522 @Test testValidatePositiveCases_MaskedWepKeysString()523 public void testValidatePositiveCases_MaskedWepKeysString() { 524 WifiConfiguration config = WifiConfigurationTestUtil.createWepNetwork(); 525 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 526 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 527 528 config.wepKeys = new String[]{ WifiConfigurationUtil.PASSWORD_MASK, 529 WifiConfigurationUtil.PASSWORD_MASK, 530 WifiConfigurationUtil.PASSWORD_MASK, 531 WifiConfigurationUtil.PASSWORD_MASK}; 532 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 533 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 534 assertTrue(WifiConfigurationUtil.validate( 535 config, SUPPORTED_FEATURES_ALL, WifiConfigurationUtil.VALIDATE_FOR_UPDATE)); 536 } 537 538 /** 539 * Verify that the validate method fails to validate WifiConfiguration with bad wep length. 540 */ 541 @Test testValidateNegativeCases_BadWepKeysLength()542 public void testValidateNegativeCases_BadWepKeysLength() { 543 WifiConfiguration config = WifiConfigurationTestUtil.createWepNetwork(); 544 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 545 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 546 547 config.wepKeys = new String[] {"\"abcd\""}; 548 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 549 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 550 config.wepKeys = new String[] {"456"}; 551 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 552 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 553 // Error scenario in b/169638868. 554 config.wepKeys = new String[] {""}; 555 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 556 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 557 } 558 559 /** 560 * Verify that the validate method fails to validate WifiConfiguration with bad wep tx key idx. 561 */ 562 @Test testValidateNegativeCases_BadWepTxKeysIndex()563 public void testValidateNegativeCases_BadWepTxKeysIndex() { 564 WifiConfiguration config = WifiConfigurationTestUtil.createWepNetwork(); 565 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 566 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 567 // Should be < wepKeys.length 568 config.wepTxKeyIndex = config.wepKeys.length; 569 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 570 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 571 } 572 573 /** 574 * Verify that the validate method fails to validate WifiConfiguration with bad key mgmt values. 575 */ 576 @Test testValidateNegativeCases_BadKeyMgmtPskEap()577 public void testValidateNegativeCases_BadKeyMgmtPskEap() { 578 WifiConfiguration config = WifiConfigurationTestUtil.createPskNetwork(); 579 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 580 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 581 582 config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.IEEE8021X); 583 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 584 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 585 } 586 587 /** 588 * Verify that the validate method fails to validate WifiConfiguration with bad key mgmt values. 589 */ 590 @Test testValidateNegativeCases_BadKeyMgmtOpenPsk()591 public void testValidateNegativeCases_BadKeyMgmtOpenPsk() { 592 WifiConfiguration config = WifiConfigurationTestUtil.createOpenNetwork(); 593 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 594 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 595 596 config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK); 597 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 598 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 599 } 600 601 /** 602 * Verify that the validate method fails to validate WifiConfiguration with bad key mgmt values. 603 */ 604 @Test testValidateNegativeCases_BadKeyMgmt()605 public void testValidateNegativeCases_BadKeyMgmt() { 606 WifiConfiguration config = WifiConfigurationTestUtil.createPskNetwork(); 607 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 608 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 609 610 config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.IEEE8021X); 611 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 612 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 613 } 614 615 /** 616 * Verify that the validate method fails to validate WifiConfiguration with bad key mgmt values. 617 */ 618 @Test testValidateNegativeCases_BadSuiteBKeyMgmt()619 public void testValidateNegativeCases_BadSuiteBKeyMgmt() { 620 WifiConfiguration config = WifiConfigurationTestUtil.createEapSuiteBNetwork(); 621 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 622 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 623 624 config.allowedKeyManagement.clear(WifiConfiguration.KeyMgmt.IEEE8021X); 625 config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA2_PSK); 626 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 627 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 628 } 629 630 /** 631 * Verify that the validate method fails to validate WifiConfiguration with bad ipconfiguration 632 * values. 633 */ 634 @Test testValidateNegativeCases_BadIpconfiguration()635 public void testValidateNegativeCases_BadIpconfiguration() { 636 WifiConfiguration config = WifiConfigurationTestUtil.createPskNetwork(); 637 IpConfiguration ipConfig = 638 WifiConfigurationTestUtil.createStaticIpConfigurationWithPacProxy(); 639 config.setIpConfiguration(ipConfig); 640 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 641 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 642 643 ipConfig.setStaticIpConfiguration(null); 644 config.setIpConfiguration(ipConfig); 645 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 646 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 647 } 648 649 /** 650 * Verify that the validate method fails to validate WifiConfiguration with bad KeyMgmt value. 651 */ 652 @Test testValidateNegativeCases_InvalidKeyMgmt()653 public void testValidateNegativeCases_InvalidKeyMgmt() { 654 WifiConfiguration config = WifiConfigurationTestUtil.createOpenNetwork(); 655 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 656 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 657 658 config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.FT_EAP + 1); 659 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 660 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 661 } 662 663 /** 664 * Verify that the validate method fails to validate WifiConfiguration with bad KeyMgmt value. 665 */ 666 @Test testValidateNegativeCases_InvalidKeyMgmtWithPreSharedKey()667 public void testValidateNegativeCases_InvalidKeyMgmtWithPreSharedKey() { 668 WifiConfiguration config = WifiConfigurationTestUtil.createPskNetwork(); 669 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 670 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 671 672 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_OSEN); 673 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 674 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 675 // Verify we reset the KeyMgmt 676 assertTrue(config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.WPA_PSK)); 677 assertFalse(config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.OSEN)); 678 } 679 680 /** 681 * Verify that the validate method fails to validate WifiConfiguration with bad Protocol value. 682 */ 683 @Test testValidateNegativeCases_InvalidProtocol()684 public void testValidateNegativeCases_InvalidProtocol() { 685 WifiConfiguration config = WifiConfigurationTestUtil.createOpenNetwork(); 686 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 687 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 688 689 config.allowedProtocols.set(4); 690 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 691 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 692 } 693 694 /** 695 * Verify that the validate method fails to validate WifiConfiguration with bad AuthAlgorithm 696 * value. 697 */ 698 @Test testValidateNegativeCases_InvalidAuthAlgorithm()699 public void testValidateNegativeCases_InvalidAuthAlgorithm() { 700 WifiConfiguration config = WifiConfigurationTestUtil.createOpenNetwork(); 701 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 702 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 703 704 config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.LEAP + 3); 705 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 706 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 707 } 708 709 /** 710 * Verify that the validate method fails to validate WifiConfiguration with bad GroupCipher 711 * value. 712 */ 713 @Test testValidateNegativeCases_InvalidGroupCipher()714 public void testValidateNegativeCases_InvalidGroupCipher() { 715 WifiConfiguration config = WifiConfigurationTestUtil.createOpenNetwork(); 716 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 717 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 718 719 config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.GTK_NOT_USED + 4); 720 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 721 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 722 } 723 724 /** 725 * Verify that the validate method fails to validate WifiConfiguration with bad PairwiseCipher 726 * value. 727 */ 728 @Test testValidateNegativeCases_InvalidPairwiseCipher()729 public void testValidateNegativeCases_InvalidPairwiseCipher() { 730 WifiConfiguration config = WifiConfigurationTestUtil.createOpenNetwork(); 731 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 732 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 733 734 config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP + 4); 735 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 736 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 737 } 738 739 /** 740 * Verify that the validate method successfully validates good WifiNetworkSpecifier with 741 * only ssid pattern set. 742 */ 743 @Test testValidateNetworkSpecifierPositiveCases_SsidPattern()744 public void testValidateNetworkSpecifierPositiveCases_SsidPattern() { 745 WifiNetworkSpecifier specifier = new WifiNetworkSpecifier( 746 new PatternMatcher(TEST_SSID, PatternMatcher.PATTERN_LITERAL), 747 Pair.create(WifiManager.ALL_ZEROS_MAC_ADDRESS, WifiManager.ALL_ZEROS_MAC_ADDRESS), 748 ScanResult.UNSPECIFIED, 749 WifiConfigurationTestUtil.createOpenNetwork()); 750 assertTrue(WifiConfigurationUtil.validateNetworkSpecifier(specifier)); 751 } 752 753 /** 754 * Verify that the validate method successfully validates good WifiNetworkSpecifier with 755 * only bssid pattern set. 756 */ 757 @Test testValidateNetworkSpecifierPositiveCases_BssidPattern()758 public void testValidateNetworkSpecifierPositiveCases_BssidPattern() { 759 WifiNetworkSpecifier specifier = new WifiNetworkSpecifier( 760 new PatternMatcher(".*", PatternMatcher.PATTERN_SIMPLE_GLOB), 761 Pair.create(MacAddress.fromString(TEST_BSSID), MacAddress.BROADCAST_ADDRESS), 762 ScanResult.UNSPECIFIED, 763 WifiConfigurationTestUtil.createOpenNetwork()); 764 assertTrue(WifiConfigurationUtil.validateNetworkSpecifier(specifier)); 765 } 766 767 /** 768 * Verify that the validate method successfully validates good WifiNetworkSpecifier with 769 * both ssid & bssid patterns set. 770 */ 771 @Test testValidateNetworkSpecifierPositiveCases_BothSsidPatternAndBssidPattern()772 public void testValidateNetworkSpecifierPositiveCases_BothSsidPatternAndBssidPattern() { 773 WifiNetworkSpecifier specifier = new WifiNetworkSpecifier( 774 new PatternMatcher(TEST_SSID, PatternMatcher.PATTERN_LITERAL), 775 Pair.create(MacAddress.fromString(TEST_BSSID), MacAddress.BROADCAST_ADDRESS), 776 ScanResult.UNSPECIFIED, 777 WifiConfigurationTestUtil.createOpenNetwork()); 778 assertTrue(WifiConfigurationUtil.validateNetworkSpecifier(specifier)); 779 } 780 781 /** 782 * Verify that the validate method validates a WifiNetworkSpecifier that specifies ssid, bssid, 783 * and band. Note that such requests will currently still be rejected by WifiNetworkFactory, but 784 * requesting specific bands may be supported in future releases. 785 */ 786 @Test testValidateNetworkSpecifierPositiveCases_SsidPatternAndBssidPatternAndBand()787 public void testValidateNetworkSpecifierPositiveCases_SsidPatternAndBssidPatternAndBand() { 788 WifiNetworkSpecifier specifier = new WifiNetworkSpecifier( 789 new PatternMatcher(TEST_SSID, PatternMatcher.PATTERN_LITERAL), 790 Pair.create(MacAddress.fromString(TEST_BSSID), MacAddress.BROADCAST_ADDRESS), 791 ScanResult.WIFI_BAND_5_GHZ, 792 WifiConfigurationTestUtil.createOpenNetwork()); 793 assertTrue(WifiConfigurationUtil.validateNetworkSpecifier(specifier)); 794 } 795 796 797 /** 798 * Verify that the validate method fails to validate WifiNetworkSpecifier with no 799 * ssid/bssid info. 800 */ 801 @Test testValidateNetworkSpecifierNegativeCases_NoSsidBssid()802 public void testValidateNetworkSpecifierNegativeCases_NoSsidBssid() { 803 WifiNetworkSpecifier specifier = new WifiNetworkSpecifier( 804 new PatternMatcher(".*", PatternMatcher.PATTERN_SIMPLE_GLOB), 805 Pair.create(WifiManager.ALL_ZEROS_MAC_ADDRESS, WifiManager.ALL_ZEROS_MAC_ADDRESS), 806 ScanResult.UNSPECIFIED, 807 WifiConfigurationTestUtil.createOpenNetwork()); 808 assertFalse(WifiConfigurationUtil.validateNetworkSpecifier(specifier)); 809 } 810 811 /** 812 * Verify that the validate method fails to validate WifiNetworkSpecifier with invalid SSID 813 * match pattern. 814 */ 815 @Test testValidateNetworkSpecifierNegativeCases_MatchNoneSsidPattern()816 public void testValidateNetworkSpecifierNegativeCases_MatchNoneSsidPattern() { 817 WifiNetworkSpecifier specifier = new WifiNetworkSpecifier( 818 new PatternMatcher("", PatternMatcher.PATTERN_LITERAL), 819 Pair.create(WifiManager.ALL_ZEROS_MAC_ADDRESS, WifiManager.ALL_ZEROS_MAC_ADDRESS), 820 ScanResult.UNSPECIFIED, 821 WifiConfigurationTestUtil.createOpenNetwork()); 822 assertFalse(WifiConfigurationUtil.validateNetworkSpecifier(specifier)); 823 } 824 825 /** 826 * Verify that the validate method fails to validate WifiNetworkSpecifier with illegal 827 * pattern. 828 */ 829 @Test testValidateNetworkSpecifierNegativeCases_MatchNoneBssidPattern()830 public void testValidateNetworkSpecifierNegativeCases_MatchNoneBssidPattern() { 831 WifiNetworkSpecifier specifier = new WifiNetworkSpecifier( 832 new PatternMatcher(TEST_SSID, PatternMatcher.PATTERN_LITERAL), 833 Pair.create(MacAddress.BROADCAST_ADDRESS, MacAddress.BROADCAST_ADDRESS), 834 ScanResult.UNSPECIFIED, 835 WifiConfigurationTestUtil.createOpenNetwork()); 836 assertFalse(WifiConfigurationUtil.validateNetworkSpecifier(specifier)); 837 } 838 839 /** 840 * Verify that the validate method fails to validate WifiNetworkSpecifier with illegal 841 * pattern. 842 */ 843 @Test testValidateNetworkSpecifierNegativeCases_InvalidBssidPattern()844 public void testValidateNetworkSpecifierNegativeCases_InvalidBssidPattern() { 845 WifiNetworkSpecifier specifier = new WifiNetworkSpecifier( 846 new PatternMatcher(TEST_SSID, PatternMatcher.PATTERN_LITERAL), 847 Pair.create(MacAddress.fromString(TEST_BSSID), WifiManager.ALL_ZEROS_MAC_ADDRESS), 848 ScanResult.UNSPECIFIED, 849 WifiConfigurationTestUtil.createOpenNetwork()); 850 assertFalse(WifiConfigurationUtil.validateNetworkSpecifier(specifier)); 851 } 852 853 /** 854 * Verify that the validate method fails to validate WifiNetworkSpecifier with SSID pattern 855 * for hidden network. 856 */ 857 @Test testValidateNetworkSpecifierNegativeCases_NoSsidPatternForHiddenNetwork()858 public void testValidateNetworkSpecifierNegativeCases_NoSsidPatternForHiddenNetwork() { 859 WifiNetworkSpecifier specifier = new WifiNetworkSpecifier( 860 new PatternMatcher(TEST_SSID, PatternMatcher.PATTERN_PREFIX), 861 Pair.create(WifiManager.ALL_ZEROS_MAC_ADDRESS, WifiManager.ALL_ZEROS_MAC_ADDRESS), 862 ScanResult.UNSPECIFIED, 863 WifiConfigurationTestUtil.createOpenHiddenNetwork()); 864 assertFalse(WifiConfigurationUtil.validateNetworkSpecifier(specifier)); 865 } 866 867 /** 868 * Verify that the validate method fails to validate WifiNetworkSpecifier with an invalid band. 869 */ 870 @Test testValidateNetworkSpecifierNegativeCases_InvalidBand()871 public void testValidateNetworkSpecifierNegativeCases_InvalidBand() { 872 WifiNetworkSpecifier specifier = new WifiNetworkSpecifier( 873 new PatternMatcher(TEST_SSID, PatternMatcher.PATTERN_LITERAL), 874 Pair.create(MacAddress.fromString(TEST_BSSID), MacAddress.BROADCAST_ADDRESS), 875 42, // invalid 876 WifiConfigurationTestUtil.createOpenNetwork()); 877 assertFalse(WifiConfigurationUtil.validateNetworkSpecifier(specifier)); 878 } 879 880 /** 881 * Verify the instance of {@link android.net.wifi.WifiScanner.PnoSettings.PnoNetwork} created 882 * for an open network using {@link WifiConfigurationUtil#createPnoNetwork( 883 * WifiConfiguration)}. 884 */ 885 @Test testCreatePnoNetworkWithOpenNetwork()886 public void testCreatePnoNetworkWithOpenNetwork() { 887 WifiConfiguration network = WifiConfigurationTestUtil.createOpenNetwork(); 888 WifiScanner.PnoSettings.PnoNetwork pnoNetwork = 889 WifiConfigurationUtil.createPnoNetwork(network); 890 assertEquals(network.SSID, pnoNetwork.ssid); 891 assertEquals( 892 WifiScanner.PnoSettings.PnoNetwork.FLAG_A_BAND 893 | WifiScanner.PnoSettings.PnoNetwork.FLAG_G_BAND, pnoNetwork.flags); 894 assertEquals(WifiScanner.PnoSettings.PnoNetwork.AUTH_CODE_OPEN, pnoNetwork.authBitField); 895 } 896 897 /** 898 * Verify the instance of {@link android.net.wifi.WifiScanner.PnoSettings.PnoNetwork} created 899 * for an open hidden network using {@link WifiConfigurationUtil#createPnoNetwork( 900 * WifiConfiguration)}. 901 */ 902 @Test testCreatePnoNetworkWithOpenHiddenNetwork()903 public void testCreatePnoNetworkWithOpenHiddenNetwork() { 904 WifiConfiguration network = WifiConfigurationTestUtil.createOpenHiddenNetwork(); 905 WifiScanner.PnoSettings.PnoNetwork pnoNetwork = 906 WifiConfigurationUtil.createPnoNetwork(network); 907 assertEquals(network.SSID, pnoNetwork.ssid); 908 assertEquals( 909 WifiScanner.PnoSettings.PnoNetwork.FLAG_A_BAND 910 | WifiScanner.PnoSettings.PnoNetwork.FLAG_G_BAND 911 | WifiScanner.PnoSettings.PnoNetwork.FLAG_DIRECTED_SCAN, pnoNetwork.flags); 912 assertEquals(WifiScanner.PnoSettings.PnoNetwork.AUTH_CODE_OPEN, pnoNetwork.authBitField); 913 } 914 915 /** 916 * Verify the instance of {@link android.net.wifi.WifiScanner.PnoSettings.PnoNetwork} created 917 * for a PSK network using {@link WifiConfigurationUtil#createPnoNetwork(WifiConfiguration) 918 * }. 919 */ 920 @Test testCreatePnoNetworkWithPskNetwork()921 public void testCreatePnoNetworkWithPskNetwork() { 922 WifiConfiguration network = WifiConfigurationTestUtil.createPskNetwork(); 923 WifiScanner.PnoSettings.PnoNetwork pnoNetwork = 924 WifiConfigurationUtil.createPnoNetwork(network); 925 assertEquals(network.SSID, pnoNetwork.ssid); 926 assertEquals( 927 WifiScanner.PnoSettings.PnoNetwork.FLAG_A_BAND 928 | WifiScanner.PnoSettings.PnoNetwork.FLAG_G_BAND, pnoNetwork.flags); 929 assertEquals(WifiScanner.PnoSettings.PnoNetwork.AUTH_CODE_PSK, pnoNetwork.authBitField); 930 } 931 932 /** 933 * Verify that WifiConfigurationUtil.isSameNetwork returns true when two WifiConfiguration 934 * objects have the same parameters. 935 */ 936 @Test testIsSameNetworkReturnsTrueOnSameNetwork()937 public void testIsSameNetworkReturnsTrueOnSameNetwork() { 938 WifiConfiguration network = WifiConfigurationTestUtil.createPskNetwork(TEST_SSID); 939 WifiConfiguration network1 = WifiConfigurationTestUtil.createPskNetwork(TEST_SSID); 940 assertTrue(WifiConfigurationUtil.isSameNetwork(network, network1)); 941 } 942 943 /** 944 * Verify that WifiConfigurationUtil.isSameNetwork returns true when two WifiConfiguration 945 * objects have the same parameters but different network selection BSSID's. 946 */ 947 @Test testIsSameNetworkReturnsTrueOnSameNetworkWithDifferentBSSID()948 public void testIsSameNetworkReturnsTrueOnSameNetworkWithDifferentBSSID() { 949 WifiConfiguration network = WifiConfigurationTestUtil.createPskNetwork(TEST_SSID); 950 network.getNetworkSelectionStatus().setNetworkSelectionBSSID(TEST_BSSID); 951 WifiConfiguration network1 = WifiConfigurationTestUtil.createPskNetwork(TEST_SSID); 952 network1.getNetworkSelectionStatus().setNetworkSelectionBSSID(TEST_BSSID_1); 953 assertTrue(WifiConfigurationUtil.isSameNetwork(network, network1)); 954 } 955 956 /** 957 * Verify that WifiConfigurationUtil.isSameNetwork returns false when two WifiConfiguration 958 * objects have the different SSIDs. 959 */ 960 @Test testIsSameNetworkReturnsFalseOnDifferentSSID()961 public void testIsSameNetworkReturnsFalseOnDifferentSSID() { 962 WifiConfiguration network = WifiConfigurationTestUtil.createPskNetwork(TEST_SSID); 963 WifiConfiguration network1 = WifiConfigurationTestUtil.createPskNetwork(TEST_SSID_1); 964 assertFalse(WifiConfigurationUtil.isSameNetwork(network, network1)); 965 } 966 967 /** 968 * Verify that WifiConfigurationUtil.isSameNetwork returns false when two WifiConfiguration 969 * objects have the different security type. 970 */ 971 @Test testIsSameNetworkReturnsFalseOnDifferentSecurityType()972 public void testIsSameNetworkReturnsFalseOnDifferentSecurityType() { 973 WifiConfiguration network = WifiConfigurationTestUtil.createPskNetwork(TEST_SSID); 974 WifiConfiguration network1 = WifiConfigurationTestUtil.createEapNetwork(TEST_SSID); 975 assertFalse(WifiConfigurationUtil.isSameNetwork(network, network1)); 976 } 977 978 /** 979 * Verify that WifiConfigurationUtil.isSameNetwork returns false when two WifiConfiguration 980 * objects have the different EAP identity. 981 */ 982 @Test testIsSameNetworkReturnsFalseOnDifferentEapIdentity()983 public void testIsSameNetworkReturnsFalseOnDifferentEapIdentity() { 984 WifiConfiguration network1 = WifiConfigurationTestUtil.createEapNetwork(TEST_SSID); 985 WifiConfiguration network2 = WifiConfigurationTestUtil.createEapNetwork(TEST_SSID); 986 network1.enterpriseConfig.setIdentity("Identity1"); 987 network2.enterpriseConfig.setIdentity("Identity2"); 988 assertFalse(WifiConfigurationUtil.isSameNetwork(network1, network2)); 989 } 990 991 /** 992 * Verify that WifiConfigurationUtil.isSameNetwork returns false when two WifiConfiguration 993 * objects have the different EAP anonymous identity. 994 */ 995 @Test testIsSameNetworkReturnsFalseOnDifferentEapAnonymousIdentity()996 public void testIsSameNetworkReturnsFalseOnDifferentEapAnonymousIdentity() { 997 WifiConfiguration network1 = WifiConfigurationTestUtil.createEapNetwork(TEST_SSID); 998 WifiConfiguration network2 = WifiConfigurationTestUtil.createEapNetwork(TEST_SSID); 999 network1.enterpriseConfig.setAnonymousIdentity("Identity1"); 1000 network2.enterpriseConfig.setAnonymousIdentity("Identity2"); 1001 assertFalse(WifiConfigurationUtil.isSameNetwork(network1, network2)); 1002 } 1003 1004 /** 1005 * Verify that WifiConfigurationUtil.isSameNetwork returns false when two WifiConfiguration 1006 * objects have the different EAP anonymous(pseudonym) identity in EAP-SIM. 1007 */ 1008 @Test testIsSameNetworkReturnsFalseOnDifferentEapAnonymousIdentityInEapSim()1009 public void testIsSameNetworkReturnsFalseOnDifferentEapAnonymousIdentityInEapSim() { 1010 WifiConfiguration network1 = WifiConfigurationTestUtil.createEapNetwork(TEST_SSID); 1011 WifiConfiguration network2 = WifiConfigurationTestUtil.createEapNetwork(TEST_SSID); 1012 network1.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.SIM); 1013 network2.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.SIM); 1014 network1.enterpriseConfig.setAnonymousIdentity("Identity1"); 1015 network2.enterpriseConfig.setAnonymousIdentity("Identity2"); 1016 assertFalse(WifiConfigurationUtil.isSameNetwork(network1, network2)); 1017 } 1018 1019 /** 1020 * Verify that WifiConfigurationUtil.isSameNetwork returns true when two WifiConfiguration 1021 * objects have the same candidate security params. 1022 */ 1023 @Test testIsSameNetworkReturnsTrueOnSameNetworkWithSameCandidateSecurityParams()1024 public void testIsSameNetworkReturnsTrueOnSameNetworkWithSameCandidateSecurityParams() { 1025 WifiConfiguration network = WifiConfigurationTestUtil.createPskNetwork(TEST_SSID); 1026 network.getNetworkSelectionStatus().setCandidateSecurityParams( 1027 SecurityParams.createSecurityParamsBySecurityType( 1028 WifiConfiguration.SECURITY_TYPE_PSK)); 1029 WifiConfiguration network1 = WifiConfigurationTestUtil.createPskNetwork(TEST_SSID); 1030 network1.getNetworkSelectionStatus().setCandidateSecurityParams( 1031 SecurityParams.createSecurityParamsBySecurityType( 1032 WifiConfiguration.SECURITY_TYPE_PSK)); 1033 assertTrue(WifiConfigurationUtil.isSameNetwork(network, network1)); 1034 } 1035 1036 /** 1037 * Verify that WifiConfigurationUtil.isSameNetwork returns false when two WifiConfiguration 1038 * objects have the different candidate security params. 1039 */ 1040 @Test testIsSameNetworkReturnsTrueOnSameNetworkWithDifferentCandidateSecurityParams()1041 public void testIsSameNetworkReturnsTrueOnSameNetworkWithDifferentCandidateSecurityParams() { 1042 WifiConfiguration network = WifiConfigurationTestUtil.createPskNetwork(TEST_SSID); 1043 network.getNetworkSelectionStatus().setCandidateSecurityParams( 1044 SecurityParams.createSecurityParamsBySecurityType( 1045 WifiConfiguration.SECURITY_TYPE_PSK)); 1046 WifiConfiguration network1 = WifiConfigurationTestUtil.createPskNetwork(TEST_SSID); 1047 network1.getNetworkSelectionStatus().setCandidateSecurityParams( 1048 SecurityParams.createSecurityParamsBySecurityType( 1049 WifiConfiguration.SECURITY_TYPE_SAE)); 1050 assertFalse(WifiConfigurationUtil.isSameNetwork(network, network1)); 1051 } 1052 1053 /** 1054 * Verify the instance of {@link android.net.wifi.WifiScanner.PnoSettings.PnoNetwork} created 1055 * for a EAP network using {@link WifiConfigurationUtil#createPnoNetwork(WifiConfiguration) 1056 * }. 1057 */ 1058 @Test testCreatePnoNetworkWithEapNetwork()1059 public void testCreatePnoNetworkWithEapNetwork() { 1060 WifiConfiguration network = WifiConfigurationTestUtil.createEapNetwork(); 1061 WifiScanner.PnoSettings.PnoNetwork pnoNetwork = 1062 WifiConfigurationUtil.createPnoNetwork(network); 1063 assertEquals(network.SSID, pnoNetwork.ssid); 1064 assertEquals( 1065 WifiScanner.PnoSettings.PnoNetwork.FLAG_A_BAND 1066 | WifiScanner.PnoSettings.PnoNetwork.FLAG_G_BAND, pnoNetwork.flags); 1067 assertEquals(WifiScanner.PnoSettings.PnoNetwork.AUTH_CODE_EAPOL, pnoNetwork.authBitField); 1068 } 1069 1070 /** 1071 * Verify that the generalized 1072 * {@link com.android.server.wifi.WifiConfigurationUtil.WifiConfigurationComparator} 1073 * can be used to sort a List given a 'compareNetworkWithSameStatus' method. 1074 */ 1075 @Test testPnoListComparator()1076 public void testPnoListComparator() { 1077 List<WifiConfiguration> networks = new ArrayList<>(); 1078 final WifiConfiguration enabledNetwork1 = WifiConfigurationTestUtil.createEapNetwork(); 1079 enabledNetwork1.getNetworkSelectionStatus().setNetworkSelectionStatus( 1080 WifiConfiguration.NetworkSelectionStatus.NETWORK_SELECTION_ENABLED); 1081 final WifiConfiguration enabledNetwork2 = WifiConfigurationTestUtil.createEapNetwork(); 1082 enabledNetwork2.getNetworkSelectionStatus().setNetworkSelectionStatus( 1083 WifiConfiguration.NetworkSelectionStatus.NETWORK_SELECTION_ENABLED); 1084 final WifiConfiguration tempDisabledNetwork1 = WifiConfigurationTestUtil.createEapNetwork(); 1085 tempDisabledNetwork1.getNetworkSelectionStatus().setNetworkSelectionStatus( 1086 WifiConfiguration.NetworkSelectionStatus.NETWORK_SELECTION_TEMPORARY_DISABLED); 1087 final WifiConfiguration tempDisabledNetwork2 = WifiConfigurationTestUtil.createEapNetwork(); 1088 tempDisabledNetwork2.getNetworkSelectionStatus().setNetworkSelectionStatus( 1089 WifiConfiguration.NetworkSelectionStatus.NETWORK_SELECTION_TEMPORARY_DISABLED); 1090 WifiConfiguration permDisabledNetwork = WifiConfigurationTestUtil.createEapNetwork(); 1091 permDisabledNetwork.getNetworkSelectionStatus().setNetworkSelectionStatus( 1092 WifiConfiguration.NetworkSelectionStatus.NETWORK_SELECTION_PERMANENTLY_DISABLED); 1093 1094 // Add all the networks to the list. 1095 networks.add(tempDisabledNetwork1); 1096 networks.add(enabledNetwork1); 1097 networks.add(permDisabledNetwork); 1098 networks.add(tempDisabledNetwork2); 1099 networks.add(enabledNetwork2); 1100 1101 // Prefer |enabledNetwork1| over |enabledNetwork2| and |tempDisabledNetwork1| over 1102 // |tempDisabledNetwork2|. 1103 WifiConfigurationUtil.WifiConfigurationComparator comparator = 1104 new WifiConfigurationUtil.WifiConfigurationComparator() { 1105 @Override 1106 public int compareNetworksWithSameStatus( 1107 WifiConfiguration a, WifiConfiguration b) { 1108 if (a == enabledNetwork1 && b == enabledNetwork2) { 1109 return -1; 1110 } else if (b == enabledNetwork1 && a == enabledNetwork2) { 1111 return 1; 1112 } else if (a == tempDisabledNetwork1 && b == tempDisabledNetwork2) { 1113 return -1; 1114 } else if (b == tempDisabledNetwork1 && a == tempDisabledNetwork2) { 1115 return 1; 1116 } 1117 return 0; 1118 } 1119 }; 1120 Collections.sort(networks, comparator); 1121 1122 // Now ensure that the networks were sorted correctly. 1123 assertEquals(enabledNetwork1, networks.get(0)); 1124 assertEquals(enabledNetwork2, networks.get(1)); 1125 assertEquals(tempDisabledNetwork1, networks.get(2)); 1126 assertEquals(tempDisabledNetwork2, networks.get(3)); 1127 assertEquals(permDisabledNetwork, networks.get(4)); 1128 } 1129 1130 /** 1131 * Verifies that when the existing configuration is null and macRandomizationSetting in the 1132 * newConfig is the default value, then hasMacRandomizationSettingsChanged returns false. 1133 */ 1134 @Test testHasMacRandomizationSettingsChangedNullExistingConfigDefaultNewConfig()1135 public void testHasMacRandomizationSettingsChangedNullExistingConfigDefaultNewConfig() { 1136 WifiConfiguration newConfig = new WifiConfiguration(); 1137 assertFalse(WifiConfigurationUtil.hasMacRandomizationSettingsChanged(null, newConfig)); 1138 } 1139 1140 /** 1141 * Verifies that when the existing configuration is null and macRandomizationSetting in the 1142 * newConfig is not the default value, then hasMacRandomizationSettingsChanged returns true. 1143 */ 1144 @Test testHasMacRandomizationSettingsChangedNullExistingConfigModifiedNewConfig()1145 public void testHasMacRandomizationSettingsChangedNullExistingConfigModifiedNewConfig() { 1146 WifiConfiguration newConfig = new WifiConfiguration(); 1147 newConfig.macRandomizationSetting = WifiConfiguration.RANDOMIZATION_NONE; 1148 assertTrue(WifiConfigurationUtil.hasMacRandomizationSettingsChanged(null, newConfig)); 1149 } 1150 1151 /** 1152 * Verifies that when macRandomizationSetting in the newConfig is different from existingConfig 1153 * hasMacRandomizationSettingsChanged returns true. 1154 */ 1155 @Test testHasMacRandomizationSettingsChangedFieldsDifferent()1156 public void testHasMacRandomizationSettingsChangedFieldsDifferent() { 1157 WifiConfiguration existingConfig = new WifiConfiguration(); 1158 WifiConfiguration newConfig = new WifiConfiguration(); 1159 newConfig.macRandomizationSetting = WifiConfiguration.RANDOMIZATION_NONE; 1160 assertTrue(WifiConfigurationUtil.hasMacRandomizationSettingsChanged( 1161 existingConfig, newConfig)); 1162 } 1163 1164 /** 1165 * Verifies that when macRandomizationSetting in the newConfig is the same as existingConfig 1166 * hasMacRandomizationSettingsChanged returns false. 1167 */ 1168 @Test testHasMacRandomizationSettingsChangedFieldsSame()1169 public void testHasMacRandomizationSettingsChangedFieldsSame() { 1170 WifiConfiguration existingConfig = new WifiConfiguration(); 1171 existingConfig.macRandomizationSetting = WifiConfiguration.RANDOMIZATION_NONE; 1172 WifiConfiguration newConfig = new WifiConfiguration(); 1173 newConfig.macRandomizationSetting = WifiConfiguration.RANDOMIZATION_NONE; 1174 assertFalse(WifiConfigurationUtil.hasMacRandomizationSettingsChanged( 1175 existingConfig, newConfig)); 1176 } 1177 1178 private static class EnterpriseConfig { 1179 public String eap; 1180 public String phase2; 1181 public String identity; 1182 public String password; 1183 public X509Certificate[] caCerts; 1184 public WifiEnterpriseConfig enterpriseConfig; 1185 public String wapiCertSuite; 1186 EnterpriseConfig(int eapMethod)1187 EnterpriseConfig(int eapMethod) { 1188 enterpriseConfig = new WifiEnterpriseConfig(); 1189 enterpriseConfig.setEapMethod(eapMethod); 1190 eap = WifiEnterpriseConfig.Eap.strings[eapMethod]; 1191 } 1192 setPhase2(int phase2Method)1193 public EnterpriseConfig setPhase2(int phase2Method) { 1194 enterpriseConfig.setPhase2Method(phase2Method); 1195 phase2 = "auth=" + WifiEnterpriseConfig.Phase2.strings[phase2Method]; 1196 return this; 1197 } 1198 setIdentity(String identity, String password)1199 public EnterpriseConfig setIdentity(String identity, String password) { 1200 enterpriseConfig.setIdentity(identity); 1201 enterpriseConfig.setPassword(password); 1202 this.identity = identity; 1203 this.password = password; 1204 return this; 1205 } 1206 setCaCerts(X509Certificate[] certs)1207 public EnterpriseConfig setCaCerts(X509Certificate[] certs) { 1208 enterpriseConfig.setCaCertificates(certs); 1209 caCerts = certs; 1210 return this; 1211 } 1212 setWapiCertSuite(String certSuite)1213 public EnterpriseConfig setWapiCertSuite(String certSuite) { 1214 enterpriseConfig.setWapiCertSuite(certSuite); 1215 wapiCertSuite = certSuite; 1216 return this; 1217 } 1218 } 1219 1220 /** 1221 * Verify WifiEnterpriseConfig CA Certificate alias changes are detected. 1222 */ 1223 @Test testCaCertificateAliasChangesDetected()1224 public void testCaCertificateAliasChangesDetected() { 1225 EnterpriseConfig eapConfig1 = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS) 1226 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2) 1227 .setIdentity("username", "password"); 1228 eapConfig1.enterpriseConfig.setCaCertificateAlias("ALIAS_1"); 1229 1230 EnterpriseConfig eapConfig2 = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS) 1231 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2) 1232 .setIdentity("username", "password"); 1233 eapConfig2.enterpriseConfig.setCaCertificateAlias("ALIAS_2"); 1234 1235 assertTrue(WifiConfigurationUtil.hasEnterpriseConfigChanged(eapConfig1.enterpriseConfig, 1236 eapConfig2.enterpriseConfig)); 1237 } 1238 1239 /** 1240 * Verify WifiEnterpriseConfig Client Certificate alias changes are detected. 1241 */ 1242 @Test testClientCertificateAliasChangesDetected()1243 public void testClientCertificateAliasChangesDetected() { 1244 EnterpriseConfig eapConfig1 = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TLS); 1245 eapConfig1.enterpriseConfig.setCaCertificateAlias("ALIAS_1"); 1246 eapConfig1.enterpriseConfig.setClientCertificateAlias("CLIENT_ALIAS_1"); 1247 1248 EnterpriseConfig eapConfig2 = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS); 1249 eapConfig2.enterpriseConfig.setCaCertificateAlias("ALIAS_1"); 1250 eapConfig2.enterpriseConfig.setClientCertificateAlias("CLIENT_ALIAS_2"); 1251 1252 assertTrue(WifiConfigurationUtil.hasEnterpriseConfigChanged(eapConfig1.enterpriseConfig, 1253 eapConfig2.enterpriseConfig)); 1254 } 1255 1256 /** 1257 * Verify WifiEnterpriseConfig OCSP changes are detected. 1258 */ 1259 @Test testOcspChangesDetected()1260 public void testOcspChangesDetected() { 1261 EnterpriseConfig eapConfig1 = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS) 1262 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2) 1263 .setIdentity("username", "password") 1264 .setCaCerts(new X509Certificate[]{FakeKeys.CA_CERT0}); 1265 eapConfig1.enterpriseConfig.setOcsp(OCSP_NONE); 1266 1267 EnterpriseConfig eapConfig2 = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS) 1268 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2) 1269 .setIdentity("username", "password") 1270 .setCaCerts(new X509Certificate[]{FakeKeys.CA_CERT0}); 1271 eapConfig2.enterpriseConfig.setOcsp(OCSP_REQUIRE_CERT_STATUS); 1272 1273 assertTrue(WifiConfigurationUtil.hasEnterpriseConfigChanged(eapConfig1.enterpriseConfig, 1274 eapConfig2.enterpriseConfig)); 1275 } 1276 1277 /** 1278 * Verify WifiEnterpriseConfig subject match changes are detected. 1279 */ 1280 @Test testSubjectMatchChangesDetected()1281 public void testSubjectMatchChangesDetected() { 1282 EnterpriseConfig eapConfig1 = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS) 1283 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2) 1284 .setIdentity("username", "password") 1285 .setCaCerts(new X509Certificate[]{FakeKeys.CA_CERT0}); 1286 eapConfig1.enterpriseConfig.setAltSubjectMatch("domain1.com"); 1287 1288 EnterpriseConfig eapConfig2 = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS) 1289 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2) 1290 .setIdentity("username", "password") 1291 .setCaCerts(new X509Certificate[]{FakeKeys.CA_CERT0}); 1292 eapConfig1.enterpriseConfig.setAltSubjectMatch("domain2.com"); 1293 1294 assertTrue(WifiConfigurationUtil.hasEnterpriseConfigChanged(eapConfig1.enterpriseConfig, 1295 eapConfig2.enterpriseConfig)); 1296 } 1297 1298 /** 1299 * Verify that new WifiEnterpriseConfig is detected. 1300 */ 1301 @Test testEnterpriseConfigWapiCertChanged()1302 public void testEnterpriseConfigWapiCertChanged() { 1303 EnterpriseConfig eapConfig1 = new EnterpriseConfig(WifiEnterpriseConfig.Eap.WAPI_CERT) 1304 .setWapiCertSuite("WapiCertSuite1"); 1305 EnterpriseConfig eapConfig2 = new EnterpriseConfig(WifiEnterpriseConfig.Eap.WAPI_CERT) 1306 .setWapiCertSuite("WapiCertSuite2"); 1307 1308 assertTrue(WifiConfigurationUtil.hasEnterpriseConfigChanged( 1309 eapConfig1.enterpriseConfig, eapConfig2.enterpriseConfig)); 1310 } 1311 1312 /** 1313 * Verify that a WAPI config is not considered an OPEN config. 1314 */ 1315 @Test testWapiConfigNotOpenConfig()1316 public void testWapiConfigNotOpenConfig() { 1317 WifiConfiguration wapiPskConfig = new WifiConfiguration(); 1318 wapiPskConfig.setSecurityParams(WifiConfiguration.SECURITY_TYPE_WAPI_CERT); 1319 assertFalse(WifiConfigurationUtil.isConfigForOpenNetwork(wapiPskConfig)); 1320 1321 WifiConfiguration wapiCertConfig = new WifiConfiguration(); 1322 wapiCertConfig.setSecurityParams(WifiConfiguration.SECURITY_TYPE_WAPI_CERT); 1323 assertFalse(WifiConfigurationUtil.isConfigForOpenNetwork(wapiCertConfig)); 1324 } 1325 1326 /** 1327 * Verify that a Passpoint config is not considered an OPEN config. 1328 */ 1329 @Test testPasspointConfigNotOpenConfig()1330 public void testPasspointConfigNotOpenConfig() { 1331 WifiConfiguration passpointR1R2Config = new WifiConfiguration(); 1332 passpointR1R2Config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PASSPOINT_R1_R2); 1333 assertFalse(WifiConfigurationUtil.isConfigForOpenNetwork(passpointR1R2Config)); 1334 1335 WifiConfiguration passpointR3Config = new WifiConfiguration(); 1336 passpointR3Config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PASSPOINT_R3); 1337 assertFalse(WifiConfigurationUtil.isConfigForOpenNetwork(passpointR3Config)); 1338 } 1339 1340 /** 1341 * Verify that the validate method fails to validate WifiConfiguration with malformed 1342 * enterprise configuration 1343 */ 1344 @Test testValidateNegativeCases_MalformedEnterpriseConfig()1345 public void testValidateNegativeCases_MalformedEnterpriseConfig() { 1346 WifiConfiguration config = new WifiConfiguration(); 1347 config.SSID = "\"someNetwork\""; 1348 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP); 1349 // EAP method is kept as Eap.NONE - should not crash, but return invalid ID 1350 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 1351 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 1352 1353 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE); 1354 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 1355 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 1356 1357 config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT); 1358 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 1359 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 1360 } 1361 1362 /** 1363 * Verify that the validate method fails to validate WifiConfiguration with enterprise 1364 * configuration that is missing the identity and/or password. 1365 */ 1366 @Test testValidateNegativeCases_NoIdentityOrPasswordEnterpriseConfig()1367 public void testValidateNegativeCases_NoIdentityOrPasswordEnterpriseConfig() { 1368 WifiConfiguration config = WifiConfigurationTestUtil.createEapNetwork(); 1369 config.enterpriseConfig.setIdentity(null); 1370 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 1371 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 1372 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 1373 WifiConfigurationUtil.VALIDATE_FOR_UPDATE)); 1374 1375 config = WifiConfigurationTestUtil.createEapNetwork(); 1376 config.enterpriseConfig.setPassword(null); 1377 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 1378 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 1379 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 1380 WifiConfigurationUtil.VALIDATE_FOR_UPDATE)); 1381 1382 config = WifiConfigurationTestUtil.createWpa3EnterpriseNetwork(TEST_SSID); 1383 config.enterpriseConfig.setIdentity(null); 1384 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 1385 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 1386 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 1387 WifiConfigurationUtil.VALIDATE_FOR_UPDATE)); 1388 1389 config = WifiConfigurationTestUtil.createWpa3EnterpriseNetwork(TEST_SSID); 1390 config.enterpriseConfig.setPassword(null); 1391 assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 1392 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 1393 assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL, 1394 WifiConfigurationUtil.VALIDATE_FOR_UPDATE)); 1395 } 1396 1397 /** 1398 * Verify that the validate method fails to validate WifiConfiguration with DPP AKM 1399 * security type if DPP AKM is not supported by the device, and succeeds if it is supported. 1400 */ 1401 @Test testValidateSecurityTypeDppAkm()1402 public void testValidateSecurityTypeDppAkm() { 1403 long supportedFeatures = SUPPORTED_FEATURES_ALL & ~WifiManager.WIFI_FEATURE_DPP_AKM; 1404 WifiConfiguration config = WifiConfigurationTestUtil.createOpenNetwork(); 1405 config.setSecurityParams(WifiInfo.SECURITY_TYPE_DPP); 1406 1407 assertFalse(WifiConfigurationUtil.validate(config, supportedFeatures, 1408 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 1409 assertFalse(WifiConfigurationUtil.validate(config, supportedFeatures, 1410 WifiConfigurationUtil.VALIDATE_FOR_UPDATE)); 1411 1412 supportedFeatures = WifiManager.WIFI_FEATURE_DPP_AKM; 1413 assertTrue(WifiConfigurationUtil.validate(config, supportedFeatures, 1414 WifiConfigurationUtil.VALIDATE_FOR_ADD)); 1415 assertTrue(WifiConfigurationUtil.validate(config, supportedFeatures, 1416 WifiConfigurationUtil.VALIDATE_FOR_UPDATE)); 1417 } 1418 } 1419