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