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