react-native-device-defense 1.0.0

package/src/hooks/useDeviceSecurity.ts

@@ -0,0 +1,91 @@
+/**
+ * React hook for device security
+ */
+
+import { useCallback, useEffect, useState } from 'react';
+import { Platform } from 'react-native';
+import deviceSecurity from '../api';
+import type {
+  SecurityStatus,
+  UseDeviceSecurityOptions,
+  UseDeviceSecurityReturn,
+} from '../types';
+
+export function useDeviceSecurity(
+  options: UseDeviceSecurityOptions = {},
+): UseDeviceSecurityReturn {
+  const {
+    onSecurityThreat,
+    blockOnThreat = false,
+    blockOptions,
+    checkInterval = 0,
+  } = options;
+
+  const [isSecure, setIsSecure] = useState<boolean | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [securityStatus, setSecurityStatus] = useState<SecurityStatus | null>(
+    null,
+  );
+  const [error, setError] = useState<Error | null>(null);
+
+  const checkSecurity = useCallback(async () => {
+    if (Platform.OS !== 'android') {
+      setIsSecure(true);
+      setIsLoading(false);
+      return;
+    }
+
+    try {
+      setIsLoading(true);
+      setError(null);
+
+      const status = await deviceSecurity.getSecurityStatus();
+      setSecurityStatus(status);
+      setIsSecure(status.isSecure);
+
+      // Handle security threats
+      if (!status.isSecure) {
+        // Call callback for each threat
+        for (const threat of status.threats) {
+          onSecurityThreat?.(threat, status);
+        }
+
+        // Block if requested
+        if (blockOnThreat) {
+          deviceSecurity.blockOnSecurityThreat(blockOptions);
+        }
+      }
+    } catch (err) {
+      const errorObj =
+        err instanceof Error ? err : new Error('Security check failed');
+      setError(errorObj);
+      setIsSecure(false);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [onSecurityThreat, blockOnThreat, blockOptions]);
+
+  const recheck = useCallback(async () => {
+    await checkSecurity();
+  }, [checkSecurity]);
+
+  useEffect(() => {
+    checkSecurity();
+
+    // Set up interval if specified
+    if (checkInterval > 0) {
+      const intervalId = setInterval(checkSecurity, checkInterval);
+      return () => clearInterval(intervalId);
+    }
+  }, [checkSecurity, checkInterval]);
+
+  return {
+    isSecure,
+    isLoading,
+    securityStatus,
+    error,
+    recheck,
+  };
+}
+
+export default useDeviceSecurity;

package/src/index.ts

@@ -0,0 +1,27 @@
+/**
+ * react-native-device-security
+ *
+ * Main exports for the library
+ */
+
+// Main API
+export { default as DeviceSecurity, DeviceSecurity as DeviceSecurityClass } from './api';
+export { default } from './api';
+
+// Native module spec
+export { default as NativeDeviceSecurity } from './NativeDeviceSecurity';
+
+// Hooks
+export { useDeviceSecurity } from './hooks';
+
+// Components
+export { SecurityBlockedScreen } from './components';
+
+// Types
+export type {
+  SecurityStatus,
+  SecurityThreat,
+  BlockOnSecurityThreatOptions,
+  UseDeviceSecurityOptions,
+  UseDeviceSecurityReturn,
+} from './types';

package/src/types.ts

@@ -0,0 +1,95 @@
+/**
+ * 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>;
+}