@akilrafeek/capacitor-jailbreak-root-detection 1.0.0

package/MeedikaCapacitorJailbreakRootDetection.podspec

@@ -0,0 +1,17 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'MeedikaCapacitorJailbreakRootDetection'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license']
+  s.homepage = package['repository']['url']
+  s.author = package['author']
+  s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
+  s.source_files = 'ios/Plugin/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.ios.deployment_target  = '13.0'
+  s.dependency 'Capacitor'
+  s.swift_version = '5.1'
+end

package/README.md

@@ -0,0 +1,78 @@
+# @meedika/capacitor-jailbreak-root-detection
+
+This is a Capacitor 6 Jailbreak Root detection plugin.
+
+## Install
+
+```bash
+npm install @meedika/capacitor-jailbreak-root-detection
+npx cap sync
+```
+
+## API
+
+<docgen-index>
+
+* [`isJailbrokenOrRooted()`](#isjailbrokenorrooted)
+* [`isSimulator()`](#issimulator)
+* [`isDebuggedMode()`](#isdebuggedmode)
+* [`exitApp()`](#exitapp)
+* [Interfaces](#interfaces)
+
+</docgen-index>
+
+<docgen-api>
+<!--Update the source file JSDoc comments and rerun docgen to update the docs below-->
+
+### isJailbrokenOrRooted()
+
+```typescript
+isJailbrokenOrRooted() => Promise<JailbreakRootResult>
+```
+
+**Returns:** <code>Promise&lt;<a href="#jailbreakrootresult">JailbreakRootResult</a>&gt;</code>
+
+--------------------
+
+
+### isSimulator()
+
+```typescript
+isSimulator() => Promise<JailbreakRootResult>
+```
+
+**Returns:** <code>Promise&lt;<a href="#jailbreakrootresult">JailbreakRootResult</a>&gt;</code>
+
+--------------------
+
+
+### isDebuggedMode()
+
+```typescript
+isDebuggedMode() => Promise<JailbreakRootResult>
+```
+
+**Returns:** <code>Promise&lt;<a href="#jailbreakrootresult">JailbreakRootResult</a>&gt;</code>
+
+--------------------
+
+
+### exitApp()
+
+```typescript
+exitApp() => void
+```
+
+--------------------
+
+
+### Interfaces
+
+
+#### JailbreakRootResult
+
+| Prop         | Type                 |
+| ------------ | -------------------- |
+| **`result`** | <code>boolean</code> |
+
+</docgen-api>

package/android/build.gradle

@@ -0,0 +1,59 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.6.1'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.1.5'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.5.1'
+}
+
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.2.1'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    namespace "com.evehr.plugins.capacitor.jailbreakrootdetection"
+    compileSdk project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 34
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 22
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 34
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    implementation 'com.scottyab:rootbeer-lib:0.1.1'
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    >
+</manifest>

package/android/src/main/java/com/evehr/plugins/capacitor/jailbreakrootdetection/CapacitorJailbreakRootDetection.java

@@ -0,0 +1,17 @@
+package com.evehr.plugins.capacitor.jailbreakrootdetection;
+
+import android.util.Log;
+
+public class CapacitorJailbreakRootDetection {
+    public boolean isJailbrokenOrRooted(boolean value) {
+        return value;
+    }
+
+    public boolean isSimulator(boolean value) {
+        return value;
+    }
+    
+    public boolean isDebuggedMode(boolean value) {
+        return value;
+    }
+}

package/android/src/main/java/com/evehr/plugins/capacitor/jailbreakrootdetection/CapacitorJailbreakRootDetectionPlugin.java

@@ -0,0 +1,66 @@
+package com.evehr.plugins.capacitor.jailbreakrootdetection;
+
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+
+import android.content.Context;
+
+import com.evehr.plugins.capacitor.jailbreakrootdetection.Rooted.RootedCheck;
+import com.evehr.plugins.capacitor.jailbreakrootdetection.Rooted.EmulatorDetector;
+
+@CapacitorPlugin(name = "CapacitorJailbreakRootDetection")
+public class CapacitorJailbreakRootDetectionPlugin extends Plugin {
+    private CapacitorJailbreakRootDetection implementation = new CapacitorJailbreakRootDetection();
+    private RootedCheck rootedCheck;
+    private EmulatorDetector emulatorDetector;
+
+    @Override
+    public void load() {
+        rootedCheck = new RootedCheck(getContext());
+        emulatorDetector = new EmulatorDetector(getContext());
+    }
+
+    @PluginMethod
+    public void isJailbrokenOrRooted(PluginCall call) {
+        boolean result = rootedCheck.isJailBroken();
+
+        JSObject ret = new JSObject();
+        ret.put("result", implementation.isJailbrokenOrRooted(result));
+        call.resolve(ret);
+    }
+    
+    
+    @PluginMethod
+    public void isSimulator(PluginCall call) {
+        boolean result = emulatorDetector.isEmulator();
+
+        JSObject ret = new JSObject();
+        ret.put("result", implementation.isSimulator(result));
+        call.resolve(ret);
+    }
+    
+    
+    @PluginMethod
+    public void isDebuggedMode(PluginCall call) {
+        boolean result = emulatorDetector.isDebuggedMode();
+
+        JSObject ret = new JSObject();
+        ret.put("result", implementation.isDebuggedMode(result));
+        call.resolve(ret);
+    }
+
+    @PluginMethod
+    public void exitApp(PluginCall call) {
+        unsetAppListeners();
+        call.resolve();
+        getBridge().getActivity().finish();
+    }
+
+    private void unsetAppListeners() {
+        bridge.getApp().setStatusChangeListener(null);
+        bridge.getApp().setAppRestoredListener(null);
+    }
+}

package/android/src/main/java/com/evehr/plugins/capacitor/jailbreakrootdetection/Rooted/CheckApiVersion.java

@@ -0,0 +1,5 @@
+package com.evehr.plugins.capacitor.jailbreakrootdetection.Rooted;
+
+public interface CheckApiVersion {
+    boolean checkRooted();
+}

package/android/src/main/java/com/evehr/plugins/capacitor/jailbreakrootdetection/Rooted/EmulatorDetector.java

@@ -0,0 +1,162 @@
+package com.evehr.plugins.capacitor.jailbreakrootdetection.Rooted;
+
+import android.content.Context;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import android.provider.Settings;
+import android.telephony.TelephonyManager;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.InputStreamReader;
+
+public class EmulatorDetector {
+
+    private final Context context;
+
+    public EmulatorDetector(Context ctx) {
+        context = ctx;
+    }
+
+    public boolean isEmulator() {
+        return (
+            checkBuildProperties() ||
+            checkEmulatorFiles() ||
+            checkTelephonyManager() ||
+            checkPipes() ||
+            checkQEmuDriverFile() ||
+            checkQEmuProps()
+        );
+    }
+
+    public boolean isDebuggedMode() {
+        boolean result = false;
+        try {
+            if ((context.getPackageManager().getPackageInfo(context.getPackageName(), 0).
+                    applicationInfo.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0)
+                result = true;
+            else
+                result = false;
+        } catch (PackageManager.NameNotFoundException e) {
+            result = false;
+        }
+
+        return result;
+    }
+
+    private boolean checkBuildProperties() {
+        String[] knownEmulatorBuildProperties = {
+            "ro.hardware",
+            "goldfish",
+            "ro.hardware",
+            "ranchu",
+            "ro.kernel.qemu",
+            "1",
+            "ro.product.model",
+            "sdk",
+            "ro.product.model",
+            "google_sdk",
+            "ro.product.model",
+            "sdk_x86",
+            "ro.product.model",
+            "vbox86p"
+        };
+
+        for (int i = 0; i < knownEmulatorBuildProperties.length; i += 2) {
+            String property = knownEmulatorBuildProperties[i];
+            String value = knownEmulatorBuildProperties[i + 1];
+            if (value.equals(getSystemProperty(property))) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean checkEmulatorFiles() {
+        String[] knownEmulatorFiles = {
+            "/dev/socket/qemud",
+            "/dev/qemu_pipe",
+            "/system/lib/libc_malloc_debug_qemu.so",
+            "/sys/qemu_trace",
+            "/system/bin/qemu-props"
+        };
+
+        for (String path : knownEmulatorFiles) {
+            if (new File(path).exists()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean checkTelephonyManager() {
+        TelephonyManager tm = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
+        String networkOperatorName = tm.getNetworkOperatorName();
+        return "Android".equalsIgnoreCase(networkOperatorName);
+    }
+
+    private boolean checkPipes() {
+        String[] knownEmulatorPipes = { "/dev/socket/qemud", "/dev/qemu_pipe" };
+
+        for (String path : knownEmulatorPipes) {
+            if (new File(path).exists()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean checkQEmuDriverFile() {
+        File driverFile = new File("/proc/tty/driver");
+        if (driverFile.exists() && driverFile.canRead()) {
+            byte[] data = new byte[(int) driverFile.length()];
+            try {
+                String driverData = new BufferedReader(new InputStreamReader(new FileInputStream(driverFile))).readLine();
+                return driverData.contains("goldfish") || driverData.contains("qemu");
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+        return false;
+    }
+
+    private boolean checkQEmuProps() {
+        int minQemuProps = 6;
+        String[] knownQemuProps = {
+            "ro.product.device",
+            "qemu",
+            "ro.product.brand",
+            "generic",
+            "ro.product.manufacturer",
+            "unknown",
+            "ro.product.model",
+            "sdk",
+            "ro.hardware",
+            "goldfish",
+            "ro.hardware",
+            "ranchu"
+        };
+
+        int matchCount = 0;
+        for (int i = 0; i < knownQemuProps.length; i += 2) {
+            String property = knownQemuProps[i];
+            String value = knownQemuProps[i + 1];
+            if (value.equals(getSystemProperty(property))) {
+                matchCount++;
+            }
+        }
+        return matchCount >= minQemuProps;
+    }
+
+    private String getSystemProperty(String propertyName) {
+        String propertyValue = "";
+        try {
+            Class<?> systemPropertyClazz = Class.forName("android.os.SystemProperties");
+            propertyValue = (String) systemPropertyClazz.getMethod("get", String.class).invoke(systemPropertyClazz, propertyName);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return propertyValue;
+    }
+}

package/android/src/main/java/com/evehr/plugins/capacitor/jailbreakrootdetection/Rooted/GreaterThan23.java

@@ -0,0 +1,44 @@
+package com.evehr.plugins.capacitor.jailbreakrootdetection.Rooted;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.InputStreamReader;
+
+public class GreaterThan23 implements CheckApiVersion {
+
+    @Override
+    public boolean checkRooted() {
+        return checkRootMethod1() || checkRootMethod2();
+    }
+
+    private boolean checkRootMethod1() {
+        String[] paths = {
+                "/system/app/Superuser.apk",
+                "/sbin/su",
+                "/system/bin/su",
+                "/system/xbin/su",
+                "/data/local/xbin/su",
+                "/data/local/bin/su",
+                "/system/sd/xbin/su",
+                "/system/bin/failsafe/su",
+                "/data/local/su"};
+        for (String path : paths) {
+            if (new File(path).exists()) return true;
+        }
+        return false;
+    }
+
+    private boolean checkRootMethod2() {
+        Process process = null;
+        try {
+            process = Runtime.getRuntime().exec(new String[] { "/system/xbin/which", "su" });
+            BufferedReader in = new BufferedReader(new InputStreamReader(process.getInputStream()));
+            if (in.readLine() != null) return true;
+            return false;
+        } catch (Throwable t) {
+            return false;
+        } finally {
+            if (process != null) process.destroy();
+        }
+    }
+}

package/android/src/main/java/com/evehr/plugins/capacitor/jailbreakrootdetection/Rooted/LessThan23.java

@@ -0,0 +1,50 @@
+package com.evehr.plugins.capacitor.jailbreakrootdetection.Rooted;
+
+import java.io.File;
+
+public class LessThan23 implements CheckApiVersion {
+    @Override
+    public boolean checkRooted() {
+        return canExecuteCommand("/system/xbin/which su") || isSuperuserPresent();
+    }
+
+    // executes a command on the system
+    private static boolean canExecuteCommand(String command) {
+        boolean executeResult;
+        try {
+            Process process = Runtime.getRuntime().exec(command);
+            if(process.waitFor() == 0) {
+                executeResult = true;
+            } else {
+                executeResult = false;
+            }
+        } catch (Exception e) {
+            executeResult = false;
+        }
+
+        return executeResult;
+    }
+
+    private static boolean isSuperuserPresent() {
+        // Check if /system/app/Superuser.apk is present
+        String[] paths = {
+                "/system/app/Superuser.apk",
+                "/sbin/su",
+                "/system/bin/su",
+                "/system/xbin/su",
+                "/data/local/xbin/su",
+                "/data/local/bin/su",
+                "/system/sd/xbin/su",
+                "/system/bin/failsafe/su",
+                "/data/local/su"
+        };
+
+        for (String path : paths) {
+            if (new File(path).exists()) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

package/android/src/main/java/com/evehr/plugins/capacitor/jailbreakrootdetection/Rooted/RootedCheck.java

@@ -0,0 +1,89 @@
+package com.evehr.plugins.capacitor.jailbreakrootdetection.Rooted;
+
+import android.content.Context;
+import com.scottyab.rootbeer.RootBeer;
+import java.util.HashMap;
+import java.util.Map;
+
+public class RootedCheck {
+    private static boolean checkWithJailMonkeyMethod() {
+        CheckApiVersion check;
+
+        if (android.os.Build.VERSION.SDK_INT >= 23) {
+            check = new GreaterThan23();
+        } else {
+            check = new LessThan23();
+        }
+        return check.checkRooted();
+    }
+
+    private final boolean jailMonkeyResult;
+    private final RootBeerResults rootBeerResults;
+
+    public RootedCheck(Context context) {
+        jailMonkeyResult = checkWithJailMonkeyMethod();
+        rootBeerResults = new RootBeerResults(context);
+    }
+
+    public boolean isJailBroken() {
+        return jailMonkeyResult || rootBeerResults.isJailBroken();
+    }
+
+    public Map<String, Object> getResultByDetectionMethod() {
+        final Map<String, Object> map = new HashMap<>();
+
+        map.put("jailMonkey", jailMonkeyResult);
+        map.put("rootBeer", rootBeerResults.toNativeMap());
+
+        return map;
+    }
+
+    private static class RootBeerResults {
+        private final boolean detectRootManagementApps;
+        private final boolean detectPotentiallyDangerousApps;
+        private final boolean checkForSuBinary;
+        private final boolean checkForDangerousProps;
+        private final boolean checkForRWPaths;
+        private final boolean detectTestKeys;
+        private final boolean checkSuExists;
+        private final boolean checkForRootNative;
+        private final boolean checkForMagiskBinary;
+
+        RootBeerResults(Context context) {
+            final RootBeer rootBeer = new RootBeer(context);
+            rootBeer.setLogging(false);
+
+            detectRootManagementApps = rootBeer.detectRootManagementApps();
+            detectPotentiallyDangerousApps = rootBeer.detectPotentiallyDangerousApps();
+            checkForSuBinary = rootBeer.checkForSuBinary();
+            checkForDangerousProps = rootBeer.checkForDangerousProps();
+            checkForRWPaths = rootBeer.checkForRWPaths();
+            detectTestKeys = rootBeer.detectTestKeys();
+            checkSuExists = rootBeer.checkSuExists();
+            checkForRootNative = rootBeer.checkForRootNative();
+            checkForMagiskBinary = rootBeer.checkForMagiskBinary();
+        }
+
+        public boolean isJailBroken() {
+            return detectRootManagementApps || detectPotentiallyDangerousApps || checkForSuBinary
+                    || checkForDangerousProps || checkForRWPaths
+                    || detectTestKeys || checkSuExists || checkForRootNative || checkForMagiskBinary;
+        }
+
+        public Map<String, Object> toNativeMap() {
+            final Map<String, Object> map = new HashMap<>();
+
+            map.put("detectRootManagementApps", detectRootManagementApps);
+            map.put("detectPotentiallyDangerousApps", detectPotentiallyDangerousApps);
+            map.put("checkForSuBinary", checkForSuBinary);
+            map.put("checkForDangerousProps", checkForDangerousProps);
+            map.put("checkForRWPaths", checkForRWPaths);
+            map.put("detectTestKeys", detectTestKeys);
+            map.put("checkSuExists", checkSuExists);
+            map.put("checkForRootNative", checkForRootNative);
+            map.put("checkForMagiskBinary", checkForMagiskBinary);
+
+            return map;
+        }
+    }
+}

package/dist/docs.json

@@ -0,0 +1,78 @@
+{
+  "api": {
+    "name": "CapacitorJailbreakRootDetectionPlugin",
+    "slug": "capacitorjailbreakrootdetectionplugin",
+    "docs": "",
+    "tags": [],
+    "methods": [
+      {
+        "name": "isJailbrokenOrRooted",
+        "signature": "() => Promise<JailbreakRootResult>",
+        "parameters": [],
+        "returns": "Promise<JailbreakRootResult>",
+        "tags": [],
+        "docs": "",
+        "complexTypes": [
+          "JailbreakRootResult"
+        ],
+        "slug": "isjailbrokenorrooted"
+      },
+      {
+        "name": "isSimulator",
+        "signature": "() => Promise<JailbreakRootResult>",
+        "parameters": [],
+        "returns": "Promise<JailbreakRootResult>",
+        "tags": [],
+        "docs": "",
+        "complexTypes": [
+          "JailbreakRootResult"
+        ],
+        "slug": "issimulator"
+      },
+      {
+        "name": "isDebuggedMode",
+        "signature": "() => Promise<JailbreakRootResult>",
+        "parameters": [],
+        "returns": "Promise<JailbreakRootResult>",
+        "tags": [],
+        "docs": "",
+        "complexTypes": [
+          "JailbreakRootResult"
+        ],
+        "slug": "isdebuggedmode"
+      },
+      {
+        "name": "exitApp",
+        "signature": "() => void",
+        "parameters": [],
+        "returns": "void",
+        "tags": [],
+        "docs": "",
+        "complexTypes": [],
+        "slug": "exitapp"
+      }
+    ],
+    "properties": []
+  },
+  "interfaces": [
+    {
+      "name": "JailbreakRootResult",
+      "slug": "jailbreakrootresult",
+      "docs": "",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "result",
+          "tags": [],
+          "docs": "",
+          "complexTypes": [],
+          "type": "boolean"
+        }
+      ]
+    }
+  ],
+  "enums": [],
+  "typeAliases": [],
+  "pluginConfigs": []
+}

package/dist/esm/definitions.d.ts

@@ -0,0 +1,9 @@
+export interface CapacitorJailbreakRootDetectionPlugin {
+    isJailbrokenOrRooted(): Promise<JailbreakRootResult>;
+    isSimulator(): Promise<JailbreakRootResult>;
+    isDebuggedMode(): Promise<JailbreakRootResult>;
+    exitApp(): void;
+}
+export interface JailbreakRootResult {
+    result: boolean;
+}