react-native-device-defense 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 OSP
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,236 @@
+# react-native-device-security
+
+> Multi-layer device security detection for React Native - Root detection, Anti-hook, Anti-debug, Emulator detection
+
+## Features
+
+- ✅ **Multi-layer Root Detection** - Detect rooted devices using multiple techniques
+- 🔒 **Native C++ Detection** - Harder to bypass with JavaScript hooks
+- 🎣 **Frida/Xposed Detection** - Detect common hooking frameworks
+- 🐛 **Anti-Debug** - Detect debugger attachment
+- 📱 **Emulator Detection** - Detect Android emulators
+- 🛡️ **App Integrity Check** - Verify app signature and tampering
+- 🔐 **Block on Security Threat** - Automatically block app when security issues detected
+
+## Installation
+
+```bash
+npm install react-native-device-security
+# or
+yarn add react-native-device-security
+```
+
+## Android Setup
+
+1. Add to `android/settings.gradle`:
+
+```gradle
+include ':react-native-device-security'
+project(':react-native-device-security').projectDir = new File(rootProject.projectDir, '../node_modules/react-native-device-security/android')
+```
+
+2. Add to `android/app/build.gradle`:
+
+```gradle
+dependencies {
+    implementation project(':react-native-device-security')
+}
+```
+
+3. Add to `MainApplication.java`:
+
+```java
+import vn.osp.security.DeviceSecurityPackage;
+
+@Override
+protected List<ReactPackage> getPackages() {
+    return Arrays.<ReactPackage>asList(
+        // ... other packages
+        new DeviceSecurityPackage()
+    );
+}
+```
+
+## Usage
+
+### Basic Usage
+
+```typescript
+import DeviceSecurity from 'react-native-device-security';
+
+// Check if device is secure
+const isSecure = await DeviceSecurity.isDeviceSecure();
+
+if (!isSecure) {
+  // Device is rooted, has hooks, or other security issues
+  Alert.alert(
+    'Security Warning',
+    'This device is not secure. The app cannot run on rooted or modified devices.',
+    [{ text: 'OK', onPress: () => BackHandler.exitApp() }]
+  );
+}
+```
+
+### Advanced Usage with Hook
+
+```typescript
+import { useDeviceSecurity } from 'react-native-device-security';
+
+function App() {
+  const { isSecure, securityStatus, isLoading } = useDeviceSecurity({
+    onSecurityThreat: (threat) => {
+      console.log('Security threat detected:', threat);
+      // Handle security threat - block app, show alert, etc.
+    },
+    blockOnThreat: true, // Block app when security threat detected
+  });
+
+  if (isLoading) {
+    return <LoadingScreen />;
+  }
+
+  if (!isSecure) {
+    return <SecurityBlockedScreen threats={securityStatus.threats} />;
+  }
+
+  return <MainApp />;
+}
+```
+
+### Security Status Details
+
+```typescript
+const status = await DeviceSecurity.getSecurityStatus();
+
+console.log({
+  isSecure: status.isSecure,
+  isRooted: status.isRooted,
+  hasRootBeerDetected: status.hasRootBeerDetected,
+  hasNativeRootDetected: status.hasNativeRootDetected,
+  hasDangerousBins: status.hasDangerousBins,
+  hasRootApps: status.hasRootApps,
+  hasSystemPropsModified: status.hasSystemPropsModified,
+  hasFrida: status.hasFrida,
+  hasXposed: status.hasXposed,
+  hasMagisk: status.hasMagisk,
+  isDebuggable: status.isDebuggable,
+  isEmulator: status.isEmulator,
+});
+```
+
+### Block on Security Threat (Recommended for Production)
+
+```typescript
+import DeviceSecurity from 'react-native-device-security';
+
+// In your app entry point
+DeviceSecurity.blockOnSecurityThreat({
+  showAlert: true,
+  alertTitle: 'Cảnh báo bảo mật',
+  alertMessage: 'Thiết bị của bạn không an toàn. Ứng dụng không thể chạy trên thiết bị đã root hoặc có sửa đổi.',
+  onBlocked: () => {
+    // Optional callback when app is blocked
+    console.log('App blocked due to security threat');
+  }
+});
+```
+
+## API Reference
+
+### Methods
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `isDeviceSecure()` | `Promise<boolean>` | Check if device is secure (no threats) |
+| `getSecurityStatus()` | `Promise<SecurityStatus>` | Get detailed security status |
+| `blockOnSecurityThreat(options)` | `void` | Block app when security threat detected |
+| `isRooted()` | `boolean` | Check if device is rooted (synchronous) |
+| `hasFrida()` | `boolean` | Check if Frida is present |
+| `hasXposed()` | `boolean` | Check if Xposed framework is present |
+| `hasMagisk()` | `boolean` | Check if Magisk is present |
+| `isDebuggable()` | `boolean` | Check if app is debuggable |
+| `isEmulator()` | `boolean` | Check if running on emulator |
+
+### Types
+
+```typescript
+interface SecurityStatus {
+  isSecure: boolean;
+  threats: SecurityThreat[];
+  isRooted: boolean;
+  hasRootBeerDetected: boolean;
+  hasNativeRootDetected: boolean;
+  hasDangerousBins: boolean;
+  hasRootApps: boolean;
+  hasSystemPropsModified: boolean;
+  hasFrida: boolean;
+  hasXposed: boolean;
+  hasMagisk: boolean;
+  isDebuggable: boolean;
+  isEmulator: boolean;
+}
+
+type SecurityThreat =
+  | 'root_detected'
+  | 'frida_detected'
+  | 'xposed_detected'
+  | 'magisk_detected'
+  | 'debugger_detected'
+  | 'emulator_detected'
+  | 'system_props_modified';
+```
+
+## Configuration
+
+### ProGuard/R8 Rules
+
+Add to `android/app/proguard-rules.pro`:
+
+```proguard
+# Device Security Library
+-keep class vn.osp.security.** { *; }
+-keepclassmembers class vn.osp.security.** { *; }
+-dontwarn vn.osp.security.**
+```
+
+## Security Techniques
+
+### Root Detection
+- RootBeer library checks
+- Native C++ checks (JNI)
+- System properties (`ro.debuggable`, `ro.secure`)
+- Dangerous binaries (`su`, `busybox`, `magisk`)
+- Root management apps detection
+- Mount point checks (`/system`, `/vendor` RW)
+
+### Hook Detection
+- Frida port scanning (27042, 27043)
+- Frida library detection
+- Xposed framework detection
+- Magisk module detection
+
+### Anti-Debug
+- `Debug.isDebuggerConnected()` check
+- Tracer PID in `/proc/self/status`
+- Timing analysis
+
+### Emulator Detection
+- Known emulator properties
+- Generic device features
+- Genymotion, Nox, BlueStacks detection
+
+## License
+
+MIT
+
+## Author
+
+OSP <dev@osp.vn>
+
+## Contributing
+
+Pull requests are welcome!
+
+## Support
+
+For issues and questions, please open a GitHub issue.

package/android/build.gradle

@@ -0,0 +1,90 @@
+def safelyConfigureGetPackages() {
+  def packagesConfigured = false
+  gradle.afterProject { project ->
+    if (!packagesConfigured && project.hasProperty('android')) {
+      packagesConfigured = true
+      project.android.packagingOptions.jniLibs.useLegacyPackaging = false
+    }
+  }
+}
+
+safelyConfigureGetPackages()
+
+buildscript {
+  ext.safeExtGet = { prop, fallback ->
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+  }
+  repositories {
+    google()
+    mavenCentral()
+  }
+  dependencies {
+    classpath('com.android.tools.build:gradle:7.4.2')
+  }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'com.facebook.react'
+
+android {
+  ndkVersion rootProject.ext.ndkVersion
+  compileSdkVersion safeExtGet('compileSdkVersion', 34)
+
+  namespace "vn.osp.security"
+
+  defaultConfig {
+    minSdkVersion safeExtGet('minSdkVersion', 21)
+    targetSdkVersion safeExtGet('targetSdkVersion', 34)
+    versionCode 1
+    versionName "1.0.0"
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-O2 -frtti -fexceptions -Wall -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared",
+                  "-DANDROID_ARM_NEON=TRUE"
+      }
+    }
+
+    ndk {
+      abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86', 'x86_64'
+    }
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+      proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+    }
+    debug {
+      minifyEnabled false
+      proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "src/main/cpp/CMakeLists.txt"
+      version "3.22.1"
+    }
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+}
+
+dependencies {
+  implementation 'com.facebook.react:react-native:+'
+
+  // RootBeer for root detection
+  implementation 'com.scottyab:rootbeer:0.1.0'
+
+  testImplementation 'junit:junit:4.13.2'
+  testImplementation 'org.mockito:mockito-core:5.3.1'
+}

package/android/proguard-rules.pro

@@ -0,0 +1,28 @@
+# React Native Device Security - ProGuard/R8 Rules
+
+# Keep all native methods
+-keepclassmembers class vn.osp.security.** {
+    native <methods>;
+}
+
+# Keep the entire module
+-keep class vn.osp.security.** { *; }
+-keep interface vn.osp.security.** { *; }
+
+# Keep enum classes
+-keepclassmembers enum vn.osp.security.** {
+    *[];
+}
+
+# Don't warn about missing classes
+-dontwarn vn.osp.security.**
+
+# Obfuscate but keep critical method names for native calls
+-keep class vn.osp.security.NativeSecurityCheck {
+    public static boolean isRooted();
+    public static boolean hasDangerousBinaries();
+    public static boolean hasSuspiciousSystemProperties();
+    public static boolean hasHookFramework();
+    public static boolean isDebuggerAttached();
+    public static java.lang.String getSecurityStatus();
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest package="vn.osp.security">
+    <!-- No permissions needed for security checks -->
+</manifest>

package/android/src/main/cpp/CMakeLists.txt

@@ -0,0 +1,45 @@
+cmake_minimum_required(VERSION 3.22.1)
+project("device-security")
+
+# Set C++ standard
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Define source files
+set(SOURCE_FILES
+    device-security.cpp
+)
+
+# Build shared library
+add_library(device-security SHARED ${SOURCE_FILES})
+
+# Find required libraries
+find_library(log-lib log)
+
+# Link libraries
+target_link_libraries(device-security
+    ${log-lib}
+)
+
+# Compiler flags for security and obfuscation
+target_compile_options(device-security PRIVATE
+    -fvisibility=hidden
+    -fdata-sections
+    -ffunction-sections
+    -Wall
+    -Wextra
+    -O2
+)
+
+# Linker flags
+target_link_options(device-security PRIVATE
+    -Wl,--gc-sections
+    -Wl,-s
+)
+
+# Strip symbols in release
+if(CMAKE_BUILD_TYPE MATCHES Release)
+    add_custom_command(TARGET device-security POST_BUILD
+        COMMAND ${CMAKE_STRIP} --strip-unneeded $<TARGET_FILE:device-security>
+    )
+endif()