Skip to content

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

feat: enhance DNSMapStore with efficient persistence and reload mechanisms

AnoF-Cyberb191487dc870
diff --git a/.gitignore b/.gitignore
index aff2397..b5a6895 100644
--- a/.gitignore
+++ b/.gitignore
@@ -99,4 +99,5 @@ Linux/cli/main.o
Linux/cli/proxybridge-cli
Linux/src/libproxybridge.so
Linux/src/ProxyBridge.o
-Android/**
\ No newline at end of file
+Android/**
+iOS/**
\ No newline at end of file
diff --git a/MacOS/ProxyBridge/extension/AppProxyProvider.swift b/MacOS/ProxyBridge/extension/AppProxyProvider.swift
index 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 in
completionHandler(error)
@@ -405,6 +407,8 @@ class AppProxyProvider: NETransparentProxyProvider {
}
override func stopProxy(with reason: NEProviderStopReason, completionHandler: @escaping () -> Void) {
+ udpSweepTimer?.cancel()
+ udpSweepTimer = nil
udpLock.lock()
let all = Array(udpAssociations.values)
udpAssociations.removeAll()
@@ -425,6 +429,17 @@ class AppProxyProvider: NETransparentProxyProvider {
let displayName: String
var loggedDestinations = Set<String>() // dedupe connection logs, bounded
var 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 false
case "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 true
default:
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 path
let 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 in
if 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 in
if 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 in
if 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 in
if 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.swift
index 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 = 1024
private 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 = true
if 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? Date
lock.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()
}
}