Skip to content
The Chat Archive
qwen3-235b-a22b-no-thinking· Alibaba (Qwen) LMArena Human Preference 140K

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

  1. User

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

  2. Assistant

    在 Go 语言中直接 Hook libc 的 accept 函数是较为复杂的,因为 Go 编译器默认会通过其运行时系统(runtime)与操作系统交互,并不直接暴露底层的 C 函数调用。然而,你可以通过一些技术手段来 Hook accept 系统调用,例如:

    1. 使用 LD_PRELOAD + 自定义 .so 动态库来 Hook accept。
    2. 使用 ptrace 或 eBPF 技术监控或拦截系统调用。
    3. 在 Go 中使用 CGO 调用 C 库函数并替换其行为。

    如果你的目标是 Hook 掉所有通过 libc 进入的 accept 调用,推荐方式是使用 LD_PRELOAD;而如果你只是想 自定义 Go 中 socket 处理逻辑,可以结合 CGO 和 Hook 后续处理。

    下面是一个完整的示例:

    • 使用 LD_PRELOAD 技术 Hook accept() 函数。
    • 替换为自己的函数逻辑。
    • 结合 Go 程序进行后续 socket 处理。

    ✅ 示例目标

    我们希望:

    • 当程序调用 accept() 时,我们的自定义函数被调用。
    • 我们记录连接信息后将控制权交给原始 accept()。
    • 最终由 Go 来处理新 socket。

    🧱 第一步:编写 Hook 的共享库 (hook_accept.c)

    // hook_accept.c
    #define _GNU_SOURCE
    #include <dlfcn.h>
    #include <sys/socket.h>
    #include <stdio.h>
    #include <stdlib.h>
    
    // 定义原始 accept 函数指针
    int (*original_accept)(int, struct sockaddr *, socklen_t *) = NULL;
    
    // 自定义的 accept 函数
    int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen) {
        if (!original_accept) {
            original_accept = dlsym(RTLD_NEXT, "accept");
        }
    
        printf("Hooked accept() called on sockfd: %d\n", sockfd);
    
        // 调用真正的 accept
        int connfd = original_accept(sockfd, addr, addrlen);
    
        if (connfd >= 0) {
            printf("Accepted connection with fd: %d\n", connfd);
            // 可以在这里通过环境变量、socket、pipe等方式通知 Go 程序
            char cmd[64];
            snprintf(cmd, sizeof(cmd), "./notify_go.sh %d", connfd);
            system(cmd); // 调用脚本通知 Go 程序有新的 socket fd
        }
    
        return connfd;
    }
    

    🛠️ 第二步:编译共享库

    gcc -fPIC -shared -o libhook_accept.so hook_accept.c -ldl -Wall
    

    📜 第三步:创建一个通知脚本(可选)

    # notify_go.sh
    #!/bin/bash
    echo "New connection FD: $1" | nc localhost 9999
    

    确保赋予执行权限:

    chmod +x notify_go.sh
    

    🐍 第四步:Go 程序监听本地端口接收 socket fd(简化版)

    // go_notifier.go
    package main
    
    import (
    	"bufio"
    	"fmt"
    	"net"
    )
    
    func main() {
    	listener, err := net.Listen("tcp", "127.0.0.1:9999")
    	if err != nil {
    		panic(err)
    	}
    	defer listener.Close()
    	fmt.Println("Listening on port 9999...")
    
    	for {
    		conn, err := listener.Accept()
    		if err != nil {
    			continue
    		}
    		go handle(conn)
    	}
    }
    
    func handle(conn net.Conn) {
    	defer conn.Close()
    
    	scanner := bufio.NewScanner(conn)
    	for scanner.Scan() {
    		line := scanner.Text()
    		fmt.Println("Received:", line)
    
    		// 解析 socket fd
    		var fd int
    		if _, err := fmt.Sscanf(line, "New connection FD: %d", &fd); err == nil {
    			fmt.Printf("Handling new client socket fd=%d\n", fd)
    			// 这里可以使用 syscall 包操作这个 fd
    		}
    	}
    }
    

    编译 Go 程序:

    go build -o go_notifier go_notifier.go
    ./go_notifier
    

    🧪 第五步:测试整个流程

    启动 Go 监听服务:

    ./go_notifier
    

    然后运行你的主程序(假设是某个 C/Go 混合程序),使用 LD_PRELOAD 加载 Hook 库:

    LD_PRELOAD=./libhook_accept.so ./your_program
    

    当有客户端连接时,你会看到:

    Hooked accept() called on sockfd: 3
    Accepted connection with fd: 4
    

    同时 Go 程序输出:

    Received: New connection FD: 4
    Handling new client socket fd=4
    

    🔁 替代方案:完全用 Go 实现 accept 并接管 socket

    如果你不想使用 LD_PRELOAD,也可以直接在 Go 中绑定 socket 并自己处理 accept:

    package main
    
    import (
    	"fmt"
    	"net"
    	"os"
    )
    
    func main() {
    	ln, err := net.Listen("tcp", ":8080")
    	if err != nil {
    		panic(err)
    	}
    	fmt.Println("Listening on :8080")
    
    	for {
    		conn, err := ln.Accept()
    		if err != nil {
    			continue
    		}
    		go func(c net.Conn) {
    			defer c.Close()
    			fd := getSocketFD(c)
    			fmt.Printf("New connection FD: %d\n", fd)
    			// 处理连接...
    		}(conn)
    	}
    }
    
    // 获取底层文件描述符(仅限 Unix)
    func getSocketFD(conn net.Conn) int {
    	switch v := conn.(type) {
    	case *net.TCPConn:
    		file, _ := v.File()
    		return int(file.Fd())
    	default:
    		return -1
    	}
    }
    

    ✅ 总结

    方法描述是否推荐
    LD_PRELOAD Hook accept可以 Hook 到任意调用 libc 的 accept✅ 适合已有程序
    Go 自己实现 Listen/Accept更加可控,无需外部 Hook✅ 推荐用于纯 Go 项目
    使用 eBPF 或 ptrace高级用法,适合内核级追踪❌ 较复杂

    如需更高级的 Hook(比如在 Go 内部 Hook 系统调用),可使用 gRPC, C shared memory, 或 syscall 包进一步扩展。

    需要我帮你封装成完整项目结构吗?

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