Check for entitlement in DBP agent

DuckDuckGo/DBP/DataBrokerProtectionSubscriptionEventHandler.swift

@@ -31,11 +31,16 @@
 
     func registerForSubscriptionAccountManagerEvents() {
         NotificationCenter.default.addObserver(self, selector: #selector(handleAccountDidSignOut), name: .accountDidSignOut, object: nil)
+        NotificationCenter.default.addObserver(self, selector: #selector(handleAccountDidSignOut), name: .entitlementsDidChange, object: nil)
     }
 
     @objc private func handleAccountDidSignOut() {
         featureDisabler.disableAndDelete()
     }
+
+    @objc private func entitlementsDidChange() {
+        #warning("Validate if valid and delete if necessary after sending pixels")
+    }
 }
 
 #endif

LocalPackages/DataBrokerProtection/Sources/DataBrokerProtection/Authentication/DataBrokerProtectionEntitlementMonitoring.swift

@@ -0,0 +1,65 @@
+//
+//  DataBrokerProtectionEntitlementMonitoring.swift
+//
+//  Copyright © 2024 DuckDuckGo. All rights reserved.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//  http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+
+import Foundation
+
+protocol DataBrokerProtectionEntitlementMonitoring {
+    func start(checkEntitlementFunction: @escaping () async throws -> Bool, intervalInMinutes: Int, callback: @escaping (DataBrokerProtectionEntitlementMonitorResult) -> Void)
+    func stop()
+}
+
+extension DataBrokerProtectionEntitlementMonitoring {
+    func start(checkEntitlementFunction: @escaping () async throws -> Bool, callback: @escaping (DataBrokerProtectionEntitlementMonitorResult) -> Void) {
+        start(checkEntitlementFunction: checkEntitlementFunction,
+              intervalInMinutes: DataBrokerProtectionEntitlementMonitor.monitoringInterval,
+              callback: callback)
+    }
+}
+
+public enum DataBrokerProtectionEntitlementMonitorResult {
+    case enabled
+    case disabled
+    case error
+}
+
+final class DataBrokerProtectionEntitlementMonitor: DataBrokerProtectionEntitlementMonitoring {
+    private var timer: Timer?
+    static let monitoringInterval = 20
+
+    func start(checkEntitlementFunction: @escaping () async throws -> Bool, intervalInMinutes: Int, callback: @escaping (DataBrokerProtectionEntitlementMonitorResult) -> Void) {
+        timer = Timer.scheduledTimer(withTimeInterval: TimeInterval(intervalInMinutes * 60), repeats: true) { _ in
+            Task {
+                do {
+                    switch try await checkEntitlementFunction() {
+                    case true:
+                        callback(.enabled)
+                    case false:
+                        callback(.disabled)
+                    }
+                } catch {
+                    callback(.error)
+                }
+            }
+        }
+    }
+
+    func stop() {
+        timer?.invalidate()
+        timer = nil
+    }
+}

LocalPackages/DataBrokerProtection/Sources/DataBrokerProtection/Scheduler/DataBrokerProtectionAgentManager.swift

@@ -71,7 +71,12 @@
                                                          contentScopeProperties: contentScopeProperties,
                                                          emailService: emailService,
                                                          captchaService: captchaService)
-         let operationDependencies = DefaultDataBrokerOperationDependencies(
+
+        let agentstopper = DefaultDataBrokerProtectionAgentStopper(dataManager: dataManager,
+                                                                   entitlementMonitor: DataBrokerProtectionEntitlementMonitor(),
+                                                                   authenticationManager: authenticationManager)
+
+        let operationDependencies = DefaultDataBrokerOperationDependencies(
             database: dataManager.database,
             config: executionConfig,
             runnerProvider: runnerProvider,
@@ -86,7 +91,8 @@
             queueManager: queueManager,
             dataManager: dataManager,
             operationDependencies: operationDependencies,
-            pixelHandler: pixelHandler)
+            pixelHandler: pixelHandler,
+            agentStopper: agentstopper)
     }
 }
 
@@ -99,6 +105,7 @@
     private let dataManager: DataBrokerProtectionDataManaging
     private let operationDependencies: DataBrokerOperationDependencies
     private let pixelHandler: EventMapping<DataBrokerProtectionPixels>
+    private let agentStopper: DataBrokerProtectionAgentStopper
 
     // Used for debug functions only, so not injected
     private lazy var browserWindowManager = BrowserWindowManager()
@@ -111,14 +118,17 @@
          queueManager: DataBrokerProtectionQueueManager,
          dataManager: DataBrokerProtectionDataManaging,
          operationDependencies: DataBrokerOperationDependencies,
-         pixelHandler: EventMapping<DataBrokerProtectionPixels>) {
+         pixelHandler: EventMapping<DataBrokerProtectionPixels>,
+         agentStopper: DataBrokerProtectionAgentStopper
+    ) {
         self.userNotificationService = userNotificationService
         self.activityScheduler = activityScheduler
         self.ipcServer = ipcServer
         self.queueManager = queueManager
         self.dataManager = dataManager
         self.operationDependencies = operationDependencies
         self.pixelHandler = pixelHandler
+        self.agentStopper = agentStopper
 
         self.activityScheduler.delegate = self
         self.ipcServer.serverDelegate = self
@@ -127,20 +137,17 @@
 
     public func agentFinishedLaunching() {
 
-        do {
-            // If there's no saved profile we don't need to start the scheduler
-            // Theoretically this should never happen, if there's no data, the agent shouldn't be running
-            guard (try dataManager.fetchProfile()) != nil else {
-                return
-            }
-        } catch {
-            os_log("Error during AgentManager.agentFinishedLaunching when trying to fetchProfile, error: %{public}@", log: .dataBrokerProtection, error.localizedDescription)
-            return
-        }
+        Task { @MainActor in
+            // The browser shouldn't start the agent if these prerequisites aren't met
+            // But since the agent can auto-start after a reboot without the browser, we need to validate it again
+            await agentStopper.validateRunPreRequisitesAndStopAgentIfNecessary()
+
+            activityScheduler.startScheduler()
+            didStartActivityScheduler = true
+            queueManager.startScheduledOperationsIfPermitted(showWebView: false, operationDependencies: operationDependencies, completion: nil)
 
-        activityScheduler.startScheduler()
-        didStartActivityScheduler = true
-        queueManager.startScheduledOperationsIfPermitted(showWebView: false, operationDependencies: operationDependencies, completion: nil)
+            agentStopper.monitorEntitlementAndStopAgentIfNecessary()
+        }
     }
 }
 
@@ -283,3 +290,4 @@
 extension DataBrokerProtectionAgentManager: DataBrokerProtectionAppToAgentInterface {
 
 }
+

LocalPackages/DataBrokerProtection/Sources/DataBrokerProtection/Utils/DataBrokerProtectionAgentStopper.swift

@@ -0,0 +1,76 @@
+//
+//  DataBrokerProtectionAgentStopper.swift
+//
+//  Copyright © 2023 DuckDuckGo. All rights reserved.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//  http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+
+import Foundation
+import Common
+
+protocol DataBrokerProtectionAgentStopper {
+    func validateRunPreRequisitesAndStopAgentIfNecessary() async
+    func monitorEntitlementAndStopAgentIfNecessary()
+    func stopAgent()
+}
+
+struct DefaultDataBrokerProtectionAgentStopper: DataBrokerProtectionAgentStopper {
+    private let dataManager: DataBrokerProtectionDataManaging
+    private let entitlementMonitor: DataBrokerProtectionEntitlementMonitoring
+    private let authenticationManager: DataBrokerProtectionAuthenticationManaging
+
+    init(dataManager: DataBrokerProtectionDataManaging,
+         entitlementMonitor: DataBrokerProtectionEntitlementMonitoring,
+         authenticationManager: DataBrokerProtectionAuthenticationManaging) {
+        self.dataManager = dataManager
+        self.entitlementMonitor = entitlementMonitor
+        self.authenticationManager = authenticationManager
+    }
+
+    public func validateRunPreRequisitesAndStopAgentIfNecessary() async {
+        do {
+            guard try dataManager.fetchProfile() != nil,
+                  authenticationManager.isUserAuthenticated,
+                  try await authenticationManager.hasValidEntitlement() else {
+
+                os_log("Prerequisites are invalid", log: .dataBrokerProtection)
+                stopAgent()
+                return
+            }
+            os_log("Prerequisites are valid", log: .dataBrokerProtection)
+        } catch {
+            os_log("Error validating prerequisites, error: %{public}@", log: .dataBrokerProtection, error.localizedDescription)
+            stopAgent()
+        }
+    }
+
+    public func monitorEntitlementAndStopAgentIfNecessary() {
+        entitlementMonitor.start(checkEntitlementFunction: authenticationManager.hasValidEntitlement) { result in
+            switch result {
+            case .enabled:
+#warning("Send pixel enabled")
+                stopAgent()
+            case .disabled:
+#warning("Send pixel disabled")
+            case .error:
+#warning("Send pixel error")
+            }
+        }
+    }
+
+    func stopAgent() {
+        os_log("Stopping DataBrokerProtection Agent", log: .dataBrokerProtection)
+        exit(EXIT_SUCCESS)
+    }
+}

LocalPackages/DataBrokerProtection/Sources/DataBrokerProtection/Utils/Logging.swift

@@ -43,6 +43,10 @@ struct Logging {
 
     fileprivate static let backgroundAgentPixelLoggingEnabled = true
     fileprivate static let backgroundAgentPixel: OSLog = OSLog(subsystem: subsystem, category: "Data Broker Protection Background Agent Pixel")
+
+    fileprivate static let dataBrokerProtectionMonitoringEnabled = true
+    fileprivate static let dataBrokerProtectionMonitoring: OSLog = OSLog(subsystem: subsystem, category: "Data Broker Protection Monitoring")
+
 }
 
 extension OSLog {
@@ -74,4 +78,8 @@ extension OSLog {
     public static var dbpBackgroundAgentPixel: OSLog {
         Logging.backgroundAgentPixelLoggingEnabled ? Logging.backgroundAgentPixel : .disabled
     }
+
+    public static var dataBrokerProtectionMonitoring: OSLog {
+        Logging.dataBrokerProtectionMonitoringEnabled ? Logging.dataBrokerProtectionMonitoring : .disabled
+    }
 }