diff --git a/wifi/java/android/net/wifi/SecurityParams.java b/wifi/java/android/net/wifi/SecurityParams.java index 0ab6f572fba3..8ee2ea046cfb 100644 --- a/wifi/java/android/net/wifi/SecurityParams.java +++ b/wifi/java/android/net/wifi/SecurityParams.java @@ -191,6 +191,15 @@ public class SecurityParams { mIsSaeH2eOnlyMode, mIsSaePkOnlyMode, mIsAddedByAutoUpgrade); } + /** + * Get the security type of this params. + * + * @return The security type defined in {@link WifiConfiguration}. + */ + public @SecurityType int getSecurityType() { + return mSecurityType; + } + /** * Check the security type of this params. * @@ -562,10 +571,65 @@ public class SecurityParams { return params; } + /** + * Create a params according to the security type. + * + * @param securityType One of the following security types: + * {@link WifiConfiguration#SECURITY_TYPE_OPEN}, + * {@link WifiConfiguration#SECURITY_TYPE_WEP}, + * {@link WifiConfiguration#SECURITY_TYPE_PSK}, + * {@link WifiConfiguration#SECURITY_TYPE_EAP}, + * {@link WifiConfiguration#SECURITY_TYPE_SAE}, + * {@link WifiConfiguration#SECURITY_TYPE_OWE}, + * {@link WifiConfiguration#SECURITY_TYPE_WAPI_PSK}, + * {@link WifiConfiguration#SECURITY_TYPE_WAPI_CERT}, + * {@link WifiConfiguration#SECURITY_TYPE_EAP_WPA3_ENTERPRISE}, + * {@link WifiConfiguration#SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT}, + * + * @return the corresponding security params if the security type is valid; + * otherwise, throw IllegalArgumentException. + */ + public static @NonNull SecurityParams createSecurityParamsBySecurityType( + @WifiConfiguration.SecurityType int securityType) { + switch (securityType) { + case WifiConfiguration.SECURITY_TYPE_OPEN: + return createOpenParams(); + case WifiConfiguration.SECURITY_TYPE_WEP: + return createWepParams(); + case WifiConfiguration.SECURITY_TYPE_PSK: + return createWpaWpa2PersonalParams(); + case WifiConfiguration.SECURITY_TYPE_EAP: + return createWpaWpa2EnterpriseParams(); + case WifiConfiguration.SECURITY_TYPE_SAE: + return createWpa3PersonalParams(); + // The value of {@link WifiConfiguration.SECURITY_TYPE_EAP_SUITE_B} is the same as + // {@link #WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT}, remove it + // to avoid duplicate case label errors. + case WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT: + return createWpa3Enterprise192BitParams(); + case WifiConfiguration.SECURITY_TYPE_OWE: + return createEnhancedOpenParams(); + case WifiConfiguration.SECURITY_TYPE_WAPI_PSK: + return createWapiPskParams(); + case WifiConfiguration.SECURITY_TYPE_WAPI_CERT: + return createWapiCertParams(); + case WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE: + return createWpa3EnterpriseParams(); + case WifiConfiguration.SECURITY_TYPE_OSEN: + return createOsenParams(); + case WifiConfiguration.SECURITY_TYPE_PASSPOINT_R1_R2: + return SecurityParams.createPasspointParams(PASSPOINT_R2); + case WifiConfiguration.SECURITY_TYPE_PASSPOINT_R3: + return SecurityParams.createPasspointParams(PASSPOINT_R3); + default: + throw new IllegalArgumentException("unknown security type " + securityType); + } + } + /** * Create EAP security params. */ - public static @NonNull SecurityParams createWpaWpa2EnterpriseParams() { + private static @NonNull SecurityParams createWpaWpa2EnterpriseParams() { SecurityParams params = new SecurityParams(); params.mSecurityType = WifiConfiguration.SECURITY_TYPE_EAP; @@ -586,7 +650,7 @@ public class SecurityParams { /** * Create Passpoint security params. */ - public static @NonNull SecurityParams createPasspointParams(@PasspointRelease int release) { + private static @NonNull SecurityParams createPasspointParams(@PasspointRelease int release) { SecurityParams params = new SecurityParams(); switch (release) { case PASSPOINT_R1: @@ -616,7 +680,7 @@ public class SecurityParams { /** * Create Enhanced Open params. */ - public static @NonNull SecurityParams createEnhancedOpenParams() { + private static @NonNull SecurityParams createEnhancedOpenParams() { SecurityParams params = new SecurityParams(); params.mSecurityType = WifiConfiguration.SECURITY_TYPE_OWE; @@ -639,7 +703,7 @@ public class SecurityParams { /** * Create Open params. */ - public static @NonNull SecurityParams createOpenParams() { + private static @NonNull SecurityParams createOpenParams() { SecurityParams params = new SecurityParams(); params.mSecurityType = WifiConfiguration.SECURITY_TYPE_OPEN; @@ -653,7 +717,7 @@ public class SecurityParams { /** * Create OSEN params. */ - public static @NonNull SecurityParams createOsenParams() { + private static @NonNull SecurityParams createOsenParams() { SecurityParams params = new SecurityParams(); params.mSecurityType = WifiConfiguration.SECURITY_TYPE_OSEN; @@ -672,7 +736,7 @@ public class SecurityParams { /** * Create WAPI-CERT params. */ - public static @NonNull SecurityParams createWapiCertParams() { + private static @NonNull SecurityParams createWapiCertParams() { SecurityParams params = new SecurityParams(); params.mSecurityType = WifiConfiguration.SECURITY_TYPE_WAPI_CERT; @@ -689,7 +753,7 @@ public class SecurityParams { /** * Create WAPI-PSK params. */ - public static @NonNull SecurityParams createWapiPskParams() { + private static @NonNull SecurityParams createWapiPskParams() { SecurityParams params = new SecurityParams(); params.mSecurityType = WifiConfiguration.SECURITY_TYPE_WAPI_PSK; @@ -706,7 +770,7 @@ public class SecurityParams { /** * Create WEP params. */ - public static @NonNull SecurityParams createWepParams() { + private static @NonNull SecurityParams createWepParams() { SecurityParams params = new SecurityParams(); params.mSecurityType = WifiConfiguration.SECURITY_TYPE_WEP; @@ -730,7 +794,7 @@ public class SecurityParams { /** * Create WPA3 Enterprise 192-bit params. */ - public static @NonNull SecurityParams createWpa3Enterprise192BitParams() { + private static @NonNull SecurityParams createWpa3Enterprise192BitParams() { SecurityParams params = new SecurityParams(); params.mSecurityType = WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT; @@ -758,7 +822,7 @@ public class SecurityParams { /** * Create WPA3 Enterprise params. */ - public static @NonNull SecurityParams createWpa3EnterpriseParams() { + private static @NonNull SecurityParams createWpa3EnterpriseParams() { SecurityParams params = new SecurityParams(); params.mSecurityType = WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE; @@ -780,7 +844,7 @@ public class SecurityParams { /** * Create WPA3 Personal params. */ - public static @NonNull SecurityParams createWpa3PersonalParams() { + private static @NonNull SecurityParams createWpa3PersonalParams() { SecurityParams params = new SecurityParams(); params.mSecurityType = WifiConfiguration.SECURITY_TYPE_SAE; @@ -803,7 +867,7 @@ public class SecurityParams { /** * Create WPA/WPA2 Personal params. */ - public static @NonNull SecurityParams createWpaWpa2PersonalParams() { + private static @NonNull SecurityParams createWpaWpa2PersonalParams() { SecurityParams params = new SecurityParams(); params.mSecurityType = WifiConfiguration.SECURITY_TYPE_PSK; diff --git a/wifi/java/android/net/wifi/WifiConfiguration.java b/wifi/java/android/net/wifi/WifiConfiguration.java index ba4a54f9a489..6c0b2dfa7899 100644 --- a/wifi/java/android/net/wifi/WifiConfiguration.java +++ b/wifi/java/android/net/wifi/WifiConfiguration.java @@ -566,10 +566,27 @@ public class WifiConfiguration implements Parcelable { */ public void setSecurityParams(@SecurityType int securityType) { // Clear existing data. - mSecurityParamsList = new ArrayList<>(); + mSecurityParamsList.clear(); addSecurityParams(securityType); } + /** + * Set security params by the given key management mask. + * + * @param givenAllowedKeyManagement the given allowed key management mask. + * @hide + */ + public void setSecurityParams(@NonNull BitSet givenAllowedKeyManagement) { + if (givenAllowedKeyManagement == null) { + throw new IllegalArgumentException("Invalid allowed key management mask."); + } + // Clear existing data. + mSecurityParamsList.clear(); + + allowedKeyManagement = (BitSet) givenAllowedKeyManagement.clone(); + convertLegacyFieldsToSecurityParamsIfNeeded(); + } + /** * Add the various security params. *
@@ -578,10 +595,25 @@ public class WifiConfiguration implements Parcelable { */ public void setSecurityParams(SecurityParams params) { // Clear existing data. - mSecurityParamsList = new ArrayList<>(); + mSecurityParamsList.clear(); addSecurityParams(params); } + /** + * Set the security params by the given security params list. + * + * This will overwrite existing security params list directly. + * + * @param securityParamsList the desired security params list. + * @hide + */ + public void setSecurityParams(@NonNull List securityParamsList) { + if (securityParamsList == null || securityParamsList.isEmpty()) { + throw new IllegalArgumentException("An empty security params list is invalid."); + } + mSecurityParamsList = new ArrayList<>(securityParamsList); + } + /** * Add the various security params to correspond to the provided security type. * This is accomplished by setting the various BitSets exposed in WifiConfiguration. @@ -605,55 +637,7 @@ public class WifiConfiguration implements Parcelable { if (mSecurityParamsList.stream().anyMatch(params -> params.isSecurityType(securityType))) { throw new IllegalArgumentException("duplicate security type " + securityType); } - SecurityParams params = null; - switch (securityType) { - case SECURITY_TYPE_OPEN: - params = SecurityParams.createOpenParams(); - break; - case SECURITY_TYPE_WEP: - params = SecurityParams.createWepParams(); - break; - case SECURITY_TYPE_PSK: - params = SecurityParams.createWpaWpa2PersonalParams(); - break; - case SECURITY_TYPE_EAP: - params = SecurityParams.createWpaWpa2EnterpriseParams(); - break; - case SECURITY_TYPE_SAE: - params = SecurityParams.createWpa3PersonalParams(); - break; - // The value of {@link SECURITY_TYPE_EAP_SUITE_B} is the same as - // {@link #SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT}, remove it to avoid - // duplicate case label errors. - case SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT: - params = SecurityParams.createWpa3Enterprise192BitParams(); - break; - case SECURITY_TYPE_OWE: - params = SecurityParams.createEnhancedOpenParams(); - break; - case SECURITY_TYPE_WAPI_PSK: - params = SecurityParams.createWapiPskParams(); - break; - case SECURITY_TYPE_WAPI_CERT: - params = SecurityParams.createWapiCertParams(); - break; - case SECURITY_TYPE_EAP_WPA3_ENTERPRISE: - params = SecurityParams.createWpa3EnterpriseParams(); - break; - case SECURITY_TYPE_OSEN: - params = SecurityParams.createOsenParams(); - break; - case SECURITY_TYPE_PASSPOINT_R1_R2: - params = SecurityParams.createPasspointParams(SecurityParams.PASSPOINT_R2); - break; - case SECURITY_TYPE_PASSPOINT_R3: - params = SecurityParams.createPasspointParams(SecurityParams.PASSPOINT_R3); - break; - default: - throw new IllegalArgumentException("unknown security type " + securityType); - } - - addSecurityParams(params); + addSecurityParams(SecurityParams.createSecurityParamsBySecurityType(securityType)); } /** @hide */ diff --git a/wifi/tests/src/android/net/wifi/SecurityParamsTest.java b/wifi/tests/src/android/net/wifi/SecurityParamsTest.java index 2f6b7245795f..c586ded29cd9 100644 --- a/wifi/tests/src/android/net/wifi/SecurityParamsTest.java +++ b/wifi/tests/src/android/net/wifi/SecurityParamsTest.java @@ -50,6 +50,7 @@ public class SecurityParamsTest { int[] expectedAllowedGroupCiphers, boolean expectedRequirePmf) { assertTrue(params.isSecurityType(expectedSecurityType)); + assertEquals(expectedSecurityType, params.getSecurityType()); for (int b: expectedAllowedKeyManagement) { assertTrue(params.getAllowedKeyManagement().get(b)); } @@ -68,10 +69,32 @@ public class SecurityParamsTest { assertEquals(expectedRequirePmf, params.isRequirePmf()); } + /** Verify the security params created by security type. */ + @Test + public void testSecurityTypeCreator() throws Exception { + int[] securityTypes = new int[] { + WifiConfiguration.SECURITY_TYPE_WAPI_CERT, + WifiConfiguration.SECURITY_TYPE_WAPI_PSK, + WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT, + WifiConfiguration.SECURITY_TYPE_OWE, + WifiConfiguration.SECURITY_TYPE_SAE, + WifiConfiguration.SECURITY_TYPE_OSEN, + WifiConfiguration.SECURITY_TYPE_EAP, + WifiConfiguration.SECURITY_TYPE_PSK, + WifiConfiguration.SECURITY_TYPE_OPEN, + WifiConfiguration.SECURITY_TYPE_PASSPOINT_R1_R2, + WifiConfiguration.SECURITY_TYPE_PASSPOINT_R3, + }; + + for (int type: securityTypes) { + assertEquals(type, + SecurityParams.createSecurityParamsBySecurityType(type).getSecurityType()); + } + } + /** Verify EAP params creator. */ @Test public void testEapCreator() throws Exception { - SecurityParams p = SecurityParams.createWpaWpa2EnterpriseParams(); int expectedSecurityType = WifiConfiguration.SECURITY_TYPE_EAP; int[] expectedAllowedKeyManagement = new int[] {KeyMgmt.WPA_EAP, KeyMgmt.IEEE8021X}; int[] expectedAllowedProtocols = new int[] {}; @@ -79,33 +102,17 @@ public class SecurityParamsTest { int[] expectedAllowedPairwiseCiphers = new int[] {}; int[] expectedAllowedGroupCiphers = new int[] {}; boolean expectedRequirePmf = false; + SecurityParams p = SecurityParams.createSecurityParamsBySecurityType( + expectedSecurityType); verifySecurityParams(p, expectedSecurityType, expectedAllowedKeyManagement, expectedAllowedProtocols, expectedAllowedAuthAlgorithms, expectedAllowedPairwiseCiphers, expectedAllowedGroupCiphers, expectedRequirePmf); } - /** Verify Passpoint R1 params creator. */ + /** Verify Passpoint R1/R2 params creator. */ @Test - public void testEapPasspointR1Creator() throws Exception { - SecurityParams p = SecurityParams.createPasspointParams(SecurityParams.PASSPOINT_R1); - int expectedSecurityType = WifiConfiguration.SECURITY_TYPE_PASSPOINT_R1_R2; - int[] expectedAllowedKeyManagement = new int[] {KeyMgmt.WPA_EAP, KeyMgmt.IEEE8021X}; - int[] expectedAllowedProtocols = new int[] {}; - int[] expectedAllowedAuthAlgorithms = new int[] {}; - int[] expectedAllowedPairwiseCiphers = new int[] {}; - int[] expectedAllowedGroupCiphers = new int[] {}; - boolean expectedRequirePmf = false; - verifySecurityParams(p, expectedSecurityType, - expectedAllowedKeyManagement, expectedAllowedProtocols, - expectedAllowedAuthAlgorithms, expectedAllowedPairwiseCiphers, - expectedAllowedGroupCiphers, expectedRequirePmf); - } - - /** Verify Passpoint R2 params creator. */ - @Test - public void testEapPasspointR2Creator() throws Exception { - SecurityParams p = SecurityParams.createPasspointParams(SecurityParams.PASSPOINT_R2); + public void testEapPasspointR1R2Creator() throws Exception { int expectedSecurityType = WifiConfiguration.SECURITY_TYPE_PASSPOINT_R1_R2; int[] expectedAllowedKeyManagement = new int[] {KeyMgmt.WPA_EAP, KeyMgmt.IEEE8021X}; int[] expectedAllowedProtocols = new int[] {}; @@ -113,6 +120,8 @@ public class SecurityParamsTest { int[] expectedAllowedPairwiseCiphers = new int[] {}; int[] expectedAllowedGroupCiphers = new int[] {}; boolean expectedRequirePmf = false; + SecurityParams p = SecurityParams.createSecurityParamsBySecurityType( + expectedSecurityType); verifySecurityParams(p, expectedSecurityType, expectedAllowedKeyManagement, expectedAllowedProtocols, expectedAllowedAuthAlgorithms, expectedAllowedPairwiseCiphers, @@ -122,7 +131,6 @@ public class SecurityParamsTest { /** Verify Passpoint R3 params creator. */ @Test public void testEapPasspointR3Creator() throws Exception { - SecurityParams p = SecurityParams.createPasspointParams(SecurityParams.PASSPOINT_R3); int expectedSecurityType = WifiConfiguration.SECURITY_TYPE_PASSPOINT_R3; int[] expectedAllowedKeyManagement = new int[] {KeyMgmt.WPA_EAP, KeyMgmt.IEEE8021X}; int[] expectedAllowedProtocols = new int[] {}; @@ -130,6 +138,8 @@ public class SecurityParamsTest { int[] expectedAllowedPairwiseCiphers = new int[] {}; int[] expectedAllowedGroupCiphers = new int[] {}; boolean expectedRequirePmf = true; + SecurityParams p = SecurityParams.createSecurityParamsBySecurityType( + expectedSecurityType); verifySecurityParams(p, expectedSecurityType, expectedAllowedKeyManagement, expectedAllowedProtocols, expectedAllowedAuthAlgorithms, expectedAllowedPairwiseCiphers, @@ -139,7 +149,6 @@ public class SecurityParamsTest { /** Verify Enhanced Open params creator. */ @Test public void testEnhancedOpenCreator() throws Exception { - SecurityParams p = SecurityParams.createEnhancedOpenParams(); int expectedSecurityType = WifiConfiguration.SECURITY_TYPE_OWE; int[] expectedAllowedKeyManagement = new int[] {KeyMgmt.OWE}; int[] expectedAllowedProtocols = new int[] {Protocol.RSN}; @@ -149,6 +158,8 @@ public class SecurityParamsTest { int[] expectedAllowedGroupCiphers = new int[] { GroupCipher.CCMP, GroupCipher.GCMP_128, GroupCipher.GCMP_256}; boolean expectedRequirePmf = true; + SecurityParams p = SecurityParams.createSecurityParamsBySecurityType( + expectedSecurityType); verifySecurityParams(p, expectedSecurityType, expectedAllowedKeyManagement, expectedAllowedProtocols, expectedAllowedAuthAlgorithms, expectedAllowedPairwiseCiphers, @@ -158,7 +169,6 @@ public class SecurityParamsTest { /** Verify Open params creator. */ @Test public void testOpenCreator() throws Exception { - SecurityParams p = SecurityParams.createOpenParams(); int expectedSecurityType = WifiConfiguration.SECURITY_TYPE_OPEN; int[] expectedAllowedKeyManagement = new int[] {KeyMgmt.NONE}; int[] expectedAllowedProtocols = new int[] {}; @@ -166,6 +176,8 @@ public class SecurityParamsTest { int[] expectedAllowedPairwiseCiphers = new int[] {}; int[] expectedAllowedGroupCiphers = new int[] {}; boolean expectedRequirePmf = false; + SecurityParams p = SecurityParams.createSecurityParamsBySecurityType( + expectedSecurityType); verifySecurityParams(p, expectedSecurityType, expectedAllowedKeyManagement, expectedAllowedProtocols, expectedAllowedAuthAlgorithms, expectedAllowedPairwiseCiphers, @@ -175,7 +187,6 @@ public class SecurityParamsTest { /** Verify OSEN params creator. */ @Test public void testOsenCreator() throws Exception { - SecurityParams p = SecurityParams.createOsenParams(); int expectedSecurityType = WifiConfiguration.SECURITY_TYPE_OSEN; int[] expectedAllowedKeyManagement = new int[] {KeyMgmt.OSEN}; int[] expectedAllowedProtocols = new int[] {Protocol.OSEN}; @@ -183,6 +194,8 @@ public class SecurityParamsTest { int[] expectedAllowedPairwiseCiphers = new int[] {}; int[] expectedAllowedGroupCiphers = new int[] {}; boolean expectedRequirePmf = false; + SecurityParams p = SecurityParams.createSecurityParamsBySecurityType( + expectedSecurityType); verifySecurityParams(p, expectedSecurityType, expectedAllowedKeyManagement, expectedAllowedProtocols, expectedAllowedAuthAlgorithms, expectedAllowedPairwiseCiphers, @@ -192,7 +205,6 @@ public class SecurityParamsTest { /** Verify WAPI CERT params creator. */ @Test public void testWapiCertCreator() throws Exception { - SecurityParams p = SecurityParams.createWapiCertParams(); int expectedSecurityType = WifiConfiguration.SECURITY_TYPE_WAPI_CERT; int[] expectedAllowedKeyManagement = new int[] {KeyMgmt.WAPI_CERT}; int[] expectedAllowedProtocols = new int[] {Protocol.WAPI}; @@ -200,6 +212,8 @@ public class SecurityParamsTest { int[] expectedAllowedPairwiseCiphers = new int[] {PairwiseCipher.SMS4}; int[] expectedAllowedGroupCiphers = new int[] {GroupCipher.SMS4}; boolean expectedRequirePmf = false; + SecurityParams p = SecurityParams.createSecurityParamsBySecurityType( + expectedSecurityType); verifySecurityParams(p, expectedSecurityType, expectedAllowedKeyManagement, expectedAllowedProtocols, expectedAllowedAuthAlgorithms, expectedAllowedPairwiseCiphers, @@ -209,7 +223,6 @@ public class SecurityParamsTest { /** Verify WAPI PSK params creator. */ @Test public void testWapiPskCreator() throws Exception { - SecurityParams p = SecurityParams.createWapiPskParams(); int expectedSecurityType = WifiConfiguration.SECURITY_TYPE_WAPI_PSK; int[] expectedAllowedKeyManagement = new int[] {KeyMgmt.WAPI_PSK}; int[] expectedAllowedProtocols = new int[] {Protocol.WAPI}; @@ -217,6 +230,8 @@ public class SecurityParamsTest { int[] expectedAllowedPairwiseCiphers = new int[] {PairwiseCipher.SMS4}; int[] expectedAllowedGroupCiphers = new int[] {GroupCipher.SMS4}; boolean expectedRequirePmf = false; + SecurityParams p = SecurityParams.createSecurityParamsBySecurityType( + expectedSecurityType); verifySecurityParams(p, expectedSecurityType, expectedAllowedKeyManagement, expectedAllowedProtocols, expectedAllowedAuthAlgorithms, expectedAllowedPairwiseCiphers, @@ -226,7 +241,6 @@ public class SecurityParamsTest { /** Verify WEP params creator. */ @Test public void testWepCreator() throws Exception { - SecurityParams p = SecurityParams.createWepParams(); int expectedSecurityType = WifiConfiguration.SECURITY_TYPE_WEP; int[] expectedAllowedKeyManagement = new int[] {KeyMgmt.NONE}; int[] expectedAllowedProtocols = new int[] {}; @@ -234,6 +248,8 @@ public class SecurityParamsTest { int[] expectedAllowedPairwiseCiphers = new int[] {}; int[] expectedAllowedGroupCiphers = new int[] {}; boolean expectedRequirePmf = false; + SecurityParams p = SecurityParams.createSecurityParamsBySecurityType( + expectedSecurityType); verifySecurityParams(p, expectedSecurityType, expectedAllowedKeyManagement, expectedAllowedProtocols, expectedAllowedAuthAlgorithms, expectedAllowedPairwiseCiphers, @@ -243,7 +259,6 @@ public class SecurityParamsTest { /** Verify WPA3 Enterprise 192-bit params creator. */ @Test public void testWpa3Enterprise192BitCreator() throws Exception { - SecurityParams p = SecurityParams.createWpa3Enterprise192BitParams(); int expectedSecurityType = WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT; int[] expectedAllowedKeyManagement = new int[] { KeyMgmt.WPA_EAP, KeyMgmt.IEEE8021X, KeyMgmt.SUITE_B_192}; @@ -253,6 +268,8 @@ public class SecurityParamsTest { PairwiseCipher.GCMP_128, PairwiseCipher.GCMP_256}; int[] expectedAllowedGroupCiphers = new int[] {GroupCipher.GCMP_128, GroupCipher.GCMP_256}; boolean expectedRequirePmf = true; + SecurityParams p = SecurityParams.createSecurityParamsBySecurityType( + expectedSecurityType); verifySecurityParams(p, expectedSecurityType, expectedAllowedKeyManagement, expectedAllowedProtocols, expectedAllowedAuthAlgorithms, expectedAllowedPairwiseCiphers, @@ -264,7 +281,6 @@ public class SecurityParamsTest { /** Verify WPA3 Enterprise params creator. */ @Test public void testWpa3EnterpriseCreator() throws Exception { - SecurityParams p = SecurityParams.createWpa3EnterpriseParams(); int expectedSecurityType = WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE; int[] expectedAllowedKeyManagement = new int[] {KeyMgmt.WPA_EAP, KeyMgmt.IEEE8021X}; int[] expectedAllowedProtocols = new int[] {Protocol.RSN}; @@ -273,6 +289,8 @@ public class SecurityParamsTest { PairwiseCipher.CCMP, PairwiseCipher.GCMP_256}; int[] expectedAllowedGroupCiphers = new int[] {GroupCipher.CCMP, GroupCipher.GCMP_256}; boolean expectedRequirePmf = true; + SecurityParams p = SecurityParams.createSecurityParamsBySecurityType( + expectedSecurityType); verifySecurityParams(p, expectedSecurityType, expectedAllowedKeyManagement, expectedAllowedProtocols, expectedAllowedAuthAlgorithms, expectedAllowedPairwiseCiphers, @@ -282,7 +300,6 @@ public class SecurityParamsTest { /** Verify WPA3 Personal params creator. */ @Test public void testWpa3PersonalCreator() throws Exception { - SecurityParams p = SecurityParams.createWpa3PersonalParams(); int expectedSecurityType = WifiConfiguration.SECURITY_TYPE_SAE; int[] expectedAllowedKeyManagement = new int[] {KeyMgmt.SAE}; int[] expectedAllowedProtocols = new int[] {Protocol.RSN}; @@ -292,6 +309,8 @@ public class SecurityParamsTest { int[] expectedAllowedGroupCiphers = new int[] { GroupCipher.CCMP, GroupCipher.GCMP_128, GroupCipher.GCMP_256}; boolean expectedRequirePmf = true; + SecurityParams p = SecurityParams.createSecurityParamsBySecurityType( + expectedSecurityType); verifySecurityParams(p, expectedSecurityType, expectedAllowedKeyManagement, expectedAllowedProtocols, expectedAllowedAuthAlgorithms, expectedAllowedPairwiseCiphers, @@ -301,7 +320,6 @@ public class SecurityParamsTest { /** Verify WPA2 Personal EAP params creator. */ @Test public void testWpaWpa2PersonalCreator() throws Exception { - SecurityParams p = SecurityParams.createWpaWpa2PersonalParams(); int expectedSecurityType = WifiConfiguration.SECURITY_TYPE_PSK; int[] expectedAllowedKeyManagement = new int[] {KeyMgmt.WPA_PSK}; int[] expectedAllowedProtocols = new int[] {}; @@ -309,6 +327,8 @@ public class SecurityParamsTest { int[] expectedAllowedPairwiseCiphers = new int[] {}; int[] expectedAllowedGroupCiphers = new int[] {}; boolean expectedRequirePmf = false; + SecurityParams p = SecurityParams.createSecurityParamsBySecurityType( + expectedSecurityType); verifySecurityParams(p, expectedSecurityType, expectedAllowedKeyManagement, expectedAllowedProtocols, expectedAllowedAuthAlgorithms, expectedAllowedPairwiseCiphers, @@ -318,7 +338,8 @@ public class SecurityParamsTest { /** Verify setter/getter methods */ @Test public void testCommonSetterGetter() throws Exception { - SecurityParams params = SecurityParams.createWpaWpa2PersonalParams(); + SecurityParams params = SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_PSK); // PSK setting BitSet allowedKeyManagement = new BitSet(); @@ -362,7 +383,8 @@ public class SecurityParamsTest { /** Verify SAE-specific methods */ @Test public void testSaeMethods() throws Exception { - SecurityParams p = SecurityParams.createWpa3PersonalParams(); + SecurityParams p = SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_SAE); assertFalse(p.isAddedByAutoUpgrade()); p.setIsAddedByAutoUpgrade(true); @@ -380,7 +402,8 @@ public class SecurityParamsTest { /** Verify copy constructor. */ @Test public void testCopyConstructor() throws Exception { - SecurityParams params = SecurityParams.createWpaWpa2PersonalParams(); + SecurityParams params = SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_PSK); params.setEnabled(false); params.setIsAddedByAutoUpgrade(true); @@ -405,9 +428,12 @@ public class SecurityParamsTest { /** Check that two params are equal if and only if their types are the same. */ @Test public void testEquals() { - SecurityParams saeParams1 = SecurityParams.createWpa3PersonalParams(); - SecurityParams saeParams2 = SecurityParams.createWpa3PersonalParams(); - SecurityParams pskParams = SecurityParams.createWpaWpa2PersonalParams(); + SecurityParams saeParams1 = SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_SAE); + SecurityParams saeParams2 = SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_SAE); + SecurityParams pskParams = SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_PSK); assertEquals(saeParams1, saeParams2); assertNotEquals(saeParams1, pskParams); } @@ -415,9 +441,12 @@ public class SecurityParamsTest { /** Check that hash values are the same if and only if their types are the same. */ @Test public void testHashCode() { - SecurityParams saeParams1 = SecurityParams.createWpa3PersonalParams(); - SecurityParams saeParams2 = SecurityParams.createWpa3PersonalParams(); - SecurityParams pskParams = SecurityParams.createWpaWpa2PersonalParams(); + SecurityParams saeParams1 = SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_SAE); + SecurityParams saeParams2 = SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_SAE); + SecurityParams pskParams = SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_PSK); assertEquals(saeParams1.hashCode(), saeParams2.hashCode()); assertNotEquals(saeParams1.hashCode(), pskParams.hashCode()); } @@ -426,26 +455,38 @@ public class SecurityParamsTest { @Test public void testIsOpenNetwork() { SecurityParams[] openSecurityParams = new SecurityParams[] { - SecurityParams.createEnhancedOpenParams(), - SecurityParams.createOpenParams(), + SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_OWE), + SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_OPEN), }; for (SecurityParams p: openSecurityParams) { assertTrue(p.isOpenSecurityType()); } SecurityParams[] nonOpenSecurityParams = new SecurityParams[] { - SecurityParams.createWpaWpa2EnterpriseParams(), - SecurityParams.createPasspointParams(SecurityParams.PASSPOINT_R1), - SecurityParams.createPasspointParams(SecurityParams.PASSPOINT_R2), - SecurityParams.createPasspointParams(SecurityParams.PASSPOINT_R3), - SecurityParams.createOsenParams(), - SecurityParams.createWapiCertParams(), - SecurityParams.createWapiPskParams(), - SecurityParams.createWepParams(), - SecurityParams.createWpa3Enterprise192BitParams(), - SecurityParams.createWpa3EnterpriseParams(), - SecurityParams.createWpa3PersonalParams(), - SecurityParams.createWpaWpa2PersonalParams(), + SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_EAP), + SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_PASSPOINT_R1_R2), + SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_PASSPOINT_R3), + SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_OSEN), + SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_WAPI_PSK), + SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_WAPI_CERT), + SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_WEP), + SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT), + SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE), + SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_SAE), + SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_PSK), }; for (SecurityParams p: nonOpenSecurityParams) { assertFalse(p.isOpenSecurityType()); @@ -456,26 +497,38 @@ public class SecurityParamsTest { @Test public void testIsEnterpriseNetwork() { SecurityParams[] enterpriseSecurityParams = new SecurityParams[] { - SecurityParams.createWpaWpa2EnterpriseParams(), - SecurityParams.createPasspointParams(SecurityParams.PASSPOINT_R1), - SecurityParams.createPasspointParams(SecurityParams.PASSPOINT_R2), - SecurityParams.createPasspointParams(SecurityParams.PASSPOINT_R3), - SecurityParams.createWapiCertParams(), - SecurityParams.createWpa3Enterprise192BitParams(), - SecurityParams.createWpa3EnterpriseParams(), + SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_EAP), + SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_PASSPOINT_R1_R2), + SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_PASSPOINT_R3), + SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_WAPI_CERT), + SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT), + SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE), }; for (SecurityParams p: enterpriseSecurityParams) { assertTrue(p.isEnterpriseSecurityType()); } SecurityParams[] nonEnterpriseSecurityParams = new SecurityParams[] { - SecurityParams.createEnhancedOpenParams(), - SecurityParams.createOpenParams(), - SecurityParams.createOsenParams(), - SecurityParams.createWapiPskParams(), - SecurityParams.createWepParams(), - SecurityParams.createWpa3PersonalParams(), - SecurityParams.createWpaWpa2PersonalParams(), + SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_OWE), + SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_OPEN), + SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_OSEN), + SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_WAPI_PSK), + SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_WEP), + SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_SAE), + SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_PSK), }; for (SecurityParams p: nonEnterpriseSecurityParams) { assertFalse(p.isEnterpriseSecurityType()); @@ -485,7 +538,8 @@ public class SecurityParamsTest { /** Check that parcel marshalling/unmarshalling works */ @Test public void testParcelMethods() { - SecurityParams params = SecurityParams.createWpa3PersonalParams(); + SecurityParams params = SecurityParams.createSecurityParamsBySecurityType( + WifiConfiguration.SECURITY_TYPE_SAE); Parcel parcelW = Parcel.obtain(); params.writeToParcel(parcelW, 0); diff --git a/wifi/tests/src/android/net/wifi/WifiConfigurationTest.java b/wifi/tests/src/android/net/wifi/WifiConfigurationTest.java index f351e61b5eb8..bde44e7f8f27 100644 --- a/wifi/tests/src/android/net/wifi/WifiConfigurationTest.java +++ b/wifi/tests/src/android/net/wifi/WifiConfigurationTest.java @@ -22,6 +22,8 @@ import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRI import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_OPEN; import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_OSEN; import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_OWE; +import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_PASSPOINT_R1_R2; +import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_PASSPOINT_R3; import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_PSK; import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_SAE; import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_WAPI_CERT; @@ -51,6 +53,8 @@ import com.android.net.module.util.MacAddressUtils; import org.junit.Before; import org.junit.Test; +import java.util.ArrayList; +import java.util.BitSet; import java.util.List; /** @@ -915,7 +919,7 @@ public class WifiConfigurationTest { WifiConfiguration config = new WifiConfiguration(); config.setSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_SAE); - config.addSecurityParams(SecurityParams.createWapiPskParams()); + config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_WAPI_PSK); List paramsList = config.getSecurityParamsList(); assertEquals(3, paramsList.size()); @@ -1004,18 +1008,18 @@ public class WifiConfigurationTest { @Test (expected = IllegalArgumentException.class) public void testAddDuplicateSecurityParams() { WifiConfiguration config = new WifiConfiguration(); - config.addSecurityParams(SecurityParams.createWpaWpa2PersonalParams()); - config.addSecurityParams(SecurityParams.createWpaWpa2PersonalParams()); + config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); + config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_PSK); } /** Verify that Suite-B type works as expected. */ @Test public void testAddSuiteBSecurityType() { WifiConfiguration config = new WifiConfiguration(); - config.addSecurityParams(SecurityParams.createWpa3EnterpriseParams()); + config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE); config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.SIM); config.enterpriseConfig.setPhase2Method(WifiEnterpriseConfig.Phase2.NONE); - config.addSecurityParams(SecurityParams.createWpa3Enterprise192BitParams()); + config.addSecurityParams(WifiConfiguration.SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT); assertFalse(config.isSuiteBCipherEcdheRsaEnabled()); config.enableSuiteBCiphers(false, true); @@ -1101,22 +1105,96 @@ public class WifiConfigurationTest { /** Verify the set security params by SecurityParams objects. */ @Test public void testSetBySecurityParamsObject() { - Pair[] securityParamsSecurityTypePairs = new Pair[] { - new Pair<>(SecurityParams.createWapiCertParams(), SECURITY_TYPE_WAPI_CERT), - new Pair<>(SecurityParams.createWapiPskParams(), SECURITY_TYPE_WAPI_PSK), - new Pair<>(SecurityParams.createWpa3Enterprise192BitParams(), - SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT), - new Pair<>(SecurityParams.createEnhancedOpenParams(), SECURITY_TYPE_OWE), - new Pair<>(SecurityParams.createWpa3PersonalParams(), SECURITY_TYPE_SAE), - new Pair<>(SecurityParams.createOsenParams(), SECURITY_TYPE_OSEN), - new Pair<>(SecurityParams.createWpaWpa2EnterpriseParams(), SECURITY_TYPE_EAP), - new Pair<>(SecurityParams.createWpaWpa2PersonalParams(), SECURITY_TYPE_PSK), - new Pair<>(SecurityParams.createOpenParams(), SECURITY_TYPE_OPEN), + int[] securityTypes = new int[] { + SECURITY_TYPE_WAPI_CERT, + SECURITY_TYPE_WAPI_PSK, + SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT, + SECURITY_TYPE_OWE, + SECURITY_TYPE_SAE, + SECURITY_TYPE_OSEN, + SECURITY_TYPE_EAP, + SECURITY_TYPE_PSK, + SECURITY_TYPE_OPEN, + SECURITY_TYPE_PASSPOINT_R1_R2, + SECURITY_TYPE_PASSPOINT_R3, }; - for (Pair pair: securityParamsSecurityTypePairs) { + for (int type: securityTypes) { WifiConfiguration config = new WifiConfiguration(); - config.setSecurityParams((SecurityParams) pair.first); + config.setSecurityParams(type); + assertTrue(config.isSecurityType(type)); + assertNotNull(config.getSecurityParams(type)); + } + } + + /** Verify the set security params by an allowed key management mask. */ + @Test + public void testSetSecurityParamsByAllowedKeyManagement() { + Pair[] keyMgmtSecurityTypePairs = new Pair[] { + new Pair<>(KeyMgmt.WAPI_CERT, SECURITY_TYPE_WAPI_CERT), + new Pair<>(KeyMgmt.WAPI_PSK, SECURITY_TYPE_WAPI_PSK), + new Pair<>(KeyMgmt.SUITE_B_192, SECURITY_TYPE_EAP_WPA3_ENTERPRISE_192_BIT), + new Pair<>(KeyMgmt.OWE, SECURITY_TYPE_OWE), + new Pair<>(KeyMgmt.SAE, SECURITY_TYPE_SAE), + new Pair<>(KeyMgmt.OSEN, SECURITY_TYPE_OSEN), + new Pair<>(KeyMgmt.WPA2_PSK, SECURITY_TYPE_PSK), + new Pair<>(KeyMgmt.WPA_EAP, SECURITY_TYPE_EAP), + new Pair<>(KeyMgmt.WPA_PSK, SECURITY_TYPE_PSK), + new Pair<>(KeyMgmt.NONE, SECURITY_TYPE_OPEN), + }; + + for (Pair pair: keyMgmtSecurityTypePairs) { + BitSet akm = new BitSet(); + akm.set((int) pair.first); + WifiConfiguration config = new WifiConfiguration(); + config.setSecurityParams(akm); assertNotNull(config.getSecurityParams((int) pair.second)); } } + + /** Verify the set security params by an invalid allowed key management mask. */ + @Test (expected = IllegalArgumentException.class) + public void testSetSecurityParamsByInvalidAllowedKeyManagement() { + WifiConfiguration config = new WifiConfiguration(); + BitSet akm = null; + config.setSecurityParams(akm); + } + + /** Verify the set security params by a security params list. */ + @Test + public void testSetSecurityParamsBySecurityParamsList() { + WifiConfiguration config = new WifiConfiguration(); + config.enterpriseConfig.setEapMethod(WifiEnterpriseConfig.Eap.SIM); + config.enterpriseConfig.setPhase2Method(WifiEnterpriseConfig.Phase2.NONE); + config.addSecurityParams(SECURITY_TYPE_EAP); + config.addSecurityParams(SECURITY_TYPE_EAP_WPA3_ENTERPRISE); + assertTrue(config.isSecurityType(SECURITY_TYPE_EAP)); + assertTrue(config.isSecurityType(SECURITY_TYPE_EAP_WPA3_ENTERPRISE)); + assertFalse(config.isSecurityType(SECURITY_TYPE_PSK)); + assertFalse(config.isSecurityType(SECURITY_TYPE_SAE)); + + List list = new ArrayList<>(); + list.add(SecurityParams.createSecurityParamsBySecurityType(SECURITY_TYPE_PSK)); + list.add(SecurityParams.createSecurityParamsBySecurityType(SECURITY_TYPE_SAE)); + config.setSecurityParams(list); + assertFalse(config.isSecurityType(SECURITY_TYPE_EAP)); + assertFalse(config.isSecurityType(SECURITY_TYPE_EAP_WPA3_ENTERPRISE)); + assertTrue(config.isSecurityType(SECURITY_TYPE_PSK)); + assertTrue(config.isSecurityType(SECURITY_TYPE_SAE)); + } + + /** Verify the set security params by an empty security params list. */ + @Test (expected = IllegalArgumentException.class) + public void testSetSecurityParamsByEmptySecurityParamsList() { + WifiConfiguration config = new WifiConfiguration(); + List list = new ArrayList<>(); + config.setSecurityParams(list); + } + + /** Verify the set security params by a null security params list. */ + @Test (expected = IllegalArgumentException.class) + public void testSetSecurityParamsByNullSecurityParamsList() { + WifiConfiguration config = new WifiConfiguration(); + List list = null; + config.setSecurityParams(list); + } }