用go语言写一个抓包程序，在抓到数据包之后分析是否为tcp syn报文，如果是，则向源地址发送一个tcp reset报文

抓包程序的代码如下：

package main

import (
    "fmt"
    "log"
    "net"
    "github.com/google/gopacket"
    "github.com/google/gopacket/pcap"
    "github.com/google/gopacket/layers"
)

func main() {
    // 打开网卡
    handle, err := pcap.OpenLive("eth0", 65535, true, pcap.BlockForever)
    if err != nil {
        log.Fatal(err)
    }
    defer handle.Close()

    // 设置过滤器
    filter := "tcp[tcpflags] & (tcp-syn) != 0"
    err = handle.SetBPFFilter(filter)
    if err != nil {
        log.Fatal(err)
    }

    // 抓包
    packetSource := gopacket.NewPacketSource(handle, handle.LinkType())
    for packet := range packetSource.Packets() {
        // 解析TCP报文
        tcpLayer := packet.Layer(layers.LayerTypeTCP)
        if tcpLayer != nil {
            tcp, _ := tcpLayer.(*layers.TCP)

            // 判断是否是SYN报文
            if tcp.SYN {
                // 向源地址发送RST报文
                ipLayer := packet.Layer(layers.LayerTypeIPv4)
                if ipLayer != nil {
                    ip, _ := ipLayer.(*layers.IPv4)
                    srcAddr := net.IP(ip.SrcIP)
                    dstAddr := net.IP(ip.DstIP)

                    // 构造TCP头
                    tcpHeader := layers.TCP{
                        SrcPort: tcp.DstPort,
                        DstPort: tcp.SrcPort,
                        Seq:     tcp.Ack,
                        RST:     true,
                        Window:  tcp.Window,
                    }
                    tcpHeader.SetNetworkLayerForChecksum(ip)

                    // 构造IP头
                    ipHeader := layers.IPv4{
                        Version:  4,
                        SrcIP:    ip.DstIP,
                        DstIP:    ip.SrcIP,
                        Protocol: layers.IPProtocolTCP,
                        TTL:      64,
                        Id:       ip.Id,
                        Flags:    ip.Flags,
                    }

                    // 发送RST报文
                    packetData := gopacket.NewSerializeBuffer()
                    gopacket.SerializeLayers(packetData, gopacket.SerializeOptions{},
                        &ipHeader, &tcpHeader)
                    packetBytes := packetData.Bytes()

                    conn, err := net.DialIP("ip4:tcp", &net.IPAddr{IP: srcAddr}, &net.IPAddr{IP: dstAddr})
                    if err != nil {
                        fmt.Println(err)
                    } else {
                        defer conn.Close()
                        _, err := conn.Write(packetBytes)
                        if err != nil {
                            fmt.Println(err)
                        }
                        fmt.Printf("Sent RST to %s\n", srcAddr.String())
                    }
                }
            }
        }
    }
}

程序的主要逻辑是：

1. 打开网卡，设置过滤器，抓包；
2. 对每一个TCP报文进行判断，如果是SYN报文，就向源地址发送RST报文。

程序使用了Google的开源库gopacket来处理网络包。首先打开网卡，设置过滤器，然后使用NewPacketSource函数生成一个PacketSource对象，用来读取网络包。PacketSource的Packets方法会返回一个管道，每次从管道中读取一个网络包，直到管道关闭。

在处理每个网络包时，先判断是否包含TCP层，如果是，再判断是否是SYN报文。如果是SYN报文，就从IPv4层中获取源地址和目的地址，然后构造RST报文并发送到源地址。构造RST报文时，需要先构造TCP头，再构造IPv4头。最后将TCP头和IPv4头序列化成字节流，并通过net包的DialIP函数连接到源地址，并发送RST报文。如果发送成功，就打印一条消息。