freerasp-react-native 4.4.0 → 4.5.1

package/CHANGELOG.md

@@ -5,6 +5,66 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [4.5.1] - 2026-03-16
+
+- Android SDK version: 18.0.4
+- iOS SDK version: 6.14.1
+
+### React Native
+
+#### Fixed
+
+- Fixed case where event dispatchers on Android were not initialized before calling onResume at the app launch
+
+## [4.5.0] - 2026-03-03
+
+- Android SDK version: 18.0.4
+- iOS SDK version: 6.14.1
+
+### React Native
+
+#### Changed
+
+- Updated the internal handling of ExternalIdResult on Android (for `storeExternalId()` method)
+
+### Android
+
+#### Added
+
+- Added support for `KernelSU` to the existing root detection capabilities
+- Added support for `HMA` to the existing root detection capabilities
+- Added new malware detection capabilities
+- Added `onAutomationDetected()` callback to `ThreatDetected` interface
+  - We are introducing a new capability, detecting whether the device is being automated using tools like Appium
+- Added value restrictions to `externalId`
+  - Method `storeExternalId()` now returns `ExternalIdResult`, which indicates `Success` or `Error` when `externalId` violates restrictions
+
+#### Fixed
+
+- Fixed exception handling for the KeyStore `getEntry` operation
+- Fixed issue in `ScreenProtector` concerning the `onScreenRecordingDetected` invocations
+- Merged internal shared libraries into a single one, reducing the final APK size
+- Fixed bug related to key storing in keystore type detection (hw-backed keystore check)
+- Fixed manifest queries merge
+
+#### Changed
+
+- Removed unused library `tmlib`
+- Refactoring of signature verification code
+- Updated compile and target API to 36
+- Improved root detection capabilities
+- Detection of wireless ADB added to ADB detections
+
+### iOS
+
+#### Added
+
+- Added time spoofing detection, detecting an inaccurate device clock. It is a new threat `timeSpoofing`.
+
+#### Changed
+
+- Improved jailbreak detection methods.
+
 ## [4.4.0] - 2026-02-06
 
 - Android SDK version: 18.0.1

package/android/build.gradle

@@ -105,7 +105,7 @@ dependencies {
   implementation "com.facebook.react:react-native:$react_native_version"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
   implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:1.4.1"
-  implementation "com.aheaditec.talsec.security:TalsecSecurity-Community-ReactNative:18.0.2"
+  implementation "com.aheaditec.talsec.security:TalsecSecurity-Community-ReactNative:18.0.4"
 }
 
 if (isNewArchitectureEnabled()) {

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

@@ -9,7 +9,6 @@ import com.aheaditec.talsec_security.security.api.SuspiciousAppInfo
 import com.aheaditec.talsec_security.security.api.Talsec
 import com.aheaditec.talsec_security.security.api.TalsecConfig
 import com.aheaditec.talsec_security.security.api.TalsecMode
-import com.aheaditec.talsec_security.security.api.ThreatListener
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.LifecycleEventListener
 import com.facebook.react.bridge.Promise
@@ -19,8 +18,10 @@ import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.UiThreadUtil.runOnUiThread
 import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
-import com.freeraspreactnative.events.BaseRaspEvent
+import com.freeraspreactnative.dispatchers.ExecutionStateDispatcher
+import com.freeraspreactnative.dispatchers.ThreatDispatcher
 import com.freeraspreactnative.events.RaspExecutionStateEvent
 import com.freeraspreactnative.events.ThreatEvent
 import com.freeraspreactnative.interfaces.PluginExecutionStateListener
@@ -38,15 +39,24 @@ class FreeraspReactNativeModule(private val reactContext: ReactApplicationContex
 
   private val lifecycleListener = object : LifecycleEventListener {
     override fun onHostResume() {
+      ThreatDispatcher.onResume()
+      ExecutionStateDispatcher.onResume()
       if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
         reactContext.currentActivity?.let { ScreenProtector.register(it) }
       }
     }
 
     override fun onHostPause() {
+      ThreatDispatcher.onPause()
+      ExecutionStateDispatcher.onPause()
       if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
         reactContext.currentActivity?.let { ScreenProtector.unregister(it) }
       }
+      if (reactContext.currentActivity?.isFinishing == true) {
+        ThreatDispatcher.unregisterListener()
+        ExecutionStateDispatcher.unregisterListener()
+        PluginThreatHandler.unregisterSDKListener(reactContext)
+      }
     }
 
     override fun onHostDestroy() {
@@ -58,19 +68,25 @@ class FreeraspReactNativeModule(private val reactContext: ReactApplicationContex
     return NAME
   }
 
-  init {
+  override fun initialize() {
     reactContext.addLifecycleEventListener(lifecycleListener)
     initializeEventKeys()
+    PluginThreatHandler.initializePluginListener(PluginListener(reactContext))
+    super.initialize()
   }
 
   @ReactMethod
   fun talsecStart(
     options: ReadableMap, promise: Promise
   ) {
+    if (talsecStarted) {
+      promise.resolve("freeRASP started")
+      return
+    }
 
     try {
       val config = buildTalsecConfig(options)
-      PluginThreatHandler.registerListener(reactContext)
+      PluginThreatHandler.registerSDKListener(reactContext)
       runOnUiThread {
         Talsec.start(reactContext, config, TalsecMode.BACKGROUND)
         mainHandler.post {
@@ -149,10 +165,10 @@ class FreeraspReactNativeModule(private val reactContext: ReactApplicationContex
   @ReactMethod
   fun addListener(eventName: String) {
     if (eventName == ThreatEvent.CHANNEL_NAME) {
-      PluginThreatHandler.threatDispatcher.listener = PluginListener(reactContext)
+      ThreatDispatcher.registerListener(PluginListener(reactContext))
     }
     if (eventName == RaspExecutionStateEvent.CHANNEL_NAME) {
-      PluginThreatHandler.executionStateDispatcher.listener = PluginListener(reactContext)
+      ExecutionStateDispatcher.registerListener(PluginListener(reactContext))
     }
   }
 
@@ -165,10 +181,10 @@ class FreeraspReactNativeModule(private val reactContext: ReactApplicationContex
   @ReactMethod
   fun removeListenerForEvent(eventName: String, promise: Promise) {
     if (eventName == ThreatEvent.CHANNEL_NAME) {
-      PluginThreatHandler.threatDispatcher.listener = null
+      ThreatDispatcher.unregisterListener()
     }
     if (eventName == RaspExecutionStateEvent.CHANNEL_NAME) {
-      PluginThreatHandler.executionStateDispatcher.listener = null
+      ExecutionStateDispatcher.unregisterListener()
     }
     promise.resolve("Listener unregistered")
   }
@@ -302,48 +318,40 @@ class FreeraspReactNativeModule(private val reactContext: ReactApplicationContex
     private val mainHandler = Handler(Looper.getMainLooper())
 
     internal var talsecStarted = false
+  }
+
+  internal class PluginListener(private val reactContext: ReactApplicationContext) :
+    PluginThreatListener, PluginExecutionStateListener {
 
-    private fun notifyEvent(event: BaseRaspEvent, appReactContext: ReactApplicationContext) {
+    override fun threatDetected(threatEventType: ThreatEvent) {
       val params = Arguments.createMap()
-      params.putInt(event.channelKey, event.value)
-      appReactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-        .emit(event.channelName, params)
+      params.putInt(threatEventType.channelKey, threatEventType.value)
+      notifyEvent(ThreatEvent.CHANNEL_NAME, params)
     }
 
-    /**
-     * Sends malware detected event to React Native
-     */
-    private fun notifyMalware(suspiciousApps: MutableList<SuspiciousAppInfo>, appReactContext: ReactApplicationContext) {
-      // Perform the malware encoding on a background thread
+    override fun malwareDetected(suspiciousApps: MutableList<SuspiciousAppInfo>) {
       backgroundHandler.post {
-
-        val encodedSuspiciousApps = suspiciousApps.toEncodedWritableArray(appReactContext)
-
+        val encodedSuspiciousApps = suspiciousApps.toEncodedWritableArray(reactContext)
         mainHandler.post {
           val params = Arguments.createMap()
           params.putInt(ThreatEvent.CHANNEL_KEY, ThreatEvent.Malware.value)
           params.putArray(
             ThreatEvent.MALWARE_CHANNEL_KEY, encodedSuspiciousApps
           )
-
-          appReactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-            .emit(ThreatEvent.CHANNEL_NAME, params)
+          notifyEvent(ThreatEvent.CHANNEL_NAME, params)
         }
       }
     }
-  }
-
-  internal class PluginListener(private val reactContext: ReactApplicationContext) : PluginThreatListener, PluginExecutionStateListener {
-    override fun threatDetected(threatEventType: ThreatEvent) {
-      notifyEvent(threatEventType, reactContext)
-    }
 
-    override fun malwareDetected(suspiciousApps: MutableList<SuspiciousAppInfo>) {
-      notifyMalware(suspiciousApps, reactContext)
+    override fun raspExecutionStateChanged(event: RaspExecutionStateEvent) {
+      val params = Arguments.createMap()
+      params.putInt(event.channelKey, event.value)
+      notifyEvent(event.channelName, params)
     }
 
-    override fun raspExecutionStateChanged(event: RaspExecutionStateEvent) {
-      notifyEvent(event, reactContext)
+    private fun notifyEvent(eventName: String, params: WritableMap) {
+      reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+        .emit(eventName, params)
     }
   }
 }

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

@@ -10,112 +10,114 @@ import com.freeraspreactnative.events.ThreatEvent
 
 internal object PluginThreatHandler {
 
-  internal val threatDispatcher = ThreatDispatcher()
-  internal val executionStateDispatcher = ExecutionStateDispatcher()
+  fun initializePluginListener(listener: FreeraspReactNativeModule.PluginListener) {
+    ThreatDispatcher.listener = listener
+    ExecutionStateDispatcher.listener = listener
+  }
 
   private val threatDetected = object : ThreatListener.ThreatDetected() {
 
     override fun onRootDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.PrivilegedAccess)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.PrivilegedAccess)
     }
 
     override fun onDebuggerDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.Debug)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.Debug)
     }
 
     override fun onEmulatorDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.Simulator)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.Simulator)
     }
 
     override fun onTamperDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.AppIntegrity)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.AppIntegrity)
     }
 
     override fun onUntrustedInstallationSourceDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.UnofficialStore)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.UnofficialStore)
     }
 
     override fun onHookDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.Hooks)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.Hooks)
     }
 
     override fun onDeviceBindingDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.DeviceBinding)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.DeviceBinding)
     }
 
     override fun onObfuscationIssuesDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.ObfuscationIssues)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.ObfuscationIssues)
     }
 
     override fun onMalwareDetected(suspiciousAppInfos: MutableList<SuspiciousAppInfo>) {
-      threatDispatcher.dispatchMalware(suspiciousAppInfos ?: mutableListOf())
+      ThreatDispatcher.dispatchMalware(suspiciousAppInfos ?: mutableListOf())
     }
 
     override fun onScreenshotDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.Screenshot)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.Screenshot)
     }
 
     override fun onScreenRecordingDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.ScreenRecording)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.ScreenRecording)
     }
 
     override fun onMultiInstanceDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.MultiInstance)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.MultiInstance)
     }
 
     override fun onUnsecureWifiDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.UnsecureWifi)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.UnsecureWifi)
     }
 
     override fun onTimeSpoofingDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.TimeSpoofing)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.TimeSpoofing)
     }
 
     override fun onLocationSpoofingDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.LocationSpoofing)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.LocationSpoofing)
     }
 
     override fun onAutomationDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.Automation)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.Automation)
     }
   }
 
   private val deviceState = object : ThreatListener.DeviceState() {
 
     override fun onUnlockedDeviceDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.Passcode)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.Passcode)
     }
 
     override fun onHardwareBackedKeystoreNotAvailableDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.SecureHardwareNotAvailable)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.SecureHardwareNotAvailable)
     }
 
     override fun onDeveloperModeDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.DevMode)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.DevMode)
     }
 
     override fun onADBEnabledDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.ADBEnabled)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.ADBEnabled)
     }
 
     override fun onSystemVPNDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.SystemVPN)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.SystemVPN)
     }
   }
 
   private val raspExecutionState = object : ThreatListener.RaspExecutionState() {
     override fun onAllChecksFinished() {
-      executionStateDispatcher.dispatch(RaspExecutionStateEvent.AllChecksFinished)
+      ExecutionStateDispatcher.dispatch(RaspExecutionStateEvent.AllChecksFinished)
     }
   }
 
   private val internalListener = ThreatListener(threatDetected, deviceState, raspExecutionState)
 
-  internal fun registerListener(context: Context) {
+  internal fun registerSDKListener(context: Context) {
     internalListener.registerListener(context)
   }
 
-  internal fun unregisterListener(context: Context) {
+  internal fun unregisterSDKListener(context: Context) {
     internalListener.unregisterListener(context)
   }
 }

package/android/src/main/java/com/freeraspreactnative/dispatchers/ExecutionStateDispatcher.kt

@@ -3,36 +3,53 @@ package com.freeraspreactnative.dispatchers
 import com.freeraspreactnative.events.RaspExecutionStateEvent
 import com.freeraspreactnative.interfaces.PluginExecutionStateListener
 
-internal class ExecutionStateDispatcher {
+internal object ExecutionStateDispatcher {
+  lateinit var listener: PluginExecutionStateListener
   private val cache = mutableSetOf<RaspExecutionStateEvent>()
 
-  var listener: PluginExecutionStateListener? = null
-    set(value) {
-      field = value
-      if (value != null) {
-        flushCache(value)
-      }
+  private var isAppInForeground = false
+  private var isListenerRegistered = false
+
+  fun registerListener(newListener: PluginExecutionStateListener) {
+    listener = newListener
+    isListenerRegistered = true
+    isAppInForeground = true
+    flushCache()
+  }
+
+  fun unregisterListener() {
+    isListenerRegistered = false
+    isAppInForeground = false
+  }
+
+  fun onResume() {
+    isAppInForeground = true
+    if (isListenerRegistered) {
+      flushCache()
     }
+  }
+
+  fun onPause() {
+    isAppInForeground = false
+  }
 
   fun dispatch(event: RaspExecutionStateEvent) {
-    val currentListener = listener
-    if (currentListener != null) {
-      currentListener.raspExecutionStateChanged(event)
+    if (isAppInForeground && isListenerRegistered) {
+      listener.raspExecutionStateChanged(event)
     } else {
       synchronized(cache) {
-        val checkedListener = listener
-        checkedListener?.raspExecutionStateChanged(event) ?: cache.add(event)
+        cache.add(event)
       }
     }
   }
 
-  private fun flushCache(registeredListener: PluginExecutionStateListener) {
+  private fun flushCache() {
     val events = synchronized(cache) {
       val snapshot = cache.toSet()
       cache.clear()
       snapshot
     }
-    events.forEach { registeredListener.raspExecutionStateChanged(it) }
+    events.forEach { listener.raspExecutionStateChanged(it) }
   }
 }
 

package/android/src/main/java/com/freeraspreactnative/dispatchers/ThreatDispatcher.kt

@@ -4,49 +4,65 @@ import com.aheaditec.talsec_security.security.api.SuspiciousAppInfo
 import com.freeraspreactnative.events.ThreatEvent
 import com.freeraspreactnative.interfaces.PluginThreatListener
 
-internal class ThreatDispatcher {
+internal object ThreatDispatcher {
+  lateinit var listener: PluginThreatListener
   private val threatCache = mutableSetOf<ThreatEvent>()
   private val malwareCache = mutableSetOf<SuspiciousAppInfo>()
 
-  var listener: PluginThreatListener? = null
-    set(value) {
-      field = value
-      if (value != null) {
-        flushCache(value)
-      }
+  private var isAppInForeground = false
+  private var isListenerRegistered = false
+
+  fun registerListener(newListener: PluginThreatListener) {
+    listener = newListener
+    isListenerRegistered = true
+    isAppInForeground = true
+    flushCache()
+  }
+
+  fun unregisterListener() {
+    isListenerRegistered = false
+    isAppInForeground = false
+  }
+
+  fun onResume() {
+    isAppInForeground = true
+    if (isListenerRegistered) {
+      flushCache()
     }
+  }
+
+  fun onPause() {
+    isAppInForeground = false
+  }
 
   fun dispatchThreat(event: ThreatEvent) {
-    val currentListener = listener
-    if (currentListener != null) {
-      currentListener.threatDetected(event)
+    if (isAppInForeground && isListenerRegistered) {
+      listener.threatDetected(event)
     } else {
       synchronized(threatCache) {
-        val checkedListener = listener
-        checkedListener?.threatDetected(event) ?: threatCache.add(event)
+        threatCache.add(event)
       }
     }
   }
 
   fun dispatchMalware(apps: MutableList<SuspiciousAppInfo>) {
-    val currentListener = listener
-    if (currentListener != null) {
-      currentListener.malwareDetected(apps)
-    } else {
+    if (isAppInForeground && isListenerRegistered) {
+      listener.malwareDetected(apps)
+    }
+    else {
       synchronized(malwareCache) {
-        val checkedListener = listener
-        checkedListener?.malwareDetected(apps) ?: malwareCache.addAll(apps)
+        malwareCache.addAll(apps)
       }
     }
   }
 
-  private fun flushCache(registeredListener: PluginThreatListener) {
+  private fun flushCache() {
     val threats = synchronized(threatCache) {
       val snapshot = threatCache.toSet()
       threatCache.clear()
       snapshot
     }
-    threats.forEach { registeredListener.threatDetected(it) }
+    threats.forEach { listener.threatDetected(it) }
 
     val malware = synchronized(malwareCache) {
       val snapshot = malwareCache.toMutableList()
@@ -54,7 +70,7 @@ internal class ThreatDispatcher {
       snapshot
     }
     if (malware.isNotEmpty()) {
-      registeredListener.malwareDetected(malware)
+      listener.malwareDetected(malware)
     }
   }
 }

package/example/src/App.tsx

@@ -221,7 +221,7 @@ const App = () => {
         )
       );
     },
-    // Android only
+    // Android & iOS
     timeSpoofing: () => {
       setAppChecks((currentState) =>
         currentState.map((threat) =>

package/example/src/checks.ts

@@ -11,6 +11,7 @@ export const commonChecks = [
   { name: 'Unofficial Store', status: 'ok' },
   { name: 'Screenshot', status: 'ok' },
   { name: 'Screen Recording', status: 'ok' },
+  { name: 'Time Spoofing', status: 'ok' },
 ];
 
 export const iosChecks = [{ name: 'Device ID', status: 'ok' }];
@@ -21,7 +22,6 @@ export const androidChecks = [
   { name: 'Malware', status: 'ok' },
   { name: 'ADB Enabled', status: 'ok' },
   { name: 'Multi Instance', status: 'ok' },
-  { name: 'Time Spoofing', status: 'ok' },
   { name: 'Location Spoofing', status: 'ok' },
   { name: 'Unsecure Wifi', status: 'ok' },
   { name: 'Automation', status: 'ok' },