Skip to content

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

Fixed app crash, too much memroy and threads usage on connection added build scrippt, Copied Windows CLI into Linux C CLI

anof-cyberd702722cc5d1
diff --git a/Linux/build.sh b/Linux/build.sh
new file mode 100755
index 0000000..95faec7
--- /dev/null
+++ b/Linux/build.sh
@@ -0,0 +1,71 @@
+#!/bin/bash
+
+set -e # Exit on error
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+OUTPUT_DIR="$SCRIPT_DIR/output"
+
+# Remove and recreate output directory
+if [ -d "$OUTPUT_DIR" ]; then
+ echo "Removing existing output directory..."
+ rm -rf "$OUTPUT_DIR"
+fi
+
+echo "Creating output directory..."
+mkdir -p "$OUTPUT_DIR"
+echo ""
+
+# Build library
+echo "=== Building Library ==="
+cd "$SCRIPT_DIR/src"
+make clean 2>/dev/null || true
+make
+
+if [ -f "libproxybridge.so" ]; then
+ echo "✓ Library build successful"
+else
+ echo "✗ Library build failed!"
+ exit 1
+fi
+echo ""
+
+# Build CLI (library must stay for linking)
+echo "=== Building CLI ==="
+cd "$SCRIPT_DIR/cli"
+make clean 2>/dev/null || true
+make
+
+if [ -f "proxybridge-cli" ]; then
+ echo "✓ CLI build successful"
+else
+ echo "✗ CLI build failed!"
+ exit 1
+fi
+echo ""
+
+# Move binaries to output
+echo "Moving binaries to output directory..."
+mv "$SCRIPT_DIR/src/libproxybridge.so" "$OUTPUT_DIR/"
+mv proxybridge-cli "$OUTPUT_DIR/"
+echo "✓ Binaries moved to output"
+echo ""
+
+# Cleanup build files
+echo "Cleaning up build artifacts..."
+cd "$SCRIPT_DIR/src"
+rm -f *.o
+make clean 2>/dev/null || true
+cd "$SCRIPT_DIR/cli"
+rm -f *.o
+make clean 2>/dev/null || true
+echo "✓ Cleanup complete"
+echo ""
+
+# Show results
+echo "==================================="
+echo "Build Complete!"
+echo "==================================="
+cd "$OUTPUT_DIR"
+ls -lh
+echo ""
+echo "Output location: $OUTPUT_DIR"
diff --git a/Linux/cli/main.c b/Linux/cli/main.c
index 2948ee0..eee7b8d 100644
--- a/Linux/cli/main.c
+++ b/Linux/cli/main.c
@@ -4,177 +4,466 @@
#include <unistd.h>
#include <signal.h>
#include <stdbool.h>
+#include <ctype.h>
#include "../src/ProxyBridge.h"
-static volatile bool keep_running = true;
+#define MAX_RULES 100
+#define MAX_RULE_STR 512
+
+typedef struct {
+ char process_name[256];
+ char target_hosts[256];
+ char target_ports[256];
+ RuleProtocol protocol;
+ RuleAction action;
+} ProxyRule;
+
+static volatile bool keep_running = false;
+static int verbose_level = 0;
static void log_callback(const char* message)
{
- printf("[LOG] %s\n", message);
+ if (verbose_level == 1 || verbose_level == 3)
+ {
+ printf("[LOG] %s\n", message);
+ }
}
static void connection_callback(const char* process_name, uint32_t pid, const char* dest_ip, uint16_t dest_port, const char* proxy_info)
{
- printf("[CONN] %s (PID: %u) -> %s:%u via %s\n",
- process_name, pid, dest_ip, dest_port, proxy_info);
+ if (verbose_level == 2 || verbose_level == 3)
+ {
+ printf("[CONN] %s (PID:%u) -> %s:%u via %s\n",
+ process_name, pid, dest_ip, dest_port, proxy_info);
+ }
}
static void signal_handler(int sig)
{
- (void)sig;
- keep_running = false;
+ if (sig == SIGSEGV || sig == SIGABRT || sig == SIGBUS)
+ {
+ printf("\n\n=== CLI CRASH DETECTED ===\n");
+ printf("Signal: %d (%s)\n", sig,
+ sig == SIGSEGV ? "SEGFAULT" :
+ sig == SIGABRT ? "ABORT" : "BUS ERROR");
+ printf("Calling emergency cleanup...\n");
+ ProxyBridge_Stop();
+ _exit(1);
+ }
+
+ if (keep_running)
+ {
+ printf("\n\nStopping ProxyBridge...\n");
+ keep_running = false;
+ }
+}
+
+static void show_banner(void)
+{
+ printf("\n");
+ printf(" ____ ____ _ _ \n");
+ printf(" | _ \\ _ __ _____ ___ _ | __ ) _ __(_) __| | __ _ ___ \n");
+ printf(" | |_) | '__/ _ \\ \\/ / | | | | _ \\| '__| |/ _` |/ _` |/ _ \\\n");
+ printf(" | __/| | | (_) > <| |_| | | |_) | | | | (_| | (_| | __/\n");
+ printf(" |_| |_| \\___/_/\\_\\\\__, | |____/|_| |_|\\__,_|\\__, |\\___|\n");
+ printf(" |___/ |___/ V3.1.0\n");
+ printf("\n");
+ printf(" Universal proxy client for Linux applications\n");
+ printf("\n");
+ printf("\tAuthor: Sourav Kalal/InterceptSuite\n");
+ printf("\tGitHub: https://github.com/InterceptSuite/ProxyBridge\n");
+ printf("\n");
+}
+
+static void show_help(const char* prog)
+{
+ show_banner();
+ printf("USAGE:\n");
+ printf(" %s [OPTIONS]\n\n", prog);
+
+ printf("OPTIONS:\n");
+ printf(" --proxy <url> Proxy server URL with optional authentication\n");
+ printf(" Format: type://ip:port or type://ip:port:username:password\n");
+ printf(" Examples: socks5://127.0.0.1:1080\n");
+ printf(" http://proxy.com:8080:myuser:mypass\n");
+ printf(" Default: socks5://127.0.0.1:4444\n\n");
+
+ printf(" --rule <rule> Traffic routing rule (can be specified multiple times)\n");
+ printf(" Format: process:hosts:ports:protocol:action\n");
+ printf(" process - Process name(s): curl, cur*, *, or multiple separated by ;\n");
+ printf(" hosts - IP/host(s): *, google.com, 192.168.*.*, or multiple separated by ; or ,\n");
+ printf(" ports - Port(s): *, 443, 80;8080, 80-100, or multiple separated by ; or ,\n");
+ printf(" protocol - TCP, UDP, or BOTH\n");
+ printf(" action - PROXY, DIRECT, or BLOCK\n");
+ printf(" Examples:\n");
+ printf(" curl:*:*:TCP:PROXY\n");
+ printf(" curl;wget:*:*:TCP:PROXY\n");
+ printf(" *:*:53:UDP:PROXY\n");
+ printf(" firefox:*:80;443:TCP:DIRECT\n\n");
+
+ printf(" --dns-via-proxy Route DNS queries through proxy (default: true)\n");
+ printf(" --no-dns-via-proxy Do not route DNS queries through proxy\n\n");
+
+ printf(" --verbose <level> Logging verbosity level\n");
+ printf(" 0 - No logs (default)\n");
+ printf(" 1 - Show log messages only\n");
+ printf(" 2 - Show connection events only\n");
+ printf(" 3 - Show both logs and connections\n\n");
+
+ printf(" --help, -h Show this help message\n\n");
+
+ printf("EXAMPLES:\n");
+ printf(" # Basic usage with default proxy\n");
+ printf(" sudo %s --rule curl:*:*:TCP:PROXY\n\n", prog);
+
+ printf(" # Multiple rules with custom proxy\n");
+ printf(" sudo %s --proxy socks5://192.168.1.10:1080 \\\n", prog);
+ printf(" --rule curl:*:*:TCP:PROXY \\\n");
+ printf(" --rule wget:*:*:TCP:PROXY \\\n");
+ printf(" --verbose 2\n\n");
+
+ printf(" # Route DNS through proxy with multiple apps\n");
+ printf(" sudo %s --proxy socks5://127.0.0.1:1080 \\\n", prog);
+ printf(" --rule \"curl;wget;firefox:*:*:BOTH:PROXY\" \\\n");
+ printf(" --dns-via-proxy --verbose 3\n\n");
+
+ printf("NOTE:\n");
+ printf(" ProxyBridge requires root privileges to use nfqueue.\n");
+ printf(" Run with 'sudo' or as root user.\n\n");
+}
+
+static RuleProtocol parse_protocol(const char* str)
+{
+ char upper[16];
+ for (size_t i = 0; str[i] && i < 15; i++)
+ upper[i] = toupper(str[i]);
+ upper[strlen(str) < 15 ? strlen(str) : 15] = '\0';
+
+ if (strcmp(upper, "TCP") == 0)
+ return RULE_PROTOCOL_TCP;
+ else if (strcmp(upper, "UDP") == 0)
+ return RULE_PROTOCOL_UDP;
+ else if (strcmp(upper, "BOTH") == 0)
+ return RULE_PROTOCOL_BOTH;
+ else
+ {
+ fprintf(stderr, "ERROR: Invalid protocol '%s'. Use TCP, UDP, or BOTH\n", str);
+ exit(1);
+ }
+}
+
+static RuleAction parse_action(const char* str)
+{
+ char upper[16];
+ for (size_t i = 0; str[i] && i < 15; i++)
+ upper[i] = toupper(str[i]);
+ upper[strlen(str) < 15 ? strlen(str) : 15] = '\0';
+
+ if (strcmp(upper, "PROXY") == 0)
+ return RULE_ACTION_PROXY;
+ else if (strcmp(upper, "DIRECT") == 0)
+ return RULE_ACTION_DIRECT;
+ else if (strcmp(upper, "BLOCK") == 0)
+ return RULE_ACTION_BLOCK;
+ else
+ {
+ fprintf(stderr, "ERROR: Invalid action '%s'. Use PROXY, DIRECT, or BLOCK\n", str);
+ exit(1);
+ }
+}
+
+static void default_if_empty(char* dest, const char* src, const char* default_val, size_t dest_size)
+{
+ if (src == NULL || src[0] == '\0' || strcmp(src, " ") == 0)
+ strncpy(dest, default_val, dest_size - 1);
+ else
+ strncpy(dest, src, dest_size - 1);
+ dest[dest_size - 1] = '\0';
+}
+
+static bool parse_rule(const char* rule_str, ProxyRule* rule)
+{
+ char buffer[MAX_RULE_STR];
+ strncpy(buffer, rule_str, sizeof(buffer) - 1);
+ buffer[sizeof(buffer) - 1] = '\0';
+
+ char* parts[5] = {NULL, NULL, NULL, NULL, NULL};
+ int part_idx = 0;
+ char* token = strtok(buffer, ":");
+
+ while (token != NULL && part_idx < 5)
+ {
+ parts[part_idx++] = token;
+ token = strtok(NULL, ":");
+ }
+
+ if (part_idx != 5)
+ {
+ fprintf(stderr, "ERROR: Invalid rule format '%s'\n", rule_str);
+ fprintf(stderr, "Expected format: process:hosts:ports:protocol:action\n");
+ return false;
+ }
+
+ default_if_empty(rule->process_name, parts[0], "*", sizeof(rule->process_name));
+ default_if_empty(rule->target_hosts, parts[1], "*", sizeof(rule->target_hosts));
+ default_if_empty(rule->target_ports, parts[2], "*", sizeof(rule->target_ports));
+
+ rule->protocol = parse_protocol(parts[3]);
+ rule->action = parse_action(parts[4]);
+
+ return true;
+}
+
+static bool parse_proxy_url(const char* url, ProxyType* type, char* host, uint16_t* port, char* username, char* password)
+{
+ char buffer[512];
+ strncpy(buffer, url, sizeof(buffer) - 1);
+ buffer[sizeof(buffer) - 1] = '\0';
+
+ username[0] = '\0';
+ password[0] = '\0';
+
+ // Parse type://
+ char* scheme_end = strstr(buffer, "://");
+ if (scheme_end == NULL)
+ {
+ fprintf(stderr, "ERROR: Invalid proxy URL format. Expected type://host:port\n");
+ return false;
+ }
+
+ *scheme_end = '\0';
+ char* scheme = buffer;
+ char* rest = scheme_end + 3;
+
+ char upper_scheme[16];
+ for (size_t i = 0; scheme[i] && i < 15; i++)
+ upper_scheme[i] = toupper(scheme[i]);
+ upper_scheme[strlen(scheme) < 15 ? strlen(scheme) : 15] = '\0';
+
+ if (strcmp(upper_scheme, "SOCKS5") == 0)
+ *type = PROXY_TYPE_SOCKS5;
+ else if (strcmp(upper_scheme, "HTTP") == 0)
+ *type = PROXY_TYPE_HTTP;
+ else
+ {
+ fprintf(stderr, "ERROR: Invalid proxy type '%s'. Use 'socks5' or 'http'\n", scheme);
+ return false;
+ }
+
+ // Parse host:port[:username:password]
+ char* parts[4];
+ int num_parts = 0;
+ char* token = strtok(rest, ":");
+ while (token != NULL && num_parts < 4)
+ {
+ parts[num_parts++] = token;
+ token = strtok(NULL, ":");
+ }
+
+ if (num_parts < 2)
+ {
+ fprintf(stderr, "ERROR: Invalid proxy URL. Missing host or port\n");
+ return false;
+ }
+
+ strncpy(host, parts[0], 255);
+ host[255] = '\0';
+
+ *port = atoi(parts[1]);
+ if (*port == 0)
+ {
+ fprintf(stderr, "ERROR: Invalid proxy port '%s'\n", parts[1]);
+ return false;
+ }
+
+ if (num_parts >= 4)
+ {
+ strncpy(username, parts[2], 255);
+ username[255] = '\0';
+ strncpy(password, parts[3], 255);
+ password[255] = '\0';
+ }
+
+ return true;
}
-static void print_usage(const char* prog)
+static bool is_root(void)
{
- printf("usage: %s [options]\n", prog);
- printf("options:\n");
- printf(" -h <proxy_host> proxy server hostname or ip (default: 127.0.0.1)\n");
- printf(" -p <proxy_port> proxy server port (default: 1080)\n");
- printf(" -t <type> proxy type: socks5 or http (default: socks5)\n");
- printf(" -u <username> proxy username (optional)\n");
- printf(" -w <password> proxy password (optional)\n");
- printf(" -d disable dns via proxy\n");
- printf(" --help show this help\n");
- printf("\nexample:\n");
- printf(" %s -h 127.0.0.1 -p 1080 -t socks5\n", prog);
+ return getuid() == 0;
}
int main(int argc, char *argv[])
{
- char proxy_host[256] = "192.168.1.4";
- uint16_t proxy_port = 4444;
- ProxyType proxy_type = PROXY_TYPE_SOCKS5;
- char username[256] = "";
- char password[256] = "";
+ char proxy_url[512] = "socks5://127.0.0.1:4444";
+ ProxyRule rules[MAX_RULES];
+ int num_rules = 0;
bool dns_via_proxy = true;
-
- // parse args
+
+ // Parse arguments
for (int i = 1; i < argc; i++)
{
- if (strcmp(argv[i], "--help") == 0)
+ if (strcmp(argv[i], "--help") == 0 || strcmp(argv[i], "-h") == 0)
{
- print_usage(argv[0]);
+ show_help(argv[0]);
return 0;
}
- else if (strcmp(argv[i], "-h") == 0 && i + 1 < argc)
+ else if (strcmp(argv[i], "--proxy") == 0 && i + 1 < argc)
{
- strncpy(proxy_host, argv[++i], sizeof(proxy_host) - 1);
+ strncpy(proxy_url, argv[++i], sizeof(proxy_url) - 1);
+ proxy_url[sizeof(proxy_url) - 1] = '\0';
}
- else if (strcmp(argv[i], "-p") == 0 && i + 1 < argc)
+ else if (strcmp(argv[i], "--rule") == 0 && i + 1 < argc)
{
- proxy_port = atoi(argv[++i]);
+ if (num_rules >= MAX_RULES)
+ {
+ fprintf(stderr, "ERROR: Maximum %d rules supported\n", MAX_RULES);
+ return 1;
+ }
+ if (!parse_rule(argv[++i], &rules[num_rules]))
+ return 1;
+ num_rules++;
}
- else if (strcmp(argv[i], "-t") == 0 && i + 1 < argc)
+ else if (strcmp(argv[i], "--dns-via-proxy") == 0)
{
- if (strcmp(argv[i + 1], "http") == 0)
- proxy_type = PROXY_TYPE_HTTP;
- else if (strcmp(argv[i + 1], "socks5") == 0)
- proxy_type = PROXY_TYPE_SOCKS5;
- i++;
+ dns_via_proxy = true;
}
- else if (strcmp(argv[i], "-u") == 0 && i + 1 < argc)
+ else if (strcmp(argv[i], "--no-dns-via-proxy") == 0)
{
- strncpy(username, argv[++i], sizeof(username) - 1);
+ dns_via_proxy = false;
}
- else if (strcmp(argv[i], "-w") == 0 && i + 1 < argc)
+ else if (strcmp(argv[i], "--verbose") == 0 && i + 1 < argc)
{
- strncpy(password, argv[++i], sizeof(password) - 1);
+ verbose_level = atoi(argv[++i]);
+ if (verbose_level < 0 || verbose_level > 3)
+ {
+ fprintf(stderr, "ERROR: Verbose level must be 0-3\n");
+ return 1;
+ }
}
- else if (strcmp(argv[i], "-d") == 0)
+ else
{
- dns_via_proxy = false;
+ fprintf(stderr, "ERROR: Unknown option '%s'\n", argv[i]);
+ fprintf(stderr, "Use --help for usage information\n");
+ return 1;
}
}
-
- printf("proxybridge cli test\n");
- printf("proxy: %s://%s:%u\n", proxy_type == PROXY_TYPE_HTTP ? "http" : "socks5",
- proxy_host, proxy_port);
-
- // setup callbacks
- ProxyBridge_SetLogCallback(log_callback);
- ProxyBridge_SetConnectionCallback(connection_callback);
-
- // configure proxy
- if (!ProxyBridge_SetProxyConfig(proxy_type, proxy_host, proxy_port,
- username[0] ? username : NULL,
- password[0] ? password : NULL))
- {
- fprintf(stderr, "failed to configure proxy\n");
- return 1;
- }
-
- ProxyBridge_SetDnsViaProxy(dns_via_proxy);
- ProxyBridge_SetTrafficLoggingEnabled(true);
-
- // add rules - redirect specific apps to proxy
- uint32_t rule_id1 = ProxyBridge_AddRule("curl", "*", "*", RULE_PROTOCOL_TCP, RULE_ACTION_PROXY);
- if (rule_id1 == 0)
+
+ show_banner();
+
+ // Check root privileges
+ if (!is_root())
{
- fprintf(stderr, "failed to add curl rule\n");
+ printf("\033[31m\nERROR: ProxyBridge requires root privileges!\033[0m\n");
+ printf("Please run this application with sudo or as root.\n\n");
return 1;
}
- 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");
+
+ // Parse proxy configuration
+ ProxyType proxy_type;
+ char proxy_host[256];
+ uint16_t proxy_port;
+ char proxy_username[256];
+ char proxy_password[256];
+
+ if (!parse_proxy_url(proxy_url, &proxy_type, proxy_host, &proxy_port, proxy_username, proxy_password))
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)
+
+ // Setup callbacks based on verbose level
+ if (verbose_level == 1 || verbose_level == 3)
+ ProxyBridge_SetLogCallback(log_callback);
+
+ if (verbose_level == 2 || verbose_level == 3)
+ ProxyBridge_SetConnectionCallback(connection_callback);
+
+ // Enable traffic logging only if needed
+ ProxyBridge_SetTrafficLoggingEnabled(verbose_level > 0);
+
+ // Display configuration
+ printf("Proxy: %s://%s:%u\n",
+ proxy_type == PROXY_TYPE_HTTP ? "http" : "socks5",
+ proxy_host, proxy_port);
+
+ if (proxy_username[0] != '\0')
+ printf("Proxy Auth: %s:***\n", proxy_username);
+
+ printf("DNS via Proxy: %s\n", dns_via_proxy ? "Enabled" : "Disabled");
+
+ // Configure proxy
+ if (!ProxyBridge_SetProxyConfig(proxy_type, proxy_host, proxy_port,
+ proxy_username[0] ? proxy_username : "",
+ proxy_password[0] ? proxy_password : ""))
{
- fprintf(stderr, "failed to add http3-client rule\n");
+ fprintf(stderr, "ERROR: Failed to set proxy configuration\n");
return 1;
}
- printf("added rule id %u: http3-client udp traffic via proxy\n", rule_id3);
-
- // test connection
- char test_result[2048];
- printf("\ntesting proxy connection\n");
- if (ProxyBridge_TestConnection("www.google.com", 80, test_result, sizeof(test_result)) == 0)
+
+ ProxyBridge_SetDnsViaProxy(dns_via_proxy);
+
+ // Add rules
+ if (num_rules > 0)
{
- printf("%s\n", test_result);
+ printf("Rules: %d\n", num_rules);
+ for (int i = 0; i < num_rules; i++)
+ {
+ const char* protocol_str = rules[i].protocol == RULE_PROTOCOL_TCP ? "TCP" :
+ rules[i].protocol == RULE_PROTOCOL_UDP ? "UDP" : "BOTH";
+ const char* action_str = rules[i].action == RULE_ACTION_PROXY ? "PROXY" :
+ rules[i].action == RULE_ACTION_DIRECT ? "DIRECT" : "BLOCK";
+
+ uint32_t rule_id = ProxyBridge_AddRule(
+ rules[i].process_name,
+ rules[i].target_hosts,
+ rules[i].target_ports,
+ rules[i].protocol,
+ rules[i].action);
+
+ if (rule_id > 0)
+ {
+ printf(" [%u] %s:%s:%s:%s -> %s\n",
+ rule_id,
+ rules[i].process_name,
+ rules[i].target_hosts,
+ rules[i].target_ports,
+ protocol_str,
+ action_str);
+ }
+ else
+ {
+ fprintf(stderr, " ERROR: Failed to add rule for %s\n", rules[i].process_name);
+ }
+ }
}
else
{
- printf("connection test failed:\n%s\n", test_result);
- return 1;
+ printf("\033[33mWARNING: No rules specified. No traffic will be proxied.\033[0m\n");
+ printf("Use --rule to add proxy rules. See --help for examples.\n");
}
-
- // start service
- printf("\nstarting proxybridge\n");
- printf("note: requires root privileges for nfqueue\n");
- if (getuid() != 0)
- {
- fprintf(stderr, "error: must run as root\n");
- return 1;
- }
-
+ // Start ProxyBridge
if (!ProxyBridge_Start())
{
- fprintf(stderr, "failed to start proxybridge\n");
+ fprintf(stderr, "ERROR: Failed to start ProxyBridge\n");
return 1;
}
-
- printf("proxybridge running - press ctrl+c to stop\n");
-
+
+ keep_running = true;
+ printf("\nProxyBridge started. Press Ctrl+C to stop...\n\n");
+
signal(SIGINT, signal_handler);
signal(SIGTERM, signal_handler);
-
- // main loop
+ signal(SIGSEGV, signal_handler); // Catch segfault
+ signal(SIGABRT, signal_handler); // Catch abort
+ signal(SIGBUS, signal_handler); // Catch bus error
+
+ // Main loop
while (keep_running)
{
sleep(1);
}
-
- printf("\nstopping proxybridge\n");
+
+ // Cleanup
ProxyBridge_Stop();
-
- printf("cleanup completed\n");
+ printf("ProxyBridge stopped.\n");
+
return 0;
}
diff --git a/Linux/src/ProxyBridge.c b/Linux/src/ProxyBridge.c
index 9f981a4..8433bb7 100644
--- a/Linux/src/ProxyBridge.c
+++ b/Linux/src/ProxyBridge.c
@@ -7,7 +7,9 @@
#include <errno.h>
#include <ctype.h>
#include <dirent.h>
+#include <fcntl.h>
#include <sys/socket.h>
+#include <sys/epoll.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/tcp.h>
@@ -92,6 +94,18 @@ static LOGGED_CONNECTION *logged_connections = NULL;
static PROCESS_RULE *rules_list = NULL;
static uint32_t g_next_rule_id = 1;
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
+
+typedef struct {
+ int client_socket;
+ uint32_t orig_dest_ip;
+ uint16_t orig_dest_port;
+} connection_config_t;
+
+typedef struct {
+ int from_socket;
+ int to_socket;
+} transfer_config_t;
+
static struct nfq_handle *nfq_h = NULL;
static struct nfq_q_handle *nfq_qh = NULL;
static pthread_t packet_thread[NUM_PACKET_THREADS] = {0};
@@ -952,114 +966,153 @@ static int http_connect(int s, uint32_t dest_ip, uint16_t dest_port)
return 0;
}
-static void* transfer_handler(void *arg)
-{
- TRANSFER_CONFIG *config = arg;
- char buffer[65536];
- ssize_t n;
-
- while ((n = recv(config->from_socket, buffer, sizeof(buffer), 0)) > 0)
- {
- if (send_all(config->to_socket, buffer, n) < 0)
- break;
- }
-
- shutdown(config->from_socket, SHUT_RD);
- shutdown(config->to_socket, SHUT_WR);
- free(config);
- return NULL;
-}
+// ===== EPOLL RELAY FUNCTIONS (Production) =====
+// Windows-style connection handler - blocks on connect and handshake, then calls transfer_handler
static void* connection_handler(void *arg)
{
- CONNECTION_CONFIG *config = arg;
+ connection_config_t *config = (connection_config_t *)arg;
int client_sock = config->client_socket;
uint32_t dest_ip = config->orig_dest_ip;
uint16_t dest_port = config->orig_dest_port;
- int socks_sock;
- struct sockaddr_in socks_addr;
- uint32_t socks5_ip;
+ int proxy_sock;
+ struct sockaddr_in proxy_addr;
+ uint32_t proxy_ip;
free(config);
- socks5_ip = resolve_hostname(g_proxy_host);
- if (socks5_ip == 0)
+ // Connect to proxy
+ proxy_ip = resolve_hostname(g_proxy_host);
+ if (proxy_ip == 0)
{
close(client_sock);
return NULL;
}
- socks_sock = socket(AF_INET, SOCK_STREAM, 0);
- if (socks_sock < 0)
+ proxy_sock = socket(AF_INET, SOCK_STREAM, 0);
+ if (proxy_sock < 0)
{
- log_message("socket creation failed %d", errno);
close(client_sock);
return NULL;
}
- configure_tcp_socket(socks_sock, 524288, 30000);
+ configure_tcp_socket(proxy_sock, 524288, 30000);
configure_tcp_socket(client_sock, 524288, 30000);
- 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);
+ memset(&proxy_addr, 0, sizeof(proxy_addr));
+ proxy_addr.sin_family = AF_INET;
+ proxy_addr.sin_addr.s_addr = proxy_ip;
+ proxy_addr.sin_port = htons(g_proxy_port);
- if (connect(socks_sock, (struct sockaddr *)&socks_addr, sizeof(socks_addr)) < 0)
+ if (connect(proxy_sock, (struct sockaddr *)&proxy_addr, sizeof(proxy_addr)) < 0)
{
- log_message("failed to connect to proxy %d", errno);
close(client_sock);
- close(socks_sock);
+ close(proxy_sock);
return NULL;
}
+ // Do blocking handshake
if (g_proxy_type == PROXY_TYPE_SOCKS5)
{
- if (socks5_connect(socks_sock, dest_ip, dest_port) != 0)
+ if (socks5_connect(proxy_sock, dest_ip, dest_port) != 0)
{
close(client_sock);
- close(socks_sock);
+ close(proxy_sock);
return NULL;
}
}
else if (g_proxy_type == PROXY_TYPE_HTTP)
{
- if (http_connect(socks_sock, dest_ip, dest_port) != 0)
+ if (http_connect(proxy_sock, dest_ip, dest_port) != 0)
{
close(client_sock);
- close(socks_sock);
+ close(proxy_sock);
return NULL;
}
}
- TRANSFER_CONFIG *client_to_socks = malloc(sizeof(TRANSFER_CONFIG));
- TRANSFER_CONFIG *socks_to_client = malloc(sizeof(TRANSFER_CONFIG));
-
- if (!client_to_socks || !socks_to_client)
+ // Create transfer config
+ transfer_config_t *transfer_config = (transfer_config_t *)malloc(sizeof(transfer_config_t));
+ if (transfer_config == NULL)
{
close(client_sock);
- close(socks_sock);
- free(client_to_socks);
- free(socks_to_client);
+ close(proxy_sock);
return NULL;
}
- client_to_socks->from_socket = client_sock;
- client_to_socks->to_socket = socks_sock;
- socks_to_client->from_socket = socks_sock;
- socks_to_client->to_socket = client_sock;
+ transfer_config->from_socket = client_sock;
+ transfer_config->to_socket = proxy_sock;
+
+ // Do bidirectional transfer in this thread (like Windows)
+ transfer_handler((void*)transfer_config);
- pthread_t transfer_thread;
- pthread_create(&transfer_thread, NULL, transfer_handler, client_to_socks);
- pthread_detach(transfer_thread);
+ return NULL;
+}
+
+// Windows-style transfer handler - uses select() to monitor both sockets
+static void* transfer_handler(void *arg)
+{
+ transfer_config_t *config = (transfer_config_t *)arg;
+ int sock1 = config->from_socket; // client socket
+ int sock2 = config->to_socket; // proxy socket
+ char buf[131072]; // 128KB buffer
+ int len;
+
+ free(config);
+
+ // Monitor BOTH sockets in one thread (like Windows)
+ while (1)
+ {
+ fd_set readfds;
+ struct timeval timeout;
+
+ FD_ZERO(&readfds);
+ FD_SET(sock1, &readfds); // client
+ FD_SET(sock2, &readfds); // proxy
+
+ timeout.tv_sec = 0;
+ timeout.tv_usec = 50000; // 50ms
+
+ int ready = select(FD_SETSIZE, &readfds, NULL, NULL, &timeout);
+
+ if (ready < 0)
+ break;
+
+ if (ready == 0)
+ continue;
- transfer_handler(socks_to_client);
+ // Check client to proxy
+ if (FD_ISSET(sock1, &readfds))
+ {
+ len = recv(sock1, buf, sizeof(buf), 0);
+ if (len <= 0)
+ break;
+
+ if (send_all(sock2, buf, len) < 0)
+ break;
+ }
+
+ // Check proxy to client
+ if (FD_ISSET(sock2, &readfds))
+ {
+ len = recv(sock2, buf, sizeof(buf), 0);
+ if (len <= 0)
+ break;
- close(client_sock);
- close(socks_sock);
+ if (send_all(sock1, buf, len) < 0)
+ break;
+ }
+ }
+
+ // Cleanup
+ shutdown(sock1, SHUT_RDWR);
+ shutdown(sock2, SHUT_RDWR);
+ close(sock1);
+ close(sock2);
return NULL;
}
+// Windows-style proxy server - accepts and spawns thread per connection
static void* local_proxy_server(void *arg)
{
(void)arg;
@@ -1070,14 +1123,12 @@ static void* local_proxy_server(void *arg)
listen_sock = socket(AF_INET, SOCK_STREAM, 0);
if (listen_sock < 0)
{
- log_message("socket creation failed %d", errno);
+ log_message("Socket creation failed");
return NULL;
}
setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
-
- int nodelay = 1;
- setsockopt(listen_sock, IPPROTO_TCP, TCP_NODELAY, &nodelay, sizeof(nodelay));
+ setsockopt(listen_sock, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on));
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
@@ -1086,19 +1137,19 @@ static void* local_proxy_server(void *arg)
if (bind(listen_sock, (struct sockaddr *)&addr, sizeof(addr)) < 0)
{
- log_message("bind failed %d", errno);
+ log_message("Bind failed");
close(listen_sock);
return NULL;
}
if (listen(listen_sock, SOMAXCONN) < 0)
{
- log_message("listen failed %d", errno);
+ log_message("Listen failed");
close(listen_sock);
return NULL;
}
- log_message("local proxy listening on port %d", g_local_relay_port);
+ log_message("Local proxy listening on port %d", g_local_relay_port);
while (running)
{
@@ -1107,7 +1158,7 @@ static void* local_proxy_server(void *arg)
FD_SET(listen_sock, &read_fds);
struct timeval timeout = {1, 0};
- if (select(listen_sock + 1, &read_fds, NULL, NULL, &timeout) <= 0)
+ if (select(FD_SETSIZE, &read_fds, NULL, NULL, &timeout) <= 0)
continue;
struct sockaddr_in client_addr;
@@ -1117,10 +1168,7 @@ static void* local_proxy_server(void *arg)
if (client_sock < 0)
continue;
- log_message("[RELAY] accepted connection from %s:%u",
- inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
-
- CONNECTION_CONFIG *conn_config = malloc(sizeof(CONNECTION_CONFIG));
+ connection_config_t *conn_config = (connection_config_t *)malloc(sizeof(connection_config_t));
if (conn_config == NULL)
{
close(client_sock);
@@ -1132,20 +1180,14 @@ static void* local_proxy_server(void *arg)
uint16_t client_port = ntohs(client_addr.sin_port);
if (!get_connection(client_port, &conn_config->orig_dest_ip, &conn_config->orig_dest_port))
{
- log_message("[RELAY] no connection tracking for port %u", client_port);
close(client_sock);
free(conn_config);
continue;
}
-
- char dest_str[32];
- format_ip_address(conn_config->orig_dest_ip, dest_str, sizeof(dest_str));
- log_message("[RELAY] forwarding to %s:%u via proxy", dest_str, conn_config->orig_dest_port);
pthread_t conn_thread;
- if (pthread_create(&conn_thread, NULL, connection_handler, conn_config) != 0)
+ if (pthread_create(&conn_thread, NULL, connection_handler, (void*)conn_config) != 0)
{
- log_message("pthread_create failed %d", errno);
close(client_sock);
free(conn_config);
continue;