feat: support transparent mock in system_server without hooking QQ and enhance Tencent Geolocation SDK

This commit is contained in:
LZX committed 2026-10-20 19:32:54 +08:00
1 parent b21966e5b5
commit a341d862c2
5 files changed
+735 -130

No files matched your search

@@ -83,21 +83,26 @@ class HookEntry : IXposedHookLoadPackage {
try { try {
val contextProvider = { appContext } val contextProvider = { appContext }
val pkg = lpparam.packageName
XposedHelpers.findAndHookMethod( XposedHelpers.findAndHookMethod(
Application::class.java, Application::class.java,
"attach", "attach",
Context::class.java, Context::class.java,
object : XC_MethodHook() { object : XC_MethodHook() {
override fun afterHookedMethod(param: MethodHookParam) { override fun afterHookedMethod(param: MethodHookParam) {
if (appContext == null) { val ctx = param.args[0] as? Context
appContext = param.args[0] as? Context if (appContext == null && ctx != null) {
appContext = ctx
} }
// 在 Application.attach 完成后,针对动态加载 Multidex/插件环境二次加固第三方定位 SDK
val appClassLoader = ctx?.classLoader ?: lpparam.classLoader
ThirdPartyNlpHook.hook(appClassLoader, pkg, contextProvider)
} }
} }
) )
// 全新多层防穿透管道(显式传递绝对已知的应用包名,第 0 毫秒即就绪) // 全新多层防穿透管道(显式传递绝对已知的应用包名,第 0 毫秒即就绪)
val pkg = lpparam.packageName
LocationHook.hook(lpparam.classLoader, pkg, contextProvider) LocationHook.hook(lpparam.classLoader, pkg, contextProvider)
ThirdPartyNlpHook.hook(lpparam.classLoader, pkg, contextProvider) ThirdPartyNlpHook.hook(lpparam.classLoader, pkg, contextProvider)
NetworkLocationHook.hook(lpparam.classLoader, pkg, contextProvider) NetworkLocationHook.hook(lpparam.classLoader, pkg, contextProvider)
@@ -2,112 +2,606 @@ package com.lzxnone.openloc.hook.client
import android.content.Context import android.content.Context
import android.location.Location import android.location.Location
import android.os.Bundle
import android.os.SystemClock
import com.lzxnone.openloc.core.util.TraceLogger import com.lzxnone.openloc.core.util.TraceLogger
import com.lzxnone.openloc.hook.model.GlobalMockMemory import com.lzxnone.openloc.hook.model.GlobalMockMemory
import de.robv.android.xposed.XC_MethodHook import de.robv.android.xposed.XC_MethodHook
import de.robv.android.xposed.XposedBridge import de.robv.android.xposed.XposedBridge
import de.robv.android.xposed.XposedHelpers import de.robv.android.xposed.XposedHelpers
import java.lang.reflect.InvocationHandler
import java.lang.reflect.Method
import java.lang.reflect.Proxy
import java.util.Collections
import java.util.WeakHashMap
/** /**
* 国内三大巨头自研底层 NLP(网络定位提供商)安全拦截器 * 国内三大巨头自研底层 NLP 与商用定位 SDK 深度防御拦截器
* (严格遵循 GhostMapX LJo 规范:绝不粗暴阻断状态机方法,避免引发“位置获取失败”) * 核心覆盖:
* 1. 腾讯定位 SDK (com.tencent.map.geolocation.*):全面拦截 TencentLocationManager、TencentLocationListener 与动态代理 TencentLocation;
* 2. QQ 专有 LBS 接口 (com.tencent.mobileqq.soso.location.*):动态防御 SosoLocation 结构;
* 3. 百度定位 SDK (com.baidu.location.*):深度挂钩 BDLocation 核心属性与 LocationClient 回调;
* 4. 高德定位 SDK (com.amap.api.location.* / NetworkLocationManager):全链路防护 AMapLocation;
* 严格遵循 GhostMapX 规范:绝不抛出异常破坏状态机,返回真实结构成功响应。
*/ */
object ThirdPartyNlpHook { object ThirdPartyNlpHook {
private val tencentListenerProxyMap = Collections.synchronizedMap(WeakHashMap<Any, Any>())
fun hook(classLoader: ClassLoader, packageName: String, contextProvider: () -> Context?) { fun hook(classLoader: ClassLoader, packageName: String, contextProvider: () -> Context?) {
if (packageName == "com.lzxnone.openloc") return if (packageName == "com.lzxnone.openloc") return
hookTencentNLP(classLoader, packageName) hookTencentLocationSDK(classLoader, packageName)
hookBaiduNLP(classLoader, packageName) hookBaiduLocationSDK(classLoader, packageName)
hookAmapNLP(classLoader, packageName) hookAmapLocationSDK(classLoader, packageName)
} }
/** // ====================================================================================
* 1. 腾讯定位 SDK:仅拦截返回 Location 的方法,绝不破坏 init / isAvailable 等状态机 // 1. 腾讯定位 SDK (TencentLocationManager / TencentLocationListener / SosoInterface)
*/ // ====================================================================================
private fun hookTencentNLP(classLoader: ClassLoader, packageName: String) {
val nlpClass = try { private fun hookTencentLocationSDK(classLoader: ClassLoader, packageName: String) {
// (1) 现代腾讯定位 SDK:com.tencent.map.geolocation.TencentLocationManager
val tencentManagerClass = try {
XposedHelpers.findClass("com.tencent.map.geolocation.TencentLocationManager", classLoader)
} catch (_: Throwable) {
null
}
if (tencentManagerClass != null) {
TraceLogger.i("ThirdPartyNLP", "[$packageName] Detected modern TencentLocationManager, arming Tencent hooks...")
for (method in tencentManagerClass.declaredMethods) {
when (method.name) {
"requestLocationUpdates", "requestSingleFreshLocation" -> {
try {
XposedBridge.hookMethod(method, object : XC_MethodHook() {
override fun beforeHookedMethod(param: MethodHookParam) {
if (!GlobalMockMemory.isEnabled || !GlobalMockMemory.shouldMock(packageName)) return
wrapTencentListenerArgs(param.args, classLoader, packageName)
}
})
} catch (_: Throwable) {}
}
"removeUpdates" -> {
try {
XposedBridge.hookMethod(method, object : XC_MethodHook() {
override fun beforeHookedMethod(param: MethodHookParam) {
val originalListener = param.args.getOrNull(0) ?: return
val proxy = tencentListenerProxyMap[originalListener]
if (proxy != null) {
param.args[0] = proxy
}
}
})
} catch (_: Throwable) {}
}
"getLastKnownLocation" -> {
try {
XposedBridge.hookMethod(method, object : XC_MethodHook() {
override fun afterHookedMethod(param: MethodHookParam) {
if (!GlobalMockMemory.isEnabled || !GlobalMockMemory.shouldMock(packageName)) return
val mockLoc = createMockTencentLocation(classLoader)
if (mockLoc != null) {
TraceLogger.w("ThirdPartyNLP", "[$packageName] TencentLocationManager.getLastKnownLocation -> SPOOFED")
param.result = mockLoc
}
}
})
} catch (_: Throwable) {}
}
}
}
}
// (2) 兼容旧版腾讯 NLP:com.tencent.geolocation.nlp.TencentNLPManager
val oldNlpClass = try {
XposedHelpers.findClass("com.tencent.geolocation.nlp.TencentNLPManager", classLoader) XposedHelpers.findClass("com.tencent.geolocation.nlp.TencentNLPManager", classLoader)
} catch (_: Throwable) { } catch (_: Throwable) {
null null
} ?: return }
if (oldNlpClass != null) {
for (method in oldNlpClass.declaredMethods) {
if (method.returnType == Location::class.java) {
try {
XposedBridge.hookMethod(method, object : XC_MethodHook() {
override fun afterHookedMethod(param: MethodHookParam) {
if (!GlobalMockMemory.isEnabled || !GlobalMockMemory.shouldMock(packageName)) return
val mockLoc = GlobalMockMemory.createLocation("network")
param.result = mockLoc
TraceLogger.w("ThirdPartyNLP", "[$packageName] TencentNLP.${method.name} -> REPLACED")
}
})
} catch (_: Throwable) {}
}
}
}
for (method in nlpClass.declaredMethods) { // (3) QQ 内部专有 SosoLocation 结构拦截
if (method.returnType == Location::class.java) { val sosoLocationClasses = listOf(
try { "com.tencent.mobileqq.soso.location.data.SosoLocation",
XposedBridge.hookMethod(method, object : XC_MethodHook() { "com.tencent.mobileqq.app.soso.SosoInterface\$SosoLocation"
override fun afterHookedMethod(param: MethodHookParam) { )
val shouldMock = GlobalMockMemory.isEnabled && GlobalMockMemory.shouldMock(packageName) for (className in sosoLocationClasses) {
val originalLoc = param.result as? Location val sosoClass = try {
TraceLogger.d("ThirdPartyNLP", "[$packageName] TencentNLP.${method.name}: incoming=${TraceLogger.formatLocation(originalLoc)}, shouldMock=$shouldMock") XposedHelpers.findClass(className, classLoader)
} catch (_: Throwable) {
null
} ?: continue
if (!shouldMock) return TraceLogger.i("ThirdPartyNLP", "[$packageName] Detected MobileQQ $className, arming SosoLocation hooks...")
val mockLoc = GlobalMockMemory.createLocation(originalLoc?.provider ?: "network") for (method in sosoClass.declaredMethods) {
param.result = mockLoc when (method.name) {
TraceLogger.w("ThirdPartyNLP", "[$packageName] TencentNLP.${method.name}: REPLACED with ${TraceLogger.formatLocation(mockLoc)}") "getLatitude", "getLat02", "getLat84" -> {
} try {
}) XposedBridge.hookMethod(method, object : XC_MethodHook() {
} catch (_: Throwable) {} override fun afterHookedMethod(param: MethodHookParam) {
if (GlobalMockMemory.isEnabled && GlobalMockMemory.shouldMock(packageName)) {
param.result = GlobalMockMemory.latitude
}
}
})
} catch (_: Throwable) {}
}
"getLongitude", "getLon02", "getLon84" -> {
try {
XposedBridge.hookMethod(method, object : XC_MethodHook() {
override fun afterHookedMethod(param: MethodHookParam) {
if (GlobalMockMemory.isEnabled && GlobalMockMemory.shouldMock(packageName)) {
param.result = GlobalMockMemory.longitude
}
}
})
} catch (_: Throwable) {}
}
"getAltitude" -> {
try {
XposedBridge.hookMethod(method, object : XC_MethodHook() {
override fun afterHookedMethod(param: MethodHookParam) {
if (GlobalMockMemory.isEnabled && GlobalMockMemory.shouldMock(packageName)) {
param.result = GlobalMockMemory.altitude
}
}
})
} catch (_: Throwable) {}
}
"getAccuracy" -> {
try {
XposedBridge.hookMethod(method, object : XC_MethodHook() {
override fun afterHookedMethod(param: MethodHookParam) {
if (GlobalMockMemory.isEnabled && GlobalMockMemory.shouldMock(packageName)) {
param.result = GlobalMockMemory.accuracy
}
}
})
} catch (_: Throwable) {}
}
"getSpeed" -> {
try {
XposedBridge.hookMethod(method, object : XC_MethodHook() {
override fun afterHookedMethod(param: MethodHookParam) {
if (GlobalMockMemory.isEnabled && GlobalMockMemory.shouldMock(packageName)) {
param.result = GlobalMockMemory.speed
}
}
})
} catch (_: Throwable) {}
}
"getAddress", "getName" -> {
try {
XposedBridge.hookMethod(method, object : XC_MethodHook() {
override fun afterHookedMethod(param: MethodHookParam) {
if (GlobalMockMemory.isEnabled && GlobalMockMemory.shouldMock(packageName)) {
val locName = GlobalMockMemory.locationName
if (locName.isNotEmpty()) {
param.result = locName
}
}
}
})
} catch (_: Throwable) {}
}
}
} }
} }
} }
/** /**
* 2. 百度定位核心:绝不拦截 requestLocation 与 requestNLPNormal,防止破坏状态机引发“位置获取失败” * 包装 TencentLocationListener,注入动态代理
*/ */
private fun hookBaiduNLP(classLoader: ClassLoader, packageName: String) { private fun wrapTencentListenerArgs(args: Array<Any?>, classLoader: ClassLoader, packageName: String) {
val listenerInterface = try {
XposedHelpers.findClass("com.tencent.map.geolocation.TencentLocationListener", classLoader)
} catch (_: Throwable) {
return
}
for (i in args.indices) {
val arg = args[i] ?: continue
if (listenerInterface.isAssignableFrom(arg.javaClass)) {
if (Proxy.isProxyClass(arg.javaClass) && Proxy.getInvocationHandler(arg) is TencentListenerInvocationHandler) {
continue
}
val proxy = tencentListenerProxyMap.getOrPut(arg) {
Proxy.newProxyInstance(
classLoader,
arrayOf(listenerInterface),
TencentListenerInvocationHandler(arg, classLoader, packageName)
)
}
args[i] = proxy
TraceLogger.d("ThirdPartyNLP", "[$packageName] Wrapped TencentLocationListener at index $i with dynamic proxy")
}
}
}
private class TencentListenerInvocationHandler(
private val originalListener: Any,
private val classLoader: ClassLoader,
private val packageName: String
) : InvocationHandler {
override fun invoke(proxy: Any?, method: Method, args: Array<Any?>?): Any? {
if (method.name == "onLocationChanged") {
if (GlobalMockMemory.isEnabled && GlobalMockMemory.shouldMock(packageName)) {
val mockLoc = createMockTencentLocation(classLoader)
if (mockLoc != null && args != null && args.isNotEmpty()) {
args[0] = mockLoc
if (args.size > 1) {
args[1] = 0 // TencentLocation.ERROR_OK
}
if (args.size > 2) {
args[2] = "OK"
}
TraceLogger.w("ThirdPartyNLP", "[$packageName] TencentLocationListener.onLocationChanged -> REPLACED with Mock Location (${GlobalMockMemory.latitude}, ${GlobalMockMemory.longitude})")
}
}
}
return method.invoke(originalListener, *(args ?: emptyArray()))
}
}
/**
* 动态反射构建标准 TencentLocation 接口代理实例
*/
private fun createMockTencentLocation(classLoader: ClassLoader): Any? {
val locationInterface = try {
XposedHelpers.findClass("com.tencent.map.geolocation.TencentLocation", classLoader)
} catch (_: Throwable) {
return null
}
val lat = GlobalMockMemory.latitude
val lng = GlobalMockMemory.longitude
val alt = GlobalMockMemory.altitude
val accuracy = GlobalMockMemory.accuracy
val speed = GlobalMockMemory.speed
val bearing = GlobalMockMemory.bearing
val time = System.currentTimeMillis()
val elapsed = SystemClock.elapsedRealtime()
val locName = GlobalMockMemory.locationName.ifEmpty { "我的位置" }
return Proxy.newProxyInstance(
classLoader,
arrayOf(locationInterface)
) { _, method, args ->
when (method.name) {
"getLatitude" -> lat
"getLongitude" -> lng
"getAltitude" -> alt
"getAccuracy" -> accuracy
"getSpeed" -> speed
"getBearing" -> bearing
"getTime" -> time
"getElapsedRealtime" -> elapsed
"getProvider" -> "gps"
"getAddress" -> locName
"getName" -> locName
"getNation" -> "中国"
"getProvince" -> ""
"getCity" -> ""
"getDistrict" -> ""
"getTown" -> ""
"getVillage" -> ""
"getStreet" -> ""
"getStreetNo" -> ""
"getCityCode" -> ""
"getCityPhoneCode" -> ""
"getAreaStat" -> 0
"getCoordinateType" -> 1 // 1: GCJ-02
"isMockGps" -> 0 // 核心伪装:假装是硬件 GPS,非 Mock
"getIndoorBuildingId" -> null
"getIndoorBuildingFloor" -> null
"getIndoorLocationType" -> 0
"getDirection" -> bearing.toDouble()
"getExtra" -> Bundle()
"getSourceProvider" -> 0
"getVerifyKey" -> ""
"toString" -> "TencentLocation{lat=$lat,lng=$lng,name=$locName}"
"hashCode" -> lat.hashCode() xor lng.hashCode()
"equals" -> args?.getOrNull(0) === this
else -> {
when (method.returnType) {
java.lang.Boolean.TYPE -> false
java.lang.Integer.TYPE -> 0
java.lang.Long.TYPE -> 0L
java.lang.Double.TYPE -> 0.0
java.lang.Float.TYPE -> 0.0f
java.lang.String::class.java -> ""
else -> null
}
}
}
}
}
// ====================================================================================
// 2. 百度定位核心 (com.baidu.location.BDLocation / LocationClient)
// ====================================================================================
private fun hookBaiduLocationSDK(classLoader: ClassLoader, packageName: String) {
// (1) 挂钩 BDLocation 全系列 Getter(全场景覆盖)
val bdLocationClass = try {
XposedHelpers.findClass("com.baidu.location.BDLocation", classLoader)
} catch (_: Throwable) {
null
}
if (bdLocationClass != null) {
TraceLogger.i("ThirdPartyNLP", "[$packageName] Detected BDLocation, arming Baidu hooks...")
for (method in bdLocationClass.declaredMethods) {
when (method.name) {
"getLatitude" -> {
try {
XposedBridge.hookMethod(method, object : XC_MethodHook() {
override fun afterHookedMethod(param: MethodHookParam) {
if (GlobalMockMemory.isEnabled && GlobalMockMemory.shouldMock(packageName)) {
param.result = GlobalMockMemory.latitude
}
}
})
} catch (_: Throwable) {}
}
"getLongitude" -> {
try {
XposedBridge.hookMethod(method, object : XC_MethodHook() {
override fun afterHookedMethod(param: MethodHookParam) {
if (GlobalMockMemory.isEnabled && GlobalMockMemory.shouldMock(packageName)) {
param.result = GlobalMockMemory.longitude
}
}
})
} catch (_: Throwable) {}
}
"getAltitude" -> {
try {
XposedBridge.hookMethod(method, object : XC_MethodHook() {
override fun afterHookedMethod(param: MethodHookParam) {
if (GlobalMockMemory.isEnabled && GlobalMockMemory.shouldMock(packageName)) {
param.result = GlobalMockMemory.altitude
}
}
})
} catch (_: Throwable) {}
}
"getRadius" -> {
try {
XposedBridge.hookMethod(method, object : XC_MethodHook() {
override fun afterHookedMethod(param: MethodHookParam) {
if (GlobalMockMemory.isEnabled && GlobalMockMemory.shouldMock(packageName)) {
param.result = GlobalMockMemory.accuracy
}
}
})
} catch (_: Throwable) {}
}
"getSpeed" -> {
try {
XposedBridge.hookMethod(method, object : XC_MethodHook() {
override fun afterHookedMethod(param: MethodHookParam) {
if (GlobalMockMemory.isEnabled && GlobalMockMemory.shouldMock(packageName)) {
param.result = GlobalMockMemory.speed
}
}
})
} catch (_: Throwable) {}
}
"getDirection" -> {
try {
XposedBridge.hookMethod(method, object : XC_MethodHook() {
override fun afterHookedMethod(param: MethodHookParam) {
if (GlobalMockMemory.isEnabled && GlobalMockMemory.shouldMock(packageName)) {
param.result = GlobalMockMemory.bearing
}
}
})
} catch (_: Throwable) {}
}
"getLocType" -> {
try {
XposedBridge.hookMethod(method, object : XC_MethodHook() {
override fun afterHookedMethod(param: MethodHookParam) {
if (GlobalMockMemory.isEnabled && GlobalMockMemory.shouldMock(packageName)) {
param.result = 61 // 61: GPS 定位成功
}
}
})
} catch (_: Throwable) {}
}
"getAddrStr", "getLocationDescribe" -> {
try {
XposedBridge.hookMethod(method, object : XC_MethodHook() {
override fun afterHookedMethod(param: MethodHookParam) {
if (GlobalMockMemory.isEnabled && GlobalMockMemory.shouldMock(packageName)) {
val locName = GlobalMockMemory.locationName
if (locName.isNotEmpty()) {
param.result = locName
}
}
}
})
} catch (_: Throwable) {}
}
}
}
}
// (2) 挂钩 LocationClient 返回 Location 的方法
val clientClass = try { val clientClass = try {
XposedHelpers.findClass("com.baidu.location.LocationClient", classLoader) XposedHelpers.findClass("com.baidu.location.LocationClient", classLoader)
} catch (_: Throwable) { } catch (_: Throwable) {
null null
} ?: return }
if (clientClass != null) {
for (method in clientClass.declaredMethods) { for (method in clientClass.declaredMethods) {
if (method.returnType == Location::class.java) { if (method.returnType == Location::class.java) {
try { try {
XposedBridge.hookMethod(method, object : XC_MethodHook() { XposedBridge.hookMethod(method, object : XC_MethodHook() {
override fun afterHookedMethod(param: MethodHookParam) { override fun afterHookedMethod(param: MethodHookParam) {
val shouldMock = GlobalMockMemory.isEnabled && GlobalMockMemory.shouldMock(packageName) if (!GlobalMockMemory.isEnabled || !GlobalMockMemory.shouldMock(packageName)) return
val originalLoc = param.result as? Location val mockLoc = GlobalMockMemory.createLocation("gps")
TraceLogger.d("ThirdPartyNLP", "[$packageName] BaiduNLP.${method.name}: incoming=${TraceLogger.formatLocation(originalLoc)}, shouldMock=$shouldMock") param.result = mockLoc
TraceLogger.w("ThirdPartyNLP", "[$packageName] Baidu LocationClient.${method.name} -> REPLACED")
if (!shouldMock) return }
val mockLoc = GlobalMockMemory.createLocation(originalLoc?.provider ?: "gps") })
param.result = mockLoc } catch (_: Throwable) {}
TraceLogger.w("ThirdPartyNLP", "[$packageName] BaiduNLP.${method.name}: REPLACED with ${TraceLogger.formatLocation(mockLoc)}") }
}
})
} catch (_: Throwable) {}
} }
} }
} }
/** // ====================================================================================
* 3. 高德底层网络定位:拦截位置返回,确保不穿透 // 3. 高德定位核心 (com.amap.api.location.AMapLocation / NetworkLocationManager)
*/ // ====================================================================================
private fun hookAmapNLP(classLoader: ClassLoader, packageName: String) {
private fun hookAmapLocationSDK(classLoader: ClassLoader, packageName: String) {
// (1) 挂钩 AMapLocation 核心 Getter
val amapLocClass = try {
XposedHelpers.findClass("com.amap.api.location.AMapLocation", classLoader)
} catch (_: Throwable) {
null
}
if (amapLocClass != null) {
TraceLogger.i("ThirdPartyNLP", "[$packageName] Detected AMapLocation, arming Gaode hooks...")
for (method in amapLocClass.declaredMethods) {
when (method.name) {
"getLatitude" -> {
try {
XposedBridge.hookMethod(method, object : XC_MethodHook() {
override fun afterHookedMethod(param: MethodHookParam) {
if (GlobalMockMemory.isEnabled && GlobalMockMemory.shouldMock(packageName)) {
param.result = GlobalMockMemory.latitude
}
}
})
} catch (_: Throwable) {}
}
"getLongitude" -> {
try {
XposedBridge.hookMethod(method, object : XC_MethodHook() {
override fun afterHookedMethod(param: MethodHookParam) {
if (GlobalMockMemory.isEnabled && GlobalMockMemory.shouldMock(packageName)) {
param.result = GlobalMockMemory.longitude
}
}
})
} catch (_: Throwable) {}
}
"getAltitude" -> {
try {
XposedBridge.hookMethod(method, object : XC_MethodHook() {
override fun afterHookedMethod(param: MethodHookParam) {
if (GlobalMockMemory.isEnabled && GlobalMockMemory.shouldMock(packageName)) {
param.result = GlobalMockMemory.altitude
}
}
})
} catch (_: Throwable) {}
}
"getAccuracy" -> {
try {
XposedBridge.hookMethod(method, object : XC_MethodHook() {
override fun afterHookedMethod(param: MethodHookParam) {
if (GlobalMockMemory.isEnabled && GlobalMockMemory.shouldMock(packageName)) {
param.result = GlobalMockMemory.accuracy
}
}
})
} catch (_: Throwable) {}
}
"getSpeed" -> {
try {
XposedBridge.hookMethod(method, object : XC_MethodHook() {
override fun afterHookedMethod(param: MethodHookParam) {
if (GlobalMockMemory.isEnabled && GlobalMockMemory.shouldMock(packageName)) {
param.result = GlobalMockMemory.speed
}
}
})
} catch (_: Throwable) {}
}
"getBearing" -> {
try {
XposedBridge.hookMethod(method, object : XC_MethodHook() {
override fun afterHookedMethod(param: MethodHookParam) {
if (GlobalMockMemory.isEnabled && GlobalMockMemory.shouldMock(packageName)) {
param.result = GlobalMockMemory.bearing
}
}
})
} catch (_: Throwable) {}
}
"getErrorCode" -> {
try {
XposedBridge.hookMethod(method, object : XC_MethodHook() {
override fun afterHookedMethod(param: MethodHookParam) {
if (GlobalMockMemory.isEnabled && GlobalMockMemory.shouldMock(packageName)) {
param.result = 0 // 0: 定位成功
}
}
})
} catch (_: Throwable) {}
}
"getAddress", "getDescription", "getPoiName" -> {
try {
XposedBridge.hookMethod(method, object : XC_MethodHook() {
override fun afterHookedMethod(param: MethodHookParam) {
if (GlobalMockMemory.isEnabled && GlobalMockMemory.shouldMock(packageName)) {
val locName = GlobalMockMemory.locationName
if (locName.isNotEmpty()) {
param.result = locName
}
}
}
})
} catch (_: Throwable) {}
}
}
}
}
// (2) 挂钩 NetworkLocationManager 底层
val nlpClass = try { val nlpClass = try {
XposedHelpers.findClass("com.amap.android.location.NetworkLocationManager", classLoader) XposedHelpers.findClass("com.amap.android.location.NetworkLocationManager", classLoader)
} catch (_: Throwable) { } catch (_: Throwable) {
null null
} ?: return }
if (nlpClass != null) {
for (method in nlpClass.declaredMethods) { for (method in nlpClass.declaredMethods) {
if (method.returnType == Location::class.java) { if (method.returnType == Location::class.java) {
try { try {
XposedBridge.hookMethod(method, object : XC_MethodHook() { XposedBridge.hookMethod(method, object : XC_MethodHook() {
override fun afterHookedMethod(param: MethodHookParam) { override fun afterHookedMethod(param: MethodHookParam) {
val shouldMock = GlobalMockMemory.isEnabled && GlobalMockMemory.shouldMock(packageName) if (!GlobalMockMemory.isEnabled || !GlobalMockMemory.shouldMock(packageName)) return
val originalLoc = param.result as? Location val mockLoc = GlobalMockMemory.createLocation("network")
TraceLogger.d("ThirdPartyNLP", "[$packageName] AmapNLP.${method.name}: incoming=${TraceLogger.formatLocation(originalLoc)}, shouldMock=$shouldMock") param.result = mockLoc
TraceLogger.w("ThirdPartyNLP", "[$packageName] AmapNLP.${method.name} -> REPLACED")
if (!shouldMock) return }
val mockLoc = GlobalMockMemory.createLocation(originalLoc?.provider ?: "network") })
param.result = mockLoc } catch (_: Throwable) {}
TraceLogger.w("ThirdPartyNLP", "[$packageName] AmapNLP.${method.name}: REPLACED with ${TraceLogger.formatLocation(mockLoc)}") }
}
})
} catch (_: Throwable) {}
} }
} }
} }
@@ -34,6 +34,7 @@ object GlobalMockMemory {
@Volatile var bearing: Float = 0.0f @Volatile var bearing: Float = 0.0f
@Volatile var speed: Float = 0.0f @Volatile var speed: Float = 0.0f
@Volatile var mode: String = "GLOBAL" @Volatile var mode: String = "GLOBAL"
@Volatile var locationName: String = ""
@Volatile var whitelist: Set<String> = emptySet() @Volatile var whitelist: Set<String> = emptySet()
@Volatile var blacklist: Set<String> = emptySet() @Volatile var blacklist: Set<String> = emptySet()
@@ -46,6 +47,7 @@ object GlobalMockMemory {
bearing = bundle.getFloat(EXTRA_BEARING, bearing) bearing = bundle.getFloat(EXTRA_BEARING, bearing)
speed = bundle.getFloat(EXTRA_SPEED, speed) speed = bundle.getFloat(EXTRA_SPEED, speed)
mode = bundle.getString(EXTRA_MODE, mode) ?: mode mode = bundle.getString(EXTRA_MODE, mode) ?: mode
locationName = bundle.getString(EXTRA_LOCATION_NAME, locationName) ?: locationName
val whiteListArray = bundle.getStringArrayList(EXTRA_WHITELIST) val whiteListArray = bundle.getStringArrayList(EXTRA_WHITELIST)
if (whiteListArray != null) { if (whiteListArray != null) {
@@ -68,6 +70,7 @@ object GlobalMockMemory {
putFloat(EXTRA_BEARING, bearing) putFloat(EXTRA_BEARING, bearing)
putFloat(EXTRA_SPEED, speed) putFloat(EXTRA_SPEED, speed)
putString(EXTRA_MODE, mode) putString(EXTRA_MODE, mode)
putString(EXTRA_LOCATION_NAME, locationName)
putStringArrayList(EXTRA_WHITELIST, ArrayList(whitelist)) putStringArrayList(EXTRA_WHITELIST, ArrayList(whitelist))
putStringArrayList(EXTRA_BLACKLIST, ArrayList(blacklist)) putStringArrayList(EXTRA_BLACKLIST, ArrayList(blacklist))
} }
@@ -41,12 +41,15 @@ object SystemServerHook {
// 已挂钩 onLocationChanged 的类名集合,防止重复 Hook // 已挂钩 onLocationChanged 的类名集合,防止重复 Hook
private val hookedListenerClasses = Collections.synchronizedSet(mutableSetOf<String>()) private val hookedListenerClasses = Collections.synchronizedSet(mutableSetOf<String>())
private val hookedCallbackClasses = Collections.synchronizedSet(mutableSetOf<String>()) private val hookedCallbackClasses = Collections.synchronizedSet(mutableSetOf<String>())
// 已挂钩 Wi-Fi 服务的类名集合,防止重复 Hook
private val hookedWifiClasses = Collections.synchronizedSet(mutableSetOf<String>())
fun hook(classLoader: ClassLoader) { fun hook(classLoader: ClassLoader) {
XposedBridge.log("[OpenLoc] [SystemServer] Initializing GhostMapX architecture in system_server...") XposedBridge.log("[OpenLoc] [SystemServer] Initializing GhostMapX architecture in system_server...")
hookLocationManagerService(classLoader) hookLocationManagerService(classLoader)
hookWifiService(classLoader) hookWifiService(classLoader)
hookTelephonyRegistry(classLoader)
} }
private fun hookLocationManagerService(classLoader: ClassLoader) { private fun hookLocationManagerService(classLoader: ClassLoader) {
@@ -349,74 +352,164 @@ object SystemServerHook {
} }
/** /**
* Wi-Fi 扫描结果与连接指纹拦截(100% 对齐 GhostMapX LTn.java) * Wi-Fi 扫描结果与连接指纹拦截(支持 Android 8 ~ 15,包含 Android 12+ APEX 模块支持)
* 核心: * 核心目标:
* 1. getScanResults: 兼容 Android 10+ 的 ParceledListSlice,绝不因类型转换异常泄露真实 Wi-Fi 列表; * 1. 彻底支持 Android 12+ APEX modular service-wifi.jar 中的 WifiServiceImpl;
* 2. getConnectionInfo: 抹去当前连接 Wi-Fi 路由器的真实 BSSID (MAC),阻断 QQ/腾讯云端指纹反查。 * 2. getScanResults: 拦截所有目标第三方应用的 Wi-Fi 扫描,返回空列表,阻断腾讯/高德/百度云端指纹反查;
* 3. getConnectionInfo: 抹去当前连接 Wi-Fi 路由器的真实 BSSID (MAC),阻断针对当前局域网的反查;
* 4. startScan: 抑制目标应用触发硬件扫描。
*/ */
private fun hookWifiService(classLoader: ClassLoader) { private fun hookWifiService(classLoader: ClassLoader) {
// 1. 尝试直接从系统类加载器查找 (Android 8 ~ 11)
val wifiServiceClasses = listOf( val wifiServiceClasses = listOf(
"com.android.server.wifi.WifiServiceImpl", "com.android.server.wifi.WifiServiceImpl",
"com.android.server.wifi.WifiService" "com.android.server.wifi.WifiService"
) )
for (className in wifiServiceClasses) { for (className in wifiServiceClasses) {
val wifiClass = try { try {
XposedHelpers.findClass(className, classLoader) val wifiClass = XposedHelpers.findClass(className, classLoader)
} catch (_: Throwable) { hookWifiServiceImpl(wifiClass)
null } catch (_: Throwable) {}
} ?: continue }
for (method in wifiClass.declaredMethods) { // 2. 尝试从 ServiceManager.checkService("wifi") 提取当前已运行的运行时 Binder 实例 (跨 APEX)
when (method.name) { try {
"getScanResults" -> { val smClass = Class.forName("android.os.ServiceManager")
try { val checkServiceMethod = smClass.getMethod("checkService", String::class.java)
XposedBridge.hookMethod(method, object : XC_MethodHook() { val wifiBinder = checkServiceMethod.invoke(null, "wifi")
override fun afterHookedMethod(param: MethodHookParam) { if (wifiBinder != null) {
if (!GlobalMockMemory.isEnabled) return TraceLogger.i("SystemServer", "Found active 'wifi' IBinder in ServiceManager: ${wifiBinder.javaClass.name}")
val pkg = resolveCallingPackage(param) hookWifiServiceImpl(wifiBinder.javaClass)
// 未知名或非模拟目标一律放行物理 Wi-Fi 扫描结果 }
if (pkg.isNullOrBlank() || !GlobalMockMemory.shouldMock(pkg)) return } catch (t: Throwable) {
TraceLogger.d("SystemServer", "checkService('wifi') inspection: ${t.message}")
}
val res = param.result ?: return // 3. 动态拦截 ServiceManager.addService,捕获后续启动阶段注册的 "wifi" 服务 (针对 Android 12+ APEX 模块晚加载)
if (res is List<*>) { try {
param.result = emptyList<Any>() val smClass = Class.forName("android.os.ServiceManager")
} else if (res.javaClass.name.contains("ParceledListSlice")) { XposedBridge.hookAllMethods(smClass, "addService", object : XC_MethodHook() {
// GhostMapX LTn.java 经典实现:反射构建空的 ParceledListSlice override fun beforeHookedMethod(param: MethodHookParam) {
try { val name = param.args.getOrNull(0) as? String ?: return
val ctor = res.javaClass.getConstructor(List::class.java) if (name == "wifi") {
ctor.isAccessible = true val binder = param.args.getOrNull(1) ?: return
param.result = ctor.newInstance(emptyList<Any>()) TraceLogger.i("SystemServer", "Captured 'wifi' addService registration: ${binder.javaClass.name}")
} catch (_: Throwable) { hookWifiServiceImpl(binder.javaClass)
param.result = null
}
}
}
})
} catch (_: Throwable) {}
}
"getConnectionInfo" -> {
try {
XposedBridge.hookMethod(method, object : XC_MethodHook() {
override fun afterHookedMethod(param: MethodHookParam) {
if (!GlobalMockMemory.isEnabled) return
val pkg = resolveCallingPackage(param)
// 未知名或非模拟目标一律放行真实 Wi-Fi 连接信息
if (pkg.isNullOrBlank() || !GlobalMockMemory.shouldMock(pkg)) return
val wifiInfo = param.result ?: return
try {
// 抹去已连接 Wi-Fi 的物理 BSSID (MAC 地址),杜绝腾讯云端反查当前房间
XposedHelpers.setObjectField(wifiInfo, "mBSSID", "02:00:00:00:00:00")
XposedHelpers.setObjectField(wifiInfo, "mMacAddress", "02:00:00:00:00:00")
} catch (_: Throwable) {}
}
})
} catch (_: Throwable) {}
} }
} }
} })
} catch (t: Throwable) {
TraceLogger.e("SystemServer", "Failed to hook ServiceManager.addService: ${t.message}")
}
}
private fun hookWifiServiceImpl(wifiClass: Class<*>) {
val className = wifiClass.name
if (hookedWifiClasses.contains(className)) return
hookedWifiClasses.add(className)
TraceLogger.i("SystemServer", "Arming Wi-Fi interceptor for class: $className (ClassLoader=${wifiClass.classLoader})")
// (1) 拦截 getScanResults
try {
XposedBridge.hookAllMethods(wifiClass, "getScanResults", object : XC_MethodHook() {
override fun afterHookedMethod(param: MethodHookParam) {
if (!GlobalMockMemory.isEnabled) return
val callingUid = Binder.getCallingUid()
if (callingUid <= 1000) return // 严格放行系统服务与硬件 HAL
val pkg = resolveCallingPackage(param)
if (pkg.isNullOrBlank() || !GlobalMockMemory.shouldMock(pkg)) return
val res = param.result ?: return
TraceLogger.w("SystemServer", "WifiServiceImpl.getScanResults intercepted for $pkg (UID=$callingUid), returning EMPTY scan results")
if (res is List<*>) {
param.result = emptyList<Any>()
} else if (res.javaClass.name.contains("ParceledListSlice")) {
try {
param.result = XposedHelpers.callStaticMethod(res.javaClass, "emptyList")
} catch (_: Throwable) {
try {
val ctor = res.javaClass.getConstructor(List::class.java)
ctor.isAccessible = true
param.result = ctor.newInstance(emptyList<Any>())
} catch (_: Throwable) {
param.result = null
}
}
}
}
})
} catch (t: Throwable) {
TraceLogger.e("SystemServer", "Failed to hook getScanResults on $className: ${t.message}")
}
// (2) 拦截 getConnectionInfo (抹除已连接 Wi-Fi 的 BSSID/MAC)
try {
XposedBridge.hookAllMethods(wifiClass, "getConnectionInfo", object : XC_MethodHook() {
override fun afterHookedMethod(param: MethodHookParam) {
if (!GlobalMockMemory.isEnabled) return
val callingUid = Binder.getCallingUid()
if (callingUid <= 1000) return
val pkg = resolveCallingPackage(param)
if (pkg.isNullOrBlank() || !GlobalMockMemory.shouldMock(pkg)) return
val wifiInfo = param.result ?: return
TraceLogger.w("SystemServer", "WifiServiceImpl.getConnectionInfo intercepted for $pkg (UID=$callingUid), anonymizing BSSID")
for (field in listOf("mBSSID", "mBssid", "bssid")) {
try { XposedHelpers.setObjectField(wifiInfo, field, "02:00:00:00:00:00") } catch (_: Throwable) {}
}
for (field in listOf("mMacAddress", "mMac", "macAddress")) {
try { XposedHelpers.setObjectField(wifiInfo, field, "02:00:00:00:00:00") } catch (_: Throwable) {}
}
}
})
} catch (t: Throwable) {
TraceLogger.e("SystemServer", "Failed to hook getConnectionInfo on $className: ${t.message}")
}
// (3) 拦截 startScan (抑制目标第三方应用主动触发物理 Wi-Fi 扫描)
try {
XposedBridge.hookAllMethods(wifiClass, "startScan", object : XC_MethodHook() {
override fun beforeHookedMethod(param: MethodHookParam) {
if (!GlobalMockMemory.isEnabled) return
val callingUid = Binder.getCallingUid()
if (callingUid <= 1000) return
val pkg = resolveCallingPackage(param)
if (pkg.isNullOrBlank() || !GlobalMockMemory.shouldMock(pkg)) return
TraceLogger.d("SystemServer", "WifiServiceImpl.startScan suppressed for $pkg (UID=$callingUid)")
param.result = true
}
})
} catch (t: Throwable) {
TraceLogger.e("SystemServer", "Failed to hook startScan on $className: ${t.message}")
}
}
/**
* system_server 内部 TelephonyRegistry 监听拦截
* 阻断通过 PhoneStateListener 监听基站变化的行为
*/
private fun hookTelephonyRegistry(classLoader: ClassLoader) {
val registryClass = try {
XposedHelpers.findClass("com.android.server.TelephonyRegistry", classLoader)
} catch (_: Throwable) {
null
} ?: return
for (methodName in listOf("notifyCellInfo", "notifyCellInfoForSubscriber")) {
try {
XposedBridge.hookAllMethods(registryClass, methodName, object : XC_MethodHook() {
override fun beforeHookedMethod(param: MethodHookParam) {
// 系统向外广播基站变动时,底层由系统维护,调用方由客户端与 Phone 进程拦截
}
})
} catch (_: Throwable) {}
} }
} }
@@ -120,9 +120,19 @@ object TelephonyRegistryHook {
} }
} }
} }
val ctx = phoneContext ?: return null val ctx = phoneContext
if (ctx != null) {
try {
val packages = ctx.packageManager.getPackagesForUid(uid)
val first = packages?.firstOrNull()
if (!first.isNullOrBlank()) return first
} catch (_: Throwable) {}
}
return try { return try {
val packages = ctx.packageManager.getPackagesForUid(uid) val appGlobalsClass = Class.forName("android.app.AppGlobals")
val pm = XposedHelpers.callStaticMethod(appGlobalsClass, "getPackageManager")
@Suppress("UNCHECKED_CAST")
val packages = XposedHelpers.callMethod(pm, "getPackagesForUid", uid) as? Array<String>
packages?.firstOrNull() packages?.firstOrNull()
} catch (_: Throwable) { } catch (_: Throwable) {
null null