• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
17 package com.android.server.wifi;
18 
19 import static android.net.wifi.WifiEnterpriseConfig.OCSP_NONE;
20 import static android.net.wifi.WifiEnterpriseConfig.OCSP_REQUIRE_CERT_STATUS;
21 
22 import static org.junit.Assert.assertEquals;
23 import static org.junit.Assert.assertFalse;
24 import static org.junit.Assert.assertTrue;
25 import static org.junit.Assume.assumeTrue;
26 import static org.mockito.Mockito.when;
27 import static org.mockito.Mockito.withSettings;
28 
29 import android.content.pm.UserInfo;
30 import android.net.IpConfiguration;
31 import android.net.MacAddress;
32 import android.net.wifi.ScanResult;
33 import android.net.wifi.SecurityParams;
34 import android.net.wifi.WifiConfiguration;
35 import android.net.wifi.WifiEnterpriseConfig;
36 import android.net.wifi.WifiInfo;
37 import android.net.wifi.WifiManager;
38 import android.net.wifi.WifiNetworkSpecifier;
39 import android.net.wifi.WifiScanner;
40 import android.os.PatternMatcher;
41 import android.util.Pair;
42 
43 import androidx.test.filters.SmallTest;
44 
45 import com.android.dx.mockito.inline.extended.ExtendedMockito;
46 import com.android.modules.utils.build.SdkLevel;
47 
48 import org.junit.After;
49 import org.junit.Before;
50 import org.junit.Test;
51 import org.mockito.Mock;
52 import org.mockito.MockitoAnnotations;
53 import org.mockito.MockitoSession;
54 import org.mockito.quality.Strictness;
55 
56 import java.security.cert.X509Certificate;
57 import java.util.ArrayList;
58 import java.util.Arrays;
59 import java.util.Collections;
60 import java.util.List;
61 
62 /**
63  * Unit tests for {@link com.android.server.wifi.WifiConfigurationUtil}.
64  */
65 @SmallTest
66 public class WifiConfigurationUtilTest extends WifiBaseTest {
67     static final int CURRENT_USER_ID = 0;
68     static final int CURRENT_USER_MANAGED_PROFILE_USER_ID = 10;
69     static final int OTHER_USER_ID = 11;
70     static final int TEST_UID = 10000;
71     static final String TEST_PACKAGE = "com.test";
72     static final String TEST_SSID = "\"test_ssid\"";
73     static final String TEST_SSID_1 = "\"test_ssid_1\"";
74     static final String TEST_BSSID = "aa:aa:11:22:cc:dd";
75     static final String TEST_BSSID_1 = "11:22:11:22:cc:dd";
76     static final List<UserInfo> PROFILES = Arrays.asList(
77             new UserInfo(CURRENT_USER_ID, "owner", 0),
78             new UserInfo(CURRENT_USER_MANAGED_PROFILE_USER_ID, "managed profile", 0));
79     private static final long SUPPORTED_FEATURES_ALL = Long.MAX_VALUE;
80 
81     private MockitoSession mSession;
82 
83     @Mock
84     private WifiInjector mWifiInjector;
85     @Mock
86     private WifiGlobals mWifiGlobals;
87 
88     @Before
setUp()89     public void setUp() throws Exception {
90         MockitoAnnotations.initMocks(this);
91         // static mocking
92         mSession = ExtendedMockito.mockitoSession().strictness(Strictness.LENIENT)
93                 .mockStatic(WifiInjector.class, withSettings().lenient())
94                 .spyStatic(MacAddress.class)
95                 .startMocking();
96         when(WifiInjector.getInstance()).thenReturn(mWifiInjector);
97         when(mWifiInjector.getWifiGlobals()).thenReturn(mWifiGlobals);
98     }
99 
100     @After
cleanUp()101     public void cleanUp() throws Exception {
102         if (mSession != null) {
103             mSession.finishMocking();
104         }
105     }
106 
107     /**
108      * Verify that new WifiEnterpriseConfig is detected.
109      */
110     @Test
testEnterpriseConfigAdded()111     public void testEnterpriseConfigAdded() {
112         EnterpriseConfig eapConfig = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS)
113                 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2)
114                 .setIdentity("username", "password")
115                 .setCaCerts(new X509Certificate[]{FakeKeys.CA_CERT0});
116 
117         assertTrue(WifiConfigurationUtil.hasEnterpriseConfigChanged(
118                 null, eapConfig.enterpriseConfig));
119     }
120 
121     /**
122      * Verify WifiEnterpriseConfig eap change is detected.
123      */
124     @Test
testEnterpriseConfigEapChangeDetected()125     public void testEnterpriseConfigEapChangeDetected() {
126         EnterpriseConfig eapConfig = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS);
127         EnterpriseConfig peapConfig = new EnterpriseConfig(WifiEnterpriseConfig.Eap.PEAP);
128 
129         assertTrue(WifiConfigurationUtil.hasEnterpriseConfigChanged(eapConfig.enterpriseConfig,
130                 peapConfig.enterpriseConfig));
131     }
132 
133     /**
134      * Verify WifiEnterpriseConfig phase2 method change is detected.
135      */
136     @Test
testEnterpriseConfigPhase2ChangeDetected()137     public void testEnterpriseConfigPhase2ChangeDetected() {
138         EnterpriseConfig eapConfig =
139                 new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS)
140                         .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2);
141         EnterpriseConfig papConfig =
142                 new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS)
143                         .setPhase2(WifiEnterpriseConfig.Phase2.PAP);
144 
145         assertTrue(WifiConfigurationUtil.hasEnterpriseConfigChanged(eapConfig.enterpriseConfig,
146                 papConfig.enterpriseConfig));
147     }
148 
149     /**
150      * Verify WifiEnterpriseConfig added Certificate is detected.
151      */
152     @Test
testCaCertificateAddedDetected()153     public void testCaCertificateAddedDetected() {
154         EnterpriseConfig eapConfigNoCerts = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS)
155                 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2)
156                 .setIdentity("username", "password");
157 
158         EnterpriseConfig eapConfig1Cert = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS)
159                 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2)
160                 .setIdentity("username", "password")
161                 .setCaCerts(new X509Certificate[]{FakeKeys.CA_CERT0});
162 
163         assertTrue(WifiConfigurationUtil.hasEnterpriseConfigChanged(
164                 eapConfigNoCerts.enterpriseConfig, eapConfig1Cert.enterpriseConfig));
165     }
166 
167     /**
168      * Verify WifiEnterpriseConfig Certificate change is detected.
169      */
170     @Test
testDifferentCaCertificateDetected()171     public void testDifferentCaCertificateDetected() {
172         EnterpriseConfig eapConfig = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS)
173                 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2)
174                 .setIdentity("username", "password")
175                 .setCaCerts(new X509Certificate[]{FakeKeys.CA_CERT0});
176 
177         EnterpriseConfig eapConfigNewCert = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS)
178                 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2)
179                 .setIdentity("username", "password")
180                 .setCaCerts(new X509Certificate[]{FakeKeys.CA_CERT1});
181 
182         assertTrue(WifiConfigurationUtil.hasEnterpriseConfigChanged(eapConfig.enterpriseConfig,
183                 eapConfigNewCert.enterpriseConfig));
184     }
185 
186     /**
187      * Verify WifiEnterpriseConfig added Certificate changes are detected.
188      */
189     @Test
testCaCertificateChangesDetected()190     public void testCaCertificateChangesDetected() {
191         EnterpriseConfig eapConfig = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS)
192                 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2)
193                 .setIdentity("username", "password")
194                 .setCaCerts(new X509Certificate[]{FakeKeys.CA_CERT0});
195 
196         EnterpriseConfig eapConfigAddedCert = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS)
197                 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2)
198                 .setIdentity("username", "password")
199                 .setCaCerts(new X509Certificate[]{FakeKeys.CA_CERT0, FakeKeys.CA_CERT1});
200 
201         assertTrue(WifiConfigurationUtil.hasEnterpriseConfigChanged(eapConfig.enterpriseConfig,
202                 eapConfigAddedCert.enterpriseConfig));
203     }
204 
205     /**
206      * Verify that WifiEnterpriseConfig does not detect changes for identical configs.
207      */
208     @Test
testWifiEnterpriseConfigNoChanges()209     public void testWifiEnterpriseConfigNoChanges() {
210         EnterpriseConfig eapConfig = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS)
211                 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2)
212                 .setIdentity("username", "password")
213                 .setCaCerts(new X509Certificate[]{FakeKeys.CA_CERT0, FakeKeys.CA_CERT1});
214 
215         // Just to be clear that check is not against the same object
216         EnterpriseConfig eapConfigSame = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS)
217                 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2)
218                 .setIdentity("username", "password")
219                 .setCaCerts(new X509Certificate[]{FakeKeys.CA_CERT0, FakeKeys.CA_CERT1});
220 
221         assertFalse(WifiConfigurationUtil.hasEnterpriseConfigChanged(eapConfig.enterpriseConfig,
222                 eapConfigSame.enterpriseConfig));
223     }
224 
225     /**
226      * Verify that the validate method successfully validates good WifiConfigurations with ASCII
227      * values.
228      */
229     @Test
testValidatePositiveCases_AsciiSsidString()230     public void testValidatePositiveCases_AsciiSsidString() {
231         assertTrue(WifiConfigurationUtil.validate(
232                 WifiConfigurationTestUtil.createOpenNetwork(), SUPPORTED_FEATURES_ALL,
233                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
234         assertTrue(WifiConfigurationUtil.validate(
235                 WifiConfigurationTestUtil.createPskNetwork(), SUPPORTED_FEATURES_ALL,
236                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
237         assertTrue(WifiConfigurationUtil.validate(
238                 WifiConfigurationTestUtil.createWepNetwork(), SUPPORTED_FEATURES_ALL,
239                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
240         assertTrue(WifiConfigurationUtil.validate(
241                 WifiConfigurationTestUtil.createEapNetwork(), SUPPORTED_FEATURES_ALL,
242                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
243         assertTrue(WifiConfigurationUtil.validate(
244                 WifiConfigurationTestUtil.createOweNetwork(), SUPPORTED_FEATURES_ALL,
245                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
246         assertTrue(WifiConfigurationUtil.validate(
247                 WifiConfigurationTestUtil.createSaeNetwork(), SUPPORTED_FEATURES_ALL,
248                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
249         assertTrue(WifiConfigurationUtil.validate(
250                 WifiConfigurationTestUtil.createEapSuiteBNetwork(), SUPPORTED_FEATURES_ALL,
251                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
252     }
253 
254     /**
255      * Verify that the validate method successfully validates good WifiConfigurations with hex
256      * values.
257      */
258     @Test
testValidatePositiveCases_HexSsidString()259     public void testValidatePositiveCases_HexSsidString() {
260         WifiConfiguration config = WifiConfigurationTestUtil.createPskNetwork();
261         config.SSID = "abcd1234555a";
262         config.preSharedKey = "abcd123455151234556788990034556667332345667322344556676743233445";
263         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
264                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
265     }
266 
267     /**
268      * Verify that the validate method validates WifiConfiguration with "any" in the BSSID field.
269      */
270     @Test
testValidatePositiveCases_AnyBssidString()271     public void testValidatePositiveCases_AnyBssidString() {
272         WifiConfiguration config = WifiConfigurationTestUtil.createPskNetwork();
273         config.BSSID = "any";
274         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
275                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
276         assertTrue(WifiConfigurationUtil.validate(
277                 config, SUPPORTED_FEATURES_ALL, WifiConfigurationUtil.VALIDATE_FOR_UPDATE));
278     }
279 
280     /**
281      * Verify that the validate method validates WifiConfiguration with masked psk string only for
282      * an update.
283      */
284     @Test
testValidatePositiveCases_MaskedPskString()285     public void testValidatePositiveCases_MaskedPskString() {
286         WifiConfiguration config = WifiConfigurationTestUtil.createPskNetwork();
287         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
288                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
289 
290         config.preSharedKey = WifiConfigurationUtil.PASSWORD_MASK;
291         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
292                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
293         assertTrue(WifiConfigurationUtil.validate(
294                 config, SUPPORTED_FEATURES_ALL, WifiConfigurationUtil.VALIDATE_FOR_UPDATE));
295     }
296 
297     /**
298      * Verify that the validate method validates WifiConfiguration with null ssid only for an
299      * update.
300      */
301     @Test
testValidatePositiveCases_OnlyUpdateIgnoresNullSsid()302     public void testValidatePositiveCases_OnlyUpdateIgnoresNullSsid() {
303         WifiConfiguration config = new WifiConfiguration();
304         config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_OPEN);
305         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
306                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
307         assertTrue(WifiConfigurationUtil.validate(
308                 config, SUPPORTED_FEATURES_ALL, WifiConfigurationUtil.VALIDATE_FOR_UPDATE));
309 
310     }
311 
312     /**
313      * Verify that the validate method fails to validate WifiConfiguration with malformed ssid
314      * string.
315      */
316     @Test
testValidateNegativeCases_MalformedAsciiSsidString()317     public void testValidateNegativeCases_MalformedAsciiSsidString() {
318         WifiConfiguration config = WifiConfigurationTestUtil.createOpenNetwork();
319         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
320                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
321 
322         config.SSID = "\"ab";
323         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
324                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
325     }
326 
327     /**
328      * Verify that the validate method fails to validate WifiConfiguration with bad ssid length.
329      */
330     @Test
testValidateNegativeCases_BadHexSsidLength()331     public void testValidateNegativeCases_BadHexSsidLength() {
332         WifiConfiguration config = WifiConfigurationTestUtil.createOpenNetwork();
333         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
334                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
335 
336         config.SSID = "abcdfe012345632423343543453456464545656464545646454ace34534545634535";
337         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
338                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
339         config.SSID = "";
340         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
341                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
342     }
343 
344     /**
345      * Verify that the validate method fails to validate WifiConfiguration with malformed ssid
346      * string.
347      */
348     @Test
testValidateNegativeCases_MalformedHexSsidString()349     public void testValidateNegativeCases_MalformedHexSsidString() {
350         WifiConfiguration config = WifiConfigurationTestUtil.createOpenNetwork();
351         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
352                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
353 
354         config.SSID = "hello";
355         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
356                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
357     }
358 
359     /**
360      * Verify that the validate method fails to validate WifiConfiguration with bad psk length.
361      */
362     @Test
testValidateNegativeCases_BadAsciiPskLength()363     public void testValidateNegativeCases_BadAsciiPskLength() {
364         WifiConfiguration config = WifiConfigurationTestUtil.createPskNetwork();
365         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
366                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
367 
368         config.preSharedKey = "\"abcdffeeretretyetreteteteabe34tetrertertrsraaaaaaaaaaa345eqwrweewq"
369                 + "weqe\"";
370         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
371                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
372         config.preSharedKey = "\"454\"";
373         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
374                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
375     }
376 
377     @Test
testValidateNegativeCases_BadAsciiPskLengthWapi()378     public void testValidateNegativeCases_BadAsciiPskLengthWapi() {
379         WifiConfiguration config = WifiConfigurationTestUtil.createWapiPskNetwork();
380         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
381                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
382 
383         config.preSharedKey = "\"abcdffeeretretyetreteteteabe34tetrertertrsraaaaaaaaaaa345eqwrweewq"
384                 + "weqe\"";
385         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
386                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
387         config.preSharedKey = "\"454\"";
388         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
389                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
390     }
391 
392     /**
393      * Verify that the validate method fails to validate WifiConfiguration with bad sae length.
394      */
395     @Test
testValidateNegativeCases_BadAsciiSaeLength()396     public void testValidateNegativeCases_BadAsciiSaeLength() {
397         WifiConfiguration config = WifiConfigurationTestUtil.createSaeNetwork();
398         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
399                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
400 
401         config.preSharedKey = "\"abcdffeeretretyetreteteteabe34tetrertertrsraaaaaaaaaaa345eqwrweewq"
402                 + "weqe\"";
403         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
404                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
405         config.preSharedKey = "\"\"";
406         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
407                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
408     }
409 
410     /**
411      * Verify that the validate method fails to validate WifiConfiguration with malformed psk
412      * string.
413      */
414     @Test
testValidateNegativeCases_MalformedAsciiPskString()415     public void testValidateNegativeCases_MalformedAsciiPskString() {
416         WifiConfiguration config = WifiConfigurationTestUtil.createPskNetwork();
417         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
418                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
419 
420         config.preSharedKey = "\"abcdfefeeretrety";
421         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
422                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
423     }
424 
425     @Test
testValidateNegativeCases_MalformedAsciiPskStringWapi()426     public void testValidateNegativeCases_MalformedAsciiPskStringWapi() {
427         WifiConfiguration config = WifiConfigurationTestUtil.createWapiPskNetwork();
428         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
429                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
430 
431         config.preSharedKey = "\"abcdfefeeretrety";
432         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
433                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
434     }
435 
436     /**
437      * Verify that the validate method fails to validate WifiConfiguration with malformed sae
438      * string.
439      */
440     @Test
testValidateNegativeCases_MalformedAsciiSaeString()441     public void testValidateNegativeCases_MalformedAsciiSaeString() {
442         WifiConfiguration config = WifiConfigurationTestUtil.createSaeNetwork();
443         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
444                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
445 
446         config.preSharedKey = "\"abcdfefeeretrety";
447         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
448                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
449     }
450 
451     /**
452      * Verify that the validate method fails to validate WifiConfiguration with bad psk length.
453      */
454     @Test
testValidateNegativeCases_BadHexPskLength()455     public void testValidateNegativeCases_BadHexPskLength() {
456         WifiConfiguration config = WifiConfigurationTestUtil.createPskNetwork();
457         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
458                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
459 
460         config.preSharedKey = "abcd123456788990013453445345465465476546";
461         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
462                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
463         config.preSharedKey = "";
464         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
465                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
466     }
467 
468     @Test
testValidateNegativeCases_BadHexPskLengthWapi()469     public void testValidateNegativeCases_BadHexPskLengthWapi() {
470         WifiConfiguration config = WifiConfigurationTestUtil.createWapiPskNetwork();
471         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
472                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
473 
474         config.preSharedKey = "01234567890123456789012345678901234567890123456789012345678901234567"
475                 + "890123456789012345678901234567890";
476         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
477                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
478         config.preSharedKey = "";
479         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
480                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
481     }
482 
483     /**
484      * Verify that the validate method fails to validate WifiConfiguration with malformed psk
485      * string.
486      */
487     @Test
testValidateNegativeCases_MalformedHexPskString()488     public void testValidateNegativeCases_MalformedHexPskString() {
489         WifiConfiguration config = WifiConfigurationTestUtil.createPskNetwork();
490         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
491                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
492 
493         config.preSharedKey = "adbdfgretrtyrtyrty";
494         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
495                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
496     }
497 
498     @Test
testValidateNegativeCases_MalformedHexPskStringWapi()499     public void testValidateNegativeCases_MalformedHexPskStringWapi() {
500         WifiConfiguration config = WifiConfigurationTestUtil.createWapiPskNetwork();
501         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
502                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
503 
504         config.preSharedKey = "adbdfgretrtyrtyrty";
505         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
506                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
507     }
508 
509     /**
510      * Verify that the validate method fails to validate WifiConfiguration with malformed sae
511      * string.
512      */
513     @Test
testValidateNegativeCases_MalformedHexSaeString()514     public void testValidateNegativeCases_MalformedHexSaeString() {
515         WifiConfiguration config = WifiConfigurationTestUtil.createSaeNetwork();
516         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
517                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
518 
519         config.preSharedKey = "adbdfgretrtyrtyrty";
520         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
521                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
522     }
523 
524     /**
525      * Verify that the validate method validates WifiConfiguration with masked wep key only for
526      * an update.
527      */
528     @Test
testValidatePositiveCases_MaskedWepKeysString()529     public void testValidatePositiveCases_MaskedWepKeysString() {
530         WifiConfiguration config = WifiConfigurationTestUtil.createWepNetwork();
531         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
532                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
533 
534         config.wepKeys = new String[]{ WifiConfigurationUtil.PASSWORD_MASK,
535                 WifiConfigurationUtil.PASSWORD_MASK,
536                 WifiConfigurationUtil.PASSWORD_MASK,
537                 WifiConfigurationUtil.PASSWORD_MASK};
538         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
539                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
540         assertTrue(WifiConfigurationUtil.validate(
541                 config, SUPPORTED_FEATURES_ALL, WifiConfigurationUtil.VALIDATE_FOR_UPDATE));
542     }
543 
544     /**
545      * Verify that the validate method fails to validate WifiConfiguration with bad wep length.
546      */
547     @Test
testValidateNegativeCases_BadWepKeysLength()548     public void testValidateNegativeCases_BadWepKeysLength() {
549         WifiConfiguration config = WifiConfigurationTestUtil.createWepNetwork();
550         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
551                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
552 
553         config.wepKeys = new String[] {"\"abcd\""};
554         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
555                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
556         config.wepKeys = new String[] {"456"};
557         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
558                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
559         // Error scenario in b/169638868.
560         config.wepKeys = new String[] {""};
561         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
562                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
563     }
564 
565     /**
566      * Verify that the validate method fails to validate WifiConfiguration with bad wep tx key idx.
567      */
568     @Test
testValidateNegativeCases_BadWepTxKeysIndex()569     public void testValidateNegativeCases_BadWepTxKeysIndex() {
570         WifiConfiguration config = WifiConfigurationTestUtil.createWepNetwork();
571         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
572                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
573         // Should be < wepKeys.length
574         config.wepTxKeyIndex = config.wepKeys.length;
575         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
576                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
577     }
578 
579     /**
580      * Verify that the validate method fails to validate WifiConfiguration with bad key mgmt values.
581      */
582     @Test
testValidateNegativeCases_BadKeyMgmtPskEap()583     public void testValidateNegativeCases_BadKeyMgmtPskEap() {
584         WifiConfiguration config = WifiConfigurationTestUtil.createPskNetwork();
585         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
586                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
587 
588         config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.IEEE8021X);
589         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
590                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
591     }
592 
593     /**
594      * Verify that the validate method fails to validate WifiConfiguration with bad key mgmt values.
595      */
596     @Test
testValidateNegativeCases_BadKeyMgmtOpenPsk()597     public void testValidateNegativeCases_BadKeyMgmtOpenPsk() {
598         WifiConfiguration config = WifiConfigurationTestUtil.createOpenNetwork();
599         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
600                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
601 
602         config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
603         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
604                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
605     }
606 
607     /**
608      * Verify that the validate method fails to validate WifiConfiguration with bad key mgmt values.
609      */
610     @Test
testValidateNegativeCases_BadKeyMgmt()611     public void testValidateNegativeCases_BadKeyMgmt() {
612         WifiConfiguration config = WifiConfigurationTestUtil.createPskNetwork();
613         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
614                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
615 
616         config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.IEEE8021X);
617         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
618                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
619     }
620 
621     /**
622      * Verify that the validate method fails to validate WifiConfiguration with bad key mgmt values.
623      */
624     @Test
testValidateNegativeCases_BadSuiteBKeyMgmt()625     public void testValidateNegativeCases_BadSuiteBKeyMgmt() {
626         WifiConfiguration config = WifiConfigurationTestUtil.createEapSuiteBNetwork();
627         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
628                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
629 
630         config.allowedKeyManagement.clear(WifiConfiguration.KeyMgmt.IEEE8021X);
631         config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA2_PSK);
632         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
633                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
634     }
635 
636     /**
637      * Verify that the validate method fails to validate WifiConfiguration with bad ipconfiguration
638      * values.
639      */
640     @Test
testValidateNegativeCases_BadIpconfiguration()641     public void testValidateNegativeCases_BadIpconfiguration() {
642         WifiConfiguration config = WifiConfigurationTestUtil.createPskNetwork();
643         IpConfiguration ipConfig =
644                 WifiConfigurationTestUtil.createStaticIpConfigurationWithPacProxy();
645         config.setIpConfiguration(ipConfig);
646         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
647                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
648 
649         ipConfig.setStaticIpConfiguration(null);
650         config.setIpConfiguration(ipConfig);
651         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
652                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
653     }
654 
655     /**
656      * Verify that the validate method fails to validate WifiConfiguration with bad KeyMgmt value.
657      */
658     @Test
testValidateNegativeCases_InvalidKeyMgmt()659     public void testValidateNegativeCases_InvalidKeyMgmt() {
660         WifiConfiguration config = WifiConfigurationTestUtil.createOpenNetwork();
661         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
662                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
663 
664         config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.FT_EAP + 1);
665         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
666                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
667     }
668 
669     /**
670      * Verify that the validate method fails to validate WifiConfiguration with bad KeyMgmt value.
671      */
672     @Test
testValidateNegativeCases_InvalidKeyMgmtWithPreSharedKey()673     public void testValidateNegativeCases_InvalidKeyMgmtWithPreSharedKey() {
674         WifiConfiguration config = WifiConfigurationTestUtil.createPskNetwork();
675         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
676                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
677 
678         config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_OSEN);
679         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
680                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
681         // Verify we reset the KeyMgmt
682         assertTrue(config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.WPA_PSK));
683         assertFalse(config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.OSEN));
684     }
685 
686     /**
687      * Verify that the validate method fails to validate WifiConfiguration with bad Protocol value.
688      */
689     @Test
testValidateNegativeCases_InvalidProtocol()690     public void testValidateNegativeCases_InvalidProtocol() {
691         WifiConfiguration config = WifiConfigurationTestUtil.createOpenNetwork();
692         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
693                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
694 
695         config.allowedProtocols.set(4);
696         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
697                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
698     }
699 
700     /**
701      * Verify that the validate method fails to validate WifiConfiguration with bad AuthAlgorithm
702      * value.
703      */
704     @Test
testValidateNegativeCases_InvalidAuthAlgorithm()705     public void testValidateNegativeCases_InvalidAuthAlgorithm() {
706         WifiConfiguration config = WifiConfigurationTestUtil.createOpenNetwork();
707         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
708                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
709 
710         config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.LEAP + 3);
711         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
712                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
713     }
714 
715     /**
716      * Verify that the validate method fails to validate WifiConfiguration with bad GroupCipher
717      * value.
718      */
719     @Test
testValidateNegativeCases_InvalidGroupCipher()720     public void testValidateNegativeCases_InvalidGroupCipher() {
721         WifiConfiguration config = WifiConfigurationTestUtil.createOpenNetwork();
722         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
723                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
724 
725         config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.GTK_NOT_USED + 4);
726         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
727                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
728     }
729 
730     /**
731      * Verify that the validate method fails to validate WifiConfiguration with bad PairwiseCipher
732      * value.
733      */
734     @Test
testValidateNegativeCases_InvalidPairwiseCipher()735     public void testValidateNegativeCases_InvalidPairwiseCipher() {
736         WifiConfiguration config = WifiConfigurationTestUtil.createOpenNetwork();
737         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
738                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
739 
740         config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP + 4);
741         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
742                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
743     }
744 
745     /**
746      * Verify that the validate method successfully validates good WifiNetworkSpecifier with
747      * only ssid pattern set.
748      */
749     @Test
testValidateNetworkSpecifierPositiveCases_SsidPattern()750     public void testValidateNetworkSpecifierPositiveCases_SsidPattern() {
751         WifiNetworkSpecifier specifier = new WifiNetworkSpecifier(
752                 new PatternMatcher(TEST_SSID, PatternMatcher.PATTERN_LITERAL),
753                 Pair.create(WifiManager.ALL_ZEROS_MAC_ADDRESS, WifiManager.ALL_ZEROS_MAC_ADDRESS),
754                 ScanResult.UNSPECIFIED,
755                 WifiConfigurationTestUtil.createOpenNetwork(), new int[0]);
756         assertTrue(WifiConfigurationUtil.validateNetworkSpecifier(specifier, 5));
757     }
758 
759     /**
760      * Verify that the validate method successfully validates good WifiNetworkSpecifier with
761      * only bssid pattern set.
762      */
763     @Test
testValidateNetworkSpecifierPositiveCases_BssidPattern()764     public void testValidateNetworkSpecifierPositiveCases_BssidPattern() {
765         WifiNetworkSpecifier specifier = new WifiNetworkSpecifier(
766                 new PatternMatcher(".*", PatternMatcher.PATTERN_SIMPLE_GLOB),
767                 Pair.create(MacAddress.fromString(TEST_BSSID), MacAddress.BROADCAST_ADDRESS),
768                 ScanResult.UNSPECIFIED,
769                 WifiConfigurationTestUtil.createOpenNetwork(), new int[0]);
770         assertTrue(WifiConfigurationUtil.validateNetworkSpecifier(specifier, 5));
771     }
772 
773     /**
774      * Verify that the validate method successfully validates good WifiNetworkSpecifier with
775      * both ssid & bssid patterns set.
776      */
777     @Test
testValidateNetworkSpecifierPositiveCases_BothSsidPatternAndBssidPattern()778     public void testValidateNetworkSpecifierPositiveCases_BothSsidPatternAndBssidPattern() {
779         WifiNetworkSpecifier specifier = new WifiNetworkSpecifier(
780                 new PatternMatcher(TEST_SSID, PatternMatcher.PATTERN_LITERAL),
781                 Pair.create(MacAddress.fromString(TEST_BSSID), MacAddress.BROADCAST_ADDRESS),
782                 ScanResult.UNSPECIFIED,
783                 WifiConfigurationTestUtil.createOpenNetwork(), new int[0]);
784         assertTrue(WifiConfigurationUtil.validateNetworkSpecifier(specifier, 5));
785     }
786 
787     /**
788      * Verify that the validate method validates a WifiNetworkSpecifier that specifies ssid, bssid,
789      * and band. Note that such requests will currently still be rejected by WifiNetworkFactory, but
790      * requesting specific bands may be supported in future releases.
791      */
792     @Test
testValidateNetworkSpecifierPositiveCases_SsidPatternAndBssidPatternAndBand()793     public void testValidateNetworkSpecifierPositiveCases_SsidPatternAndBssidPatternAndBand() {
794         WifiNetworkSpecifier specifier = new WifiNetworkSpecifier(
795                 new PatternMatcher(TEST_SSID, PatternMatcher.PATTERN_LITERAL),
796                 Pair.create(MacAddress.fromString(TEST_BSSID), MacAddress.BROADCAST_ADDRESS),
797                 ScanResult.WIFI_BAND_5_GHZ,
798                 WifiConfigurationTestUtil.createOpenNetwork(), new int[0]);
799         assertTrue(WifiConfigurationUtil.validateNetworkSpecifier(specifier, 5));
800     }
801 
802 
803     /**
804      * Verify that the validate method fails to validate WifiNetworkSpecifier with no
805      * ssid/bssid info.
806      */
807     @Test
testValidateNetworkSpecifierNegativeCases_NoSsidBssid()808     public void testValidateNetworkSpecifierNegativeCases_NoSsidBssid() {
809         WifiNetworkSpecifier specifier = new WifiNetworkSpecifier(
810                 new PatternMatcher(".*", PatternMatcher.PATTERN_SIMPLE_GLOB),
811                 Pair.create(WifiManager.ALL_ZEROS_MAC_ADDRESS, WifiManager.ALL_ZEROS_MAC_ADDRESS),
812                 ScanResult.UNSPECIFIED,
813                 WifiConfigurationTestUtil.createOpenNetwork(), new int[0]);
814         assertFalse(WifiConfigurationUtil.validateNetworkSpecifier(specifier, 5));
815     }
816 
817     /**
818      * Verify that the validate method fails to validate WifiNetworkSpecifier with invalid SSID
819      * match pattern.
820      */
821     @Test
testValidateNetworkSpecifierNegativeCases_MatchNoneSsidPattern()822     public void testValidateNetworkSpecifierNegativeCases_MatchNoneSsidPattern() {
823         WifiNetworkSpecifier specifier = new WifiNetworkSpecifier(
824                 new PatternMatcher("", PatternMatcher.PATTERN_LITERAL),
825                 Pair.create(WifiManager.ALL_ZEROS_MAC_ADDRESS, WifiManager.ALL_ZEROS_MAC_ADDRESS),
826                 ScanResult.UNSPECIFIED,
827                 WifiConfigurationTestUtil.createOpenNetwork(), new int[0]);
828         assertFalse(WifiConfigurationUtil.validateNetworkSpecifier(specifier, 5));
829     }
830 
831     /**
832      * Verify that the validate method fails to validate WifiNetworkSpecifier with illegal
833      * pattern.
834      */
835     @Test
testValidateNetworkSpecifierNegativeCases_MatchNoneBssidPattern()836     public void testValidateNetworkSpecifierNegativeCases_MatchNoneBssidPattern() {
837         WifiNetworkSpecifier specifier = new WifiNetworkSpecifier(
838                 new PatternMatcher(TEST_SSID, PatternMatcher.PATTERN_LITERAL),
839                 Pair.create(MacAddress.BROADCAST_ADDRESS, MacAddress.BROADCAST_ADDRESS),
840                 ScanResult.UNSPECIFIED,
841                 WifiConfigurationTestUtil.createOpenNetwork(), new int[0]);
842         assertFalse(WifiConfigurationUtil.validateNetworkSpecifier(specifier, 5));
843     }
844 
845     /**
846      * Verify that the validate method fails to validate WifiNetworkSpecifier with illegal
847      * pattern.
848      */
849     @Test
testValidateNetworkSpecifierNegativeCases_InvalidBssidPattern()850     public void testValidateNetworkSpecifierNegativeCases_InvalidBssidPattern() {
851         WifiNetworkSpecifier specifier = new WifiNetworkSpecifier(
852                 new PatternMatcher(TEST_SSID, PatternMatcher.PATTERN_LITERAL),
853                 Pair.create(MacAddress.fromString(TEST_BSSID), WifiManager.ALL_ZEROS_MAC_ADDRESS),
854                 ScanResult.UNSPECIFIED,
855                 WifiConfigurationTestUtil.createOpenNetwork(), new int[0]);
856         assertFalse(WifiConfigurationUtil.validateNetworkSpecifier(specifier, 5));
857     }
858 
859     /**
860      * Verify that the validate method fails to validate WifiNetworkSpecifier with SSID pattern
861      * for hidden network.
862      */
863     @Test
testValidateNetworkSpecifierNegativeCases_NoSsidPatternForHiddenNetwork()864     public void testValidateNetworkSpecifierNegativeCases_NoSsidPatternForHiddenNetwork() {
865         WifiNetworkSpecifier specifier = new WifiNetworkSpecifier(
866                 new PatternMatcher(TEST_SSID, PatternMatcher.PATTERN_PREFIX),
867                 Pair.create(WifiManager.ALL_ZEROS_MAC_ADDRESS, WifiManager.ALL_ZEROS_MAC_ADDRESS),
868                 ScanResult.UNSPECIFIED,
869                 WifiConfigurationTestUtil.createOpenHiddenNetwork(), new int[0]);
870         assertFalse(WifiConfigurationUtil.validateNetworkSpecifier(specifier, 5));
871     }
872 
873     /**
874      * Verify that the validate method fails to validate WifiNetworkSpecifier with an invalid band.
875      */
876     @Test
testValidateNetworkSpecifierNegativeCases_InvalidBand()877     public void testValidateNetworkSpecifierNegativeCases_InvalidBand() {
878         WifiNetworkSpecifier specifier = new WifiNetworkSpecifier(
879                 new PatternMatcher(TEST_SSID, PatternMatcher.PATTERN_LITERAL),
880                 Pair.create(MacAddress.fromString(TEST_BSSID), MacAddress.BROADCAST_ADDRESS),
881                 42,  // invalid
882                 WifiConfigurationTestUtil.createOpenNetwork(), new int[0]);
883         assertFalse(WifiConfigurationUtil.validateNetworkSpecifier(specifier, 5));
884     }
885 
886     /**
887      * Verify the instance of {@link android.net.wifi.WifiScanner.PnoSettings.PnoNetwork} created
888      * for an open network using {@link WifiConfigurationUtil#createPnoNetwork(
889      * WifiConfiguration)}.
890      */
891     @Test
testCreatePnoNetworkWithOpenNetwork()892     public void testCreatePnoNetworkWithOpenNetwork() {
893         WifiConfiguration network = WifiConfigurationTestUtil.createOpenNetwork();
894         WifiScanner.PnoSettings.PnoNetwork pnoNetwork =
895                 WifiConfigurationUtil.createPnoNetwork(network);
896         assertEquals(network.SSID, pnoNetwork.ssid);
897         assertEquals(
898                 WifiScanner.PnoSettings.PnoNetwork.FLAG_A_BAND
899                         | WifiScanner.PnoSettings.PnoNetwork.FLAG_G_BAND, pnoNetwork.flags);
900         assertEquals(WifiScanner.PnoSettings.PnoNetwork.AUTH_CODE_OPEN, pnoNetwork.authBitField);
901     }
902 
903     /**
904      * Verify the instance of {@link android.net.wifi.WifiScanner.PnoSettings.PnoNetwork} created
905      * for an open hidden network using {@link WifiConfigurationUtil#createPnoNetwork(
906      * WifiConfiguration)}.
907      */
908     @Test
testCreatePnoNetworkWithOpenHiddenNetwork()909     public void testCreatePnoNetworkWithOpenHiddenNetwork() {
910         WifiConfiguration network = WifiConfigurationTestUtil.createOpenHiddenNetwork();
911         WifiScanner.PnoSettings.PnoNetwork pnoNetwork =
912                 WifiConfigurationUtil.createPnoNetwork(network);
913         assertEquals(network.SSID, pnoNetwork.ssid);
914         assertEquals(
915                 WifiScanner.PnoSettings.PnoNetwork.FLAG_A_BAND
916                         | WifiScanner.PnoSettings.PnoNetwork.FLAG_G_BAND
917                         | WifiScanner.PnoSettings.PnoNetwork.FLAG_DIRECTED_SCAN, pnoNetwork.flags);
918         assertEquals(WifiScanner.PnoSettings.PnoNetwork.AUTH_CODE_OPEN, pnoNetwork.authBitField);
919     }
920 
921     /**
922      * Verify the instance of {@link android.net.wifi.WifiScanner.PnoSettings.PnoNetwork} created
923      * for a PSK network using {@link WifiConfigurationUtil#createPnoNetwork(WifiConfiguration)
924      * }.
925      */
926     @Test
testCreatePnoNetworkWithPskNetwork()927     public void testCreatePnoNetworkWithPskNetwork() {
928         WifiConfiguration network = WifiConfigurationTestUtil.createPskNetwork();
929         WifiScanner.PnoSettings.PnoNetwork pnoNetwork =
930                 WifiConfigurationUtil.createPnoNetwork(network);
931         assertEquals(network.SSID, pnoNetwork.ssid);
932         assertEquals(
933                 WifiScanner.PnoSettings.PnoNetwork.FLAG_A_BAND
934                         | WifiScanner.PnoSettings.PnoNetwork.FLAG_G_BAND, pnoNetwork.flags);
935         assertEquals(WifiScanner.PnoSettings.PnoNetwork.AUTH_CODE_PSK, pnoNetwork.authBitField);
936     }
937 
938     /**
939      * Verify that WifiConfigurationUtil.isSameNetwork returns true when two WifiConfiguration
940      * objects have the same parameters.
941      */
942     @Test
testIsSameNetworkReturnsTrueOnSameNetwork()943     public void testIsSameNetworkReturnsTrueOnSameNetwork() {
944         WifiConfiguration network = WifiConfigurationTestUtil.createPskNetwork(TEST_SSID);
945         WifiConfiguration network1 = WifiConfigurationTestUtil.createPskNetwork(TEST_SSID);
946         assertTrue(WifiConfigurationUtil.isSameNetwork(network, network1));
947     }
948 
949     /**
950      * Verify that WifiConfigurationUtil.isSameNetwork returns true when two WifiConfiguration
951      * objects have the same parameters but different network selection BSSID's.
952      */
953     @Test
testIsSameNetworkReturnsTrueOnSameNetworkWithDifferentBSSID()954     public void testIsSameNetworkReturnsTrueOnSameNetworkWithDifferentBSSID() {
955         WifiConfiguration network = WifiConfigurationTestUtil.createPskNetwork(TEST_SSID);
956         network.getNetworkSelectionStatus().setNetworkSelectionBSSID(TEST_BSSID);
957         WifiConfiguration network1 = WifiConfigurationTestUtil.createPskNetwork(TEST_SSID);
958         network1.getNetworkSelectionStatus().setNetworkSelectionBSSID(TEST_BSSID_1);
959         assertTrue(WifiConfigurationUtil.isSameNetwork(network, network1));
960     }
961 
962     /**
963      * Verify that WifiConfigurationUtil.isSameNetwork returns false when two WifiConfiguration
964      * objects have the different SSIDs.
965      */
966     @Test
testIsSameNetworkReturnsFalseOnDifferentSSID()967     public void testIsSameNetworkReturnsFalseOnDifferentSSID() {
968         WifiConfiguration network = WifiConfigurationTestUtil.createPskNetwork(TEST_SSID);
969         WifiConfiguration network1 = WifiConfigurationTestUtil.createPskNetwork(TEST_SSID_1);
970         assertFalse(WifiConfigurationUtil.isSameNetwork(network, network1));
971     }
972 
973     /**
974      * Verify that WifiConfigurationUtil.isSameNetwork returns false when two WifiConfiguration
975      * objects have the different security type.
976      */
977     @Test
testIsSameNetworkReturnsFalseOnDifferentSecurityType()978     public void testIsSameNetworkReturnsFalseOnDifferentSecurityType() {
979         WifiConfiguration network = WifiConfigurationTestUtil.createPskNetwork(TEST_SSID);
980         WifiConfiguration network1 = WifiConfigurationTestUtil.createEapNetwork(TEST_SSID);
981         assertFalse(WifiConfigurationUtil.isSameNetwork(network, network1));
982     }
983 
984     /**
985      * Verify that WifiConfigurationUtil.isSameNetwork returns false when two WifiConfiguration
986      * objects have the different EAP identity.
987      */
988     @Test
testIsSameNetworkReturnsFalseOnDifferentEapIdentity()989     public void testIsSameNetworkReturnsFalseOnDifferentEapIdentity() {
990         WifiConfiguration network1 = WifiConfigurationTestUtil.createEapNetwork(TEST_SSID);
991         WifiConfiguration network2 = WifiConfigurationTestUtil.createEapNetwork(TEST_SSID);
992         network1.enterpriseConfig.setIdentity("Identity1");
993         network2.enterpriseConfig.setIdentity("Identity2");
994         assertFalse(WifiConfigurationUtil.isSameNetwork(network1, network2));
995     }
996 
997     /**
998      * Verify that WifiConfigurationUtil.isSameNetwork returns false when two WifiConfiguration
999      * objects have the different EAP anonymous identity.
1000      */
1001     @Test
testIsSameNetworkReturnsFalseOnDifferentEapAnonymousIdentity()1002     public void testIsSameNetworkReturnsFalseOnDifferentEapAnonymousIdentity() {
1003         WifiConfiguration network1 = WifiConfigurationTestUtil.createEapNetwork(TEST_SSID);
1004         WifiConfiguration network2 = WifiConfigurationTestUtil.createEapNetwork(TEST_SSID);
1005         network1.enterpriseConfig.setAnonymousIdentity("Identity1");
1006         network2.enterpriseConfig.setAnonymousIdentity("Identity2");
1007         assertFalse(WifiConfigurationUtil.isSameNetwork(network1, network2));
1008     }
1009 
1010     /**
1011      * Verify WifiConfigurationUtil.isSameNetwork return vale when two WifiConfiguration
1012      * objects have the different EAP anonymous(pseudonym) identity in EAP-SIM.
1013      */
1014     @Test
testIsSameNetworkReturnValueOnDifferentEapAnonymousIdentityInEapSim()1015     public void testIsSameNetworkReturnValueOnDifferentEapAnonymousIdentityInEapSim() {
1016         WifiConfiguration network1 = WifiConfigurationTestUtil.createEapNetwork(TEST_SSID);
1017         WifiConfiguration network2 = WifiConfigurationTestUtil.createEapNetwork(TEST_SSID);
1018         network1.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.SIM);
1019         network2.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.SIM);
1020         network1.enterpriseConfig.setAnonymousIdentity("Identity1");
1021         network2.enterpriseConfig.setAnonymousIdentity("Identity2");
1022         if (SdkLevel.isAtLeastT()) {
1023             assertTrue(WifiConfigurationUtil.isSameNetwork(network1, network2));
1024         } else {
1025             assertFalse(WifiConfigurationUtil.isSameNetwork(network1, network2));
1026         }
1027     }
1028 
1029     /**
1030      * Verify that WifiConfigurationUtil.isSameNetwork returns true when two WifiConfiguration
1031      * objects have the same candidate security params.
1032      */
1033     @Test
testIsSameNetworkReturnsTrueOnSameNetworkWithSameCandidateSecurityParams()1034     public void testIsSameNetworkReturnsTrueOnSameNetworkWithSameCandidateSecurityParams() {
1035         WifiConfiguration network = WifiConfigurationTestUtil.createPskNetwork(TEST_SSID);
1036         network.getNetworkSelectionStatus().setCandidateSecurityParams(
1037                 SecurityParams.createSecurityParamsBySecurityType(
1038                         WifiConfiguration.SECURITY_TYPE_PSK));
1039         WifiConfiguration network1 = WifiConfigurationTestUtil.createPskNetwork(TEST_SSID);
1040         network1.getNetworkSelectionStatus().setCandidateSecurityParams(
1041                 SecurityParams.createSecurityParamsBySecurityType(
1042                         WifiConfiguration.SECURITY_TYPE_PSK));
1043         assertTrue(WifiConfigurationUtil.isSameNetwork(network, network1));
1044     }
1045 
1046     /**
1047      * Verify that WifiConfigurationUtil.isSameNetwork returns false when two WifiConfiguration
1048      * objects have the different candidate security params.
1049      */
1050     @Test
testIsSameNetworkReturnsTrueOnSameNetworkWithDifferentCandidateSecurityParams()1051     public void testIsSameNetworkReturnsTrueOnSameNetworkWithDifferentCandidateSecurityParams() {
1052         WifiConfiguration network = WifiConfigurationTestUtil.createPskNetwork(TEST_SSID);
1053         network.getNetworkSelectionStatus().setCandidateSecurityParams(
1054                 SecurityParams.createSecurityParamsBySecurityType(
1055                         WifiConfiguration.SECURITY_TYPE_PSK));
1056         WifiConfiguration network1 = WifiConfigurationTestUtil.createPskNetwork(TEST_SSID);
1057         network1.getNetworkSelectionStatus().setCandidateSecurityParams(
1058                 SecurityParams.createSecurityParamsBySecurityType(
1059                         WifiConfiguration.SECURITY_TYPE_SAE));
1060         assertFalse(WifiConfigurationUtil.isSameNetwork(network, network1));
1061     }
1062 
1063     /**
1064      * Verify the instance of {@link android.net.wifi.WifiScanner.PnoSettings.PnoNetwork} created
1065      * for a EAP network using {@link WifiConfigurationUtil#createPnoNetwork(WifiConfiguration)
1066      * }.
1067      */
1068     @Test
testCreatePnoNetworkWithEapNetwork()1069     public void testCreatePnoNetworkWithEapNetwork() {
1070         WifiConfiguration network = WifiConfigurationTestUtil.createEapNetwork();
1071         WifiScanner.PnoSettings.PnoNetwork pnoNetwork =
1072                 WifiConfigurationUtil.createPnoNetwork(network);
1073         assertEquals(network.SSID, pnoNetwork.ssid);
1074         assertEquals(
1075                 WifiScanner.PnoSettings.PnoNetwork.FLAG_A_BAND
1076                         | WifiScanner.PnoSettings.PnoNetwork.FLAG_G_BAND, pnoNetwork.flags);
1077         assertEquals(WifiScanner.PnoSettings.PnoNetwork.AUTH_CODE_EAPOL, pnoNetwork.authBitField);
1078     }
1079 
1080     /**
1081      * Verify that the generalized
1082      * {@link com.android.server.wifi.WifiConfigurationUtil.WifiConfigurationComparator}
1083      * can be used to sort a List given a 'compareNetworkWithSameStatus' method.
1084      */
1085     @Test
testPnoListComparator()1086     public void testPnoListComparator() {
1087         List<WifiConfiguration> networks = new ArrayList<>();
1088         final WifiConfiguration enabledNetwork1 = WifiConfigurationTestUtil.createEapNetwork();
1089         enabledNetwork1.getNetworkSelectionStatus().setNetworkSelectionStatus(
1090                 WifiConfiguration.NetworkSelectionStatus.NETWORK_SELECTION_ENABLED);
1091         final WifiConfiguration enabledNetwork2 = WifiConfigurationTestUtil.createEapNetwork();
1092         enabledNetwork2.getNetworkSelectionStatus().setNetworkSelectionStatus(
1093                 WifiConfiguration.NetworkSelectionStatus.NETWORK_SELECTION_ENABLED);
1094         final WifiConfiguration tempDisabledNetwork1 = WifiConfigurationTestUtil.createEapNetwork();
1095         tempDisabledNetwork1.getNetworkSelectionStatus().setNetworkSelectionStatus(
1096                 WifiConfiguration.NetworkSelectionStatus.NETWORK_SELECTION_TEMPORARY_DISABLED);
1097         final WifiConfiguration tempDisabledNetwork2 = WifiConfigurationTestUtil.createEapNetwork();
1098         tempDisabledNetwork2.getNetworkSelectionStatus().setNetworkSelectionStatus(
1099                 WifiConfiguration.NetworkSelectionStatus.NETWORK_SELECTION_TEMPORARY_DISABLED);
1100         WifiConfiguration permDisabledNetwork = WifiConfigurationTestUtil.createEapNetwork();
1101         permDisabledNetwork.getNetworkSelectionStatus().setNetworkSelectionStatus(
1102                 WifiConfiguration.NetworkSelectionStatus.NETWORK_SELECTION_PERMANENTLY_DISABLED);
1103 
1104         // Add all the networks to the list.
1105         networks.add(tempDisabledNetwork1);
1106         networks.add(enabledNetwork1);
1107         networks.add(permDisabledNetwork);
1108         networks.add(tempDisabledNetwork2);
1109         networks.add(enabledNetwork2);
1110 
1111         // Prefer |enabledNetwork1| over |enabledNetwork2| and |tempDisabledNetwork1| over
1112         // |tempDisabledNetwork2|.
1113         WifiConfigurationUtil.WifiConfigurationComparator comparator =
1114                 new WifiConfigurationUtil.WifiConfigurationComparator() {
1115                     @Override
1116                     public int compareNetworksWithSameStatus(
1117                             WifiConfiguration a, WifiConfiguration b) {
1118                         if (a == enabledNetwork1 && b == enabledNetwork2) {
1119                             return -1;
1120                         } else if (b == enabledNetwork1 && a == enabledNetwork2) {
1121                             return 1;
1122                         } else if (a == tempDisabledNetwork1 && b == tempDisabledNetwork2) {
1123                             return -1;
1124                         } else if (b == tempDisabledNetwork1 && a == tempDisabledNetwork2) {
1125                             return 1;
1126                         }
1127                         return 0;
1128                     }
1129                 };
1130         Collections.sort(networks, comparator);
1131 
1132         // Now ensure that the networks were sorted correctly.
1133         assertEquals(enabledNetwork1, networks.get(0));
1134         assertEquals(enabledNetwork2, networks.get(1));
1135         assertEquals(tempDisabledNetwork1, networks.get(2));
1136         assertEquals(tempDisabledNetwork2, networks.get(3));
1137         assertEquals(permDisabledNetwork, networks.get(4));
1138     }
1139 
1140     /**
1141      * Verifies that when the existing configuration is null and macRandomizationSetting in the
1142      * newConfig is the default value, then hasMacRandomizationSettingsChanged returns false.
1143      */
1144     @Test
testHasMacRandomizationSettingsChangedNullExistingConfigDefaultNewConfig()1145     public void testHasMacRandomizationSettingsChangedNullExistingConfigDefaultNewConfig() {
1146         WifiConfiguration newConfig = new WifiConfiguration();
1147         assertFalse(WifiConfigurationUtil.hasMacRandomizationSettingsChanged(null, newConfig));
1148     }
1149 
1150     /**
1151      * Verifies that when the existing configuration is null and macRandomizationSetting in the
1152      * newConfig is not the default value, then hasMacRandomizationSettingsChanged returns true.
1153      */
1154     @Test
testHasMacRandomizationSettingsChangedNullExistingConfigModifiedNewConfig()1155     public void testHasMacRandomizationSettingsChangedNullExistingConfigModifiedNewConfig() {
1156         WifiConfiguration newConfig = new WifiConfiguration();
1157         newConfig.macRandomizationSetting = WifiConfiguration.RANDOMIZATION_NONE;
1158         assertTrue(WifiConfigurationUtil.hasMacRandomizationSettingsChanged(null, newConfig));
1159     }
1160 
1161     /**
1162      * Verifies that when macRandomizationSetting in the newConfig is different from existingConfig
1163      * hasMacRandomizationSettingsChanged returns true.
1164      */
1165     @Test
testHasMacRandomizationSettingsChangedFieldsDifferent()1166     public void testHasMacRandomizationSettingsChangedFieldsDifferent() {
1167         WifiConfiguration existingConfig = new WifiConfiguration();
1168         WifiConfiguration newConfig = new WifiConfiguration();
1169         newConfig.macRandomizationSetting = WifiConfiguration.RANDOMIZATION_NONE;
1170         assertTrue(WifiConfigurationUtil.hasMacRandomizationSettingsChanged(
1171                 existingConfig, newConfig));
1172     }
1173 
1174     /**
1175      * Verifies that when macRandomizationSetting in the newConfig is the same as existingConfig
1176      * hasMacRandomizationSettingsChanged returns false.
1177      */
1178     @Test
testHasMacRandomizationSettingsChangedFieldsSame()1179     public void testHasMacRandomizationSettingsChangedFieldsSame() {
1180         WifiConfiguration existingConfig = new WifiConfiguration();
1181         existingConfig.macRandomizationSetting = WifiConfiguration.RANDOMIZATION_NONE;
1182         WifiConfiguration newConfig = new WifiConfiguration();
1183         newConfig.macRandomizationSetting = WifiConfiguration.RANDOMIZATION_NONE;
1184         assertFalse(WifiConfigurationUtil.hasMacRandomizationSettingsChanged(
1185                 existingConfig, newConfig));
1186     }
1187 
1188     /**
1189      * Verifies that isConfigForEnterpriseNetwork() returns true for SECURITY_TYPE_EAP,
1190      * SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT, SECURITY_TYPE_PASSPOINT_R1_R2 and
1191      * SECURITY_TYPE_PASSPOINT_R3 WiFi configurations.
1192      */
1193     @Test
testisConfigForEnterpriseNetworkReturnTrue()1194     public void testisConfigForEnterpriseNetworkReturnTrue() {
1195         WifiConfiguration config = new WifiConfiguration();
1196         config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP);
1197         assertTrue(WifiConfigurationUtil.isConfigForEnterpriseNetwork(config));
1198 
1199         config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE);
1200         assertTrue(WifiConfigurationUtil.isConfigForEnterpriseNetwork(config));
1201 
1202         config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT);
1203         assertTrue(WifiConfigurationUtil.isConfigForEnterpriseNetwork(config));
1204 
1205         config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PASSPOINT_R1_R2);
1206         assertTrue(WifiConfigurationUtil.isConfigForEnterpriseNetwork(config));
1207 
1208         config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PASSPOINT_R3);
1209         assertTrue(WifiConfigurationUtil.isConfigForEnterpriseNetwork(config));
1210     }
1211 
1212     /**
1213      * Verifies that isConfigForEnterpriseNetwork() returns false for SECURITY_TYPE_OPEN,
1214      * SECURITY_TYPE_PSK, SECURITY_TYPE_OWE and SECURITY_TYPE_SAE WiFi configurations.
1215      */
1216     @Test
testisConfigForEnterpriseNetworkReturnFalse()1217     public void testisConfigForEnterpriseNetworkReturnFalse() {
1218         WifiConfiguration config = new WifiConfiguration();
1219         config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_OPEN);
1220         assertFalse(WifiConfigurationUtil.isConfigForEnterpriseNetwork(config));
1221 
1222         config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK);
1223         assertFalse(WifiConfigurationUtil.isConfigForEnterpriseNetwork(config));
1224 
1225         config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_OWE);
1226         assertFalse(WifiConfigurationUtil.isConfigForEnterpriseNetwork(config));
1227 
1228         config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_SAE);
1229         assertFalse(WifiConfigurationUtil.isConfigForEnterpriseNetwork(config));
1230     }
1231 
1232     private static class EnterpriseConfig {
1233         public String eap;
1234         public String phase2;
1235         public String identity;
1236         public String password;
1237         public X509Certificate[] caCerts;
1238         public WifiEnterpriseConfig enterpriseConfig;
1239         public String wapiCertSuite;
1240 
EnterpriseConfig(int eapMethod)1241         EnterpriseConfig(int eapMethod) {
1242             enterpriseConfig = new WifiEnterpriseConfig();
1243             enterpriseConfig.setEapMethod(eapMethod);
1244             eap = WifiEnterpriseConfig.Eap.strings[eapMethod];
1245         }
1246 
setPhase2(int phase2Method)1247         public EnterpriseConfig setPhase2(int phase2Method) {
1248             enterpriseConfig.setPhase2Method(phase2Method);
1249             phase2 = "auth=" + WifiEnterpriseConfig.Phase2.strings[phase2Method];
1250             return this;
1251         }
1252 
setIdentity(String identity, String password)1253         public EnterpriseConfig setIdentity(String identity, String password) {
1254             enterpriseConfig.setIdentity(identity);
1255             enterpriseConfig.setPassword(password);
1256             this.identity = identity;
1257             this.password = password;
1258             return this;
1259         }
1260 
setCaCerts(X509Certificate[] certs)1261         public EnterpriseConfig setCaCerts(X509Certificate[] certs) {
1262             enterpriseConfig.setCaCertificates(certs);
1263             caCerts = certs;
1264             return this;
1265         }
1266 
setWapiCertSuite(String certSuite)1267         public EnterpriseConfig setWapiCertSuite(String certSuite) {
1268             enterpriseConfig.setWapiCertSuite(certSuite);
1269             wapiCertSuite = certSuite;
1270             return this;
1271         }
1272     }
1273 
1274     /**
1275      * Verify WifiEnterpriseConfig CA Certificate alias changes are detected.
1276      */
1277     @Test
testCaCertificateAliasChangesDetected()1278     public void testCaCertificateAliasChangesDetected() {
1279         EnterpriseConfig eapConfig1 = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS)
1280                 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2)
1281                 .setIdentity("username", "password");
1282         eapConfig1.enterpriseConfig.setCaCertificateAlias("ALIAS_1");
1283 
1284         EnterpriseConfig eapConfig2 = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS)
1285                 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2)
1286                 .setIdentity("username", "password");
1287         eapConfig2.enterpriseConfig.setCaCertificateAlias("ALIAS_2");
1288 
1289         assertTrue(WifiConfigurationUtil.hasEnterpriseConfigChanged(eapConfig1.enterpriseConfig,
1290                 eapConfig2.enterpriseConfig));
1291     }
1292 
1293     /**
1294      * Verify WifiEnterpriseConfig Client Certificate alias changes are detected.
1295      */
1296     @Test
testClientCertificateAliasChangesDetected()1297     public void testClientCertificateAliasChangesDetected() {
1298         EnterpriseConfig eapConfig1 = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TLS);
1299         eapConfig1.enterpriseConfig.setCaCertificateAlias("ALIAS_1");
1300         eapConfig1.enterpriseConfig.setClientCertificateAlias("CLIENT_ALIAS_1");
1301 
1302         EnterpriseConfig eapConfig2 = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS);
1303         eapConfig2.enterpriseConfig.setCaCertificateAlias("ALIAS_1");
1304         eapConfig2.enterpriseConfig.setClientCertificateAlias("CLIENT_ALIAS_2");
1305 
1306         assertTrue(WifiConfigurationUtil.hasEnterpriseConfigChanged(eapConfig1.enterpriseConfig,
1307                 eapConfig2.enterpriseConfig));
1308     }
1309 
1310     /**
1311      * Verify WifiEnterpriseConfig OCSP changes are detected.
1312      */
1313     @Test
testOcspChangesDetected()1314     public void testOcspChangesDetected() {
1315         EnterpriseConfig eapConfig1 = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS)
1316                 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2)
1317                 .setIdentity("username", "password")
1318                 .setCaCerts(new X509Certificate[]{FakeKeys.CA_CERT0});
1319         eapConfig1.enterpriseConfig.setOcsp(OCSP_NONE);
1320 
1321         EnterpriseConfig eapConfig2 = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS)
1322                 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2)
1323                 .setIdentity("username", "password")
1324                 .setCaCerts(new X509Certificate[]{FakeKeys.CA_CERT0});
1325         eapConfig2.enterpriseConfig.setOcsp(OCSP_REQUIRE_CERT_STATUS);
1326 
1327         assertTrue(WifiConfigurationUtil.hasEnterpriseConfigChanged(eapConfig1.enterpriseConfig,
1328                 eapConfig2.enterpriseConfig));
1329     }
1330 
1331     /**
1332      * Verify WifiEnterpriseConfig Domain changes are detected.
1333      */
1334     @Test
testDomainNameChangesDetected()1335     public void testDomainNameChangesDetected() {
1336         EnterpriseConfig eapConfig1 = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TLS);
1337         eapConfig1.enterpriseConfig.setDomainSuffixMatch("wlan.android.com");
1338 
1339         EnterpriseConfig eapConfig2 = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS);
1340         eapConfig1.enterpriseConfig.setDomainSuffixMatch("wifi.android.com");
1341 
1342         assertTrue(WifiConfigurationUtil.hasEnterpriseConfigChanged(eapConfig1.enterpriseConfig,
1343                 eapConfig2.enterpriseConfig));
1344     }
1345 
1346     /**
1347      * Verify WifiEnterpriseConfig subject match changes are detected.
1348      */
1349     @Test
testSubjectMatchChangesDetected()1350     public void testSubjectMatchChangesDetected() {
1351         EnterpriseConfig eapConfig1 = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS)
1352                 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2)
1353                 .setIdentity("username", "password")
1354                 .setCaCerts(new X509Certificate[]{FakeKeys.CA_CERT0});
1355         eapConfig1.enterpriseConfig.setAltSubjectMatch("domain1.com");
1356 
1357         EnterpriseConfig eapConfig2 = new EnterpriseConfig(WifiEnterpriseConfig.Eap.TTLS)
1358                 .setPhase2(WifiEnterpriseConfig.Phase2.MSCHAPV2)
1359                 .setIdentity("username", "password")
1360                 .setCaCerts(new X509Certificate[]{FakeKeys.CA_CERT0});
1361         eapConfig1.enterpriseConfig.setAltSubjectMatch("domain2.com");
1362 
1363         assertTrue(WifiConfigurationUtil.hasEnterpriseConfigChanged(eapConfig1.enterpriseConfig,
1364                 eapConfig2.enterpriseConfig));
1365     }
1366 
1367     /**
1368      * Verify that new WifiEnterpriseConfig is detected.
1369      */
1370     @Test
testEnterpriseConfigWapiCertChanged()1371     public void testEnterpriseConfigWapiCertChanged() {
1372         EnterpriseConfig eapConfig1 = new EnterpriseConfig(WifiEnterpriseConfig.Eap.WAPI_CERT)
1373                 .setWapiCertSuite("WapiCertSuite1");
1374         EnterpriseConfig eapConfig2 = new EnterpriseConfig(WifiEnterpriseConfig.Eap.WAPI_CERT)
1375                 .setWapiCertSuite("WapiCertSuite2");
1376 
1377         assertTrue(WifiConfigurationUtil.hasEnterpriseConfigChanged(
1378                 eapConfig1.enterpriseConfig, eapConfig2.enterpriseConfig));
1379     }
1380 
1381     /**
1382      * Verify that a WAPI config is not considered an OPEN config.
1383      */
1384     @Test
testWapiConfigNotOpenConfig()1385     public void testWapiConfigNotOpenConfig() {
1386         WifiConfiguration wapiPskConfig = new WifiConfiguration();
1387         wapiPskConfig.setSecurityParams(WifiConfiguration.SECURITY_TYPE_WAPI_CERT);
1388         assertFalse(WifiConfigurationUtil.isConfigForOpenNetwork(wapiPskConfig));
1389 
1390         WifiConfiguration wapiCertConfig = new WifiConfiguration();
1391         wapiCertConfig.setSecurityParams(WifiConfiguration.SECURITY_TYPE_WAPI_CERT);
1392         assertFalse(WifiConfigurationUtil.isConfigForOpenNetwork(wapiCertConfig));
1393     }
1394 
1395     /**
1396      * Verify that a Passpoint config is not considered an OPEN config.
1397      */
1398     @Test
testPasspointConfigNotOpenConfig()1399     public void testPasspointConfigNotOpenConfig() {
1400         WifiConfiguration passpointR1R2Config = new WifiConfiguration();
1401         passpointR1R2Config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PASSPOINT_R1_R2);
1402         assertFalse(WifiConfigurationUtil.isConfigForOpenNetwork(passpointR1R2Config));
1403 
1404         WifiConfiguration passpointR3Config = new WifiConfiguration();
1405         passpointR3Config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PASSPOINT_R3);
1406         assertFalse(WifiConfigurationUtil.isConfigForOpenNetwork(passpointR3Config));
1407     }
1408 
1409     /**
1410      * Verify that the validate method fails to validate WifiConfiguration with malformed
1411      * enterprise configuration
1412      */
1413     @Test
testValidateNegativeCases_MalformedEnterpriseConfig()1414     public void testValidateNegativeCases_MalformedEnterpriseConfig() {
1415         WifiConfiguration config = new WifiConfiguration();
1416         config.SSID = "\"someNetwork\"";
1417         config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP);
1418         // EAP method is kept as Eap.NONE - should not crash, but return invalid ID
1419         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
1420                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
1421 
1422         config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE);
1423         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
1424                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
1425 
1426         config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT);
1427         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
1428                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
1429     }
1430 
1431     /**
1432      * Verify that the validate method fails to validate WifiConfiguration with enterprise
1433      * configuration that is missing the identity and/or password.
1434      */
1435     @Test
testValidateNegativeCases_NoIdentityOrPasswordEnterpriseConfig()1436     public void testValidateNegativeCases_NoIdentityOrPasswordEnterpriseConfig() {
1437         WifiConfiguration config = WifiConfigurationTestUtil.createEapNetwork();
1438         config.enterpriseConfig.setIdentity(null);
1439         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
1440                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
1441         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
1442                 WifiConfigurationUtil.VALIDATE_FOR_UPDATE));
1443 
1444         config = WifiConfigurationTestUtil.createEapNetwork();
1445         config.enterpriseConfig.setPassword(null);
1446         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
1447                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
1448         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
1449                 WifiConfigurationUtil.VALIDATE_FOR_UPDATE));
1450 
1451         config = WifiConfigurationTestUtil.createWpa3EnterpriseNetwork(TEST_SSID);
1452         config.enterpriseConfig.setIdentity(null);
1453         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
1454                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
1455         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
1456                 WifiConfigurationUtil.VALIDATE_FOR_UPDATE));
1457 
1458         config = WifiConfigurationTestUtil.createWpa3EnterpriseNetwork(TEST_SSID);
1459         config.enterpriseConfig.setPassword(null);
1460         assertFalse(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
1461                 WifiConfigurationUtil.VALIDATE_FOR_ADD));
1462         assertTrue(WifiConfigurationUtil.validate(config, SUPPORTED_FEATURES_ALL,
1463                 WifiConfigurationUtil.VALIDATE_FOR_UPDATE));
1464     }
1465 
1466     /**
1467      * Verify that the validate method fails to validate WifiConfiguration with DPP AKM
1468      * security type if DPP AKM is not supported by the device, and succeeds if it is supported.
1469      */
1470     @Test
testValidateSecurityTypeDppAkm()1471     public void testValidateSecurityTypeDppAkm() {
1472         long supportedFeatures = SUPPORTED_FEATURES_ALL & ~WifiManager.WIFI_FEATURE_DPP_AKM;
1473         WifiConfiguration config = WifiConfigurationTestUtil.createOpenNetwork();
1474         config.setSecurityParams(WifiInfo.SECURITY_TYPE_DPP);
1475 
1476         assertFalse(WifiConfigurationUtil.validate(config, supportedFeatures,
1477                   WifiConfigurationUtil.VALIDATE_FOR_ADD));
1478         assertFalse(WifiConfigurationUtil.validate(config, supportedFeatures,
1479                   WifiConfigurationUtil.VALIDATE_FOR_UPDATE));
1480 
1481         supportedFeatures = WifiManager.WIFI_FEATURE_DPP_AKM;
1482         assertTrue(WifiConfigurationUtil.validate(config, supportedFeatures,
1483                   WifiConfigurationUtil.VALIDATE_FOR_ADD));
1484         assertTrue(WifiConfigurationUtil.validate(config, supportedFeatures,
1485                   WifiConfigurationUtil.VALIDATE_FOR_UPDATE));
1486     }
1487 
1488     @Test
testConvertMultiTypeConfigsToLegacyConfigs()1489     public void testConvertMultiTypeConfigsToLegacyConfigs() {
1490         assumeTrue(SdkLevel.isAtLeastS());
1491         List<WifiConfiguration> expectedResult = new ArrayList<>();
1492         List<WifiConfiguration> multiTypeConfigs = new ArrayList<>();
1493 
1494         // Genreate configurations
1495         WifiConfiguration pskSaeConfig = new WifiConfiguration();
1496         pskSaeConfig.addSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK);
1497         // PSK is disabled in this configuration.
1498         pskSaeConfig.setSecurityParamsEnabled(WifiConfiguration.SECURITY_TYPE_PSK, false);
1499         pskSaeConfig.addSecurityParams(WifiConfiguration.SECURITY_TYPE_SAE);
1500 
1501         WifiConfiguration openOweConfig = new WifiConfiguration();
1502         openOweConfig.addSecurityParams(WifiConfiguration.SECURITY_TYPE_OPEN);
1503         openOweConfig.addSecurityParams(WifiConfiguration.SECURITY_TYPE_OWE);
1504 
1505         WifiConfiguration pskConfig = new WifiConfiguration();
1506         pskConfig.addSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK);
1507         pskConfig.setSecurityParamsEnabled(WifiConfiguration.SECURITY_TYPE_PSK, false);
1508         pskConfig.getNetworkSelectionStatus().setNetworkSelectionDisableReason(
1509                 WifiConfiguration.NetworkSelectionStatus
1510                         .DISABLED_TRANSITION_DISABLE_INDICATION);
1511         pskConfig.getNetworkSelectionStatus().setDisableReasonCounter(
1512                 WifiConfiguration.NetworkSelectionStatus
1513                         .DISABLED_TRANSITION_DISABLE_INDICATION, 1);
1514 
1515         WifiConfiguration saeConfig = new WifiConfiguration();
1516         saeConfig.addSecurityParams(WifiConfiguration.SECURITY_TYPE_SAE);
1517 
1518         WifiConfiguration openConfig = new WifiConfiguration();
1519         openConfig.addSecurityParams(WifiConfiguration.SECURITY_TYPE_OPEN);
1520 
1521         WifiConfiguration oweConfig = new WifiConfiguration();
1522         oweConfig.addSecurityParams(WifiConfiguration.SECURITY_TYPE_OWE);
1523 
1524         // Prepare the input
1525         multiTypeConfigs.add(pskSaeConfig);
1526         multiTypeConfigs.add(openOweConfig);
1527 
1528         // Prepare expected results
1529         expectedResult.clear();
1530         expectedResult.add(pskConfig);
1531         expectedResult.add(saeConfig);
1532         expectedResult.add(openConfig);
1533         expectedResult.add(oweConfig);
1534         List<WifiConfiguration> singleTypeConfigsWithDisabledType =
1535                 WifiConfigurationUtil.convertMultiTypeConfigsToLegacyConfigs(
1536                         multiTypeConfigs, false);
1537         WifiConfigurationTestUtil.assertConfigurationsEqualForBackup(
1538                 expectedResult, singleTypeConfigsWithDisabledType);
1539 
1540         // Prepare expected results
1541         expectedResult.clear();
1542         expectedResult.add(saeConfig);
1543         expectedResult.add(openConfig);
1544         expectedResult.add(oweConfig);
1545         List<WifiConfiguration> singleTypeConfigsWithoutDisabledType =
1546                 WifiConfigurationUtil.convertMultiTypeConfigsToLegacyConfigs(
1547                         multiTypeConfigs, true);
1548         WifiConfigurationTestUtil.assertConfigurationsEqualForBackup(
1549                 expectedResult, singleTypeConfigsWithoutDisabledType);
1550     }
1551 
1552     @Test
testIsConfigLinkable()1553     public void testIsConfigLinkable() throws Exception {
1554         WifiConfiguration openConfig = WifiConfigurationTestUtil.createOpenNetwork();
1555 
1556         WifiConfiguration pskConfig = WifiConfigurationTestUtil.createPskNetwork();
1557 
1558         WifiConfiguration pskDisabledConfig = WifiConfigurationTestUtil.createPskNetwork();
1559         pskDisabledConfig.setSecurityParamsEnabled(WifiConfiguration.SECURITY_TYPE_PSK, false);
1560 
1561         WifiConfiguration saeConfig = WifiConfigurationTestUtil.createSaeNetwork();
1562 
1563         WifiConfiguration saeDisabledConfig = WifiConfigurationTestUtil.createSaeNetwork();
1564         saeDisabledConfig.setSecurityParamsEnabled(WifiConfiguration.SECURITY_TYPE_SAE, false);
1565 
1566         when(mWifiGlobals.isWpa3SaeUpgradeOffloadEnabled()).thenReturn(false);
1567         assertFalse(WifiConfigurationUtil.isConfigLinkable(openConfig));
1568         assertTrue(WifiConfigurationUtil.isConfigLinkable(pskConfig));
1569         assertFalse(WifiConfigurationUtil.isConfigLinkable(pskDisabledConfig));
1570         assertFalse(WifiConfigurationUtil.isConfigLinkable(saeConfig));
1571         assertFalse(WifiConfigurationUtil.isConfigLinkable(saeDisabledConfig));
1572 
1573         when(mWifiGlobals.isWpa3SaeUpgradeOffloadEnabled()).thenReturn(true);
1574         assertFalse(WifiConfigurationUtil.isConfigLinkable(openConfig));
1575         assertTrue(WifiConfigurationUtil.isConfigLinkable(pskConfig));
1576         assertFalse(WifiConfigurationUtil.isConfigLinkable(pskDisabledConfig));
1577         assertTrue(WifiConfigurationUtil.isConfigLinkable(saeConfig));
1578         assertFalse(WifiConfigurationUtil.isConfigLinkable(saeDisabledConfig));
1579     }
1580 }
1581