freerasp-react-native 4.3.2 → 4.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "freerasp-react-native",
-  "version": "4.3.2",
+  "version": "4.5.0",
   "description": "React Native plugin for improving app security and threat monitoring on Android and iOS mobile devices.",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",

package/src/api/listeners/raspExecutionState.ts

@@ -1,6 +1,6 @@
 import { NativeEventEmitter, type EmitterSubscription } from 'react-native';
 import { FreeraspReactNative } from '../nativeModules';
-import { onInvalidCallback } from '../methods/native';
+import { onInvalidCallback, removeListenerForEvent } from '../methods/native';
 import type {
   NativeEvent,
   RaspExecutionStateEventActions,
@@ -12,19 +12,41 @@ import {
 import { RaspExecutionState } from '../../models/raspExecutionState';
 
 const eventEmitter = new NativeEventEmitter(FreeraspReactNative);
-let eventsListener: EmitterSubscription | undefined;
+let eventsListener: EmitterSubscription | null = null;
+let executionStateChannel: string | null = null;
+let executionStateKey: string | null = null;
+
+let isMappingPrepared = false;
+let isInitializing = false;
 
 export const setRaspExecutionStateListener = async (
   config: RaspExecutionStateEventActions
 ) => {
-  const [channel, key] = await getRaspExecutionStateChannelData();
-  await prepareRaspExecutionStateMapping();
+  if (isInitializing) {
+    return;
+  }
+
+  isInitializing = true;
+
+  await removeRaspExecutionStateEventListener();
+
+  if (!executionStateChannel || !executionStateKey) {
+    [executionStateChannel, executionStateKey] =
+      await getRaspExecutionStateChannelData();
+  }
+
+  if (!isMappingPrepared) {
+    await prepareRaspExecutionStateMapping();
+    isMappingPrepared = true;
+  }
 
   const listener = async (event: NativeEvent) => {
-    if (event[key] === undefined) {
+    if (!executionStateKey) {
       onInvalidCallback();
+      return;
     }
-    switch (event[key]) {
+
+    switch (event[executionStateKey]) {
       case RaspExecutionState.AllChecksFinished.value:
         config.allChecksFinished?.();
         break;
@@ -33,10 +55,16 @@ export const setRaspExecutionStateListener = async (
         break;
     }
   };
-  eventsListener = eventEmitter.addListener(channel, listener);
+  eventsListener = eventEmitter.addListener(executionStateChannel, listener);
+  isInitializing = false;
 };
 
-export const removeRaspExecutionStateEventListener = (): void => {
-  eventsListener?.remove();
-  eventsListener = undefined;
-};
+export const removeRaspExecutionStateEventListener =
+  async (): Promise<void> => {
+    if (!eventsListener || !executionStateChannel) {
+      return;
+    }
+    await removeListenerForEvent(executionStateChannel);
+    eventsListener?.remove();
+    eventsListener = null;
+  };

package/src/api/listeners/threat.ts

@@ -1,6 +1,6 @@
 import { NativeEventEmitter, type EmitterSubscription } from 'react-native';
 import { FreeraspReactNative } from '../nativeModules';
-import { onInvalidCallback } from '../methods/native';
+import { onInvalidCallback, removeListenerForEvent } from '../methods/native';
 import { Threat } from '../../models/threat';
 import type { NativeEvent, ThreatEventActions } from '../../types/types';
 import { parseMalwareData } from '../../utils/malware';
@@ -10,17 +10,40 @@ import {
 } from '../../channels/threat';
 
 const eventEmitter = new NativeEventEmitter(FreeraspReactNative);
-let eventsListener: EmitterSubscription | undefined;
+let eventsListener: EmitterSubscription | null = null;
+
+let threatChannel: string | null = null;
+let threatKey: string | null = null;
+let threatMalwareKey: string | null = null;
+
+let isMappingPrepared = false;
+let isInitializing = false;
 
 export const setThreatListeners = async (config: ThreatEventActions) => {
-  const [channel, key, malwareKey] = await getThreatChannelData();
-  await prepareThreatMapping();
+  if (isInitializing) {
+    return;
+  }
+
+  isInitializing = true;
+
+  await removeThreatListener();
+
+  if (!threatChannel || !threatKey || !threatMalwareKey) {
+    [threatChannel, threatKey, threatMalwareKey] = await getThreatChannelData();
+  }
+
+  if (!isMappingPrepared) {
+    await prepareThreatMapping();
+    isMappingPrepared = true;
+  }
 
   const listener = async (event: NativeEvent) => {
-    if (event[key] === undefined) {
+    if (!threatKey || !threatMalwareKey) {
       onInvalidCallback();
+      return;
     }
-    switch (event[key]) {
+
+    switch (event[threatKey]) {
       case Threat.PrivilegedAccess.value:
         config.privilegedAccess?.();
         break;
@@ -61,7 +84,7 @@ export const setThreatListeners = async (config: ThreatEventActions) => {
         config.systemVPN?.();
         break;
       case Threat.Malware.value:
-        const malwareData = event[malwareKey];
+        const malwareData = event[threatMalwareKey];
         config.malware?.(
           await parseMalwareData(Array.isArray(malwareData) ? malwareData : [])
         );
@@ -87,15 +110,23 @@ export const setThreatListeners = async (config: ThreatEventActions) => {
       case Threat.UnsecureWifi.value:
         config.unsecureWifi?.();
         break;
+      case Threat.Automation.value:
+        config.automation?.();
+        break;
       default:
         onInvalidCallback();
         break;
     }
   };
-  eventsListener = eventEmitter.addListener(channel, listener);
+  eventsListener = eventEmitter.addListener(threatChannel, listener);
+  isInitializing = false;
 };
 
-export const removeThreatListener = (): void => {
+export const removeThreatListener = async (): Promise<void> => {
+  if (!eventsListener || !threatChannel) {
+    return;
+  }
+  await removeListenerForEvent(threatChannel);
   eventsListener?.remove();
-  eventsListener = undefined;
+  eventsListener = null;
 };

package/src/api/methods/native.ts

@@ -25,6 +25,10 @@ export const storeExternalId = (data: string): Promise<string> => {
   return FreeraspReactNative.storeExternalId(data);
 };
 
+export const removeExternalId = (): Promise<string> => {
+  return FreeraspReactNative.removeExternalId();
+};
+
 export const getAppIcon = (packageName: string): Promise<string> => {
   if (Platform.OS === 'ios') {
     return Promise.reject(
@@ -37,3 +41,7 @@ export const getAppIcon = (packageName: string): Promise<string> => {
 export const onInvalidCallback = (): void => {
   FreeraspReactNative.onInvalidCallback();
 };
+
+export const removeListenerForEvent = (channel: string): Promise<string> => {
+  return FreeraspReactNative.removeListenerForEvent(channel);
+};

package/src/api/methods/reactNative.ts

@@ -1,4 +1,4 @@
-import { talsecStart } from 'freerasp-react-native';
+import { talsecStart } from './native';
 import { useEffect } from 'react';
 import {
   setRaspExecutionStateListener,
@@ -12,6 +12,8 @@ import type {
 } from '../../types/types';
 import { onInvalidCallback } from './native';
 
+let isRaspStarted = false;
+
 export const useFreeRasp = (
   config: TalsecConfig,
   actions: ThreatEventActions,
@@ -22,21 +24,28 @@ export const useFreeRasp = (
       await setThreatListeners(actions);
       raspExecutionStateActions &&
         (await setRaspExecutionStateListener(raspExecutionStateActions));
+
+      if (isRaspStarted) {
+        return;
+      }
+
       try {
-        let response = await talsecStart(config);
+        const response = await talsecStart(config);
         if (response !== 'freeRASP started') {
           onInvalidCallback();
         }
-        console.log(response);
+        isRaspStarted = true;
       } catch (e: any) {
         console.error(`${e.code}: ${e.message}`);
       }
-
-      return () => {
-        removeThreatListener();
-        removeRaspExecutionStateEventListener();
-      };
     })();
+
+    return () => {
+      (async () => {
+        await removeThreatListener();
+        await removeRaspExecutionStateEventListener();
+      })();
+    };
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 };

package/src/channels/threat.ts

@@ -1,4 +1,3 @@
-import { Platform } from 'react-native';
 import { getThreatCount, itemsHaveType } from '../utils/utils';
 import { FreeraspReactNative } from '../api/nativeModules';
 import { Threat } from '../models/threat';
@@ -18,9 +17,8 @@ export const getThreatIdentifiers = async (): Promise<number[]> => {
 export const getThreatChannelData = async (): Promise<
   [string, string, string]
 > => {
-  const dataLength = Platform.OS === 'ios' ? 2 : 3;
   const data = await FreeraspReactNative.getThreatChannelData();
-  if (data.length !== dataLength || !itemsHaveType(data, 'string')) {
+  if (data.length !== 3 || !itemsHaveType(data, 'string')) {
     onInvalidCallback();
   }
   return data;

package/src/models/threat.ts

@@ -24,6 +24,7 @@ export class Threat {
   static TimeSpoofing = new Threat(0);
   static LocationSpoofing = new Threat(0);
   static UnsecureWifi = new Threat(0);
+  static Automation = new Threat(0);
 
   constructor(value: number) {
     this.value = value;
@@ -52,6 +53,7 @@ export class Threat {
           this.TimeSpoofing,
           this.LocationSpoofing,
           this.UnsecureWifi,
+          this.Automation,
         ]
       : [
           this.AppIntegrity,
@@ -67,6 +69,7 @@ export class Threat {
           this.UnofficialStore,
           this.Screenshot,
           this.ScreenRecording,
+          this.TimeSpoofing,
         ];
   }
 }

package/src/types/types.ts

@@ -61,6 +61,7 @@ export type ThreatEventActions = {
   timeSpoofing?: () => any;
   locationSpoofing?: () => any;
   unsecureWifi?: () => any;
+  automation?: () => any;
 };
 
 export type NativeEvent = { [key: string]: number | string[] | undefined };

package/android/src/main/java/com/freeraspreactnative/FreeraspThreatHandler.kt

@@ -1,103 +0,0 @@
-package com.freeraspreactnative
-
-import com.aheaditec.talsec_security.security.api.SuspiciousAppInfo
-import com.aheaditec.talsec_security.security.api.ThreatListener
-import com.freeraspreactnative.events.RaspExecutionStateEvent
-import com.freeraspreactnative.events.ThreatEvent
-
-internal object FreeraspThreatHandler : ThreatListener.ThreatDetected, ThreatListener.DeviceState, ThreatListener.RaspExecutionState() {
-
-  internal var listener: TalsecReactNative? = null
-
-  override fun onRootDetected() {
-    listener?.threatDetected(ThreatEvent.PrivilegedAccess)
-  }
-
-  override fun onDebuggerDetected() {
-    listener?.threatDetected(ThreatEvent.Debug)
-  }
-
-  override fun onEmulatorDetected() {
-    listener?.threatDetected(ThreatEvent.Simulator)
-  }
-
-  override fun onTamperDetected() {
-    listener?.threatDetected(ThreatEvent.AppIntegrity)
-  }
-
-  override fun onUntrustedInstallationSourceDetected() {
-    listener?.threatDetected(ThreatEvent.UnofficialStore)
-  }
-
-  override fun onHookDetected() {
-    listener?.threatDetected(ThreatEvent.Hooks)
-  }
-
-  override fun onDeviceBindingDetected() {
-    listener?.threatDetected(ThreatEvent.DeviceBinding)
-  }
-
-  override fun onObfuscationIssuesDetected() {
-    listener?.threatDetected(ThreatEvent.ObfuscationIssues)
-  }
-
-  override fun onMalwareDetected(suspiciousAppInfos: MutableList<SuspiciousAppInfo>) {
-    listener?.malwareDetected(suspiciousAppInfos ?: mutableListOf())
-  }
-
-  override fun onUnlockedDeviceDetected() {
-    listener?.threatDetected(ThreatEvent.Passcode)
-  }
-
-  override fun onHardwareBackedKeystoreNotAvailableDetected() {
-    listener?.threatDetected(ThreatEvent.SecureHardwareNotAvailable)
-  }
-
-  override fun onDeveloperModeDetected() {
-    listener?.threatDetected(ThreatEvent.DevMode)
-  }
-
-  override fun onADBEnabledDetected() {
-    listener?.threatDetected(ThreatEvent.ADBEnabled)
-  }
-
-  override fun onSystemVPNDetected() {
-    listener?.threatDetected(ThreatEvent.SystemVPN)
-  }
-
-  override fun onScreenshotDetected() {
-    listener?.threatDetected(ThreatEvent.Screenshot)
-  }
-
-  override fun onScreenRecordingDetected() {
-    listener?.threatDetected(ThreatEvent.ScreenRecording)
-  }
-
-  override fun onMultiInstanceDetected() {
-    listener?.threatDetected(ThreatEvent.MultiInstance)
-  }
-
-  override fun onUnsecureWifiDetected() {
-    listener?.threatDetected(ThreatEvent.UnsecureWifi)
-  }
-
-  override fun onTimeSpoofingDetected() {
-    listener?.threatDetected(ThreatEvent.TimeSpoofing)
-  }
-
-  override fun onLocationSpoofingDetected() {
-    listener?.threatDetected(ThreatEvent.LocationSpoofing)
-  }
-
-  override fun onAllChecksFinished() {
-    listener?.raspExecutionStateChanged(RaspExecutionStateEvent.AllChecksFinished)
-  }
-
-  internal interface TalsecReactNative {
-    fun threatDetected(threatEventType: ThreatEvent)
-
-    fun malwareDetected(suspiciousApps: MutableList<SuspiciousAppInfo>)
-
-    fun raspExecutionStateChanged(event: RaspExecutionStateEvent)
-  }
-}