当前位置：首页 > 文章列表 > Golang > Go教程 > Go语言实现原始套接字编程详解

Go语言实现原始套接字编程详解

2025-11-04 19:54:49 0浏览收藏

大家好，今天本人给大家带来文章《Go语言实现原始套接字编程教程》，文中内容主要涉及到，如果你对Golang方面的知识点感兴趣，那就请各位朋友继续看下去吧~希望能真正帮到你们，谢谢！

使用 Go 语言进行原始套接字编程

本文旨在指导开发者如何使用 Go 语言进行原始套接字编程，以实现自定义网络数据包的发送和接收。重点介绍使用 go.net/ipv4 库创建和操作原始套接字，以及如何构造自定义 IP 头部来实现源 IP 地址欺骗等高级网络功能。同时，也强调了使用原始套接字的安全风险和权限要求。

在某些网络编程场景下，标准库提供的套接字 API 可能无法满足需求，例如需要修改 IP 头部、实现自定义协议等。这时，原始套接字就派上了用场。Go 语言的标准 net 库并没有直接提供原始套接字的支持，但 go.net 子仓库提供了 ipv4 和 ipv6 包，可以用来进行原始套接字编程。

安全性考虑

使用原始套接字需要特别注意安全性问题。由于可以自定义 IP 头部，包括源 IP 地址，这可能被用于恶意攻击，例如 IP 地址欺骗。在 Linux 系统下，通常需要以 root 权限运行程序，或者赋予程序 CAP_NET_RAW capability 才能使用原始套接字。可以使用 setcap 命令赋予程序 capability：

sudo setcap cap_net_raw+ep <your_program>

使用 go.net/ipv4 进行原始套接字编程

go.net/ipv4 包提供了创建和操作 IPv4 原始套接字的 API。核心是 ipv4.RawConn 类型。

1. 创建原始套接字

首先，需要创建一个 ipv4.RawConn 实例。可以使用 ipv4.NewRawConn 函数：

import (
    "fmt"
    "log"
    "net"

    "golang.org/x/net/ipv4"
)

func main() {
    // 创建 IPv4 原始套接字
    conn, err := net.ListenIP("ip4:icmp", &net.IPAddr{IP: net.IPv4zero})
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()

    rawConn, err := ipv4.NewRawConn(conn)
    if err != nil {
        log.Fatal(err)
    }
    defer rawConn.Close()

    fmt.Println("Raw socket created successfully!")
}

这段代码创建了一个监听 ICMP 协议的 IPv4 原始套接字。 net.ListenIP 用于创建一个底层的 IP 连接，然后 ipv4.NewRawConn 基于这个连接创建一个 ipv4.RawConn 实例。

2. 读取数据包

可以使用 ipv4.RawConn 的 ReadFrom 方法读取接收到的数据包：

    buf := make([]byte, 1500) // MTU 大小
    for {
        hdr, payload, peer, err := rawConn.ReadFrom(buf)
        if err != nil {
            log.Println("Error reading:", err)
            continue
        }

        fmt.Printf("Received packet from: %v\n", peer)
        fmt.Printf("Header: %+v\n", hdr)
        fmt.Printf("Payload: %v\n", payload)
    }

ReadFrom 方法返回 IP 头部、数据载荷以及发送方的地址。

3. 构造和发送数据包

可以使用 ipv4.RawConn 的 WriteTo 方法发送自定义的数据包。需要手动构造 IP 头部。

    // 构造 IP 头部
    ipHeader := &ipv4.Header{
        Version:  ipv4.Version,
        Len:      ipv4.HeaderLen,
        TOS:      0,
        TotalLen: ipv4.HeaderLen + len(payload),
        ID:       0,
        Flags:    0,
        FragOff:  0,
        TTL:      64,
        Protocol: 1, // ICMP
        Checksum: 0,
        Src:      net.ParseIP("192.168.1.100").To4(), // 伪造的源 IP
        Dst:      net.ParseIP("8.8.8.8").To4(),      // 目标 IP
    }

    // 计算校验和 (需要自行实现)
    ipHeader.Checksum = checksum(ipHeader, payload)

    // 发送数据包
    err = rawConn.WriteTo(ipHeader, payload, &net.IPAddr{IP: ipHeader.Dst})
    if err != nil {
        log.Println("Error writing:", err)
    }

这段代码构造了一个包含伪造源 IP 地址的 IP 头部，并使用 WriteTo 方法发送出去。注意，checksum 函数需要自行实现，用于计算 IP 头部的校验和。

4. 校验和计算

IP 头部的校验和计算是一个常见的操作。以下是一个示例的校验和计算函数：

func checksum(hdr *ipv4.Header, payload []byte) uint16 {
    h := ipv4.Header{
        Version:  ipv4.Version,
        Len:      ipv4.HeaderLen,
        TOS:      hdr.TOS,
        TotalLen: ipv4.HeaderLen + len(payload),
        ID:       hdr.ID,
        Flags:    hdr.Flags,
        FragOff:  hdr.FragOff,
        TTL:      hdr.TTL,
        Protocol: hdr.Protocol,
        Checksum: 0,
        Src:      hdr.Src,
        Dst:      hdr.Dst,
    }

    headerBytes, err := h.Marshal()
    if err != nil {
        panic(err)
    }
    data := append(headerBytes, payload...)
    var sum uint32
    for i := 0; i < len(data)-1; i += 2 {
        sum += uint32(data[i])<<8 | uint32(data[i+1])
    }
    if len(data)%2 == 1 {
        sum += uint32(data[len(data)-1]) << 8
    }
    for sum>>16 != 0 {
        sum = (sum & 0xffff) + (sum >> 16)
    }
    return uint16(^sum)
}

完整示例

下面是一个完整的示例代码，演示了如何使用 go.net/ipv4 创建原始套接字，发送包含自定义 IP 头部和 ICMP 协议数据的数据包。

package main

import (
    "fmt"
    "log"
    "net"
    "time"

    "golang.org/x/net/icmp"
    "golang.org/x/net/ipv4"
)

func checksum(hdr *ipv4.Header, payload []byte) uint16 {
    h := ipv4.Header{
        Version:  ipv4.Version,
        Len:      ipv4.HeaderLen,
        TOS:      hdr.TOS,
        TotalLen: ipv4.HeaderLen + len(payload),
        ID:       hdr.ID,
        Flags:    hdr.Flags,
        FragOff:  hdr.FragOff,
        TTL:      hdr.TTL,
        Protocol: hdr.Protocol,
        Checksum: 0,
        Src:      hdr.Src,
        Dst:      hdr.Dst,
    }

    headerBytes, err := h.Marshal()
    if err != nil {
        panic(err)
    }
    data := append(headerBytes, payload...)
    var sum uint32
    for i := 0; i < len(data)-1; i += 2 {
        sum += uint32(data[i])<<8 | uint32(data[i+1])
    }
    if len(data)%2 == 1 {
        sum += uint32(data[len(data)-1]) << 8
    }
    for sum>>16 != 0 {
        sum = (sum & 0xffff) + (sum >> 16)
    }
    return uint16(^sum)
}

func main() {
    // 创建 IPv4 原始套接字
    conn, err := net.ListenIP("ip4:icmp", &net.IPAddr{IP: net.IPv4zero})
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()

    rawConn, err := ipv4.NewRawConn(conn)
    if err != nil {
        log.Fatal(err)
    }
    defer rawConn.Close()

    fmt.Println("Raw socket created successfully!")

    // 构造 ICMP 数据
    icmpMessage := icmp.Message{
        Type: ipv4.ICMPTypeEcho,
        Code: 0,
        Body: &icmp.Echo{
            ID:   12345,
            Seq:  1,
            Data: []byte("Hello, Raw Socket!"),
        },
    }

    icmpBytes, err := icmpMessage.Marshal(nil)
    if err != nil {
        log.Fatal(err)
    }

    // 构造 IP 头部
    ipHeader := &ipv4.Header{
        Version:  ipv4.Version,
        Len:      ipv4.HeaderLen,
        TOS:      0,
        TotalLen: ipv4.HeaderLen + len(icmpBytes),
        ID:       0,
        Flags:    0,
        FragOff:  0,
        TTL:      64,
        Protocol: 1, // ICMP
        Checksum: 0,
        Src:      net.ParseIP("192.168.1.100").To4(), // 伪造的源 IP
        Dst:      net.ParseIP("8.8.8.8").To4(),      // 目标 IP
    }

    // 计算校验和
    ipHeader.Checksum = checksum(ipHeader, icmpBytes)

    // 发送数据包
    err = rawConn.WriteTo(ipHeader, icmpBytes, &net.IPAddr{IP: ipHeader.Dst})
    if err != nil {
        log.Println("Error writing:", err)
    } else {
        fmt.Println("Packet sent successfully!")
    }

    // 接收数据 (可选)
    buf := make([]byte, 1500)
    rawConn.SetReadDeadline(time.Now().Add(5 * time.Second)) // 设置超时
    hdr, payload, peer, err := rawConn.ReadFrom(buf)
    if err != nil {
        log.Println("Error reading:", err)
    } else {
        fmt.Printf("Received packet from: %v\n", peer)
        fmt.Printf("Header: %+v\n", hdr)
        fmt.Printf("Payload: %v\n", payload)
    }
}

注意事项：