AI 助理
备案控制台
开发者社区 云计算 文章 正文

用户态协议栈02-arp reply实现

2024-08-15 36
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
云解析 DNS，旗舰版 1个月
全局流量管理 GTM，标准版 1个月
公共DNS（含HTTPDNS解析），每月1000万次HTTP解析
简介： 用户态协议栈02-arp reply实现

在上一节DODK的UDP收发中发送udp包的时候，需要向物理机的arp表中添加一个静态的arp记录。这在生产环境中显然是不可以的。在内核的协议栈中，会将自己的ip和mac在局域网中进行广播，并且记录其他电脑的ip和mac。在需要发送数据包的时候，查询arp表来获取目标的地址构建发送数据包。在实现arp reply之后，dpdk可以回复收到的arp数据包，让对方在arp表中添加一条动态的记录，这样就不需要添加静态的arp记录了。

arp协议

地址解析协议，即ARP（Address Resolution Protocol），是根据IP地址获取物理地址的一个TCP/IP协议。主机发送信息时将包含目标IP地址的ARP请求广播到局域网络上的所有主机，并接收返回消息，以此确定目标的物理地址；收到返回消息后将该IP地址和物理地址存入本机ARP缓存中并保留一定时间，下次请求时直接查询ARP缓存以节约资源。地址解析协议是建立在网络中各个主机互相信任的基础上的，局域网络上的主机可以自主发送ARP应答消息，其他主机收到应答报文时不会检测该报文的真实性就会将其记入本机ARP缓存；由此攻击者就可以向某一主机发送伪ARP应答报文，使其发送的信息无法到达预期的主机或到达错误的主机，这就构成了一个ARP欺骗。ARP命令可用于查询本机ARP缓存中IP地址和MAC地址的对应关系、添加或删除静态对应关系等。相关协议有RARP、代理ARP。NDP用于在IPv6中代替地址解析协议。

arp报文结构

协议解析

  • 硬件类型：指明了发送方想知道的硬件接口类型，以太网的值为1
  • 协议类型：指明了发送方提供的高层协议类型，IP为0800（16进制）
  • 硬件地址长度和协议长度：指明了硬件地址和高层协议地址的长度，这样ARP报文就可以在任意硬件和任意协议的网络中使用
  • 操作类型：用来表示这个报文的类型，ARP请求为1，ARP响应为2，RARP请求为3，RARP响应为4
  • 发送方硬件地址（0-3字节）：源主机硬件地址的前3个字节
  • 发送方硬件地址（4-5字节）：源主机硬件地址的后3个字节
  • 发送方IP地址（0-1字节）：源主机硬件地址的前2个字节
  • 发送方IP地址（2-3字节）：源主机硬件地址的后2个字节
  • 目标硬件地址（0-1字节）：目的主机硬件地址的前2个字节
  • 目标硬件地址（2-5字节）：目的主机硬件地址的后4个字节
  • 目标IP地址（0-3字节）：目的主机的IP地址

DPDK实现

在UDP的基础上加上ARP的实现，和UDP一样，都分为报文解析和报文组织两个部分。

报文解析

if(ethhdr->ether_type == rte_cpu_to_be_16(RTE_ETHER_TYPE_ARP)) {
            struct rte_arp_hdr* arphdr = rte_pktmbuf_mtod_offset(mbufs[i], struct rte_arp_hdr*, sizeof(struct rte_ether_hdr));
            struct in_addr addr;
            addr.s_addr = arphdr->arp_data.arp_tip;
            printf("arp --> src: %s ", inet_ntoa(addr));
            addr.s_addr = gLocalIp;
            printf("local: %s\n", inet_ntoa(addr));
            if(arphdr->arp_data.arp_tip == gLocalIp) {
                struct rte_mbuf* arpbuf = ng_send_arp(mbuf_pool, arphdr->arp_data.arp_sha.addr_bytes, gLocalIp, arphdr->arp_data.arp_sip);
                rte_eth_tx_burst(gDpdkPortId, 0, &arpbuf, 1);
                rte_pktmbuf_free(arpbuf);
                rte_pktmbuf_free(mbufs[i]);
                arpbuf = NULL;
                mbufs[i] = NULL;
            }
            continue;
        }

ARP协议工作在数据链路层，主要传递的信息是IP和MAC。在解析完以太网之后，如果他的数据包是ARP数据包，那就对数据包进行解析。针对数据包内容，组织一个新的ARP包进行回发。

报文组织

static int ng_encode_arp_pkt(uint8_t *msg, uint8_t *dst_mac, uint32_t sip, uint32_t dip) {
  // 1 ethhdr
  struct rte_ether_hdr *eth = (struct rte_ether_hdr *)msg;
  rte_memcpy(eth->s_addr.addr_bytes, gSrcMac, RTE_ETHER_ADDR_LEN);
  rte_memcpy(eth->d_addr.addr_bytes, dst_mac, RTE_ETHER_ADDR_LEN);
  eth->ether_type = htons(RTE_ETHER_TYPE_ARP);
  // 2 arp 
  struct rte_arp_hdr *arp = (struct rte_arp_hdr *)(eth + 1);
  arp->arp_hardware = htons(1);
  arp->arp_protocol = htons(RTE_ETHER_TYPE_IPV4);
  arp->arp_hlen = RTE_ETHER_ADDR_LEN;
  arp->arp_plen = sizeof(uint32_t);
  arp->arp_opcode = htons(2);
  rte_memcpy(arp->arp_data.arp_sha.addr_bytes, gSrcMac, RTE_ETHER_ADDR_LEN);
  rte_memcpy( arp->arp_data.arp_tha.addr_bytes, dst_mac, RTE_ETHER_ADDR_LEN);
  arp->arp_data.arp_sip = sip;
  arp->arp_data.arp_tip = dip;
  
  return 0;
}
static struct rte_mbuf *ng_send_arp(struct rte_mempool *mbuf_pool, uint8_t *dst_mac, uint32_t sip, uint32_t dip) {
  const unsigned total_length = sizeof(struct rte_ether_hdr) + sizeof(struct rte_arp_hdr);
  struct rte_mbuf *mbuf = rte_pktmbuf_alloc(mbuf_pool);
  if (!mbuf) {
    rte_exit(EXIT_FAILURE, "rte_pktmbuf_alloc\n");
  }
  mbuf->pkt_len = total_length;
  mbuf->data_len = total_length;
  uint8_t *pkt_data = rte_pktmbuf_mtod(mbuf, uint8_t *);
  ng_encode_arp_pkt(pkt_data, dst_mac, sip, dip);
  return mbuf;
}

这里的步骤和UDP一样，作为对ARP协议的实现，后面的arp_table会有详细的实现，这里是回复arp request使得不需要手动添加静态ARP。

完整代码

#if 1
#include <rte_eal.h>
#include <rte_ethdev.h>
#include <stdio.h>
#include <arpa/inet.h>
static int gDpdkPortId = 0;
#define MAKE_IPV4_ADDR(a, b, c, d) (a + (b<<8) + (c<<16) + (d<<24))
static uint32_t gLocalIp = MAKE_IPV4_ADDR(192, 168, 1, 111);
uint32_t gSrcIp;
uint32_t gDstIp;
uint16_t gSrcPort;
uint16_t gDstPort;
uint8_t gSrcMac[RTE_ETHER_ADDR_LEN];
uint8_t gDstMac[RTE_ETHER_ADDR_LEN];
#define MBUF_LEN    (4096-1)
#define BURST_LEN   64
static const struct rte_eth_conf port_conf_default = {
        .rxmode = {.max_rx_pkt_len = RTE_ETHER_MAX_LEN}
};
static void ng_encode_udp_pkt(uint8_t* msg, uint8_t* data, unsigned total_len) {
    struct rte_ether_hdr* ethhdr = (struct rte_ether_hdr*)(msg);
    rte_memcpy(ethhdr->s_addr.addr_bytes, gSrcMac, RTE_ETHER_ADDR_LEN);
    rte_memcpy(ethhdr->d_addr.addr_bytes, gDstMac, RTE_ETHER_ADDR_LEN);
    ethhdr->ether_type = htons(RTE_ETHER_TYPE_IPV4);
    struct rte_ipv4_hdr* iphdr = (struct rte_ipv4_hdr*)(ethhdr + 1);
    iphdr->version_ihl = 0x45;
    iphdr->type_of_service = 0;
    iphdr->total_length = htons(total_len - sizeof(struct rte_ether_hdr));
    iphdr->packet_id = 0;
    iphdr->fragment_offset = 0;
    iphdr->time_to_live = 64;
    iphdr->next_proto_id = IPPROTO_UDP;
    iphdr->src_addr = gSrcIp;
    iphdr->dst_addr = gDstIp;
    iphdr->hdr_checksum = 0;
    iphdr->hdr_checksum = rte_ipv4_cksum(iphdr);
    struct rte_udp_hdr* udphdr = (struct rte_udp_hdr*)(iphdr + 1);
    udphdr->src_port = gSrcPort;
    udphdr->dst_port = gDstPort;
    uint16_t len = total_len - sizeof(struct rte_ether_hdr) - sizeof(struct rte_ipv4_hdr);
    udphdr->dgram_len = htons(len);
    rte_memcpy((uint8_t*)(udphdr + 1), data, len);
    udphdr->dgram_cksum = 0;
    udphdr->dgram_cksum = rte_ipv4_udptcp_cksum(iphdr, udphdr);
    struct in_addr addr;
    addr.s_addr = gSrcIp;
    printf("-->Src: %s:%d ", inet_ntoa(addr), ntohs(gSrcPort));
    addr.s_addr = gDstIp;
    printf("Dst:%s:%d %s\n", inet_ntoa(addr), ntohs(gDstPort), data);
}
static struct rte_mbuf* ng_udp_send(struct rte_mempool* mbuf_pool, uint8_t* data, uint16_t length) {
    struct rte_mbuf* mbuf = rte_pktmbuf_alloc(mbuf_pool);
    if(!mbuf) {
        rte_exit(EXIT_FAILURE, "rte_pktmbuf_alloc\n");
    }
    const unsigned total_len = length + 42;
    mbuf->pkt_len = total_len;
    mbuf->data_len = total_len;
    uint8_t* pkt = rte_pktmbuf_mtod(mbuf, uint8_t*);
    ng_encode_udp_pkt(pkt, data, total_len);
    return mbuf;
}
static int ng_encode_arp_pkt(uint8_t *msg, uint8_t *dst_mac, uint32_t sip, uint32_t dip) {
  // 1 ethhdr
  struct rte_ether_hdr *eth = (struct rte_ether_hdr *)msg;
  rte_memcpy(eth->s_addr.addr_bytes, gSrcMac, RTE_ETHER_ADDR_LEN);
  rte_memcpy(eth->d_addr.addr_bytes, dst_mac, RTE_ETHER_ADDR_LEN);
  eth->ether_type = htons(RTE_ETHER_TYPE_ARP);
  // 2 arp 
  struct rte_arp_hdr *arp = (struct rte_arp_hdr *)(eth + 1);
  arp->arp_hardware = htons(1);
  arp->arp_protocol = htons(RTE_ETHER_TYPE_IPV4);
  arp->arp_hlen = RTE_ETHER_ADDR_LEN;
  arp->arp_plen = sizeof(uint32_t);
  arp->arp_opcode = htons(2);
  rte_memcpy(arp->arp_data.arp_sha.addr_bytes, gSrcMac, RTE_ETHER_ADDR_LEN);
  rte_memcpy( arp->arp_data.arp_tha.addr_bytes, dst_mac, RTE_ETHER_ADDR_LEN);
  arp->arp_data.arp_sip = sip;
  arp->arp_data.arp_tip = dip;
  
  return 0;
}
static struct rte_mbuf *ng_send_arp(struct rte_mempool *mbuf_pool, uint8_t *dst_mac, uint32_t sip, uint32_t dip) {
  const unsigned total_length = sizeof(struct rte_ether_hdr) + sizeof(struct rte_arp_hdr);
  struct rte_mbuf *mbuf = rte_pktmbuf_alloc(mbuf_pool);
  if (!mbuf) {
    rte_exit(EXIT_FAILURE, "rte_pktmbuf_alloc\n");
  }
  mbuf->pkt_len = total_length;
  mbuf->data_len = total_length;
  uint8_t *pkt_data = rte_pktmbuf_mtod(mbuf, uint8_t *);
  ng_encode_arp_pkt(pkt_data, dst_mac, sip, dip);
  return mbuf;
}
static void ng_init_port(struct rte_mempool* mbuf_pool) {
    int dev_sys_ports = rte_eth_dev_count_avail();
    if(dev_sys_ports == 0) {
        rte_exit(EXIT_FAILURE, "Could not support dpdk\n");
    }
    struct rte_eth_dev_info dev_info;
    rte_eth_dev_info_get(gDpdkPortId, &dev_info);
    const int nb_rx_queue = 1;
    const int nb_tx_queue = 1;
    struct rte_eth_conf port_conf = port_conf_default;
    rte_eth_dev_configure(gDpdkPortId, nb_rx_queue, nb_tx_queue, &port_conf);
    if(rte_eth_rx_queue_setup(gDpdkPortId, 0, 1024, rte_eth_dev_socket_id(gDpdkPortId), NULL, mbuf_pool) < 0) {
        rte_exit(EXIT_FAILURE, "Could not setup RX queue\n");
    }
    struct rte_eth_txconf txconf = dev_info.default_txconf;
    txconf.offloads = port_conf_default.rxmode.offloads;
    if(rte_eth_tx_queue_setup(gDpdkPortId, 0, 1024, rte_eth_dev_socket_id(gDpdkPortId), &txconf) < 0) {
        rte_exit(EXIT_FAILURE, "Could not setup TX queue\n");
    }
    if(rte_eth_dev_start(gDpdkPortId) < 0) {
        rte_exit(EXIT_FAILURE, "Could not start\n");
    }
}
int main(int argc, char* argv[]) {
    if(rte_eal_init(argc, argv) < 0) {
        rte_exit(EXIT_FAILURE, "Error with eal init\n");
    }
    
    struct rte_mempool* mbuf_pool = rte_pktmbuf_pool_create("mbuf_pool", MBUF_LEN, 0, 0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id());
    if(!mbuf_pool) {
        rte_exit(EXIT_FAILURE, "Error with mempool create\n");
    }
    ng_init_port(mbuf_pool);
    rte_eth_macaddr_get(gDpdkPortId, (struct rte_ether_addr*)gSrcMac);
    //printf("local mac: %s\n", gSrcMac);
    while (1)
    {
        struct rte_mbuf* mbufs[BURST_LEN];
        unsigned nb_pkt = rte_eth_rx_burst(gDpdkPortId, 0, mbufs, BURST_LEN);
        if (nb_pkt > BURST_LEN) {
      rte_exit(EXIT_FAILURE, "Error receiving from eth\n");
    }
        for(size_t i = 0; i < nb_pkt; i++) {
            struct rte_ether_hdr* ethhdr = rte_pktmbuf_mtod(mbufs[i], struct rte_ether_hdr*);
            if(ethhdr->ether_type == rte_cpu_to_be_16(RTE_ETHER_TYPE_ARP)) {
                struct rte_arp_hdr* arphdr = rte_pktmbuf_mtod_offset(mbufs[i], struct rte_arp_hdr*, sizeof(struct rte_ether_hdr));
                struct in_addr addr;
                addr.s_addr = arphdr->arp_data.arp_tip;
                printf("arp --> src: %s ", inet_ntoa(addr));
                addr.s_addr = gLocalIp;
                printf("local: %s\n", inet_ntoa(addr));
                if(arphdr->arp_data.arp_tip == gLocalIp) {
                    struct rte_mbuf* arpbuf = ng_send_arp(mbuf_pool, arphdr->arp_data.arp_sha.addr_bytes, gLocalIp, arphdr->arp_data.arp_sip);
                    rte_eth_tx_burst(gDpdkPortId, 0, &arpbuf, 1);
                    rte_pktmbuf_free(arpbuf);
                    rte_pktmbuf_free(mbufs[i]);
                    arpbuf = NULL;
                    mbufs[i] = NULL;
                }
                continue;
            }
            if(ethhdr->ether_type != rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4)) {
                rte_pktmbuf_free(mbufs[i]);
                mbufs[i] = NULL;
                continue;
            }
            struct rte_ipv4_hdr* iphdr = rte_pktmbuf_mtod_offset(mbufs[i], struct rte_ipv4_hdr*, sizeof(struct rte_ether_hdr));
            if(iphdr->next_proto_id == IPPROTO_UDP) {
                struct rte_udp_hdr* udphdr = (struct rte_udp_hdr*)(iphdr + 1);
               // rte_memcpy(gSrcMac, ethhdr->d_addr.addr_bytes, RTE_ETHER_ADDR_LEN);
                rte_memcpy(gDstMac, ethhdr->s_addr.addr_bytes, RTE_ETHER_ADDR_LEN);
                rte_memcpy(&gDstIp, &iphdr->src_addr, sizeof(uint32_t));
                rte_memcpy(&gSrcIp, &iphdr->dst_addr, sizeof(uint32_t));
                rte_memcpy(&gSrcPort, &udphdr->dst_port, sizeof(uint16_t));
                rte_memcpy(&gDstPort, &udphdr->src_port, sizeof(uint16_t));
                uint16_t data_len = ntohs(udphdr->dgram_len);
                *((char*)udphdr + data_len) = '\0';
                struct in_addr addr;
                addr.s_addr = iphdr->src_addr;
                printf("<--Src: %s:%d ", inet_ntoa(addr), htons(udphdr->src_port));
                addr.s_addr = iphdr->dst_addr;
                printf("Dst: %s:%d %s\n", inet_ntoa(addr), htons(udphdr->dst_port), (char*)(udphdr+1));
                struct rte_mbuf* txbuf = ng_udp_send(mbuf_pool, (uint8_t*)(udphdr + 1), data_len);
                rte_eth_tx_burst(gDpdkPortId, 0, &txbuf, 1);
                rte_pktmbuf_free(txbuf);
                rte_pktmbuf_free(mbufs[i]);
                mbufs[i] = NULL;
                txbuf = NULL;
            }
        }
    }
    
}
#endif


文章标签：
云解析DNS
混合云容灾服务
网络协议
缓存
关键词：
协议栈ARP
小狮子安度因1
目录
相关文章
bruce_xiaowei
|
18天前
|
缓存 网络协议 Linux
Python渗透测试之ARP毒化和协议应用
Python渗透测试之ARP毒化和协议应用
bruce_xiaowei
19 0
小狮子安度因1
|
2月前
|
网络协议
用户态协议栈04-定时arp-table的实现
用户态协议栈04-定时arp-table的实现
小狮子安度因1
26 3
wljslmz
|
2月前
|
网络协议 安全 网络安全
ARP协议详解及其工作原理
【8月更文挑战第31天】
wljslmz
77 0
wljslmz
|
2月前
|
存储 缓存 监控
ARP 协议详解：类型、工作原理和消息格式
【8月更文挑战第20天】
wljslmz
256 0
蓝易云
|
2月前
|
存储 缓存 网络协议
MAC协议原理与ARP协议
总结一下，MAC协议是控制同一网络媒介上多个设备的数据访问的规范，而ARP是解决局域网络中的IP地址到MAC地址的转换问题，以确保IP包能在本地网络上传输到正确的设备。尽管这两种协议服务于网络通信中的不同层面，但它们都是网络正常操作的基本要素，保证了数据能从一个设备准确无误地传递到另一个设备。
蓝易云
35 0
香吧香
|
3月前
|
存储 缓存 网络协议
ARP 地址解析协议
ARP 地址解析协议
香吧香
59 0
欢喜躲在眉梢里
|
3月前
|
人工智能 缓存 网络协议
网络层之三层交换、icmp协议、arp协议
网络层之三层交换、icmp协议、arp协议
欢喜躲在眉梢里
61 0
西瓜味的敌敌畏
|
4月前
|
存储 缓存 网络协议
ARP 协议
ARP 协议
西瓜味的敌敌畏
74 0
玉米侠爱吃玉米
|
5月前
|
网络协议 Linux 网络架构
arp协议 与网关
arp协议 与网关
玉米侠爱吃玉米
67 0
爱吃糖的范同学
|
5月前
|
缓存 网络协议 安全
【网络工程师】＜软考中级＞解析协议ARP&路由协议RIP/OSPF/BGP
【1月更文挑战第27天】【网络工程师】＜软考中级＞解析协议ARP&路由协议RIP/OSPF/BGP
爱吃糖的范同学
218 2

热门文章

最新文章

  • 1
    arp 攻击&欺骗
  • 2
    普通ARP和免费ARP及arping命令的使用
  • 3
    公司交换机arp 绑定操作
  • 4
    还在讨论ARP攻击吗？你OUT了
  • 5
    ARP解析MAC地址的全过程（ARP的工作机制）
  • 6
    协议森林03 IP接力赛 (IP, ARP, RIP和BGP协议)
  • 7
    实战分析ARP***与欺骗
  • 8
    HA高可用的arp问题及ARP企业级故障案例介绍
  • 9
    Linux下防御arp攻击的方法
  • 10
    ARP攻击故障解析
  • 1
    使用 Wireshark 实现 ARP 嗅探监听网络
    165
  • 2
    使用 eNSP 模拟交换机防御 ARP 泛洪
    213
  • 3
    使用 Scapy 库编写 ARP 缓存中毒脚本
    87
  • 4
    基于 Wireshark 分析 ARP 协议
    242
  • 5
    CCNA 200-301系列：地址解析协议(ARP)
    53
  • 6
    【计算机网络】第三章 数据链路层（MAC地址 IP地址 ARP协议）
    106
  • 7
    【Shell 命令集合 网络通讯 】Linux 监控和记录网络中ARP（Address Resolution Protocol）活动 arpwatch命令 使用指南
    137
  • 8
    详细解析以太网帧、ARP数据报、IP数据报、UDP数据报和TCP数据报的协议格式
    598
  • 9
    计算机网络：思科实验【2-MAC地址、IP地址、ARP协议及总线型以太网的特性】
    227
  • 10
    计算机网络-数据链路层：以太网协议、ARP协议、MAC、MTU
    186

    • 相关课程

    更多
  • TCP/IP 网络基础
  • Linux网络进阶 - TCP/IP协议及OSI七层模型

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    AI助理直击要害，从繁复中提炼精华——使用CDN加速访问OSS存储的图片