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 17package com.android.server.wifi; 18 19import static org.junit.Assert.*; 20import static org.mockito.Mockito.*; 21 22import android.net.wifi.WifiConfiguration; 23import android.os.Process; 24import android.test.suitebuilder.annotation.SmallTest; 25 26import com.android.server.net.IpConfigStore; 27import com.android.server.wifi.util.WifiPermissionsUtil; 28 29import org.junit.After; 30import org.junit.Before; 31import org.junit.Test; 32import org.mockito.Mock; 33import org.mockito.MockitoAnnotations; 34 35import java.io.ByteArrayOutputStream; 36import java.io.DataOutputStream; 37import java.io.FileDescriptor; 38import java.io.IOException; 39import java.io.OutputStreamWriter; 40import java.io.PrintWriter; 41import java.io.StringWriter; 42import java.util.ArrayList; 43import java.util.HashMap; 44import java.util.List; 45import java.util.Map; 46import java.util.Random; 47 48/** 49 * Unit tests for {@link com.android.server.wifi.WifiBackupRestore}. 50 */ 51@SmallTest 52public class WifiBackupRestoreTest { 53 54 @Mock WifiPermissionsUtil mWifiPermissionsUtil; 55 private WifiBackupRestore mWifiBackupRestore; 56 private boolean mCheckDump = true; 57 58 @Before 59 public void setUp() throws Exception { 60 MockitoAnnotations.initMocks(this); 61 when(mWifiPermissionsUtil.checkConfigOverridePermission(anyInt())).thenReturn(true); 62 mWifiBackupRestore = new WifiBackupRestore(mWifiPermissionsUtil); 63 // Enable verbose logging before tests to check the backup data dumps. 64 mWifiBackupRestore.enableVerboseLogging(1); 65 } 66 67 @After 68 public void cleanUp() throws Exception { 69 if (mCheckDump) { 70 StringWriter stringWriter = new StringWriter(); 71 mWifiBackupRestore.dump( 72 new FileDescriptor(), new PrintWriter(stringWriter), new String[0]); 73 String dumpString = stringWriter.toString(); 74 // Ensure that the SSID was dumped out. 75 assertTrue("Dump: " + dumpString, 76 dumpString.contains(WifiConfigurationTestUtil.TEST_SSID)); 77 // Ensure that the password wasn't dumped out. 78 assertFalse("Dump: " + dumpString, 79 dumpString.contains(WifiConfigurationTestUtil.TEST_PSK)); 80 assertFalse("Dump: " + dumpString, 81 dumpString.contains(WifiConfigurationTestUtil.TEST_WEP_KEYS[0])); 82 assertFalse("Dump: " + dumpString, 83 dumpString.contains(WifiConfigurationTestUtil.TEST_WEP_KEYS[1])); 84 assertFalse("Dump: " + dumpString, 85 dumpString.contains(WifiConfigurationTestUtil.TEST_WEP_KEYS[2])); 86 assertFalse("Dump: " + dumpString, 87 dumpString.contains(WifiConfigurationTestUtil.TEST_WEP_KEYS[3])); 88 } 89 } 90 91 /** 92 * Verify that a null network list is serialized correctly. 93 */ 94 @Test 95 public void testNullNetworkListBackup() { 96 byte[] backupData = mWifiBackupRestore.retrieveBackupDataFromConfigurations(null); 97 assertTrue(backupData != null); 98 assertEquals(backupData.length, 0); 99 // No valid data to check in dump. 100 mCheckDump = false; 101 } 102 103 /** 104 * Verify that a single open network configuration is serialized & deserialized correctly. 105 */ 106 @Test 107 public void testSingleOpenNetworkBackupRestore() { 108 List<WifiConfiguration> configurations = new ArrayList<>(); 109 configurations.add(WifiConfigurationTestUtil.createOpenNetwork()); 110 111 byte[] backupData = mWifiBackupRestore.retrieveBackupDataFromConfigurations(configurations); 112 List<WifiConfiguration> retrievedConfigurations = 113 mWifiBackupRestore.retrieveConfigurationsFromBackupData(backupData); 114 WifiConfigurationTestUtil.assertConfigurationsEqualForBackup( 115 configurations, retrievedConfigurations); 116 } 117 118 /** 119 * Verify that a single open hidden network configuration is serialized & deserialized 120 * correctly. 121 */ 122 @Test 123 public void testSingleOpenHiddenNetworkBackupRestore() { 124 List<WifiConfiguration> configurations = new ArrayList<>(); 125 configurations.add(WifiConfigurationTestUtil.createOpenHiddenNetwork()); 126 127 byte[] backupData = mWifiBackupRestore.retrieveBackupDataFromConfigurations(configurations); 128 List<WifiConfiguration> retrievedConfigurations = 129 mWifiBackupRestore.retrieveConfigurationsFromBackupData(backupData); 130 WifiConfigurationTestUtil.assertConfigurationsEqualForBackup( 131 configurations, retrievedConfigurations); 132 } 133 134 /** 135 * Verify that a single PSK network configuration is serialized & deserialized correctly. 136 */ 137 @Test 138 public void testSinglePskNetworkBackupRestore() { 139 List<WifiConfiguration> configurations = new ArrayList<>(); 140 configurations.add(WifiConfigurationTestUtil.createPskNetwork()); 141 142 byte[] backupData = mWifiBackupRestore.retrieveBackupDataFromConfigurations(configurations); 143 List<WifiConfiguration> retrievedConfigurations = 144 mWifiBackupRestore.retrieveConfigurationsFromBackupData(backupData); 145 WifiConfigurationTestUtil.assertConfigurationsEqualForBackup( 146 configurations, retrievedConfigurations); 147 } 148 149 /** 150 * Verify that a single PSK hidden network configuration is serialized & deserialized correctly. 151 */ 152 @Test 153 public void testSinglePskHiddenNetworkBackupRestore() { 154 List<WifiConfiguration> configurations = new ArrayList<>(); 155 configurations.add(WifiConfigurationTestUtil.createPskHiddenNetwork()); 156 157 byte[] backupData = mWifiBackupRestore.retrieveBackupDataFromConfigurations(configurations); 158 List<WifiConfiguration> retrievedConfigurations = 159 mWifiBackupRestore.retrieveConfigurationsFromBackupData(backupData); 160 WifiConfigurationTestUtil.assertConfigurationsEqualForBackup( 161 configurations, retrievedConfigurations); 162 } 163 164 /** 165 * Verify that a single WEP network configuration is serialized & deserialized correctly. 166 */ 167 @Test 168 public void testSingleWepNetworkBackupRestore() { 169 List<WifiConfiguration> configurations = new ArrayList<>(); 170 configurations.add(WifiConfigurationTestUtil.createWepNetwork()); 171 172 byte[] backupData = mWifiBackupRestore.retrieveBackupDataFromConfigurations(configurations); 173 List<WifiConfiguration> retrievedConfigurations = 174 mWifiBackupRestore.retrieveConfigurationsFromBackupData(backupData); 175 WifiConfigurationTestUtil.assertConfigurationsEqualForBackup( 176 configurations, retrievedConfigurations); 177 } 178 179 /** 180 * Verify that a single WEP network configuration with only 1 key is serialized & deserialized 181 * correctly. 182 */ 183 @Test 184 public void testSingleWepNetworkWithSingleKeyBackupRestore() { 185 List<WifiConfiguration> configurations = new ArrayList<>(); 186 configurations.add(WifiConfigurationTestUtil.createWepNetworkWithSingleKey()); 187 188 byte[] backupData = mWifiBackupRestore.retrieveBackupDataFromConfigurations(configurations); 189 List<WifiConfiguration> retrievedConfigurations = 190 mWifiBackupRestore.retrieveConfigurationsFromBackupData(backupData); 191 WifiConfigurationTestUtil.assertConfigurationsEqualForBackup( 192 configurations, retrievedConfigurations); 193 } 194 195 /** 196 * Verify that a single enterprise network configuration is not serialized. 197 */ 198 @Test 199 public void testSingleEnterpriseNetworkNotBackupRestore() { 200 List<WifiConfiguration> configurations = new ArrayList<>(); 201 configurations.add(WifiConfigurationTestUtil.createEapNetwork()); 202 203 byte[] backupData = mWifiBackupRestore.retrieveBackupDataFromConfigurations(configurations); 204 List<WifiConfiguration> retrievedConfigurations = 205 mWifiBackupRestore.retrieveConfigurationsFromBackupData(backupData); 206 assertTrue(retrievedConfigurations.isEmpty()); 207 // No valid data to check in dump. 208 mCheckDump = false; 209 } 210 211 /** 212 * Verify that a single PSK network configuration with static ip/proxy settings is serialized & 213 * deserialized correctly. 214 */ 215 @Test 216 public void testSinglePskNetworkWithStaticIpAndStaticProxyBackupRestore() { 217 List<WifiConfiguration> configurations = new ArrayList<>(); 218 WifiConfiguration pskNetwork = WifiConfigurationTestUtil.createPskNetwork(); 219 pskNetwork.setIpConfiguration( 220 WifiConfigurationTestUtil.createStaticIpConfigurationWithStaticProxy()); 221 configurations.add(pskNetwork); 222 223 byte[] backupData = mWifiBackupRestore.retrieveBackupDataFromConfigurations(configurations); 224 List<WifiConfiguration> retrievedConfigurations = 225 mWifiBackupRestore.retrieveConfigurationsFromBackupData(backupData); 226 WifiConfigurationTestUtil.assertConfigurationsEqualForBackup( 227 configurations, retrievedConfigurations); 228 } 229 230 /** 231 * Verify that a single PSK network configuration with static ip & PAC proxy settings is 232 * serialized & deserialized correctly. 233 */ 234 @Test 235 public void testSinglePskNetworkWithStaticIpAndPACProxyBackupRestore() { 236 List<WifiConfiguration> configurations = new ArrayList<>(); 237 WifiConfiguration pskNetwork = WifiConfigurationTestUtil.createPskNetwork(); 238 pskNetwork.setIpConfiguration( 239 WifiConfigurationTestUtil.createStaticIpConfigurationWithPacProxy()); 240 configurations.add(pskNetwork); 241 242 byte[] backupData = mWifiBackupRestore.retrieveBackupDataFromConfigurations(configurations); 243 List<WifiConfiguration> retrievedConfigurations = 244 mWifiBackupRestore.retrieveConfigurationsFromBackupData(backupData); 245 WifiConfigurationTestUtil.assertConfigurationsEqualForBackup( 246 configurations, retrievedConfigurations); 247 } 248 249 /** 250 * Verify that a single PSK network configuration with DHCP ip & PAC proxy settings is 251 * serialized & deserialized correctly. 252 */ 253 @Test 254 public void testSinglePskNetworkWithDHCPIpAndPACProxyBackupRestore() { 255 List<WifiConfiguration> configurations = new ArrayList<>(); 256 WifiConfiguration pskNetwork = WifiConfigurationTestUtil.createPskNetwork(); 257 pskNetwork.setIpConfiguration( 258 WifiConfigurationTestUtil.createDHCPIpConfigurationWithPacProxy()); 259 configurations.add(pskNetwork); 260 261 byte[] backupData = mWifiBackupRestore.retrieveBackupDataFromConfigurations(configurations); 262 List<WifiConfiguration> retrievedConfigurations = 263 mWifiBackupRestore.retrieveConfigurationsFromBackupData(backupData); 264 WifiConfigurationTestUtil.assertConfigurationsEqualForBackup( 265 configurations, retrievedConfigurations); 266 } 267 268 /** 269 * Verify that a single PSK network configuration with partial static ip settings is serialized 270 * & deserialized correctly. 271 */ 272 @Test 273 public void testSinglePskNetworkWithPartialStaticIpBackupRestore() { 274 List<WifiConfiguration> configurations = new ArrayList<>(); 275 WifiConfiguration pskNetwork = WifiConfigurationTestUtil.createPskNetwork(); 276 pskNetwork.setIpConfiguration( 277 WifiConfigurationTestUtil.createPartialStaticIpConfigurationWithPacProxy()); 278 configurations.add(pskNetwork); 279 280 byte[] backupData = mWifiBackupRestore.retrieveBackupDataFromConfigurations(configurations); 281 List<WifiConfiguration> retrievedConfigurations = 282 mWifiBackupRestore.retrieveConfigurationsFromBackupData(backupData); 283 WifiConfigurationTestUtil.assertConfigurationsEqualForBackup( 284 configurations, retrievedConfigurations); 285 } 286 287 /** 288 * Verify that multiple networks of different types are serialized and deserialized correctly. 289 */ 290 @Test 291 public void testMultipleNetworksAllBackupRestore() { 292 List<WifiConfiguration> configurations = new ArrayList<>(); 293 configurations.add(WifiConfigurationTestUtil.createWepNetwork()); 294 configurations.add(WifiConfigurationTestUtil.createWepNetwork()); 295 configurations.add(WifiConfigurationTestUtil.createPskNetwork()); 296 configurations.add(WifiConfigurationTestUtil.createOpenNetwork()); 297 298 byte[] backupData = mWifiBackupRestore.retrieveBackupDataFromConfigurations(configurations); 299 List<WifiConfiguration> retrievedConfigurations = 300 mWifiBackupRestore.retrieveConfigurationsFromBackupData(backupData); 301 WifiConfigurationTestUtil.assertConfigurationsEqualForBackup( 302 configurations, retrievedConfigurations); 303 } 304 305 /** 306 * Verify that multiple networks of different types except enterprise ones are serialized and 307 * deserialized correctly 308 */ 309 @Test 310 public void testMultipleNetworksNonEnterpriseBackupRestore() { 311 List<WifiConfiguration> configurations = new ArrayList<>(); 312 List<WifiConfiguration> expectedConfigurations = new ArrayList<>(); 313 314 WifiConfiguration wepNetwork = WifiConfigurationTestUtil.createWepNetwork(); 315 configurations.add(wepNetwork); 316 expectedConfigurations.add(wepNetwork); 317 318 configurations.add(WifiConfigurationTestUtil.createEapNetwork()); 319 320 WifiConfiguration pskNetwork = WifiConfigurationTestUtil.createPskNetwork(); 321 configurations.add(pskNetwork); 322 expectedConfigurations.add(pskNetwork); 323 324 WifiConfiguration openNetwork = WifiConfigurationTestUtil.createOpenNetwork(); 325 configurations.add(openNetwork); 326 expectedConfigurations.add(openNetwork); 327 328 byte[] backupData = mWifiBackupRestore.retrieveBackupDataFromConfigurations(configurations); 329 List<WifiConfiguration> retrievedConfigurations = 330 mWifiBackupRestore.retrieveConfigurationsFromBackupData(backupData); 331 WifiConfigurationTestUtil.assertConfigurationsEqualForBackup( 332 expectedConfigurations, retrievedConfigurations); 333 } 334 335 /** 336 * Verify that multiple networks with different credential types and IpConfiguration types are 337 * serialized and deserialized correctly. 338 */ 339 @Test 340 public void testMultipleNetworksWithDifferentIpConfigurationsAllBackupRestore() { 341 List<WifiConfiguration> configurations = new ArrayList<>(); 342 343 WifiConfiguration wepNetwork = WifiConfigurationTestUtil.createWepNetwork(); 344 wepNetwork.setIpConfiguration( 345 WifiConfigurationTestUtil.createDHCPIpConfigurationWithPacProxy()); 346 configurations.add(wepNetwork); 347 348 WifiConfiguration pskNetwork = WifiConfigurationTestUtil.createPskNetwork(); 349 pskNetwork.setIpConfiguration( 350 WifiConfigurationTestUtil.createStaticIpConfigurationWithPacProxy()); 351 configurations.add(pskNetwork); 352 353 WifiConfiguration openNetwork = WifiConfigurationTestUtil.createOpenNetwork(); 354 openNetwork.setIpConfiguration( 355 WifiConfigurationTestUtil.createStaticIpConfigurationWithStaticProxy()); 356 configurations.add(openNetwork); 357 358 byte[] backupData = mWifiBackupRestore.retrieveBackupDataFromConfigurations(configurations); 359 List<WifiConfiguration> retrievedConfigurations = 360 mWifiBackupRestore.retrieveConfigurationsFromBackupData(backupData); 361 WifiConfigurationTestUtil.assertConfigurationsEqualForBackup( 362 configurations, retrievedConfigurations); 363 } 364 365 /** 366 * Verify that multiple networks of different types except the non system app created ones are 367 * serialized and deserialized correctly. 368 */ 369 @Test 370 public void testMultipleNetworksSystemAppBackupRestore() { 371 int systemAppUid = Process.SYSTEM_UID; 372 int nonSystemAppUid = Process.FIRST_APPLICATION_UID + 556; 373 when(mWifiPermissionsUtil.checkConfigOverridePermission(eq(systemAppUid))) 374 .thenReturn(true); 375 when(mWifiPermissionsUtil.checkConfigOverridePermission(eq(nonSystemAppUid))) 376 .thenReturn(false); 377 378 List<WifiConfiguration> configurations = new ArrayList<>(); 379 List<WifiConfiguration> expectedConfigurations = new ArrayList<>(); 380 381 WifiConfiguration wepNetwork = WifiConfigurationTestUtil.createWepNetwork(); 382 wepNetwork.creatorUid = systemAppUid; 383 configurations.add(wepNetwork); 384 expectedConfigurations.add(wepNetwork); 385 386 // These should not be in |expectedConfigurations|. 387 WifiConfiguration nonSystemAppWepNetwork = WifiConfigurationTestUtil.createWepNetwork(); 388 nonSystemAppWepNetwork.creatorUid = nonSystemAppUid; 389 configurations.add(nonSystemAppWepNetwork); 390 391 WifiConfiguration pskNetwork = WifiConfigurationTestUtil.createPskNetwork(); 392 pskNetwork.creatorUid = systemAppUid; 393 configurations.add(pskNetwork); 394 expectedConfigurations.add(pskNetwork); 395 396 // These should not be in |expectedConfigurations|. 397 WifiConfiguration nonSystemAppPskNetwork = WifiConfigurationTestUtil.createPskNetwork(); 398 nonSystemAppPskNetwork.creatorUid = nonSystemAppUid; 399 configurations.add(nonSystemAppPskNetwork); 400 401 WifiConfiguration openNetwork = WifiConfigurationTestUtil.createOpenNetwork(); 402 configurations.add(openNetwork); 403 expectedConfigurations.add(openNetwork); 404 405 byte[] backupData = mWifiBackupRestore.retrieveBackupDataFromConfigurations(configurations); 406 List<WifiConfiguration> retrievedConfigurations = 407 mWifiBackupRestore.retrieveConfigurationsFromBackupData(backupData); 408 WifiConfigurationTestUtil.assertConfigurationsEqualForBackup( 409 expectedConfigurations, retrievedConfigurations); 410 } 411 412 /** 413 * Verify that a single open network configuration is serialized & deserialized correctly from 414 * old backups. 415 */ 416 @Test 417 public void testSingleOpenNetworkSupplicantBackupRestore() { 418 List<WifiConfiguration> configurations = new ArrayList<>(); 419 configurations.add(WifiConfigurationTestUtil.createOpenNetwork()); 420 421 byte[] supplicantData = createWpaSupplicantConfBackupData(configurations); 422 byte[] ipConfigData = createIpConfBackupData(configurations); 423 List<WifiConfiguration> retrievedConfigurations = 424 mWifiBackupRestore.retrieveConfigurationsFromSupplicantBackupData( 425 supplicantData, ipConfigData); 426 WifiConfigurationTestUtil.assertConfigurationsEqualForBackup( 427 configurations, retrievedConfigurations); 428 } 429 430 /** 431 * Verify that a single open hidden network configuration is serialized & deserialized 432 * correctly from old backups. 433 */ 434 @Test 435 public void testSingleOpenHiddenNetworkSupplicantBackupRestore() { 436 List<WifiConfiguration> configurations = new ArrayList<>(); 437 configurations.add(WifiConfigurationTestUtil.createOpenHiddenNetwork()); 438 439 byte[] supplicantData = createWpaSupplicantConfBackupData(configurations); 440 byte[] ipConfigData = createIpConfBackupData(configurations); 441 List<WifiConfiguration> retrievedConfigurations = 442 mWifiBackupRestore.retrieveConfigurationsFromSupplicantBackupData( 443 supplicantData, ipConfigData); 444 WifiConfigurationTestUtil.assertConfigurationsEqualForBackup( 445 configurations, retrievedConfigurations); 446 } 447 448 /** 449 * Verify that a single PSK network configuration is serialized & deserialized correctly from 450 * old backups. 451 */ 452 @Test 453 public void testSinglePskNetworkSupplicantBackupRestore() { 454 List<WifiConfiguration> configurations = new ArrayList<>(); 455 configurations.add(WifiConfigurationTestUtil.createPskNetwork()); 456 457 byte[] supplicantData = createWpaSupplicantConfBackupData(configurations); 458 byte[] ipConfigData = createIpConfBackupData(configurations); 459 List<WifiConfiguration> retrievedConfigurations = 460 mWifiBackupRestore.retrieveConfigurationsFromSupplicantBackupData( 461 supplicantData, ipConfigData); 462 WifiConfigurationTestUtil.assertConfigurationsEqualForBackup( 463 configurations, retrievedConfigurations); 464 } 465 466 /** 467 * Verify that a single PSK hidden network configuration is serialized & deserialized correctly 468 * from old backups. 469 */ 470 @Test 471 public void testSinglePskHiddenNetworkSupplicantBackupRestore() { 472 List<WifiConfiguration> configurations = new ArrayList<>(); 473 configurations.add(WifiConfigurationTestUtil.createPskHiddenNetwork()); 474 475 byte[] supplicantData = createWpaSupplicantConfBackupData(configurations); 476 byte[] ipConfigData = createIpConfBackupData(configurations); 477 List<WifiConfiguration> retrievedConfigurations = 478 mWifiBackupRestore.retrieveConfigurationsFromSupplicantBackupData( 479 supplicantData, ipConfigData); 480 WifiConfigurationTestUtil.assertConfigurationsEqualForBackup( 481 configurations, retrievedConfigurations); 482 } 483 484 /** 485 * Verify that a single WEP network configuration is serialized & deserialized correctly from 486 * old backups. 487 */ 488 @Test 489 public void testSingleWepNetworkSupplicantBackupRestore() { 490 List<WifiConfiguration> configurations = new ArrayList<>(); 491 configurations.add(WifiConfigurationTestUtil.createWepNetwork()); 492 493 byte[] supplicantData = createWpaSupplicantConfBackupData(configurations); 494 byte[] ipConfigData = createIpConfBackupData(configurations); 495 List<WifiConfiguration> retrievedConfigurations = 496 mWifiBackupRestore.retrieveConfigurationsFromSupplicantBackupData( 497 supplicantData, ipConfigData); 498 WifiConfigurationTestUtil.assertConfigurationsEqualForBackup( 499 configurations, retrievedConfigurations); 500 } 501 502 /** 503 * Verify that a single WEP network configuration with only 1 key is serialized & deserialized 504 * correctly from old backups. 505 */ 506 @Test 507 public void testSingleWepNetworkWithSingleKeySupplicantBackupRestore() { 508 List<WifiConfiguration> configurations = new ArrayList<>(); 509 configurations.add(WifiConfigurationTestUtil.createWepNetworkWithSingleKey()); 510 511 byte[] supplicantData = createWpaSupplicantConfBackupData(configurations); 512 byte[] ipConfigData = createIpConfBackupData(configurations); 513 List<WifiConfiguration> retrievedConfigurations = 514 mWifiBackupRestore.retrieveConfigurationsFromSupplicantBackupData( 515 supplicantData, ipConfigData); 516 WifiConfigurationTestUtil.assertConfigurationsEqualForBackup( 517 configurations, retrievedConfigurations); 518 } 519 520 /** 521 * Verify that a single enterprise network configuration is not serialized from old backups. 522 */ 523 @Test 524 public void testSingleEnterpriseNetworkNotSupplicantBackupRestore() { 525 List<WifiConfiguration> configurations = new ArrayList<>(); 526 configurations.add(WifiConfigurationTestUtil.createEapNetwork()); 527 528 byte[] supplicantData = createWpaSupplicantConfBackupData(configurations); 529 byte[] ipConfigData = createIpConfBackupData(configurations); 530 List<WifiConfiguration> retrievedConfigurations = 531 mWifiBackupRestore.retrieveConfigurationsFromSupplicantBackupData( 532 supplicantData, ipConfigData); 533 assertTrue(retrievedConfigurations.isEmpty()); 534 } 535 536 /** 537 * Verify that multiple networks with different credential types and IpConfiguration types are 538 * serialized and deserialized correctly from old backups 539 */ 540 @Test 541 public void testMultipleNetworksWithDifferentIpConfigurationsAllSupplicantBackupRestore() { 542 List<WifiConfiguration> configurations = new ArrayList<>(); 543 544 WifiConfiguration wepNetwork = WifiConfigurationTestUtil.createWepNetwork(); 545 wepNetwork.setIpConfiguration( 546 WifiConfigurationTestUtil.createDHCPIpConfigurationWithPacProxy()); 547 configurations.add(wepNetwork); 548 549 WifiConfiguration pskNetwork = WifiConfigurationTestUtil.createPskNetwork(); 550 pskNetwork.setIpConfiguration( 551 WifiConfigurationTestUtil.createStaticIpConfigurationWithPacProxy()); 552 configurations.add(pskNetwork); 553 554 WifiConfiguration openNetwork = WifiConfigurationTestUtil.createOpenNetwork(); 555 openNetwork.setIpConfiguration( 556 WifiConfigurationTestUtil.createStaticIpConfigurationWithStaticProxy()); 557 configurations.add(openNetwork); 558 559 byte[] supplicantData = createWpaSupplicantConfBackupData(configurations); 560 byte[] ipConfigData = createIpConfBackupData(configurations); 561 List<WifiConfiguration> retrievedConfigurations = 562 mWifiBackupRestore.retrieveConfigurationsFromSupplicantBackupData( 563 supplicantData, ipConfigData); 564 WifiConfigurationTestUtil.assertConfigurationsEqualForBackup( 565 configurations, retrievedConfigurations); 566 } 567 568 /** 569 * Verify that a single open network configuration is serialized & deserialized correctly from 570 * old backups with no ipconfig data. 571 */ 572 @Test 573 public void testSingleOpenNetworkSupplicantBackupRestoreWithNoIpConfigData() { 574 List<WifiConfiguration> configurations = new ArrayList<>(); 575 configurations.add(WifiConfigurationTestUtil.createOpenNetwork()); 576 577 byte[] supplicantData = createWpaSupplicantConfBackupData(configurations); 578 List<WifiConfiguration> retrievedConfigurations = 579 mWifiBackupRestore.retrieveConfigurationsFromSupplicantBackupData( 580 supplicantData, null); 581 WifiConfigurationTestUtil.assertConfigurationsEqualForBackup( 582 configurations, retrievedConfigurations); 583 } 584 585 /** 586 * Verify that multiple networks with different credential types are serialized and 587 * deserialized correctly from old backups with no ipconfig data. 588 */ 589 @Test 590 public void testMultipleNetworksAllSupplicantBackupRestoreWithNoIpConfigData() { 591 List<WifiConfiguration> configurations = new ArrayList<>(); 592 593 WifiConfiguration wepNetwork = WifiConfigurationTestUtil.createWepNetwork(); 594 configurations.add(wepNetwork); 595 596 WifiConfiguration pskNetwork = WifiConfigurationTestUtil.createPskNetwork(); 597 configurations.add(pskNetwork); 598 599 WifiConfiguration openNetwork = WifiConfigurationTestUtil.createOpenNetwork(); 600 configurations.add(openNetwork); 601 602 byte[] supplicantData = createWpaSupplicantConfBackupData(configurations); 603 List<WifiConfiguration> retrievedConfigurations = 604 mWifiBackupRestore.retrieveConfigurationsFromSupplicantBackupData( 605 supplicantData, null); 606 WifiConfigurationTestUtil.assertConfigurationsEqualForBackup( 607 configurations, retrievedConfigurations); 608 } 609 610 /** 611 * Verify that multiple networks of different types except the non system app created ones are 612 * serialized and deserialized correctly from old backups. 613 */ 614 @Test 615 public void testMultipleNetworksSystemAppSupplicantBackupRestore() { 616 List<WifiConfiguration> configurations = new ArrayList<>(); 617 List<WifiConfiguration> expectedConfigurations = new ArrayList<>(); 618 619 WifiConfiguration wepNetwork = WifiConfigurationTestUtil.createWepNetwork(); 620 configurations.add(wepNetwork); 621 expectedConfigurations.add(wepNetwork); 622 623 // These should not be in |expectedConfigurations|. 624 WifiConfiguration nonSystemAppWepNetwork = WifiConfigurationTestUtil.createWepNetwork(); 625 nonSystemAppWepNetwork.creatorUid = Process.FIRST_APPLICATION_UID; 626 configurations.add(nonSystemAppWepNetwork); 627 628 WifiConfiguration pskNetwork = WifiConfigurationTestUtil.createPskNetwork(); 629 configurations.add(pskNetwork); 630 expectedConfigurations.add(pskNetwork); 631 632 // These should not be in |expectedConfigurations|. 633 WifiConfiguration nonSystemAppPskNetwork = WifiConfigurationTestUtil.createPskNetwork(); 634 nonSystemAppPskNetwork.creatorUid = Process.FIRST_APPLICATION_UID + 1; 635 configurations.add(nonSystemAppPskNetwork); 636 637 WifiConfiguration openNetwork = WifiConfigurationTestUtil.createOpenNetwork(); 638 configurations.add(openNetwork); 639 expectedConfigurations.add(openNetwork); 640 641 byte[] supplicantData = createWpaSupplicantConfBackupData(configurations); 642 byte[] ipConfigData = createIpConfBackupData(configurations); 643 List<WifiConfiguration> retrievedConfigurations = 644 mWifiBackupRestore.retrieveConfigurationsFromSupplicantBackupData( 645 supplicantData, ipConfigData); 646 WifiConfigurationTestUtil.assertConfigurationsEqualForBackup( 647 expectedConfigurations, retrievedConfigurations); 648 } 649 650 /** 651 * Verifying that backup data containing some unknown keys is properly restored. 652 * The backup data used here is a PII masked version of a backup data seen in a reported bug. 653 */ 654 @Test 655 public void testSingleNetworkSupplicantBackupRestoreWithUnknownEAPKey() { 656 String backupSupplicantConfNetworkBlock = "network={\n" 657 + "ssid=" + WifiConfigurationTestUtil.TEST_SSID + "\n" 658 + "psk=" + WifiConfigurationTestUtil.TEST_PSK + "\n" 659 + "key_mgmt=WPA-PSK WPA-PSK-SHA256\n" 660 + "priority=18\n" 661 + "id_str=\"%7B%22creatorUid%22%3A%221000%22%2C%22configKey" 662 + "%22%3A%22%5C%22BLAH%5C%22WPA_PSK%22%7D\"\n" 663 + "eapRetryCount=6\n"; 664 byte[] supplicantData = backupSupplicantConfNetworkBlock.getBytes(); 665 List<WifiConfiguration> retrievedConfigurations = 666 mWifiBackupRestore.retrieveConfigurationsFromSupplicantBackupData( 667 supplicantData, null); 668 669 final WifiConfiguration expectedConfiguration = new WifiConfiguration(); 670 expectedConfiguration.SSID = WifiConfigurationTestUtil.TEST_SSID; 671 expectedConfiguration.preSharedKey = WifiConfigurationTestUtil.TEST_PSK; 672 expectedConfiguration.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK); 673 674 ArrayList<WifiConfiguration> expectedConfigurations = new ArrayList<WifiConfiguration>() {{ 675 add(expectedConfiguration); 676 }}; 677 WifiConfigurationTestUtil.assertConfigurationsEqualForBackup( 678 expectedConfigurations, retrievedConfigurations); 679 } 680 681 /** 682 * Verify that any corrupted data provided by Backup/Restore is ignored correctly. 683 */ 684 @Test 685 public void testCorruptBackupRestore() { 686 Random random = new Random(); 687 byte[] backupData = new byte[100]; 688 random.nextBytes(backupData); 689 690 List<WifiConfiguration> retrievedConfigurations = 691 mWifiBackupRestore.retrieveConfigurationsFromBackupData(backupData); 692 assertNull(retrievedConfigurations); 693 // No valid data to check in dump. 694 mCheckDump = false; 695 } 696 697 /** 698 * Helper method to write a list of networks in wpa_supplicant.conf format to the output stream. 699 */ 700 private byte[] createWpaSupplicantConfBackupData(List<WifiConfiguration> configurations) { 701 ByteArrayOutputStream bos = new ByteArrayOutputStream(); 702 OutputStreamWriter out = new OutputStreamWriter(bos); 703 try { 704 for (WifiConfiguration configuration : configurations) { 705 writeConfigurationToWpaSupplicantConf(out, configuration); 706 } 707 out.flush(); 708 return bos.toByteArray(); 709 } catch (IOException e) { 710 return null; 711 } 712 } 713 714 /** 715 * Helper method to write a network in wpa_supplicant.conf format to the output stream. 716 * This was created using a sample wpa_supplicant.conf file. Using the raw key strings here 717 * (instead of consts in WifiBackupRestore). 718 */ 719 private void writeConfigurationToWpaSupplicantConf( 720 OutputStreamWriter out, WifiConfiguration configuration) 721 throws IOException { 722 out.write("network={\n"); 723 out.write(" " + "ssid=" + configuration.SSID + "\n"); 724 String allowedKeyManagement = ""; 725 if (configuration.hiddenSSID) { 726 out.write(" " + "scan_ssid=1" + "\n"); 727 } 728 if (configuration.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.NONE)) { 729 allowedKeyManagement += "NONE"; 730 } 731 if (configuration.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.WPA_PSK)) { 732 allowedKeyManagement += "WPA-PSK "; 733 } 734 if (configuration.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.WPA_EAP)) { 735 allowedKeyManagement += "WPA-EAP "; 736 } 737 if (configuration.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.IEEE8021X)) { 738 allowedKeyManagement += "IEEE8021X "; 739 } 740 out.write(" " + "key_mgmt=" + allowedKeyManagement + "\n"); 741 if (configuration.preSharedKey != null) { 742 out.write(" " + "psk=" + configuration.preSharedKey + "\n"); 743 } 744 if (configuration.wepKeys[0] != null) { 745 out.write(" " + "wep_key0=" + configuration.wepKeys[0] + "\n"); 746 } 747 if (configuration.wepKeys[1] != null) { 748 out.write(" " + "wep_key1=" + configuration.wepKeys[1] + "\n"); 749 } 750 if (configuration.wepKeys[2] != null) { 751 out.write(" " + "wep_key2=" + configuration.wepKeys[2] + "\n"); 752 } 753 if (configuration.wepKeys[3] != null) { 754 out.write(" " + "wep_key3=" + configuration.wepKeys[3] + "\n"); 755 } 756 if (configuration.wepKeys[0] != null || configuration.wepKeys[1] != null 757 || configuration.wepKeys[2] != null || configuration.wepKeys[3] != null) { 758 out.write(" " + "wep_tx_keyidx=" + configuration.wepTxKeyIndex + "\n"); 759 } 760 Map<String, String> extras = new HashMap<>(); 761 extras.put(SupplicantStaNetworkHal.ID_STRING_KEY_CONFIG_KEY, configuration.configKey()); 762 extras.put(SupplicantStaNetworkHal.ID_STRING_KEY_CREATOR_UID, 763 Integer.toString(configuration.creatorUid)); 764 String idString = "\"" + SupplicantStaNetworkHal.createNetworkExtra(extras) + "\""; 765 if (idString != null) { 766 out.write(" " + "id_str=" + idString + "\n"); 767 } 768 out.write("}\n"); 769 out.write("\n"); 770 } 771 772 /** 773 * Helper method to write a list of networks in ipconfig.txt format to the output stream. 774 */ 775 private byte[] createIpConfBackupData(List<WifiConfiguration> configurations) { 776 ByteArrayOutputStream bos = new ByteArrayOutputStream(); 777 DataOutputStream out = new DataOutputStream(bos); 778 try { 779 // write version first. 780 out.writeInt(2); 781 for (WifiConfiguration configuration : configurations) { 782 IpConfigStore.writeConfig(out, configuration.configKey().hashCode(), 783 configuration.getIpConfiguration()); 784 } 785 out.flush(); 786 return bos.toByteArray(); 787 } catch (IOException e) { 788 return null; 789 } 790 } 791} 792