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 android.net.wifi;
18 
19 import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_EAP;
20 import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE;
21 import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT;
22 import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_OPEN;
23 import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_OSEN;
24 import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_OWE;
25 import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_PASSPOINT_R1_R2;
26 import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_PASSPOINT_R3;
27 import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_PSK;
28 import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_SAE;
29 import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_WAPI_CERT;
30 import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_WAPI_PSK;
31 import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_WEP;
32 
33 import static org.junit.Assert.assertArrayEquals;
34 import static org.junit.Assert.assertEquals;
35 import static org.junit.Assert.assertFalse;
36 import static org.junit.Assert.assertNotNull;
37 import static org.junit.Assert.assertNotSame;
38 import static org.junit.Assert.assertTrue;
39 import static org.junit.Assume.assumeFalse;
40 import static org.junit.Assume.assumeTrue;
41 
42 import android.net.MacAddress;
43 import android.net.wifi.WifiConfiguration.GroupCipher;
44 import android.net.wifi.WifiConfiguration.KeyMgmt;
45 import android.net.wifi.WifiConfiguration.NetworkSelectionStatus;
46 import android.net.wifi.WifiConfiguration.PairwiseCipher;
47 import android.net.wifi.WifiConfiguration.Protocol;
48 import android.os.Parcel;
49 import android.util.Pair;
50 
51 import androidx.test.filters.SmallTest;
52 
53 import com.android.modules.utils.build.SdkLevel;
54 import com.android.net.module.util.MacAddressUtils;
55 
56 import org.junit.Before;
57 import org.junit.Test;
58 
59 import java.util.ArrayList;
60 import java.util.BitSet;
61 import java.util.List;
62 
63 /**
64  * Unit tests for {@link android.net.wifi.WifiConfiguration}.
65  */
66 @SmallTest
67 public class WifiConfigurationTest {
68     private static final String TEST_PASSPOINT_UNIQUE_ID = "uniqueId";
69     private static final int TEST_CARRIER_ID = 1234;
70     private static final int TEST_SUB_ID = 3;
71     private static final String TEST_PACKAGE_NAME = "google.com";
72 
73     @Before
setUp()74     public void setUp() {
75     }
76 
77     /**
78      * Check that parcel marshalling/unmarshalling works
79      *
80      * Create and populate a WifiConfiguration.
81      * Marshall and unmashall it, and expect to recover a copy of the original.
82      * Marshall the resulting object, and expect the bytes to match the
83      * first marshall result.
84      */
85     @Test
testWifiConfigurationParcel()86     public void testWifiConfigurationParcel() {
87         String cookie = "C O.o |<IE";
88         WifiConfiguration config = new WifiConfiguration();
89         config.setPasspointManagementObjectTree(cookie);
90         config.trusted = false;
91         config.oemPaid = true;
92         config.oemPrivate = true;
93         config.carrierMerged = true;
94         config.updateIdentifier = "1234";
95         config.fromWifiNetworkSpecifier = true;
96         config.fromWifiNetworkSuggestion = true;
97         config.setRandomizedMacAddress(MacAddressUtils.createRandomUnicastAddress());
98         MacAddress macBeforeParcel = config.getRandomizedMacAddress();
99         config.subscriptionId = 1;
100         config.carrierId = 1189;
101         Parcel parcelW = Parcel.obtain();
102         config.writeToParcel(parcelW, 0);
103         byte[] bytes = parcelW.marshall();
104         parcelW.recycle();
105 
106         Parcel parcelR = Parcel.obtain();
107         parcelR.unmarshall(bytes, 0, bytes.length);
108         parcelR.setDataPosition(0);
109         WifiConfiguration reconfig = WifiConfiguration.CREATOR.createFromParcel(parcelR);
110 
111         // lacking a useful config.equals, check two fields near the end.
112         assertEquals(cookie, reconfig.getMoTree());
113         assertEquals(macBeforeParcel, reconfig.getRandomizedMacAddress());
114         assertEquals(config.updateIdentifier, reconfig.updateIdentifier);
115         assertFalse(reconfig.trusted);
116         assertTrue(reconfig.fromWifiNetworkSpecifier);
117         assertTrue(reconfig.fromWifiNetworkSuggestion);
118         assertTrue(reconfig.oemPaid);
119         assertTrue(reconfig.oemPrivate);
120         assertTrue(reconfig.carrierMerged);
121 
122         Parcel parcelWW = Parcel.obtain();
123         reconfig.writeToParcel(parcelWW, 0);
124         byte[] rebytes = parcelWW.marshall();
125         parcelWW.recycle();
126 
127         assertArrayEquals(bytes, rebytes);
128     }
129 
130     @Test
testWifiConfigurationCopyConstructor()131     public void testWifiConfigurationCopyConstructor() {
132         WifiConfiguration config = new WifiConfiguration();
133         config.trusted = false;
134         config.oemPaid = true;
135         config.oemPrivate = true;
136         config.carrierMerged = true;
137         config.updateIdentifier = "1234";
138         config.fromWifiNetworkSpecifier = true;
139         config.fromWifiNetworkSuggestion = true;
140         config.setRandomizedMacAddress(MacAddressUtils.createRandomUnicastAddress());
141         MacAddress macBeforeParcel = config.getRandomizedMacAddress();
142         config.subscriptionId = 1;
143         config.carrierId = 1189;
144 
145         WifiConfiguration reconfig = new WifiConfiguration(config);
146 
147         // lacking a useful config.equals, check two fields near the end.
148         assertEquals(macBeforeParcel, reconfig.getRandomizedMacAddress());
149         assertEquals(config.updateIdentifier, reconfig.updateIdentifier);
150         assertFalse(reconfig.trusted);
151         assertTrue(reconfig.fromWifiNetworkSpecifier);
152         assertTrue(reconfig.fromWifiNetworkSuggestion);
153         assertTrue(reconfig.oemPaid);
154         assertTrue(reconfig.oemPrivate);
155         assertTrue(reconfig.carrierMerged);
156     }
157 
158     @Test
testIsOpenNetwork_IsOpen_NullWepKeys()159     public void testIsOpenNetwork_IsOpen_NullWepKeys() {
160         WifiConfiguration config = new WifiConfiguration();
161         config.allowedKeyManagement.clear();
162         config.wepKeys = null;
163 
164         assertTrue(config.isOpenNetwork());
165     }
166 
167     @Test
testIsOpenNetwork_IsOpen_ZeroLengthWepKeysArray()168     public void testIsOpenNetwork_IsOpen_ZeroLengthWepKeysArray() {
169         WifiConfiguration config = new WifiConfiguration();
170         config.allowedKeyManagement.clear();
171         config.wepKeys = new String[0];
172 
173         assertTrue(config.isOpenNetwork());
174     }
175 
176     @Test
testIsOpenNetwork_IsOpen_NullWepKeysArray()177     public void testIsOpenNetwork_IsOpen_NullWepKeysArray() {
178         WifiConfiguration config = new WifiConfiguration();
179         config.allowedKeyManagement.clear();
180         config.wepKeys = new String[1];
181 
182         assertTrue(config.isOpenNetwork());
183     }
184 
185     @Test
testIsOpenNetwork_NotOpen_HasWepKeys()186     public void testIsOpenNetwork_NotOpen_HasWepKeys() {
187         WifiConfiguration config = new WifiConfiguration();
188         config.allowedKeyManagement.clear();
189         config.wepKeys = new String[] {"test"};
190 
191         assertFalse(config.isOpenNetwork());
192     }
193 
194     @Test
testIsOpenNetwork_NotOpen_HasNullWepKeyFollowedByNonNullKey()195     public void testIsOpenNetwork_NotOpen_HasNullWepKeyFollowedByNonNullKey() {
196         WifiConfiguration config = new WifiConfiguration();
197         config.allowedKeyManagement.clear();
198         config.wepKeys = new String[] {null, null, "test"};
199 
200         assertFalse(config.isOpenNetwork());
201     }
202 
203     @Test
testIsOpenNetwork_NotOpen_HasAuthType()204     public void testIsOpenNetwork_NotOpen_HasAuthType() {
205         int[] securityTypes = new int [] {
206                 SECURITY_TYPE_WEP,
207                 SECURITY_TYPE_PSK,
208                 SECURITY_TYPE_EAP,
209                 SECURITY_TYPE_SAE,
210                 SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT,
211                 SECURITY_TYPE_WAPI_PSK,
212                 SECURITY_TYPE_WAPI_CERT,
213                 SECURITY_TYPE_EAP_WPA3_ENTERPRISE,
214                 SECURITY_TYPE_OSEN,
215         };
216         for (int type: securityTypes) {
217             WifiConfiguration config = new WifiConfiguration();
218             config.setSecurityParams(type);
219             config.wepKeys = null;
220 
221             assertFalse("Open network reported when security type was set to "
222                             + type, config.isOpenNetwork());
223         }
224     }
225 
226     @Test
testIsOpenNetwork_NotOpen_HasAuthTypeNoneAndMore()227     public void testIsOpenNetwork_NotOpen_HasAuthTypeNoneAndMore() {
228         WifiConfiguration config = new WifiConfiguration();
229         config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
230         config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_EAP);
231         config.wepKeys = null;
232         config.convertLegacyFieldsToSecurityParamsIfNeeded();
233 
234         assertFalse(config.isOpenNetwork());
235     }
236 
237     @Test
testSetRandomizedMacAddress_ChangesSavedAddress()238     public void testSetRandomizedMacAddress_ChangesSavedAddress() {
239         WifiConfiguration config = new WifiConfiguration();
240         MacAddress defaultMac = MacAddress.fromString(WifiInfo.DEFAULT_MAC_ADDRESS);
241         assertEquals(defaultMac, config.getRandomizedMacAddress());
242 
243         MacAddress macToChangeInto = MacAddressUtils.createRandomUnicastAddress();
244         config.setRandomizedMacAddress(macToChangeInto);
245         MacAddress macAfterChange = config.getRandomizedMacAddress();
246 
247         assertEquals(macToChangeInto, macAfterChange);
248     }
249 
250     @Test
testSetRandomizedMacAddress_DoesNothingWhenNull()251     public void testSetRandomizedMacAddress_DoesNothingWhenNull() {
252         WifiConfiguration config = new WifiConfiguration();
253         MacAddress defaultMac = MacAddress.fromString(WifiInfo.DEFAULT_MAC_ADDRESS);
254         config.setRandomizedMacAddress(null);
255         assertEquals(defaultMac, config.getRandomizedMacAddress());
256     }
257 
258     /**
259      * Verifies that updateIdentifier should be copied for copy constructor.
260      */
261     @Test
testUpdateIdentifierForCopyConstructor()262     public void testUpdateIdentifierForCopyConstructor() {
263         WifiConfiguration config = new WifiConfiguration();
264         config.updateIdentifier = "1234";
265         WifiConfiguration copyConfig = new WifiConfiguration(config);
266 
267         assertEquals(config.updateIdentifier, copyConfig.updateIdentifier);
268     }
269 
270     /**
271      * Verifies that getKeyIdForCredentials returns the expected string for Enterprise networks
272      * @throws Exception
273      */
274     @Test
testGetKeyIdForCredentials()275     public void testGetKeyIdForCredentials() throws Exception {
276         WifiConfiguration config = new WifiConfiguration();
277         final String mSsid = "TestAP";
278         config.SSID = mSsid;
279 
280         // Test various combinations
281         // EAP with TLS
282         config.allowedKeyManagement.set(KeyMgmt.WPA_EAP);
283         config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.TLS);
284         config.enterpriseConfig.setPhase2Method(WifiEnterpriseConfig.Phase2.NONE);
285         String keyId = config.getKeyIdForCredentials(config);
286         assertEquals(keyId, mSsid + "_WPA_EAP_TLS_NULL");
287 
288         // EAP with TTLS & MSCHAPv2
289         config.allowedKeyManagement.set(KeyMgmt.WPA_EAP);
290         config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.TTLS);
291         config.enterpriseConfig.setPhase2Method(WifiEnterpriseConfig.Phase2.MSCHAPV2);
292         keyId = config.getKeyIdForCredentials(config);
293         assertEquals(keyId, mSsid + "_WPA_EAP_TTLS_MSCHAPV2");
294 
295         // Suite-B 192 with PWD & GTC
296         config.allowedKeyManagement.clear();
297         config.allowedKeyManagement.set(KeyMgmt.SUITE_B_192);
298         config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.PWD);
299         config.enterpriseConfig.setPhase2Method(WifiEnterpriseConfig.Phase2.GTC);
300         keyId = config.getKeyIdForCredentials(config);
301         assertEquals(keyId, mSsid + "_SUITE_B_192_PWD_GTC");
302 
303         // IEEE8021X with SIM
304         config.allowedKeyManagement.clear();
305         config.allowedKeyManagement.set(KeyMgmt.IEEE8021X);
306         config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.SIM);
307         config.enterpriseConfig.setPhase2Method(WifiEnterpriseConfig.Phase2.NONE);
308         keyId = config.getKeyIdForCredentials(config);
309         assertEquals(keyId, mSsid + "_IEEE8021X_SIM_NULL");
310 
311         // Try calling this method with non-Enterprise network, expect an exception
312         boolean exceptionThrown = false;
313         try {
314             config.allowedKeyManagement.clear();
315             config.allowedKeyManagement.set(KeyMgmt.WPA2_PSK);
316             config.preSharedKey = "TestPsk";
317             keyId = config.getKeyIdForCredentials(config);
318         } catch (IllegalStateException e) {
319             exceptionThrown = true;
320         }
321         assertTrue(exceptionThrown);
322     }
323 
324     /**
325      * Verifies that getKeyIdForCredentials returns the expected string for Suggestion Enterprise
326      * networks
327      * @throws Exception
328      */
329     @Test
testGetKeyIdForCredentialsForSuggestion()330     public void testGetKeyIdForCredentialsForSuggestion() throws Exception {
331         WifiConfiguration config = new WifiConfiguration();
332         final String mSsid = "TestAP";
333         final String packageName = "TestApp";
334         final String bSsid = MacAddressUtils.createRandomUnicastAddress().toString();
335         String suggestionSuffix = "_" + bSsid + "_" + packageName;
336         config.SSID = mSsid;
337         config.fromWifiNetworkSuggestion = true;
338         config.creatorName = packageName;
339         config.BSSID = bSsid;
340 
341         // Test various combinations
342         // EAP with TLS
343         config.allowedKeyManagement.set(KeyMgmt.WPA_EAP);
344         config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.TLS);
345         config.enterpriseConfig.setPhase2Method(WifiEnterpriseConfig.Phase2.NONE);
346         String keyId = config.getKeyIdForCredentials(config);
347         assertEquals(keyId, mSsid + "_WPA_EAP_TLS_NULL" + suggestionSuffix);
348 
349         // EAP with TTLS & MSCHAPv2
350         config.allowedKeyManagement.set(KeyMgmt.WPA_EAP);
351         config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.TTLS);
352         config.enterpriseConfig.setPhase2Method(WifiEnterpriseConfig.Phase2.MSCHAPV2);
353         keyId = config.getKeyIdForCredentials(config);
354         assertEquals(keyId, mSsid + "_WPA_EAP_TTLS_MSCHAPV2" + suggestionSuffix);
355 
356         // Suite-B 192 with PWD & GTC
357         config.allowedKeyManagement.clear();
358         config.allowedKeyManagement.set(KeyMgmt.SUITE_B_192);
359         config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.PWD);
360         config.enterpriseConfig.setPhase2Method(WifiEnterpriseConfig.Phase2.GTC);
361         keyId = config.getKeyIdForCredentials(config);
362         assertEquals(keyId, mSsid + "_SUITE_B_192_PWD_GTC" + suggestionSuffix);
363 
364         // IEEE8021X with SIM
365         config.allowedKeyManagement.clear();
366         config.allowedKeyManagement.set(KeyMgmt.IEEE8021X);
367         config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.SIM);
368         config.enterpriseConfig.setPhase2Method(WifiEnterpriseConfig.Phase2.NONE);
369         keyId = config.getKeyIdForCredentials(config);
370         assertEquals(keyId, mSsid + "_IEEE8021X_SIM_NULL" + suggestionSuffix);
371 
372         // Try calling this method with non-Enterprise network, expect an exception
373         boolean exceptionThrown = false;
374         try {
375             config.allowedKeyManagement.clear();
376             config.allowedKeyManagement.set(KeyMgmt.WPA2_PSK);
377             config.preSharedKey = "TestPsk";
378             keyId = config.getKeyIdForCredentials(config);
379         } catch (IllegalStateException e) {
380             exceptionThrown = true;
381         }
382         assertTrue(exceptionThrown);
383     }
384 
385     /**
386      * Verifies that getSsidAndSecurityTypeString returns the correct String for networks of
387      * various different security types
388      */
389     @Test
testGetSsidAndSecurityTypeString()390     public void testGetSsidAndSecurityTypeString() {
391         WifiConfiguration config = new WifiConfiguration();
392         final String mSsid = "TestAP";
393         config.SSID = mSsid;
394 
395         // Test various combinations
396         config.allowedKeyManagement.set(KeyMgmt.WPA_PSK);
397         assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.WPA_PSK],
398                 config.getSsidAndSecurityTypeString());
399 
400         config.allowedKeyManagement.clear();
401         config.allowedKeyManagement.set(KeyMgmt.WPA_EAP);
402         assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.WPA_EAP],
403                 config.getSsidAndSecurityTypeString());
404 
405         config.wepKeys[0] = "TestWep";
406         config.allowedKeyManagement.clear();
407         assertEquals(mSsid + "WEP", config.getSsidAndSecurityTypeString());
408 
409         // set WEP key and give a valid index.
410         config.wepKeys[0] = null;
411         config.wepKeys[2] = "TestWep";
412         config.wepTxKeyIndex = 2;
413         config.allowedKeyManagement.clear();
414         assertEquals(mSsid + "WEP", config.getSsidAndSecurityTypeString());
415 
416         // set WEP key but does not give a valid index.
417         config.wepKeys[0] = null;
418         config.wepKeys[2] = "TestWep";
419         config.wepTxKeyIndex = 0;
420         config.allowedKeyManagement.clear();
421         config.allowedKeyManagement.set(KeyMgmt.OWE);
422         assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.OWE], config.getSsidAndSecurityTypeString());
423 
424         config.wepKeys[0] = null;
425         config.wepTxKeyIndex = 0;
426         config.allowedKeyManagement.clear();
427         config.allowedKeyManagement.set(KeyMgmt.OWE);
428         assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.OWE], config.getSsidAndSecurityTypeString());
429 
430         config.allowedKeyManagement.clear();
431         config.allowedKeyManagement.set(KeyMgmt.SAE);
432         assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.SAE], config.getSsidAndSecurityTypeString());
433 
434         config.allowedKeyManagement.clear();
435         config.allowedKeyManagement.set(KeyMgmt.SUITE_B_192);
436         assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.SUITE_B_192],
437                 config.getSsidAndSecurityTypeString());
438 
439         config.allowedKeyManagement.clear();
440         config.allowedKeyManagement.set(KeyMgmt.NONE);
441         assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.NONE], config.getSsidAndSecurityTypeString());
442 
443         config.allowedKeyManagement.clear();
444         config.allowedKeyManagement.set(KeyMgmt.WAPI_PSK);
445         assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.WAPI_PSK],
446                 config.getSsidAndSecurityTypeString());
447 
448         config.allowedKeyManagement.clear();
449         config.allowedKeyManagement.set(KeyMgmt.WAPI_CERT);
450         assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.WAPI_CERT],
451                 config.getSsidAndSecurityTypeString());
452     }
453 
454     /**
455      * Verifies that getNetworkKey returns the correct String for networks of
456      * various different security types, the result should be stable.
457      */
458     @Test
testGetNetworkKeyString()459     public void testGetNetworkKeyString() {
460         WifiConfiguration config = new WifiConfiguration();
461         final String mSsid = "TestAP";
462         config.SSID = mSsid;
463 
464         // Test various combinations
465         config.allowedKeyManagement.set(KeyMgmt.WPA_PSK);
466         assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.WPA_PSK],
467                 config.getNetworkKey());
468 
469         config.allowedKeyManagement.clear();
470         config.allowedKeyManagement.set(KeyMgmt.WPA_EAP);
471         assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.WPA_EAP],
472                 config.getNetworkKey());
473 
474         config.wepKeys[0] = "TestWep";
475         config.allowedKeyManagement.clear();
476         assertEquals(mSsid + "WEP", config.getNetworkKey());
477 
478         // set WEP key and give a valid index.
479         config.wepKeys[0] = null;
480         config.wepKeys[2] = "TestWep";
481         config.wepTxKeyIndex = 2;
482         config.allowedKeyManagement.clear();
483         assertEquals(mSsid + "WEP", config.getNetworkKey());
484 
485         // set WEP key but does not give a valid index.
486         config.wepKeys[0] = null;
487         config.wepKeys[2] = "TestWep";
488         config.wepTxKeyIndex = 0;
489         config.allowedKeyManagement.clear();
490         config.allowedKeyManagement.set(KeyMgmt.OWE);
491         assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.OWE], config.getNetworkKey());
492 
493         config.wepKeys[0] = null;
494         config.wepTxKeyIndex = 0;
495         config.allowedKeyManagement.clear();
496         config.allowedKeyManagement.set(KeyMgmt.OWE);
497         assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.OWE], config.getNetworkKey());
498 
499         config.allowedKeyManagement.clear();
500         config.allowedKeyManagement.set(KeyMgmt.SAE);
501         assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.SAE], config.getNetworkKey());
502 
503         config.allowedKeyManagement.clear();
504         config.allowedKeyManagement.set(KeyMgmt.SUITE_B_192);
505         assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.SUITE_B_192],
506                 config.getNetworkKey());
507 
508         config.allowedKeyManagement.clear();
509         config.allowedKeyManagement.set(KeyMgmt.NONE);
510         assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.NONE], config.getNetworkKey());
511 
512         config.allowedKeyManagement.clear();
513         config.allowedKeyManagement.set(KeyMgmt.WAPI_PSK);
514         assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.WAPI_PSK],
515                 config.getNetworkKey());
516 
517         config.allowedKeyManagement.clear();
518         config.allowedKeyManagement.set(KeyMgmt.WAPI_CERT);
519         assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.WAPI_CERT],
520                 config.getNetworkKey());
521 
522         config.allowedKeyManagement.clear();
523         config.setPasspointUniqueId(TEST_PASSPOINT_UNIQUE_ID);
524         assertEquals(TEST_PASSPOINT_UNIQUE_ID, config.getNetworkKey());
525     }
526 
527     /**
528      * Ensure that the {@link NetworkSelectionStatus.DisableReasonInfo}s are populated in
529      * {@link NetworkSelectionStatus#DISABLE_REASON_INFOS} for reason codes from 0 to
530      * {@link NetworkSelectionStatus#NETWORK_SELECTION_DISABLED_MAX} - 1.
531      */
532     @Test
testNetworkSelectionDisableReasonInfosPopulated()533     public void testNetworkSelectionDisableReasonInfosPopulated() {
534         assertEquals(NetworkSelectionStatus.NETWORK_SELECTION_DISABLED_MAX,
535                 NetworkSelectionStatus.DISABLE_REASON_INFOS.size());
536         for (int i = 0; i < NetworkSelectionStatus.NETWORK_SELECTION_DISABLED_MAX; i++) {
537             assertNotNull(NetworkSelectionStatus.DISABLE_REASON_INFOS.get(i));
538         }
539     }
540 
541     /**
542      * Ensure that {@link NetworkSelectionStatus#getMaxNetworkSelectionDisableReason()} returns
543      * the maximum disable reason.
544      */
545     @Test
testNetworkSelectionGetMaxNetworkSelectionDisableReason()546     public void testNetworkSelectionGetMaxNetworkSelectionDisableReason() {
547         int maxReason = Integer.MIN_VALUE;
548         for (int i = 0; i < NetworkSelectionStatus.DISABLE_REASON_INFOS.size(); i++) {
549             int reason = NetworkSelectionStatus.DISABLE_REASON_INFOS.keyAt(i);
550             maxReason = Math.max(maxReason, reason);
551         }
552         assertEquals(maxReason, NetworkSelectionStatus.getMaxNetworkSelectionDisableReason());
553     }
554 
555     /**
556      * Ensure that {@link WifiConfiguration#setSecurityParams(int)} sets up the
557      * {@link WifiConfiguration} object correctly for SAE security type.
558      * @throws Exception
559      */
560     @Test
testSetSecurityParamsForSae()561     public void testSetSecurityParamsForSae() throws Exception {
562         WifiConfiguration config = new WifiConfiguration();
563 
564         config.setSecurityParams(SECURITY_TYPE_SAE);
565 
566         assertTrue(config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.SAE));
567         assertTrue(config.allowedPairwiseCiphers.get(WifiConfiguration.PairwiseCipher.CCMP));
568         assertTrue(config.allowedPairwiseCiphers.get(WifiConfiguration.PairwiseCipher.GCMP_256));
569         assertTrue(config.allowedGroupCiphers.get(WifiConfiguration.GroupCipher.CCMP));
570         assertTrue(config.allowedGroupCiphers.get(WifiConfiguration.GroupCipher.GCMP_256));
571         assertTrue(config.requirePmf);
572     }
573 
574     /**
575      * Ensure that {@link WifiConfiguration#setSecurityParams(int)} sets up the
576      * {@link WifiConfiguration} object correctly for OWE security type.
577      * @throws Exception
578      */
579     @Test
testSetSecurityParamsForOwe()580     public void testSetSecurityParamsForOwe() throws Exception {
581         WifiConfiguration config = new WifiConfiguration();
582 
583         config.setSecurityParams(SECURITY_TYPE_OWE);
584 
585         assertTrue(config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.OWE));
586         assertTrue(config.allowedPairwiseCiphers.get(WifiConfiguration.PairwiseCipher.CCMP));
587         assertTrue(config.allowedPairwiseCiphers.get(WifiConfiguration.PairwiseCipher.GCMP_256));
588         assertTrue(config.allowedGroupCiphers.get(WifiConfiguration.GroupCipher.CCMP));
589         assertTrue(config.allowedGroupCiphers.get(WifiConfiguration.GroupCipher.GCMP_256));
590         assertTrue(config.requirePmf);
591     }
592 
593     /**
594      * Ensure that {@link WifiConfiguration#setSecurityParams(int)} sets up the
595      * {@link WifiConfiguration} object correctly for Suite-B security type.
596      * @throws Exception
597      */
598     @Test
testSetSecurityParamsForSuiteB()599     public void testSetSecurityParamsForSuiteB() throws Exception {
600         WifiConfiguration config = new WifiConfiguration();
601 
602         config.setSecurityParams(SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT);
603 
604         assertTrue(config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.SUITE_B_192));
605         assertTrue(config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.WPA_EAP));
606         assertTrue(config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.IEEE8021X));
607         assertTrue(config.allowedPairwiseCiphers.get(WifiConfiguration.PairwiseCipher.GCMP_256));
608         assertTrue(config.allowedGroupCiphers.get(WifiConfiguration.GroupCipher.GCMP_256));
609         assertTrue(config.allowedGroupManagementCiphers
610                 .get(WifiConfiguration.GroupMgmtCipher.BIP_GMAC_256));
611         assertTrue(config.requirePmf);
612     }
613 
614     /**
615      * Ensure that {@link WifiConfiguration#setSecurityParams(int)} sets up the
616      * {@link WifiConfiguration} object correctly for WPA3 Enterprise security type.
617      * @throws Exception
618      */
619     @Test
testSetSecurityParamsForWpa3Enterprise()620     public void testSetSecurityParamsForWpa3Enterprise() throws Exception {
621         WifiConfiguration config = new WifiConfiguration();
622 
623         config.setSecurityParams(SECURITY_TYPE_EAP_WPA3_ENTERPRISE);
624 
625         assertTrue(config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.WPA_EAP));
626         assertTrue(config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.IEEE8021X));
627         assertTrue(config.allowedPairwiseCiphers.get(WifiConfiguration.PairwiseCipher.CCMP));
628         assertTrue(config.allowedPairwiseCiphers.get(WifiConfiguration.PairwiseCipher.GCMP_256));
629         assertTrue(config.allowedGroupCiphers.get(WifiConfiguration.GroupCipher.CCMP));
630         assertTrue(config.allowedGroupCiphers.get(WifiConfiguration.GroupCipher.GCMP_256));
631         assertTrue(config.requirePmf);
632     }
633 
634     /**
635      * Test that the NetworkSelectionStatus Builder returns the same values that was set, and that
636      * calling build multiple times returns different instances.
637      */
638     @Test
testNetworkSelectionStatusBuilder()639     public void testNetworkSelectionStatusBuilder() throws Exception {
640         NetworkSelectionStatus.Builder builder = new NetworkSelectionStatus.Builder()
641                 .setNetworkSelectionDisableReason(
642                         NetworkSelectionStatus.DISABLED_ASSOCIATION_REJECTION)
643                 .setNetworkSelectionStatus(
644                         NetworkSelectionStatus.NETWORK_SELECTION_PERMANENTLY_DISABLED);
645 
646         NetworkSelectionStatus status1 = builder.build();
647 
648         assertEquals(NetworkSelectionStatus.DISABLED_ASSOCIATION_REJECTION,
649                 status1.getNetworkSelectionDisableReason());
650         assertEquals(NetworkSelectionStatus.NETWORK_SELECTION_PERMANENTLY_DISABLED,
651                 status1.getNetworkSelectionStatus());
652 
653         NetworkSelectionStatus status2 = builder
654                 .setNetworkSelectionDisableReason(NetworkSelectionStatus.DISABLED_BY_WRONG_PASSWORD)
655                 .build();
656 
657         // different instances
658         assertNotSame(status1, status2);
659 
660         // assert that status1 didn't change
661         assertEquals(NetworkSelectionStatus.DISABLED_ASSOCIATION_REJECTION,
662                 status1.getNetworkSelectionDisableReason());
663         assertEquals(NetworkSelectionStatus.NETWORK_SELECTION_PERMANENTLY_DISABLED,
664                 status1.getNetworkSelectionStatus());
665 
666         // assert that status2 changed
667         assertEquals(NetworkSelectionStatus.DISABLED_BY_WRONG_PASSWORD,
668                 status2.getNetworkSelectionDisableReason());
669         assertEquals(NetworkSelectionStatus.NETWORK_SELECTION_PERMANENTLY_DISABLED,
670                 status2.getNetworkSelectionStatus());
671     }
672 
673     @Test
testNeedsPreSharedKey()674     public void testNeedsPreSharedKey() throws Exception {
675         WifiConfiguration configuration = new WifiConfiguration();
676 
677         configuration.setSecurityParams(SECURITY_TYPE_PSK);
678         assertTrue(configuration.needsPreSharedKey());
679 
680         configuration.setSecurityParams(SECURITY_TYPE_SAE);
681         assertTrue(configuration.needsPreSharedKey());
682 
683         configuration.setSecurityParams(SECURITY_TYPE_WAPI_PSK);
684         assertTrue(configuration.needsPreSharedKey());
685 
686         configuration.setSecurityParams(SECURITY_TYPE_OPEN);
687         assertFalse(configuration.needsPreSharedKey());
688 
689         configuration.setSecurityParams(SECURITY_TYPE_OWE);
690         assertFalse(configuration.needsPreSharedKey());
691 
692         configuration.setSecurityParams(SECURITY_TYPE_EAP);
693         assertFalse(configuration.needsPreSharedKey());
694 
695         configuration.setSecurityParams(SECURITY_TYPE_EAP_WPA3_ENTERPRISE);
696         assertFalse(configuration.needsPreSharedKey());
697 
698         configuration.setSecurityParams(SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT);
699         assertFalse(configuration.needsPreSharedKey());
700     }
701 
702     @Test
testGetAuthType()703     public void testGetAuthType() throws Exception {
704         WifiConfiguration configuration = new WifiConfiguration();
705 
706         configuration.setSecurityParams(SECURITY_TYPE_PSK);
707         assertEquals(KeyMgmt.WPA_PSK, configuration.getAuthType());
708 
709         configuration.setSecurityParams(SECURITY_TYPE_SAE);
710         assertEquals(KeyMgmt.SAE, configuration.getAuthType());
711 
712         configuration.setSecurityParams(SECURITY_TYPE_WAPI_PSK);
713         assertEquals(KeyMgmt.WAPI_PSK, configuration.getAuthType());
714 
715         configuration.setSecurityParams(SECURITY_TYPE_OPEN);
716         assertEquals(KeyMgmt.NONE, configuration.getAuthType());
717 
718         configuration.setSecurityParams(SECURITY_TYPE_OWE);
719         assertEquals(KeyMgmt.OWE, configuration.getAuthType());
720 
721         configuration.setSecurityParams(SECURITY_TYPE_EAP);
722         assertEquals(KeyMgmt.WPA_EAP, configuration.getAuthType());
723 
724         configuration.setSecurityParams(SECURITY_TYPE_EAP_WPA3_ENTERPRISE);
725         assertEquals(KeyMgmt.WPA_EAP, configuration.getAuthType());
726 
727         configuration.setSecurityParams(SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT);
728         assertEquals(KeyMgmt.SUITE_B_192, configuration.getAuthType());
729 
730         configuration.setSecurityParams(SECURITY_TYPE_WAPI_CERT);
731         assertEquals(KeyMgmt.WAPI_CERT, configuration.getAuthType());
732     }
733 
734     @Test (expected = IllegalStateException.class)
testGetAuthTypeFailure1()735     public void testGetAuthTypeFailure1() throws Exception {
736         WifiConfiguration configuration = new WifiConfiguration();
737 
738         configuration.setSecurityParams(SECURITY_TYPE_PSK);
739         configuration.allowedKeyManagement.set(KeyMgmt.IEEE8021X);
740         configuration.getAuthType();
741     }
742 
743     @Test (expected = IllegalStateException.class)
testGetAuthTypeFailure2()744     public void testGetAuthTypeFailure2() throws Exception {
745         WifiConfiguration configuration = new WifiConfiguration();
746 
747         configuration.allowedKeyManagement.set(KeyMgmt.IEEE8021X);
748         configuration.allowedKeyManagement.set(KeyMgmt.WPA_EAP);
749         configuration.allowedKeyManagement.set(KeyMgmt.SAE);
750         configuration.getAuthType();
751     }
752 
753     /**
754      * Verifies that getProfileKey returns the correct String for networks of
755      * various different security types, the result should be stable.
756      */
757     @Test
testGetProfileKeyString()758     public void testGetProfileKeyString() {
759         assumeTrue(SdkLevel.isAtLeastS());
760         WifiConfiguration config = new WifiConfiguration();
761         final String mSsid = "TestAP";
762         config.SSID = mSsid;
763         config.carrierId = TEST_CARRIER_ID;
764         config.subscriptionId = TEST_SUB_ID;
765         config.creatorName = TEST_PACKAGE_NAME;
766 
767 
768         // Test various combinations
769         config.allowedKeyManagement.set(KeyMgmt.WPA_PSK);
770         config.fromWifiNetworkSuggestion = false;
771         assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.WPA_PSK], TEST_PACKAGE_NAME,
772                 TEST_CARRIER_ID, TEST_SUB_ID, false), config.getProfileKey());
773         config.fromWifiNetworkSuggestion = true;
774         assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.WPA_PSK], TEST_PACKAGE_NAME,
775                 TEST_CARRIER_ID, TEST_SUB_ID, true), config.getProfileKey());
776 
777         config.allowedKeyManagement.clear();
778         config.allowedKeyManagement.set(KeyMgmt.WPA_EAP);
779         config.fromWifiNetworkSuggestion = false;
780         assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.WPA_EAP], TEST_PACKAGE_NAME,
781                 TEST_CARRIER_ID, TEST_SUB_ID, false), config.getProfileKey());
782         config.fromWifiNetworkSuggestion = true;
783         assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.WPA_EAP], TEST_PACKAGE_NAME,
784                 TEST_CARRIER_ID, TEST_SUB_ID, true), config.getProfileKey());
785 
786         config.wepKeys[0] = "TestWep";
787         config.allowedKeyManagement.clear();
788         config.fromWifiNetworkSuggestion = false;
789         assertEquals(createProfileKey(mSsid, "WEP", TEST_PACKAGE_NAME,
790                 TEST_CARRIER_ID, TEST_SUB_ID, false), config.getProfileKey());
791         config.fromWifiNetworkSuggestion = true;
792         assertEquals(createProfileKey(mSsid, "WEP", TEST_PACKAGE_NAME,
793                 TEST_CARRIER_ID, TEST_SUB_ID, true), config.getProfileKey());
794 
795         // set WEP key and give a valid index.
796         config.wepKeys[0] = null;
797         config.wepKeys[2] = "TestWep";
798         config.wepTxKeyIndex = 2;
799         config.allowedKeyManagement.clear();
800         config.fromWifiNetworkSuggestion = false;
801         assertEquals(createProfileKey(mSsid, "WEP", TEST_PACKAGE_NAME,
802                 TEST_CARRIER_ID, TEST_SUB_ID, false), config.getProfileKey());
803         config.fromWifiNetworkSuggestion = true;
804         assertEquals(createProfileKey(mSsid, "WEP", TEST_PACKAGE_NAME,
805                 TEST_CARRIER_ID, TEST_SUB_ID, true), config.getProfileKey());
806 
807         // set WEP key but does not give a valid index.
808         config.wepKeys[0] = null;
809         config.wepKeys[2] = "TestWep";
810         config.wepTxKeyIndex = 0;
811         config.allowedKeyManagement.clear();
812         config.allowedKeyManagement.set(KeyMgmt.OWE);
813         config.fromWifiNetworkSuggestion = false;
814         assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.OWE], TEST_PACKAGE_NAME,
815                 TEST_CARRIER_ID, TEST_SUB_ID, false), config.getProfileKey());
816         config.fromWifiNetworkSuggestion = true;
817         assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.OWE], TEST_PACKAGE_NAME,
818                 TEST_CARRIER_ID, TEST_SUB_ID, true), config.getProfileKey());
819 
820         config.wepKeys[0] = null;
821         config.wepTxKeyIndex = 0;
822         config.allowedKeyManagement.clear();
823         config.allowedKeyManagement.set(KeyMgmt.OWE);
824         config.fromWifiNetworkSuggestion = false;
825         assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.OWE], TEST_PACKAGE_NAME,
826                 TEST_CARRIER_ID, TEST_SUB_ID, false), config.getProfileKey());
827         config.fromWifiNetworkSuggestion = true;
828         assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.OWE], TEST_PACKAGE_NAME,
829                 TEST_CARRIER_ID, TEST_SUB_ID, true), config.getProfileKey());
830 
831         config.allowedKeyManagement.clear();
832         config.allowedKeyManagement.set(KeyMgmt.SAE);
833         config.fromWifiNetworkSuggestion = false;
834         assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.SAE], TEST_PACKAGE_NAME,
835                 TEST_CARRIER_ID, TEST_SUB_ID, false), config.getProfileKey());
836         config.fromWifiNetworkSuggestion = true;
837         assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.SAE], TEST_PACKAGE_NAME,
838                 TEST_CARRIER_ID, TEST_SUB_ID, true), config.getProfileKey());
839 
840         config.allowedKeyManagement.clear();
841         config.allowedKeyManagement.set(KeyMgmt.SUITE_B_192);
842         config.fromWifiNetworkSuggestion = false;
843         assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.SUITE_B_192],
844                 TEST_PACKAGE_NAME, TEST_CARRIER_ID, TEST_SUB_ID, false), config.getProfileKey());
845         config.fromWifiNetworkSuggestion = true;
846         assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.SUITE_B_192],
847                 TEST_PACKAGE_NAME, TEST_CARRIER_ID, TEST_SUB_ID, true), config.getProfileKey());
848 
849         config.allowedKeyManagement.clear();
850         config.allowedKeyManagement.set(KeyMgmt.NONE);
851         config.fromWifiNetworkSuggestion = false;
852         assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.NONE], TEST_PACKAGE_NAME,
853                 TEST_CARRIER_ID, TEST_SUB_ID, false), config.getProfileKey());
854         config.fromWifiNetworkSuggestion = true;
855         assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.NONE], TEST_PACKAGE_NAME,
856                 TEST_CARRIER_ID, TEST_SUB_ID, true), config.getProfileKey());
857 
858         config.allowedKeyManagement.clear();
859         config.allowedKeyManagement.set(KeyMgmt.WAPI_PSK);
860         config.fromWifiNetworkSuggestion = false;
861         assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.WAPI_PSK], TEST_PACKAGE_NAME,
862                 TEST_CARRIER_ID, TEST_SUB_ID, false), config.getProfileKey());
863         config.fromWifiNetworkSuggestion = true;
864         assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.WAPI_PSK], TEST_PACKAGE_NAME,
865                 TEST_CARRIER_ID, TEST_SUB_ID, true), config.getProfileKey());
866 
867         config.allowedKeyManagement.clear();
868         config.allowedKeyManagement.set(KeyMgmt.WAPI_CERT);
869         config.fromWifiNetworkSuggestion = false;
870         assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.WAPI_CERT], TEST_PACKAGE_NAME,
871                 TEST_CARRIER_ID, TEST_SUB_ID, false), config.getProfileKey());
872         config.fromWifiNetworkSuggestion = true;
873         assertEquals(createProfileKey(mSsid, KeyMgmt.strings[KeyMgmt.WAPI_CERT], TEST_PACKAGE_NAME,
874                 TEST_CARRIER_ID, TEST_SUB_ID, true), config.getProfileKey());
875 
876         config.allowedKeyManagement.clear();
877         config.setPasspointUniqueId(TEST_PASSPOINT_UNIQUE_ID);
878         assertEquals(TEST_PASSPOINT_UNIQUE_ID, config.getProfileKey());
879     }
880 
881     @Test
testGetProfileKeyOnR()882     public void testGetProfileKeyOnR() {
883         assumeFalse(SdkLevel.isAtLeastS());
884         WifiConfiguration config = new WifiConfiguration();
885         final String mSsid = "TestAP";
886         config.SSID = mSsid;
887         config.carrierId = TEST_CARRIER_ID;
888         config.subscriptionId = TEST_SUB_ID;
889         config.creatorName = TEST_PACKAGE_NAME;
890 
891         assertEquals(mSsid + KeyMgmt.strings[KeyMgmt.NONE] , config.getProfileKey());
892     }
893 
createProfileKey(String ssid, String keyMgmt, String providerName, int carrierId, int subId, boolean isFromSuggestion)894     private String createProfileKey(String ssid, String keyMgmt, String providerName,
895             int carrierId, int subId, boolean isFromSuggestion) {
896         StringBuilder sb = new StringBuilder();
897         sb.append(ssid).append(keyMgmt);
898         if (isFromSuggestion) {
899             sb.append("_").append(providerName).append('-')
900                     .append(carrierId).append('-').append(subId);
901         }
902         return sb.toString();
903     }
904 
verifyAllowedKeyManagement(WifiConfiguration config, int[] akms)905     private void verifyAllowedKeyManagement(WifiConfiguration config, int[] akms) {
906         for (int akm: akms) {
907             assertTrue(config.getSecurityParamsList().stream()
908                     .anyMatch(params -> params.getAllowedKeyManagement().get(akm)));
909         }
910     }
911 
verifyAllowedProtocols(WifiConfiguration config, int[] aps)912     private void verifyAllowedProtocols(WifiConfiguration config, int[] aps) {
913         for (int ap: aps) {
914             assertTrue(config.getSecurityParamsList().stream()
915                     .anyMatch(params -> params.getAllowedProtocols().get(ap)));
916         }
917     }
918 
verifyAllowedPairwiseCiphers(WifiConfiguration config, int[] apcs)919     private void verifyAllowedPairwiseCiphers(WifiConfiguration config, int[] apcs) {
920         for (int apc: apcs) {
921             assertTrue(config.getSecurityParamsList().stream()
922                     .anyMatch(params -> params.getAllowedPairwiseCiphers().get(apc)));
923         }
924     }
925 
verifyAllowedGroupCiphers(WifiConfiguration config, int[] agcs)926     private void verifyAllowedGroupCiphers(WifiConfiguration config, int[] agcs) {
927         for (int agc: agcs) {
928             assertTrue(config.getSecurityParamsList().stream()
929                     .anyMatch(params -> params.getAllowedGroupCiphers().get(agc)));
930         }
931     }
932 
933     /** Verify that adding security types works as expected. */
934     @Test
testAddSecurityTypes()935     public void testAddSecurityTypes() {
936         WifiConfiguration config = new WifiConfiguration();
937         config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK);
938         config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_SAE);
939         config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_WAPI_PSK);
940         List<SecurityParams> paramsList = config.getSecurityParamsList();
941         assertEquals(3, paramsList.size());
942 
943         verifyAllowedKeyManagement(config, new int[] {
944                 KeyMgmt.WPA_PSK, KeyMgmt.SAE, KeyMgmt.WAPI_PSK});
945         verifyAllowedProtocols(config, new int[] {Protocol.WPA, Protocol.RSN, Protocol.WAPI});
946         verifyAllowedPairwiseCiphers(config, new int[] {
947                 PairwiseCipher.CCMP, PairwiseCipher.TKIP,
948                 PairwiseCipher.GCMP_128, PairwiseCipher.GCMP_256,
949                 PairwiseCipher.SMS4});
950         verifyAllowedGroupCiphers(config, new int[] {
951                 GroupCipher.CCMP, GroupCipher.TKIP,
952                 GroupCipher.GCMP_128, GroupCipher.GCMP_256,
953                 GroupCipher.SMS4});
954     }
955 
956     /** Check that a personal security type can be added to a personal configuration. */
957     @Test
testAddPersonalTypeToPersonalConfiguration()958     public void testAddPersonalTypeToPersonalConfiguration() {
959         WifiConfiguration config = new WifiConfiguration();
960         config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK);
961         config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_SAE);
962     }
963 
964     /** Check that an enterprise security type can be added to an enterprise configuration. */
965     @Test
testAddEnterpriseTypeToEnterpriseConfiguration()966     public void testAddEnterpriseTypeToEnterpriseConfiguration() {
967         WifiConfiguration config = new WifiConfiguration();
968         config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP);
969         config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.SIM);
970         config.enterpriseConfig.setPhase2Method(WifiEnterpriseConfig.Phase2.NONE);
971         config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE);
972     }
973 
974     /** Verify that adding an enterprise type to a personal configuration. */
975     @Test (expected = IllegalArgumentException.class)
testAddEnterpriseTypeToPersonalConfig()976     public void testAddEnterpriseTypeToPersonalConfig() {
977         WifiConfiguration config = new WifiConfiguration();
978         config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK);
979         config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP);
980     }
981 
982     /** Verify that adding a personal type to an enterprise configuration. */
983     @Test (expected = IllegalArgumentException.class)
testAddPersonalTypeToEnterpriseConfig()984     public void testAddPersonalTypeToEnterpriseConfig() {
985         WifiConfiguration config = new WifiConfiguration();
986         config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP);
987         config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.SIM);
988         config.enterpriseConfig.setPhase2Method(WifiEnterpriseConfig.Phase2.NONE);
989         config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK);
990     }
991 
992     /** Check that an open security cannot be added to a non-open configuration. */
993     @Test(expected = IllegalArgumentException.class)
testAddOpenTypeToNonOpenConfiguration()994     public void testAddOpenTypeToNonOpenConfiguration() {
995         WifiConfiguration config = new WifiConfiguration();
996         config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK);
997         config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_OPEN);
998     }
999 
1000     /** Check that a non-open security cannot be added to an open configuration. */
1001     @Test(expected = IllegalArgumentException.class)
testAddNonOpenTypeToOpenConfiguration()1002     public void testAddNonOpenTypeToOpenConfiguration() {
1003         WifiConfiguration config = new WifiConfiguration();
1004         config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_OPEN);
1005         config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK);
1006     }
1007 
1008     /** Check that a OSEN security cannot be added as additional type. */
1009     @Test(expected = IllegalArgumentException.class)
testAddOsenTypeToConfiguration()1010     public void testAddOsenTypeToConfiguration() {
1011         WifiConfiguration config = new WifiConfiguration();
1012         config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK);
1013         config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_OSEN);
1014     }
1015 
1016     /** Verify that adding duplicate security types raises the exception. */
1017     @Test (expected = IllegalArgumentException.class)
testAddDuplicateSecurityTypes()1018     public void testAddDuplicateSecurityTypes() {
1019         WifiConfiguration config = new WifiConfiguration();
1020         config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK);
1021         config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK);
1022     }
1023 
1024     /** Verify that adding duplicate security params raises the exception. */
1025     @Test (expected = IllegalArgumentException.class)
testAddDuplicateSecurityParams()1026     public void testAddDuplicateSecurityParams() {
1027         WifiConfiguration config = new WifiConfiguration();
1028         config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK);
1029         config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK);
1030     }
1031 
1032     /** Verify that Suite-B type works as expected. */
1033     @Test
testAddSuiteBSecurityType()1034     public void testAddSuiteBSecurityType() {
1035         WifiConfiguration config = new WifiConfiguration();
1036         config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE);
1037         config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.SIM);
1038         config.enterpriseConfig.setPhase2Method(WifiEnterpriseConfig.Phase2.NONE);
1039         config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT);
1040 
1041         assertFalse(config.isSuiteBCipherEcdheRsaEnabled());
1042         config.enableSuiteBCiphers(false, true);
1043         assertTrue(config.isSuiteBCipherEcdheRsaEnabled());
1044     }
1045 
1046     /** Verify that FILS bit can be set correctly. */
1047     @Test
testFilsKeyMgmt()1048     public void testFilsKeyMgmt() {
1049         WifiConfiguration config = new WifiConfiguration();
1050         config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK);
1051         config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_SAE);
1052 
1053         config.enableFils(false, true);
1054         assertFalse(config.isFilsSha256Enabled());
1055         assertTrue(config.isFilsSha384Enabled());
1056     }
1057 
1058     /** Verify that SAE mode can be configured correctly. */
1059     @Test
testSaeTypeMethods()1060     public void testSaeTypeMethods() {
1061         WifiConfiguration config = new WifiConfiguration();
1062         config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK);
1063         config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_SAE);
1064 
1065         SecurityParams saeParams = config.getSecurityParams(WifiConfiguration.SECURITY_TYPE_SAE);
1066         assertNotNull(saeParams);
1067         assertFalse(saeParams.isSaeH2eOnlyMode());
1068         assertFalse(saeParams.isSaePkOnlyMode());
1069 
1070         config.enableSaeH2eOnlyMode(true);
1071         config.enableSaePkOnlyMode(true);
1072 
1073         saeParams = config.getSecurityParams(WifiConfiguration.SECURITY_TYPE_SAE);
1074         assertNotNull(saeParams);
1075         assertTrue(saeParams.isSaeH2eOnlyMode());
1076         assertTrue(saeParams.isSaePkOnlyMode());
1077     }
1078 
1079     /** Verify the legacy configuration conversion */
1080     @Test
testLegacyConfigurationConversion()1081     public void testLegacyConfigurationConversion() {
1082         Pair[] keyMgmtSecurityTypePairs = new Pair[] {
1083                 new Pair<>(KeyMgmt.WAPI_CERT, SECURITY_TYPE_WAPI_CERT),
1084                 new Pair<>(KeyMgmt.WAPI_PSK, SECURITY_TYPE_WAPI_PSK),
1085                 new Pair<>(KeyMgmt.SUITE_B_192, SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT),
1086                 new Pair<>(KeyMgmt.OWE, SECURITY_TYPE_OWE),
1087                 new Pair<>(KeyMgmt.SAE, SECURITY_TYPE_SAE),
1088                 new Pair<>(KeyMgmt.OSEN, SECURITY_TYPE_OSEN),
1089                 new Pair<>(KeyMgmt.WPA2_PSK, SECURITY_TYPE_PSK),
1090                 new Pair<>(KeyMgmt.WPA_EAP, SECURITY_TYPE_EAP),
1091                 new Pair<>(KeyMgmt.WPA_PSK, SECURITY_TYPE_PSK),
1092                 new Pair<>(KeyMgmt.NONE, SECURITY_TYPE_OPEN),
1093         };
1094 
1095         for (Pair pair: keyMgmtSecurityTypePairs) {
1096             WifiConfiguration config = new WifiConfiguration();
1097             config.allowedKeyManagement.set((int) pair.first);
1098             config.convertLegacyFieldsToSecurityParamsIfNeeded();
1099             assertNotNull(config.getSecurityParams((int) pair.second));
1100         }
1101 
1102         // If none of key management is set, it should be open.
1103         WifiConfiguration emptyConfig = new WifiConfiguration();
1104         emptyConfig.convertLegacyFieldsToSecurityParamsIfNeeded();
1105         assertNotNull(emptyConfig.getSecurityParams(SECURITY_TYPE_OPEN));
1106 
1107         // If EAP key management is set and requirePmf is true, it is WPA3 Enterprise.
1108         WifiConfiguration wpa3EnterpriseConfig = new WifiConfiguration();
1109         wpa3EnterpriseConfig.allowedKeyManagement.set(KeyMgmt.WPA_EAP);
1110         wpa3EnterpriseConfig.requirePmf = true;
1111         wpa3EnterpriseConfig.convertLegacyFieldsToSecurityParamsIfNeeded();
1112         assertNotNull(wpa3EnterpriseConfig.getSecurityParams(SECURITY_TYPE_EAP_WPA3_ENTERPRISE));
1113 
1114         // If key management is NONE and wep key is set, it is WEP type.
1115         WifiConfiguration wepConfig = new WifiConfiguration();
1116         wepConfig.allowedKeyManagement.set(KeyMgmt.NONE);
1117         wepConfig.wepKeys = new String[] {"\"abcdef\""};
1118         wepConfig.convertLegacyFieldsToSecurityParamsIfNeeded();
1119         assertNotNull(wepConfig.getSecurityParams(SECURITY_TYPE_WEP));
1120     }
1121 
1122     /** Verify the set security params by SecurityParams objects. */
1123     @Test
testSetBySecurityParamsObject()1124     public void testSetBySecurityParamsObject() {
1125         int[] securityTypes = new int[] {
1126                 SECURITY_TYPE_WAPI_CERT,
1127                 SECURITY_TYPE_WAPI_PSK,
1128                 SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT,
1129                 SECURITY_TYPE_OWE,
1130                 SECURITY_TYPE_SAE,
1131                 SECURITY_TYPE_OSEN,
1132                 SECURITY_TYPE_EAP,
1133                 SECURITY_TYPE_PSK,
1134                 SECURITY_TYPE_OPEN,
1135                 SECURITY_TYPE_PASSPOINT_R1_R2,
1136                 SECURITY_TYPE_PASSPOINT_R3,
1137         };
1138         for (int type: securityTypes) {
1139             WifiConfiguration config = new WifiConfiguration();
1140             config.setSecurityParams(type);
1141             assertTrue(config.isSecurityType(type));
1142             assertNotNull(config.getSecurityParams(type));
1143         }
1144     }
1145 
1146     /** Verify the set security params by an allowed key management mask. */
1147     @Test
testSetSecurityParamsByAllowedKeyManagement()1148     public void testSetSecurityParamsByAllowedKeyManagement() {
1149         Pair[] keyMgmtSecurityTypePairs = new Pair[] {
1150                 new Pair<>(KeyMgmt.WAPI_CERT, SECURITY_TYPE_WAPI_CERT),
1151                 new Pair<>(KeyMgmt.WAPI_PSK, SECURITY_TYPE_WAPI_PSK),
1152                 new Pair<>(KeyMgmt.SUITE_B_192, SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT),
1153                 new Pair<>(KeyMgmt.OWE, SECURITY_TYPE_OWE),
1154                 new Pair<>(KeyMgmt.SAE, SECURITY_TYPE_SAE),
1155                 new Pair<>(KeyMgmt.OSEN, SECURITY_TYPE_OSEN),
1156                 new Pair<>(KeyMgmt.WPA2_PSK, SECURITY_TYPE_PSK),
1157                 new Pair<>(KeyMgmt.WPA_EAP, SECURITY_TYPE_EAP),
1158                 new Pair<>(KeyMgmt.WPA_PSK, SECURITY_TYPE_PSK),
1159                 new Pair<>(KeyMgmt.NONE, SECURITY_TYPE_OPEN),
1160         };
1161 
1162         for (Pair pair: keyMgmtSecurityTypePairs) {
1163             BitSet akm = new BitSet();
1164             akm.set((int) pair.first);
1165             WifiConfiguration config = new WifiConfiguration();
1166             config.setSecurityParams(akm);
1167             assertNotNull(config.getSecurityParams((int) pair.second));
1168         }
1169     }
1170 
1171     /** Verify the set security params by an invalid allowed key management mask. */
1172     @Test (expected = IllegalArgumentException.class)
testSetSecurityParamsByInvalidAllowedKeyManagement()1173     public void testSetSecurityParamsByInvalidAllowedKeyManagement() {
1174         WifiConfiguration config = new WifiConfiguration();
1175         BitSet akm = null;
1176         config.setSecurityParams(akm);
1177     }
1178 
1179     /** Verify the set security params by a security params list. */
1180     @Test
testSetSecurityParamsBySecurityParamsList()1181     public void testSetSecurityParamsBySecurityParamsList() {
1182         WifiConfiguration config = new WifiConfiguration();
1183         config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.SIM);
1184         config.enterpriseConfig.setPhase2Method(WifiEnterpriseConfig.Phase2.NONE);
1185         config.addSecurityParams(SECURITY_TYPE_EAP);
1186         config.addSecurityParams(SECURITY_TYPE_EAP_WPA3_ENTERPRISE);
1187         assertTrue(config.isSecurityType(SECURITY_TYPE_EAP));
1188         assertTrue(config.isSecurityType(SECURITY_TYPE_EAP_WPA3_ENTERPRISE));
1189         assertFalse(config.isSecurityType(SECURITY_TYPE_PSK));
1190         assertFalse(config.isSecurityType(SECURITY_TYPE_SAE));
1191 
1192         List<SecurityParams> list = new ArrayList<>();
1193         list.add(SecurityParams.createSecurityParamsBySecurityType(SECURITY_TYPE_PSK));
1194         list.add(SecurityParams.createSecurityParamsBySecurityType(SECURITY_TYPE_SAE));
1195         config.setSecurityParams(list);
1196         assertFalse(config.isSecurityType(SECURITY_TYPE_EAP));
1197         assertFalse(config.isSecurityType(SECURITY_TYPE_EAP_WPA3_ENTERPRISE));
1198         assertTrue(config.isSecurityType(SECURITY_TYPE_PSK));
1199         assertTrue(config.isSecurityType(SECURITY_TYPE_SAE));
1200     }
1201 
1202     /** Verify the set security params by an empty security params list. */
1203     @Test (expected = IllegalArgumentException.class)
testSetSecurityParamsByEmptySecurityParamsList()1204     public void testSetSecurityParamsByEmptySecurityParamsList() {
1205         WifiConfiguration config = new WifiConfiguration();
1206         List<SecurityParams> list = new ArrayList<>();
1207         config.setSecurityParams(list);
1208     }
1209 
1210     /** Verify the set security params by a null security params list. */
1211     @Test (expected = IllegalArgumentException.class)
testSetSecurityParamsByNullSecurityParamsList()1212     public void testSetSecurityParamsByNullSecurityParamsList() {
1213         WifiConfiguration config = new WifiConfiguration();
1214         List<SecurityParams> list = null;
1215         config.setSecurityParams(list);
1216     }
1217 }
1218