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