react-native-rootbeer-checkroot 0.1.0

package/src/NativeRootBeer.ts

@@ -0,0 +1,44 @@
+import { TurboModuleRegistry, type TurboModule } from 'react-native';
+
+export interface Spec extends TurboModule {
+  /** Runs all RootBeer checks (includes BusyBox check). */
+  isRooted(): boolean;
+
+  /** Runs all RootBeer checks except the BusyBox check. */
+  isRootedWithoutBusyBoxCheck(): boolean;
+
+  /** Checks for the presence of known potentially-dangerous rooting apps. */
+  detectPotentiallyDangerousApps(): boolean;
+
+  /** Checks for the presence of known root management apps (e.g. SuperSU, Magisk Manager). */
+  detectRootManagementApps(): boolean;
+
+  /** Checks if the device is running a test-keys build (non-official ROM). */
+  detectTestKeys(): boolean;
+
+  /**
+   * Checks for the presence of a specific binary (e.g. "su", "busybox").
+   * @param binaryName - The name of the binary to look for.
+   */
+  checkForBinary(binaryName: string): boolean;
+
+  /** Checks for dangerous system properties that indicate rooting. */
+  checkForDangerousProps(): boolean;
+
+  /** Checks for writable paths that should be read-only on a stock device. */
+  checkForRWPaths(): boolean;
+
+  /** Checks for the presence of known root-cloaking apps (e.g. RootCloak). */
+  detectRootCloakingApps(): boolean;
+
+  /** Attempts to execute `su` and checks whether it succeeds. */
+  checkSuExists(): boolean;
+
+  /** Scans common binary paths for the `su` binary. */
+  checkForSuBinary(): boolean;
+
+  /** Scans common binary paths for the Magisk binary. */
+  checkForMagiskBinary(): boolean;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('RootBeer');

package/src/RootBeer.ts

@@ -0,0 +1,118 @@
+import NativeRootBeer from './NativeRootBeer';
+
+/**
+ * A wrapper around the RootBeer Android root-detection library.
+ * All methods call through to `com.scottyab:rootbeer-lib` via JSI.
+ *
+ * On iOS (or any non-Android platform) these methods will throw because
+ * the TurboModule is enforcing — guard calls with `Platform.OS === 'android'`
+ * if cross-platform support is needed.
+ *
+ * @example
+ * ```ts
+ * import { Platform } from 'react-native';
+ * import { RootBeer } from 'react-native-root-beer';
+ *
+ * if (Platform.OS === 'android') {
+ *   const rooted = RootBeer.isRooted();
+ *   console.log('Device is rooted:', rooted);
+ * }
+ * ```
+ */
+export const RootBeer = {
+  /**
+   * Runs all RootBeer checks (includes BusyBox check).
+   * This is the main high-level check — prefer this for most use cases.
+   */
+  isRooted(): boolean {
+    return NativeRootBeer.isRooted();
+  },
+
+  /**
+   * Runs all RootBeer checks except the BusyBox check.
+   * Use this if BusyBox false-positives are a concern in your environment.
+   */
+  isRootedWithoutBusyBoxCheck(): boolean {
+    return NativeRootBeer.isRootedWithoutBusyBoxCheck();
+  },
+
+  /**
+   * Checks for the presence of known potentially-dangerous rooting apps
+   * (e.g. apps that typically accompany root access).
+   */
+  detectPotentiallyDangerousApps(): boolean {
+    return NativeRootBeer.detectPotentiallyDangerousApps();
+  },
+
+  /**
+   * Checks for the presence of known root management apps
+   * (e.g. SuperSU, Magisk Manager, KingRoot).
+   */
+  detectRootManagementApps(): boolean {
+    return NativeRootBeer.detectRootManagementApps();
+  },
+
+  /**
+   * Checks if the device build is signed with test-keys instead of
+   * release-keys. Test-key builds typically indicate a custom/rooted ROM.
+   */
+  detectTestKeys(): boolean {
+    return NativeRootBeer.detectTestKeys();
+  },
+
+  /**
+   * Checks for the presence of a specific binary by scanning common paths.
+   * @param binaryName - The binary to search for, e.g. `"su"`, `"busybox"`.
+   */
+  checkForBinary(binaryName: string): boolean {
+    return NativeRootBeer.checkForBinary(binaryName);
+  },
+
+  /**
+   * Checks for dangerous system properties that are commonly set on rooted
+   * devices (e.g. `ro.debuggable=1`, `ro.secure=0`).
+   */
+  checkForDangerousProps(): boolean {
+    return NativeRootBeer.checkForDangerousProps();
+  },
+
+  /**
+   * Checks for file-system paths that should be read-only on a stock device
+   * but are mounted as read-write — a strong indicator of root access.
+   */
+  checkForRWPaths(): boolean {
+    return NativeRootBeer.checkForRWPaths();
+  },
+
+  /**
+   * Checks for the presence of known root-cloaking apps (e.g. RootCloak,
+   * Hide My Root) that try to hide root from other apps.
+   */
+  detectRootCloakingApps(): boolean {
+    return NativeRootBeer.detectRootCloakingApps();
+  },
+
+  /**
+   * Attempts to execute `su` and returns `true` if it succeeds.
+   * This is a runtime probe rather than a static file check.
+   */
+  checkSuExists(): boolean {
+    return NativeRootBeer.checkSuExists();
+  },
+
+  /**
+   * Scans a list of well-known binary paths for the `su` executable.
+   * Less invasive than `checkSuExists()` as it doesn't execute anything.
+   */
+  checkForSuBinary(): boolean {
+    return NativeRootBeer.checkForSuBinary();
+  },
+
+  /**
+   * Scans common binary paths for the Magisk binary.
+   * Useful for detecting Magisk-based root even when it hides itself.
+   */
+  checkForMagiskBinary(): boolean {
+    return NativeRootBeer.checkForMagiskBinary();
+  },
+} as const;

package/src/index.tsx

@@ -0,0 +1 @@
+export { RootBeer } from './RootBeer';