From 8d0bb8682d18edeb765d633112af3901b211bfd6 Mon Sep 17 00:00:00 2001
From: Jimmy Chen <jimmycmchen@google.com>
Date: Fri, 11 Dec 2020 15:59:43 +0800
Subject: [PATCH] wifi: add getSecurityType and
createSecurityParamsBySecurityType methods
For backup/restore, it needs to know security type and create a security
params from the security type.
Bug: 162685856
Test: atest FrameworksWifiApiTes
Change-Id: I2a52a288157d7875074f8e20218d564c363b568f
---
.../java/android/net/wifi/SecurityParams.java | 88 ++++++--
.../android/net/wifi/WifiConfiguration.java | 50 +----
.../android/net/wifi/SecurityParamsTest.java | 194 +++++++++++-------
.../net/wifi/WifiConfigurationTest.java | 42 ++--
4 files changed, 224 insertions(+), 150 deletions(-)
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..d0e1204e7fbd 100644
--- a/wifi/java/android/net/wifi/WifiConfiguration.java
+++ b/wifi/java/android/net/wifi/WifiConfiguration.java
@@ -605,55 +605,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,44 +69,50 @@ public class SecurityParamsTest {
assertEquals(expectedRequirePmf, params.isRequirePmf());
}
- /** Verify EAP params creator. */
+ /** Verify the security params created by security type. */
@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[] {};
- int[] expectedAllowedAuthAlgorithms = new int[] {};
- int[] expectedAllowedPairwiseCiphers = new int[] {};
- int[] expectedAllowedGroupCiphers = new int[] {};
- boolean expectedRequirePmf = false;
- verifySecurityParams(p, expectedSecurityType,
- expectedAllowedKeyManagement, expectedAllowedProtocols,
- expectedAllowedAuthAlgorithms, expectedAllowedPairwiseCiphers,
- expectedAllowedGroupCiphers, expectedRequirePmf);
+ 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 Passpoint R1 params creator. */
+ /** Verify EAP params creator. */
@Test
- public void testEapPasspointR1Creator() throws Exception {
- SecurityParams p = SecurityParams.createPasspointParams(SecurityParams.PASSPOINT_R1);
- int expectedSecurityType = WifiConfiguration.SECURITY_TYPE_PASSPOINT_R1_R2;
+ public void testEapCreator() throws Exception {
+ int expectedSecurityType = WifiConfiguration.SECURITY_TYPE_EAP;
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;
+ SecurityParams p = SecurityParams.createSecurityParamsBySecurityType(
+ expectedSecurityType);
verifySecurityParams(p, expectedSecurityType,
expectedAllowedKeyManagement, expectedAllowedProtocols,
expectedAllowedAuthAlgorithms, expectedAllowedPairwiseCiphers,
expectedAllowedGroupCiphers, expectedRequirePmf);
}
- /** Verify Passpoint R2 params creator. */
+ /** Verify Passpoint R1/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..ea41434f907f 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;
@@ -915,7 +917,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<SecurityParams> paramsList = config.getSecurityParamsList();
assertEquals(3, paramsList.size());
@@ -1004,18 +1006,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 +1103,24 @@ 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);
- assertNotNull(config.getSecurityParams((int) pair.second));
+ config.setSecurityParams(type);
+ assertTrue(config.isSecurityType(type));
+ assertNotNull(config.getSecurityParams(type));
}
}
}
--
GitLab