AI Assistant

import Sense

AI Assistant

internal import Sense      // Swift 5.9+

AI Assistant

func initiateSense() {
    let senseConfig = SenseConfig()
    senseConfig.apiKey           = "Your Unique Public API Key"
    senseConfig.senseInfo        = false        // true or false
    senseConfig.allowGeoLocation = true         // true or false
    senseConfig.tag              = "index"      // free-form call-site label
    senseConfig.sessionId        = ""           // optional, used for Workflow
    senseConfig.metaInfo = [
        "phone": "9987654532",
        "name":  "kumar"
    ]

    // Certificate pinning — see SSL pinning below
    senseConfig.sensePinningConfig = SensePinningConfig(
        pinSets: [
            SensePinSet(
                host: "www.dempapp.com",
                pins: [
                    "sha256............"
                ]
            )
        ],
        enabled: true
    )

    Sense.initSDK(senseConfig: senseConfig, withDelegate: self)
}

AI Assistant

senseConfig.sensePinningConfig = SensePinningConfig(
    pinSets: [
        SensePinSet(
            host: "api.yourdomain.com",
            pins: [
                "sha256/<leaf-spki-hash>",
                "sha256/<intermediate-spki-hash>",
                "sha256/<backup-spki-hash>"
            ]
        )
    ],
    enabled: true
)

AI Assistant

openssl s_client -servername api.yourdomain.com -connect api.yourdomain.com:443 </dev/null \
  | openssl x509 -pubkey -noout \
  | openssl pkey -pubin -outform der \
  | openssl dgst -sha256 -binary \
  | openssl base64

AI Assistant

openssl s_client -servername api.yourdomain.com -connect api.yourdomain.com:443 -showcerts </dev/null

AI Assistant

extension ViewController: SenseDelegate {
    func onSuccess(data: String) {
        // Success callback — parse the identity payload
    }

    func onFailure(message: String) {
        // Network error, invalid key, or blocked environment
    }
}

AI Assistant

func onSuccess(data: String) {
    guard
        let payload = data.data(using: .utf8),
        let json = try? JSONSerialization.jsonObject(with: payload) as? [String: Any]
    else { return }

    let senseId   = json["sense_id"]   as? String
    let requestId = json["request_id"] as? String
    // Forward senseId / requestId to your backend
}

AI Assistant

Sense.getSenseDetails(withDelegate: self)

AI Assistant

Sense.senseRASPdegate = self

AI Assistant

extension SceneDelegate: SenseRASPDelegate {
    func onJailbreakDetected(isOn: Bool) {
        guard isOn else { return }
        // Block the sensitive flow, warn the user, report to your backend
    }
}

AI Assistant

private func threat(_ label: String, _ isOn: Bool) {
    DispatchQueue.main.async {
        isOn ? ToastManager.show(label) : ToastManager.clear(label)
    }
}

AI Assistant

func sceneDidBecomeActive(_ scene: UIScene) {
    Sense.senseRASPdegate = self

    DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
        if let window = self.window {
            Sense.screenShield(for: window)
        }
    }
}

AI Assistant

SenseScreenShield.shared.activate(for: window)

AI Assistant

<key>NSLocationWhenInUseUsageDescription</key>
<string>This app needs access to your location to provide location-based services.</string>
<key>NSLocationAlwaysAndWhenInUseUsageDescription</key>
<string>Location access is required for enhanced app functionality.</string>

AI Assistant

<key>LSApplicationQueriesSchemes</key>
<array>
    <!-- Remote access -->
    <string>tvcontrol1</string>   <!-- TeamViewer -->
    <string>anydesk</string>      <!-- AnyDesk -->
    <string>rustdesk</string>     <!-- RustDesk -->

    <!-- Meeting / screen share -->
    <string>zoommtg</string>      <!-- Zoom -->
    <string>msteams</string>      <!-- Microsoft Teams -->
    <string>slack</string>        <!-- Slack -->
    <string>skype</string>        <!-- Skype -->
</array>

AI Assistant

<key>LSApplicationQueriesSchemes</key>
<array>
    <string>tvcontrol1</string>
    <string>anydesk</string>
    <string>rustdesk</string>
    <string>zoommtg</string>
    <string>msteams</string>
    <string>slack</string>
    <string>skype</string>
    <string>whatsapp</string>
    <string>tez</string>
    <string>phonepe</string>
    <string>cred</string>
    <string>amazon</string>
</array>

AI Assistant

import UIKit
internal import Sense

@available(iOS 13.0, *)
class SceneDelegate: UIResponder, UIWindowSceneDelegate {

    var window: UIWindow?

    func scene(_ scene: UIScene,
               willConnectTo session: UISceneSession,
               options connectionOptions: UIScene.ConnectionOptions) {
        // Arm runtime protection as early as the scene allows.
        Sense.senseRASPdegate = self
        initiateSense()
    }

    func sceneDidBecomeActive(_ scene: UIScene) {
        Sense.senseRASPdegate = self

        // Window must be attached before the shield can cover it.
        DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
            if let window = self.window {
                Sense.screenShield(for: window)
            }
        }
    }

    func sceneDidDisconnect(_ scene: UIScene)      {}
    func sceneWillResignActive(_ scene: UIScene)   {}
    func sceneWillEnterForeground(_ scene: UIScene){}
    func sceneDidEnterBackground(_ scene: UIScene) {}

    // MARK: - Sense initialization

    func initiateSense() {
        let senseConfig = SenseConfig()
        senseConfig.apiKey           = "Your Unique Public API Key"
        senseConfig.allowGeoLocation = true
        senseConfig.senseInfo        = false
        senseConfig.tag              = "index"
        senseConfig.metaInfo = [
            "phone": "9987654532",
            "name":  "kumar"
        ]
        senseConfig.sensePinningConfig = SensePinningConfig(
            pinSets: [
                SensePinSet(
                    host: "dummyjson.com",
                    pins: [
                        "sha256//1kYlcCuXHofjS1hAFCOx21ULpPjNxh78MyOZ+EXFOQ=",
                        "sha256/kIdp6NNEd8wsugYyyIYFsi1ylMCED3hZbSR8ZFsa/A4=",
                        "sha256/mEflZT5enoR1FuXLgYYGqnVEoZvmf9c2bVBpiOjYQ0c="
                    ]
                )
            ],
            enabled: true
        )

        Sense.initSDK(senseConfig: senseConfig, withDelegate: self)
        Sense.getSenseDetails(withDelegate: self)
    }
}

// MARK: - Device identity

@available(iOS 13.0, *)
extension SceneDelegate: SenseDelegate {

    func onSuccess(data: String) {
        guard
            let payload = data.data(using: .utf8),
            let json = try? JSONSerialization.jsonObject(with: payload) as? [String: Any]
        else { return }

        let senseId   = json["sense_id"]   as? String ?? ""
        let requestId = json["request_id"] as? String ?? ""
        print("Sense ID: \(senseId), Request ID: \(requestId)")
        // Forward to your backend for the authoritative verdict
    }

    func onFailure(message: String) {
        print("Sense failure: \(message)")
    }
}

// MARK: - Runtime protection

@available(iOS 13.0, *)
extension SceneDelegate: SenseRASPDelegate {

    // Device integrity
    func onJailbreakDetected(isOn: Bool)                   { threat("Jailbreak Detected", isOn) }
    func onFridaDetected(isOn: Bool)                       { threat("Frida Detected", isOn) }
    func onSimulatorDetected(isOn: Bool)                   { threat("Simulator Detected", isOn) }
    func onSandboxEnvironment(isOn: Bool)                  { threat("Sandbox Environment Detected", isOn) }
    func onAutomatedInstall(isOn: Bool)                    { threat("Automated Install Detected", isOn) }
    func onDevicePolicyEnforcementDetected(isOn: Bool)     { threat("Device Policy Enforcement Detected", isOn) }
    func onSystemTimeManipulationDetected(isOn: Bool)      { threat("System Time Manipulation Detected", isOn) }
    func onTimeZoneMismatch(isOn: Bool)                    { threat("Timezone Mismatch Detected", isOn) }
    func onMockLocationDetected(isOn: Bool)                { threat("Mock Location Detected", isOn) }
    func onFaceIdChanged(isOn: Bool)                       { threat("Face ID Changes Detected", isOn) }
    func onBiometricStrengthValidationFailed(isOn: Bool)   { threat("Biometric Strength Validation Failed", isOn) }

    // App & memory integrity
    func onChecksumValidationFailed(isOn: Bool)            { threat("Checksum Validation Failed", isOn) }
    func onMemoryProtectionFailed(isOn: Bool)              { threat("Memory Protection Failed", isOn) }
    func onMemoryEditingDetected(isOn: Bool)               { threat("Memory Editing Detected", isOn) }
    func onMemoryTamperingDetected(isOn: Bool)             { threat("Memory Tampering Detected", isOn) }
    func onApplicationDataLeakageDetected(isOn: Bool)      { threat("Application Data Leakage Detected", isOn) }

    // Network
    func onVpnDetected(isOn: Bool)                         { threat("VPN Detected", isOn) }
    func onSystemVPNDetected(isOn: Bool)                   { threat("System VPN Detected", isOn) }
    func onProxyDetected(isOn: Bool)                       { threat("Proxy Detected", isOn) }
    func onSystemProxyDetected(isOn: Bool)                 { threat("System Proxy Detected", isOn) }
    func onNonSSLTLSConnectionDetected(isOn: Bool)         { threat("Non-SSL/TLS Connection Detected", isOn) }
    func onSSLPinningBypassDetected(isOn: Bool)            { threat("SSL Pinning Bypass Detected", isOn) }
    func onIPBlocklisted(isOn: Bool)                       { threat("IP Blocklisted", isOn) }
    func onNetworkSandboxingDetected(isOn: Bool)           { threat("Network Sandboxing Detected", isOn) }
    func onSecureSessionSignallingFailed(isOn: Bool)       { threat("Secure Session Signalling Failed", isOn) }
    func onWifiDetected(isOn: Bool)                        { threat("WiFi Detected", isOn) }

    // Screen capture & remote access
    func onScreenRecordingDetected(isOn: Bool)             { threat("Screen Recording Detected", isOn) }
    func onScreenMirroringDetected(isOn: Bool)             { threat("Screen Mirroring Detected", isOn) }
    func onScreenSharingAppsDetected(isOn: Bool)           { threat("Screen Sharing Apps Detected", isOn) }
    func onMaliciousPiPDetected(isOn: Bool)                { threat("Malicious PiP Detected", isOn) }
    func onRemoteControlDetected(isOn: Bool)               { threat("Remote Control Detected", isOn) }

    // Input & accessibility
    func onThirdPartyKeyboardDetected(isOn: Bool)          { threat("Third-Party Keyboard Detected", isOn) }
    func onUntrustedScreenReaderDetected(isOn: Bool)       { threat("Untrusted Screen Reader Detected", isOn) }
    func onKeystrokeInjectionDetected(isOn: Bool)          { threat("Keystroke Injection Detected", isOn) }
    func onAutoClickerDetected(isOn: Bool)                 { threat("Auto-Clicker Detected", isOn) }

    // Telephony
    func onSimNotFound(isOn: Bool)                         { threat("Sim Not Detected", isOn) }
    func onActivePhoneCallDetected(isOn: Bool)             { threat("Active Phone Call Detected", isOn) }
    func onVoIPVideoCallDetected(isOn: Bool)               { threat("VoIP/Video Call Detected", isOn) }

    // MARK: - Shared handler

    private func threat(_ label: String, _ isOn: Bool) {
        DispatchQueue.main.async {
            guard isOn else { return }
            ToastManager.show(label)
            // Production: block the sensitive flow and report to your backend
        }
    }
}

AI Assistant

final class ToastManager {

    static let shared = ToastManager()
    private init() {}

    private var queue: [(message: String, duration: TimeInterval)] = []
    private var isShowing = false
    private var lastMessage: String?
    private weak var currentToast: UIView?
    private var isCleared = false

    // MARK: - Public

    static func show(_ message: String, duration: TimeInterval = 2.0) {
        shared.enqueue(message, duration: duration)
    }

    func clearAll() {
        DispatchQueue.main.async {
            self.isCleared = true
            self.queue.removeAll()
            self.currentToast?.layer.removeAllAnimations()
            self.currentToast?.removeFromSuperview()
            self.currentToast = nil
            self.isShowing = false
        }
    }

    // MARK: - Queue

    private func enqueue(_ message: String, duration: TimeInterval) {
        DispatchQueue.main.async {
            guard self.lastMessage != message else { return }   // de-dupe repeats
            self.lastMessage = message
            self.queue.append((message, duration))
            self.showNextIfNeeded()
        }
    }

    private func showNextIfNeeded() {
        guard !isShowing, !queue.isEmpty else { return }
        isShowing = true
        isCleared = false
        let item = queue.removeFirst()
        showToast(message: item.message, duration: item.duration)
    }

    // MARK: - UI

    private func showToast(message: String, duration: TimeInterval) {
        guard let window = Self.keyWindow() else {
            isShowing = false
            return
        }

        let label = PaddingLabel()
        label.text            = message
        label.textColor       = .white
        label.textAlignment   = .center
        label.numberOfLines   = 0
        label.font            = .systemFont(ofSize: 15, weight: .medium)
        label.backgroundColor = UIColor.black.withAlphaComponent(0.85)
        label.layer.cornerRadius = 14
        label.clipsToBounds   = true
        label.alpha           = 0

        let maxWidth = window.frame.width * 0.8
        let size = label.sizeThatFits(CGSize(width: maxWidth, height: .greatestFiniteMagnitude))
        label.frame = CGRect(
            x: (window.frame.width  - size.width  - 24) / 2,
            y: (window.frame.height - size.height - 24) / 2,
            width:  size.width  + 24,
            height: size.height + 24
        )

        window.addSubview(label)
        currentToast = label

        UIView.animate(withDuration: 0.25) {
            label.alpha = 1
        } completion: { _ in
            UIView.animate(withDuration: 0.25, delay: duration, options: .curveEaseOut) {
                label.alpha = 0
            } completion: { _ in
                if self.isCleared { self.isShowing = false; return }
                label.removeFromSuperview()
                self.currentToast = nil
                self.isShowing    = false
                self.lastMessage  = nil
                DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
                    self.showNextIfNeeded()
                }
            }
        }
    }

    // MARK: - Helper

    private static func keyWindow() -> UIWindow? {
        UIApplication.shared.connectedScenes
            .compactMap { $0 as? UIWindowScene }
            .flatMap { $0.windows }
            .first { $0.isKeyWindow }
    }
}