ModifierModule/app/src/main/java/com/example/modifiermodule/HookSystem.java

package com.example.modifiermodule;

import android.content.AttributionSource;
import android.content.Context;
import android.content.SharedPreferences;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;

import org.apache.commons.lang3.StringUtils;

import java.io.File;

import de.robv.android.xposed.XC_MethodHook;
import de.robv.android.xposed.XposedHelpers;
import de.robv.android.xposed.callbacks.XC_LoadPackage;

public class HookSystem extends BaseHook {

    public HookSystem(ClassLoader classLoader) {
        super(classLoader);
    }

    public void handleLoadPackage(XC_LoadPackage.LoadPackageParam lpparam) throws Throwable {
        try {
            setConfigFile(new File("/data/system/config.json"));
        } catch (Exception e) {
            e.printStackTrace();
            log("setConfigFile fail");
        }
        try {
            Class<?> DeviceIdentifiersPolicy = XposedHelpers.findClass("com.android.server.os.DeviceIdentifiersPolicyService$DeviceIdentifiersPolicy", lpparam.classLoader);
            XposedHelpers.findAndHookMethod(DeviceIdentifiersPolicy, "getSerial", new XC_MethodHook() {
                @Override
                protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                    String serial = getProperty(PROP_SERIAL, "");
                    log(String.format("getSerial(): %s -> %s", param.getResult(), serial));
                    param.setResult(serial);
                }
            });
            XposedHelpers.findAndHookMethod(DeviceIdentifiersPolicy, "getSerialForPackage", String.class, String.class, new XC_MethodHook() {
                @Override
                protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                    String serial = getProperty(PROP_SERIAL, "");
                    log(String.format("getSerialForPackage(%s, %s): %s -> %s", param.args[0], param.args[1], param.getResult(), serial));
                    param.setResult(serial);
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }

        try {
            Class<?> SystemServiceManager = XposedHelpers.findClass("com.android.server.SystemServiceManager", lpparam.classLoader);
            XposedHelpers.findAndHookMethod(SystemServiceManager, "loadClassFromLoader", String.class, ClassLoader.class, new XC_MethodHook() {
                @Override
                protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                    if (param.hasThrowable()) return;
                    Class<?> cls = (Class<?>) param.getResult();
                    String name = cls.getName();
                    log(String.format("loadClassFromLoader(%s, %s)", param.args[0], param.args[1]));

                    if (name.equals("com.android.server.wifi.WifiService")) {
                        ClassLoader classLoader = (ClassLoader) param.args[1];
                        Class<?> WifiServiceImpl = XposedHelpers.findClass("com.android.server.wifi.WifiServiceImpl", classLoader);
                        XposedHelpers.findAndHookMethod(WifiServiceImpl, "getFactoryMacAddresses", new XC_MethodHook() {
                            @Override
                            protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                                String[] old = (String[]) param.getResult();
                                String[] macs = new String[]{getProperty(PROP_WIFI_MAC, "")};
                                if (old == null) {
                                    log(String.format("getFactoryMacAddresses(): null -> %s", param.getResult(), macs[0]));
                                } else {
                                    log(String.format("getFactoryMacAddresses(): %s -> %s", StringUtils.join(old, ","), macs[0]));
                                }
                                param.setResult(macs);
                            }
                        });

                        XposedHelpers.findAndHookMethod(WifiServiceImpl, "getConnectionInfo", String.class, String.class, new XC_MethodHook() {
                            @Override
                            protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                                String mac = getProperty(PROP_WIFI_MAC, "");
                                String bssid = getProperty(PROP_BSSID, "");
                                log(String.format("getConnectionInfo(%s, %s)", param.args[0], param.args[1]));
                                log(String.format("  mac: %s -> %s", XposedHelpers.getObjectField(param.getResult(), "mMacAddress"), mac));
                                log(String.format("  bssid: %s -> %s", XposedHelpers.getObjectField(param.getResult(), "mBSSID"), bssid));
                                XposedHelpers.setObjectField(param.getResult(), "mMacAddress", mac);
                                XposedHelpers.setObjectField(param.getResult(), "mBSSID", bssid);
                            }
                        });
                    } else if (name.equals("com.android.server.bluetooth.BluetoothService")) {
                        ClassLoader classLoader = (ClassLoader) param.args[1];
                        Class<?> BluetoothManagerService = XposedHelpers.findClass("com.android.server.bluetooth.BluetoothManagerService", classLoader);
                        XposedHelpers.findAndHookMethod(BluetoothManagerService, "getAddress", new XC_MethodHook() {
                            @Override
                            protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                                AttributionSource attributionSource = (AttributionSource) param.args[0];
                                String packageName = attributionSource.getPackageName();
                                String mac = getProperty(PROP_BT_MAC, (String) param.getResult());
                                log(String.format("getAddress(%s): %s -> %s", packageName, param.getResult(), mac));
                                param.setResult(mac);
                            }
                        });

                    } else if (name.equals("com.android.server.ConnectivityServiceInitializer")) {
                        ClassLoader classLoader = (ClassLoader) param.args[1];
                        Class<?> ConnectivityService = XposedHelpers.findClass("com.android.server.ConnectivityService", classLoader);
                        XposedHelpers.findAndHookMethod(ConnectivityService, "getNetworkInfo", int.class, new XC_MethodHook() {
                            @Override
                            protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                                int networkType = (int) param.args[0];
                                log(String.format("getNetworkInfo(%d)", networkType));
                                if (networkType == ConnectivityManager.TYPE_ETHERNET && param.getResult() != null) {
                                    NetworkInfo networkInfo = (NetworkInfo) param.getResult();
                                    String mac = getProperty(PROP_ETH_MAC, networkInfo.getExtraInfo());
                                    log(String.format("  .extra: %s -> %s", networkInfo.getExtraInfo(), mac));
                                    XposedHelpers.setObjectField(networkInfo, "mExtraInfo", mac);
                                }
                            }
                        });
                    }
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
            log("SystemProperties not found");
        }
    }


}