react-native-device-defense 1.0.0

package/lib/typescript/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * react-native-device-security
+ *
+ * Main exports for the library
+ */
+export { default as DeviceSecurity, DeviceSecurity as DeviceSecurityClass } from './api';
+export { default } from './api';
+export { default as NativeDeviceSecurity } from './NativeDeviceSecurity';
+export { useDeviceSecurity } from './hooks';
+export { SecurityBlockedScreen } from './components';
+export type { SecurityStatus, SecurityThreat, BlockOnSecurityThreatOptions, UseDeviceSecurityOptions, UseDeviceSecurityReturn, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,cAAc,IAAI,mBAAmB,EAAE,MAAM,OAAO,CAAC;AACzF,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAGhC,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAGzE,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAG5C,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAGrD,YAAY,EACV,cAAc,EACd,cAAc,EACd,4BAA4B,EAC5B,wBAAwB,EACxB,uBAAuB,GACxB,MAAM,SAAS,CAAC"}

package/lib/typescript/types.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Security threat types
+ */
+export type SecurityThreat = 'root_detected' | 'root_beer_detected' | 'native_root_detected' | 'dangerous_bins_detected' | 'root_apps_detected' | 'system_props_modified' | 'frida_detected' | 'xposed_detected' | 'magisk_detected' | 'debugger_detected' | 'emulator_detected';
+/**
+ * Detailed security status
+ */
+export interface SecurityStatus {
+    /** Overall security status */
+    isSecure: boolean;
+    /** List of detected threats */
+    threats: SecurityThreat[];
+    /** Device is rooted */
+    isRooted: boolean;
+    /** RootBeer library detected root */
+    hasRootBeerDetected: boolean;
+    /** Native C++ detection found root */
+    hasNativeRootDetected: boolean;
+    /** Dangerous binaries found */
+    hasDangerousBins: boolean;
+    /** Root management apps found */
+    hasRootApps: boolean;
+    /** System properties modified */
+    hasSystemPropsModified: boolean;
+    /** Frida framework detected */
+    hasFrida: boolean;
+    /** Xposed framework detected */
+    hasXposed: boolean;
+    /** Magisk detected */
+    hasMagisk: boolean;
+    /** Debugger is attached */
+    isDebuggable: boolean;
+    /** Running on emulator */
+    isEmulator: boolean;
+    /** Additional details about detection */
+    details?: Record<string, boolean | string | number>;
+}
+/**
+ * Options for blocking on security threat
+ */
+export interface BlockOnSecurityThreatOptions {
+    /** Show alert to user when blocked */
+    showAlert?: boolean;
+    /** Custom alert title (default: 'Security Warning') */
+    alertTitle?: string;
+    /** Custom alert message */
+    alertMessage?: string;
+    /** Alert button text (default: 'OK') */
+    alertButtonText?: string;
+    /** Callback when app is blocked */
+    onBlocked?: (status: SecurityStatus) => void;
+}
+/**
+ * Hook options
+ */
+export interface UseDeviceSecurityOptions {
+    /** Callback when security threat detected */
+    onSecurityThreat?: (threat: SecurityThreat, status: SecurityStatus) => void;
+    /** Block app when threat detected */
+    blockOnThreat?: boolean;
+    /** Custom block options */
+    blockOptions?: BlockOnSecurityThreatOptions;
+    /** Check interval in ms (default: 0 - check once) */
+    checkInterval?: number;
+}
+/**
+ * Hook return value
+ */
+export interface UseDeviceSecurityReturn {
+    /** Device is secure */
+    isSecure: boolean | null;
+    /** Loading state */
+    isLoading: boolean;
+    /** Security status details */
+    securityStatus: SecurityStatus | null;
+    /** Error if any */
+    error: Error | null;
+    /** Manually re-check security */
+    recheck: () => Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,cAAc,GACtB,eAAe,GACf,oBAAoB,GACpB,sBAAsB,GACtB,yBAAyB,GACzB,oBAAoB,GACpB,uBAAuB,GACvB,gBAAgB,GAChB,iBAAiB,GACjB,iBAAiB,GACjB,mBAAmB,GACnB,mBAAmB,CAAC;AAExB;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,8BAA8B;IAC9B,QAAQ,EAAE,OAAO,CAAC;IAClB,+BAA+B;IAC/B,OAAO,EAAE,cAAc,EAAE,CAAC;IAC1B,uBAAuB;IACvB,QAAQ,EAAE,OAAO,CAAC;IAClB,qCAAqC;IACrC,mBAAmB,EAAE,OAAO,CAAC;IAC7B,sCAAsC;IACtC,qBAAqB,EAAE,OAAO,CAAC;IAC/B,+BAA+B;IAC/B,gBAAgB,EAAE,OAAO,CAAC;IAC1B,iCAAiC;IACjC,WAAW,EAAE,OAAO,CAAC;IACrB,iCAAiC;IACjC,sBAAsB,EAAE,OAAO,CAAC;IAChC,+BAA+B;IAC/B,QAAQ,EAAE,OAAO,CAAC;IAClB,gCAAgC;IAChC,SAAS,EAAE,OAAO,CAAC;IACnB,sBAAsB;IACtB,SAAS,EAAE,OAAO,CAAC;IACnB,2BAA2B;IAC3B,YAAY,EAAE,OAAO,CAAC;IACtB,0BAA0B;IAC1B,UAAU,EAAE,OAAO,CAAC;IACpB,yCAAyC;IACzC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC,CAAC;CACrD;AAED;;GAEG;AACH,MAAM,WAAW,4BAA4B;IAC3C,sCAAsC;IACtC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,uDAAuD;IACvD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2BAA2B;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,wCAAwC;IACxC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mCAAmC;IACnC,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,IAAI,CAAC;CAC9C;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,6CAA6C;IAC7C,gBAAgB,CAAC,EAAE,CAAC,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,cAAc,KAAK,IAAI,CAAC;IAC5E,qCAAqC;IACrC,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,2BAA2B;IAC3B,YAAY,CAAC,EAAE,4BAA4B,CAAC;IAC5C,qDAAqD;IACrD,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,uBAAuB;IACvB,QAAQ,EAAE,OAAO,GAAG,IAAI,CAAC;IACzB,oBAAoB;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,8BAA8B;IAC9B,cAAc,EAAE,cAAc,GAAG,IAAI,CAAC;IACtC,mBAAmB;IACnB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,iCAAiC;IACjC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B"}

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "react-native-device-defense",
+  "version": "1.0.0",
+  "description": "Multi-layer device security detection for React Native (root, hook, debugger, emulator detection)",
+  "main": "lib/commonjs/index.js",
+  "module": "lib/module/index.js",
+  "types": "lib/typescript/index.d.ts",
+  "react-native": "src/index.ts",
+  "source": "src/index.ts",
+  "files": [
+    "src",
+    "lib",
+    "android",
+    "ios",
+    "react-native-device-security.podspec",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__"
+  ],
+  "keywords": [
+    "react-native",
+    "security",
+    "root-detection",
+    "anti-hook",
+    "anti-debug",
+    "device-security",
+    "android-security"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BuiHung1612/react-native-device-security.git"
+  },
+  "author": "OSP <dev@osp.vn>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/BuiHung1612/react-native-device-security/issues"
+  },
+  "homepage": "https://github.com/BuiHung1612/react-native-device-security#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "jest",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint \"**/*.{js,ts,tsx}\"",
+    "prepare": "bob build"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*"
+  },
+  "devDependencies": {
+    "@types/react": "^18.0.0",
+    "@types/react-native": "^0.72.0",
+    "react-native-builder-bob": "^0.20.0",
+    "typescript": "^5.0.0"
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      "commonjs",
+      "module",
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  }
+}

package/react-native-device-security.podspec

@@ -0,0 +1,18 @@
+Pod::Spec.new do |s|
+  s.name           = 'react-native-device-security'
+  s.version        = '1.0.0'
+  s.summary        = 'Multi-layer device security detection for React Native'
+  s.description    = <<-DESC
+    React Native library for detecting device security threats including root detection,
+    hook detection (Frida, Xposed, Magisk), debugger detection, and emulator detection.
+    DESC
+  s.homepage       = 'https://github.com/your-org/react-native-device-security'
+  s.license        = { :type => 'MIT', :file => 'LICENSE' }
+  s.author         = { 'OSP' => 'dev@osp.vn' }
+  s.platforms      = { :ios => '12.0' }
+  s.source         = { :git => 'https://github.com/your-org/react-native-device-security.git', :tag => "v#{s.version}" }
+  s.source_files   = 'ios/**/*.{h,m,mm,swift}'
+  s.requires_arc   = true
+
+  s.dependency 'React-Core'
+end

package/src/NativeDeviceSecurity.ts

@@ -0,0 +1,33 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  // Root detection methods
+  isRooted(): boolean;
+  isRootedWithDetails(): Promise<string>;
+
+  // Hook detection methods
+  hasFrida(): boolean;
+  hasXposed(): boolean;
+  hasMagisk(): boolean;
+
+  // Debug detection
+  isDebuggable(): boolean;
+
+  // Emulator detection
+  isEmulator(): boolean;
+
+  // Comprehensive security check
+  getSecurityStatus(): Promise<string>;
+  isDeviceSecure(): Promise<boolean>;
+
+  // Blocking methods
+  blockOnSecurityThreat(
+    showAlert: boolean,
+    alertTitle: string,
+    alertMessage: string,
+    alertButtonText: string,
+  ): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('DeviceSecurity');

package/src/api.ts

@@ -0,0 +1,225 @@
+/**
+ * DeviceSecurity API
+ * Main singleton class for device security checks
+ */
+
+import { Platform } from 'react-native';
+import NativeDeviceSecurity from './NativeDeviceSecurity';
+import type {
+  BlockOnSecurityThreatOptions,
+  SecurityStatus,
+  SecurityThreat,
+} from './types';
+
+/**
+ * Main DeviceSecurity API class
+ */
+class DeviceSecurity {
+  /**
+   * Check if device is secure (no security threats)
+   */
+  async isDeviceSecure(): Promise<boolean> {
+    if (Platform.OS !== 'android') {
+      // iOS: no-op for now, return true
+      return true;
+    }
+
+    try {
+      return await NativeDeviceSecurity.isDeviceSecure();
+    } catch (error) {
+      console.error('DeviceSecurity: Error checking device security', error);
+      return false;
+    }
+  }
+
+  /**
+   * Get detailed security status
+   */
+  async getSecurityStatus(): Promise<SecurityStatus> {
+    if (Platform.OS !== 'android') {
+      // iOS: no-op for now, return secure status
+      return {
+        isSecure: true,
+        threats: [],
+        isRooted: false,
+        hasRootBeerDetected: false,
+        hasNativeRootDetected: false,
+        hasDangerousBins: false,
+        hasRootApps: false,
+        hasSystemPropsModified: false,
+        hasFrida: false,
+        hasXposed: false,
+        hasMagisk: false,
+        isDebuggable: false,
+        isEmulator: false,
+      };
+    }
+
+    try {
+      const statusJson = await NativeDeviceSecurity.getSecurityStatus();
+      return JSON.parse(statusJson) as SecurityStatus;
+    } catch (error) {
+      console.error('DeviceSecurity: Error getting security status', error);
+      return this.getDefaultSecurityStatus();
+    }
+  }
+
+  /**
+   * Check if device is rooted (synchronous, Android only)
+   */
+  isRooted(): boolean {
+    if (Platform.OS !== 'android') {
+      return false;
+    }
+
+    try {
+      return NativeDeviceSecurity.isRooted();
+    } catch (error) {
+      console.error('DeviceSecurity: Error checking root status', error);
+      return false;
+    }
+  }
+
+  /**
+   * Check if Frida is present
+   */
+  hasFrida(): boolean {
+    if (Platform.OS !== 'android') {
+      return false;
+    }
+
+    try {
+      return NativeDeviceSecurity.hasFrida();
+    } catch (error) {
+      console.error('DeviceSecurity: Error checking Frida', error);
+      return false;
+    }
+  }
+
+  /**
+   * Check if Xposed framework is present
+   */
+  hasXposed(): boolean {
+    if (Platform.OS !== 'android') {
+      return false;
+    }
+
+    try {
+      return NativeDeviceSecurity.hasXposed();
+    } catch (error) {
+      console.error('DeviceSecurity: Error checking Xposed', error);
+      return false;
+    }
+  }
+
+  /**
+   * Check if Magisk is present
+   */
+  hasMagisk(): boolean {
+    if (Platform.OS !== 'android') {
+      return false;
+    }
+
+    try {
+      return NativeDeviceSecurity.hasMagisk();
+    } catch (error) {
+      console.error('DeviceSecurity: Error checking Magisk', error);
+      return false;
+    }
+  }
+
+  /**
+   * Check if app is debuggable
+   */
+  isDebuggable(): boolean {
+    if (Platform.OS !== 'android') {
+      return false;
+    }
+
+    try {
+      return NativeDeviceSecurity.isDebuggable();
+    } catch (error) {
+      console.error('DeviceSecurity: Error checking debuggable', error);
+      return false;
+    }
+  }
+
+  /**
+   * Check if running on emulator
+   */
+  isEmulator(): boolean {
+    if (Platform.OS !== 'android') {
+      return false;
+    }
+
+    try {
+      return NativeDeviceSecurity.isEmulator();
+    } catch (error) {
+      console.error('DeviceSecurity: Error checking emulator', error);
+      return false;
+    }
+  }
+
+  /**
+   * Block app when security threat detected
+   * This will show an alert and potentially exit the app
+   */
+  blockOnSecurityThreat(options: BlockOnSecurityThreatOptions = {}): void {
+    if (Platform.OS !== 'android') {
+      return;
+    }
+
+    const {
+      showAlert = true,
+      alertTitle = 'Security Warning',
+      alertMessage = 'This device is not secure. The app cannot run on rooted or modified devices.',
+      alertButtonText = 'OK',
+      onBlocked,
+    } = options;
+
+    try {
+      NativeDeviceSecurity.blockOnSecurityThreat(
+        showAlert,
+        alertTitle,
+        alertMessage,
+        alertButtonText,
+      );
+
+      // Call callback if provided
+      if (onBlocked) {
+        // Get status for callback
+        this.getSecurityStatus().then(status => {
+          onBlocked(status);
+        });
+      }
+    } catch (error) {
+      console.error('DeviceSecurity: Error blocking on security threat', error);
+    }
+  }
+
+  /**
+   * Get default security status (error case)
+   */
+  private getDefaultSecurityStatus(): SecurityStatus {
+    return {
+      isSecure: false,
+      threats: ['emulator_detected'], // Mark as threat on error to be safe
+      isRooted: false,
+      hasRootBeerDetected: false,
+      hasNativeRootDetected: false,
+      hasDangerousBins: false,
+      hasRootApps: false,
+      hasSystemPropsModified: false,
+      hasFrida: false,
+      hasXposed: false,
+      hasMagisk: false,
+      isDebuggable: false,
+      isEmulator: false,
+    };
+  }
+}
+
+// Export singleton instance
+const deviceSecurityInstance = new DeviceSecurity();
+export default deviceSecurityInstance;
+export { DeviceSecurity };

package/src/components/SecurityBlockedScreen.tsx

@@ -0,0 +1,204 @@
+/**
+ * SecurityBlockedScreen.tsx
+ *
+ * Screen to display when app is blocked due to security threats
+ */
+
+import React from 'react';
+import {
+  View,
+  Text,
+  StyleSheet,
+  ScrollView,
+  SafeAreaView,
+  Platform,
+} from 'react-native';
+import type { SecurityStatus, SecurityThreat } from '../types';
+
+interface SecurityBlockedScreenProps {
+  /** Security status details */
+  threats?: SecurityThreat[];
+  /** Custom title */
+  title?: string;
+  /** Custom message */
+  message?: string;
+  /** Custom icon component */
+  icon?: React.ReactNode;
+}
+
+const THREAT_TITLES: Record<SecurityThreat, string> = {
+  root_detected: 'Thiết bị đã root',
+  root_beer_detected: 'Phát hiện root (RootBeer)',
+  native_root_detected: 'Phát hiện root (Native)',
+  dangerous_bins_detected: 'Phát hiện binary nguy hiểm',
+  root_apps_detected: 'Phát hiện ứng dụng root',
+  system_props_modified: 'Thuộc tính hệ thống đã sửa đổi',
+  frida_detected: 'Phát hiện Frida (Hooking)',
+  xposed_detected: 'Phát hiện Xposed Framework',
+  magisk_detected: 'Phát hiện Magisk',
+  debugger_detected: 'Phát hiện Debugger',
+  emulator_detected: 'Phát hiện Bộ giả lập',
+};
+
+const THREAT_DESCRIPTIONS: Record<SecurityThreat, string> = {
+  root_detected: 'Thiết bị của bạn đã được root, làm giảm tính bảo mật của ứng dụng.',
+  root_beer_detected: 'Công cụ phát hiện root đã phát hiện thiết bị đã bị can thiệp.',
+  native_root_detected: 'Phát hiện native root - thiết bị có thể đã bị sửa đổi.',
+  dangerous_bins_detected: 'Phát hiện các file thực thi nguy hiểm trên thiết bị.',
+  root_apps_detected: 'Phát hiện ứng dụng quản lý root trên thiết bị.',
+  system_props_modified: 'Các thuộc tính hệ thống quan trọng đã bị sửa đổi.',
+  frida_detected: 'Phát hiện công cụ Frida - thường dùng để can thiệp vào ứng dụng.',
+  xposed_detected: 'Phát hiện Xposed Framework - có thể can thiệp vào ứng dụng.',
+  magisk_detected: 'Phát hiện Magisk - công cụ root ẩn danh.',
+  debugger_detected: 'Phát hiện debugger đang gắn vào ứng dụng.',
+  emulator_detected: 'Ứng dụng đang chạy trên bộ giả lập, không an toàn cho môi trường production.',
+};
+
+/**
+ * Default security blocked screen component
+ */
+export const SecurityBlockedScreen: React.FC<SecurityBlockedScreenProps> = ({
+  threats = [],
+  title = 'Cảnh báo bảo mật',
+  message = 'Thiết bị của bạn không đáp ứng yêu cầu bảo mật. Ứng dụng không thể tiếp tục chạy.',
+  icon,
+}) => {
+  return (
+    <SafeAreaView style={styles.container}>
+      <ScrollView
+        contentContainerStyle={styles.scrollContent}
+        bounces={false}
+      >
+        {icon || (
+          <View style={styles.iconContainer}>
+            <Text style={styles.icon}>🔒</Text>
+          </View>
+        )}
+
+        <Text style={styles.title}>{title}</Text>
+
+        <Text style={styles.message}>{message}</Text>
+
+        {threats.length > 0 && (
+          <>
+            <Text style={styles.threatsTitle}>Vấn đề phát hiện:</Text>
+
+            <View style={styles.threatsList}>
+              {threats.map((threat) => (
+                <View key={threat} style={styles.threatItem}>
+                  <View style={styles.bullet} />
+                  <View style={styles.threatContent}>
+                    <Text style={styles.threatTitle}>
+                      {THREAT_TITLES[threat] || threat}
+                    </Text>
+                    <Text style={styles.threatDescription}>
+                      {THREAT_DESCRIPTIONS[threat] || 'Vấn đề bảo mật không xác định.'}
+                    </Text>
+                  </View>
+                </View>
+              ))}
+            </View>
+          </>
+        )}
+
+        <View style={styles.footer}>
+          <Text style={styles.footerText}>
+            Nếu bạn cho rằng đây là sự nhầm lẫn, vui lòng liên hệ với bộ phận hỗ trợ.
+          </Text>
+        </View>
+      </ScrollView>
+    </SafeAreaView>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    backgroundColor: '#f5f5f5',
+  },
+  scrollContent: {
+    padding: 24,
+    alignItems: 'center',
+  },
+  iconContainer: {
+    width: 100,
+    height: 100,
+    borderRadius: 50,
+    backgroundColor: '#ffebee',
+    justifyContent: 'center',
+    alignItems: 'center',
+    marginBottom: 24,
+  },
+  icon: {
+    fontSize: 48,
+  },
+  title: {
+    fontSize: 24,
+    fontWeight: '700',
+    color: '#d32f2f',
+    textAlign: 'center',
+    marginBottom: 12,
+  },
+  message: {
+    fontSize: 16,
+    color: '#424242',
+    textAlign: 'center',
+    marginBottom: 24,
+    lineHeight: 24,
+  },
+  threatsTitle: {
+    fontSize: 18,
+    fontWeight: '600',
+    color: '#212121',
+    alignSelf: 'flex-start',
+    marginBottom: 16,
+  },
+  threatsList: {
+    width: '100%',
+    marginBottom: 24,
+  },
+  threatItem: {
+    flexDirection: 'row',
+    backgroundColor: '#ffffff',
+    borderRadius: 8,
+    padding: 16,
+    marginBottom: 12,
+    borderLeftWidth: 4,
+    borderLeftColor: '#d32f2f',
+  },
+  bullet: {
+    width: 8,
+    height: 8,
+    borderRadius: 4,
+    backgroundColor: '#d32f2f',
+    marginTop: 6,
+    marginRight: 12,
+  },
+  threatContent: {
+    flex: 1,
+  },
+  threatTitle: {
+    fontSize: 16,
+    fontWeight: '600',
+    color: '#212121',
+    marginBottom: 4,
+  },
+  threatDescription: {
+    fontSize: 14,
+    color: '#757575',
+    lineHeight: 20,
+  },
+  footer: {
+    marginTop: 24,
+    paddingTop: 24,
+    borderTopWidth: 1,
+    borderTopColor: '#e0e0e0',
+  },
+  footerText: {
+    fontSize: 14,
+    color: '#9e9e9e',
+    textAlign: 'center',
+  },
+});
+
+export default SecurityBlockedScreen;

package/src/components/index.ts

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

package/src/hooks/index.ts

@@ -0,0 +1,5 @@
+export { useDeviceSecurity } from './useDeviceSecurity';
+export type {
+  UseDeviceSecurityOptions,
+  UseDeviceSecurityReturn,
+} from '../types';