capacitor-freerasp 2.2.1 → 2.3.0

package/CHANGELOG.md

@@ -5,8 +5,79 @@ 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).
 
+## [2.3.0] - 2025-12-15
+
+- Android SDK version: 17.0.1
+- iOS SDK version: 6.13.0
+
+### Capacitor
+
+#### Added
+
+- Added `killOnBypass` to `TalsecConfig` that configures if the app should be terminated when the threat callbacks are suppressed/hooked by an attacker (Android only) ([Issue 65](https://github.com/talsec/Free-RASP-Android/issues/65))
+- Added API for `timeSpoofing` callback into `ThreatEventActions` (Android only)
+- Added API for `unsecureWifi` callback into `ThreatEventActions` (Android only)
+- Added API for `allChecksFinished` callback into new `RaspExecutionStateEventActions` object
+- Added matched permissions to `SuspiciousAppInfo` object when malware detection reason is `suspiciousPermission`
+
+#### Fixed
+
+- Resolved potential collision in threat identifiers
+
+### Android
+
+#### Added
+
+- Added `killOnBypass` method to the `TalsecConfig.Builder` that configures if the app should be terminated when the threat callbacks are suppressed/hooked by an attacker [Issue 65](https://github.com/talsec/Free-RASP-Android/issues/65)
+- We are introducing a new capability, detecting whether the device time has been tampered with (`timeSpoofing`)
+- We are introducing a new capability, detecting whether the location is being spoofed on the device (`locationSpoofing`)
+- We are introducing a new capability, detection of unsecure WiFi (`unecureWifi`)
+- Removed deprecated functionality `Pbkdf2Native` and both related native libraries (`libpbkdf2_native.so` and `libpolarssl.so`)
+- Added new `RaspExecutionState` which contains `onAllChecksFinished()` method, which is triggered after all checks are completed.
+- Added matched permissions to `SuspiciousAppInfo` object when malware detection reason is `suspiciousPermission`
+- New option to start Talsec, `Talsec.start()` takes new parameter `TalsecMode` that determines the dispatcher thread of initialization and sync checks (uses background thread by default)
+- Capability to check if another app has an option `REQUEST_INSTALL_PACKAGES` enabled in the system settings to malware detection
+
+#### Fixed
+
+- Root detection related bugs causing false positives
+- ANR issue caused by `registerScreenCaptureCallback()` method on the main thread
+- `NullPointerException` when checking key alias in Keystore on Android 7
+- `JaCoCo` issue causing `MethodTooLargeException` during instrumentation
+- `DeadApplicationException` when calling `Settings.Global.getInt` or `Settings.Secure.getInt` on invalid context
+- `AndroidKeyStore` crashes causing `java.util.concurrent.TimeoutException` when calling `finalize()` method on `Cipher` (GC issues)
+- Fixed issue with late initializers and `TalsecMode` coroutines scopes
+
+
+#### Changed
+
+- Deprecated Nexus repository removed (GCP artifact registry is the main supported distribution repository)
+- Shortened the value of threat detection interval
+- Refactoring of internal architecture of SDK that newly uses Coroutines to manage threading
+- Update of internal dependencies and security libraries
+
+### iOS
+
+#### Changed
+
+- Updated internal dependencies
+
+## [2.2.2] - 2025-08-12
+
+- iOS SDK version: 6.12.1
+- Android SDK version: 16.0.2
+
+### Capacitor
+
+#### Fixed
+
+- Added missing `proguard-rules.pro` into package on npmjs
+
 ## [2.2.1] - 2025-08-05
 
+- iOS SDK version: 6.12.1
+- Android SDK version: 16.0.2
+
 ### Android
 
 #### Fixed

package/CapacitorFreerasp.podspec

@@ -10,7 +10,7 @@ Pod::Spec.new do |s|
   s.homepage = package['repository']['url']
   s.author = package['author']
   s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
-  s.source_files = 'ios/Plugin/*.{swift,h,m,c,cc,mm,cpp}', 'ios/Plugin/TalsecRuntime.xcframework'
+  s.source_files = 'ios/Plugin/models/*.{swift,h,m,c,cc,mm,cpp}', 'ios/Plugin/utils/*.{swift,h,m,c,cc,mm,cpp}', 'ios/Plugin/*.{swift,h,m,c,cc,mm,cpp}', 'ios/Plugin/TalsecRuntime.xcframework'
   s.ios.deployment_target  = '13.0'
   s.dependency 'Capacitor'
   s.swift_version = '5.1'

package/README.md

@@ -6,9 +6,9 @@
 
 # freeRASP for Capacitor
 
-freeRASP for Capacitor is a mobile in-app protection and security monitoring plugin. It aims to cover the main aspects of RASP (Runtime App Self Protection) and application shielding.
+freeRASP for Capacitor is a mobile in-app threat detection and security monitoring plugin. It aims to cover the main aspects of RASP (Runtime App Self Protection) and application shielding.
 
-:loudspeaker: [The official documentation has been moved to a new location. You can now find it here](https://docs.talsec.app/docs-and-articles-portal). :loudspeaker:
+:loudspeaker: [The official documentation has been moved to a new location. You can now find it here](https://docs.talsec.app/docs-and-articles-portal?utm_source=github). :loudspeaker:
 
 # Overview
 
@@ -28,7 +28,7 @@ Key features are the detection and prevention of
 - Untrusted installation method
 - App/Device (un)binding
 
-Additional freeRASP features include low latency, easy integration and a weekly [Security Report](https://docs.talsec.app/freerasp/security-report) containing detailed information about detected incidents and potential threats, summarizing the state of your app security.
+Additional freeRASP features include low latency, easy integration and a weekly [Security Report](https://docs.talsec.app/freerasp/security-report?utm_source=github) containing detailed information about detected incidents and potential threats, summarizing the state of your app security.
 
 The commercial version provides a top-notch protection level, extra features, support and maintenance. One of the most valued commercial features is AppiCrypt® - App Integrity Cryptogram.
 
@@ -41,7 +41,7 @@ It allows easy to implement API protection and App Integrity verification on the
 
 It is a unified solution that works across all mobile platforms without dependency on external web services (i.e., without extra latency, an additional point of failure, and maintenance costs).
 
-Learn more about commercial features at [https://talsec.app](https://talsec.app).
+Learn more about commercial features at [https://talsec.app](https://talsec.app?utm_source=github).
 
 Learn more about freemium freeRASP features at [GitHub main repository](https://github.com/talsec/Free-RASP-Community).
 
@@ -54,17 +54,17 @@ After the integration of freeRASP, make sure you visit the [freeMalwareDetection
 
 Visit the [GitBook page](https://docs.talsec.app/freerasp) for comprehensive and up-to-date guides, tutorials, and technical documentation specifically for freeRASP. It serves as your go-to resource, offering everything from basic instructions to advanced tips and tricks to help you get the most out of the project.
 
-:loudspeaker: [The official documentation has been moved to a new location. You can now find it here](https://docs.talsec.app/docs-and-articles-portal). :loudspeaker:
+:loudspeaker: [The official documentation has been moved to a new location. You can now find it here](https://docs.talsec.app/docs-and-articles-portal?utm_source=github). :loudspeaker:
 
 ## :link: Integration Guide
 
-For integrating freeRASP on the Capacitor platform, be sure to follow all the steps in the [Integration Guide](https://docs.talsec.app/freerasp/integration). This guide provides detailed instructions to help you achieve a smooth and efficient integration.
+For integrating freeRASP on the Capacitor platform, be sure to follow all the steps in the [Integration Guide](https://docs.talsec.app/freerasp/integration?utm_source=github). This guide provides detailed instructions to help you achieve a smooth and efficient integration.
 
 Be sure to bookmark it and stay informed! :books: :sparkles:.
 
 # :rocket: What's New and Changelog
 
-Stay informed and make the most of freeRASP by checking out [What's New and Changelog](https://docs.talsec.app/freerasp/whats-new-and-changelog)! Here, you’ll discover the latest features, enhancements, and bug fixes we’ve implemented to improve your experience across all platforms, including Android, iOS, Flutter, React Native, Capacitor, and Cordova. 
+Stay informed and make the most of freeRASP by checking out [What's New and Changelog](https://docs.talsec.app/freerasp/whats-new-and-changelog?utm_source=github)! Here, you’ll discover the latest features, enhancements, and bug fixes we’ve implemented to improve your experience across all platforms, including Android, iOS, Flutter, React Native, Capacitor, and Cordova. 
 
 Don’t miss out on any updates and explore the changelog to see how we’re continually making freeRASP better for you!
 
@@ -76,4 +76,4 @@ You can check out the project board [here](https://github.com/orgs/talsec/projec
 
 # :page_facing_up: License
 
-This project is provided as freemium software, i.e. there is a [fair usage policy](https://docs.talsec.app/freerasp/features-and-pricing-plans#plans-comparison) that imposes some limitations on the free usage. The SDK software consists of open-source and binary parts, which is the property of Talsec. The open-source part is licensed under the MIT License - see the LICENSE file for details.
+This project is provided as freemium software, i.e. there is a [fair usage policy](https://docs.talsec.app/freerasp/features-and-pricing-plans#plans-comparison?utm_source=github) that imposes some limitations on the free usage. The SDK software consists of open-source and binary parts, which is the property of Talsec. The open-source part is licensed under the MIT License - see the LICENSE file for details.

package/android/build.gradle

@@ -76,5 +76,5 @@ dependencies {
     androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
     androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
     
-    implementation 'com.aheaditec.talsec.security:TalsecSecurity-Community-Capacitor:16.0.2'
+    implementation 'com.aheaditec.talsec.security:TalsecSecurity-Community-Capacitor:17.0.1'
 }

package/android/proguard-rules.pro

@@ -0,0 +1,23 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile
+
+-dontwarn java.lang.invoke.StringConcatFactory

package/android/src/main/java/com/aheaditec/freerasp/FreeraspPlugin.kt

@@ -12,6 +12,9 @@ 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.ThreatListener
+import com.aheaditec.freerasp.events.BaseRaspEvent
+import com.aheaditec.freerasp.events.RaspExecutionStateEvent
+import com.aheaditec.freerasp.events.ThreatEvent
 import com.getcapacitor.JSObject
 import com.getcapacitor.Plugin
 import com.getcapacitor.PluginCall
@@ -23,7 +26,7 @@ import org.json.JSONArray
 class FreeraspPlugin : Plugin() {
 
     private val threatHandler = TalsecThreatHandler(this)
-    private val listener = ThreatListener(threatHandler, threatHandler)
+    private val listener = ThreatListener(threatHandler, threatHandler, threatHandler)
     private var registered = true
 
     @PluginMethod
@@ -97,29 +100,51 @@ class FreeraspPlugin : Plugin() {
      */
     @PluginMethod
     fun getThreatIdentifiers(call: PluginCall) {
-        call.resolve(JSObject().put("ids", Threat.getThreatValues()))
+        call.resolve(JSObject().put("ids", ThreatEvent.ALL_EVENTS))
     }
 
     /**
-     * Method to setup the message passing between native and React Native
-     * @return list of [THREAT_CHANNEL_NAME, THREAT_CHANNEL_KEY]
+     * Method to get the random identifiers of callbacks
+     */
+    @PluginMethod
+    fun getRaspExecutionStateIdentifiers(call: PluginCall) {
+        call.resolve(JSObject().put("ids", RaspExecutionStateEvent.ALL_EVENTS))
+    }
+
+    /**
+     * Method to setup the message passing between native and Capacitor
+     * @return list of [CHANNEL_NAME, CHANNEL_KEY, MALWARE_CHANNEL_KEY]
      */
     @PluginMethod
     fun getThreatChannelData(call: PluginCall) {
         val channelData = JSONArray(
             (listOf(
-                THREAT_CHANNEL_NAME, THREAT_CHANNEL_KEY, MALWARE_CHANNEL_KEY
+                ThreatEvent.CHANNEL_NAME, ThreatEvent.CHANNEL_KEY, ThreatEvent.MALWARE_CHANNEL_KEY
             ))
         )
         call.resolve(JSObject().put("ids", channelData))
     }
 
+    /**
+     * Method to setup the execution state message passing between native and Capacitor
+     * @return list of [CHANNEL_NAME, CHANNEL_KEY]
+     */
+     @PluginMethod
+     fun getRaspExecutionStateChannelData(call: PluginCall) {
+        val channelData = JSONArray(
+            (listOf(
+                RaspExecutionStateEvent.CHANNEL_NAME, RaspExecutionStateEvent.CHANNEL_KEY
+            ))
+        )
+        call.resolve(JSObject().put("ids", channelData))
+     }
+
     /**
      * We never send an invalid callback over our channel.
      * Therefore, if this happens, we want to kill the app.
      */
     @PluginMethod
-    fun onInvalidCallback() {
+    fun onInvalidCallback(call: PluginCall) {
         android.os.Process.killProcess(android.os.Process.myPid())
     }
 
@@ -179,7 +204,7 @@ class FreeraspPlugin : Plugin() {
 
         activity?.runOnUiThread {
             try {
-                Talsec.blockScreenCapture(context, enable)
+                Talsec.blockScreenCapture(activity, enable)
                 call.resolve(JSObject().put("result", true))
             } catch (e: Exception) {
                 call.reject(
@@ -224,11 +249,12 @@ class FreeraspPlugin : Plugin() {
                 "Error during storeExternalId operation in freeRASP Native Plugin",
                 "NativePluginError"
             )
+            return
         }
     }
 
-    internal fun notifyListeners(threat: Threat) {
-        notifyListeners(THREAT_CHANNEL_NAME, JSObject().put(THREAT_CHANNEL_KEY, threat.value), true)
+    internal fun notifyListeners(event: BaseRaspEvent) {
+        notifyListeners(event.channelName, JSObject().put(event.channelKey, event.value), true)
     }
 
     internal fun notifyMalware(suspiciousApps: MutableList<SuspiciousAppInfo>) {
@@ -238,9 +264,9 @@ class FreeraspPlugin : Plugin() {
             val encodedSuspiciousApps = suspiciousApps.toEncodedJSArray(context)
             mainHandler.post {
                 val params = JSObject()
-                    .put(THREAT_CHANNEL_KEY, Threat.Malware.value)
-                    .put(MALWARE_CHANNEL_KEY, encodedSuspiciousApps)
-                notifyListeners(THREAT_CHANNEL_NAME, params, true)
+                    .put(ThreatEvent.CHANNEL_KEY, ThreatEvent.Malware.value)
+                    .put(ThreatEvent.MALWARE_CHANNEL_KEY, encodedSuspiciousApps)
+                notifyListeners(ThreatEvent.CHANNEL_NAME, params, true)
             }
         }
     }
@@ -253,6 +279,7 @@ class FreeraspPlugin : Plugin() {
             .watcherMail(configJson.getString("watcherMail"))
             .supportedAlternativeStores(androidConfig.getArraySafe("supportedAlternativeStores"))
             .prod(configJson.getBool("isProd") ?: true)
+            .killOnBypass(configJson.getBool("killOnBypass") ?: false)
 
         if (androidConfig.has("malwareConfig")) {
             val malwareConfig = androidConfig.getJSONObject("malwareConfig")
@@ -266,12 +293,6 @@ class FreeraspPlugin : Plugin() {
 
 
     companion object {
-        private val THREAT_CHANNEL_NAME = (10000..999999999).random()
-            .toString() // name of the channel over which threat callbacks are sent
-        private val THREAT_CHANNEL_KEY = (10000..999999999).random()
-            .toString() // key of the argument map under which threats are expected
-        private val MALWARE_CHANNEL_KEY = (10000..999999999).random()
-            .toString() // key of the argument map under which malware data is expected
         private val backgroundHandlerThread = HandlerThread("BackgroundThread").apply { start() }
         private val backgroundHandler = Handler(backgroundHandlerThread.looper)
         private val mainHandler = Handler(Looper.getMainLooper())

package/android/src/main/java/com/aheaditec/freerasp/ScreenProtector.kt

@@ -11,6 +11,7 @@ import android.view.WindowManager.SCREEN_RECORDING_STATE_VISIBLE
 import androidx.annotation.RequiresApi
 import androidx.core.content.ContextCompat
 import com.aheaditec.talsec_security.security.api.Talsec
+import com.aheaditec.freerasp.events.ThreatEvent
 import java.util.function.Consumer
 
 @RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
@@ -18,14 +19,35 @@ internal object ScreenProtector {
     private const val TAG = "TalsecScreenProtector"
     private const val SCREEN_CAPTURE_PERMISSION = "android.permission.DETECT_SCREEN_CAPTURE"
     private const val SCREEN_RECORDING_PERMISSION = "android.permission.DETECT_SCREEN_RECORDING"
+
     private var registered = false
-    private val screenCaptureCallback = ScreenCaptureCallback { Talsec.onScreenshotDetected() }
+    private val cachedThreats = mutableSetOf<ThreatEvent>()
+
+    private val screenCaptureCallback = ScreenCaptureCallback { handleThreat(ThreatEvent.Screenshot) }
     private val screenRecordCallback: Consumer<Int> = Consumer<Int> { state ->
         if (state == SCREEN_RECORDING_STATE_VISIBLE) {
-            Talsec.onScreenRecordingDetected()
+            handleThreat(ThreatEvent.ScreenRecording)
+        }
+    }
+
+    private fun handleThreat(threat: ThreatEvent) {
+        if(!FreeraspPlugin.talsecStarted) {
+            cachedThreats.add(threat)
+            return
+        }
+
+        when (threat) {
+            ThreatEvent.Screenshot -> Talsec.onScreenshotDetected()
+            ThreatEvent.ScreenRecording -> Talsec.onScreenRecordingDetected()
+            else -> throw IllegalArgumentException("Unexpected Threat type: $threat")
         }
     }
 
+    internal fun flushCache() {
+        cachedThreats.forEach { handleThreat(it) }
+        cachedThreats.clear()
+    }
+
     /**
      * Registers screenshot and screen recording detector with the given activity
      *

package/android/src/main/java/com/aheaditec/freerasp/ThreatHandler.kt

@@ -2,75 +2,93 @@ package com.aheaditec.freerasp
 
 import com.aheaditec.talsec_security.security.api.SuspiciousAppInfo
 import com.aheaditec.talsec_security.security.api.ThreatListener
+import com.aheaditec.freerasp.events.RaspExecutionStateEvent
+import com.aheaditec.freerasp.events.ThreatEvent
 
 internal class TalsecThreatHandler(private val instance: FreeraspPlugin) :
-    ThreatListener.ThreatDetected, ThreatListener.DeviceState {
+    ThreatListener.ThreatDetected, ThreatListener.DeviceState, ThreatListener.RaspExecutionState() {
 
     override fun onRootDetected() {
-        instance.notifyListeners(Threat.PrivilegedAccess)
+        instance.notifyListeners(ThreatEvent.PrivilegedAccess)
     }
 
     override fun onDebuggerDetected() {
-        instance.notifyListeners(Threat.Debug)
+        instance.notifyListeners(ThreatEvent.Debug)
     }
 
     override fun onEmulatorDetected() {
-        instance.notifyListeners(Threat.Simulator)
+        instance.notifyListeners(ThreatEvent.Simulator)
     }
 
     override fun onTamperDetected() {
-        instance.notifyListeners(Threat.AppIntegrity)
+        instance.notifyListeners(ThreatEvent.AppIntegrity)
     }
 
     override fun onUntrustedInstallationSourceDetected() {
-        instance.notifyListeners(Threat.UnofficialStore)
+        instance.notifyListeners(ThreatEvent.UnofficialStore)
     }
 
     override fun onHookDetected() {
-        instance.notifyListeners(Threat.Hooks)
+        instance.notifyListeners(ThreatEvent.Hooks)
     }
 
     override fun onDeviceBindingDetected() {
-        instance.notifyListeners(Threat.DeviceBinding)
+        instance.notifyListeners(ThreatEvent.DeviceBinding)
     }
 
     override fun onObfuscationIssuesDetected() {
-        instance.notifyListeners(Threat.ObfuscationIssues)
+        instance.notifyListeners(ThreatEvent.ObfuscationIssues)
     }
 
-    override fun onMalwareDetected(suspiciousAppInfos: MutableList<SuspiciousAppInfo>?) {
+    override fun onMalwareDetected(suspiciousAppInfos: MutableList<SuspiciousAppInfo>) {
         instance.notifyMalware(suspiciousAppInfos ?: mutableListOf())
     }
 
     override fun onUnlockedDeviceDetected() {
-        instance.notifyListeners(Threat.Passcode)
+        instance.notifyListeners(ThreatEvent.Passcode)
     }
 
     override fun onHardwareBackedKeystoreNotAvailableDetected() {
-        instance.notifyListeners(Threat.SecureHardwareNotAvailable)
+        instance.notifyListeners(ThreatEvent.SecureHardwareNotAvailable)
     }
 
     override fun onDeveloperModeDetected() {
-        instance.notifyListeners(Threat.DevMode)
+        instance.notifyListeners(ThreatEvent.DevMode)
     }
 
     override fun onADBEnabledDetected() {
-        instance.notifyListeners(Threat.ADBEnabled)
+        instance.notifyListeners(ThreatEvent.ADBEnabled)
     }
 
     override fun onSystemVPNDetected() {
-        instance.notifyListeners(Threat.SystemVPN)
+        instance.notifyListeners(ThreatEvent.SystemVPN)
     }
 
     override fun onScreenshotDetected() {
-        instance.notifyListeners(Threat.Screenshot)
+        instance.notifyListeners(ThreatEvent.Screenshot)
     }
 
     override fun onScreenRecordingDetected() {
-        instance.notifyListeners(Threat.ScreenRecording)
+        instance.notifyListeners(ThreatEvent.ScreenRecording)
     }
 
     override fun onMultiInstanceDetected() {
-        instance.notifyListeners(Threat.MultiInstance)
+        instance.notifyListeners(ThreatEvent.MultiInstance)
+    }
+
+    override fun onUnsecureWifiDetected() {
+        instance.notifyListeners(ThreatEvent.UnsecureWifi)
+    }
+
+    override fun onTimeSpoofingDetected() {
+        instance.notifyListeners(ThreatEvent.TimeSpoofing)
+    }
+
+    override fun onLocationSpoofingDetected() {
+        instance.notifyListeners(ThreatEvent.LocationSpoofing)
+    }
+
+    override fun onAllChecksFinished() {
+        instance.notifyListeners(RaspExecutionStateEvent.AllChecksFinished)
     }
 }

package/android/src/main/java/com/aheaditec/freerasp/events/BaseRaspEvent.kt

@@ -0,0 +1,7 @@
+package com.aheaditec.freerasp.events
+
+internal interface BaseRaspEvent {
+    val value: Int
+    val channelName: String
+    val channelKey: String
+}

package/android/src/main/java/com/aheaditec/freerasp/events/RaspExecutionStateEvent.kt

@@ -0,0 +1,22 @@
+package com.aheaditec.freerasp.events
+
+import com.aheaditec.freerasp.utils.RandomGenerator
+import org.json.JSONArray
+
+internal sealed class RaspExecutionStateEvent(override val value: Int) : BaseRaspEvent {
+    override val channelName: String get() = CHANNEL_NAME
+    override val channelKey: String get() = CHANNEL_KEY
+
+    object AllChecksFinished : RaspExecutionStateEvent(RandomGenerator.next())
+
+    companion object {
+        internal val CHANNEL_NAME = RandomGenerator.next().toString()
+        internal val CHANNEL_KEY = RandomGenerator.next().toString()
+
+        internal val ALL_EVENTS = JSONArray(
+            listOf(
+                AllChecksFinished.value
+            )
+        )
+    }
+}

package/android/src/main/java/com/aheaditec/freerasp/events/ThreatEvent.kt

@@ -0,0 +1,69 @@
+package com.aheaditec.freerasp.events
+
+import com.aheaditec.freerasp.utils.RandomGenerator
+import org.json.JSONArray
+
+/**
+ * Sealed class to represent the error codes.
+ *
+ * Sealed classes are used because of obfuscation - enums classes are not obfuscated well enough.
+ *
+ * @property value integer value of the error code.
+ */
+internal sealed class ThreatEvent(override val value: Int) : BaseRaspEvent {
+    override val channelName: String get() = CHANNEL_NAME
+    override val channelKey: String get() = CHANNEL_KEY
+
+    object AppIntegrity : ThreatEvent(RandomGenerator.next())
+    object PrivilegedAccess : ThreatEvent(RandomGenerator.next())
+    object Debug : ThreatEvent(RandomGenerator.next())
+    object Hooks : ThreatEvent(RandomGenerator.next())
+    object Passcode : ThreatEvent(RandomGenerator.next())
+    object Simulator : ThreatEvent(RandomGenerator.next())
+    object SecureHardwareNotAvailable : ThreatEvent(RandomGenerator.next())
+    object DeviceBinding : ThreatEvent(RandomGenerator.next())
+    object UnofficialStore : ThreatEvent(RandomGenerator.next())
+    object ObfuscationIssues : ThreatEvent(RandomGenerator.next())
+    object SystemVPN : ThreatEvent(RandomGenerator.next())
+    object DevMode : ThreatEvent(RandomGenerator.next())
+    object Malware : ThreatEvent(RandomGenerator.next())
+    object ADBEnabled : ThreatEvent(RandomGenerator.next())
+    object Screenshot : ThreatEvent(RandomGenerator.next())
+    object ScreenRecording : ThreatEvent(RandomGenerator.next())
+    object MultiInstance : ThreatEvent(RandomGenerator.next())
+    object TimeSpoofing : ThreatEvent(RandomGenerator.next())
+    object LocationSpoofing : ThreatEvent(RandomGenerator.next())
+    object UnsecureWifi : ThreatEvent(RandomGenerator.next())
+
+    companion object {
+
+        internal val CHANNEL_NAME = RandomGenerator.next().toString()
+        internal val CHANNEL_KEY = RandomGenerator.next().toString()
+        internal val MALWARE_CHANNEL_KEY = RandomGenerator.next().toString()
+
+        internal val ALL_EVENTS = JSONArray(
+            listOf(
+                AppIntegrity,
+                PrivilegedAccess,
+                Debug,
+                Hooks,
+                Passcode,
+                Simulator,
+                SecureHardwareNotAvailable,
+                SystemVPN,
+                DeviceBinding,
+                UnofficialStore,
+                ObfuscationIssues,
+                DevMode,
+                Malware,
+                ADBEnabled,
+                Screenshot,
+                ScreenRecording,
+                MultiInstance,
+                TimeSpoofing,
+                LocationSpoofing,
+                UnsecureWifi
+            ).map { it.value }
+        )
+    }
+}

package/android/src/main/java/com/aheaditec/freerasp/models/CapSuspiciousAppInfo.kt

@@ -10,6 +10,7 @@ import kotlinx.serialization.Serializable
 data class CapSuspiciousAppInfo(
     val packageInfo: CapPackageInfo,
     val reason: String,
+    val permissions: Set<String>?
 )
 
 /**

package/android/src/main/java/com/aheaditec/freerasp/utils/Extensions.kt

@@ -57,6 +57,7 @@ internal fun SuspiciousAppInfo.toCapSuspiciousAppInfo(context: Context): CapSusp
     return CapSuspiciousAppInfo(
         packageInfo = this.packageInfo.toCapPackageInfo(context),
         reason = this.reason,
+        permissions = this.permissions
     )
 }
 

package/android/src/main/java/com/aheaditec/freerasp/utils/RandomGenerator.kt

@@ -0,0 +1,24 @@
+package com.aheaditec.freerasp.utils
+
+import java.security.SecureRandom
+import java.util.concurrent.ConcurrentHashMap
+
+internal object RandomGenerator {
+    private val secureRandom = SecureRandom()
+
+    private val generatedNumbers = ConcurrentHashMap.newKeySet<Int>()
+
+    internal fun next(): Int {
+        val min = 10_000_000
+        val max = 999_999_999
+        val range = (max - min) + 1
+
+        var nextNumber: Int
+        do {
+            nextNumber = secureRandom.nextInt(range) + min
+        } while (!generatedNumbers.add(nextNumber))
+
+        return nextNumber
+    }
+
+}

package/android/src/main/java/com/aheaditec/freerasp/utils/Utils.kt

@@ -9,6 +9,8 @@ import android.os.Build
 import android.util.Base64
 import android.util.Log
 import java.io.ByteArrayOutputStream
+import androidx.core.graphics.createBitmap
+
 
 internal object Utils {
 
@@ -42,11 +44,7 @@ internal object Utils {
             }
 
             if (drawable.intrinsicWidth > 0 && drawable.intrinsicHeight > 0) {
-                val bitmap = Bitmap.createBitmap(
-                    drawable.intrinsicWidth,
-                    drawable.intrinsicHeight,
-                    Bitmap.Config.ARGB_8888
-                )
+                val bitmap = createBitmap(drawable.intrinsicWidth, drawable.intrinsicHeight)
                 val canvas = Canvas(bitmap)
                 drawable.setBounds(0, 0, canvas.width, canvas.height)
                 drawable.draw(canvas)

package/dist/esm/api/listeners/raspExecutionState.d.ts

@@ -0,0 +1,2 @@
+import type { RaspExecutionStateEventActions } from '../../types/types';
+export declare const registerRaspExecutionStateListener: (config: RaspExecutionStateEventActions) => Promise<void>;