Skip to content
The Chat Archive
claude-sonnet-4-20250514· Anthropic LMArena Human Preference 140K

使用go语言对libc的accept函数进行hook,并给出编译命令,并使用go处理后续的套接字

  1. User

    使用go语言对libc的accept函数进行hook,并给出编译命令,并使用go处理后续的套接字

  2. Assistant

    我来帮你实现使用Go语言对libc的accept函数进行hook的方案。

    实现方案

    // main.go
    package main
    
    /*
    #cgo LDFLAGS: -ldl
    #include <dlfcn.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #include <unistd.h>
    #include <stdio.h>
    
    // 原始accept函数指针
    static int (*original_accept)(int sockfd, struct sockaddr *addr, socklen_t *addrlen) = NULL;
    
    // 初始化原始函数指针
    void init_original_accept() {
        if (original_accept == NULL) {
            original_accept = (int (*)(int, struct sockaddr *, socklen_t *))dlsym(RTLD_NEXT, "accept");
        }
    }
    
    // Go回调函数声明
    extern void goHandleAccept(int fd, char* addr, int port);
    
    // Hook的accept函数
    int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen) {
        init_original_accept();
        
        // 调用原始accept函数
        int client_fd = original_accept(sockfd, addr, addrlen);
        
        if (client_fd >= 0 && addr != NULL) {
            // 解析客户端地址信息
            struct sockaddr_in *client_addr = (struct sockaddr_in *)addr;
            char *ip_str = inet_ntoa(client_addr->sin_addr);
            int port = ntohs(client_addr->sin_port);
            
            // 调用Go处理函数
            goHandleAccept(client_fd, ip_str, port);
        }
        
        return client_fd;
    }
    */
    import "C"
    
    import (
        "fmt"
        "net"
        "os"
        "syscall"
        "unsafe"
    )
    
    // 存储被hook的socket连接
    var hookedConnections = make(map[int]*HookedConn)
    
    type HookedConn struct {
        fd       int
        clientIP string
        port     int
        conn     net.Conn
    }
    
    //export goHandleAccept
    func goHandleAccept(fd C.int, addr *C.char, port C.int) {
        clientIP := C.GoString(addr)
        clientPort := int(port)
        
        fmt.Printf("[HOOK] Accept intercepted: fd=%d, client=%s:%d\n", 
                   int(fd), clientIP, clientPort)
        
        // 创建Go的net.Conn包装
        file := os.NewFile(uintptr(fd), "socket")
        conn, err := net.FileConn(file)
        if err != nil {
            fmt.Printf("[ERROR] Failed to create Go connection: %v\n", err)
            return
        }
        
        // 存储连接信息
        hookedConn := &HookedConn{
            fd:       int(fd),
            clientIP: clientIP,
            port:     clientPort,
            conn:     conn,
        }
        
        hookedConnections[int(fd)] = hookedConn
        
        // 启动Go协程处理连接
        go handleConnection(hookedConn)
    }
    
    // 处理被hook的连接
    func handleConnection(hookedConn *HookedConn) {
        defer func() {
            hookedConn.conn.Close()
            delete(hookedConnections, hookedConn.fd)
            fmt.Printf("[HOOK] Connection closed: fd=%d\n", hookedConn.fd)
        }()
        
        fmt.Printf("[HOOK] Handling connection from %s:%d (fd=%d)\n", 
                   hookedConn.clientIP, hookedConn.port, hookedConn.fd)
        
        // 读取数据示例
        buffer := make([]byte, 1024)
        for {
            n, err := hookedConn.conn.Read(buffer)
            if err != nil {
                if err.Error() != "EOF" {
                    fmt.Printf("[ERROR] Read error: %v\n", err)
                }
                break
            }
            
            data := string(buffer[:n])
            fmt.Printf("[HOOK] Received data from %s:%d: %s", 
                       hookedConn.clientIP, hookedConn.port, data)
            
            // 回显数据
            response := fmt.Sprintf("Echo: %s", data)
            _, err = hookedConn.conn.Write([]byte(response))
            if err != nil {
                fmt.Printf("[ERROR] Write error: %v\n", err)
                break
            }
        }
    }
    
    // 创建测试服务器
    func createTestServer() {
        listener, err := net.Listen("tcp", ":8080")
        if err != nil {
            fmt.Printf("Failed to create listener: %v\n", err)
            return
        }
        defer listener.Close()
        
        fmt.Println("Test server listening on :8080")
        
        for {
            conn, err := listener.Accept()
            if err != nil {
                fmt.Printf("Accept error: %v\n", err)
                continue
            }
            
            // 这个连接会被我们的hook拦截
            fmt.Printf("Original Accept called for: %s\n", conn.RemoteAddr())
        }
    }
    
    func main() {
        fmt.Println("Starting Go accept() hook demo...")
        
        // 启动测试服务器
        go createTestServer()
        
        // 保持程序运行
        select {}
    }
    

    编译命令

    # 编译为共享库(用于LD_PRELOAD)
    go build -buildmode=c-shared -o libaccept_hook.so main.go
    
    # 或者编译为可执行文件
    go build -o accept_hook main.go
    

    使用方法

    方法1:作为共享库使用(推荐)

    # 编译共享库
    go build -buildmode=c-shared -o libaccept_hook.so main.go
    
    # 使用LD_PRELOAD运行目标程序
    LD_PRELOAD=./libaccept_hook.so your_target_program
    
    # 或者hook系统中的程序
    LD_PRELOAD=./libaccept_hook.so nc -l 9999
    

    方法2:直接运行

    # 编译并运行
    go build -o accept_hook main.go
    ./accept_hook
    

    测试hook效果

    在另一个终端中测试连接:

    # 测试连接
    telnet localhost 8080
    
    # 或使用nc
    echo "Hello World" | nc localhost 8080
    

    高级版本 - 支持更多功能

    // advanced_hook.go
    package main
    
    /*
    #cgo LDFLAGS: -ldl
    #include <dlfcn.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #include <unistd.h>
    #include <stdio.h>
    
    static int (*original_accept)(int sockfd, struct sockaddr *addr, socklen_t *addrlen) = NULL;
    static int (*original_accept4)(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags) = NULL;
    
    void init_original_functions() {
        if (original_accept == NULL) {
            original_accept = (int (*)(int, struct sockaddr *, socklen_t *))dlsym(RTLD_NEXT, "accept");
        }
        if (original_accept4 == NULL) {
            original_accept4 = (int (*)(int, struct sockaddr *, socklen_t *, int))dlsym(RTLD_NEXT, "accept4");
        }
    }
    
    extern void goHandleAccept(int fd, char* addr, int port);
    
    int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen) {
        init_original_functions();
        int client_fd = original_accept(sockfd, addr, addrlen);
        
        if (client_fd >= 0 && addr != NULL) {
            struct sockaddr_in *client_addr = (struct sockaddr_in *)addr;
            char *ip_str = inet_ntoa(client_addr->sin_addr);
            int port = ntohs(client_addr->sin_port);
            goHandleAccept(client_fd, ip_str, port);
        }
        
        return client_fd;
    }
    
    int accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags) {
        init_original_functions();
        int client_fd = original_accept4(sockfd, addr, addrlen, flags);
        
        if (client_fd >= 0 && addr != NULL) {
            struct sockaddr_in *client_addr = (struct sockaddr_in *)addr;
            char *ip_str = inet_ntoa(client_addr->sin_addr);
            int port = ntohs(client_addr->sin_port);
            goHandleAccept(client_fd, ip_str, port);
        }
        
        return client_fd;
    }
    */
    import "C"
    
    import (
        "fmt"
        "log"
        "net"
        "os"
        "sync"
        "time"
    )
    
    type ConnectionManager struct {
        connections map[int]*ManagedConn
        mutex       sync.RWMutex
    }
    
    type ManagedConn struct {
        fd        int
        clientIP  string
        port      int
        conn      net.Conn
        startTime time.Time
    }
    
    var connManager = &ConnectionManager{
        connections: make(map[int]*ManagedConn),
    }
    
    //export goHandleAccept
    func goHandleAccept(fd C.int, addr *C.char, port C.int) {
        clientIP := C.GoString(addr)
        clientPort := int(port)
        
        log.Printf("[HOOK] New connection: fd=%d, client=%s:%d", 
                   int(fd), clientIP, clientPort)
        
        file := os.NewFile(uintptr(fd), "socket")
        conn, err := net.FileConn(file)
        if err != nil {
            log.Printf("[ERROR] Failed to create Go connection: %v", err)
            return
        }
        
        managedConn := &ManagedConn{
            fd:        int(fd),
            clientIP:  clientIP,
            port:      clientPort,
            conn:      conn,
            startTime: time.Now(),
        }
        
        connManager.mutex.Lock()
        connManager.connections[int(fd)] = managedConn
        connManager.mutex.Unlock()
        
        go handleManagedConnection(managedConn)
    }
    
    func handleManagedConnection(mc *ManagedConn) {
        defer func() {
            mc.conn.Close()
            connManager.mutex.Lock()
            delete(connManager.connections, mc.fd)
            connManager.mutex.Unlock()
            
            duration := time.Since(mc.startTime)
            log.Printf("[HOOK] Connection closed: fd=%d, duration=%v", 
                       mc.fd, duration)
        }()
        
        // 设置读取超时
        mc.conn.SetReadDeadline(time.Now().Add(30 * time.Second))
        
        buffer := make([]byte, 4096)
        for {
            n, err := mc.conn.Read(buffer)
            if err != nil {
                if !isTimeoutError(err) {
                    log.Printf("[ERROR] Read error from %s:%d: %v", 
                               mc.clientIP, mc.port, err)
                }
                break
            }
            
            data := buffer[:n]
            log.Printf("[HOOK] Data from %s:%d (%d bytes): %q", 
                       mc.clientIP, mc.port, n, string(data))
            
            // 简单的HTTP响应示例
            if isHTTPRequest(data) {
                response := "HTTP/1.1 200 OK\r\nContent-Length: 13\r\n\r\nHello, World!"
                mc.conn.Write([]byte(response))
                break
            } else {
                // 回显其他数据
                mc.conn.Write(data)
            }
            
            // 重置超时
            mc.conn.SetReadDeadline(time.Now().Add(30 * time.Second))
        }
    }
    
    func isHTTPRequest(data []byte) bool {
        return len(data) > 4 && 
               (string(data[:4]) == "GET " || 
                string(data[:4]) == "POST" || 
                string(data[:4]) == "PUT " || 
                string(data[:4]) == "HEAD")
    }
    
    func isTimeoutError(err error) bool {
        if netErr, ok := err.(net.Error); ok {
            return netErr.Timeout()
        }
        return false
    }
    
    func main() {
        log.Println("Advanced accept() hook loaded")
        
        // 定期打印连接统计
        go func() {
            ticker := time.NewTicker(10 * time.Second)
            defer ticker.Stop()
            
            for range ticker.C {
                connManager.mutex.RLock()
                count := len(connManager.connections)
                connManager.mutex.RUnlock()
                
                if count > 0 {
                    log.Printf("[STATS] Active connections: %d", count)
                }
            }
        }()
        
        select {} // 保持程序运行
    }
    

    编译高级版本

    go build -buildmode=c-shared -o libadvanced_hook.so advanced_hook.go
    

    这个实现提供了完整的accept函数hook功能,包括连接管理、超时处理、HTTP请求识别等特性。你可以根据具体需求进一步定制处理逻辑。

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.