Skip to content

Force Proxy to any Windows/MacOS/Linux Application TCP and UDP traffic

Refactor RuleManager and AppProxyProvider for improved clarity and performance

AnoF-Cyber2fc49502484b
diff --git a/MacOS/ProxyBridge/ProxyBridge/ContentView.swift b/MacOS/ProxyBridge/ProxyBridge/ContentView.swift
index 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 cpu
if 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 cpu
if 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.swift
index d0915a8..11f7a84 100644
--- a/MacOS/ProxyBridge/ProxyBridge/ProxyBridgeViewModel.swift
+++ b/MacOS/ProxyBridge/ProxyBridge/ProxyBridgeViewModel.swift
@@ -2,6 +2,7 @@ import Foundation
import NetworkExtension
import SystemExtensions
import Combine
+import AppKit
class 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 entry
private let trimToEntries = 800
private let logPollingInterval = 1.0
private let extensionIdentifier = "com.interceptsuite.ProxyBridge.extension"
- // reuse formatter
- // saves memory about 2% and speed up the ui
private 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 size
private var connectionIdCounter: Int = 0
private 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 stopping
clearExtensionMemory(session: session) { [weak self] in
guard 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 closed
RuleManager.clearRules(session: session) { success, message in
- //clear proxy config as well keep meory usage low for extesion
let 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] in
guard 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 in
guard 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.swift
index 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 rules
static 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.swift
index 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 assets
let pkgAsset = release.assets.first { asset in
asset.name.lowercased().hasSuffix(".pkg") &&
(asset.name.lowercased().contains("proxybridge") ||
asset.name.lowercased().contains("installer"))
}
- // a macOS pkg installer in the release is valid update
let isUpdateAvailable = isNewerVersion(latestVersion, currentVersion) && pkgAsset != nil
return VersionInfo(
@@ -95,34 +93,50 @@ class UpdateService {
let tempDir = FileManager.default.temporaryDirectory
let fileURL = tempDir.appendingPathComponent(fileName)
- // Remove existing file if any
try? 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 = 0
for 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 = downloadedBytes
let 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 installer
NSWorkspace.shared.open(installerPath)
-
- // Give the installer a moment to start, then quit
+ // let the installer come up before we quit
DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
NSApplication.shared.terminate(nil)
}
diff --git a/MacOS/ProxyBridge/extension/AppProxyProvider.swift b/MacOS/ProxyBridge/extension/AppProxyProvider.swift
index 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.254
if 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 pop
private 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 = 0
private var logCount = 0
private 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 connection
private 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 first
pidCacheLock.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] = entry
logTail = (logTail + 1) % AppProxyProvider.logCapacity
if 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 entry
logHead = (logHead + 1) % AppProxyProvider.logCapacity
logCount -= 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 through
return false
}
@@ -539,11 +507,11 @@ class AppProxyProvider: NETransparentProxyProvider {
let metaData = flow.metaData
let processPath = metaData.sourceAppSigningIdentifier
- // early exit for own app traffic before any other work
+ // never proxy our own traffic, it would loop
if processPath == "com.interceptsuite.ProxyBridge" || processPath == "com.interceptsuite.ProxyBridge.extension" {
return false
}
-
+
let remoteEndpoint = flow.remoteEndpoint
var 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 in
guard 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 in
guard 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 in
guard 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 in
guard 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.clientFlow
clientFlow.readDatagrams { [weak self] datagrams, endpoints, error in
guard 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 cleanly
guard 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-arm
guard !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 in
guard let self = self else { return }
-
+
if let error = error {
+ // covers relay failures and icmp port-unreachable surfacing as a read error
self.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 = 4
var 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 filters
let 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 fallback
if 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 port
if checkIpPort {
if rule.matchesIP(destination) && rule.matchesPort(port) {
return rule
}
} else {
- // no destination on udp, match on process alone
+ // udp matches on process alone
return rule
}
}
}
- // nothing matched, fall back to wildcard if we have one
if 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))
}
}