Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7ff19c53 authored by Jimmy Chen's avatar Jimmy Chen Committed by Android (Google) Code Review
Browse files

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

* changes:
  wifi: add setSecurityParams APIs for wifi service migration
  wifi: add getSecurityType and createSecurityParamsBySecurityType methods
parents 11cb8f86 97ff070f
Loading
Loading
Loading
Loading
+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;

+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 */
+124 −70

File changed.

Preview size limit exceeded, changes collapsed.

+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);
    }
}