如何确保为本机“ping”实现创建的 IPv4 数据包的正确性？

Question

概述

我一直在从事一个业余项目，该项目本质上是一个网络故障排除工具。我的目的是加深对网络基础知识的理解，并熟悉使用操作系统提供的故障排除工具。

这是一个 CLI 应用程序，它将获取主机名并尝试诊断问题（如果有）。计划是首先实施 ping 和 Traceroute，然后根据我的舒适程度逐步实施其他工具。

但是，我的 ping 实现并不准确，因为 IPv4 数据包格式错误。这就是wireshark 必须说的。

1   0.000000    192.168.0.100   142.250.195.132 ICMP    300 Unknown ICMP (obsolete or malformed?)

代码

这是我的实施方式

ping

package ping

import (
    "encoding/json"
    "net"

    "github.com/pkg/errors"
)

var (
    IcmpProtocolNumber uint8 = 1
    IPv4Version        uint8 = 4
    IPv4IHL            uint8 = 5
    ICMPHeaderType     uint8 = 8
    ICMPHeaderSubtype  uint8 = 0
)

type NativePinger struct {
    SourceIP string
    DestIP   string
}

type ICMPHeader struct {
    Type     uint8
    Code     uint8
    Checksum uint16
}

type ICMPPacket struct {
    Header  ICMPHeader
    Payload interface{}
}

type IPv4Header struct {
    SourceIP       string
    DestinationIP  string
    Length         uint16
    Identification uint16
    FlagsAndOffset uint16
    Checksum       uint16
    VersionIHL     uint8
    DSCPAndECN     uint8
    TTL            uint8
    Protocol       uint8
}

type IPv4Packet struct {
    Header  IPv4Header
    Payload *ICMPPacket
}

func (p *NativePinger) createIPv4Packet() (*IPv4Packet, error) {
    versionIHL := (IPv4Version << 4) | IPv4IHL

    icmpPacket := &ICMPPacket{
        Header: ICMPHeader{
            Type: ICMPHeaderType,
            Code: ICMPHeaderSubtype,
        },
    }
    ipv4Packet := &IPv4Packet{
        Header: IPv4Header{
            VersionIHL:     versionIHL,
            DSCPAndECN:     0,
            Identification: 0,
            FlagsAndOffset: 0,
            TTL:            64,
            Protocol:       IcmpProtocolNumber,
            SourceIP:       p.SourceIP,
            DestinationIP:  p.DestIP,
        },
        Payload: icmpPacket,
    }
    ipv4Packet.Header.Length = 40

    bytes, err := json.Marshal(icmpPacket)
    if err != nil {
        return nil, errors.Wrapf(err, "error converting ICMP packet to bytes")
    }

    icmpPacket.Header.Checksum = calculateChecksum(bytes)

    bytes, err = json.Marshal(ipv4Packet)
    if err != nil {
        return nil, errors.Wrapf(err, "error converting IPv4 packet to bytes")
    }

    ipv4Packet.Header.Checksum = calculateChecksum(bytes)

    return ipv4Packet, nil
}

func calculateChecksum(data []byte) uint16 {
    sum := uint32(0)

    // creating 16 bit words
    for i := 0; i < len(data)-1; i++ {
        word := uint32(data[i])<<8 | uint32(data[i+1])
        sum += word
    }
    if len(data)%2 == 1 {
        sum += uint32(data[len(data)-1])
    }

    // adding carry bits with lower 16 bits
    for (sum >> 16) > 0 {
        sum = (sum & 0xffff) + (sum >> 16)
    }

    // taking one's compliment
    checksum := ^sum
    return uint16(checksum)
}

func (p *NativePinger) ResolveAddress(dest string) error {
    ips, err := net.LookupIP(dest)
    if err != nil {
        return errors.Wrapf(err, "error resolving address of remote host")
    }

    for _, ip := range ips {
        if ipv4 := ip.To4(); ipv4 != nil {
            p.DestIP = ipv4.String()
        }
    }

    // The destination address does not need to exist as unlike tcp, udp does not require a handshake.
    // The goal here is to retrieve the outbound IP. Source: https://stackoverflow.com/a/37382208/3728336
    //
    conn, err := net.Dial("udp", "8.8.8.8:80")
    if err != nil {
        return errors.Wrapf(err, "error resolving outbound ip address of local machine")
    }
    defer conn.Close()

    p.SourceIP = conn.LocalAddr().(*net.UDPAddr).IP.String()

    return nil
}

func (p *NativePinger) Ping(host string) error {
    if err := p.ResolveAddress(host); err != nil {
        return errors.Wrapf(err, "error resolving source/destination addresses")
    }

    packet, err := p.createIPv4Packet()
    if err != nil {
        return errors.Wrapf(err, "error creating IPv4Packet")
    }

    conn, err := net.Dial("ip4:icmp", packet.Header.DestinationIP)
    if err != nil {
        return errors.Wrapf(err, "error eshtablishing connection with %s", host)
    }
    defer conn.Close()

    bytes, err := json.Marshal(packet)
    if err != nil {
        return errors.Wrapf(err, "error converting IPv4 packet into bytes")
    }

    _, err = conn.Write(bytes)
    if err != nil {
        return errors.Wrapf(err, "error sending ICMP echo request")
    }

    buff := make([]byte, 2048)
    _, err = conn.Read(buff) // The implementation doesn't proceed beyond this point
    if err != nil {
        return errors.Wrapf(err, "error receiving ICMP echo response")
    }

    return nil
}

反省后

我不确定数据包的畸形是单一原因还是多种原因造成的。 我觉得问题出在这两个地方之一（或两者？）：

1. 标头长度计算不正确我手动计算的长度为

   40 bytes (wordsize = 4 bytes)

   。按照防止“结构体对齐”的顺序编写结构体字段。 我参考这个来源来了解各种类型的尺寸。

// 1 word (4 bytes)
type ICMPHeader struct {
    Type     uint8  // 8 bit
    Code     uint8  // 8 bit
    Checksum uint16 // 16 bit
}

// 3 words (3*4 = 12 bytes)
type ICMPPacket struct {
    Header  ICMPHeader  // 1 word
    Payload interface{} // 2 words
}

// 7 words (7*4 = 28 bytes)
type IPv4Header struct {
    // Below group takes 4 words (each string takes 2 words)
    SourceIP      string
    DestinationIP string

    // Following group takes 2 words (each 16 bits)
    Length         uint16
    Identification uint16
    FlagsAndOffset uint16
    Checksum       uint16

    // Below group takes 1 word (each takes 8 bits)
    VersionIHL uint8
    DSCPAndECN uint8
    TTL        uint8
    Protocol   uint8
}

// 10 words (40 bytes)
type IPv4Packet struct {
    Header  IPv4Header // 7 words as calculated above
    Payload ICMPPacket // 3 words as calculated above
}

校验和计算不正确
2. 我实现了互联网校验和算法。如果这不是我应该在这里做的，请告诉我。
实现中缺少一些部分，例如配置计数、为数据包分配序列号等，但在此之前需要修复基本实现，即接收 ICMP ECHO 数据包的响应。很高兴知道我在哪里犯了错误。

谢谢！

23 年 8 月 24 日更新

考虑到我在评论中得到的建议，我已经

更新了代码

，即修复字节顺序并使用原始字节作为源地址、目标地址。然而，仅此并不能解决问题，数据包仍然格式错误，因此肯定还有其他问题。

Answer 1

序列化问题

正如 Andy 正确指出的那样，我发送的是 JSON 对象，而不是按网络字节顺序发送原始字节。这是使用

binary.Write(buf, binary.BigEndian, field)

 修复的

但是，由于此方法仅适用于固定大小的值，因此我必须对每个结构体字段执行此操作，从而使代码重复且有些难看。

结构优化和序列化是不同的问题。

我知道将

Version

和

IHL

字段组合在一起以优化内存的做法，这就是为什么我的结构中有这个单一字段

VersionIHL

。但是在序列化时，字段值（在本例中为 4 和 5）要单独序列化，而我

没有

这样做。相反，我将整个 VersionIHL 字段的值转换为字节。结果，我发现自己在字节流中发送了一个意外的八位字节

69

，它来自于

4

和

5

组合在一起

0100 0101

。不完整的 ICMP 数据包

我的 ICMP 结构不包含标识符和序列号字段。

Wikipedia

上的 ICMP 数据报标头部分提供的信息感觉有点通用。然而，我发现RFC页面（第14页）上的详细信息更有洞察力。 考虑到 ping 实用程序的序列号的重要性，这感觉很奇怪。在实现过程中，我经常发现自己想知道序列号在代码中的适当位置。直到我偶然发现 RFC 页面，我才清楚地了解何时何地合并序列号。

对于任何可能感兴趣的人，这是我整理的

功能代码

。