drgreen/android_frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge changes from topics "s-security-params-backup-restore", "s-seucrity-params-setup-migration"

Browse Source 
* changes:
  wifi: add setSecurityParams APIs for wifi service migration
  wifi: add getSecurityType and createSecurityParamsBySecurityType methods
This commit is contained in:
Jimmy Chen 2020-12-23 05:24:38 +00:00 committed by Android (Google) Code Review
commit 7ff19c531f
4 changed files with 331 additions and 151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

88
wifi/java/android/net/wifi/SecurityParams.java
View File

@ -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;

86
wifi/java/android/net/wifi/WifiConfiguration.java
View File

@ -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.
* <br>
@ -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<SecurityParams> 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 */

194
wifi/tests/src/android/net/wifi/SecurityParamsTest.java
View File

@ -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);

114
wifi/tests/src/android/net/wifi/WifiConfigurationTest.java
View File

@ -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<SecurityParams> 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<SecurityParams> 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<SecurityParams> 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<SecurityParams> list = null;
config.setSecurityParams(list);
}
}