Force Proxy to any Windows/MacOS/Linux Application TCP and UDP traffic
C ccybersecurityhttp3httpproxylinuxlinux-proxymacosmacos-appmacos-proxyproxifierproxifier-alternativeproxyclienttcpthick-clientudpwindivertwindows
Refactor RuleManager and AppProxyProvider for improved clarity and performance
AnoF-Cyber2fc49502484b
diff --git a/MacOS/ProxyBridge/ProxyBridge/ContentView.swift b/MacOS/ProxyBridge/ProxyBridge/ContentView.swiftindex 03ae036..325da64 100644--- a/MacOS/ProxyBridge/ProxyBridge/ContentView.swift+++ b/MacOS/ProxyBridge/ProxyBridge/ContentView.swift@@ -163,10 +163,9 @@ struct ConnectionsView: View {}private func scrollToLast(proxy: ScrollViewProxy) {+ // no animation, this fires on every poll and animating a long list burns cpuif let last = connections.last {- withAnimation {- proxy.scrollTo(last.id, anchor: .bottom)- }+ proxy.scrollTo(last.id, anchor: .bottom)}}}@@ -230,10 +229,9 @@ struct ActivityLogsView: View {}private func scrollToLast(proxy: ScrollViewProxy) {+ // no animation, this fires on every poll and animating a long list burns cpuif let last = logs.last {- withAnimation {- proxy.scrollTo(last.id, anchor: .bottom)- }+ proxy.scrollTo(last.id, anchor: .bottom)}}}diff --git a/MacOS/ProxyBridge/ProxyBridge/ProxyBridgeViewModel.swift b/MacOS/ProxyBridge/ProxyBridge/ProxyBridgeViewModel.swiftindex d0915a8..11f7a84 100644--- a/MacOS/ProxyBridge/ProxyBridge/ProxyBridgeViewModel.swift+++ b/MacOS/ProxyBridge/ProxyBridge/ProxyBridgeViewModel.swift@@ -2,6 +2,7 @@ import Foundationimport NetworkExtensionimport SystemExtensionsimport Combine+import AppKitclass ProxyBridgeViewModel: NSObject, ObservableObject {@Published var connections: [ConnectionLog] = []@@ -14,18 +15,15 @@ class ProxyBridgeViewModel: NSObject, ObservableObject {@Published private(set) var proxyConfigs: [ProxyConfig] = []private let maxLogEntries = 1000- // trim to 80% when limit hit to avoid trimming on each entry+ // trim back to this when the cap is hit, so we don't shift on every entryprivate let trimToEntries = 800private let logPollingInterval = 1.0private let extensionIdentifier = "com.interceptsuite.ProxyBridge.extension"- // reuse formatter- // saves memory about 2% and speed up the uiprivate let timestampFormatter: DateFormatter = {let f = DateFormatter()f.dateFormat = "HH:mm:ss"return f}()- // removed uuid and use int - memory usage and speed improved due to sizeprivate var connectionIdCounter: Int = 0private var activityIdCounter: Int = 0@@ -83,12 +81,46 @@ class ProxyBridgeViewModel: NSObject, ObservableObject {let message: String}+ // when every window is hidden or minimized there's no point polling logs+ private var isWindowVisible = true+override init() {super.init()+ // both arrays are capped at maxLogEntries, reserve up front so a busy+ // session doesn't keep reallocating the backing storage as it fills+ connections.reserveCapacity(maxLogEntries)+ activityLogs.reserveCapacity(maxLogEntries)loadTrafficLoggingSetting()loadProxyConfig()+ NotificationCenter.default.addObserver(+ self,+ selector: #selector(occlusionChanged),+ name: NSApplication.didChangeOcclusionStateNotification,+ object: nil+ )installAndStartProxy()}++ @objc private func occlusionChanged() {+ isWindowVisible = NSApp.occlusionState.contains(.visible)+ updatePollingState()+ }++ // single place that decides whether the poll timer should be running+ private func updatePollingState() {+ if isTrafficLoggingEnabled && tunnelSession != nil && isWindowVisible {+ startLogPollingTimer()+ } else {+ stopLogPollingTimer()+ }+ }++ private func stopLogPollingTimer() {+ DispatchQueue.main.async { [weak self] in+ self?.logTimer?.invalidate()+ self?.logTimer = nil+ }+ }private func loadTrafficLoggingSetting() {isTrafficLoggingEnabled = UserDefaults.standard.object(forKey: "trafficLoggingEnabled") as? Bool ?? true@@ -98,13 +130,7 @@ class ProxyBridgeViewModel: NSObject, ObservableObject {isTrafficLoggingEnabled.toggle()UserDefaults.standard.set(isTrafficLoggingEnabled, forKey: "trafficLoggingEnabled")sendTrafficLoggingToExtension(isTrafficLoggingEnabled)-- if isTrafficLoggingEnabled {- startLogPollingTimer()- } else {- logTimer?.invalidate()- logTimer = nil- }+ updatePollingState()}private func sendTrafficLoggingToExtension(_ enabled: Bool) {@@ -294,7 +320,6 @@ class ProxyBridgeViewModel: NSObject, ObservableObject {return}- // Clear all data from extension memory before stoppingclearExtensionMemory(session: session) { [weak self] inguard let self = self else { return }@@ -312,9 +337,8 @@ class ProxyBridgeViewModel: NSObject, ObservableObject {}private func clearExtensionMemory(session: NETunnelProviderSession, completion: @escaping () -> Void) {- // clear rules auto fix the #51 - and proxy rules become inactive after It closes+ // clearing rules fixes #51 where rules stayed active after the app closedRuleManager.clearRules(session: session) { success, message in- //clear proxy config as well keep meory usage low for extesionlet clearConfigMessage: [String: Any] = ["action": "clearConfig"]@@ -332,18 +356,15 @@ class ProxyBridgeViewModel: NSObject, ObservableObject {private func setupLogPolling(session: NETunnelProviderSession) {tunnelSession = session-sendTrafficLoggingToExtension(isTrafficLoggingEnabled)-- if isTrafficLoggingEnabled {- startLogPollingTimer()- }+ updatePollingState()}private func startLogPollingTimer() {DispatchQueue.main.async { [weak self] inguard let self = self else { return }- self.logTimer?.invalidate()+ // already running, don't reset the cadence+ guard self.logTimer == nil else { return }self.logTimer = Timer.scheduledTimer(withTimeInterval: self.logPollingInterval,repeats: true@@ -361,37 +382,59 @@ class ProxyBridgeViewModel: NSObject, ObservableObject {try? session.sendProviderMessage(data) { [weak self] response inguard let self = self,- let responseData = response else {+ let responseData = response,+ let logs = try? JSONSerialization.jsonObject(with: responseData) as? [[String: String]],+ !logs.isEmpty else {return}-- if let logs = try? JSONSerialization.jsonObject(with: responseData) as? [[String: String]] {- DispatchQueue.main.async {- for log in logs {- if log["type"] == "connection" {- self.handleConnectionLog(log)- } else {- self.handleActivityLog(log)- }++ // build the batch first, then touch the published arrays once each+ // so a busy second is one ui update instead of a hundred+ DispatchQueue.main.async {+ var newConnections: [ConnectionLog] = []+ var newActivity: [ActivityLog] = []+ for log in logs {+ if log["type"] == "connection" {+ if let c = self.makeConnectionLog(log) { newConnections.append(c) }+ } else {+ if let a = self.makeActivityLog(log) { newActivity.append(a) }}}+ self.appendConnections(newConnections)+ self.appendActivity(newActivity)}}}-- private func handleConnectionLog(_ log: [String: String]) {- guard isTrafficLoggingEnabled else { return }-++ private func appendConnections(_ items: [ConnectionLog]) {+ guard !items.isEmpty else { return }+ connections.append(contentsOf: items)+ if connections.count > maxLogEntries {+ connections.removeFirst(connections.count - trimToEntries)+ }+ }++ private func appendActivity(_ items: [ActivityLog]) {+ guard !items.isEmpty else { return }+ activityLogs.append(contentsOf: items)+ if activityLogs.count > maxLogEntries {+ activityLogs.removeFirst(activityLogs.count - trimToEntries)+ }+ }++ private func makeConnectionLog(_ log: [String: String]) -> ConnectionLog? {+ guard isTrafficLoggingEnabled else { return nil }+guard let proto = log["protocol"],let process = log["process"],let dest = log["destination"],let port = log["port"],let proxy = log["proxy"] else {- return+ return nil}-+connectionIdCounter &+= 1- let connectionLog = ConnectionLog(+ return ConnectionLog(id: connectionIdCounter,timestamp: getCurrentTimestamp(),connectionProtocol: proto,@@ -400,35 +443,23 @@ class ProxyBridgeViewModel: NSObject, ObservableObject {port: port,proxy: proxy)- connections.append(connectionLog)-- // Trim in bulk to avoid O(n) shift on every entry at the limit- if connections.count > maxLogEntries {- connections.removeFirst(connections.count - trimToEntries)- }}-- private func handleActivityLog(_ log: [String: String]) {++ private func makeActivityLog(_ log: [String: String]) -> ActivityLog? {guard let timestamp = log["timestamp"],let level = log["level"],let message = log["message"] else {- return+ return nil}-+activityIdCounter &+= 1- let activityLog = ActivityLog(+ return ActivityLog(id: activityIdCounter,timestamp: timestamp,level: level,message: message)- activityLogs.append(activityLog)-- if activityLogs.count > maxLogEntries {- activityLogs.removeFirst(activityLogs.count - trimToEntries)- }}-func sendProxyConfigsToExtension(session: NETunnelProviderSession) {let configsArray: [[String: Any]] = proxyConfigs.map { config in@@ -474,11 +505,7 @@ class ProxyBridgeViewModel: NSObject, ObservableObject {level: level,message: message)- activityLogs.append(log)-- if activityLogs.count > maxLogEntries {- activityLogs.removeFirst(activityLogs.count - trimToEntries)- }+ appendActivity([log])}private func getCurrentTimestamp() -> String {@@ -486,6 +513,7 @@ class ProxyBridgeViewModel: NSObject, ObservableObject {}deinit {+ NotificationCenter.default.removeObserver(self)logTimer?.invalidate()stopProxy()}diff --git a/MacOS/ProxyBridge/ProxyBridge/RuleManager.swift b/MacOS/ProxyBridge/ProxyBridge/RuleManager.swiftindex fa24e10..a742ee2 100644--- a/MacOS/ProxyBridge/ProxyBridge/RuleManager.swift+++ b/MacOS/ProxyBridge/ProxyBridge/RuleManager.swift@@ -34,85 +34,6 @@ struct RuleManager {}}- static func updateRule(- session: NETunnelProviderSession,- ruleId: UInt32,- processNames: String,- targetHosts: String,- targetPorts: String,- protocol: String,- action: String,- enabled: Bool = true,- completion: @escaping (Bool, String) -> Void- ) {- sendMessage(- session: session,- action: "updateRule",- params: [- "ruleId": ruleId,- "processNames": processNames,- "targetHosts": targetHosts,- "targetPorts": targetPorts,- "ruleProtocol": `protocol`,- "ruleAction": action,- "enabled": enabled- ]- ) { success, result in- let message = success- ? "Rule #\(ruleId) updated successfully"- : (result?["message"] as? String ?? "Unknown error")- completion(success, message)- }- }-- static func toggleRule(- session: NETunnelProviderSession,- ruleId: UInt32,- enabled: Bool,- completion: @escaping (Bool, String) -> Void- ) {- sendMessage(- session: session,- action: "toggleRule",- params: ["ruleId": ruleId, "enabled": enabled]- ) { success, result in- let message = success- ? "Rule #\(ruleId) \(enabled ? "enabled" : "disabled")"- : (result?["message"] as? String ?? "Unknown error")- completion(success, message)- }- }-- static func removeRule(- session: NETunnelProviderSession,- ruleId: UInt32,- completion: @escaping (Bool, String) -> Void- ) {- sendMessage(- session: session,- action: "removeRule",- params: ["ruleId": ruleId]- ) { success, result in- let message = success- ? "Removed \(result?["removed"] as? Int ?? 0) rule(s)"- : (result?["message"] as? String ?? "Unknown error")- completion(success, message)- }- }-- static func listRules(- session: NETunnelProviderSession,- completion: @escaping (Bool, [[String: Any]]) -> Void- ) {- sendMessage(session: session, action: "listRules", params: [:]) { success, result in- if success, let rules = result?["rules"] as? [[String: Any]] {- completion(true, rules)- } else {- completion(false, [])- }- }- }-static func clearRules(session: NETunnelProviderSession,completion: @escaping (Bool, String) -> Void@@ -151,50 +72,6 @@ struct RuleManager {}}- // Print rules in a nice format- static func printRules(_ rules: [[String: Any]]) {- if rules.isEmpty {- print("No rules configured")- return- }-- print("\n=== Proxy Rules ===")- print(String(format: "%-5s %-15s %-20s %-20s %-10s %-8s %-8s",- "ID", "Process", "Hosts", "Ports", "Protocol", "Action", "Enabled"))- print(String(repeating: "-", count: 100))-- for rule in rules {- let ruleId = rule["ruleId"] as? UInt32 ?? 0- let processNames = (rule["processNames"] as? String ?? "*").prefix(15)- let targetHosts = (rule["targetHosts"] as? String ?? "*").prefix(20)- let targetPorts = (rule["targetPorts"] as? String ?? "*").prefix(20)- let proto = rule["protocol"] as? String ?? "BOTH"- let action = rule["action"] as? String ?? "DIRECT"- let enabled = rule["enabled"] as? Bool ?? true-- print(String(format: "%-5d %-15s %-20s %-20s %-10s %-8s %-8s",- ruleId,- String(processNames),- String(targetHosts),- String(targetPorts),- proto,- action,- enabled ? "Yes" : "No"))- }- print("")- }-- static func saveRulesToUserDefaults(_ rules: [[String: Any]]) {- let rulesToSave = rules.map { rule -> [String: Any] in- var ruleData = rule- ruleData.removeValue(forKey: "ruleId")- return ruleData- }- UserDefaults.standard.set(rulesToSave, forKey: "proxyRules")- }-- // wipe the extension rules then push the current UserDefaults set back- // used after any edit so ids stay in sync and we never double up rulesstatic func resyncRules(session: NETunnelProviderSession,completion: @escaping (Bool, Int) -> Void@@ -209,33 +86,43 @@ struct RuleManager {completion: @escaping (Bool, Int) -> Void) {let rules = UserDefaults.standard.array(forKey: "proxyRules") as? [[String: Any]] ?? []-guard !rules.isEmpty else {completion(true, 0)return}-- var successCount = 0- let group = DispatchGroup()-- for rule in rules {- group.enter()- addRule(- session: session,- processNames: rule["processNames"] as? String ?? "",- targetHosts: rule["targetHosts"] as? String ?? "",- targetPorts: rule["targetPorts"] as? String ?? "",- protocol: rule["protocol"] as? String ?? "BOTH",- action: rule["action"] as? String ?? "DIRECT",- enabled: rule["enabled"] as? Bool ?? true- ) { success, _, _ in- if success { successCount += 1 }- group.leave()- }+ // add one at a time so rule order matches the saved order and the+ // running counter isn't touched from concurrent completion handlers+ addRulesInOrder(session: session, rules: rules, index: 0, added: 0, completion: completion)+ }++ private static func addRulesInOrder(+ session: NETunnelProviderSession,+ rules: [[String: Any]],+ index: Int,+ added: Int,+ completion: @escaping (Bool, Int) -> Void+ ) {+ guard index < rules.count else {+ DispatchQueue.main.async { completion(true, added) }+ return}-- group.notify(queue: .main) {- completion(true, successCount)+ let rule = rules[index]+ addRule(+ session: session,+ processNames: rule["processNames"] as? String ?? "",+ targetHosts: rule["targetHosts"] as? String ?? "",+ targetPorts: rule["targetPorts"] as? String ?? "",+ protocol: rule["protocol"] as? String ?? "BOTH",+ action: rule["action"] as? String ?? "DIRECT",+ enabled: rule["enabled"] as? Bool ?? true+ ) { success, _, _ in+ addRulesInOrder(+ session: session,+ rules: rules,+ index: index + 1,+ added: added + (success ? 1 : 0),+ completion: completion+ )}}}diff --git a/MacOS/ProxyBridge/ProxyBridge/UpdateService.swift b/MacOS/ProxyBridge/ProxyBridge/UpdateService.swiftindex ac828f3..1d254a4 100644--- a/MacOS/ProxyBridge/ProxyBridge/UpdateService.swift+++ b/MacOS/ProxyBridge/ProxyBridge/UpdateService.swift@@ -56,14 +56,12 @@ class UpdateService {let currentVersion = getCurrentVersion()let latestVersion = parseVersion(release.tagName)- // Find the PKG installer in assetslet pkgAsset = release.assets.first { asset inasset.name.lowercased().hasSuffix(".pkg") &&(asset.name.lowercased().contains("proxybridge") ||asset.name.lowercased().contains("installer"))}- // a macOS pkg installer in the release is valid updatelet isUpdateAvailable = isNewerVersion(latestVersion, currentVersion) && pkgAsset != nilreturn VersionInfo(@@ -95,34 +93,50 @@ class UpdateService {let tempDir = FileManager.default.temporaryDirectorylet fileURL = tempDir.appendingPathComponent(fileName)- // Remove existing file if anytry? FileManager.default.removeItem(at: fileURL)var downloadedBytes: Int64 = 0- let data = NSMutableData()+ var data = Data()+ if totalBytes > 0 { data.reserveCapacity(Int(totalBytes)) }++ // collect into a buffer and flush in chunks, and only report progress+ // every ~256kb so we aren't hopping to the main actor for every byte+ var buffer = [UInt8]()+ buffer.reserveCapacity(65536)+ let progressStep: Int64 = 256 * 1024+ var lastReported: Int64 = 0for try await byte in asyncBytes {- var byteValue = byte- data.append(&byteValue, length: 1)+ buffer.append(byte)downloadedBytes += 1- if totalBytes > 0 {+ if buffer.count >= 65536 {+ data.append(contentsOf: buffer)+ buffer.removeAll(keepingCapacity: true)+ }++ if totalBytes > 0, downloadedBytes - lastReported >= progressStep {+ lastReported = downloadedByteslet progressValue = Double(downloadedBytes) / Double(totalBytes)- await MainActor.run {- progress(progressValue)- }+ await MainActor.run { progress(progressValue) }}}+ if !buffer.isEmpty {+ data.append(contentsOf: buffer)+ }++ if totalBytes > 0 {+ await MainActor.run { progress(1.0) }+ }+try data.write(to: fileURL)return fileURL}func installUpdateAndQuit(installerPath: URL) {- // Open the PKG installerNSWorkspace.shared.open(installerPath)-- // Give the installer a moment to start, then quit+ // let the installer come up before we quitDispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {NSApplication.shared.terminate(nil)}diff --git a/MacOS/ProxyBridge/extension/AppProxyProvider.swift b/MacOS/ProxyBridge/extension/AppProxyProvider.swiftindex 84ed86c..e7b51ac 100644--- a/MacOS/ProxyBridge/extension/AppProxyProvider.swift+++ b/MacOS/ProxyBridge/extension/AppProxyProvider.swift@@ -146,7 +146,7 @@ struct ProxyRule: Codable {return true}- // Check for IP range (e.g., 192.168.1.1-192.168.1.254)+ // ip range, e.g. 192.168.1.1-192.168.1.254if pattern.contains("-") {let parts = pattern.components(separatedBy: "-")if parts.count == 2 {@@ -162,7 +162,7 @@ struct ProxyRule: Codable {return false}- // Wildcard matching (e.g., 192.168.1.*)+ // wildcard, e.g. 192.168.1.*let patternOctets = pattern.components(separatedBy: ".")let ipOctets = ipString.components(separatedBy: ".")@@ -220,16 +220,33 @@ struct ProxyRule: Codable {class AppProxyProvider: NETransparentProxyProvider {+ // one log entry, kept as an enum so we don't allocate a dictionary per line,+ // the dict is only built when the gui drains a batch+ private enum LogEntry {+ case connection(proto: String, process: String, destination: String, port: String, proxy: String)+ case activity(timestamp: String, level: String, message: String)++ func toDict() -> [String: String] {+ switch self {+ case let .connection(proto, process, destination, port, proxy):+ return ["type": "connection", "protocol": proto, "process": process,+ "destination": destination, "port": port, "proxy": proxy]+ case let .activity(timestamp, level, message):+ return ["type": "activity", "timestamp": timestamp, "level": level, "message": message]+ }+ }+ }+// circular buffer for logs, avoids shifting the whole array on every popprivate static let logCapacity = 1000- private var logBuffer: [[String: String]] = Array(repeating: [:], count: AppProxyProvider.logCapacity)- private var logHead = 0 // next read position- private var logTail = 0 // next write position+ private var logBuffer = [LogEntry?](repeating: nil, count: AppProxyProvider.logCapacity)+ private var logHead = 0+ private var logTail = 0private var logCount = 0private let logQueueLock = NSLock()private let dateFormatter: ISO8601DateFormatter = ISO8601DateFormatter()- // cache results so each process only instead of per-connection.+ // cache by pid so we don't call proc_pidpath on every connectionprivate var pidCache: [pid_t: String] = [:]private let pidCacheLock = NSLock()private static let pidCacheMaxSize = 256@@ -250,15 +267,13 @@ class AppProxyProvider: NETransparentProxyProvider {guard pid > 0 else { return nil }- // Check cache firstpidCacheLock.lock()if let cached = pidCache[pid] {pidCacheLock.unlock()return cached}pidCacheLock.unlock()-- // Cache miss - call proc_pidpath()+var pathBuffer = [Int8](repeating: 0, count: Int(MAXPATHLEN))guard proc_pidpath(pid, &pathBuffer, UInt32(MAXPATHLEN)) > 0 else {return nil@@ -278,10 +293,13 @@ class AppProxyProvider: NETransparentProxyProvider {return processName}- private var _trafficLoggingEnabled: Int32 = 1 // atomic: 1=enabled, 0=disabled+ // guarded by its own lock, the old OSAtomic compare-and-swap setter could+ // silently no-op if the stored value wasn't the exact expected one+ private var _trafficLoggingEnabled = true+ private let trafficLoggingLock = NSLock()private var trafficLoggingEnabled: Bool {- get { return OSAtomicAdd32(0, &_trafficLoggingEnabled) != 0 }- set { OSAtomicCompareAndSwap32(newValue ? 0 : 1, newValue ? 1 : 0, &_trafficLoggingEnabled) }+ get { trafficLoggingLock.lock(); defer { trafficLoggingLock.unlock() }; return _trafficLoggingEnabled }+ set { trafficLoggingLock.lock(); _trafficLoggingEnabled = newValue; trafficLoggingLock.unlock() }}private var rules: [ProxyRule] = []@@ -299,13 +317,12 @@ class AppProxyProvider: NETransparentProxyProvider {private let proxyLock = NSLock()private func log(_ message: String, level: String = "INFO") {- let logEntry: [String: String] = [- "timestamp": dateFormatter.string(from: Date()),- "level": level,- "message": message- ]+ appendLog(.activity(timestamp: dateFormatter.string(from: Date()), level: level, message: message))+ }++ private func appendLog(_ entry: LogEntry) {logQueueLock.lock()- logBuffer[logTail] = logEntry+ logBuffer[logTail] = entrylogTail = (logTail + 1) % AppProxyProvider.logCapacityif logCount < AppProxyProvider.logCapacity {logCount += 1@@ -336,11 +353,36 @@ class AppProxyProvider: NETransparentProxyProvider {}override func stopProxy(with reason: NEProviderStopReason, completionHandler: @escaping () -> Void) {+ udpLock.lock()+ let all = Array(udpAssociations.values)+ udpAssociations.removeAll()+ udpLock.unlock()+ for a in all {+ a.controlConnection.cancel()+ a.udpSession.cancel()+ }completionHandler()}- private var udpTCPConnections: [NEAppProxyUDPFlow: NWTCPConnection] = [:]- private let tcpConnectionsLock = NSLock()+ // one association per udp flow, holds both channels so we tear the whole thing+ // down together when any side goes away+ private final class UDPAssociation {+ let clientFlow: NEAppProxyUDPFlow+ let controlConnection: NWTCPConnection // socks5 tcp control channel, keeps the association alive+ let udpSession: NWUDPSession // relay channel to the socks server+ let processPath: String+ var loggedDestinations = Set<String>() // dedupe connection logs, bounded+ var isTornDown = false++ init(clientFlow: NEAppProxyUDPFlow, controlConnection: NWTCPConnection, udpSession: NWUDPSession, processPath: String) {+ self.clientFlow = clientFlow+ self.controlConnection = controlConnection+ self.udpSession = udpSession+ self.processPath = processPath+ }+ }+ private var udpAssociations: [NEAppProxyUDPFlow: UDPAssociation] = [:]+ private let udpLock = NSLock()override func handleAppMessage(_ messageData: Data, completionHandler: ((Data?) -> Void)?) {guard let message = try? JSONSerialization.jsonObject(with: messageData) as? [String: Any],@@ -357,7 +399,10 @@ class AppProxyProvider: NETransparentProxyProvider {var logsToSend: [[String: String]] = []logsToSend.reserveCapacity(batchSize)for _ in 0..<batchSize {- logsToSend.append(logBuffer[logHead])+ if let entry = logBuffer[logHead] {+ logsToSend.append(entry.toDict())+ }+ logBuffer[logHead] = nil // release the drained entrylogHead = (logHead + 1) % AppProxyProvider.logCapacitylogCount -= 1}@@ -395,7 +440,6 @@ class AppProxyProvider: NETransparentProxyProvider {}completionHandler?(try? JSONSerialization.data(withJSONObject: ["status": "ok"]))-case "addRule":if let ruleData = try? JSONSerialization.data(withJSONObject: message),var rule = try? JSONDecoder().decode(ProxyRule.self, from: ruleData) {@@ -423,81 +467,6 @@ class AppProxyProvider: NETransparentProxyProvider {completionHandler?(try? JSONSerialization.data(withJSONObject: response))}- case "updateRule":- if let ruleId = message["ruleId"] as? UInt32,- let ruleData = try? JSONSerialization.data(withJSONObject: message),- let updatedRule = try? JSONDecoder().decode(ProxyRule.self, from: ruleData) {- rulesLock.lock()- if let index = rules.firstIndex(where: { $0.ruleId == ruleId }) {- var rule = updatedRule- rule.ruleId = ruleId- rules[index] = rule- rulesLock.unlock()- log("Updated rule #\(ruleId): \(rule.processNames) -> \(rule.action)")- let response: [String: Any] = ["status": "ok", "ruleId": ruleId]- completionHandler?(try? JSONSerialization.data(withJSONObject: response))- } else {- rulesLock.unlock()- let response = ["status": "error", "message": "Rule not found"]- completionHandler?(try? JSONSerialization.data(withJSONObject: response))- }- } else {- let response = ["status": "error", "message": "Invalid update data"]- completionHandler?(try? JSONSerialization.data(withJSONObject: response))- }-- case "toggleRule":- if let ruleId = message["ruleId"] as? UInt32,- let enabled = message["enabled"] as? Bool {- rulesLock.lock()- if let index = rules.firstIndex(where: { $0.ruleId == ruleId }) {- rules[index].enabled = enabled- rulesLock.unlock()- log("Rule #\(ruleId) \(enabled ? "enabled" : "disabled")")- let response: [String: Any] = ["status": "ok", "ruleId": ruleId, "enabled": enabled]- completionHandler?(try? JSONSerialization.data(withJSONObject: response))- } else {- rulesLock.unlock()- let response = ["status": "error", "message": "Rule not found"]- completionHandler?(try? JSONSerialization.data(withJSONObject: response))- }- } else {- let response = ["status": "error", "message": "Missing ruleId or enabled"]- completionHandler?(try? JSONSerialization.data(withJSONObject: response))- }-- case "removeRule":- if let ruleId = message["ruleId"] as? UInt32 {- rulesLock.lock()- let beforeCount = rules.count- rules.removeAll { $0.ruleId == ruleId }- let removed = beforeCount - rules.count- rulesLock.unlock()- log("Removed rule #\(ruleId)")- let response: [String: Any] = ["status": "ok", "removed": removed]- completionHandler?(try? JSONSerialization.data(withJSONObject: response))- } else {- let response = ["status": "error", "message": "Missing ruleId"]- completionHandler?(try? JSONSerialization.data(withJSONObject: response))- }-- case "listRules":- rulesLock.lock()- let rulesList = rules.map { rule -> [String: Any] in- return [- "ruleId": rule.ruleId,- "processNames": rule.processNames,- "targetHosts": rule.targetHosts,- "targetPorts": rule.targetPorts,- "protocol": rule.ruleProtocol.rawValue,- "action": rule.action,- "enabled": rule.enabled- ]- }- rulesLock.unlock()- let response: [String: Any] = ["status": "ok", "rules": rulesList]- completionHandler?(try? JSONSerialization.data(withJSONObject: response))-case "clearRules":rulesLock.lock()let count = rules.count@@ -507,12 +476,12 @@ class AppProxyProvider: NETransparentProxyProvider {let response: [String: Any] = ["status": "ok", "cleared": count]completionHandler?(try? JSONSerialization.data(withJSONObject: response))- case "setRules":- if let rules = message["rules"] as? [[String: String]] {- log("Rules updated: \(rules.count) rules")- }- let response = ["status": "ok"]- completionHandler?(try? JSONSerialization.data(withJSONObject: response))+ case "clearConfig":+ // drop the stored proxy configs so credentials don't sit in memory after stop+ proxyLock.lock()+ storedProxyConfigs.removeAll()+ proxyLock.unlock()+ completionHandler?(try? JSONSerialization.data(withJSONObject: ["status": "ok"]))default:completionHandler?(nil)}@@ -531,7 +500,6 @@ class AppProxyProvider: NETransparentProxyProvider {} else if let udpFlow = flow as? NEAppProxyUDPFlow {return handleUDPFlow(udpFlow)}- // unhandled flow types just pass throughreturn false}@@ -539,11 +507,11 @@ class AppProxyProvider: NETransparentProxyProvider {let metaData = flow.metaDatalet processPath = metaData.sourceAppSigningIdentifier- // early exit for own app traffic before any other work+ // never proxy our own traffic, it would loopif processPath == "com.interceptsuite.ProxyBridge" || processPath == "com.interceptsuite.ProxyBridge.extension" {return false}-+let remoteEndpoint = flow.remoteEndpointvar destination = ""var portNum: UInt16 = 0@@ -651,40 +619,48 @@ class AppProxyProvider: NETransparentProxyProvider {}}+ // handshake failed before an association existed, so drop the control+ // connection and close the flow instead of leaking them+ private func failUDPHandshake(_ clientFlow: NEAppProxyUDPFlow, _ tcpConnection: NWTCPConnection, _ reason: String) {+ log(reason, level: "ERROR")+ tcpConnection.cancel()+ clientFlow.closeReadWithError(nil)+ clientFlow.closeWriteWithError(nil)+ }+private func proxyUDPFlowViaSOCKS5(_ clientFlow: NEAppProxyUDPFlow, processPath: String, socksHost: String, socksPort: Int) {let proxyEndpoint = NWHostEndpoint(hostname: socksHost, port: String(socksPort))let tcpConnection = createTCPConnection(to: proxyEndpoint, enableTLS: false, tlsParameters: nil, delegate: nil)-- let greeting: [UInt8] = [0x05, 0x01, 0x00]- let greetingData = Data(greeting)-++ let greetingData = Data([0x05, 0x01, 0x00])+tcpConnection.write(greetingData) { [weak self] error inguard let self = self else { return }-+if let error = error {- self.log("SOCKS5 UDP greeting failed: \(error.localizedDescription)", level: "ERROR")+ self.failUDPHandshake(clientFlow, tcpConnection, "SOCKS5 UDP greeting failed: \(error.localizedDescription)")return}-+tcpConnection.readMinimumLength(2, maximumLength: 2) { [weak self] data, error inguard let self = self else { return }-+if let error = error {- self.log("SOCKS5 UDP greeting response failed: \(error.localizedDescription)", level: "ERROR")+ self.failUDPHandshake(clientFlow, tcpConnection, "SOCKS5 UDP greeting response failed: \(error.localizedDescription)")return}-+guard let data = data, data.count == 2, data[1] == 0x00 else {- self.log("SOCKS5 UDP greeting response failed", level: "ERROR")+ self.failUDPHandshake(clientFlow, tcpConnection, "SOCKS5 UDP greeting response invalid")return}-- self.sendSOCKS5UDPAssociate(clientFlow: clientFlow, tcpConnection: tcpConnection, processPath: processPath)++ self.sendSOCKS5UDPAssociate(clientFlow: clientFlow, tcpConnection: tcpConnection, socksHost: socksHost, processPath: processPath)}}}-- private func sendSOCKS5UDPAssociate(clientFlow: NEAppProxyUDPFlow, tcpConnection: NWTCPConnection, processPath: String) {++ private func sendSOCKS5UDPAssociate(clientFlow: NEAppProxyUDPFlow, tcpConnection: NWTCPConnection, socksHost: String, processPath: String) {var request = Data()request.append(0x05)request.append(0x03)@@ -695,26 +671,32 @@ class AppProxyProvider: NETransparentProxyProvider {tcpConnection.write(request) { [weak self] error inguard let self = self else { return }-+if let error = error {- self.log("SOCKS5 UDP ASSOCIATE failed: \(error.localizedDescription)", level: "ERROR")+ self.failUDPHandshake(clientFlow, tcpConnection, "SOCKS5 UDP ASSOCIATE failed: \(error.localizedDescription)")return}-+tcpConnection.readMinimumLength(10, maximumLength: 512) { [weak self] data, error inguard let self = self else { return }-+if let error = error {- self.log("SOCKS5 UDP ASSOCIATE response error: \(error.localizedDescription)", level: "ERROR")+ self.failUDPHandshake(clientFlow, tcpConnection, "SOCKS5 UDP ASSOCIATE response error: \(error.localizedDescription)")return}-+guard let data = data, data.count >= 10, data[0] == 0x05, data[1] == 0x00 else {- self.log("SOCKS5 UDP ASSOCIATE rejected", level: "ERROR")+ self.failUDPHandshake(clientFlow, tcpConnection, "SOCKS5 UDP ASSOCIATE rejected")+ return+ }++ let (parsedHost, relayPort) = self.parseSOCKS5Address(from: data, offset: 3)+ // many socks servers reply 0.0.0.0 meaning "reuse the control connection host"+ let relayHost = (parsedHost == "0.0.0.0" || parsedHost == "::" || parsedHost.isEmpty) ? socksHost : parsedHost+ guard relayPort != 0 else {+ self.failUDPHandshake(clientFlow, tcpConnection, "SOCKS5 UDP ASSOCIATE returned no relay port")return}-- let (relayHost, relayPort) = self.parseSOCKS5Address(from: data, offset: 3)self.relayUDPThroughSOCKS5(clientFlow: clientFlow, relayHost: relayHost, relayPort: relayPort, tcpConnection: tcpConnection, processPath: processPath)}}@@ -756,102 +738,133 @@ class AppProxyProvider: NETransparentProxyProvider {let relayEndpoint = NWHostEndpoint(hostname: relayHost, port: String(relayPort))let udpSession = self.createUDPSession(to: relayEndpoint, from: nil)- tcpConnectionsLock.lock()- udpTCPConnections[clientFlow] = tcpConnection- tcpConnectionsLock.unlock()+ let association = UDPAssociation(clientFlow: clientFlow, controlConnection: tcpConnection, udpSession: udpSession, processPath: processPath)++ udpLock.lock()+ let existing = udpAssociations[clientFlow]+ udpAssociations[clientFlow] = association+ udpLock.unlock()+ // if the app reused a flow, drop the stale association first+ existing?.controlConnection.cancel()+ existing?.udpSession.cancel()++ readAndForwardClientUDP(association)+ readAndForwardRelayUDP(association)+ monitorControlConnection(association)+ }++ // idempotent, cancels both channels and closes the flow exactly once+ private func teardownUDP(_ flow: NEAppProxyUDPFlow) {+ udpLock.lock()+ guard let assoc = udpAssociations.removeValue(forKey: flow), !assoc.isTornDown else {+ udpLock.unlock()+ return+ }+ assoc.isTornDown = true+ udpLock.unlock()- readAndForwardClientUDP(clientFlow: clientFlow, udpSession: udpSession, processPath: processPath)- readAndForwardRelayUDP(clientFlow: clientFlow, udpSession: udpSession)+ assoc.controlConnection.cancel()+ assoc.udpSession.cancel()+ flow.closeReadWithError(nil)+ flow.closeWriteWithError(nil)}- private func cleanupUDPFlow(_ flow: NEAppProxyUDPFlow) {- tcpConnectionsLock.lock()- let conn = udpTCPConnections.removeValue(forKey: flow)- tcpConnectionsLock.unlock()- conn?.cancel()+ // the socks control channel carries no data during a udp associate, so any+ // completion here means the server dropped it and the association is dead+ private func monitorControlConnection(_ association: UDPAssociation) {+ let clientFlow = association.clientFlow+ association.controlConnection.readMinimumLength(1, maximumLength: 1) { [weak self] _, _ in+ self?.teardownUDP(clientFlow)+ }}-- private func readAndForwardClientUDP(clientFlow: NEAppProxyUDPFlow, udpSession: NWUDPSession, processPath: String) {- var isFirstPacket = true-++ private func readAndForwardClientUDP(_ association: UDPAssociation) {+ let clientFlow = association.clientFlowclientFlow.readDatagrams { [weak self] datagrams, endpoints, error inguard let self = self else { return }if let error = error {self.log("UDP read error: \(error.localizedDescription)", level: "ERROR")- self.cleanupUDPFlow(clientFlow)+ self.teardownUDP(clientFlow)return}-- // empty datagrams with no error = flow closed cleanly++ // nil datagrams with no error = flow closed cleanlyguard let datagrams = datagrams, let endpoints = endpoints else {- self.cleanupUDPFlow(clientFlow)+ self.teardownUDP(clientFlow)return}- // empty but non-nil = nothing arrived this read, keep going+ // non-nil but empty = nothing this round, just re-armguard !datagrams.isEmpty else {- self.readAndForwardClientUDP(clientFlow: clientFlow, udpSession: udpSession, processPath: processPath)+ self.readAndForwardClientUDP(association)return}-- for i in 0..<datagrams.count {- let datagram = datagrams[i]- let endpoint = endpoints[i]-- var destHost = ""- var destPort: UInt16 = 0- var portStr = ""-- if let nwHost = endpoint as? NWHostEndpoint {- destHost = nwHost.hostname- destPort = UInt16(nwHost.port) ?? 0- portStr = nwHost.port++ var toSend: [Data] = []+ toSend.reserveCapacity(datagrams.count)++ for i in 0..<min(datagrams.count, endpoints.count) {+ guard let nwHost = endpoints[i] as? NWHostEndpoint else { continue }+ let destHost = nwHost.hostname+ let destPort = UInt16(nwHost.port) ?? 0+ guard destPort != 0 else { continue }++ // log each distinct destination once, cap the set so it can't grow forever+ if !association.loggedDestinations.contains(destHost) {+ if association.loggedDestinations.count < 64 {+ association.loggedDestinations.insert(destHost)+ }+ self.sendLogToApp(protocol: "UDP", process: association.processPath, destination: destHost, port: nwHost.port, proxy: "SOCKS5")}-- if isFirstPacket {- isFirstPacket = false- self.sendLogToApp(protocol: "UDP", process: processPath, destination: destHost, port: portStr, proxy: "SOCKS5")++ if let encapsulated = self.encapsulateSOCKS5UDP(datagram: datagrams[i], destHost: destHost, destPort: destPort) {+ toSend.append(encapsulated)}-- if let encapsulated = self.encapsulateSOCKS5UDP(datagram: datagram, destHost: destHost, destPort: destPort) {- udpSession.writeDatagram(encapsulated, completionHandler: { error in- if let error = error {- self.log("UDP write error: \(error)", level: "ERROR")- }- })+ }++ if !toSend.isEmpty {+ association.udpSession.writeMultipleDatagrams(toSend) { [weak self] error in+ if let error = error {+ self?.log("UDP write error: \(error.localizedDescription)", level: "ERROR")+ }}}-- self.readAndForwardClientUDP(clientFlow: clientFlow, udpSession: udpSession, processPath: processPath)++ self.readAndForwardClientUDP(association)}}-- private func readAndForwardRelayUDP(clientFlow: NEAppProxyUDPFlow, udpSession: NWUDPSession) {- udpSession.setReadHandler({ [weak self] datagrams, error in++ private func readAndForwardRelayUDP(_ association: UDPAssociation) {+ let clientFlow = association.clientFlow+ association.udpSession.setReadHandler({ [weak self] datagrams, error inguard let self = self else { return }-+if let error = error {+ // covers relay failures and icmp port-unreachable surfacing as a read errorself.log("UDP relay error: \(error.localizedDescription)", level: "ERROR")+ self.teardownUDP(clientFlow)return}-- if let datagrams = datagrams, !datagrams.isEmpty {- var unwrappedDatagrams: [Data] = []- var unwrappedEndpoints: [NWEndpoint] = []-- for datagram in datagrams {- if let (unwrapped, destHost, destPort) = self.decapsulateSOCKS5UDPWithEndpoint(datagram: datagram) {- unwrappedDatagrams.append(unwrapped)- unwrappedEndpoints.append(NWHostEndpoint(hostname: destHost, port: String(destPort)))- }++ guard let datagrams = datagrams, !datagrams.isEmpty else { return }++ var payloads: [Data] = []+ var endpoints: [NWEndpoint] = []+ payloads.reserveCapacity(datagrams.count)+ endpoints.reserveCapacity(datagrams.count)++ for datagram in datagrams {+ if let (payload, destHost, destPort) = self.decapsulateSOCKS5UDPWithEndpoint(datagram: datagram) {+ payloads.append(payload)+ endpoints.append(NWHostEndpoint(hostname: destHost, port: String(destPort)))}-- if !unwrappedDatagrams.isEmpty {- clientFlow.writeDatagrams(unwrappedDatagrams, sentBy: unwrappedEndpoints) { error in- if let error = error {- self.log("UDP response write error: \(error.localizedDescription)", level: "ERROR")- }+ }++ if !payloads.isEmpty {+ clientFlow.writeDatagrams(payloads, sentBy: endpoints) { [weak self] error in+ if let error = error {+ self?.log("UDP response write error: \(error.localizedDescription)", level: "ERROR")}}}@@ -875,13 +888,15 @@ class AppProxyProvider: NETransparentProxyProvider {header.append(0x04)header.append(contentsOf: ipv6.rawValue)} else {- guard destHost.count <= 255 else {- self.log("Domain name too long: \(destHost.count) bytes", level: "ERROR")+ // length prefix must be the utf8 byte count, not the character count+ let hostBytes = Array(destHost.utf8)+ guard hostBytes.count <= 255 else {+ self.log("Domain name too long: \(hostBytes.count) bytes", level: "ERROR")return nil}header.append(0x03)- header.append(UInt8(destHost.count))- header.append(destHost.data(using: .utf8) ?? Data())+ header.append(UInt8(hostBytes.count))+ header.append(contentsOf: hostBytes)}header.append(UInt8(destPort >> 8))@@ -898,31 +913,12 @@ class AppProxyProvider: NETransparentProxyProvider {return result}- private func decapsulateSOCKS5UDP(datagram: Data) -> Data? {- guard datagram.count > 10 else { return nil }-- let atyp = datagram[3]- var headerLen = 4-- if atyp == 0x01 {- headerLen += 6- } else if atyp == 0x04 {- headerLen += 18- } else if atyp == 0x03 {- let domainLen = Int(datagram[4])- headerLen += 1 + domainLen + 2- } else {- return nil- }-- guard datagram.count > headerLen else { return nil }-- return datagram[headerLen...]- }-private func decapsulateSOCKS5UDPWithEndpoint(datagram: Data) -> (Data, String, UInt16)? {guard datagram.count > 10 else { return nil }+ // byte 2 is FRAG, we don't reassemble so drop any fragmented datagram+ guard datagram[2] == 0x00 else { return nil }+let atyp = datagram[3]var headerLen = 4var destHost = ""@@ -967,8 +963,6 @@ class AppProxyProvider: NETransparentProxyProvider {let proxyEndpoint = NWHostEndpoint(hostname: config.host, port: String(config.port))let proxyConnection = createTCPConnection(to: proxyEndpoint, enableTLS: false, tlsParameters: nil, delegate: nil)- proxyConnection.addObserver(self, forKeyPath: "state", options: .new, context: nil)-switch config.type.lowercased() {case "socks5":handleSOCKS5Proxy(clientFlow: flow, proxyConnection: proxyConnection, destination: destination, port: port, username: config.username, password: config.password)@@ -1276,9 +1270,6 @@ class AppProxyProvider: NETransparentProxyProvider {}}- override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {- }-private func findMatchingRule(bundleId: String, processName: String?, destination: String, port: UInt16, connectionProtocol: RuleProtocol, checkIpPort: Bool) -> ProxyRule? {rulesLock.lock()let currentRules = rules@@ -1288,54 +1279,44 @@ class AppProxyProvider: NETransparentProxyProvider {for rule in currentRules {guard rule.enabled else { continue }-- // check protocol first+if rule.ruleProtocol != .both && rule.ruleProtocol != connectionProtocol {continue}-- // if this is a wildcard process rule+let isWildcardProcess = (rule.processNames == "*" || rule.processNames.isEmpty)-+if isWildcardProcess {- // wildcard has specific filterslet hasIpFilter = (rule.targetHosts != "*" && !rule.targetHosts.isEmpty)let hasPortFilter = (rule.targetPorts != "*" && !rule.targetPorts.isEmpty)-+if hasIpFilter || hasPortFilter {- // wildcard with filters, check immediately- if checkIpPort {- if rule.matchesIP(destination) && rule.matchesPort(port) {- return rule- }- } else {- // for UDP without destination info, skip filtered wildcards+ // udp has no destination here, so a filtered wildcard can't match+ if checkIpPort, rule.matchesIP(destination), rule.matchesPort(port) {+ return rule}continue}-- // pure wildcard, save it for later - only the first one++ // pure wildcard, keep the first one as a fallbackif wildcardRule == nil {wildcardRule = rule}continue}-- // specific process rule, see if it matches+if rule.matchesProcess(bundleId: bundleId, processName: processName) {- // process matched, now check ip and portif checkIpPort {if rule.matchesIP(destination) && rule.matchesPort(port) {return rule}} else {- // no destination on udp, match on process alone+ // udp matches on process alonereturn rule}}}- // nothing matched, fall back to wildcard if we have oneif let wildcardRule = wildcardRule {return wildcardRule}@@ -1345,25 +1326,7 @@ class AppProxyProvider: NETransparentProxyProvider {private func sendLogToApp(protocol: String, process: String, destination: String, port: String, proxy: String) {guard trafficLoggingEnabled else { return }-- let logData: [String: String] = [- "type": "connection",- "protocol": `protocol`,- "process": process,- "destination": destination,- "port": port,- "proxy": proxy- ]-- logQueueLock.lock()- logBuffer[logTail] = logData- logTail = (logTail + 1) % AppProxyProvider.logCapacity- if logCount < AppProxyProvider.logCapacity {- logCount += 1- } else {- logHead = (logHead + 1) % AppProxyProvider.logCapacity- }- logQueueLock.unlock()+ appendLog(.connection(proto: `protocol`, process: process, destination: destination, port: port, proxy: proxy))}}