golang arp request

This article will introduce how to use Golang to send an ARP request to obtain the MAC address of the target device.

ARP (Address Resolution Protocol) is a protocol that resolves network layer addresses (IP addresses) and data link layer addresses (MAC addresses). In a LAN, each device has a unique MAC address that identifies the device. When we know the IP address of the target device, but not its MAC address, we can send an ARP request to obtain the MAC address of the device.

In Golang, we can use the net.InterfaceAddrs() function in the net package to obtain the IP and MAC address of the current device. Then, use the net.ParseIP() function in the net package to parse the target IP address into a variable of type IP. Next, use the gopacket library to build an ARP request packet and send it to the network.

Let us take a look at the sample code:

package main

import (
    "fmt"
    "net"
    "time"

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

func main() {
    // 获取当前设备的IP和MAC地址
    interfaces, err := net.Interfaces()
    if err != nil {
        panic(err)
    }
    var localIP net.IP
    var localMAC net.HardwareAddr
    for _, iface := range interfaces {
        if iface.Flags&net.FlagUp != 0 && iface.Flags&net.FlagLoopback == 0 {
            addrs, err := iface.Addrs()
            if err != nil {
                panic(err)
            }
            for _, addr := range addrs {
                switch addr := addr.(type) {
                case *net.IPNet:
                    if addr.IP.To4() != nil {
                        localIP = addr.IP
                    }
                case *net.IPAddr:
                    if addr.IP.To4() != nil {
                        localIP = addr.IP
                    }
                }
            }
            localMAC = iface.HardwareAddr
            break
        }
    }
    if localIP == nil || localMAC == nil {
        panic("Could not find local IP and MAC addresses")
    }
    fmt.Println("Local IP:", localIP)
    fmt.Println("Local MAC:", localMAC)

    // 目标IP地址
    targetIP := net.ParseIP("192.168.1.1")
    if targetIP == nil {
        panic("Invalid target IP address")
    }
    fmt.Println("Target IP:", targetIP)

    // 使用gopacket构建ARP请求包
    var buf gopacket.SerializeBuffer
    opts := gopacket.SerializeOptions{}
    eth := layers.Ethernet{
        SrcMAC:       localMAC,
        DstMAC:       net.HardwareAddr{0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
        EthernetType: layers.EthernetTypeARP,
    }
    arp := layers.ARP{
        AddrType:          layers.LinkTypeEthernet,
        Protocol:          layers.EthernetTypeIPv4,
        HwAddressSize:     6,
        ProtAddressSize:   4,
        Operation:         layers.ARPRequest,
        SourceHwAddress:   []byte(localMAC),
        SourceProtAddress: []byte(localIP.To4()),
        DstHwAddress:      []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
        DstProtAddress:    []byte(targetIP.To4()),
    }
    if err := gopacket.SerializeLayers(&buf, opts, &eth, &arp); err != nil {
        panic(err)
    }

    // 打开网络接口并发送ARP请求包
    handle, err := pcap.OpenLive("eth0", 65535, true, pcap.BlockForever)
    if err != nil {
        panic(err)
    }
    defer handle.Close()
    if err := handle.WritePacketData(buf.Bytes()); err != nil {
        panic(err)
    }

    // 等待一段时间以获得目标设备的MAC地址
    time.Sleep(time.Second)
    packetSource := packetio.NewPacketSource(handle, handle.LinkType())
    for packet := range packetSource.Packets() {
        arpLayer := packet.Layer(layers.LayerTypeARP)
        if arpLayer != nil {
            arpPacket, _ := arpLayer.(*layers.ARP)
            if arpPacket.Operation == layers.ARPReply && bytes.Equal(arpPacket.SourceProtAddress, targetIP.To4()) {
                fmt.Println("Target MAC:", net.HardwareAddr(arpPacket.SourceHwAddress))
                return
            }
        }
    }
    panic("Could not resolve target MAC address")
}

In the sample code, we first use the net package to obtain the IP and MAC address of the current device. Then, use the net.ParseIP() function to parse the target IP address into a variable of type IP. Next, we use the gopacket.SerializeLayers() function to build the ARP request packet. We first define the Ethernet layer, set the source MAC address to the local MAC address, and the destination MAC address to the broadcast address. Then define the ARP layer, set the request type to ARP request, the source MAC address and source IP address to the local MAC address and local IP address, the target MAC address to 0, and the target IP address to the target IP address. Finally, we open the network interface through the pcap.OpenLive() function and write the ARP request packet.

We wait for a while to get the response from the target device. Use the packetio.NewPacketSource() function to get the source of the received data, and then use a for loop to iterate over the received packets. If an ARP response is received and the source IP address is the destination IP address, it means we have obtained the MAC address of the destination device. The program outputs the MAC address of the target device and ends the run.

Using the above code you can easily send an ARP request and get the MAC address of the target device.

The above is the detailed content of golang arp request. For more information, please follow other related articles on the PHP Chinese website!