Force Proxy to any Windows/MacOS/Linux Application TCP and UDP traffic
C ccybersecurityhttp3httpproxylinuxlinux-proxymacosmacos-appmacos-proxyproxifierproxifier-alternativeproxyclienttcpthick-clientudpwindivertwindows
added udp support, added socsk5 assoicate, added caching, fixed connection track, fixed pid lookup, added falback, improved lookup speed
anof-cyberd7a758a1a21c
diff --git a/.gitignore b/.gitignoreindex bbf80e0..3a0bbe7 100644--- a/.gitignore+++ b/.gitignore@@ -95,3 +95,7 @@ Linux/output/**Linux/build/**MacOS/ProxyBridge/config/Signing-Config-ext.xcconfigMacOS/ProxyBridge/config/Signing-Config-app.xcconfig+Linux/cli/main.o+Linux/cli/proxybridge-cli+Linux/src/libproxybridge.so+Linux/src/ProxyBridge.odiff --git a/Linux/cli/main.c b/Linux/cli/main.cindex c3c582b..2948ee0 100644--- a/Linux/cli/main.c+++ b/Linux/cli/main.c@@ -107,14 +107,30 @@ int main(int argc, char *argv[])ProxyBridge_SetDnsViaProxy(dns_via_proxy);ProxyBridge_SetTrafficLoggingEnabled(true);- // add rule - curl tcp traffic via proxy- uint32_t rule_id = ProxyBridge_AddRule("curl", "*", "*", RULE_PROTOCOL_TCP, RULE_ACTION_PROXY);- if (rule_id == 0)+ // add rules - redirect specific apps to proxy+ uint32_t rule_id1 = ProxyBridge_AddRule("curl", "*", "*", RULE_PROTOCOL_TCP, RULE_ACTION_PROXY);+ if (rule_id1 == 0){fprintf(stderr, "failed to add curl rule\n");return 1;}- printf("added rule id %u: curl tcp traffic via proxy\n", rule_id);+ printf("added rule id %u: curl tcp traffic via proxy\n", rule_id1);++ uint32_t rule_id2 = ProxyBridge_AddRule("nghttp", "*", "*", RULE_PROTOCOL_BOTH, RULE_ACTION_PROXY);+ if (rule_id2 == 0)+ {+ fprintf(stderr, "failed to add nghttp rule\n");+ return 1;+ }+ printf("added rule id %u: nghttp tcp+udp traffic via proxy\n", rule_id2);++ uint32_t rule_id3 = ProxyBridge_AddRule("http3-client", "*", "*", RULE_PROTOCOL_UDP, RULE_ACTION_PROXY);+ if (rule_id3 == 0)+ {+ fprintf(stderr, "failed to add http3-client rule\n");+ return 1;+ }+ printf("added rule id %u: http3-client udp traffic via proxy\n", rule_id3);// test connectionchar test_result[2048];diff --git a/Linux/src/ProxyBridge.c b/Linux/src/ProxyBridge.cindex d9a6b2f..94d4513 100644--- a/Linux/src/ProxyBridge.c+++ b/Linux/src/ProxyBridge.c@@ -96,12 +96,21 @@ static struct nfq_handle *nfq_h = NULL;static struct nfq_q_handle *nfq_qh = NULL;static pthread_t packet_thread[NUM_PACKET_THREADS] = {0};static pthread_t proxy_thread = 0;+static pthread_t udp_relay_thread = 0;static pthread_t cleanup_thread = 0;static PID_CACHE_ENTRY *pid_cache[PID_CACHE_SIZE] = {NULL};static bool g_has_active_rules = false;static bool running = false;static uint32_t g_current_process_id = 0;+// UDP relay globals+static int udp_relay_socket = -1;+static int socks5_udp_control_socket = -1;+static int socks5_udp_send_socket = -1;+static struct sockaddr_in socks5_udp_relay_addr;+static bool udp_associate_connected = false;+static uint64_t last_udp_connect_attempt = 0;+static bool g_traffic_logging_enabled = true;static char g_proxy_host[256] = "";@@ -270,7 +279,7 @@ static uint32_t get_process_id_from_connection(uint32_t src_ip, uint16_t src_porreq.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;req.r.sdiag_family = AF_INET;req.r.sdiag_protocol = is_udp ? IPPROTO_UDP : IPPROTO_TCP;- req.r.idiag_states = is_udp ? (1 << TCP_ESTABLISHED) : -1;+ req.r.idiag_states = -1; // All states (UDP is connectionless, doesn't have TCP states)req.r.idiag_ext = 0;struct sockaddr_nl sa;@@ -379,6 +388,76 @@ static uint32_t get_process_id_from_connection(uint32_t src_ip, uint16_t src_pordone:close(fd);++ // Fallback for UDP: scan /proc/net/udp if netlink didn't find the socket+ // This happens when UDP socket uses sendto() without connect()+ if (matches_found == 0 && is_udp) {++ // Try both IPv4 and IPv6 (socket might be IPv6 sending IPv4 packets)+ const char* udp_files[] = {"/proc/net/udp", "/proc/net/udp6"};+ for (int file_idx = 0; file_idx < 2 && pid == 0; file_idx++) {+ FILE *fp = fopen(udp_files[file_idx], "r");+ if (fp) {+ char line[512];+ (void)fgets(line, sizeof(line), fp); // skip header+ int entries_scanned = 0;+ while (fgets(line, sizeof(line), fp)) {+ unsigned int local_addr, local_port;+ unsigned long inode;+ int uid_val;++ // Format: sl local_address rem_address st tx_queue rx_queue tr tm->when retrnsmt uid timeout inode+ if (sscanf(line, "%*d: %X:%X %*X:%*X %*X %*X:%*X %*X:%*X %*X %d %*d %lu",+ &local_addr, &local_port, &uid_val, &inode) == 4) {+ entries_scanned++;++ if (local_port == src_port) {+ target_inode = inode;++ // Now find PID from /proc/*/fd/* with this inode+ DIR *proc_dir = opendir("/proc");+ if (proc_dir) {+ struct dirent *proc_entry;+ while ((proc_entry = readdir(proc_dir)) != NULL && pid == 0) {+ if (proc_entry->d_type == DT_DIR && isdigit(proc_entry->d_name[0])) {+ char fd_path[256];+ snprintf(fd_path, sizeof(fd_path), "/proc/%s/fd", proc_entry->d_name);+ DIR *fd_dir = opendir(fd_path);+ if (fd_dir) {+ struct dirent *fd_entry;+ while ((fd_entry = readdir(fd_dir)) != NULL && pid == 0) {+ if (fd_entry->d_type == DT_LNK) {+ char link_path[512];+ snprintf(link_path, sizeof(link_path), "/proc/%s/fd/%s",+ proc_entry->d_name, fd_entry->d_name);+ char link_target[256];+ ssize_t link_len = readlink(link_path, link_target, sizeof(link_target) - 1);+ if (link_len > 0) {+ link_target[link_len] = '\0';+ char expected[64];+ snprintf(expected, sizeof(expected), "socket:[%lu]", inode);+ if (strcmp(link_target, expected) == 0) {+ pid = (uint32_t)atoi(proc_entry->d_name);+ break;+ }+ }+ }+ }+ closedir(fd_dir);+ }+ }+ }+ closedir(proc_dir);+ }+ break;+ }+ }+ }+ fclose(fp);+ }+ }+ }+if (pid != 0)cache_pid(src_ip, src_port, pid, is_udp);return pid;@@ -1056,6 +1135,304 @@ static void* local_proxy_server(void *arg)return NULL;}+// SOCKS5 UDP ASSOCIATE+static int socks5_udp_associate(int s, struct sockaddr_in *relay_addr)+{+ unsigned char buf[512];+ ssize_t len;++ // Auth handshake+ bool use_auth = (g_proxy_username[0] != '\0');+ buf[0] = SOCKS5_VERSION;+ buf[1] = use_auth ? 0x02 : 0x01;+ buf[2] = SOCKS5_AUTH_NONE;+ if (use_auth)+ buf[3] = 0x02; // username/password auth++ if (send(s, buf, use_auth ? 4 : 3, 0) != (use_auth ? 4 : 3))+ return -1;++ len = recv(s, buf, 2, 0);+ if (len != 2 || buf[0] != SOCKS5_VERSION)+ return -1;++ if (buf[1] == 0x02 && use_auth)+ {+ size_t ulen = strlen(g_proxy_username);+ size_t plen = strlen(g_proxy_password);+ buf[0] = 0x01;+ buf[1] = (unsigned char)ulen;+ memcpy(buf + 2, g_proxy_username, ulen);+ buf[2 + ulen] = (unsigned char)plen;+ memcpy(buf + 3 + ulen, g_proxy_password, plen);++ if (send(s, buf, 3 + ulen + plen, 0) != (ssize_t)(3 + ulen + plen))+ return -1;++ len = recv(s, buf, 2, 0);+ if (len != 2 || buf[0] != 0x01 || buf[1] != 0x00)+ return -1;+ }+ else if (buf[1] != SOCKS5_AUTH_NONE)+ return -1;++ // UDP ASSOCIATE request+ buf[0] = SOCKS5_VERSION;+ buf[1] = SOCKS5_CMD_UDP_ASSOCIATE;+ buf[2] = 0x00;+ buf[3] = SOCKS5_ATYP_IPV4;+ memset(buf + 4, 0, 4); // 0.0.0.0+ memset(buf + 8, 0, 2); // port 0++ if (send(s, buf, 10, 0) != 10)+ return -1;++ len = recv(s, buf, 512, 0);+ if (len < 10 || buf[0] != SOCKS5_VERSION || buf[1] != 0x00)+ return -1;++ // Extract relay address+ if (buf[3] == SOCKS5_ATYP_IPV4)+ {+ memset(relay_addr, 0, sizeof(*relay_addr));+ relay_addr->sin_family = AF_INET;+ memcpy(&relay_addr->sin_addr.s_addr, buf + 4, 4);+ memcpy(&relay_addr->sin_port, buf + 8, 2);+ return 0;+ }++ return -1;+}++static bool establish_udp_associate(void)+{+ uint64_t now = get_monotonic_ms();+ if (now - last_udp_connect_attempt < 5000)+ return false;++ last_udp_connect_attempt = now;++ if (socks5_udp_control_socket >= 0)+ {+ close(socks5_udp_control_socket);+ socks5_udp_control_socket = -1;+ }+ if (socks5_udp_send_socket >= 0)+ {+ close(socks5_udp_send_socket);+ socks5_udp_send_socket = -1;+ }++ int tcp_sock = socket(AF_INET, SOCK_STREAM, 0);+ if (tcp_sock < 0)+ return false;++ configure_tcp_socket(tcp_sock, 262144, 3000);++ uint32_t socks5_ip = resolve_hostname(g_proxy_host);+ if (socks5_ip == 0)+ {+ close(tcp_sock);+ return false;+ }++ struct sockaddr_in socks_addr;+ memset(&socks_addr, 0, sizeof(socks_addr));+ socks_addr.sin_family = AF_INET;+ socks_addr.sin_addr.s_addr = socks5_ip;+ socks_addr.sin_port = htons(g_proxy_port);++ if (connect(tcp_sock, (struct sockaddr *)&socks_addr, sizeof(socks_addr)) < 0)+ {+ close(tcp_sock);+ return false;+ }++ if (socks5_udp_associate(tcp_sock, &socks5_udp_relay_addr) != 0)+ {+ close(tcp_sock);+ return false;+ }++ socks5_udp_control_socket = tcp_sock;++ socks5_udp_send_socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);+ if (socks5_udp_send_socket < 0)+ {+ close(socks5_udp_control_socket);+ socks5_udp_control_socket = -1;+ return false;+ }++ configure_udp_socket(socks5_udp_send_socket, 262144, 30000);++ udp_associate_connected = true;+ log_message("[UDP] ASSOCIATE established with SOCKS5 proxy");+ return true;+}++static void* udp_relay_server(void *arg)+{+ (void)arg;+ struct sockaddr_in local_addr, from_addr;+ unsigned char recv_buf[65536];+ unsigned char send_buf[65536];+ socklen_t from_len;++ udp_relay_socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);+ if (udp_relay_socket < 0)+ return NULL;++ int on = 1;+ setsockopt(udp_relay_socket, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));+ configure_udp_socket(udp_relay_socket, 262144, 30000);++ memset(&local_addr, 0, sizeof(local_addr));+ local_addr.sin_family = AF_INET;+ local_addr.sin_addr.s_addr = INADDR_ANY;+ local_addr.sin_port = htons(LOCAL_UDP_RELAY_PORT);++ if (bind(udp_relay_socket, (struct sockaddr *)&local_addr, sizeof(local_addr)) < 0)+ {+ close(udp_relay_socket);+ udp_relay_socket = -1;+ return NULL;+ }++ udp_associate_connected = establish_udp_associate();++ log_message("[UDP] relay listening on port %d", LOCAL_UDP_RELAY_PORT);+ if (!udp_associate_connected)+ log_message("[UDP] ASSOCIATE not available yet - will retry when needed");++ while (running)+ {+ fd_set read_fds;+ FD_ZERO(&read_fds);+ FD_SET(udp_relay_socket, &read_fds);++ int max_fd = udp_relay_socket;++ if (udp_associate_connected && socks5_udp_send_socket >= 0)+ {+ FD_SET(socks5_udp_send_socket, &read_fds);+ if (socks5_udp_send_socket > max_fd)+ max_fd = socks5_udp_send_socket;+ }++ struct timeval timeout = {1, 0};++ if (select(max_fd + 1, &read_fds, NULL, NULL, &timeout) <= 0)+ continue;++ // Client -> SOCKS5 proxy+ if (FD_ISSET(udp_relay_socket, &read_fds))+ {+ from_len = sizeof(from_addr);+ ssize_t recv_len = recvfrom(udp_relay_socket, recv_buf, sizeof(recv_buf), 0,+ (struct sockaddr *)&from_addr, &from_len);+ if (recv_len <= 0)+ continue;++ if (!udp_associate_connected)+ {+ if (!establish_udp_associate())+ continue;+ }++ uint16_t client_port = ntohs(from_addr.sin_port);+ uint32_t dest_ip;+ uint16_t dest_port;++ if (!get_connection(client_port, &dest_ip, &dest_port))+ continue;++ // Build SOCKS5 UDP packet: +----+------+------+----------+----------+----------++ // |RSV | FRAG | ATYP | DST.ADDR | DST.PORT | DATA |+ // +----+------+------+----------+----------+----------++ send_buf[0] = 0x00; // RSV+ send_buf[1] = 0x00; // RSV+ send_buf[2] = 0x00; // FRAG+ send_buf[3] = SOCKS5_ATYP_IPV4;+ memcpy(send_buf + 4, &dest_ip, 4);+ uint16_t port_net = htons(dest_port);+ memcpy(send_buf + 8, &port_net, 2);+ memcpy(send_buf + 10, recv_buf, recv_len);++ sendto(socks5_udp_send_socket, send_buf, 10 + recv_len, 0,+ (struct sockaddr *)&socks5_udp_relay_addr, sizeof(socks5_udp_relay_addr));+ }++ // SOCKS5 proxy -> Client+ if (udp_associate_connected && socks5_udp_send_socket >= 0 && FD_ISSET(socks5_udp_send_socket, &read_fds))+ {+ from_len = sizeof(from_addr);+ ssize_t recv_len = recvfrom(socks5_udp_send_socket, recv_buf, sizeof(recv_buf), 0,+ (struct sockaddr *)&from_addr, &from_len);+ if (recv_len < 10)+ continue;++ // Parse SOCKS5 UDP packet+ if (recv_buf[3] != SOCKS5_ATYP_IPV4)+ continue;++ uint32_t src_ip;+ uint16_t src_port;+ memcpy(&src_ip, recv_buf + 4, 4);+ memcpy(&src_port, recv_buf + 8, 2);+ src_port = ntohs(src_port);++ // Find the client that sent a packet to this destination+ // Iterate through hash table to find matching dest_ip:dest_port+ pthread_mutex_lock(&lock);++ struct sockaddr_in client_addr;+ bool found_client = false;++ for (int hash = 0; hash < CONNECTION_HASH_SIZE; hash++)+ {+ CONNECTION_INFO *conn = connection_hash_table[hash];+ while (conn != NULL)+ {+ if (conn->orig_dest_ip == src_ip &&+ conn->orig_dest_port == src_port)+ {+ // Found the connection - send response back to original client port+ memset(&client_addr, 0, sizeof(client_addr));+ client_addr.sin_family = AF_INET;+ client_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);+ client_addr.sin_port = htons(conn->src_port);+ found_client = true;+ break;+ }+ conn = conn->next;+ }+ if (found_client)+ break;+ }++ pthread_mutex_unlock(&lock);++ if (found_client)+ {+ // Send unwrapped UDP data back to client+ ssize_t data_len = recv_len - 10;+ sendto(udp_relay_socket, recv_buf + 10, data_len, 0,+ (struct sockaddr *)&client_addr, sizeof(client_addr));+ }+ }+ }++ if (socks5_udp_control_socket >= 0)+ close(socks5_udp_control_socket);+ if (socks5_udp_send_socket >= 0)+ close(socks5_udp_send_socket);+ if (udp_relay_socket >= 0)+ close(udp_relay_socket);++ return NULL;+}+// nfqueue packet callbackstatic int packet_callback(struct nfq_q_handle *qh, struct nfgenmsg *nfmsg, struct nfq_data *nfad, void *data){@@ -1127,17 +1504,17 @@ static int packet_callback(struct nfq_q_handle *qh, struct nfgenmsg *nfmsg, struchar proxy_info[128];if (action == RULE_ACTION_PROXY){- snprintf(proxy_info, sizeof(proxy_info), "proxy %s://%s:%d",+ snprintf(proxy_info, sizeof(proxy_info), "proxy %s://%s:%d tcp",g_proxy_type == PROXY_TYPE_HTTP ? "http" : "socks5",g_proxy_host, g_proxy_port);}else if (action == RULE_ACTION_DIRECT){- snprintf(proxy_info, sizeof(proxy_info), "direct");+ snprintf(proxy_info, sizeof(proxy_info), "direct tcp");}else if (action == RULE_ACTION_BLOCK){- snprintf(proxy_info, sizeof(proxy_info), "blocked");+ snprintf(proxy_info, sizeof(proxy_info), "blocked tcp");}const char* display_name = extract_filename(process_name);@@ -1191,15 +1568,37 @@ static int packet_callback(struct nfq_q_handle *qh, struct nfgenmsg *nfmsg, struif (action == RULE_ACTION_PROXY && (dest_port == 67 || dest_port == 68))action = RULE_ACTION_DIRECT;++ // UDP proxy only works with SOCKS5, not HTTP+ if (action == RULE_ACTION_PROXY && g_proxy_type != PROXY_TYPE_SOCKS5)+ action = RULE_ACTION_DIRECT;++ // UDP proxy only works with SOCKS5, not HTTP+ if (action == RULE_ACTION_PROXY && g_proxy_type != PROXY_TYPE_SOCKS5)+ action = RULE_ACTION_DIRECT;++ // UDP proxy only works with SOCKS5, not HTTP+ if (action == RULE_ACTION_PROXY && g_proxy_type != PROXY_TYPE_SOCKS5)+ action = RULE_ACTION_DIRECT;- // log (skip our own process)- if (g_connection_callback != NULL && pid > 0 && pid != g_current_process_id)+ // log (skip our own process, log even without PID for ephemeral UDP sockets)+ if (g_connection_callback != NULL && pid != g_current_process_id){char process_name[MAX_PROCESS_NAME];- if (get_process_name_from_pid(pid, process_name, sizeof(process_name)))+ uint32_t log_pid = (pid == 0) ? 1 : pid; // Use PID 1 for unknown processes++ if (pid > 0 && get_process_name_from_pid(pid, process_name, sizeof(process_name)))+ {+ // Got process name from PID+ }+ else+ {+ // UDP socket not found - ephemeral or timing issue+ snprintf(process_name, sizeof(process_name), "unknown");+ }++ if (!is_connection_already_logged(log_pid, dest_ip, dest_port, action)){- if (!is_connection_already_logged(pid, dest_ip, dest_port, action))- {char dest_ip_str[32];format_ip_address(dest_ip, dest_ip_str, sizeof(dest_ip_str));@@ -1219,14 +1618,13 @@ static int packet_callback(struct nfq_q_handle *qh, struct nfgenmsg *nfmsg, stru}const char* display_name = extract_filename(process_name);- g_connection_callback(display_name, pid, dest_ip_str, dest_port, proxy_info);+ g_connection_callback(display_name, log_pid, dest_ip_str, dest_port, proxy_info);if (g_traffic_logging_enabled){- add_logged_connection(pid, dest_ip, dest_port, action);+ add_logged_connection(log_pid, dest_ip, dest_port, action);}}- }}if (action == RULE_ACTION_DIRECT)@@ -1235,16 +1633,12 @@ static int packet_callback(struct nfq_q_handle *qh, struct nfgenmsg *nfmsg, strureturn nfq_set_verdict(qh, id, NF_DROP, 0, NULL);else if (action == RULE_ACTION_PROXY){+ // UDP proxy via SOCKS5 UDP ASSOCIATEadd_connection(src_port, src_ip, dest_ip, dest_port);- // add dynamic redirect rule for this source port- char cmd[256];- snprintf(cmd, sizeof(cmd),- "iptables -t nat -A OUTPUT -p udp --sport %u -j REDIRECT --to-port %u 2>/dev/null",- src_port, LOCAL_UDP_RELAY_PORT);- system(cmd);-- return nfq_set_verdict(qh, id, NF_ACCEPT, 0, NULL);+ // Mark UDP packet for redirect to local UDP relay (port 34011)+ uint32_t mark = 2; // Use mark=2 for UDP (mark=1 is for TCP)+ return nfq_set_verdict2(qh, id, NF_ACCEPT, mark, 0, NULL);}}@@ -1872,6 +2266,15 @@ bool ProxyBridge_Start(void)return false;}+ // Start UDP relay server if SOCKS5 proxy+ if (g_proxy_type == PROXY_TYPE_SOCKS5)+ {+ if (pthread_create(&udp_relay_thread, NULL, udp_relay_server, NULL) != 0)+ {+ log_message("failed to create UDP relay thread");+ }+ }+nfq_h = nfq_open();if (!nfq_h){@@ -1925,11 +2328,13 @@ bool ProxyBridge_Start(void)// setup nat redirect for marked packetsint ret3 = system("iptables -t nat -A OUTPUT -p tcp -m mark --mark 1 -j REDIRECT --to-port 34010");- if (ret3 != 0) {- log_message("failed to add nat redirect rule");+ int ret4 = system("iptables -t nat -A OUTPUT -p udp -m mark --mark 2 -j REDIRECT --to-port 34011");+ if (ret3 != 0 || ret4 != 0) {+ log_message("failed to add nat redirect rules");}(void)ret3;+ (void)ret4;for (int i = 0; i < NUM_PACKET_THREADS; i++){@@ -1954,9 +2359,11 @@ bool ProxyBridge_Stop(void)int ret1 = system("iptables -t mangle -D OUTPUT -p tcp -j NFQUEUE --queue-num 0 2>/dev/null");int ret2 = system("iptables -t mangle -D OUTPUT -p udp -j NFQUEUE --queue-num 0 2>/dev/null");int ret3 = system("iptables -t nat -D OUTPUT -p tcp -m mark --mark 1 -j REDIRECT --to-port 34010 2>/dev/null");+ int ret4 = system("iptables -t nat -D OUTPUT -p udp -m mark --mark 2 -j REDIRECT --to-port 34011 2>/dev/null");(void)ret1;(void)ret2;(void)ret3;+ (void)ret4;for (int i = 0; i < NUM_PACKET_THREADS; i++){@@ -1987,6 +2394,13 @@ bool ProxyBridge_Stop(void)proxy_thread = 0;}+ if (udp_relay_thread != 0)+ {+ pthread_cancel(udp_relay_thread);+ pthread_join(udp_relay_thread, NULL);+ udp_relay_thread = 0;+ }+if (cleanup_thread != 0){pthread_cancel(cleanup_thread);