Git-Mirrors/DivestOS
1
0
Fork 0
mirror of https://github.com/Divested-Mobile/DivestOS-Build.git synced 2025-12-15 08:38:49 -05:00
Code Issues Projects Releases Packages Wiki Activity

Add the GrapheneOS always randomize MAC option to 17.1 and 18.1

Browse source 
The DHCP state patch was backported to 17.1

Signed-off-by: Tad <tad@spotco.us>
This commit is contained in:
Tad 2022-03-29 22:27:06 -04:00
parent 09834b568f
commit f481055ae9
13 changed files with 3612 additions and 1 deletions
Download patch file Download diff file Expand all files Collapse all files

32
Patches/LineageOS-17.1/android_frameworks_base/0019-Random_MAC.patch Normal file
View file

@ -0,0 +1,32 @@
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Renlord <me@renlord.com>
Date: Fri, 13 Dec 2019 22:44:39 +1100
Subject: [PATCH] add option of always randomizing MAC addresses
---
wifi/java/android/net/wifi/WifiConfiguration.java | 7 ++++++-
1 file changed, 6 insertions(+), 1 deletion(-)
diff --git a/wifi/java/android/net/wifi/WifiConfiguration.java b/wifi/java/android/net/wifi/WifiConfiguration.java
index 88f2bb2ad6e8..24a9b043b75c 100644
--- a/wifi/java/android/net/wifi/WifiConfiguration.java
+++ b/wifi/java/android/net/wifi/WifiConfiguration.java
@@ -1015,12 +1015,17 @@ public class WifiConfiguration implements Parcelable {
* Generate a randomized MAC once and reuse it for all connections to this network
*/
public static final int RANDOMIZATION_PERSISTENT = 1;
+ /**
+ * @hide
+ * Generate a randomize MAC always
+ */
+ public static final int RANDOMIZATION_ALWAYS = 100;
/**
* @hide
* Level of MAC randomization for this network
*/
- public int macRandomizationSetting = RANDOMIZATION_PERSISTENT;
+ public int macRandomizationSetting = RANDOMIZATION_ALWAYS;
/**
* @hide

105
Patches/LineageOS-17.1/android_frameworks_opt_net_wifi/0002-Random_MAC.patch Normal file
View file

@ -0,0 +1,105 @@
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Renlord <me@renlord.com>
Date: Sat, 21 Dec 2019 00:33:56 +1100
Subject: [PATCH] add support for always generating new random MAC
To trigger re-generation of randomized MAC addressed for an already
connected AP. User simply has to toggle on/off wifi. Otherwise, on
re-connection, a new randomized MAC address also gets generated.
---
.../java/com/android/server/wifi/ClientModeImpl.java | 9 +++++++--
.../com/android/server/wifi/WifiConfigManager.java | 10 ++++++++--
.../com/android/server/wifi/WifiConfigurationUtil.java | 2 +-
service/java/com/android/server/wifi/WifiMetrics.java | 4 ++--
4 files changed, 18 insertions(+), 7 deletions(-)
diff --git a/service/java/com/android/server/wifi/ClientModeImpl.java b/service/java/com/android/server/wifi/ClientModeImpl.java
index d91b7f8b8..befc92fb4 100644
--- a/service/java/com/android/server/wifi/ClientModeImpl.java
+++ b/service/java/com/android/server/wifi/ClientModeImpl.java
@@ -3407,7 +3407,12 @@ public class ClientModeImpl extends StateMachine {
String currentMacString = mWifiNative.getMacAddress(mInterfaceName);
MacAddress currentMac = currentMacString == null ? null :
MacAddress.fromString(currentMacString);
- MacAddress newMac = config.getOrCreateRandomizedMacAddress();
+ MacAddress newMac;
+ if (config.macRandomizationSetting == WifiConfiguration.RANDOMIZATION_PERSISTENT) {
+ newMac = config.getOrCreateRandomizedMacAddress();
+ } else {
+ newMac = MacAddress.createRandomUnicastAddress();
+ }
mWifiConfigManager.setNetworkRandomizedMacAddress(config.networkId, newMac);
if (!WifiConfiguration.isValidMacAddressForRandomization(newMac)) {
Log.wtf(TAG, "Config generated an invalid MAC address");
@@ -4310,7 +4315,7 @@ public class ClientModeImpl extends StateMachine {
reportConnectionAttemptStart(config, mTargetRoamBSSID,
WifiMetricsProto.ConnectionEvent.ROAM_UNRELATED);
if (config.macRandomizationSetting
- == WifiConfiguration.RANDOMIZATION_PERSISTENT
+ != WifiConfiguration.RANDOMIZATION_NONE
&& mConnectedMacRandomzationSupported) {
configureRandomizedMacAddress(config);
} else {
diff --git a/service/java/com/android/server/wifi/WifiConfigManager.java b/service/java/com/android/server/wifi/WifiConfigManager.java
index 393a5c395..cb44fb4ab 100644
--- a/service/java/com/android/server/wifi/WifiConfigManager.java
+++ b/service/java/com/android/server/wifi/WifiConfigManager.java
@@ -1113,7 +1113,13 @@ public class WifiConfigManager {
packageName != null ? packageName : mContext.getPackageManager().getNameForUid(uid);
newInternalConfig.creationTime = newInternalConfig.updateTime =
createDebugTimeStampString(mClock.getWallClockMillis());
- MacAddress randomizedMac = getPersistentMacAddress(newInternalConfig);
+
+ MacAddress randomizedMac;
+ if (externalConfig.macRandomizationSetting == WifiConfiguration.RANDOMIZATION_PERSISTENT) {
+ randomizedMac = getPersistentMacAddress(newInternalConfig);
+ } else {
+ randomizedMac = MacAddress.createRandomUnicastAddress();
+ }
if (randomizedMac != null) {
newInternalConfig.setRandomizedMacAddress(randomizedMac);
}
@@ -1533,7 +1539,7 @@ public class WifiConfigManager {
public boolean isInFlakyRandomizationSsidHotlist(int networkId) {
WifiConfiguration config = getConfiguredNetwork(networkId);
return config != null
- && config.macRandomizationSetting == WifiConfiguration.RANDOMIZATION_PERSISTENT
+ && config.macRandomizationSetting != WifiConfiguration.RANDOMIZATION_NONE
&& mRandomizationFlakySsidHotlist.contains(config.SSID);
}
diff --git a/service/java/com/android/server/wifi/WifiConfigurationUtil.java b/service/java/com/android/server/wifi/WifiConfigurationUtil.java
index b8992a011..f47f42d1b 100644
--- a/service/java/com/android/server/wifi/WifiConfigurationUtil.java
+++ b/service/java/com/android/server/wifi/WifiConfigurationUtil.java
@@ -242,7 +242,7 @@ public class WifiConfigurationUtil {
public static boolean hasMacRandomizationSettingsChanged(WifiConfiguration existingConfig,
WifiConfiguration newConfig) {
if (existingConfig == null) {
- return newConfig.macRandomizationSetting != WifiConfiguration.RANDOMIZATION_PERSISTENT;
+ return newConfig.macRandomizationSetting != WifiConfiguration.RANDOMIZATION_ALWAYS;
}
return newConfig.macRandomizationSetting != existingConfig.macRandomizationSetting;
}
diff --git a/service/java/com/android/server/wifi/WifiMetrics.java b/service/java/com/android/server/wifi/WifiMetrics.java
index 6db4e9955..5ea824ee3 100644
--- a/service/java/com/android/server/wifi/WifiMetrics.java
+++ b/service/java/com/android/server/wifi/WifiMetrics.java
@@ -1115,7 +1115,7 @@ public class WifiMetrics {
if (config != null) {
mCurrentConnectionEvent.mConnectionEvent.useRandomizedMac =
config.macRandomizationSetting
- == WifiConfiguration.RANDOMIZATION_PERSISTENT;
+ != WifiConfiguration.RANDOMIZATION_NONE;
mCurrentConnectionEvent.mConnectionEvent.connectionNominator =
mNetworkIdToNominatorId.get(config.networkId,
WifiMetricsProto.ConnectionEvent.NOMINATOR_UNKNOWN);
@@ -3037,7 +3037,7 @@ public class WifiMetrics {
if (config.isPasspoint()) {
mWifiLogProto.numPasspointNetworks++;
}
- if (config.macRandomizationSetting == WifiConfiguration.RANDOMIZATION_PERSISTENT) {
+ if (config.macRandomizationSetting != WifiConfiguration.RANDOMIZATION_NONE) {
mWifiLogProto.numSavedNetworksWithMacRandomization++;
}
}

106
Patches/LineageOS-17.1/android_packages_apps_Settings/0010-Random_MAC-1.patch Normal file
View file

@ -0,0 +1,106 @@
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Renlord <me@renlord.com>
Date: Sun, 8 Dec 2019 23:58:24 +0100
Subject: [PATCH] add option to always randomize MAC
RANDOMIZATION_ALWAYS is set as the default option
---
res/values/arrays.xml | 4 ++-
.../WifiDetailPreferenceController.java | 3 +-
.../WifiPrivacyPreferenceController.java | 31 ++++++++++++++-----
3 files changed, 29 insertions(+), 9 deletions(-)
diff --git a/res/values/arrays.xml b/res/values/arrays.xml
index b983f467df..e1e7581deb 100644
--- a/res/values/arrays.xml
+++ b/res/values/arrays.xml
@@ -1120,7 +1120,8 @@
</string-array>
<string-array name="wifi_privacy_entries">
- <item>Use randomized MAC (default)</item>
+ <item>Use fully randomized MAC (default)</item>
+ <item>Use per-network randomized MAC</item>
<item>Use device MAC</item>
</string-array>
@@ -1136,6 +1137,7 @@
</string-array>
<string-array name="wifi_privacy_values" translatable="false">
+ <item>100</item>
<item>1</item>
<item>0</item>
</string-array>
diff --git a/src/com/android/settings/wifi/details/WifiDetailPreferenceController.java b/src/com/android/settings/wifi/details/WifiDetailPreferenceController.java
index afcf883fb6..ce45108f22 100644
--- a/src/com/android/settings/wifi/details/WifiDetailPreferenceController.java
+++ b/src/com/android/settings/wifi/details/WifiDetailPreferenceController.java
@@ -700,7 +700,8 @@ public class WifiDetailPreferenceController extends AbstractPreferenceController
// return randomized MAC address
if (mWifiConfig != null &&
- mWifiConfig.macRandomizationSetting == WifiConfiguration.RANDOMIZATION_PERSISTENT) {
+ (mWifiConfig.macRandomizationSetting == WifiConfiguration.RANDOMIZATION_PERSISTENT
+ || mWifiConfig.macRandomizationSetting == WifiConfiguration.RANDOMIZATION_ALWAYS)) {
return mWifiConfig.getRandomizedMacAddress().toString();
}
diff --git a/src/com/android/settings/wifi/details/WifiPrivacyPreferenceController.java b/src/com/android/settings/wifi/details/WifiPrivacyPreferenceController.java
index 950cc131f4..1ed9646a7f 100644
--- a/src/com/android/settings/wifi/details/WifiPrivacyPreferenceController.java
+++ b/src/com/android/settings/wifi/details/WifiPrivacyPreferenceController.java
@@ -112,11 +112,12 @@ public class WifiPrivacyPreferenceController extends BasePreferenceController im
if (mWifiConfiguration != null) {
return mWifiConfiguration.macRandomizationSetting;
}
- return WifiConfiguration.RANDOMIZATION_PERSISTENT;
+ return WifiConfiguration.RANDOMIZATION_ALWAYS;
}
- private static final int PREF_RANDOMIZATION_PERSISTENT = 0;
- private static final int PREF_RANDOMIZATION_NONE = 1;
+ private static final int PREF_RANDOMIZATION_ALWAYS = 0;
+ private static final int PREF_RANDOMIZATION_PERSISTENT = 1;
+ private static final int PREF_RANDOMIZATION_NONE = 2;
/**
* Returns preference index value.
@@ -125,8 +126,16 @@ public class WifiPrivacyPreferenceController extends BasePreferenceController im
* @return index value of preference
*/
public static int translateMacRandomizedValueToPrefValue(int macRandomized) {
- return (macRandomized == WifiConfiguration.RANDOMIZATION_PERSISTENT)
- ? PREF_RANDOMIZATION_PERSISTENT : PREF_RANDOMIZATION_NONE;
+ switch (macRandomized) {
+ case WifiConfiguration.RANDOMIZATION_ALWAYS:
+ return PREF_RANDOMIZATION_ALWAYS;
+ case WifiConfiguration.RANDOMIZATION_PERSISTENT:
+ return PREF_RANDOMIZATION_PERSISTENT;
+ case WifiConfiguration.RANDOMIZATION_NONE:
+ return PREF_RANDOMIZATION_NONE;
+ default:
+ return PREF_RANDOMIZATION_ALWAYS;
+ }
}
/**
@@ -136,8 +145,16 @@ public class WifiPrivacyPreferenceController extends BasePreferenceController im
* @return mac randomized value
*/
public static int translatePrefValueToMacRandomizedValue(int prefMacRandomized) {
- return (prefMacRandomized == PREF_RANDOMIZATION_PERSISTENT)
- ? WifiConfiguration.RANDOMIZATION_PERSISTENT : WifiConfiguration.RANDOMIZATION_NONE;
+ switch (prefMacRandomized) {
+ case PREF_RANDOMIZATION_ALWAYS:
+ return WifiConfiguration.RANDOMIZATION_ALWAYS;
+ case PREF_RANDOMIZATION_PERSISTENT:
+ return WifiConfiguration.RANDOMIZATION_PERSISTENT;
+ case PREF_RANDOMIZATION_NONE:
+ return WifiConfiguration.RANDOMIZATION_NONE;
+ default:
+ return WifiConfiguration.RANDOMIZATION_ALWAYS;
+ }
}
private void updateSummary(DropDownPreference preference, int macRandomized) {

1368
Patches/LineageOS-17.1/android_packages_apps_Settings/0010-Random_MAC-2.patch Normal file
View file

File diff suppressed because it is too large Load diff

71
Patches/LineageOS-17.1/android_packages_modules_NetworkStack/0001-Random_MAC.patch Normal file
View file

@ -0,0 +1,71 @@
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Pratyush <39559233+empratyush@users.noreply.github.com>
Date: Thu, 20 May 2021 13:21:31 +0530
Subject: [PATCH] avoid reusing DHCP state for full MAC randomization
---
src/android/net/dhcp/DhcpClient.java | 30 +++++++++++++++++++++++++++-
1 file changed, 29 insertions(+), 1 deletion(-)
diff --git a/src/android/net/dhcp/DhcpClient.java b/src/android/net/dhcp/DhcpClient.java
index c45fc82..b62239c 100644
--- a/src/android/net/dhcp/DhcpClient.java
+++ b/src/android/net/dhcp/DhcpClient.java
@@ -60,6 +60,9 @@ import android.net.metrics.IpConnectivityLog;
import android.net.util.InterfaceParams;
import android.net.util.NetworkStackUtils;
import android.net.util.SocketUtils;
+import android.net.wifi.WifiConfiguration;
+import android.net.wifi.WifiInfo;
+import android.net.wifi.WifiManager;
import android.os.Message;
import android.os.SystemClock;
import android.system.ErrnoException;
@@ -84,6 +87,8 @@ import java.net.SocketAddress;
import java.net.SocketException;
import java.nio.ByteBuffer;
import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.List;
import java.util.Random;
/**
@@ -917,7 +922,7 @@ public class DhcpClient extends StateMachine {
+ " lease expiry: " + attributes.assignedV4AddressExpiry
+ " current time: " + currentTime);
}
- if (currentTime >= attributes.assignedV4AddressExpiry) {
+ if (currentTime >= attributes.assignedV4AddressExpiry || shouldAvoidStateReuse()) {
// Lease has expired.
transitionTo(mDhcpInitState);
return HANDLED;
@@ -941,6 +946,29 @@ public class DhcpClient extends StateMachine {
}
}
+ private static final int RANDOMIZATION_ALWAYS = 100;
+
+ private boolean shouldAvoidStateReuse() {
+ try {
+ WifiManager wifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);
+ WifiInfo wifiInfo = wifiManager.getConnectionInfo();
+ if (wifiInfo != null) {
+ int connectedNetworkId = wifiInfo.getNetworkId();
+ List<WifiConfiguration> configurationList = wifiManager.getConfiguredNetworks();
+ for (WifiConfiguration configuration : configurationList){
+ if (configuration.networkId == connectedNetworkId){
+ return configuration.macRandomizationSetting == RANDOMIZATION_ALWAYS;
+ }
+ }
+ }
+ } catch (Exception e) {
+ loge(e.getLocalizedMessage(), e);
+ }
+
+ loge("ConfiguredNetworks should contain Connected network id config");
+ return true;
+ }
+
class DhcpInitState extends PacketRetransmittingState {
public DhcpInitState() {
super();

75
Patches/LineageOS-18.1/android_frameworks_base/0019-Random_MAC.patch Normal file
View file

@ -0,0 +1,75 @@
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Renlord <me@renlord.com>
Date: Fri, 13 Dec 2019 22:44:39 +1100
Subject: [PATCH] add option of always randomizing MAC addresses
---
api/system-current.txt | 1 +
wifi/api/system-current.txt | 1 +
wifi/java/android/net/wifi/WifiConfiguration.java | 15 +++++++++++----
3 files changed, 13 insertions(+), 4 deletions(-)
diff --git a/api/system-current.txt b/api/system-current.txt
index f07ebaf19cb6..21dbbbc244a6 100755
--- a/api/system-current.txt
+++ b/api/system-current.txt
@@ -7117,6 +7117,7 @@ package android.net.wifi {
field @Deprecated public static final int METERED_OVERRIDE_METERED = 1; // 0x1
field @Deprecated public static final int METERED_OVERRIDE_NONE = 0; // 0x0
field @Deprecated public static final int METERED_OVERRIDE_NOT_METERED = 2; // 0x2
+ field @Deprecated public static final int RANDOMIZATION_ALWAYS = 100; // 0x64
field @Deprecated public static final int RANDOMIZATION_NONE = 0; // 0x0
field @Deprecated public static final int RANDOMIZATION_PERSISTENT = 1; // 0x1
field @Deprecated public static final int RECENT_FAILURE_AP_UNABLE_TO_HANDLE_NEW_STA = 17; // 0x11
diff --git a/wifi/api/system-current.txt b/wifi/api/system-current.txt
index 07793c1eb02a..2a9fa1093774 100644
--- a/wifi/api/system-current.txt
+++ b/wifi/api/system-current.txt
@@ -320,6 +320,7 @@ package android.net.wifi {
field @Deprecated public static final int METERED_OVERRIDE_METERED = 1; // 0x1
field @Deprecated public static final int METERED_OVERRIDE_NONE = 0; // 0x0
field @Deprecated public static final int METERED_OVERRIDE_NOT_METERED = 2; // 0x2
+ field @Deprecated public static final int RANDOMIZATION_ALWAYS = 100; // 0x64
field @Deprecated public static final int RANDOMIZATION_NONE = 0; // 0x0
field @Deprecated public static final int RANDOMIZATION_PERSISTENT = 1; // 0x1
field @Deprecated public static final int RECENT_FAILURE_AP_UNABLE_TO_HANDLE_NEW_STA = 17; // 0x11
diff --git a/wifi/java/android/net/wifi/WifiConfiguration.java b/wifi/java/android/net/wifi/WifiConfiguration.java
index 71f0ab8087ab..8f52ba46a409 100644
--- a/wifi/java/android/net/wifi/WifiConfiguration.java
+++ b/wifi/java/android/net/wifi/WifiConfiguration.java
@@ -1130,7 +1130,8 @@ public class WifiConfiguration implements Parcelable {
@Retention(RetentionPolicy.SOURCE)
@IntDef(prefix = {"RANDOMIZATION_"}, value = {
RANDOMIZATION_NONE,
- RANDOMIZATION_PERSISTENT})
+ RANDOMIZATION_PERSISTENT,
+ RANDOMIZATION_ALWAYS})
public @interface MacRandomizationSetting {}
/**
@@ -1145,16 +1146,22 @@ public class WifiConfiguration implements Parcelable {
*/
@SystemApi
public static final int RANDOMIZATION_PERSISTENT = 1;
+ /**
+ * @hide
+ * Generate a randomize MAC always
+ */
+ @SystemApi
+ public static final int RANDOMIZATION_ALWAYS = 100;
/**
* Level of MAC randomization for this network.
- * One of {@link #RANDOMIZATION_NONE} or {@link #RANDOMIZATION_PERSISTENT}.
- * By default this field is set to {@link #RANDOMIZATION_PERSISTENT}.
+ * One of {@link #RANDOMIZATION_NONE} or {@link #RANDOMIZATION_PERSISTENT} or RANDOMIZATION_ALWAYS.
+ * By default this field is set to RANDOMIZATION_ALWAYS in GrapheneOS.
* @hide
*/
@SystemApi
@MacRandomizationSetting
- public int macRandomizationSetting = RANDOMIZATION_PERSISTENT;
+ public int macRandomizationSetting = RANDOMIZATION_ALWAYS;
/**
* @hide

192
Patches/LineageOS-18.1/android_frameworks_opt_net_wifi/0001-Random_MAC.patch Normal file
View file

@ -0,0 +1,192 @@
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Renlord <me@renlord.com>
Date: Sat, 21 Dec 2019 00:33:56 +1100
Subject: [PATCH] add support for always generating new random MAC
To trigger re-generation of randomized MAC addressed for an already
connected AP. User simply has to toggle on/off wifi. Otherwise, on
re-connection, a new randomized MAC address also gets generated.
---
.../wifitrackerlib/StandardWifiEntry.java | 34 ++++++++++++++-----
.../com/android/wifitrackerlib/WifiEntry.java | 1 +
.../android/server/wifi/ClientModeImpl.java | 5 +--
.../server/wifi/WifiConfigManager.java | 13 +++++--
.../server/wifi/WifiConfigurationUtil.java | 2 +-
.../com/android/server/wifi/WifiMetrics.java | 4 +--
6 files changed, 43 insertions(+), 16 deletions(-)
diff --git a/libs/WifiTrackerLib/src/com/android/wifitrackerlib/StandardWifiEntry.java b/libs/WifiTrackerLib/src/com/android/wifitrackerlib/StandardWifiEntry.java
index 51270545b..a96ba03e3 100644
--- a/libs/WifiTrackerLib/src/com/android/wifitrackerlib/StandardWifiEntry.java
+++ b/libs/WifiTrackerLib/src/com/android/wifitrackerlib/StandardWifiEntry.java
@@ -324,7 +324,7 @@ public class StandardWifiEntry extends WifiEntry {
return wifiInfoMac;
}
}
- if (mWifiConfig == null || getPrivacy() != PRIVACY_RANDOMIZED_MAC) {
+ if (mWifiConfig == null || getPrivacy() == PRIVACY_DEVICE_MAC) {
final String[] factoryMacs = mWifiManager.getFactoryMacAddresses();
if (factoryMacs.length > 0) {
return factoryMacs[0];
@@ -578,11 +578,19 @@ public class StandardWifiEntry extends WifiEntry {
@Override
@Privacy
public int getPrivacy() {
- if (mWifiConfig != null
- && mWifiConfig.macRandomizationSetting == WifiConfiguration.RANDOMIZATION_NONE) {
- return PRIVACY_DEVICE_MAC;
+ if (mWifiConfig != null) {
+ switch(mWifiConfig.macRandomizationSetting) {
+ case WifiConfiguration.RANDOMIZATION_NONE:
+ return PRIVACY_DEVICE_MAC;
+ case WifiConfiguration.RANDOMIZATION_PERSISTENT:
+ return PRIVACY_RANDOMIZED_MAC;
+ case WifiConfiguration.RANDOMIZATION_ALWAYS:
+ return PRIVACY_FULLY_RANDOMIZED_MAC;
+ default:
+ return PRIVACY_FULLY_RANDOMIZED_MAC;
+ }
} else {
- return PRIVACY_RANDOMIZED_MAC;
+ return PRIVACY_FULLY_RANDOMIZED_MAC;
}
}
@@ -591,9 +599,7 @@ public class StandardWifiEntry extends WifiEntry {
if (!canSetPrivacy()) {
return;
}
-
- mWifiConfig.macRandomizationSetting = privacy == PRIVACY_RANDOMIZED_MAC
- ? WifiConfiguration.RANDOMIZATION_PERSISTENT : WifiConfiguration.RANDOMIZATION_NONE;
+ mWifiConfig.macRandomizationSetting = translatePrivacyToWifiConfigurationValues(privacy);
mWifiManager.save(mWifiConfig, null /* listener */);
}
@@ -929,4 +935,16 @@ public class StandardWifiEntry extends WifiEntry {
String getNetworkSelectionDescription() {
return Utils.getNetworkSelectionDescription(getWifiConfiguration());
}
+
+ private static int translatePrivacyToWifiConfigurationValues(int privacy_value) {
+ switch(privacy_value) {
+ case PRIVACY_FULLY_RANDOMIZED_MAC:
+ return WifiConfiguration.RANDOMIZATION_ALWAYS;
+ case PRIVACY_RANDOMIZED_MAC:
+ return WifiConfiguration.RANDOMIZATION_PERSISTENT;
+ case PRIVACY_DEVICE_MAC:
+ return WifiConfiguration.RANDOMIZATION_NONE;
+ }
+ return WifiConfiguration.RANDOMIZATION_ALWAYS;
+ }
}
diff --git a/libs/WifiTrackerLib/src/com/android/wifitrackerlib/WifiEntry.java b/libs/WifiTrackerLib/src/com/android/wifitrackerlib/WifiEntry.java
index 92c2ed531..3cd333fd3 100644
--- a/libs/WifiTrackerLib/src/com/android/wifitrackerlib/WifiEntry.java
+++ b/libs/WifiTrackerLib/src/com/android/wifitrackerlib/WifiEntry.java
@@ -149,6 +149,7 @@ public abstract class WifiEntry implements Comparable<WifiEntry> {
public static final int PRIVACY_DEVICE_MAC = 0;
public static final int PRIVACY_RANDOMIZED_MAC = 1;
public static final int PRIVACY_UNKNOWN = 2;
+ public static final int PRIVACY_FULLY_RANDOMIZED_MAC = 100;
@Retention(RetentionPolicy.SOURCE)
@IntDef(value = {
diff --git a/service/java/com/android/server/wifi/ClientModeImpl.java b/service/java/com/android/server/wifi/ClientModeImpl.java
index 14866c87e..8db407fa3 100644
--- a/service/java/com/android/server/wifi/ClientModeImpl.java
+++ b/service/java/com/android/server/wifi/ClientModeImpl.java
@@ -6452,7 +6452,8 @@ public class ClientModeImpl extends StateMachine {
}
if (isConnectedMacRandomizationEnabled()) {
- if (config.macRandomizationSetting == WifiConfiguration.RANDOMIZATION_PERSISTENT) {
+ if (config.macRandomizationSetting == WifiConfiguration.RANDOMIZATION_PERSISTENT ||
+ config.macRandomizationSetting == WifiConfiguration.RANDOMIZATION_ALWAYS) {
configureRandomizedMacAddress(config);
} else {
setCurrentMacToFactoryMac(config);
@@ -6489,7 +6490,7 @@ public class ClientModeImpl extends StateMachine {
(config.getIpAssignment() == IpConfiguration.IpAssignment.STATIC);
final boolean isUsingMacRandomization =
config.macRandomizationSetting
- == WifiConfiguration.RANDOMIZATION_PERSISTENT
+ != WifiConfiguration.RANDOMIZATION_NONE
&& isConnectedMacRandomizationEnabled();
if (mVerboseLoggingEnabled) {
final String key = config.getKey();
diff --git a/service/java/com/android/server/wifi/WifiConfigManager.java b/service/java/com/android/server/wifi/WifiConfigManager.java
index 8fc91cb09..25304cca4 100644
--- a/service/java/com/android/server/wifi/WifiConfigManager.java
+++ b/service/java/com/android/server/wifi/WifiConfigManager.java
@@ -425,9 +425,14 @@ public class WifiConfigManager {
*/
public boolean shouldUseAggressiveRandomization(WifiConfiguration config) {
if (!isMacRandomizationSupported()
- || config.macRandomizationSetting != WifiConfiguration.RANDOMIZATION_PERSISTENT) {
+ || config.macRandomizationSetting < WifiConfiguration.RANDOMIZATION_PERSISTENT) {
return false;
}
+
+ if (config.macRandomizationSetting == WifiConfiguration.RANDOMIZATION_ALWAYS) {
+ return true;
+ }
+
if (mFrameworkFacade.getIntegerSetting(mContext,
ENHANCED_MAC_RANDOMIZATION_FEATURE_FORCE_ENABLE_FLAG, 0) == 1) {
return true;
@@ -546,7 +551,9 @@ public class WifiConfigManager {
*/
private MacAddress updateRandomizedMacIfNeeded(WifiConfiguration config) {
boolean shouldUpdateMac = config.randomizedMacExpirationTimeMs
- < mClock.getWallClockMillis();
+ < mClock.getWallClockMillis() ||
+ config.macRandomizationSetting == WifiConfiguration.RANDOMIZATION_ALWAYS;
+
if (!shouldUpdateMac) {
return config.getRandomizedMacAddress();
}
@@ -1579,7 +1586,7 @@ public class WifiConfigManager {
public boolean isInFlakyRandomizationSsidHotlist(int networkId) {
WifiConfiguration config = getConfiguredNetwork(networkId);
return config != null
- && config.macRandomizationSetting == WifiConfiguration.RANDOMIZATION_PERSISTENT
+ && config.macRandomizationSetting != WifiConfiguration.RANDOMIZATION_NONE
&& mDeviceConfigFacade.getRandomizationFlakySsidHotlist().contains(config.SSID);
}
diff --git a/service/java/com/android/server/wifi/WifiConfigurationUtil.java b/service/java/com/android/server/wifi/WifiConfigurationUtil.java
index 336d97810..9c3e074ae 100644
--- a/service/java/com/android/server/wifi/WifiConfigurationUtil.java
+++ b/service/java/com/android/server/wifi/WifiConfigurationUtil.java
@@ -203,7 +203,7 @@ public class WifiConfigurationUtil {
public static boolean hasMacRandomizationSettingsChanged(WifiConfiguration existingConfig,
WifiConfiguration newConfig) {
if (existingConfig == null) {
- return newConfig.macRandomizationSetting != WifiConfiguration.RANDOMIZATION_PERSISTENT;
+ return newConfig.macRandomizationSetting != WifiConfiguration.RANDOMIZATION_ALWAYS;
}
return newConfig.macRandomizationSetting != existingConfig.macRandomizationSetting;
}
diff --git a/service/java/com/android/server/wifi/WifiMetrics.java b/service/java/com/android/server/wifi/WifiMetrics.java
index 75d53fc95..4ef2e5f8e 100644
--- a/service/java/com/android/server/wifi/WifiMetrics.java
+++ b/service/java/com/android/server/wifi/WifiMetrics.java
@@ -1556,7 +1556,7 @@ public class WifiMetrics {
if (config != null) {
mCurrentConnectionEvent.mConnectionEvent.useRandomizedMac =
config.macRandomizationSetting
- == WifiConfiguration.RANDOMIZATION_PERSISTENT;
+ != WifiConfiguration.RANDOMIZATION_NONE;
mCurrentConnectionEvent.mConnectionEvent.useAggressiveMac =
mWifiConfigManager.shouldUseAggressiveRandomization(config);
mCurrentConnectionEvent.mConnectionEvent.connectionNominator =
@@ -3958,7 +3958,7 @@ public class WifiMetrics {
if (config.isPasspoint()) {
mWifiLogProto.numPasspointNetworks++;
}
- if (config.macRandomizationSetting == WifiConfiguration.RANDOMIZATION_PERSISTENT) {
+ if (config.macRandomizationSetting != WifiConfiguration.RANDOMIZATION_NONE) {
mWifiLogProto.numSavedNetworksWithMacRandomization++;
}
}

193
Patches/LineageOS-18.1/android_packages_apps_Settings/0011-Random_MAC-1.patch Normal file
View file

@ -0,0 +1,193 @@
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Renlord <me@renlord.com>
Date: Sun, 8 Dec 2019 23:58:24 +0100
Subject: [PATCH] add option to always randomize MAC
RANDOMIZATION_ALWAYS is set as the default option
---
res/values/arrays.xml | 4 ++-
.../WifiDetailPreferenceController.java | 5 +--
.../WifiPrivacyPreferenceController.java | 31 ++++++++++++++-----
.../WifiDetailPreferenceController2.java | 2 +-
.../WifiPrivacyPreferenceController2.java | 31 +++++++++++++++----
5 files changed, 56 insertions(+), 17 deletions(-)
diff --git a/res/values/arrays.xml b/res/values/arrays.xml
index 6259f4d1a5..e93794e955 100644
--- a/res/values/arrays.xml
+++ b/res/values/arrays.xml
@@ -1332,7 +1332,8 @@
</string-array>
<string-array name="wifi_privacy_entries">
- <item>Use randomized MAC (default)</item>
+ <item>Use fully randomized MAC (default)</item>
+ <item>Use per-network randomized MAC</item>
<item>Use device MAC</item>
</string-array>
@@ -1348,6 +1349,7 @@
</string-array>
<string-array name="wifi_privacy_values" translatable="false">
+ <item>100</item>
<item>1</item>
<item>0</item>
</string-array>
diff --git a/src/com/android/settings/wifi/details/WifiDetailPreferenceController.java b/src/com/android/settings/wifi/details/WifiDetailPreferenceController.java
index 8dd8d7ad6a..d900bc6a27 100644
--- a/src/com/android/settings/wifi/details/WifiDetailPreferenceController.java
+++ b/src/com/android/settings/wifi/details/WifiDetailPreferenceController.java
@@ -822,7 +822,8 @@ public class WifiDetailPreferenceController extends AbstractPreferenceController
// return randomized MAC address
if (mWifiConfig != null &&
- mWifiConfig.macRandomizationSetting == WifiConfiguration.RANDOMIZATION_PERSISTENT) {
+ (mWifiConfig.macRandomizationSetting == WifiConfiguration.RANDOMIZATION_PERSISTENT
+ || mWifiConfig.macRandomizationSetting == WifiConfiguration.RANDOMIZATION_ALWAYS)) {
return mWifiConfig.getRandomizedMacAddress().toString();
}
@@ -1288,7 +1289,7 @@ public class WifiDetailPreferenceController extends AbstractPreferenceController
mMacAddressPref.setTitle(
(mWifiConfig.macRandomizationSetting
- == WifiConfiguration.RANDOMIZATION_PERSISTENT)
+ != WifiConfiguration.RANDOMIZATION_NONE)
? R.string.wifi_advanced_randomized_mac_address_title
: R.string.wifi_advanced_device_mac_address_title);
diff --git a/src/com/android/settings/wifi/details/WifiPrivacyPreferenceController.java b/src/com/android/settings/wifi/details/WifiPrivacyPreferenceController.java
index 6658411479..2266805808 100644
--- a/src/com/android/settings/wifi/details/WifiPrivacyPreferenceController.java
+++ b/src/com/android/settings/wifi/details/WifiPrivacyPreferenceController.java
@@ -115,11 +115,12 @@ public class WifiPrivacyPreferenceController extends BasePreferenceController im
if (mWifiConfiguration != null) {
return mWifiConfiguration.macRandomizationSetting;
}
- return WifiConfiguration.RANDOMIZATION_PERSISTENT;
+ return WifiConfiguration.RANDOMIZATION_ALWAYS;
}
- private static final int PREF_RANDOMIZATION_PERSISTENT = 0;
- private static final int PREF_RANDOMIZATION_NONE = 1;
+ private static final int PREF_RANDOMIZATION_ALWAYS = 0;
+ private static final int PREF_RANDOMIZATION_PERSISTENT = 1;
+ private static final int PREF_RANDOMIZATION_NONE = 2;
/**
* Returns preference index value.
@@ -128,8 +129,16 @@ public class WifiPrivacyPreferenceController extends BasePreferenceController im
* @return index value of preference
*/
public static int translateMacRandomizedValueToPrefValue(int macRandomized) {
- return (macRandomized == WifiConfiguration.RANDOMIZATION_PERSISTENT)
- ? PREF_RANDOMIZATION_PERSISTENT : PREF_RANDOMIZATION_NONE;
+ switch (macRandomized) {
+ case WifiConfiguration.RANDOMIZATION_ALWAYS:
+ return PREF_RANDOMIZATION_ALWAYS;
+ case WifiConfiguration.RANDOMIZATION_PERSISTENT:
+ return PREF_RANDOMIZATION_PERSISTENT;
+ case WifiConfiguration.RANDOMIZATION_NONE:
+ return PREF_RANDOMIZATION_NONE;
+ default:
+ return PREF_RANDOMIZATION_ALWAYS;
+ }
}
/**
@@ -139,8 +148,16 @@ public class WifiPrivacyPreferenceController extends BasePreferenceController im
* @return mac randomized value
*/
public static int translatePrefValueToMacRandomizedValue(int prefMacRandomized) {
- return (prefMacRandomized == PREF_RANDOMIZATION_PERSISTENT)
- ? WifiConfiguration.RANDOMIZATION_PERSISTENT : WifiConfiguration.RANDOMIZATION_NONE;
+ switch (prefMacRandomized) {
+ case PREF_RANDOMIZATION_ALWAYS:
+ return WifiConfiguration.RANDOMIZATION_ALWAYS;
+ case PREF_RANDOMIZATION_PERSISTENT:
+ return WifiConfiguration.RANDOMIZATION_PERSISTENT;
+ case PREF_RANDOMIZATION_NONE:
+ return WifiConfiguration.RANDOMIZATION_NONE;
+ default:
+ return WifiConfiguration.RANDOMIZATION_ALWAYS;
+ }
}
private void updateSummary(DropDownPreference preference, int macRandomized) {
diff --git a/src/com/android/settings/wifi/details2/WifiDetailPreferenceController2.java b/src/com/android/settings/wifi/details2/WifiDetailPreferenceController2.java
index 9b305777fd..f04bbcd38f 100644
--- a/src/com/android/settings/wifi/details2/WifiDetailPreferenceController2.java
+++ b/src/com/android/settings/wifi/details2/WifiDetailPreferenceController2.java
@@ -749,7 +749,7 @@ public class WifiDetailPreferenceController2 extends AbstractPreferenceControlle
mMacAddressPref.setVisible(true);
- mMacAddressPref.setTitle((mWifiEntry.getPrivacy() == WifiEntry.PRIVACY_RANDOMIZED_MAC)
+ mMacAddressPref.setTitle((mWifiEntry.getPrivacy() != WifiEntry.PRIVACY_DEVICE_MAC)
? R.string.wifi_advanced_randomized_mac_address_title
: R.string.wifi_advanced_device_mac_address_title);
diff --git a/src/com/android/settings/wifi/details2/WifiPrivacyPreferenceController2.java b/src/com/android/settings/wifi/details2/WifiPrivacyPreferenceController2.java
index d6e1b6054d..ab51c59e1a 100644
--- a/src/com/android/settings/wifi/details2/WifiPrivacyPreferenceController2.java
+++ b/src/com/android/settings/wifi/details2/WifiPrivacyPreferenceController2.java
@@ -100,8 +100,9 @@ public class WifiPrivacyPreferenceController2 extends BasePreferenceController i
return mWifiEntry.getPrivacy();
}
- private static final int PREF_RANDOMIZATION_PERSISTENT = 0;
- private static final int PREF_RANDOMIZATION_NONE = 1;
+ private static final int PREF_RANDOMIZATION_ALWAYS = 0;
+ private static final int PREF_RANDOMIZATION_PERSISTENT = 1;
+ private static final int PREF_RANDOMIZATION_NONE = 2;
/**
* Returns preference index value.
@@ -110,8 +111,16 @@ public class WifiPrivacyPreferenceController2 extends BasePreferenceController i
* @return index value of preference
*/
public static int translateMacRandomizedValueToPrefValue(int macRandomized) {
- return (macRandomized == WifiEntry.PRIVACY_RANDOMIZED_MAC)
- ? PREF_RANDOMIZATION_PERSISTENT : PREF_RANDOMIZATION_NONE;
+ switch (macRandomized) {
+ case WifiConfiguration.RANDOMIZATION_ALWAYS:
+ return PREF_RANDOMIZATION_ALWAYS;
+ case WifiConfiguration.RANDOMIZATION_PERSISTENT:
+ return PREF_RANDOMIZATION_PERSISTENT;
+ case WifiConfiguration.RANDOMIZATION_NONE:
+ return PREF_RANDOMIZATION_NONE;
+ default:
+ return PREF_RANDOMIZATION_ALWAYS;
+ }
}
/**
@@ -121,8 +130,16 @@ public class WifiPrivacyPreferenceController2 extends BasePreferenceController i
* @return mac randomized value
*/
public static int translatePrefValueToMacRandomizedValue(int prefMacRandomized) {
- return (prefMacRandomized == PREF_RANDOMIZATION_PERSISTENT)
- ? WifiEntry.PRIVACY_RANDOMIZED_MAC : WifiEntry.PRIVACY_DEVICE_MAC;
+ switch (prefMacRandomized) {
+ case PREF_RANDOMIZATION_ALWAYS:
+ return WifiConfiguration.RANDOMIZATION_ALWAYS;
+ case PREF_RANDOMIZATION_PERSISTENT:
+ return WifiConfiguration.RANDOMIZATION_PERSISTENT;
+ case PREF_RANDOMIZATION_NONE:
+ return WifiConfiguration.RANDOMIZATION_NONE;
+ default:
+ return WifiConfiguration.RANDOMIZATION_ALWAYS;
+ }
}
private void updateSummary(DropDownPreference preference, int macRandomized) {
@@ -152,6 +169,8 @@ public class WifiPrivacyPreferenceController2 extends BasePreferenceController i
return WifiEntry.PRIVACY_DEVICE_MAC;
case WifiConfiguration.RANDOMIZATION_PERSISTENT:
return WifiEntry.PRIVACY_RANDOMIZED_MAC;
+ case WifiConfiguration.RANDOMIZATION_ALWAYS:
+ return WifiEntry.PRIVACY_FULLY_RANDOMIZED_MAC;
default:
return WifiEntry.PRIVACY_UNKNOWN;
}

1368
Patches/LineageOS-18.1/android_packages_apps_Settings/0011-Random_MAC-2.patch Normal file
View file

File diff suppressed because it is too large Load diff

71
Patches/LineageOS-18.1/android_packages_modules_NetworkStack/0001-Random_MAC.patch Normal file
View file

@ -0,0 +1,71 @@
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Pratyush <39559233+empratyush@users.noreply.github.com>
Date: Thu, 20 May 2021 13:21:31 +0530
Subject: [PATCH] avoid reusing DHCP state for full MAC randomization
---
src/android/net/dhcp/DhcpClient.java | 30 +++++++++++++++++++++++++++-
1 file changed, 29 insertions(+), 1 deletion(-)
diff --git a/src/android/net/dhcp/DhcpClient.java b/src/android/net/dhcp/DhcpClient.java
index 4fedf308..5b613a2a 100644
--- a/src/android/net/dhcp/DhcpClient.java
+++ b/src/android/net/dhcp/DhcpClient.java
@@ -74,6 +74,9 @@ import android.net.util.InterfaceParams;
import android.net.util.NetworkStackUtils;
import android.net.util.PacketReader;
import android.net.util.SocketUtils;
+import android.net.wifi.WifiConfiguration;
+import android.net.wifi.WifiInfo;
+import android.net.wifi.WifiManager;
import android.os.Build;
import android.os.Handler;
import android.os.Message;
@@ -111,6 +114,8 @@ import java.net.SocketAddress;
import java.net.SocketException;
import java.nio.ByteBuffer;
import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.List;
import java.util.Random;
/**
@@ -1198,7 +1203,7 @@ public class DhcpClient extends StateMachine {
+ " lease expiry: " + attributes.assignedV4AddressExpiry
+ " current time: " + currentTime);
}
- if (currentTime >= attributes.assignedV4AddressExpiry) {
+ if (currentTime >= attributes.assignedV4AddressExpiry || shouldAvoidStateReuse()) {
// Lease has expired.
transitionTo(mDhcpInitState);
return HANDLED;
@@ -1223,6 +1228,29 @@ public class DhcpClient extends StateMachine {
}
}
+ private static final int RANDOMIZATION_ALWAYS = 100;
+
+ private boolean shouldAvoidStateReuse() {
+ try {
+ WifiManager wifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);
+ WifiInfo wifiInfo = wifiManager.getConnectionInfo();
+ if (wifiInfo != null) {
+ int connectedNetworkId = wifiInfo.getNetworkId();
+ List<WifiConfiguration> configurationList = wifiManager.getConfiguredNetworks();
+ for (WifiConfiguration configuration : configurationList){
+ if (configuration.networkId == connectedNetworkId){
+ return configuration.macRandomizationSetting == RANDOMIZATION_ALWAYS;
+ }
+ }
+ }
+ } catch (Exception e) {
+ loge(e.getLocalizedMessage(), e);
+ }
+
+ loge("ConfiguredNetworks should contain Connected network id config");
+ return true;
+ }
+
private void receiveOfferOrAckPacket(final DhcpPacket packet, final boolean acceptRapidCommit) {
if (!isValidPacket(packet)) return;