Force Proxy to any Windows/MacOS/Linux Application TCP and UDP traffic
C ccybersecurityhttp3httpproxylinuxlinux-proxymacosmacos-appmacos-proxyproxifierproxifier-alternativeproxyclienttcpthick-clientudpwindivertwindows
feat: enhance DNSMapStore with efficient persistence and reload mechanisms
AnoF-Cyberb191487dc870
diff --git a/.gitignore b/.gitignoreindex aff2397..b5a6895 100644--- a/.gitignore+++ b/.gitignore@@ -99,4 +99,5 @@ Linux/cli/main.oLinux/cli/proxybridge-cliLinux/src/libproxybridge.soLinux/src/ProxyBridge.o-Android/**\ No newline at end of file+Android/**+iOS/**\ No newline at end of filediff --git a/MacOS/ProxyBridge/extension/AppProxyProvider.swift b/MacOS/ProxyBridge/extension/AppProxyProvider.swiftindex 68ce6f2..6027b97 100644--- a/MacOS/ProxyBridge/extension/AppProxyProvider.swift+++ b/MacOS/ProxyBridge/extension/AppProxyProvider.swift@@ -398,6 +398,8 @@ class AppProxyProvider: NETransparentProxyProvider {)settings.includedNetworkRules = [allTrafficRule]++ startUDPSweepTimer()self.setTunnelNetworkSettings(settings) { error incompletionHandler(error)@@ -405,6 +407,8 @@ class AppProxyProvider: NETransparentProxyProvider {}override func stopProxy(with reason: NEProviderStopReason, completionHandler: @escaping () -> Void) {+ udpSweepTimer?.cancel()+ udpSweepTimer = niludpLock.lock()let all = Array(udpAssociations.values)udpAssociations.removeAll()@@ -425,6 +429,17 @@ class AppProxyProvider: NETransparentProxyProvider {let displayName: Stringvar loggedDestinations = Set<String>() // dedupe connection logs, boundedvar isTornDown = false+ private var lastActivity = Date()+ private let activityLock = NSLock()++ func touch() {+ activityLock.lock(); lastActivity = Date(); activityLock.unlock()+ }++ func idleTime() -> TimeInterval {+ activityLock.lock(); defer { activityLock.unlock() }+ return Date().timeIntervalSince(lastActivity)+ }init(clientFlow: NEAppProxyUDPFlow, controlConnection: NWTCPConnection, udpSession: NWUDPSession, displayName: String) {self.clientFlow = clientFlow@@ -435,6 +450,63 @@ class AppProxyProvider: NETransparentProxyProvider {}private var udpAssociations: [NEAppProxyUDPFlow: UDPAssociation] = [:]private let udpLock = NSLock()++ // udp has no close signal we can rely on (quic flows come and go), so idle+ // associations are reaped here, otherwise each one pins a flow, a tcp+ // control connection and a udp session for the life of the extension+ private static let udpIdleTimeout: TimeInterval = 120+ private var udpSweepTimer: DispatchSourceTimer?++ private func startUDPSweepTimer() {+ udpSweepTimer?.cancel()+ let timer = DispatchSource.makeTimerSource(queue: DispatchQueue.global(qos: .utility))+ timer.schedule(deadline: .now() + 30, repeating: 30, leeway: .seconds(5))+ timer.setEventHandler { [weak self] in+ guard let self = self else { return }+ self.udpLock.lock()+ let stale = self.udpAssociations.filter { $0.value.idleTime() > AppProxyProvider.udpIdleTimeout }.map { $0.key }+ self.udpLock.unlock()+ for flow in stale { self.teardownUDP(flow) }+ }+ timer.resume()+ udpSweepTimer = timer+ }++ // tcp and udp proxy handshakes have no timeout of their own, so a proxy that+ // accepts the connection and then goes quiet would pin the flow forever.+ // an id stays in this set until the handshake finishes or the timer fires.+ private var pendingHandshakes = Set<ObjectIdentifier>()+ private let handshakeLock = NSLock()+ private static let handshakeTimeout: TimeInterval = 20++ private func armHandshakeTimeout(flow: NEAppProxyFlow, connection: NWTCPConnection) {+ let id = ObjectIdentifier(connection)+ handshakeLock.lock(); pendingHandshakes.insert(id); handshakeLock.unlock()+ DispatchQueue.global(qos: .utility).asyncAfter(deadline: .now() + AppProxyProvider.handshakeTimeout) { [weak self] in+ guard let self = self else { return }+ self.handshakeLock.lock()+ let timedOut = self.pendingHandshakes.remove(id) != nil+ self.handshakeLock.unlock()+ if timedOut {+ connection.cancel()+ flow.closeReadWithError(nil)+ flow.closeWriteWithError(nil)+ }+ }+ }++ // false means the timeout already fired and tore everything down+ private func completeHandshake(_ connection: NWTCPConnection) -> Bool {+ handshakeLock.lock()+ defer { handshakeLock.unlock() }+ return pendingHandshakes.remove(ObjectIdentifier(connection)) != nil+ }++ private func closeRelay(_ flow: NEAppProxyTCPFlow, _ connection: NWTCPConnection, error: Error? = nil) {+ connection.cancel()+ flow.closeReadWithError(error)+ flow.closeWriteWithError(error)+ }override func handleAppMessage(_ messageData: Data, completionHandler: ((Data?) -> Void)?) {guard let message = try? JSONSerialization.jsonObject(with: messageData) as? [String: Any],@@ -656,6 +728,9 @@ class AppProxyProvider: NETransparentProxyProvider {return falsecase "BLOCK":sendLogToApp(protocol: "UDP", process: displayName, destination: "unknown", port: "unknown", proxy: "BLOCK")+ // a handled flow that is never closed stays pinned in the extension+ flow.closeReadWithError(nil)+ flow.closeWriteWithError(nil)return truedefault:proxyLock.lock()@@ -692,6 +767,7 @@ class AppProxyProvider: NETransparentProxyProvider {private func proxyUDPFlowViaSOCKS5(_ clientFlow: NEAppProxyUDPFlow, displayName: String, socksHost: String, socksPort: Int, username: String?, password: String?) {let proxyEndpoint = NWHostEndpoint(hostname: socksHost, port: String(socksPort))let tcpConnection = createTCPConnection(to: proxyEndpoint, enableTLS: false, tlsParameters: nil, delegate: nil)+ armHandshakeTimeout(flow: clientFlow, connection: tcpConnection)// offer username/password auth when we have credentials, same as the tcp pathlet useAuth = (username != nil && password != nil)@@ -873,6 +949,7 @@ class AppProxyProvider: NETransparentProxyProvider {}private func relayUDPThroughSOCKS5(clientFlow: NEAppProxyUDPFlow, relayHost: String, relayPort: UInt16, tcpConnection: NWTCPConnection, displayName: String) {+ guard completeHandshake(tcpConnection) else { return }let relayEndpoint = NWHostEndpoint(hostname: relayHost, port: String(relayPort))let udpSession = self.createUDPSession(to: relayEndpoint, from: nil)@@ -928,6 +1005,7 @@ class AppProxyProvider: NETransparentProxyProvider {return}+ association.touch()var toSend: [Data] = []toSend.reserveCapacity(datagrams.count)@@ -975,6 +1053,7 @@ class AppProxyProvider: NETransparentProxyProvider {}guard let datagrams = datagrams, !datagrams.isEmpty else { return }+ association.touch()var payloads: [Data] = []var endpoints: [NWEndpoint] = []@@ -1084,6 +1163,7 @@ class AppProxyProvider: NETransparentProxyProvider {private func proxyTCPFlow(_ flow: NEAppProxyTCPFlow, destination: String, port: UInt16, config: StoredProxyConfig) {let proxyEndpoint = NWHostEndpoint(hostname: config.host, port: String(config.port))let proxyConnection = createTCPConnection(to: proxyEndpoint, enableTLS: false, tlsParameters: nil, delegate: nil)+ armHandshakeTimeout(flow: flow, connection: proxyConnection)switch config.type.lowercased() {case "socks5":@@ -1160,12 +1240,18 @@ class AppProxyProvider: NETransparentProxyProvider {}private func sendSOCKS5Auth(clientFlow: NEAppProxyTCPFlow, proxyConnection: NWTCPConnection, destination: String, port: UInt16, username: String, password: String) {+ let user = Array(username.utf8), pass = Array(password.utf8)+ guard user.count <= 255, pass.count <= 255 else {+ log("SOCKS5 credentials too long", level: "ERROR")+ closeRelay(clientFlow, proxyConnection)+ return+ }var authData = Data()authData.append(0x01)- authData.append(UInt8(username.count))- authData.append(username.data(using: .utf8) ?? Data())- authData.append(UInt8(password.count))- authData.append(password.data(using: .utf8) ?? Data())+ authData.append(UInt8(user.count))+ authData.append(contentsOf: user)+ authData.append(UInt8(pass.count))+ authData.append(contentsOf: pass)proxyConnection.write(authData) { [weak self] error inif let error = error {@@ -1213,9 +1299,15 @@ class AppProxyProvider: NETransparentProxyProvider {request.append(0x04)request.append(contentsOf: ipAddr.rawValue)} else {+ let hostBytes = Array(destination.utf8)+ guard hostBytes.count <= 255 else {+ log("SOCKS5 destination name too long", level: "ERROR")+ closeRelay(clientFlow, proxyConnection)+ return+ }request.append(0x03)- request.append(UInt8(destination.count))- request.append(destination.data(using: .utf8) ?? Data())+ request.append(UInt8(hostBytes.count))+ request.append(contentsOf: hostBytes)}request.append(UInt8(port >> 8))@@ -1320,10 +1412,11 @@ class AppProxyProvider: NETransparentProxyProvider {}private func relayData(clientFlow: NEAppProxyTCPFlow, proxyConnection: NWTCPConnection) {+ guard completeHandshake(proxyConnection) else { return }clientFlow.open(withLocalEndpoint: nil) { [weak self] error inif let error = error {self?.log("Failed to open client flow: \(error.localizedDescription)", level: "ERROR")- proxyConnection.cancel()+ self?.closeRelay(clientFlow, proxyConnection, error: error)return}@@ -1340,20 +1433,19 @@ class AppProxyProvider: NETransparentProxyProvider {if code != 57 && code != 54 && code != 89 {self?.log("Client read error: \(error.localizedDescription)", level: "ERROR")}- proxyConnection.cancel()+ self?.closeRelay(clientFlow, proxyConnection)return}guard let data = data, !data.isEmpty else {- proxyConnection.cancel()+ self?.closeRelay(clientFlow, proxyConnection)return}proxyConnection.write(data) { error inif let error = error {self?.log("Proxy write error: \(error.localizedDescription)", level: "ERROR")- clientFlow.closeReadWithError(error)- clientFlow.closeWriteWithError(error)+ self?.closeRelay(clientFlow, proxyConnection, error: error)} else {self?.relayClientToProxy(clientFlow: clientFlow, proxyConnection: proxyConnection)}@@ -1368,21 +1460,19 @@ class AppProxyProvider: NETransparentProxyProvider {if code != 57 && code != 54 && code != 89 {self?.log("Proxy read error: \(error.localizedDescription)", level: "ERROR")}- clientFlow.closeReadWithError(nil)- clientFlow.closeWriteWithError(nil)+ self?.closeRelay(clientFlow, proxyConnection)return}guard let data = data, !data.isEmpty else {- clientFlow.closeReadWithError(nil)- clientFlow.closeWriteWithError(nil)+ self?.closeRelay(clientFlow, proxyConnection)return}clientFlow.write(data) { error inif let error = error {self?.log("Client write error: \(error.localizedDescription)", level: "ERROR")- proxyConnection.cancel()+ self?.closeRelay(clientFlow, proxyConnection, error: error)} else {self?.relayProxyToClient(clientFlow: clientFlow, proxyConnection: proxyConnection)}diff --git a/MacOS/ProxyBridge/extension/DNSMapStore.swift b/MacOS/ProxyBridge/extension/DNSMapStore.swiftindex fadeeb7..e89b006 100644--- a/MacOS/ProxyBridge/extension/DNSMapStore.swift+++ b/MacOS/ProxyBridge/extension/DNSMapStore.swift@@ -15,6 +15,15 @@ final class DNSMapStore {private let maxEntries = 1024private var lastMtime: Date?+ // the file is rewritten at most once per persistInterval no matter how many+ // lookups land, and the reader only stats it once per reloadCheckInterval,+ // domains(forIP:) runs for every new connection+ private let persistInterval: TimeInterval = 1.0+ private let reloadCheckInterval: TimeInterval = 1.0+ private var persistScheduled = false+ private var lastReloadCheck = Date.distantPast+ private let ioQueue = DispatchQueue(label: "com.interceptsuite.ProxyBridge.dnsmap", qos: .utility)+private init() {fileURL = FileManager.default.containerURL(forSecurityApplicationGroupIdentifier: appGroup)?@@ -45,18 +54,25 @@ final class DNSMapStore {order.append(ip)changed = trueif order.count > maxEntries {- let evicted = order.removeFirst()- map[evicted] = nil+ // drop a batch at once so the O(n) removal isn't paid per insert+ let overflow = order.count - maxEntries + 64+ for evicted in order.prefix(overflow) { map[evicted] = nil }+ order.removeFirst(min(overflow, order.count))}}if map[ip]?.insert(name).inserted == true { changed = true }}// only touch the file when something actually changed, most resolutions// are repeats of already-known domains- let snapshot = changed ? map : nil+ let shouldSchedule = changed && !persistScheduled+ if shouldSchedule { persistScheduled = true }lock.unlock()- if let snapshot = snapshot { persist(snapshot) }+ if shouldSchedule {+ ioQueue.asyncAfter(deadline: .now() + persistInterval) { [weak self] in+ self?.persist()+ }+ }}// reader side (transparent proxy): domains that resolved to this ip, if any@@ -67,15 +83,36 @@ final class DNSMapStore {return Array(map[ip] ?? [])}- private func persist(_ snapshot: [String: Set<String>]) {+ private func persist() {+ lock.lock()+ persistScheduled = false+ let snapshot = map+ lock.unlock()+guard let fileURL = fileURL else { return }let plain = snapshot.mapValues { Array($0) }guard let data = try? JSONSerialization.data(withJSONObject: plain) else { return }try? data.write(to: fileURL, options: .atomic)++ // remember our own write so the reader doesn't parse back what it already has+ let mtime = (try? FileManager.default.attributesOfItem(atPath: fileURL.path)[.modificationDate]) as? Date+ lock.lock()+ lastMtime = mtime+ lock.unlock()}private func reloadIfChanged() {guard let fileURL = fileURL else { return }++ lock.lock()+ let now = Date()+ if now.timeIntervalSince(lastReloadCheck) < reloadCheckInterval {+ lock.unlock()+ return+ }+ lastReloadCheck = now+ lock.unlock()+let mtime = (try? FileManager.default.attributesOfItem(atPath: fileURL.path)[.modificationDate]) as? Datelock.lock()let needsReload = mtime != nil && mtime != lastMtime@@ -89,6 +126,8 @@ final class DNSMapStore {}lock.lock()map = plain.mapValues { Set($0) }+ // keep eviction order in step with the loaded map+ order = Array(plain.keys)lock.unlock()}}