Modifier/app/src/main/java/com/example/modifier/repo/SpoofedSimInfoRepo.kt

package com.example.modifier.repo

import android.Manifest
import android.annotation.SuppressLint
import android.content.Context
import android.telephony.SubscriptionManager
import android.telephony.TelephonyManager
import android.util.Log
import androidx.datastore.preferences.core.booleanPreferencesKey
import androidx.datastore.preferences.core.edit
import androidx.datastore.preferences.core.intPreferencesKey
import androidx.datastore.preferences.core.stringPreferencesKey
import androidx.datastore.preferences.preferencesDataStore
import com.example.modifier.BuildConfig
import com.example.modifier.baseTag
import com.example.modifier.constants.PACKAGE_GMS
import com.example.modifier.constants.PACKAGE_MESSAGING
import com.example.modifier.constants.SIMView
import com.example.modifier.extension.kill
import com.example.modifier.model.SpoofedSimInfo
import com.example.modifier.utils.ApduChannel
import com.example.modifier.utils.ROOT_ACCESS
import com.example.modifier.utils.SimEncoder
import com.example.modifier.utils.genICCID
import com.example.modifier.utils.genIMEI
import com.example.modifier.utils.genIMSI
import com.example.modifier.utils.getContext
import com.example.modifier.utils.hasPermission
import com.example.modifier.utils.isOldVersion
import com.example.modifier.utils.resumePackage
import com.example.modifier.utils.shellRun
import com.example.modifier.utils.suspendPackage
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.launch

val Context.simInfoDataStore by preferencesDataStore(name = "${BuildConfig.APPLICATION_ID}.simInfo")

class SpoofedSimInfoRepo private constructor(private val context: Context) {

    companion object {
        private const val TAG = "$baseTag/SpoofedSimInfoRepository"
        val instance by lazy(LazyThreadSafetyMode.SYNCHRONIZED) { SpoofedSimInfoRepo(getContext()) }
    }

    private object PreferencesKeys {
        val NUMBER_ID = intPreferencesKey("number_id")
        val NUMBER = stringPreferencesKey("number")
        val MCC = stringPreferencesKey("mcc")
        val MNC = stringPreferencesKey("mnc")
        val ICCID = stringPreferencesKey("iccid")
        val IMSI = stringPreferencesKey("imsi")
        val IMEI = stringPreferencesKey("imei")
        val COUNTRY = stringPreferencesKey("country")
        val AREA_CODE = stringPreferencesKey("area_code")
        val AVAILABLE = booleanPreferencesKey("available")
        val CARRIER_ID = stringPreferencesKey("carrier_id")
        val CARRIER_NAME = stringPreferencesKey("carrier_name")
    }

    private val simInfoFlow = context.simInfoDataStore.data.map {
        val numberId = it[PreferencesKeys.NUMBER_ID] ?: 0
        val number = it[PreferencesKeys.NUMBER] ?: ""
        val mcc = it[PreferencesKeys.MCC] ?: ""
        val mnc = it[PreferencesKeys.MNC] ?: ""
        val iccid = it[PreferencesKeys.ICCID] ?: ""
        val imsi = it[PreferencesKeys.IMSI] ?: ""
        val imei = it[PreferencesKeys.IMEI] ?: ""
        val country = it[PreferencesKeys.COUNTRY] ?: ""
        val areaCode = it[PreferencesKeys.AREA_CODE] ?: ""
        val available = it[PreferencesKeys.AVAILABLE] ?: false
        val carrierId = it[PreferencesKeys.CARRIER_ID] ?: ""
        val carrierName = it[PreferencesKeys.CARRIER_NAME] ?: ""
        SpoofedSimInfo(
            numberId = numberId,
            number = number,
            mcc = mcc,
            mnc = mnc,
            iccid = iccid,
            imsi = imsi,
            imei = imei,
            country = country,
            areaCode = areaCode,
            available = available,
            carrierId = carrierId,
            carrierName = carrierName
        )
    }

    val spoofedSimInfo = MutableStateFlow(
        SpoofedSimInfo(
            numberId = 0,
            number = "",
            mcc = "",
            mnc = "",
            iccid = "",
            imsi = "",
            imei = "",
            country = "",
            areaCode = "",
            available = false,
            carrierId = "",
            carrierName = ""
        )
    )

    init {
        CoroutineScope(Dispatchers.IO).launch {
            simInfoFlow.collect {
                spoofedSimInfo.emit(it)
            }
        }
    }

    @SuppressLint("MissingPermission")
    suspend fun updateSpoofedSimInfo(spoofedSimInfo: SpoofedSimInfo, suspend: Boolean? = true) {
        context.simInfoDataStore.edit {
            it[PreferencesKeys.NUMBER_ID] = spoofedSimInfo.numberId
            it[PreferencesKeys.NUMBER] = spoofedSimInfo.number
            it[PreferencesKeys.MCC] = spoofedSimInfo.mcc
            it[PreferencesKeys.MNC] = spoofedSimInfo.mnc
            it[PreferencesKeys.ICCID] = spoofedSimInfo.iccid
            it[PreferencesKeys.IMSI] = spoofedSimInfo.imsi
            it[PreferencesKeys.IMEI] = spoofedSimInfo.imei
            it[PreferencesKeys.COUNTRY] = spoofedSimInfo.country
            it[PreferencesKeys.AREA_CODE] = spoofedSimInfo.areaCode
            it[PreferencesKeys.AVAILABLE] = spoofedSimInfo.available
            it[PreferencesKeys.CARRIER_ID] = spoofedSimInfo.carrierId
            it[PreferencesKeys.CARRIER_NAME] = spoofedSimInfo.carrierName
        }
        try {
            if (ROOT_ACCESS) {
                if (suspend == true) {
                    suspendPackage(PACKAGE_GMS, PACKAGE_MESSAGING)
                }
                shellRun(
                    "setprop persist.spoof.number ${spoofedSimInfo.number}",
                    "setprop persist.spoof.mcc ${spoofedSimInfo.mcc}",
                    "setprop persist.spoof.mnc ${spoofedSimInfo.mnc}",
                    "setprop persist.spoof.iccid ${spoofedSimInfo.iccid}",
                    "setprop persist.spoof.imsi ${spoofedSimInfo.imsi}",
                    "setprop persist.spoof.imei ${spoofedSimInfo.imei}",
                    "setprop persist.spoof.country ${spoofedSimInfo.country}",
                    "setprop persist.spoof.carrier.id ${spoofedSimInfo.carrierId}",
                    "setprop persist.spoof.carrier.name '${spoofedSimInfo.carrierName}'",
                )

                val context = getContext()
                val subscriptionManager: SubscriptionManager =
                    context.getSystemService(Context.TELEPHONY_SUBSCRIPTION_SERVICE) as SubscriptionManager

                if (hasPermission(Manifest.permission.READ_PHONE_STATE)) {
                    val simCount = subscriptionManager.activeSubscriptionInfoCountMax
                    for (i in 0 until simCount) {
                        val info = subscriptionManager.getActiveSubscriptionInfoForSimSlotIndex(i)
                        if (info != null) {
                            val mcc = info.mccString
                            val mnc = info.mncString
                            Log.i(TAG, "mccmnc spoofed: $mcc$mnc")
                        }
                    }
                }
                if (suspend == true) {
                    resumePackage(PACKAGE_GMS, PACKAGE_MESSAGING)
                }

            } else {
                if (suspend == true) {
                    suspendPackage(PACKAGE_GMS, PACKAGE_MESSAGING)
                    shellRun(
                        PACKAGE_GMS.kill(),
                        PACKAGE_MESSAGING.kill()
                    )
                }

                val plmn = spoofedSimInfo.mcc + spoofedSimInfo.mnc
                val plmnHex = SimEncoder.encPLMN(spoofedSimInfo.mcc + spoofedSimInfo.mnc)
                val plmnwactHex = SimEncoder.encPLMNwAcT("$plmn:4000,$plmn:8000,$plmn:0080")
                val fplmn =
                    SimEncoder.encPLMN("46000，46001,46002,46006,46007,46011,46012,46015,46020")
                val telephonyManager =
                    context.getSystemService(Context.TELEPHONY_SERVICE) as TelephonyManager
                val apduChannel = ApduChannel(telephonyManager, SIMView.AID_CUSTOM)
                apduChannel.select(SIMView.FID_MF)

                apduChannel.select(SIMView.FID_EF_ICCID)
                apduChannel.writeBinary(SimEncoder.encICCID(spoofedSimInfo.iccid))

                apduChannel.select(SIMView.FID_DF_GSM)
                apduChannel.select(SIMView.FID_EF_IMSI)
                apduChannel.writeBinary(SimEncoder.encIMSI(spoofedSimInfo.imsi))

                apduChannel.select(SIMView.FID_EF_PLMNSEL)
                apduChannel.writeBinary(plmnHex.padEnd(120, 'f'))

                apduChannel.select(SIMView.FID_EF_EHPLMN)
                apduChannel.writeBinary(plmnHex.padEnd(24, 'f'))

                apduChannel.select(SIMView.FID_EF_PLMNWACT)
                apduChannel.writeBinary(plmnwactHex.padEnd(240, 'f'))

                apduChannel.select(SIMView.FID_EF_OPLMNWACT)
                apduChannel.writeBinary(plmnwactHex.padEnd(120, 'f'))

                apduChannel.select(SIMView.FID_EF_HPLMNWACT)
                apduChannel.writeBinary(plmnwactHex.padEnd(40, 'f'))

                apduChannel.select(SIMView.FID_EF_FPLMN)
                apduChannel.writeBinary(fplmn.padEnd(60, 'f'))

                if (plmn.isNotEmpty()) {
                    if (plmn.length == 5) {
                        apduChannel.select(SIMView.FID_EF_AD)
                        apduChannel.writeBinary("00000102")
                    } else if (plmn.length == 6) {
                        apduChannel.select(SIMView.FID_EF_AD)
                        apduChannel.writeBinary("00000103")
                    }
                }
                apduChannel.close()

                val apduChannel1 = ApduChannel(telephonyManager, SIMView.AID_USIM)
                apduChannel1.writeMSISDN_USIM(spoofedSimInfo.number)
                apduChannel.close()

                telephonyManager.rebootModem()
                delay(5000)

                if (suspend == true) {
                    shellRun(
                        PACKAGE_GMS.kill(),
                        PACKAGE_MESSAGING.kill()
                    )
                    resumePackage(PACKAGE_GMS, PACKAGE_MESSAGING)
                }
            }
        } catch (e: Exception) {
            Log.e(TAG, "Error updateSpoofedSimInfo: ${e.message}", e)
        }
    }

    suspend fun mock() {
        if (isOldVersion(context)) {
            val content = getContext().assets.open("us_numbers.txt").bufferedReader().use {
                it.readText()
            }
            // get random number
            content.split("\n")
                .filter { it.isNotBlank() }
                .shuffled()
                .firstOrNull()
                ?.let {
                    updateSpoofedSimInfo(
                        SpoofedSimInfo(
                            numberId = 0,
                            number = it,
                            mcc = "310",
                            mnc = "150",
                            iccid = genICCID("150", "1"),
                            imsi = genIMSI("310150"),
                            imei = genIMEI(),
                            country = "us",
                            areaCode = "1",
                            available = false,
                            carrierId = "1779",
                            carrierName = "Cricket Wireless"
                        )
                    )
                }
        } else {
            val content = getContext().assets.open("us_numbers.txt")
                .bufferedReader().use { it.readText() }
            // get random number
            content.split("\n")
                .filter { it.isNotBlank() }
                .shuffled()
                .firstOrNull()
                ?.let {
                    updateSpoofedSimInfo(
                        SpoofedSimInfo(
                            numberId = 0,
                            number = it,
                            mcc = "310",
                            mnc = "240",
                            iccid = genICCID("240", "1"),
                            imsi = genIMSI("310240"),
                            imei = genIMEI(),
                            country = "us",
                            areaCode = "1",
                            available = false,
                            carrierId = "1",
                            carrierName = "T-Mobile"
                        )
                    )
                }
        }
    }
}