Create other_files/network_filter.c

other_files/network_filter.c

@@ -0,0 +1,192 @@
+/*
+ * network_filter.c - LD_PRELOAD library to filter network connections
+ * 编译: gcc -shared -fPIC -o network_filter.so network_filter.c -ldl
+ * 使用: LD_PRELOAD=./network_filter.so ALLOWED_HOSTS="127.0.0.1,api.openai.com" your_program
+ */
+
+ #define _GNU_SOURCE
+ #include <dlfcn.h>
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <string.h>
+ #include <sys/socket.h>
+ #include <netinet/in.h>
+ #include <arpa/inet.h>
+ #include <netdb.h>
+ #include <errno.h>
+ #include <unistd.h>
+ 
+ // 函数指针类型定义
+ typedef int (*original_connect_t)(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
+ typedef int (*original_socket_t)(int domain, int type, int protocol);
+ typedef ssize_t (*original_send_t)(int sockfd, const void *buf, size_t len, int flags);
+ typedef ssize_t (*original_sendto_t)(int sockfd, const void *buf, size_t len, int flags,
+                                      const struct sockaddr *dest_addr, socklen_t addrlen);
+ 
+ // 全局变量
+ static original_connect_t original_connect = NULL;
+ static original_socket_t original_socket = NULL;
+ static original_send_t original_send = NULL;
+ static original_sendto_t original_sendto = NULL;
+ 
+ static char allowed_hosts[1024] = {0};
+ static int filter_initialized = 0;
+ 
+ // 初始化过滤器
+ static void init_filter() {
+     if (filter_initialized) return;
+     
+     const char* env_hosts = getenv("ALLOWED_HOSTS");
+     if (env_hosts) {
+         strncpy(allowed_hosts, env_hosts, sizeof(allowed_hosts) - 1);
+     } else {
+         // 默认允许的主机
+         strcpy(allowed_hosts, "127.0.0.1,::1,localhost");
+     }
+     
+     filter_initialized = 1;
+ }
+ 
+ // 检查IP地址是否被允许
+ static int is_ip_allowed(const char* ip_str) {
+     init_filter();
+     
+     char* hosts_copy = strdup(allowed_hosts);
+     char* token = strtok(hosts_copy, ",");
+     
+     while (token != NULL) {
+         // 去除前后空格
+         while (*token == ' ') token++;
+         char* end = token + strlen(token) - 1;
+         while (end > token && *end == ' ') *end-- = '\0';
+         
+         // 检查是否是IP地址直接匹配
+         if (strcmp(token, ip_str) == 0) {
+             free(hosts_copy);
+             return 1;
+         }
+         
+         // 如果是域名，解析并比较
+         struct hostent* host_entry = gethostbyname(token);
+         if (host_entry != NULL) {
+             for (int i = 0; host_entry->h_addr_list[i] != NULL; i++) {
+                 char* resolved_ip = inet_ntoa(*((struct in_addr*)host_entry->h_addr_list[i]));
+                 if (strcmp(resolved_ip, ip_str) == 0) {
+                     free(hosts_copy);
+                     return 1;
+                 }
+             }
+         }
+         
+         token = strtok(NULL, ",");
+     }
+     
+     free(hosts_copy);
+     return 0;
+ }
+ 
+ // 检查连接地址是否被允许
+ static int is_connection_allowed(const struct sockaddr *addr) {
+     if (addr->sa_family == AF_INET) {
+         struct sockaddr_in* sin = (struct sockaddr_in*)addr;
+         char ip_str[INET_ADDRSTRLEN];
+         inet_ntop(AF_INET, &(sin->sin_addr), ip_str, INET_ADDRSTRLEN);
+         
+         int allowed = is_ip_allowed(ip_str);
+         if (!allowed) {
+             fprintf(stderr, "[NETWORK_FILTER] Blocked connection to %s:%d\n", 
+                    ip_str, ntohs(sin->sin_port));
+         } else {
+             fprintf(stderr, "[NETWORK_FILTER] Allowed connection to %s:%d\n", 
+                    ip_str, ntohs(sin->sin_port));
+         }
+         return allowed;
+     } else if (addr->sa_family == AF_INET6) {
+         struct sockaddr_in6* sin6 = (struct sockaddr_in6*)addr;
+         char ip_str[INET6_ADDRSTRLEN];
+         inet_ntop(AF_INET6, &(sin6->sin6_addr), ip_str, INET6_ADDRSTRLEN);
+         
+         int allowed = is_ip_allowed(ip_str);
+         if (!allowed) {
+             fprintf(stderr, "[NETWORK_FILTER] Blocked IPv6 connection to [%s]:%d\n", 
+                    ip_str, ntohs(sin6->sin6_port));
+         } else {
+             fprintf(stderr, "[NETWORK_FILTER] Allowed IPv6 connection to [%s]:%d\n", 
+                    ip_str, ntohs(sin6->sin6_port));
+         }
+         return allowed;
+     } else if (addr->sa_family == AF_UNIX) {
+         // 允许 Unix domain socket
+         return 1;
+     }
+     
+     // 其他协议族默认阻止
+     fprintf(stderr, "[NETWORK_FILTER] Blocked connection to unknown address family %d\n", 
+            addr->sa_family);
+     return 0;
+ }
+ 
+ // 拦截 connect 系统调用
+ int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen) {
+     // 获取原始函数指针
+     if (!original_connect) {
+         original_connect = (original_connect_t)dlsym(RTLD_NEXT, "connect");
+     }
+     
+     // 检查连接是否被允许
+     if (!is_connection_allowed(addr)) {
+         errno = EPERM;
+         return -1;
+     }
+     
+     // 调用原始的 connect 函数
+     return original_connect(sockfd, addr, addrlen);
+ }
+ 
+ // 拦截 socket 系统调用（可选，用于记录）
+ int socket(int domain, int type, int protocol) {
+     if (!original_socket) {
+         original_socket = (original_socket_t)dlsym(RTLD_NEXT, "socket");
+     }
+     
+     const char* domain_str = "unknown";
+     switch (domain) {
+         case AF_INET: domain_str = "IPv4"; break;
+         case AF_INET6: domain_str = "IPv6"; break;
+         case AF_UNIX: domain_str = "Unix"; break;
+     }
+     
+     const char* type_str = (type & SOCK_STREAM) ? "TCP" : 
+                           (type & SOCK_DGRAM) ? "UDP" : "other";
+     
+     int result = original_socket(domain, type, protocol);
+     if (result >= 0) {
+         fprintf(stderr, "[NETWORK_FILTER] Created socket: %s %s (fd=%d)\n", 
+                domain_str, type_str, result);
+     }
+     
+     return result;
+ }
+ 
+ // 拦截 sendto 系统调用（用于 UDP）
+ ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
+                const struct sockaddr *dest_addr, socklen_t addrlen) {
+     if (!original_sendto) {
+         original_sendto = (original_sendto_t)dlsym(RTLD_NEXT, "sendto");
+     }
+     
+     // 如果指定了目标地址，检查是否允许
+     if (dest_addr && !is_connection_allowed(dest_addr)) {
+         errno = EPERM;
+         return -1;
+     }
+     
+     return original_sendto(sockfd, buf, len, flags, dest_addr, addrlen);
+ }
+ 
+ // 库构造函数，在加载时调用
+ __attribute__((constructor))
+ static void network_filter_init() {
+     init_filter();
+ }
+