react-native-device-defense 1.0.0

package/android/src/main/java/vn/osp/security/DeviceSecurityModule.kt

@@ -0,0 +1,277 @@
+package vn.osp.security
+
+import android.util.Log
+import com.facebook.react.bridge.*
+import org.json.JSONObject
+
+/**
+ * React Native module for device security detection
+ */
+class DeviceSecurityModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    private val rootDetection by lazy { RootDetection(reactContext) }
+    private val hookDetection by lazy { HookDetection(reactContext) }
+    private val debugDetection by lazy { DebugDetection(reactContext) }
+    private val emulatorDetection by lazy { EmulatorDetection(reactContext) }
+
+    override fun getName(): String = NAME
+
+    override fun getConstants(): Map<String, Any> {
+        val nativeLibLoaded = try {
+            NativeSecurityCheck.isNativeLibraryLoaded()
+        } catch (e: Exception) {
+            Log.e(NAME, "Error checking native library", e)
+            false
+        }
+
+        return mapOf(
+            "NAME" to NAME,
+            "NATIVE_LIBRARY_LOADED" to nativeLibLoaded
+        )
+    }
+
+    /**
+     * Check if device is rooted (synchronous)
+     */
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    fun isRooted(): Boolean {
+        return try {
+            val result = rootDetection.performDetection()
+            result.isRooted
+        } catch (e: Exception) {
+            Log.e(NAME, "Error checking root status", e)
+            false
+        }
+    }
+
+    /**
+     * Get detailed root detection result
+     */
+    @ReactMethod
+    fun isRootedWithDetails(promise: Promise) {
+        try {
+            val result = rootDetection.performDetection()
+            val json = JSONObject().apply {
+                put("isRooted", result.isRooted)
+                put("hasRootBeerDetected", result.hasRootBeerDetected)
+                put("hasNativeRootDetected", result.hasNativeRootDetected)
+                put("hasDangerousBins", result.hasDangerousBins)
+                put("hasRootApps", result.hasRootApps)
+                put("hasSystemPropsModified", result.hasSystemPropsModified)
+                put("details", JSONObject(result.details))
+            }
+            promise.resolve(json.toString())
+        } catch (e: Exception) {
+            Log.e(NAME, "Error getting root details", e)
+            promise.reject("ROOT_CHECK_ERROR", e.message)
+        }
+    }
+
+    /**
+     * Check if Frida is present
+     */
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    fun hasFrida(): Boolean {
+        return try {
+            hookDetection.hasFrida()
+        } catch (e: Exception) {
+            Log.e(NAME, "Error checking Frida", e)
+            false
+        }
+    }
+
+    /**
+     * Check if Xposed is present
+     */
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    fun hasXposed(): Boolean {
+        return try {
+            hookDetection.hasXposed()
+        } catch (e: Exception) {
+            Log.e(NAME, "Error checking Xposed", e)
+            false
+        }
+    }
+
+    /**
+     * Check if Magisk is present
+     */
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    fun hasMagisk(): Boolean {
+        return try {
+            hookDetection.hasMagisk()
+        } catch (e: Exception) {
+            Log.e(NAME, "Error checking Magisk", e)
+            false
+        }
+    }
+
+    /**
+     * Check if app is debuggable
+     */
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    fun isDebuggable(): Boolean {
+        return try {
+            debugDetection.isDebuggable()
+        } catch (e: Exception) {
+            Log.e(NAME, "Error checking debuggable", e)
+            false
+        }
+    }
+
+    /**
+     * Check if running on emulator
+     */
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    fun isEmulator(): Boolean {
+        return try {
+            emulatorDetection.isEmulator()
+        } catch (e: Exception) {
+            Log.e(NAME, "Error checking emulator", e)
+            false
+        }
+    }
+
+    /**
+     * Get comprehensive security status
+     */
+    @ReactMethod
+    fun getSecurityStatus(promise: Promise) {
+        try {
+            val rootResult = rootDetection.performDetection()
+            val hasFrida = hookDetection.hasFrida()
+            val hasXposed = hookDetection.hasXposed()
+            val hasMagisk = hookDetection.hasMagisk()
+            val isDebuggable = debugDetection.isDebuggable()
+            val isEmulator = emulatorDetection.isEmulator()
+
+            val threats = mutableListOf<String>()
+
+            if (rootResult.isRooted) {
+                threats.add("root_detected")
+                if (rootResult.hasRootBeerDetected) threats.add("root_beer_detected")
+                if (rootResult.hasNativeRootDetected) threats.add("native_root_detected")
+                if (rootResult.hasDangerousBins) threats.add("dangerous_bins_detected")
+                if (rootResult.hasRootApps) threats.add("root_apps_detected")
+                if (rootResult.hasSystemPropsModified) threats.add("system_props_modified")
+            }
+            if (hasFrida) threats.add("frida_detected")
+            if (hasXposed) threats.add("xposed_detected")
+            if (hasMagisk) threats.add("magisk_detected")
+            if (isDebuggable) threats.add("debugger_detected")
+            if (isEmulator) threats.add("emulator_detected")
+
+            val securityStatus = JSONObject().apply {
+                put("isSecure", threats.isEmpty())
+                put("threats", org.json.JSONArray(threats))
+                put("isRooted", rootResult.isRooted)
+                put("hasRootBeerDetected", rootResult.hasRootBeerDetected)
+                put("hasNativeRootDetected", rootResult.hasNativeRootDetected)
+                put("hasDangerousBins", rootResult.hasDangerousBins)
+                put("hasRootApps", rootResult.hasRootApps)
+                put("hasSystemPropsModified", rootResult.hasSystemPropsModified)
+                put("hasFrida", hasFrida)
+                put("hasXposed", hasXposed)
+                put("hasMagisk", hasMagisk)
+                put("isDebuggable", isDebuggable)
+                put("isEmulator", isEmulator)
+                put("details", JSONObject().apply {
+                    put("emulatorType", emulatorDetection.getEmulatorType())
+                    val nativeLibLoaded = try {
+                        NativeSecurityCheck.isNativeLibraryLoaded()
+                    } catch (e: Exception) {
+                        false
+                    }
+                    put("nativeLibraryLoaded", nativeLibLoaded)
+                })
+            }
+
+            promise.resolve(securityStatus.toString())
+        } catch (e: Exception) {
+            Log.e(NAME, "Error getting security status", e)
+            promise.reject("SECURITY_STATUS_ERROR", e.message)
+        }
+    }
+
+    /**
+     * Check if device is secure (no threats)
+     */
+    @ReactMethod
+    fun isDeviceSecure(promise: Promise) {
+        try {
+            val rootResult = rootDetection.performDetection()
+            val isSecure = !rootResult.isRooted &&
+                    !hookDetection.hasFrida() &&
+                    !hookDetection.hasXposed() &&
+                    !hookDetection.hasMagisk() &&
+                    !debugDetection.isDebuggable() &&
+                    !emulatorDetection.isEmulator()
+
+            promise.resolve(isSecure)
+        } catch (e: Exception) {
+            Log.e(NAME, "Error checking device security", e)
+            promise.reject("SECURITY_CHECK_ERROR", e.message)
+        }
+    }
+
+    /**
+     * Block app when security threat detected
+     * Shows an alert and exits the app
+     */
+    @ReactMethod
+    fun blockOnSecurityThreat(
+        showAlert: Boolean,
+        alertTitle: String,
+        alertMessage: String,
+        alertButtonText: String
+    ) {
+        try {
+            val rootResult = rootDetection.performDetection()
+            val hasFrida = hookDetection.hasFrida()
+            val hasXposed = hookDetection.hasXposed()
+            val hasMagisk = hookDetection.hasMagisk()
+            val isDebuggable = debugDetection.isDebuggable()
+            val isEmulator = emulatorDetection.isEmulator()
+
+            val hasThreat = rootResult.isRooted ||
+                    hasFrida ||
+                    hasXposed ||
+                    hasMagisk ||
+                    isDebuggable ||
+                    isEmulator
+
+            if (hasThreat) {
+                Log.w(NAME, "Security threat detected, blocking app")
+
+                // Show alert if requested
+                if (showAlert) {
+                    val activity = currentActivity
+                    activity?.runOnUiThread {
+                        android.app.AlertDialog.Builder(activity)
+                            .setCancelable(false)
+                            .setTitle(alertTitle)
+                            .setMessage(alertMessage)
+                            .setPositiveButton(alertButtonText) { _, _ ->
+                                activity.finishAffinity()
+                                System.exit(0)
+                            }
+                            .show()
+                    }
+                } else {
+                    // Exit without alert
+                    currentActivity?.finishAffinity()
+                    System.exit(0)
+                }
+            } else {
+                Log.i(NAME, "No security threat detected, app continues")
+            }
+        } catch (e: Exception) {
+            Log.e(NAME, "Error blocking on security threat", e)
+        }
+    }
+
+    companion object {
+        const val NAME = "DeviceSecurity"
+    }
+}

package/android/src/main/java/vn/osp/security/DeviceSecurityPackage.kt

@@ -0,0 +1,58 @@
+package vn.osp.security
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.uimanager.ViewManager
+
+/**
+ * React Native package for device security module
+ */
+class DeviceSecurityPackage : ReactPackage {
+
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(DeviceSecurityModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+
+    override fun getModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider {
+            val moduleInfo: MutableMap<String, ReactModuleInfo> = java.util.HashMap()
+
+            val methods = listOf(
+                "isRooted",
+                "isRootedWithDetails",
+                "hasFrida",
+                "hasXposed",
+                "hasMagisk",
+                "isDebuggable",
+                "isEmulator",
+                "getSecurityStatus",
+                "isDeviceSecure",
+                "blockOnSecurityThreat"
+            )
+
+            val constants = listOf("NAME", "NATIVE_LIBRARY_LOADED")
+
+            moduleInfo["DeviceSecurity"] = ReactModuleInfo(
+                "DeviceSecurity",
+                "DeviceSecurity",
+                false,  // isTurboModule
+                false,  // isCxxModule
+                true,   // canOverrideExistingModule
+                methods,
+                constants,
+                false,  // supportsEventEmitter
+                false,  // needsDispatchEvent
+                true    // hasConstants
+            )
+
+            moduleInfo
+        }
+    }
+}

package/android/src/main/java/vn/osp/security/EmulatorDetection.kt

@@ -0,0 +1,204 @@
+package vn.osp.security
+
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import android.telephony.TelephonyManager
+import java.io.File
+
+/**
+ * Detection for Android emulators
+ */
+class EmulatorDetection(private val context: Context) {
+
+    /**
+     * Check if running on emulator
+     */
+    fun isEmulator(): Boolean {
+        return checkKnownEmulatorProperties() ||
+                checkEmulatorBuildProps() ||
+                checkEmulatorFiles() ||
+                checkEmulatorFeatures() ||
+                checkNetworkInterfaces() ||
+                checkCamera()
+    }
+
+    /**
+     * Check for known emulator properties
+     */
+    private fun checkKnownEmulatorProperties(): Boolean {
+        val emulatorProps = listOf(
+            "generic" to Build.BRAND,
+            "generic" to Build.PRODUCT,
+            "google_sdk" to Build.PRODUCT,
+            "sdk" to Build.PRODUCT,
+            "sdk_gphone" to Build.PRODUCT,
+            "sdk_gphone64_arm64" to Build.PRODUCT,
+            "sdk_gphone_x86" to Build.PRODUCT,
+            "sdk_gphone64_x86_64" to Build.PRODUCT,
+            "vbox86p" to Build.HARDWARE,
+            "vmos" to Build.HARDWARE,
+            "nox" to Build.HARDWARE,
+            "ttVM_x86" to Build.MANUFACTURER,
+            "Genymotion" to Build.MANUFACTURER,
+            "Genymotion" to Build.PRODUCT,
+            "Android SDK built for x86" to Build.MANUFACTURER,
+            "Android SDK built for x86_64" to Build.MANUFACTURER
+        )
+
+        for ((key, value) in emulatorProps) {
+            if (value.contains(key, ignoreCase = true)) {
+                return true
+            }
+        }
+
+        return false
+    }
+
+    /**
+     * Check emulator build properties
+     */
+    private fun checkEmulatorBuildProps(): Boolean {
+        // Check device model
+        val model = Build.MODEL.lowercase()
+        if (model.contains("sdk") ||
+            model.contains("google_sdk") ||
+            model.contains("emulator") ||
+            model.contains("android sdk")) {
+            return true
+        }
+
+        // Check device
+        val device = Build.DEVICE.lowercase()
+        if (device.contains("generic") ||
+            device.contains("emulator") ||
+            device.contains("sdk")) {
+            return true
+        }
+
+        // Check fingerprint
+        val fingerprint = Build.FINGERPRINT.lowercase()
+        if (fingerprint.contains("generic") ||
+            fingerprint.contains("sdk_gphone")) {
+            return true
+        }
+
+        // Check hardware
+        val hardware = Build.HARDWARE.lowercase()
+        if (hardware.contains("goldfish") ||
+            hardware.contains("ranchu") ||
+            hardware.contains("vbox")) {
+            return true
+        }
+
+        return false
+    }
+
+    /**
+     * Check for emulator-specific files
+     */
+    private fun checkEmulatorFiles(): Boolean {
+        val emulatorPaths = listOf(
+            "/dev/socket/qemud",
+            "/dev/qemu_pipe",
+            "/system/lib/libc_malloc_debug_qemu.so",
+            "/system/bin/qemu-props",
+            "/system/lib/libc_malloc_debug_qemu.so",
+            "/dev/socket/genyd",
+            "/dev/socket/baseband_genyd",
+            "/system/lib/libnim-dumo.so",
+            "/system/lib/libdum.so"
+        )
+
+        return emulatorPaths.any { File(it).exists() }
+    }
+
+    /**
+     * Check for emulator features
+     */
+    private fun checkEmulatorFeatures(): Boolean {
+        val telephonyManager = context.getSystemService(Context.TELEPHONY_SERVICE) as? TelephonyManager
+            ?: return false
+
+        // Check for invalid network operator
+        val networkOperator = telephonyManager.networkOperator
+        if (networkOperator == null || networkOperator == "000000000000000") {
+            return true
+        }
+
+        // Check for invalid subscriber ID
+        val subscriberId = telephonyManager.subscriberId
+        if (subscriberId == null || subscriberId == "000000000000000") {
+            return true
+        }
+
+        // Check for invalid IMEI/MEID
+        val deviceId = telephonyManager.deviceId
+        if (deviceId == null || deviceId == "000000000000000" || deviceId == "0") {
+            return true
+        }
+
+        return false
+    }
+
+    /**
+     * Check network interfaces for emulator indicators
+     */
+    private fun checkNetworkInterfaces(): Boolean {
+        val emulatorInterfaces = listOf(
+            "vboxnet",
+            "vnic",
+            "tun",
+            "tap"
+        )
+
+        try {
+            val interfaces = java.net.NetworkInterface.getNetworkInterfaces()
+            for (networkInterface in interfaces.toList()) {
+                val name = networkInterface.name.lowercase()
+                for (emulatorInterface in emulatorInterfaces) {
+                    if (name.contains(emulatorInterface)) {
+                        return true
+                    }
+                }
+            }
+        } catch (e: Exception) {
+            // Ignore errors
+        }
+
+        return false
+    }
+
+    /**
+     * Check camera availability (emulators often lack cameras)
+     * Note: This is just a hint, many real devices also lack cameras
+     */
+    private fun checkCamera(): Boolean {
+        return try {
+            // Check if device has camera hardware feature
+            val hasCamera = context.packageManager.hasSystemFeature(PackageManager.FEATURE_CAMERA)
+                    || context.packageManager.hasSystemFeature(PackageManager.FEATURE_CAMERA_FRONT)
+
+            // If no camera feature, might be emulator (but not guaranteed)
+            !hasCamera
+        } catch (e: Exception) {
+            // On error, assume it's not an emulator based on camera check
+            false
+        }
+    }
+
+    /**
+     * Get emulator type if detected
+     */
+    fun getEmulatorType(): String? {
+        return when {
+            Build.HARDWARE.contains("ranchu") -> "QEMU/KVM"
+            Build.HARDWARE.contains("vbox") -> "VirtualBox"
+            Build.MANUFACTURER.contains("Genymotion") -> "Genymotion"
+            Build.PRODUCT.contains("nox") -> "Nox"
+            Build.HARDWARE.contains("vmos") -> "VMOS"
+            Build.BRAND.contains("google") && Build.PRODUCT.contains("sdk") -> "Android Emulator"
+            else -> "Unknown"
+        }
+    }
+}