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