capacitor-freerasp 2.3.0 → 2.4.0

package/ios/Plugin/FreeraspPlugin.swift

@@ -6,21 +6,17 @@ import TalsecRuntime
 public class FreeraspPlugin: CAPPlugin {
 
     public static var shared: FreeraspPlugin?
-
-    static var threatCache = Set<SecurityThreat>()
-    static var executionStateCache = Set<RaspExecutionStates>()
     
     override public func load() {
         FreeraspPlugin.shared = self
-        FreeraspPlugin.flushCache()
-    }
-
-    private static func flushCache() {
-        FreeraspPlugin.threatCache.forEach(FreeraspPlugin.dispatchEvent)
-        FreeraspPlugin.threatCache.removeAll()
-
-        FreeraspPlugin.executionStateCache.forEach(FreeraspPlugin.dispatchRaspExecutionStateEvent)
-        FreeraspPlugin.executionStateCache.removeAll()
+        
+        ThreatDispatcher.shared.listener = { [weak self] threat in
+            self?.notifyListeners(EventIdentifiers.threatChannelName, data: [EventIdentifiers.threatChannelKey: threat.callbackIdentifier], retainUntilConsumed: true)
+        }
+        
+        ExecutionStateDispatcher.shared.listener = { [weak self] event in
+            self?.notifyListeners(EventIdentifiers.raspExecutionStateChannelName, data: [EventIdentifiers.raspExecutionStateChannelKey: event.callbackIdentifier], retainUntilConsumed: true)
+        }
     }
     
     /// Runs Talsec with given configuration
@@ -49,6 +45,11 @@ public class FreeraspPlugin: CAPPlugin {
         UserDefaults.standard.set(externalId, forKey: "app.talsec.externalid")
         call.resolve(["result": true])
     }
+    
+    @objc func removeExternalId(_ call: CAPPluginCall) -> Void {
+        UserDefaults.standard.removeObject(forKey: "app.talsec.externalid")
+        call.resolve(["result": true])
+    }
 
     @objc func blockScreenCapture(_ call: CAPPluginCall) -> Void {
         guard let enable = call.getBool("enable") else {
@@ -76,22 +77,6 @@ public class FreeraspPlugin: CAPPlugin {
             }
         }
     }
-
-    static func dispatchEvent(securityThreat: SecurityThreat) {
-        if let instance = FreeraspPlugin.shared {
-            instance.notifyListeners(EventIdentifiers.threatChannelName, data: [EventIdentifiers.threatChannelKey: securityThreat.callbackIdentifier], retainUntilConsumed: true)
-        } else {
-            FreeraspPlugin.threatCache.insert(securityThreat)
-        }
-    }
-
-    static func dispatchRaspExecutionStateEvent(event: RaspExecutionStates) -> Void {
-        if let instance = FreeraspPlugin.shared {
-            instance.notifyListeners(EventIdentifiers.raspExecutionStateChannelName, data: [EventIdentifiers.raspExecutionStateChannelKey: event.callbackIdentifier], retainUntilConsumed: true)
-        } else {
-            FreeraspPlugin.executionStateCache.insert(event)
-        }
-    }
     
     /**
      * Method to setup the message passing between native and Capacitor
@@ -160,11 +145,10 @@ extension SecurityThreatCenter:  @retroactive SecurityThreatHandler, @retroactiv
         if (securityThreat.rawValue == "passcodeChange") {
             return
         }
-
-        FreeraspPlugin.dispatchEvent(securityThreat: securityThreat)
+        ThreatDispatcher.shared.dispatch(threat: securityThreat)
     }
     
     public func onAllChecksFinished() {
-        FreeraspPlugin.dispatchRaspExecutionStateEvent(event: RaspExecutionStates.allChecksFinished)
+        ExecutionStateDispatcher.shared.dispatch(event: RaspExecutionStates.allChecksFinished)
     }
-}
+}

package/ios/Plugin/dispatchers/ExecutionStateDispatcher.swift

@@ -0,0 +1,35 @@
+import Foundation
+
+class ExecutionStateDispatcher {
+    static let shared = ExecutionStateDispatcher()
+    private var cache: Set<RaspExecutionStates> = []
+    private let lock = NSLock()
+    
+    var listener: ((RaspExecutionStates) -> Void)? {
+        didSet {
+            if listener != nil {
+                flushCache()
+            }
+        }
+    }
+
+    func dispatch(event: RaspExecutionStates) {
+        lock.lock()
+        defer { lock.unlock() }
+        
+        if let listener = listener {
+            listener(event)
+        } else {
+            cache.insert(event)
+        }
+    }
+
+    private func flushCache() {
+        lock.lock()
+        let events = cache
+        cache.removeAll()
+        lock.unlock()
+        
+        events.forEach { listener?($0) }
+    }
+}

package/ios/Plugin/dispatchers/ThreatDispatcher.swift

@@ -0,0 +1,36 @@
+import Foundation
+import TalsecRuntime
+
+class ThreatDispatcher {
+    static let shared = ThreatDispatcher()
+    private var threatCache: Set<SecurityThreat> = []
+    private let lock = NSLock()
+    
+    var listener: ((SecurityThreat) -> Void)? {
+        didSet {
+            if listener != nil {
+                flushCache()
+            }
+        }
+    }
+
+    func dispatch(threat: SecurityThreat) {
+        lock.lock()
+        defer { lock.unlock() }
+        
+        if let listener = listener {
+            listener(threat)
+        } else {
+            threatCache.insert(threat)
+        }
+    }
+
+    private func flushCache() {
+        lock.lock()
+        let threats = threatCache
+        threatCache.removeAll()
+        lock.unlock()
+        
+        threats.forEach { listener?($0) }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capacitor-freerasp",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "Capacitor plugin for improving app security and threat monitoring on Android and iOS mobile devices",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",

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

@@ -1,94 +0,0 @@
-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.RaspExecutionState() {
-
-    override fun onRootDetected() {
-        instance.notifyListeners(ThreatEvent.PrivilegedAccess)
-    }
-
-    override fun onDebuggerDetected() {
-        instance.notifyListeners(ThreatEvent.Debug)
-    }
-
-    override fun onEmulatorDetected() {
-        instance.notifyListeners(ThreatEvent.Simulator)
-    }
-
-    override fun onTamperDetected() {
-        instance.notifyListeners(ThreatEvent.AppIntegrity)
-    }
-
-    override fun onUntrustedInstallationSourceDetected() {
-        instance.notifyListeners(ThreatEvent.UnofficialStore)
-    }
-
-    override fun onHookDetected() {
-        instance.notifyListeners(ThreatEvent.Hooks)
-    }
-
-    override fun onDeviceBindingDetected() {
-        instance.notifyListeners(ThreatEvent.DeviceBinding)
-    }
-
-    override fun onObfuscationIssuesDetected() {
-        instance.notifyListeners(ThreatEvent.ObfuscationIssues)
-    }
-
-    override fun onMalwareDetected(suspiciousAppInfos: MutableList<SuspiciousAppInfo>) {
-        instance.notifyMalware(suspiciousAppInfos ?: mutableListOf())
-    }
-
-    override fun onUnlockedDeviceDetected() {
-        instance.notifyListeners(ThreatEvent.Passcode)
-    }
-
-    override fun onHardwareBackedKeystoreNotAvailableDetected() {
-        instance.notifyListeners(ThreatEvent.SecureHardwareNotAvailable)
-    }
-
-    override fun onDeveloperModeDetected() {
-        instance.notifyListeners(ThreatEvent.DevMode)
-    }
-
-    override fun onADBEnabledDetected() {
-        instance.notifyListeners(ThreatEvent.ADBEnabled)
-    }
-
-    override fun onSystemVPNDetected() {
-        instance.notifyListeners(ThreatEvent.SystemVPN)
-    }
-
-    override fun onScreenshotDetected() {
-        instance.notifyListeners(ThreatEvent.Screenshot)
-    }
-
-    override fun onScreenRecordingDetected() {
-        instance.notifyListeners(ThreatEvent.ScreenRecording)
-    }
-
-    override fun onMultiInstanceDetected() {
-        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)
-    }
-}