Merge changes from topics "s-security-params-backup-restore", "s-seucrity-params-setup-migration" (7ff19c53) · Commits · e / os / android_frameworks_base

wifi/java/android/net/wifi/SecurityParams.java

+76 −12

Original line number	Diff line number	Diff line
		@@ -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;

wifi/java/android/net/wifi/WifiConfiguration.java

+35 −51

Original line number	Diff line number	Diff line
		@@ -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 */

wifi/tests/src/android/net/wifi/SecurityParamsTest.java

+124 −70

File changed.

Preview size limit exceeded, changes collapsed.

wifi/tests/src/android/net/wifi/WifiConfigurationTest.java

+96 −18

Original line number	Diff line number	Diff line
		@@ -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 (int type: securityTypes) {
		WifiConfiguration config = new WifiConfiguration();
		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: securityParamsSecurityTypePairs) {

		for (Pair pair: keyMgmtSecurityTypePairs) {
		BitSet akm = new BitSet();
		akm.set((int) pair.first);
		WifiConfiguration config = new WifiConfiguration();
		config.setSecurityParams((SecurityParams) pair.first);
		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);
		}
		}