go的实现arp客户端

使用go实现arp客户端

net包是Go语言标准库中与网络编程有关的包，它提供了一套用于创建各种类型的网络连接的函数和接口，提供了TCP、UDP、Unix 域套接字等传输层协议的支持。

net包的主要功能如下所示：

• 创建和管理 TCP 和 UDP 连接;
• 解析和格式化 IP 地址和域名;
• 实现 DNS 查询;
• 提供了可移植的网络 I/O 接口，包括对非阻塞模式和超时控制的支持;

1、使用 net.ParseIP() 方法将字符串形式的 IP 地址解析成 net.IP 类型的变量。

类型net.IP定义表示了一个 IPv4 或 IPv6 地址，它是一个字节数组类型[]byte 的别名。

2 、使用net.Interfaces()方法获取网络接口信息

这个方法会返回一个[]net.Interface切片，其中包含了主机上所有网络接口的信息。

3、使用pcap.OpenLive() 打开指定的网络设备进行实时捕获数据包

func OpenLive(device string, snaplen int32, promisc bool, timeout time.Duration) (handle *Handle, _ error)

• device:网络设备的名称，如eth0; 也可以使用通过pcap.FindAllDevs()获得的设备的名称；

• snaplen: 每个数据包读取的最大长度 65535;

• promisc:是否将网口设置为混杂模式,即是否接收目的地址不为本机的包,true;

• timeout:设置抓到包返回的超时。如果设置成30s，那么每30s才会刷新一次数据包；设置成负数，会立刻刷新数据包，即不做等待；

• handler ：是一个*Handle类型的返回值，可以作为gopacket其他函数调用时作为函数参数来传递。

  package main

  import (
  "fmt"
  "net"
  "os"
  "time"

    "github.com/google/gopacket"
    "github.com/google/gopacket/layers"
    "github.com/google/gopacket/pcap"

  )

  func main() {
  if len(os.Args) != 3 {
  fmt.Println("Usage: ./arp_client <interface> <target_ip>")
  return
  }

    ifaceName := os.Args[1]
    targetIP := net.ParseIP(os.Args[2])
    if targetIP == nil {
    	fmt.Println("Invalid target IP address")
    	return
    }
  
    // 获取接口信息
    iface, err := net.InterfaceByName(ifaceName)
    if err != nil {
    	fmt.Printf("Failed to get interface %s: %v\n", ifaceName, err)
    	return
    }
  
    // 打开pcap句柄
    handle, err := pcap.OpenLive(ifaceName, 65536, true, pcap.BlockForever)
    if err != nil {
    	fmt.Printf("Failed to open pcap handle: %v\n", err)
    	return
    }
    defer handle.Close()
  
    // 构造第二层(Layer 2)的数据结构
    eth := layers.Ethernet{
    	SrcMAC:       iface.HardwareAddr,
    	DstMAC:       net.HardwareAddr{0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
    	EthernetType: layers.EthernetTypeARP,
    }

  // 构造ARP(第三层 layer 3)请求数据结构
  arp := layers.ARP{
  AddrType: layers.LinkTypeEthernet,
  Protocol: layers.EthernetTypeIPv4,
  HwAddressSize: 6,
  ProtAddressSize: 4,
  Operation: layers.ARPRequest,
  SourceHwAddress: []byte(iface.HardwareAddr),
  SourceProtAddress: []byte{0, 0, 0, 0}, // 通常设为0.0.0.0
  DstHwAddress: []byte{0, 0, 0, 0, 0, 0},
  DstProtAddress: []byte(targetIP.To4()),
  }

    buf := gopacket.NewSerializeBuffer()
    opts := gopacket.SerializeOptions{
    	FixLengths:       true,
    	ComputeChecksums: true,
    }
  
    // 序列化数据包
    err = gopacket.SerializeLayers(buf, opts, &eth, &arp)
    if err != nil {
    	fmt.Printf("Failed to serialize packet: %v\n", err)
    	return
    }
  
    // 发送ARP请求
    err = handle.WritePacketData(buf.Bytes())
    if err != nil {
    	fmt.Printf("Failed to send packet: %v\n", err)
    	return
    }
  
    fmt.Printf("ARP request sent to %s via %s\n", targetIP, ifaceName)
  
    // 设置超时并监听响应
    start := time.Now()
    timeout := 5 * time.Second
    packetSource := gopacket.NewPacketSource(handle, handle.LinkType())
  
    for {
    	if time.Since(start) > timeout {
    		fmt.Println("Timeout waiting for ARP response")
    		return
    	}
  
    	packet, err := packetSource.NextPacket()
    	if err != nil {
    		continue
    	}
  
    	arpLayer := packet.Layer(layers.LayerTypeARP)
    	if arpLayer == nil {
    		continue
    	}
  
    	arpResponse, _ := arpLayer.(*layers.ARP)
    	if arpResponse.Operation == layers.ARPReply &&
    		net.IP(arpResponse.SourceProtAddress).Equal(targetIP) {
    		fmt.Printf("ARP response received: %s is at %s\n",
    			targetIP, net.HardwareAddr(arpResponse.SourceHwAddress))
    		return
    	}
    }

  }

<- 仅供参考->